refactor: 统一项目名称从OpenFang到ZCLAW

重构所有代码和文档中的项目名称，将OpenFang统一更新为ZCLAW。包括：
- 配置文件中的项目名称
- 代码注释和文档引用
- 环境变量和路径
- 类型定义和接口名称
- 测试用例和模拟数据

同时优化部分代码结构，移除未使用的模块，并更新相关依赖项。

desktop/E2E_TEST_REPORT.md

@@ -2,7 +2,7 @@
 
 **测试日期**: 2026-03-13
 **测试环境**: Windows 11 Pro, Chrome DevTools MCP
-**测试范围**: 前端 UI 组件、OpenFang 集成、设置页面
+**测试范围**: 前端 UI 组件、ZCLAW 集成、设置页面
 
 ---
 
@@ -12,7 +12,7 @@
 |---------|------|------|------|
 | 前端页面加载 | 5 | 0 | 5 |
 | 设置页面功能 | 6 | 0 | 6 |
-| OpenFang UI 组件 | 5 | 0 | 5 |
+| ZCLAW UI 组件 | 5 | 0 | 5 |
 | TypeScript 编译 | 1 | 0 | 1 |
 | **总计** | **17** | **0** | **17** |
 
@@ -51,12 +51,12 @@
 #### 2.1 后端设置 UI ✓
 - **状态**: 通过
 - **验证项**:
-  - Gateway 类型选择器 (OpenClaw/OpenFang) 正常工作
-  - 切换到 OpenFang 时：
+  - Gateway 类型选择器 (OpenClaw/ZCLAW) 正常工作
+  - 切换到 ZCLAW 时：
     - 默认端口显示 4200
     - 协议显示 "WebSocket + REST API"
     - 配置格式显示 "TOML"
-    - 显示 OpenFang 特有功能提示
+    - 显示 ZCLAW 特有功能提示
   - 切换到 OpenClaw 时：
     - 默认端口显示 18789
     - 协议显示 "WebSocket RPC"
@@ -105,7 +105,7 @@
 
 ---
 
-### 3. OpenFang UI 组件测试
+### 3. ZCLAW UI 组件测试
 
 #### 3.1 Hands 面板 ✓
 - **状态**: 通过
@@ -159,9 +159,9 @@
 
 ### 新增功能
 1. **后端设置 UI** (`General.tsx`)
-   - 添加 OpenClaw/OpenFang 后端类型选择器
+   - 添加 OpenClaw/ZCLAW 后端类型选择器
    - 显示后端特性信息（端口、协议、配置格式）
-   - OpenFang 特有功能提示
+   - ZCLAW 特有功能提示
 
 2. **TypeScript 类型修复**
    - `gatewayStore.ts`: 添加 `Hand.currentRunId` 和 `cancelWorkflow`
@@ -193,7 +193,7 @@ Node.js: v20.x
    - CLI 检测功能
    - 服务注册功能
 
-2. **连接真实 OpenFang 后测试**
+2. **连接真实 ZCLAW 后测试**
    - Hands 触发和审批流程
    - Workflow 执行
    - 审计日志获取
@@ -208,7 +208,7 @@ Node.js: v20.x
 
 ## 结论
 
-本次 E2E 测试覆盖了 ZCLAW Desktop 的主要前端功能，所有测试项目均通过。OpenFang 相关 UI 组件已正确集成并显示，后端类型切换功能正常工作。
+本次 E2E 测试覆盖了 ZCLAW Desktop 的主要前端功能，所有测试项目均通过。ZCLAW 相关 UI 组件已正确集成并显示，后端类型切换功能正常工作。
 
 **测试状态**: ✅ 全部通过
 
@@ -216,12 +216,12 @@ Node.js: v20.x
 
 ## 5. WebSocket 流式聊天测试 (2026-03-14)
 
-### 5.1 OpenFang 协议发现 ✅
+### 5.1 ZCLAW 协议发现 ✅
 
 **测试方法:** 直接 WebSocket 连接到 `ws://127.0.0.1:50051/api/agents/{agentId}/ws`
 
 **发现:**
-- OpenFang 实际使用的消息格式与文档不同
+- ZCLAW 实际使用的消息格式与文档不同
 - 正确的消息格式: `{ type: 'message', content, session_id }`
 - 错误的文档格式: `{ type: 'chat', message: { role, content } }`
 
@@ -258,7 +258,7 @@ Node.js: v20.x
 **修复内容:**
 1. `gateway-client.ts`:
    - 更新 `chatStream()` 使用正确的消息格式
-   - 更新 `handleOpenFangStreamEvent()` 处理实际的事件类型
+   - 更新 `handleZCLAWStreamEvent()` 处理实际的事件类型
    - 添加 `setDefaultAgentId()` 和 `getDefaultAgentId()` 方法
 
 2. `chatStore.ts`:
@@ -309,7 +309,7 @@ curl -X POST http://127.0.0.1:50051/api/agents/{id}/message \
 
 | 测试项 | 状态 | 详情 |
 |--------|------|------|
-| OpenFang 健康检查 | ✅ PASS | 版本 0.4.0 |
+| ZCLAW 健康检查 | ✅ PASS | 版本 0.4.0 |
 | Agent 列表 | ✅ PASS | 10 个 Agent |
 | Hands 列表 | ✅ PASS | 8 个 Hands |
 | WebSocket 流式聊天 | ✅ PASS | 正确接收 text_delta 事件 |
@@ -342,7 +342,7 @@ ws.send(JSON.stringify({
 |------|------|------|
 | Tauri Desktop | - | ✅ 运行中 (PID 72760) |
 | Vite Dev Server | 1420 | ✅ 运行中 |
-| OpenFang Backend | 50051 | ✅ 运行中 (v0.4.0) |
+| ZCLAW Backend | 50051 | ✅ 运行中 (v0.4.0) |
 
 ### 7.4 前端功能待验证
 

desktop/NEXT_SESSION_PROMPT.md

@@ -4,8 +4,8 @@
 
 ### 已完成的工作 (2026-03-14)
 
-1. **OpenFang 连接适配** ✅
-   - ZCLAW Desktop 已成功连接 OpenFang (端口 50051)
+1. **ZCLAW 连接适配** ✅
+   - ZCLAW Desktop 已成功连接 ZCLAW (端口 50051)
    - 对话功能测试通过，AI 响应正常
 
 2. **WebSocket 流式聊天** ✅ (新完成)
@@ -27,9 +27,9 @@
 | `gatewayStore.ts` | loadClones 自动设置默认 Agent |
 | `vite.config.ts` | 启用 WebSocket 代理 |
 
-### OpenFang vs OpenClaw 协议差异
+### ZCLAW vs OpenClaw 协议差异
 
-| 方面 | OpenClaw | OpenFang |
+| 方面 | OpenClaw | ZCLAW |
 |------|----------|----------|
 | 端口 | 18789 | **50051** |
 | 聊天 API | `/api/chat` | `/api/agents/{id}/message` |
@@ -38,7 +38,7 @@
 
 ### 运行环境
 
-- **OpenFang**: `~/.openfang/` (config.toml, .env)
+- **ZCLAW**: `~/.zclaw/` (config.toml, .env)
 - **OpenClaw**: `~/.openclaw/` (openclaw.json, devices/)
 - **ZCLAW 前端**: `http://localhost:1420` (Vite)
 - **默认 Agent**: 动态获取第一个可用 Agent
@@ -46,7 +46,7 @@
 ### localStorage 配置
 
 ```javascript
-localStorage.setItem('zclaw-backend', 'openfang');
+localStorage.setItem('zclaw-backend', 'zclaw');
 localStorage.setItem('zclaw_gateway_url', 'ws://127.0.0.1:50051/ws');
 ```
 
@@ -62,23 +62,23 @@ localStorage.setItem('zclaw_gateway_url', 'ws://127.0.0.1:50051/ws');
 
 ### 优先级 P2 - 优化
 
-4. **后端切换优化** - 代理配置应动态切换 (OpenClaw: 18789, OpenFang: 50051)
+4. **后端切换优化** - 代理配置应动态切换 (OpenClaw: 18789, ZCLAW: 50051)
 5. **错误处理** - 更友好的错误提示
-6. **连接状态显示** - 显示 OpenFang 版本号
+6. **连接状态显示** - 显示 ZCLAW 版本号
 
 ---
 
 ## 快速启动命令
 
 ```bash
-# 启动 OpenFang
-cd "desktop/src-tauri/resources/openfang-runtime" && ./openfang.exe start
+# 启动 ZCLAW
+cd "desktop/src-tauri/resources/zclaw-runtime" && ./zclaw.exe start
 
 # 启动 Vite 开发服务器
 cd desktop && pnpm dev
 
-# 检查 OpenFang 状态
-./openfang.exe status
+# 检查 ZCLAW 状态
+./zclaw.exe status
 
 # 测试 API
 curl http://127.0.0.1:50051/api/health
@@ -96,7 +96,7 @@ curl http://127.0.0.1:50051/api/agents
 | `desktop/src/store/chatStore.ts` | 聊天状态管理 |
 | `desktop/src/components/Settings/General.tsx` | 后端切换设置 |
 | `desktop/vite.config.ts` | Vite 代理配置 |
-| `docs/openfang-technical-reference.md` | OpenFang 技术文档 |
+| `docs/zclaw-technical-reference.md` | ZCLAW 技术文档 |
 
 ---
 
@@ -106,7 +106,7 @@ curl http://127.0.0.1:50051/api/agents
 请继续 ZCLAW Desktop 的开发工作。
 
 当前状态：
-- OpenFang REST API 聊天已可用 ✅
+- ZCLAW REST API 聊天已可用 ✅
 - WebSocket 流式聊天已实现 ✅
 - 动态 Agent 选择已实现 ✅
 

desktop/TEST_REPORT.md

@@ -1,4 +1,4 @@
-# ZClaw OpenFang 系统功能测试报告
+# ZClaw ZCLAW 系统功能测试报告
 
 > 测试日期: 2026-03-13
 > 测试环境: Windows 11 Pro, Node.js v20+, pnpm 10+
@@ -38,11 +38,11 @@ Duration    1.29s
 | gatewayStore.test.ts | 17 | ✅ |
 | general-settings.test.tsx | 1 | ✅ |
 | ws-client.test.ts | 12 | ✅ |
-| openfang-api.test.ts | 34 | ✅ |
+| zclaw-api.test.ts | 34 | ✅ |
 
 ### 2.2 集成测试覆盖
 
-OpenFang API 集成测试覆盖以下模块：
+ZCLAW API 集成测试覆盖以下模块：
 
 | 模块 | 测试数 | 覆盖功能 |
 |------|-------|---------|
@@ -73,27 +73,27 @@ Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.60s
 
 | 命令 | 功能 | 状态 |
 |------|------|------|
-| `openfang_status` | 获取 OpenFang 状态 | ✅ |
-| `openfang_start` | 启动 OpenFang | ✅ |
-| `openfang_stop` | 停止 OpenFang | ✅ |
-| `openfang_restart` | 重启 OpenFang | ✅ |
-| `openfang_local_auth` | 获取本地认证 | ✅ |
-| `openfang_prepare_for_tauri` | 准备 Tauri 环境 | ✅ |
-| `openfang_approve_device_pairing` | 设备配对审批 | ✅ |
-| `openfang_doctor` | 诊断检查 | ✅ |
-| `openfang_process_list` | 进程列表 | ✅ |
-| `openfang_process_logs` | 进程日志 | ✅ |
-| `openfang_version` | 版本信息 | ✅ |
+| `zclaw_status` | 获取 ZCLAW 状态 | ✅ |
+| `zclaw_start` | 启动 ZCLAW | ✅ |
+| `zclaw_stop` | 停止 ZCLAW | ✅ |
+| `zclaw_restart` | 重启 ZCLAW | ✅ |
+| `zclaw_local_auth` | 获取本地认证 | ✅ |
+| `zclaw_prepare_for_tauri` | 准备 Tauri 环境 | ✅ |
+| `zclaw_approve_device_pairing` | 设备配对审批 | ✅ |
+| `zclaw_doctor` | 诊断检查 | ✅ |
+| `zclaw_process_list` | 进程列表 | ✅ |
+| `zclaw_process_logs` | 进程日志 | ✅ |
+| `zclaw_version` | 版本信息 | ✅ |
 
 ### 3.3 向后兼容别名
 
-所有 `gateway_*` 命令已正确映射到 `openfang_*` 命令。
+所有 `gateway_*` 命令已正确映射到 `zclaw_*` 命令。
 
 ---
 
 ## 4. 前端组件验证
 
-### 4.1 OpenFang 特性组件
+### 4.1 ZCLAW 特性组件
 
 | 组件 | 文件 | 状态 | 功能 |
 |------|------|------|------|
@@ -105,7 +105,7 @@ Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.60s
 
 ### 4.2 RightPanel 集成
 
-所有 OpenFang 组件已正确集成到 `RightPanel.tsx`:
+所有 ZCLAW 组件已正确集成到 `RightPanel.tsx`:
 - ✅ SecurityStatus 已渲染
 - ✅ HandsPanel 已渲染
 - ✅ TriggersPanel 已渲染
@@ -115,7 +115,7 @@ Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.60s
 
 ## 5. 状态管理验证
 
-### 5.1 gatewayStore OpenFang 方法
+### 5.1 gatewayStore ZCLAW 方法
 
 | 方法 | 功能 | 状态 |
 |------|------|------|
@@ -132,7 +132,7 @@ Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.60s
 
 ### 5.2 连接后自动加载
 
-`connect()` 成功后自动加载 OpenFang 数据:
+`connect()` 成功后自动加载 ZCLAW 数据:
 - ✅ `loadHands()`
 - ✅ `loadWorkflows()`
 - ✅ `loadTriggers()`
@@ -181,7 +181,7 @@ Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.60s
 
 | 脚本 | 功能 | 状态 |
 |------|------|------|
-| `prepare-openfang-runtime.mjs` | 下载 OpenFang 二进制 | ✅ |
+| `prepare-zclaw-runtime.mjs` | 下载 ZCLAW 二进制 | ✅ |
 | `preseed-tauri-tools.mjs` | 预置 Tauri 工具 | ✅ |
 | `tauri-build-bundled.mjs` | 打包构建 | ✅ |
 
@@ -193,7 +193,7 @@ Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.60s
 | WebSocket 路径 | `/ws` | ✅ |
 | REST API 前缀 | `/api` | ✅ |
 | 配置格式 | TOML | ✅ |
-| 配置目录 | `~/.openfang/` | ✅ |
+| 配置目录 | `~/.zclaw/` | ✅ |
 
 ---
 
@@ -203,8 +203,8 @@ Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.60s
 
 | 问题 | 文件 | 修复 |
 |------|------|------|
-| 集成测试握手超时 | `openfang-api.test.ts` | 改为纯 REST API 测试 |
-| 构建脚本引用旧运行时 | `tauri-build-bundled.mjs` | 更新为 `prepare-openfang-runtime.mjs` |
+| 集成测试握手超时 | `zclaw-api.test.ts` | 改为纯 REST API 测试 |
+| 构建脚本引用旧运行时 | `tauri-build-bundled.mjs` | 更新为 `prepare-zclaw-runtime.mjs` |
 | Rust 临时变量生命周期 | `lib.rs` | 使用 owned strings |
 
 ### 8.2 无已知问题
@@ -231,13 +231,13 @@ Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.60s
 
 ## 10. 结论
 
-**ZClaw OpenFang 迁移项目 Phase 1-7 功能测试通过。**
+**ZClaw ZCLAW 迁移项目 Phase 1-7 功能测试通过。**
 
 - ✅ 前端构建成功
 - ✅ Tauri 后端编译成功
 - ✅ 75 个单元测试全部通过
-- ✅ 所有 OpenFang 特性组件已集成
+- ✅ 所有 ZCLAW 特性组件已集成
 - ✅ 所有 Tauri 命令已实现
 - ✅ 中文模型插件支持 7 个提供商
 
-系统功能完整，可用于下一阶段的真实 OpenFang 集成测试。
+系统功能完整，可用于下一阶段的真实 ZCLAW 集成测试。

desktop/package.json

@@ -9,18 +9,18 @@
     "preview": "vite preview",
     "prepare:openclaw-runtime": "node scripts/prepare-openclaw-runtime.mjs",
     "prepare:openclaw-runtime:dry-run": "node scripts/prepare-openclaw-runtime.mjs --dry-run",
-    "prepare:openfang-runtime": "node scripts/prepare-openfang-runtime.mjs",
-    "prepare:openfang-runtime:dry-run": "node scripts/prepare-openfang-runtime.mjs --dry-run",
+    "prepare:zclaw-runtime": "node scripts/prepare-zclaw-runtime.mjs",
+    "prepare:zclaw-runtime:dry-run": "node scripts/prepare-zclaw-runtime.mjs --dry-run",
     "prepare:tauri-tools": "node scripts/preseed-tauri-tools.mjs",
     "prepare:tauri-tools:dry-run": "node scripts/preseed-tauri-tools.mjs --dry-run",
     "tauri": "tauri",
     "tauri:dev": "tauri dev",
     "tauri:dev:web": "tauri dev --features dev-server",
     "tauri:build": "tauri build",
-    "tauri:build:bundled": "pnpm prepare:openfang-runtime && node scripts/tauri-build-bundled.mjs",
-    "tauri:build:bundled:debug": "pnpm prepare:openfang-runtime && node scripts/tauri-build-bundled.mjs --debug",
-    "tauri:build:nsis:debug": "pnpm prepare:openfang-runtime && node scripts/tauri-build-bundled.mjs --debug --bundles nsis",
-    "tauri:build:msi:debug": "pnpm prepare:openfang-runtime && node scripts/tauri-build-bundled.mjs --debug --bundles msi",
+    "tauri:build:bundled": "pnpm prepare:zclaw-runtime && node scripts/tauri-build-bundled.mjs",
+    "tauri:build:bundled:debug": "pnpm prepare:zclaw-runtime && node scripts/tauri-build-bundled.mjs --debug",
+    "tauri:build:nsis:debug": "pnpm prepare:zclaw-runtime && node scripts/tauri-build-bundled.mjs --debug --bundles nsis",
+    "tauri:build:msi:debug": "pnpm prepare:zclaw-runtime && node scripts/tauri-build-bundled.mjs --debug --bundles msi",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",

desktop/scripts/download-zclaw.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
- * OpenFang Binary Downloader
- * Automatically downloads the correct OpenFang binary for the current platform
+ * ZCLAW Binary Downloader
+ * Automatically downloads the correct ZCLAW binary for the current platform
  * Run during Tauri build process
  */
 
@@ -12,11 +12,11 @@ import { fileURLToPath } from 'url';
 import { platform, arch } from 'os';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const RESOURCES_DIR = join(__dirname, '../src-tauri/resources/openfang-runtime');
+const RESOURCES_DIR = join(__dirname, '../src-tauri/resources/zclaw-runtime');
 
-// OpenFang release info
-const OPENFANG_REPO = 'RightNow-AI/openfang';
-const OPENFANG_VERSION = process.env.OPENFANG_VERSION || 'latest';
+// ZCLAW release info
+const ZCLAW_REPO = 'RightNow-AI/zclaw';
+const ZCLAW_VERSION = process.env.ZCLAW_VERSION || 'latest';
 
 interface PlatformConfig {
   binaryName: string;
@@ -30,28 +30,28 @@ function getPlatformConfig(): PlatformConfig {
   switch (currentPlatform) {
     case 'win32':
       return {
-        binaryName: 'openfang.exe',
+        binaryName: 'zclaw.exe',
         downloadName: currentArch === 'x64'
-          ? 'openfang-x86_64-pc-windows-msvc.exe'
-          : 'openfang-aarch64-pc-windows-msvc.exe',
+          ? 'zclaw-x86_64-pc-windows-msvc.exe'
+          : 'zclaw-aarch64-pc-windows-msvc.exe',
       };
     case 'darwin':
       return {
         binaryName: currentArch === 'arm64'
-          ? 'openfang-aarch64-apple-darwin'
-          : 'openfang-x86_64-apple-darwin',
+          ? 'zclaw-aarch64-apple-darwin'
+          : 'zclaw-x86_64-apple-darwin',
         downloadName: currentArch === 'arm64'
-          ? 'openfang-aarch64-apple-darwin'
-          : 'openfang-x86_64-apple-darwin',
+          ? 'zclaw-aarch64-apple-darwin'
+          : 'zclaw-x86_64-apple-darwin',
       };
     case 'linux':
       return {
         binaryName: currentArch === 'arm64'
-          ? 'openfang-aarch64-unknown-linux-gnu'
-          : 'openfang-x86_64-unknown-linux-gnu',
+          ? 'zclaw-aarch64-unknown-linux-gnu'
+          : 'zclaw-x86_64-unknown-linux-gnu',
         downloadName: currentArch === 'arm64'
-          ? 'openfang-aarch64-unknown-linux-gnu'
-          : 'openfang-x86_64-unknown-linux-gnu',
+          ? 'zclaw-aarch64-unknown-linux-gnu'
+          : 'zclaw-x86_64-unknown-linux-gnu',
       };
     default:
       throw new Error(`Unsupported platform: ${currentPlatform}`);
@@ -60,19 +60,19 @@ function getPlatformConfig(): PlatformConfig {
 
 function downloadBinary(): void {
   const config = getPlatformConfig();
-  const baseUrl = `https://github.com/${OPENFANG_REPO}/releases`;
-  const downloadUrl = OPENFANG_VERSION === 'latest'
+  const baseUrl = `https://github.com/${ZCLAW_REPO}/releases`;
+  const downloadUrl = ZCLAW_VERSION === 'latest'
     ? `${baseUrl}/latest/download/${config.downloadName}`
-    : `${baseUrl}/download/${OPENFANG_VERSION}/${config.downloadName}`;
+    : `${baseUrl}/download/${ZCLAW_VERSION}/${config.downloadName}`;
 
   const outputPath = join(RESOURCES_DIR, config.binaryName);
 
   console.log('='.repeat(60));
-  console.log('OpenFang Binary Downloader');
+  console.log('ZCLAW Binary Downloader');
   console.log('='.repeat(60));
   console.log(`Platform: ${platform()} (${arch()})`);
   console.log(`Binary: ${config.binaryName}`);
-  console.log(`Version: ${OPENFANG_VERSION}`);
+  console.log(`Version: ${ZCLAW_VERSION}`);
   console.log(`URL: ${downloadUrl}`);
   console.log('='.repeat(60));
 
@@ -83,7 +83,7 @@ function downloadBinary(): void {
 
   // Check if already downloaded
   if (existsSync(outputPath)) {
-    console.log('✓ Binary already exists, skipping download.');
+    console.log('Binary already exists, skipping download.');
     return;
   }
 
@@ -113,11 +113,11 @@ function downloadBinary(): void {
       execSync(`chmod +x "${outputPath}"`);
     }
 
-    console.log('✓ Download complete!');
+    console.log('Download complete!');
   } catch (error) {
-    console.error('✗ Download failed:', error);
+    console.error('Download failed:', error);
     console.log('\nPlease download manually from:');
-    console.log(`  ${baseUrl}/${OPENFANG_VERSION === 'latest' ? 'latest' : 'tag/' + OPENFANG_VERSION}`);
+    console.log(`  ${baseUrl}/${ZCLAW_VERSION === 'latest' ? 'latest' : 'tag/' + ZCLAW_VERSION}`);
     process.exit(1);
   }
 }
@@ -127,12 +127,12 @@ function updateManifest(): void {
 
   const manifest = {
     source: {
-      binPath: platform() === 'win32' ? 'openfang.exe' : `openfang-${arch()}-${platform()}`,
+      binPath: platform() === 'win32' ? 'zclaw.exe' : `zclaw-${arch()}-${platform()}`,
     },
     stagedAt: new Date().toISOString(),
-    version: OPENFANG_VERSION === 'latest' ? new Date().toISOString().split('T')[0].replace(/-/g, '.') : OPENFANG_VERSION,
-    runtimeType: 'openfang',
-    description: 'OpenFang Agent OS - Single binary runtime (~32MB)',
+    version: ZCLAW_VERSION === 'latest' ? new Date().toISOString().split('T')[0].replace(/-/g, '.') : ZCLAW_VERSION,
+    runtimeType: 'zclaw',
+    description: 'ZCLAW Agent OS - Single binary runtime (~32MB)',
     endpoints: {
       websocket: 'ws://127.0.0.1:4200/ws',
       rest: 'http://127.0.0.1:4200/api',
@@ -140,11 +140,11 @@ function updateManifest(): void {
   };
 
   writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-  console.log('✓ Manifest updated');
+  console.log('Manifest updated');
 }
 
 // Run
 downloadBinary();
 updateManifest();
 
-console.log('\n✓ OpenFang runtime ready for build!');
+console.log('\nZCLAW runtime ready for build!');

desktop/scripts/prepare-openclaw-runtime.mjs

@@ -1,167 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const desktopRoot = path.resolve(__dirname, '..');
-const outputDir = path.join(desktopRoot, 'src-tauri', 'resources', 'openclaw-runtime');
-const dryRun = process.argv.includes('--dry-run');
-
-function log(message) {
-  console.log(`[prepare-openclaw-runtime] ${message}`);
-}
-
-function readFirstExistingPath(commandNames) {
-  for (const commandName of commandNames) {
-    try {
-      const stdout = execFileSync('where.exe', [commandName], {
-        encoding: 'utf8',
-        stdio: ['ignore', 'pipe', 'ignore'],
-      });
-      const firstMatch = stdout
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .find(Boolean);
-      if (firstMatch) {
-        return firstMatch;
-      }
-    } catch {
-      continue;
-    }
-  }
-
-  return null;
-}
-
-function ensureFileExists(filePath, label) {
-  if (!filePath || !fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
-    throw new Error(`${label} 不存在：${filePath || '(empty)'}`);
-  }
-}
-
-function ensureDirExists(dirPath, label) {
-  if (!dirPath || !fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) {
-    throw new Error(`${label} 不存在：${dirPath || '(empty)'}`);
-  }
-}
-
-function resolveOpenClawBin() {
-  const override = process.env.OPENCLAW_BIN;
-  if (override) {
-    return path.resolve(override);
-  }
-
-  const resolved = readFirstExistingPath(['openclaw.cmd', 'openclaw']);
-  if (!resolved) {
-    throw new Error('未找到 openclaw 入口。请先安装 OpenClaw，或设置 OPENCLAW_BIN。');
-  }
-
-  return resolved;
-}
-
-function resolvePackageDir(openclawBinPath) {
-  const override = process.env.OPENCLAW_PACKAGE_DIR;
-  if (override) {
-    return path.resolve(override);
-  }
-
-  return path.join(path.dirname(openclawBinPath), 'node_modules', 'openclaw');
-}
-
-function resolveNodeExe(openclawBinPath) {
-  const override = process.env.OPENCLAW_NODE_EXE;
-  if (override) {
-    return path.resolve(override);
-  }
-
-  const bundledNode = path.join(path.dirname(openclawBinPath), 'node.exe');
-  if (fs.existsSync(bundledNode)) {
-    return bundledNode;
-  }
-
-  const resolved = readFirstExistingPath(['node.exe', 'node']);
-  if (!resolved) {
-    throw new Error('未找到 node.exe。请先安装 Node.js，或设置 OPENCLAW_NODE_EXE。');
-  }
-
-  return resolved;
-}
-
-function cleanOutputDirectory(dirPath) {
-  if (!fs.existsSync(dirPath)) {
-    return;
-  }
-
-  for (const entry of fs.readdirSync(dirPath)) {
-    fs.rmSync(path.join(dirPath, entry), { recursive: true, force: true });
-  }
-}
-
-function writeCmdLauncher(dirPath) {
-  const launcher = [
-    '@ECHO off',
-    'SETLOCAL',
-    'SET "_prog=%~dp0\\node.exe"',
-    '"%_prog%" "%~dp0\\node_modules\\openclaw\\openclaw.mjs" %*',
-    '',
-  ].join('\r\n');
-
-  fs.writeFileSync(path.join(dirPath, 'openclaw.cmd'), launcher, 'utf8');
-}
-
-function stageRuntime() {
-  const openclawBinPath = resolveOpenClawBin();
-  const packageDir = resolvePackageDir(openclawBinPath);
-  const nodeExePath = resolveNodeExe(openclawBinPath);
-  const packageJsonPath = path.join(packageDir, 'package.json');
-  const entryPath = path.join(packageDir, 'openclaw.mjs');
-
-  ensureFileExists(openclawBinPath, 'OpenClaw 入口');
-  ensureDirExists(packageDir, 'OpenClaw 包目录');
-  ensureFileExists(packageJsonPath, 'OpenClaw package.json');
-  ensureFileExists(entryPath, 'OpenClaw 入口脚本');
-  ensureFileExists(nodeExePath, 'Node.js 可执行文件');
-
-  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-  const destinationPackageDir = path.join(outputDir, 'node_modules', 'openclaw');
-  const manifest = {
-    source: {
-      openclawBinPath,
-      packageDir,
-      nodeExePath,
-    },
-    stagedAt: new Date().toISOString(),
-    version: packageJson.version ?? null,
-  };
-
-  log(`OpenClaw version: ${packageJson.version || 'unknown'}`);
-  log(`Source bin: ${openclawBinPath}`);
-  log(`Source package: ${packageDir}`);
-  log(`Source node.exe: ${nodeExePath}`);
-  log(`Target dir: ${outputDir}`);
-
-  if (dryRun) {
-    log('Dry run 完成，未写入任何文件。');
-    return;
-  }
-
-  fs.mkdirSync(outputDir, { recursive: true });
-  cleanOutputDirectory(outputDir);
-  fs.mkdirSync(path.join(outputDir, 'node_modules'), { recursive: true });
-  fs.copyFileSync(nodeExePath, path.join(outputDir, 'node.exe'));
-  fs.cpSync(packageDir, destinationPackageDir, { recursive: true, force: true });
-  writeCmdLauncher(outputDir);
-  fs.writeFileSync(path.join(outputDir, 'runtime-manifest.json'), JSON.stringify(manifest, null, 2), 'utf8');
-
-  log('OpenClaw runtime 已写入 src-tauri/resources/openclaw-runtime');
-}
-
-try {
-  stageRuntime();
-} catch (error) {
-  const message = error instanceof Error ? error.message : String(error);
-  console.error(`[prepare-openclaw-runtime] ${message}`);
-  process.exit(1);
-}

desktop/scripts/prepare-zclaw-runtime.mjs

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 /**
- * OpenFang Runtime Preparation Script
+ * ZCLAW Runtime Preparation Script
  *
- * Prepares the OpenFang binary for bundling with Tauri.
+ * Prepares the ZCLAW binary for bundling with Tauri.
  * Supports cross-platform: Windows, Linux, macOS
  *
  * Usage:
- *   node scripts/prepare-openfang-runtime.mjs
- *   node scripts/prepare-openfang-runtime.mjs --dry-run
- *   OPENFANG_VERSION=v1.2.3 node scripts/prepare-openfang-runtime.mjs
+ *   node scripts/prepare-zclaw-runtime.mjs
+ *   node scripts/prepare-zclaw-runtime.mjs --dry-run
+ *   ZCLAW_VERSION=v1.2.3 node scripts/prepare-zclaw-runtime.mjs
  */
 
 import { execSync, execFileSync } from 'node:child_process';
@@ -20,64 +20,64 @@ import { arch as osArch, platform as osPlatform, homedir } from 'node:os';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const desktopRoot = path.resolve(__dirname, '..');
-const outputDir = path.join(desktopRoot, 'src-tauri', 'resources', 'openfang-runtime');
+const outputDir = path.join(desktopRoot, 'src-tauri', 'resources', 'zclaw-runtime');
 const dryRun = process.argv.includes('--dry-run');
-const openfangVersion = process.env.OPENFANG_VERSION || 'latest';
+const zclawVersion = process.env.ZCLAW_VERSION || 'latest';
 
 const PLATFORM = osPlatform();
 const ARCH = osArch();
 
 function log(message) {
-  console.log(`[prepare-openfang-runtime] ${message}`);
+  console.log(`[prepare-zclaw-runtime] ${message}`);
 }
 
 function warn(message) {
-  console.warn(`[prepare-openfang-runtime] WARN: ${message}`);
+  console.warn(`[prepare-zclaw-runtime] WARN: ${message}`);
 }
 
 function error(message) {
-  console.error(`[prepare-openfang-runtime] ERROR: ${message}`);
+  console.error(`[prepare-zclaw-runtime] ERROR: ${message}`);
 }
 
 /**
  * Get platform-specific binary configuration
- * OpenFang releases: .zip for Windows, .tar.gz for Unix
+ * ZCLAW releases: .zip for Windows, .tar.gz for Unix
  */
 function getPlatformConfig() {
   const configs = {
     win32: {
       x64: {
-        binaryName: 'openfang.exe',
-        downloadName: 'openfang-x86_64-pc-windows-msvc.zip',
+        binaryName: 'zclaw.exe',
+        downloadName: 'zclaw-x86_64-pc-windows-msvc.zip',
         archiveFormat: 'zip',
       },
       arm64: {
-        binaryName: 'openfang.exe',
-        downloadName: 'openfang-aarch64-pc-windows-msvc.zip',
+        binaryName: 'zclaw.exe',
+        downloadName: 'zclaw-aarch64-pc-windows-msvc.zip',
         archiveFormat: 'zip',
       },
     },
     darwin: {
       x64: {
-        binaryName: 'openfang-x86_64-apple-darwin',
-        downloadName: 'openfang-x86_64-apple-darwin.tar.gz',
+        binaryName: 'zclaw-x86_64-apple-darwin',
+        downloadName: 'zclaw-x86_64-apple-darwin.tar.gz',
         archiveFormat: 'tar.gz',
       },
       arm64: {
-        binaryName: 'openfang-aarch64-apple-darwin',
-        downloadName: 'openfang-aarch64-apple-darwin.tar.gz',
+        binaryName: 'zclaw-aarch64-apple-darwin',
+        downloadName: 'zclaw-aarch64-apple-darwin.tar.gz',
         archiveFormat: 'tar.gz',
       },
     },
     linux: {
       x64: {
-        binaryName: 'openfang-x86_64-unknown-linux-gnu',
-        downloadName: 'openfang-x86_64-unknown-linux-gnu.tar.gz',
+        binaryName: 'zclaw-x86_64-unknown-linux-gnu',
+        downloadName: 'zclaw-x86_64-unknown-linux-gnu.tar.gz',
         archiveFormat: 'tar.gz',
       },
       arm64: {
-        binaryName: 'openfang-aarch64-unknown-linux-gnu',
-        downloadName: 'openfang-aarch64-unknown-linux-gnu.tar.gz',
+        binaryName: 'zclaw-aarch64-unknown-linux-gnu',
+        downloadName: 'zclaw-aarch64-unknown-linux-gnu.tar.gz',
         archiveFormat: 'tar.gz',
       },
     },
@@ -97,26 +97,26 @@ function getPlatformConfig() {
 }
 
 /**
- * Find OpenFang binary in system PATH
+ * Find ZCLAW binary in system PATH
  */
 function findSystemBinary() {
-  const override = process.env.OPENFANG_BIN;
+  const override = process.env.ZCLAW_BIN;
   if (override) {
     if (fs.existsSync(override)) {
       return override;
     }
-    throw new Error(`OPENFANG_BIN specified but file not found: ${override}`);
+    throw new Error(`ZCLAW_BIN specified but file not found: ${override}`);
   }
 
   try {
     let result;
     if (PLATFORM === 'win32') {
-      result = execFileSync('where.exe', ['openfang'], {
+      result = execFileSync('where.exe', ['zclaw'], {
         encoding: 'utf8',
         stdio: ['ignore', 'pipe', 'ignore'],
       });
     } else {
-      result = execFileSync('which', ['openfang'], {
+      result = execFileSync('which', ['zclaw'], {
         encoding: 'utf8',
         stdio: ['ignore', 'pipe', 'ignore'],
       });
@@ -134,7 +134,7 @@ function findSystemBinary() {
 }
 
 /**
- * Check if OpenFang is installed via install script
+ * Check if ZCLAW is installed via install script
  */
 function findInstalledBinary() {
   const config = getPlatformConfig();
@@ -142,12 +142,12 @@ function findInstalledBinary() {
 
   const possiblePaths = [
     // Default install location
-    path.join(home, '.openfang', 'bin', config.binaryName),
+    path.join(home, '.zclaw', 'bin', config.binaryName),
     path.join(home, '.local', 'bin', config.binaryName),
     // macOS
-    path.join(home, '.openfang', 'bin', 'openfang'),
-    '/usr/local/bin/openfang',
-    '/usr/bin/openfang',
+    path.join(home, '.zclaw', 'bin', 'zclaw'),
+    '/usr/local/bin/zclaw',
+    '/usr/bin/zclaw',
   ];
 
   for (const p of possiblePaths) {
@@ -160,21 +160,21 @@ function findInstalledBinary() {
 }
 
 /**
- * Download OpenFang binary from GitHub Releases
+ * Download ZCLAW binary from GitHub Releases
  * Handles .zip for Windows, .tar.gz for Unix
  */
 function downloadBinary(config) {
-  const baseUrl = 'https://github.com/RightNow-AI/openfang/releases';
-  const downloadUrl = openfangVersion === 'latest'
+  const baseUrl = 'https://github.com/RightNow-AI/zclaw/releases';
+  const downloadUrl = zclawVersion === 'latest'
     ? `${baseUrl}/latest/download/${config.downloadName}`
-    : `${baseUrl}/download/${openfangVersion}/${config.downloadName}`;
+    : `${baseUrl}/download/${zclawVersion}/${config.downloadName}`;
 
   const archivePath = path.join(outputDir, config.downloadName);
   const binaryOutputPath = path.join(outputDir, config.binaryName);
 
-  log(`Downloading OpenFang binary...`);
+  log(`Downloading ZCLAW binary...`);
   log(`  Platform: ${PLATFORM} (${ARCH})`);
-  log(`  Version: ${openfangVersion}`);
+  log(`  Version: ${zclawVersion}`);
   log(`  Archive: ${config.downloadName}`);
   log(`  URL: ${downloadUrl}`);
 
@@ -211,7 +211,7 @@ function downloadBinary(config) {
     // Find and rename the extracted binary
     // The archive contains a single binary file
     const extractedFiles = fs.readdirSync(outputDir).filter(f =>
-      f.startsWith('openfang') && !f.endsWith('.zip') && !f.endsWith('.tar.gz') && !f.endsWith('.sha256')
+      f.startsWith('zclaw') && !f.endsWith('.zip') && !f.endsWith('.tar.gz') && !f.endsWith('.sha256')
     );
 
     if (extractedFiles.length === 0) {
@@ -285,16 +285,16 @@ function writeManifest(config) {
   const manifest = {
     source: {
       binPath: config.binaryName,
-      binPathLinux: 'openfang-x86_64-unknown-linux-gnu',
-      binPathMac: 'openfang-x86_64-apple-darwin',
-      binPathMacArm: 'openfang-aarch64-apple-darwin',
+      binPathLinux: 'zclaw-x86_64-unknown-linux-gnu',
+      binPathMac: 'zclaw-x86_64-apple-darwin',
+      binPathMacArm: 'zclaw-aarch64-apple-darwin',
     },
     stagedAt: new Date().toISOString(),
-    version: openfangVersion === 'latest'
+    version: zclawVersion === 'latest'
       ? new Date().toISOString().split('T')[0].replace(/-/g, '.')
-      : openfangVersion,
-    runtimeType: 'openfang',
-    description: 'OpenFang Agent OS - Single binary runtime (~32MB)',
+      : zclawVersion,
+    runtimeType: 'zclaw',
+    description: 'ZCLAW Agent OS - Single binary runtime (~32MB)',
     endpoints: {
       websocket: 'ws://127.0.0.1:4200/ws',
       rest: 'http://127.0.0.1:4200/api',
@@ -322,21 +322,21 @@ function writeLauncherScripts(config) {
   // Windows launcher
   const cmdLauncher = [
     '@echo off',
-    'REM OpenFang Agent OS - Bundled Binary Launcher',
+    'REM ZCLAW Agent OS - Bundled Binary Launcher',
     `"%~dp0${config.binaryName}" %*`,
     '',
   ].join('\r\n');
-  fs.writeFileSync(path.join(outputDir, 'openfang.cmd'), cmdLauncher, 'utf8');
+  fs.writeFileSync(path.join(outputDir, 'zclaw.cmd'), cmdLauncher, 'utf8');
 
   // Unix launcher
   const shLauncher = [
     '#!/bin/bash',
-    '# OpenFang Agent OS - Bundled Binary Launcher',
+    '# ZCLAW Agent OS - Bundled Binary Launcher',
     `SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"`,
     `exec "$SCRIPT_DIR/${config.binaryName}" "$@"`,
     '',
   ].join('\n');
-  const shPath = path.join(outputDir, 'openfang.sh');
+  const shPath = path.join(outputDir, 'zclaw.sh');
   fs.writeFileSync(shPath, shLauncher, 'utf8');
   fs.chmodSync(shPath, 0o755);
 
@@ -370,7 +370,7 @@ function cleanOldRuntime() {
  */
 function main() {
   log('='.repeat(60));
-  log('OpenFang Runtime Preparation');
+  log('ZCLAW Runtime Preparation');
   log('='.repeat(60));
 
   const config = getPlatformConfig();
@@ -385,23 +385,23 @@ function main() {
   let binaryPath = findSystemBinary();
 
   if (binaryPath) {
-    log(`Found OpenFang in PATH: ${binaryPath}`);
+    log(`Found ZCLAW in PATH: ${binaryPath}`);
     copyBinary(binaryPath, config);
   } else {
     binaryPath = findInstalledBinary();
     if (binaryPath) {
-      log(`Found installed OpenFang: ${binaryPath}`);
+      log(`Found installed ZCLAW: ${binaryPath}`);
       copyBinary(binaryPath, config);
     } else {
-      log('OpenFang not found locally, downloading...');
+      log('ZCLAW not found locally, downloading...');
       const downloaded = downloadBinary(config);
       if (!downloaded && !dryRun) {
-        error('Failed to obtain OpenFang binary!');
+        error('Failed to obtain ZCLAW binary!');
         error('');
         error('Please either:');
-        error('  1. Install OpenFang: curl -fsSL https://openfang.sh/install | sh');
-        error('  2. Set OPENFANG_BIN environment variable to binary path');
-        error('  3. Manually download from: https://github.com/RightNow-AI/openfang/releases');
+        error('  1. Install ZCLAW: curl -fsSL https://zclaw.sh/install | sh');
+        error('  2. Set ZCLAW_BIN environment variable to binary path');
+        error('  3. Manually download from: https://github.com/RightNow-AI/zclaw/releases');
         process.exit(1);
       }
     }
@@ -415,7 +415,7 @@ function main() {
   if (dryRun) {
     log('DRY RUN complete. No files were written.');
   } else {
-    log('OpenFang runtime ready for build!');
+    log('ZCLAW runtime ready for build!');
   }
   log('='.repeat(60));
 }

desktop/scripts/tauri-build-bundled.mjs

@@ -35,6 +35,6 @@ if (!process.env.TAURI_BUNDLER_TOOLS_GITHUB_MIRROR_TEMPLATE && process.env.ZCLAW
   env.TAURI_BUNDLER_TOOLS_GITHUB_MIRROR_TEMPLATE = process.env.ZCLAW_TAURI_TOOLS_GITHUB_MIRROR_TEMPLATE;
 }
 
-run('node', ['scripts/prepare-openfang-runtime.mjs']);
+run('node', ['scripts/prepare-zclaw-runtime.mjs']);
 run('node', ['scripts/preseed-tauri-tools.mjs']);
 run('pnpm', ['exec', 'tauri', 'build', ...forwardArgs], env);

desktop/scripts/test-api-connection.mjs

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 /**
- * OpenFang Backend API Connection Test Script
+ * ZCLAW Backend API Connection Test Script
  *
  * Tests all API endpoints used by the ZCLAW desktop client against
- * the OpenFang Kernel backend.
+ * the ZCLAW Kernel backend.
  *
  * Usage:
  *   node desktop/scripts/test-api-connection.mjs [options]
  *
  * Options:
- *   --url=URL     Base URL for OpenFang API (default: http://127.0.0.1:50051)
+ *   --url=URL     Base URL for ZCLAW API (default: http://127.0.0.1:50051)
  *   --verbose     Show detailed output
  *   --json        Output results as JSON
  *   --timeout=MS  Request timeout in milliseconds (default: 5000)
@@ -41,12 +41,12 @@ for (const arg of args) {
     config.timeout = parseInt(arg.slice(10), 10);
   } else if (arg === '--help' || arg === '-h') {
     console.log(`
-OpenFang API Connection Tester
+ZCLAW API Connection Tester
 
 Usage: node test-api-connection.mjs [options]
 
 Options:
-  --url=URL      Base URL for OpenFang API (default: ${DEFAULT_BASE_URL})
+  --url=URL      Base URL for ZCLAW API (default: ${DEFAULT_BASE_URL})
   --verbose      Show detailed output including response bodies
   --json         Output results as JSON for programmatic processing
   --timeout=MS   Request timeout in milliseconds (default: ${DEFAULT_TIMEOUT})
@@ -324,7 +324,7 @@ function printSummary() {
  * Run all API tests
  */
 async function runAllTests() {
-  console.log(`\n=== OpenFang API Connection Test ===`);
+  console.log(`\n=== ZCLAW API Connection Test ===`);
   console.log(`Base URL: ${config.baseUrl}`);
   console.log(`Timeout: ${config.timeout}ms`);
   console.log(`\n`);

desktop/scripts/test-toml-parsing.mjs

@@ -13,7 +13,7 @@ websocket_port = 4200
 websocket_path = "/ws"
 
 [agent.defaults]
-workspace = "~/.openfang/workspace"
+workspace = "~/.zclaw/workspace"
 default_model = "gpt-4"
 
 [llm]

desktop/src-tauri/Cargo.toml

@@ -70,6 +70,7 @@ rand = { workspace = true }
 
 # SQLite (keep for backward compatibility during migration)
 sqlx = { workspace = true }
+libsqlite3-sys = { workspace = true }
 
 # Development server (optional, only for debug builds)
 axum = { version = "0.7", optional = true }

desktop/src-tauri/src/embedding_adapter.rs

@@ -0,0 +1,32 @@
+//! Embedding Adapter - Bridges Tauri LLM EmbeddingClient to Growth System trait
+//!
+//! Implements zclaw_growth::retrieval::semantic::EmbeddingClient
+//! by wrapping the concrete llm::EmbeddingClient.
+
+use std::sync::Arc;
+use zclaw_growth::retrieval::semantic::EmbeddingClient;
+
+/// Adapter wrapping Tauri's llm::EmbeddingClient to implement the growth trait
+pub struct TauriEmbeddingAdapter {
+    inner: Arc<crate::llm::EmbeddingClient>,
+}
+
+impl TauriEmbeddingAdapter {
+    pub fn new(client: crate::llm::EmbeddingClient) -> Self {
+        Self {
+            inner: Arc::new(client),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl EmbeddingClient for TauriEmbeddingAdapter {
+    async fn embed(&self, text: &str) -> Result<Vec<f32>, String> {
+        let response = self.inner.embed(text).await?;
+        Ok(response.embedding)
+    }
+
+    fn is_available(&self) -> bool {
+        self.inner.is_configured()
+    }
+}

desktop/src-tauri/src/intelligence/heartbeat.rs

@@ -9,8 +9,6 @@
 //!
 //! NOTE: Some methods are reserved for future proactive features.
 
-#![allow(dead_code)] // Methods reserved for future proactive features
-
 use chrono::{Local, Timelike};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -94,6 +92,7 @@ pub enum HeartbeatStatus {
 }
 
 /// Type alias for heartbeat check function
+#[allow(dead_code)] // Reserved for future proactive check registration
 pub type HeartbeatCheckFn = Box<dyn Fn(String) -> std::pin::Pin<Box<dyn std::future::Future<Output = Option<HeartbeatAlert>> + Send>> + Send + Sync>;
 
 // === Default Config ===
@@ -187,6 +186,7 @@ impl HeartbeatEngine {
     }
 
     /// Check if the engine is running
+    #[allow(dead_code)] // Reserved for UI status display
     pub async fn is_running(&self) -> bool {
         *self.running.lock().await
     }
@@ -197,6 +197,7 @@ impl HeartbeatEngine {
     }
 
     /// Subscribe to alerts
+    #[allow(dead_code)] // Reserved for future UI notification integration
     pub fn subscribe(&self) -> broadcast::Receiver<HeartbeatAlert> {
         self.alert_sender.subscribe()
     }
@@ -355,7 +356,9 @@ static LAST_INTERACTION: OnceLock<RwLock<StdHashMap<String, String>>> = OnceLock
 pub struct MemoryStatsCache {
     pub task_count: usize,
     pub total_entries: usize,
+    #[allow(dead_code)] // Reserved for UI display
     pub storage_size_bytes: usize,
+    #[allow(dead_code)] // Reserved for UI display
     pub last_updated: Option<String>,
 }
 

desktop/src-tauri/src/intelligence/mesh.rs

@@ -1,397 +0,0 @@
-//! Adaptive Intelligence Mesh - Coordinates Memory, Pipeline, and Heartbeat
-//!
-//! This module provides proactive workflow recommendations based on user behavior patterns.
-//! It integrates with:
-//! - PatternDetector for behavior pattern detection
-//! - WorkflowRecommender for generating recommendations
-//! - HeartbeatEngine for periodic checks
-//! - PersistentMemoryStore for historical data
-//! - PipelineExecutor for workflow execution
-//!
-//! NOTE: Some methods are reserved for future integration with the UI.
-
-#![allow(dead_code)] // Methods reserved for future UI integration
-
-use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::sync::Arc;
-use tokio::sync::{broadcast, Mutex};
-
-use super::pattern_detector::{BehaviorPattern, PatternContext, PatternDetector};
-use super::recommender::WorkflowRecommender;
-
-// === Types ===
-
-/// Workflow recommendation generated by the mesh
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct WorkflowRecommendation {
-    /// Unique recommendation identifier
-    pub id: String,
-    /// Pipeline ID to recommend
-    pub pipeline_id: String,
-    /// Confidence score (0.0-1.0)
-    pub confidence: f32,
-    /// Human-readable reason for recommendation
-    pub reason: String,
-    /// Suggested input values
-    pub suggested_inputs: HashMap<String, serde_json::Value>,
-    /// Pattern IDs that matched
-    pub patterns_matched: Vec<String>,
-    /// When this recommendation was generated
-    pub timestamp: DateTime<Utc>,
-}
-
-/// Mesh coordinator configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct MeshConfig {
-    /// Enable mesh recommendations
-    pub enabled: bool,
-    /// Minimum confidence threshold for recommendations
-    pub min_confidence: f32,
-    /// Maximum recommendations to generate per analysis
-    pub max_recommendations: usize,
-    /// Hours to look back for pattern analysis
-    pub analysis_window_hours: u64,
-}
-
-impl Default for MeshConfig {
-    fn default() -> Self {
-        Self {
-            enabled: true,
-            min_confidence: 0.6,
-            max_recommendations: 5,
-            analysis_window_hours: 24,
-        }
-    }
-}
-
-/// Analysis result from mesh coordinator
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct MeshAnalysisResult {
-    /// Generated recommendations
-    pub recommendations: Vec<WorkflowRecommendation>,
-    /// Patterns detected
-    pub patterns_detected: usize,
-    /// Analysis timestamp
-    pub timestamp: DateTime<Utc>,
-}
-
-// === Mesh Coordinator ===
-
-/// Main mesh coordinator that integrates pattern detection and recommendations
-pub struct MeshCoordinator {
-    /// Agent ID
-    #[allow(dead_code)] // Reserved for multi-agent scenarios
-    agent_id: String,
-    /// Configuration
-    config: Arc<Mutex<MeshConfig>>,
-    /// Pattern detector
-    pattern_detector: Arc<Mutex<PatternDetector>>,
-    /// Workflow recommender
-    recommender: Arc<Mutex<WorkflowRecommender>>,
-    /// Recommendation sender
-    #[allow(dead_code)] // Reserved for real-time recommendation streaming
-    recommendation_sender: broadcast::Sender<WorkflowRecommendation>,
-    /// Last analysis timestamp
-    last_analysis: Arc<Mutex<Option<DateTime<Utc>>>>,
-}
-
-impl MeshCoordinator {
-    /// Create a new mesh coordinator
-    pub fn new(agent_id: String, config: Option<MeshConfig>) -> Self {
-        let (sender, _) = broadcast::channel(100);
-        let config = config.unwrap_or_default();
-
-        Self {
-            agent_id,
-            config: Arc::new(Mutex::new(config)),
-            pattern_detector: Arc::new(Mutex::new(PatternDetector::new(None))),
-            recommender: Arc::new(Mutex::new(WorkflowRecommender::new(None))),
-            recommendation_sender: sender,
-            last_analysis: Arc::new(Mutex::new(None)),
-        }
-    }
-
-    /// Analyze current context and generate recommendations
-    pub async fn analyze(&self) -> Result<MeshAnalysisResult, String> {
-        let config = self.config.lock().await.clone();
-
-        if !config.enabled {
-            return Ok(MeshAnalysisResult {
-                recommendations: vec![],
-                patterns_detected: 0,
-                timestamp: Utc::now(),
-            });
-        }
-
-        // Get patterns from detector (clone to avoid borrow issues)
-        let patterns: Vec<BehaviorPattern> = {
-            let detector = self.pattern_detector.lock().await;
-            let patterns_ref = detector.get_patterns();
-            patterns_ref.into_iter().cloned().collect()
-        };
-        let patterns_detected = patterns.len();
-
-        // Generate recommendations from patterns
-        let recommender = self.recommender.lock().await;
-        let pattern_refs: Vec<&BehaviorPattern> = patterns.iter().collect();
-        let mut recommendations = recommender.recommend(&pattern_refs);
-
-        // Filter by confidence
-        recommendations.retain(|r| r.confidence >= config.min_confidence);
-
-        // Limit count
-        recommendations.truncate(config.max_recommendations);
-
-        // Update timestamps
-        for rec in &mut recommendations {
-            rec.timestamp = Utc::now();
-        }
-
-        // Update last analysis time
-        *self.last_analysis.lock().await = Some(Utc::now());
-
-        Ok(MeshAnalysisResult {
-            recommendations: recommendations.clone(),
-            patterns_detected,
-            timestamp: Utc::now(),
-        })
-    }
-
-    /// Record user activity for pattern detection
-    pub async fn record_activity(
-        &self,
-        activity_type: ActivityType,
-        context: PatternContext,
-    ) -> Result<(), String> {
-        let mut detector = self.pattern_detector.lock().await;
-
-        match activity_type {
-            ActivityType::SkillUsed { skill_ids } => {
-                detector.record_skill_usage(skill_ids);
-            }
-            ActivityType::PipelineExecuted {
-                task_type,
-                pipeline_id,
-            } => {
-                detector.record_pipeline_execution(&task_type, &pipeline_id, context);
-            }
-            ActivityType::InputReceived { keywords, intent } => {
-                detector.record_input_pattern(keywords, &intent, context);
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Subscribe to recommendations
-    pub fn subscribe(&self) -> broadcast::Receiver<WorkflowRecommendation> {
-        self.recommendation_sender.subscribe()
-    }
-
-    /// Get current patterns
-    pub async fn get_patterns(&self) -> Vec<BehaviorPattern> {
-        let detector = self.pattern_detector.lock().await;
-        detector.get_patterns().into_iter().cloned().collect()
-    }
-
-    /// Decay old patterns (call periodically)
-    pub async fn decay_patterns(&self) {
-        let mut detector = self.pattern_detector.lock().await;
-        detector.decay_patterns();
-    }
-
-    /// Update configuration
-    pub async fn update_config(&self, config: MeshConfig) {
-        *self.config.lock().await = config;
-    }
-
-    /// Get configuration
-    pub async fn get_config(&self) -> MeshConfig {
-        self.config.lock().await.clone()
-    }
-
-    /// Record a user correction (for pattern refinement)
-    pub async fn record_correction(&self, correction_type: &str) {
-        let mut detector = self.pattern_detector.lock().await;
-        // Record as input pattern with negative signal
-        detector.record_input_pattern(
-            vec![format!("correction:{}", correction_type)],
-            "user_preference",
-            PatternContext::default(),
-        );
-    }
-
-    /// Get recommendation count
-    pub async fn recommendation_count(&self) -> usize {
-        let recommender = self.recommender.lock().await;
-        recommender.recommendation_count()
-    }
-
-    /// Accept a recommendation (returns the accepted recommendation)
-    pub async fn accept_recommendation(&self, recommendation_id: &str) -> Option<WorkflowRecommendation> {
-        let mut recommender = self.recommender.lock().await;
-        recommender.accept_recommendation(recommendation_id)
-    }
-
-    /// Dismiss a recommendation (returns true if found and dismissed)
-    pub async fn dismiss_recommendation(&self, recommendation_id: &str) -> bool {
-        let mut recommender = self.recommender.lock().await;
-        recommender.dismiss_recommendation(recommendation_id)
-    }
-}
-
-/// Types of user activities that can be recorded
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(tag = "type", rename_all = "snake_case")]
-pub enum ActivityType {
-    /// Skills were used together
-    SkillUsed { skill_ids: Vec<String> },
-    /// A pipeline was executed
-    PipelineExecuted { task_type: String, pipeline_id: String },
-    /// User input was received
-    InputReceived { keywords: Vec<String>, intent: String },
-}
-
-// === Tauri Commands ===
-
-/// Mesh coordinator state for Tauri
-pub type MeshCoordinatorState = Arc<Mutex<HashMap<String, MeshCoordinator>>>;
-
-/// Initialize mesh coordinator for an agent
-#[tauri::command]
-pub async fn mesh_init(
-    agent_id: String,
-    config: Option<MeshConfig>,
-    state: tauri::State<'_, MeshCoordinatorState>,
-) -> Result<(), String> {
-    let coordinator = MeshCoordinator::new(agent_id.clone(), config);
-    let mut coordinators = state.lock().await;
-    coordinators.insert(agent_id, coordinator);
-    Ok(())
-}
-
-/// Analyze and get recommendations
-#[tauri::command]
-pub async fn mesh_analyze(
-    agent_id: String,
-    state: tauri::State<'_, MeshCoordinatorState>,
-) -> Result<MeshAnalysisResult, String> {
-    let coordinators = state.lock().await;
-    let coordinator = coordinators
-        .get(&agent_id)
-        .ok_or_else(|| format!("Mesh coordinator not initialized for agent: {}", agent_id))?;
-    coordinator.analyze().await
-}
-
-/// Record user activity
-#[tauri::command]
-pub async fn mesh_record_activity(
-    agent_id: String,
-    activity_type: ActivityType,
-    context: PatternContext,
-    state: tauri::State<'_, MeshCoordinatorState>,
-) -> Result<(), String> {
-    let coordinators = state.lock().await;
-    let coordinator = coordinators
-        .get(&agent_id)
-        .ok_or_else(|| format!("Mesh coordinator not initialized for agent: {}", agent_id))?;
-    coordinator.record_activity(activity_type, context).await
-}
-
-/// Get current patterns
-#[tauri::command]
-pub async fn mesh_get_patterns(
-    agent_id: String,
-    state: tauri::State<'_, MeshCoordinatorState>,
-) -> Result<Vec<BehaviorPattern>, String> {
-    let coordinators = state.lock().await;
-    let coordinator = coordinators
-        .get(&agent_id)
-        .ok_or_else(|| format!("Mesh coordinator not initialized for agent: {}", agent_id))?;
-    Ok(coordinator.get_patterns().await)
-}
-
-/// Update mesh configuration
-#[tauri::command]
-pub async fn mesh_update_config(
-    agent_id: String,
-    config: MeshConfig,
-    state: tauri::State<'_, MeshCoordinatorState>,
-) -> Result<(), String> {
-    let coordinators = state.lock().await;
-    let coordinator = coordinators
-        .get(&agent_id)
-        .ok_or_else(|| format!("Mesh coordinator not initialized for agent: {}", agent_id))?;
-    coordinator.update_config(config).await;
-    Ok(())
-}
-
-/// Decay old patterns
-#[tauri::command]
-pub async fn mesh_decay_patterns(
-    agent_id: String,
-    state: tauri::State<'_, MeshCoordinatorState>,
-) -> Result<(), String> {
-    let coordinators = state.lock().await;
-    let coordinator = coordinators
-        .get(&agent_id)
-        .ok_or_else(|| format!("Mesh coordinator not initialized for agent: {}", agent_id))?;
-    coordinator.decay_patterns().await;
-    Ok(())
-}
-
-/// Accept a recommendation (removes it and returns the accepted recommendation)
-#[tauri::command]
-pub async fn mesh_accept_recommendation(
-    agent_id: String,
-    recommendation_id: String,
-    state: tauri::State<'_, MeshCoordinatorState>,
-) -> Result<Option<WorkflowRecommendation>, String> {
-    let coordinators = state.lock().await;
-    let coordinator = coordinators
-        .get(&agent_id)
-        .ok_or_else(|| format!("Mesh coordinator not initialized for agent: {}", agent_id))?;
-    Ok(coordinator.accept_recommendation(&recommendation_id).await)
-}
-
-/// Dismiss a recommendation (removes it without acting on it)
-#[tauri::command]
-pub async fn mesh_dismiss_recommendation(
-    agent_id: String,
-    recommendation_id: String,
-    state: tauri::State<'_, MeshCoordinatorState>,
-) -> Result<bool, String> {
-    let coordinators = state.lock().await;
-    let coordinator = coordinators
-        .get(&agent_id)
-        .ok_or_else(|| format!("Mesh coordinator not initialized for agent: {}", agent_id))?;
-    Ok(coordinator.dismiss_recommendation(&recommendation_id).await)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_mesh_config_default() {
-        let config = MeshConfig::default();
-        assert!(config.enabled);
-        assert_eq!(config.min_confidence, 0.6);
-    }
-
-    #[tokio::test]
-    async fn test_mesh_coordinator_creation() {
-        let coordinator = MeshCoordinator::new("test_agent".to_string(), None);
-        let config = coordinator.get_config().await;
-        assert!(config.enabled);
-    }
-
-    #[tokio::test]
-    async fn test_mesh_analysis() {
-        let coordinator = MeshCoordinator::new("test_agent".to_string(), None);
-        let result = coordinator.analyze().await;
-        assert!(result.is_ok());
-    }
-}

desktop/src-tauri/src/intelligence/pattern_detector.rs

@@ -1,421 +0,0 @@
-//! Pattern Detector - Behavior pattern detection for Adaptive Intelligence Mesh
-//!
-//! Detects patterns from user activities including:
-//! - Skill combinations (frequently used together)
-//! - Temporal triggers (time-based patterns)
-//! - Task-pipeline mappings (task types mapped to pipelines)
-//! - Input patterns (keyword/intent patterns)
-//!
-//! NOTE: Analysis and export methods are reserved for future dashboard integration.
-
-#![allow(dead_code)] // Analysis and export methods reserved for future dashboard features
-
-use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-
-// === Pattern Types ===
-
-/// Unique identifier for a pattern
-pub type PatternId = String;
-
-/// Behavior pattern detected from user activities
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct BehaviorPattern {
-    /// Unique pattern identifier
-    pub id: PatternId,
-    /// Type of pattern detected
-    pub pattern_type: PatternType,
-    /// How many times this pattern has occurred
-    pub frequency: usize,
-    /// When this pattern was last detected
-    pub last_occurrence: DateTime<Utc>,
-    /// When this pattern was first detected
-    pub first_occurrence: DateTime<Utc>,
-    /// Confidence score (0.0-1.0)
-    pub confidence: f32,
-    /// Context when pattern was detected
-    pub context: PatternContext,
-}
-
-/// Types of detectable patterns
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(tag = "type", rename_all = "snake_case")]
-pub enum PatternType {
-    /// Skills frequently used together
-    SkillCombination {
-        skill_ids: Vec<String>,
-    },
-    /// Time-based trigger pattern
-    TemporalTrigger {
-        hand_id: String,
-        time_pattern: String, // Cron-like pattern or time range
-    },
-    /// Task type mapped to a pipeline
-    TaskPipelineMapping {
-        task_type: String,
-        pipeline_id: String,
-    },
-    /// Input keyword/intent pattern
-    InputPattern {
-        keywords: Vec<String>,
-        intent: String,
-    },
-}
-
-/// Context information when pattern was detected
-#[derive(Debug, Clone, Serialize, Deserialize, Default)]
-pub struct PatternContext {
-    /// Skills involved in the session
-    pub skill_ids: Option<Vec<String>>,
-    /// Topics discussed recently
-    pub recent_topics: Option<Vec<String>>,
-    /// Detected intent
-    pub intent: Option<String>,
-    /// Time of day when detected (hour 0-23)
-    pub time_of_day: Option<u8>,
-    /// Day of week (0=Monday, 6=Sunday)
-    pub day_of_week: Option<u8>,
-}
-
-/// Pattern detection configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct PatternDetectorConfig {
-    /// Minimum occurrences before pattern is recognized
-    pub min_frequency: usize,
-    /// Minimum confidence threshold
-    pub min_confidence: f32,
-    /// Days after which pattern confidence decays
-    pub decay_days: u32,
-    /// Maximum patterns to keep
-    pub max_patterns: usize,
-}
-
-impl Default for PatternDetectorConfig {
-    fn default() -> Self {
-        Self {
-            min_frequency: 3,
-            min_confidence: 0.5,
-            decay_days: 30,
-            max_patterns: 100,
-        }
-    }
-}
-
-// === Pattern Detector ===
-
-/// Pattern detector that identifies behavior patterns from activities
-pub struct PatternDetector {
-    /// Detected patterns
-    patterns: HashMap<PatternId, BehaviorPattern>,
-    /// Configuration
-    config: PatternDetectorConfig,
-    /// Skill combination history for pattern detection
-    skill_combination_history: Vec<(Vec<String>, DateTime<Utc>)>,
-}
-
-impl PatternDetector {
-    /// Create a new pattern detector
-    pub fn new(config: Option<PatternDetectorConfig>) -> Self {
-        Self {
-            patterns: HashMap::new(),
-            config: config.unwrap_or_default(),
-            skill_combination_history: Vec::new(),
-        }
-    }
-
-    /// Record skill usage for combination detection
-    pub fn record_skill_usage(&mut self, skill_ids: Vec<String>) {
-        let now = Utc::now();
-        self.skill_combination_history.push((skill_ids, now));
-
-        // Keep only recent history (last 1000 entries)
-        if self.skill_combination_history.len() > 1000 {
-            self.skill_combination_history.drain(0..500);
-        }
-
-        // Detect patterns
-        self.detect_skill_combinations();
-    }
-
-    /// Record a pipeline execution for task mapping detection
-    pub fn record_pipeline_execution(
-        &mut self,
-        task_type: &str,
-        pipeline_id: &str,
-        context: PatternContext,
-    ) {
-        let pattern_key = format!("task_pipeline:{}:{}", task_type, pipeline_id);
-
-        self.update_or_create_pattern(
-            &pattern_key,
-            PatternType::TaskPipelineMapping {
-                task_type: task_type.to_string(),
-                pipeline_id: pipeline_id.to_string(),
-            },
-            context,
-        );
-    }
-
-    /// Record an input pattern
-    pub fn record_input_pattern(
-        &mut self,
-        keywords: Vec<String>,
-        intent: &str,
-        context: PatternContext,
-    ) {
-        let pattern_key = format!("input_pattern:{}:{}", keywords.join(","), intent);
-
-        self.update_or_create_pattern(
-            &pattern_key,
-            PatternType::InputPattern {
-                keywords,
-                intent: intent.to_string(),
-            },
-            context,
-        );
-    }
-
-    /// Update existing pattern or create new one
-    fn update_or_create_pattern(
-        &mut self,
-        key: &str,
-        pattern_type: PatternType,
-        context: PatternContext,
-    ) {
-        let now = Utc::now();
-        let decay_days = self.config.decay_days;
-
-        if let Some(pattern) = self.patterns.get_mut(key) {
-            // Update existing pattern
-            pattern.frequency += 1;
-            pattern.last_occurrence = now;
-            pattern.context = context;
-
-            // Recalculate confidence inline to avoid borrow issues
-            let days_since_last = (now - pattern.last_occurrence).num_days() as f32;
-            let frequency_score = (pattern.frequency as f32 / 10.0).min(1.0);
-            let decay_factor = if days_since_last > decay_days as f32 {
-                0.5
-            } else {
-                1.0 - (days_since_last / decay_days as f32) * 0.3
-            };
-            pattern.confidence = (frequency_score * decay_factor).min(1.0);
-        } else {
-            // Create new pattern
-            let pattern = BehaviorPattern {
-                id: key.to_string(),
-                pattern_type,
-                frequency: 1,
-                first_occurrence: now,
-                last_occurrence: now,
-                confidence: 0.1, // Low initial confidence
-                context,
-            };
-
-            self.patterns.insert(key.to_string(), pattern);
-
-            // Enforce max patterns limit
-            self.enforce_max_patterns();
-        }
-    }
-
-    /// Detect skill combination patterns from history
-    fn detect_skill_combinations(&mut self) {
-        // Group skill combinations
-        let mut combination_counts: HashMap<String, (Vec<String>, usize, DateTime<Utc>)> =
-            HashMap::new();
-
-        for (skills, time) in &self.skill_combination_history {
-            if skills.len() < 2 {
-                continue;
-            }
-
-            // Sort skills for consistent grouping
-            let mut sorted_skills = skills.clone();
-            sorted_skills.sort();
-            let key = sorted_skills.join("|");
-
-            let entry = combination_counts.entry(key).or_insert((
-                sorted_skills,
-                0,
-                *time,
-            ));
-            entry.1 += 1;
-            entry.2 = *time; // Update last occurrence
-        }
-
-        // Create patterns for combinations meeting threshold
-        for (key, (skills, count, last_time)) in combination_counts {
-            if count >= self.config.min_frequency {
-                let pattern = BehaviorPattern {
-                    id: format!("skill_combo:{}", key),
-                    pattern_type: PatternType::SkillCombination { skill_ids: skills },
-                    frequency: count,
-                    first_occurrence: last_time,
-                    last_occurrence: last_time,
-                    confidence: self.calculate_confidence_from_frequency(count),
-                    context: PatternContext::default(),
-                };
-
-                self.patterns.insert(pattern.id.clone(), pattern);
-            }
-        }
-
-        self.enforce_max_patterns();
-    }
-
-    /// Calculate confidence based on frequency and recency
-    fn calculate_confidence(&self, pattern: &BehaviorPattern) -> f32 {
-        let now = Utc::now();
-        let days_since_last = (now - pattern.last_occurrence).num_days() as f32;
-
-        // Base confidence from frequency (capped at 1.0)
-        let frequency_score = (pattern.frequency as f32 / 10.0).min(1.0);
-
-        // Decay factor based on time since last occurrence
-        let decay_factor = if days_since_last > self.config.decay_days as f32 {
-            0.5 // Significant decay for old patterns
-        } else {
-            1.0 - (days_since_last / self.config.decay_days as f32) * 0.3
-        };
-
-        (frequency_score * decay_factor).min(1.0)
-    }
-
-    /// Calculate confidence from frequency alone
-    fn calculate_confidence_from_frequency(&self, frequency: usize) -> f32 {
-        (frequency as f32 / self.config.min_frequency.max(1) as f32).min(1.0)
-    }
-
-    /// Enforce maximum patterns limit by removing lowest confidence patterns
-    fn enforce_max_patterns(&mut self) {
-        if self.patterns.len() <= self.config.max_patterns {
-            return;
-        }
-
-        // Sort patterns by confidence and remove lowest
-        let mut patterns_vec: Vec<_> = self.patterns.drain().collect();
-        patterns_vec.sort_by(|a, b| b.1.confidence.partial_cmp(&a.1.confidence).unwrap());
-
-        // Keep top patterns
-        self.patterns = patterns_vec
-            .into_iter()
-            .take(self.config.max_patterns)
-            .collect();
-    }
-
-    /// Get all patterns above confidence threshold
-    pub fn get_patterns(&self) -> Vec<&BehaviorPattern> {
-        self.patterns
-            .values()
-            .filter(|p| p.confidence >= self.config.min_confidence)
-            .collect()
-    }
-
-    /// Get patterns of a specific type
-    pub fn get_patterns_by_type(&self, pattern_type: &PatternType) -> Vec<&BehaviorPattern> {
-        self.patterns
-            .values()
-            .filter(|p| std::mem::discriminant(&p.pattern_type) == std::mem::discriminant(pattern_type))
-            .filter(|p| p.confidence >= self.config.min_confidence)
-            .collect()
-    }
-
-    /// Get patterns sorted by confidence
-    pub fn get_patterns_sorted(&self) -> Vec<&BehaviorPattern> {
-        let mut patterns: Vec<_> = self.get_patterns();
-        patterns.sort_by(|a, b| b.confidence.partial_cmp(&a.confidence).unwrap());
-        patterns
-    }
-
-    /// Decay old patterns (should be called periodically)
-    pub fn decay_patterns(&mut self) {
-        let now = Utc::now();
-
-        for pattern in self.patterns.values_mut() {
-            let days_since_last = (now - pattern.last_occurrence).num_days() as f32;
-
-            if days_since_last > self.config.decay_days as f32 {
-                // Reduce confidence for old patterns
-                let decay_amount = 0.1 * (days_since_last / self.config.decay_days as f32);
-                pattern.confidence = (pattern.confidence - decay_amount).max(0.0);
-            }
-        }
-
-        // Remove patterns below threshold
-        self.patterns
-            .retain(|_, p| p.confidence >= self.config.min_confidence * 0.5);
-    }
-
-    /// Clear all patterns
-    pub fn clear(&mut self) {
-        self.patterns.clear();
-        self.skill_combination_history.clear();
-    }
-
-    /// Get pattern count
-    pub fn pattern_count(&self) -> usize {
-        self.patterns.len()
-    }
-
-    /// Export patterns for persistence
-    pub fn export_patterns(&self) -> Vec<BehaviorPattern> {
-        self.patterns.values().cloned().collect()
-    }
-
-    /// Import patterns from persistence
-    pub fn import_patterns(&mut self, patterns: Vec<BehaviorPattern>) {
-        for pattern in patterns {
-            self.patterns.insert(pattern.id.clone(), pattern);
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_pattern_creation() {
-        let detector = PatternDetector::new(None);
-        assert_eq!(detector.pattern_count(), 0);
-    }
-
-    #[test]
-    fn test_skill_combination_detection() {
-        let mut detector = PatternDetector::new(Some(PatternDetectorConfig {
-            min_frequency: 2,
-            ..Default::default()
-        }));
-
-        // Record skill usage multiple times
-        detector.record_skill_usage(vec!["skill_a".to_string(), "skill_b".to_string()]);
-        detector.record_skill_usage(vec!["skill_a".to_string(), "skill_b".to_string()]);
-
-        // Should detect pattern after 2 occurrences
-        let patterns = detector.get_patterns();
-        assert!(!patterns.is_empty());
-    }
-
-    #[test]
-    fn test_confidence_calculation() {
-        let detector = PatternDetector::new(None);
-
-        let pattern = BehaviorPattern {
-            id: "test".to_string(),
-            pattern_type: PatternType::TaskPipelineMapping {
-                task_type: "test".to_string(),
-                pipeline_id: "pipeline".to_string(),
-            },
-            frequency: 5,
-            first_occurrence: Utc::now(),
-            last_occurrence: Utc::now(),
-            confidence: 0.5,
-            context: PatternContext::default(),
-        };
-
-        let confidence = detector.calculate_confidence(&pattern);
-        assert!(confidence > 0.0 && confidence <= 1.0);
-    }
-}

desktop/src-tauri/src/intelligence/persona_evolver.rs

@@ -1,819 +0,0 @@
-//! Persona Evolver - Memory-powered persona evolution system
-//!
-//! Automatically evolves agent persona based on:
-//! - User interaction patterns (preferences, communication style)
-//! - Reflection insights (positive/negative patterns)
-//! - Memory accumulation (facts, lessons, context)
-//!
-//! Key features:
-//! - Automatic user_profile enrichment from preferences
-//! - Instruction refinement proposals based on patterns
-//! - Soul evolution suggestions (requires explicit user approval)
-//!
-//! Phase 4 of Intelligence Layer - P1 Innovation Task.
-//!
-//! NOTE: Tauri commands defined here are not yet registered with the app.
-
-#![allow(dead_code)] // Tauri commands not yet registered with application
-
-use chrono::Utc;
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::sync::Arc;
-use tokio::sync::Mutex;
-
-use super::reflection::{ReflectionResult, Sentiment, MemoryEntryForAnalysis};
-use super::identity::{IdentityFiles, IdentityFile, ProposalStatus};
-
-// === Types ===
-
-/// Persona evolution configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct PersonaEvolverConfig {
-    /// Enable automatic user_profile updates
-    #[serde(default = "default_auto_profile_update")]
-    pub auto_profile_update: bool,
-    /// Minimum preferences before suggesting profile update
-    #[serde(default = "default_min_preferences")]
-    pub min_preferences_for_update: usize,
-    /// Minimum conversations before evolution
-    #[serde(default = "default_min_conversations")]
-    pub min_conversations_for_evolution: usize,
-    /// Enable instruction refinement proposals
-    #[serde(default = "default_enable_instruction_refinement")]
-    pub enable_instruction_refinement: bool,
-    /// Enable soul evolution (requires explicit approval)
-    #[serde(default = "default_enable_soul_evolution")]
-    pub enable_soul_evolution: bool,
-    /// Maximum proposals per evolution cycle
-    #[serde(default = "default_max_proposals")]
-    pub max_proposals_per_cycle: usize,
-}
-
-fn default_auto_profile_update() -> bool { true }
-fn default_min_preferences() -> usize { 3 }
-fn default_min_conversations() -> usize { 5 }
-fn default_enable_instruction_refinement() -> bool { true }
-fn default_enable_soul_evolution() -> bool { true }
-fn default_max_proposals() -> usize { 3 }
-
-impl Default for PersonaEvolverConfig {
-    fn default() -> Self {
-        Self {
-            auto_profile_update: true,
-            min_preferences_for_update: 3,
-            min_conversations_for_evolution: 5,
-            enable_instruction_refinement: true,
-            enable_soul_evolution: true,
-            max_proposals_per_cycle: 3,
-        }
-    }
-}
-
-/// Persona evolution result
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct EvolutionResult {
-    /// Agent ID
-    pub agent_id: String,
-    /// Timestamp
-    pub timestamp: String,
-    /// Profile updates applied (auto)
-    pub profile_updates: Vec<ProfileUpdate>,
-    /// Proposals generated (require approval)
-    pub proposals: Vec<EvolutionProposal>,
-    /// Evolution insights
-    pub insights: Vec<EvolutionInsight>,
-    /// Whether evolution occurred
-    pub evolved: bool,
-}
-
-/// Profile update (auto-applied)
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ProfileUpdate {
-    pub section: String,
-    pub previous: String,
-    pub updated: String,
-    pub source: String,
-}
-
-/// Evolution proposal (requires approval)
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct EvolutionProposal {
-    pub id: String,
-    pub agent_id: String,
-    pub target_file: IdentityFile,
-    pub change_type: EvolutionChangeType,
-    pub reason: String,
-    pub current_content: String,
-    pub proposed_content: String,
-    pub confidence: f32,
-    pub evidence: Vec<String>,
-    pub status: ProposalStatus,
-    pub created_at: String,
-}
-
-/// Type of evolution change
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum EvolutionChangeType {
-    /// Add new instruction section
-    InstructionAddition,
-    /// Refine existing instruction
-    InstructionRefinement,
-    /// Add personality trait
-    TraitAddition,
-    /// Communication style adjustment
-    StyleAdjustment,
-    /// Knowledge domain expansion
-    DomainExpansion,
-}
-
-/// Evolution insight
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct EvolutionInsight {
-    pub category: InsightCategory,
-    pub observation: String,
-    pub recommendation: String,
-    pub confidence: f32,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum InsightCategory {
-    CommunicationStyle,
-    TechnicalExpertise,
-    TaskEfficiency,
-    UserPreference,
-    KnowledgeGap,
-}
-
-/// Persona evolution state
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct PersonaEvolverState {
-    pub last_evolution: Option<String>,
-    pub total_evolutions: usize,
-    pub pending_proposals: usize,
-    pub profile_enrichment_score: f32,
-}
-
-impl Default for PersonaEvolverState {
-    fn default() -> Self {
-        Self {
-            last_evolution: None,
-            total_evolutions: 0,
-            pending_proposals: 0,
-            profile_enrichment_score: 0.0,
-        }
-    }
-}
-
-// === Persona Evolver ===
-
-pub struct PersonaEvolver {
-    config: PersonaEvolverConfig,
-    state: PersonaEvolverState,
-    evolution_history: Vec<EvolutionResult>,
-}
-
-impl PersonaEvolver {
-    pub fn new(config: Option<PersonaEvolverConfig>) -> Self {
-        Self {
-            config: config.unwrap_or_default(),
-            state: PersonaEvolverState::default(),
-            evolution_history: Vec::new(),
-        }
-    }
-
-    /// Run evolution cycle for an agent
-    pub fn evolve(
-        &mut self,
-        agent_id: &str,
-        memories: &[MemoryEntryForAnalysis],
-        reflection_result: &ReflectionResult,
-        current_identity: &IdentityFiles,
-    ) -> EvolutionResult {
-        let mut profile_updates = Vec::new();
-        let mut proposals = Vec::new();
-        #[allow(unused_assignments)] // Overwritten by generate_insights below
-        let mut insights = Vec::new();
-
-        // 1. Extract user preferences and auto-update profile
-        if self.config.auto_profile_update {
-            profile_updates = self.extract_profile_updates(memories, current_identity);
-        }
-
-        // 2. Generate instruction refinement proposals
-        if self.config.enable_instruction_refinement {
-            let instruction_proposals = self.generate_instruction_proposals(
-                agent_id,
-                reflection_result,
-                current_identity,
-            );
-            proposals.extend(instruction_proposals);
-        }
-
-        // 3. Generate soul evolution proposals (rare, high bar)
-        if self.config.enable_soul_evolution {
-            let soul_proposals = self.generate_soul_proposals(
-                agent_id,
-                reflection_result,
-                current_identity,
-            );
-            proposals.extend(soul_proposals);
-        }
-
-        // 4. Generate insights
-        insights = self.generate_insights(memories, reflection_result);
-
-        // 5. Limit proposals
-        proposals.truncate(self.config.max_proposals_per_cycle);
-
-        // 6. Update state
-        let evolved = !profile_updates.is_empty() || !proposals.is_empty();
-        if evolved {
-            self.state.last_evolution = Some(Utc::now().to_rfc3339());
-            self.state.total_evolutions += 1;
-            self.state.pending_proposals += proposals.len();
-            self.state.profile_enrichment_score = self.calculate_profile_score(memories);
-        }
-
-        let result = EvolutionResult {
-            agent_id: agent_id.to_string(),
-            timestamp: Utc::now().to_rfc3339(),
-            profile_updates,
-            proposals,
-            insights,
-            evolved,
-        };
-
-        // Store in history
-        self.evolution_history.push(result.clone());
-        if self.evolution_history.len() > 20 {
-            self.evolution_history = self.evolution_history.split_off(10);
-        }
-
-        result
-    }
-
-    /// Extract profile updates from memory
-    fn extract_profile_updates(
-        &self,
-        memories: &[MemoryEntryForAnalysis],
-        current_identity: &IdentityFiles,
-    ) -> Vec<ProfileUpdate> {
-        let mut updates = Vec::new();
-
-        // Extract preferences
-        let preferences: Vec<_> = memories
-            .iter()
-            .filter(|m| m.memory_type == "preference")
-            .collect();
-
-        if preferences.len() >= self.config.min_preferences_for_update {
-            // Check if user_profile needs updating
-            let current_profile = &current_identity.user_profile;
-            let default_profile = "尚未收集到用户偏好信息";
-
-            if current_profile.contains(default_profile) || current_profile.len() < 100 {
-                // Build new profile from preferences
-                let mut sections = Vec::new();
-
-                // Group preferences by category
-                let mut categories: HashMap<String, Vec<String>> = HashMap::new();
-                for pref in &preferences {
-                    // Simple categorization based on keywords
-                    let category = self.categorize_preference(&pref.content);
-                    categories
-                        .entry(category)
-                        .or_insert_with(Vec::new)
-                        .push(pref.content.clone());
-                }
-
-                // Build sections
-                for (category, items) in categories {
-                    if !items.is_empty() {
-                        sections.push(format!("### {}\n{}", category, items.iter()
-                            .map(|i| format!("- {}", i))
-                            .collect::<Vec<_>>()
-                            .join("\n")));
-                    }
-                }
-
-                if !sections.is_empty() {
-                    let new_profile = format!("# 用户画像\n\n{}\n\n_自动生成于 {}_",
-                        sections.join("\n\n"),
-                        Utc::now().format("%Y-%m-%d")
-                    );
-
-                    updates.push(ProfileUpdate {
-                        section: "user_profile".to_string(),
-                        previous: current_profile.clone(),
-                        updated: new_profile,
-                        source: format!("{} 个偏好记忆", preferences.len()),
-                    });
-                }
-            }
-        }
-
-        updates
-    }
-
-    /// Categorize a preference
-    fn categorize_preference(&self, content: &str) -> String {
-        let content_lower = content.to_lowercase();
-
-        if content_lower.contains("语言") || content_lower.contains("沟通") || content_lower.contains("回复") {
-            "沟通偏好".to_string()
-        } else if content_lower.contains("技术") || content_lower.contains("框架") || content_lower.contains("工具") {
-            "技术栈".to_string()
-        } else if content_lower.contains("项目") || content_lower.contains("工作") || content_lower.contains("任务") {
-            "工作习惯".to_string()
-        } else if content_lower.contains("格式") || content_lower.contains("风格") || content_lower.contains("风格") {
-            "输出风格".to_string()
-        } else {
-            "其他偏好".to_string()
-        }
-    }
-
-    /// Generate instruction refinement proposals
-    fn generate_instruction_proposals(
-        &self,
-        agent_id: &str,
-        reflection_result: &ReflectionResult,
-        current_identity: &IdentityFiles,
-    ) -> Vec<EvolutionProposal> {
-        let mut proposals = Vec::new();
-
-        // Only propose if there are negative patterns
-        let negative_patterns: Vec<_> = reflection_result.patterns
-            .iter()
-            .filter(|p| matches!(p.sentiment, Sentiment::Negative))
-            .collect();
-
-        if negative_patterns.is_empty() {
-            return proposals;
-        }
-
-        // Check if instructions already contain these warnings
-        let current_instructions = &current_identity.instructions;
-
-        // Build proposed additions
-        let mut additions = Vec::new();
-        let mut evidence = Vec::new();
-
-        for pattern in &negative_patterns {
-            // Check if this pattern is already addressed
-            let key_phrase = &pattern.observation;
-            if !current_instructions.contains(key_phrase) {
-                additions.push(format!("- **注意事项**: {}", pattern.observation));
-                evidence.extend(pattern.evidence.clone());
-            }
-        }
-
-        if !additions.is_empty() {
-            let proposed = format!(
-                "{}\n\n## 🔄 自我改进建议\n\n{}\n\n_基于交互模式分析自动生成_",
-                current_instructions.trim_end(),
-                additions.join("\n")
-            );
-
-            proposals.push(EvolutionProposal {
-                id: format!("evo_inst_{}", Utc::now().timestamp()),
-                agent_id: agent_id.to_string(),
-                target_file: IdentityFile::Instructions,
-                change_type: EvolutionChangeType::InstructionAddition,
-                reason: format!(
-                    "基于 {} 个负面模式观察，建议在指令中增加自我改进提醒",
-                    negative_patterns.len()
-                ),
-                current_content: current_instructions.clone(),
-                proposed_content: proposed,
-                confidence: 0.7 + (negative_patterns.len() as f32 * 0.05).min(0.2),
-                evidence,
-                status: ProposalStatus::Pending,
-                created_at: Utc::now().to_rfc3339(),
-            });
-        }
-
-        // Check for improvement suggestions that could become instructions
-        for improvement in &reflection_result.improvements {
-            if current_instructions.contains(&improvement.suggestion) {
-                continue;
-            }
-
-            // High priority improvements become instruction proposals
-            if matches!(improvement.priority, super::reflection::Priority::High) {
-                proposals.push(EvolutionProposal {
-                    id: format!("evo_inst_{}_{}", Utc::now().timestamp(), rand_suffix()),
-                    agent_id: agent_id.to_string(),
-                    target_file: IdentityFile::Instructions,
-                    change_type: EvolutionChangeType::InstructionRefinement,
-                    reason: format!("高优先级改进建议: {}", improvement.area),
-                    current_content: current_instructions.clone(),
-                    proposed_content: format!(
-                        "{}\n\n### {}\n\n{}",
-                        current_instructions.trim_end(),
-                        improvement.area,
-                        improvement.suggestion
-                    ),
-                    confidence: 0.75,
-                    evidence: vec![improvement.suggestion.clone()],
-                    status: ProposalStatus::Pending,
-                    created_at: Utc::now().to_rfc3339(),
-                });
-            }
-        }
-
-        proposals
-    }
-
-    /// Generate soul evolution proposals (high bar)
-    fn generate_soul_proposals(
-        &self,
-        agent_id: &str,
-        reflection_result: &ReflectionResult,
-        current_identity: &IdentityFiles,
-    ) -> Vec<EvolutionProposal> {
-        let mut proposals = Vec::new();
-
-        // Soul evolution requires strong positive patterns
-        let positive_patterns: Vec<_> = reflection_result.patterns
-            .iter()
-            .filter(|p| matches!(p.sentiment, Sentiment::Positive))
-            .collect();
-
-        // Need at least 3 strong positive patterns
-        if positive_patterns.len() < 3 {
-            return proposals;
-        }
-
-        // Calculate overall confidence
-        let avg_frequency: usize = positive_patterns.iter()
-            .map(|p| p.frequency)
-            .sum::<usize>() / positive_patterns.len();
-
-        if avg_frequency < 5 {
-            return proposals;
-        }
-
-        // Build soul enhancement proposal
-        let current_soul = &current_identity.soul;
-        let mut traits = Vec::new();
-        let mut evidence = Vec::new();
-
-        for pattern in &positive_patterns {
-            // Extract trait from observation
-            if pattern.observation.contains("偏好") {
-                traits.push("深入理解用户偏好");
-            } else if pattern.observation.contains("经验") {
-                traits.push("持续积累经验教训");
-            } else if pattern.observation.contains("知识") {
-                traits.push("构建核心知识体系");
-            }
-            evidence.extend(pattern.evidence.clone());
-        }
-
-        if !traits.is_empty() {
-            let traits_section = traits.iter()
-                .map(|t| format!("- {}", t))
-                .collect::<Vec<_>>()
-                .join("\n");
-
-            let proposed = format!(
-                "{}\n\n## 🌱 成长特质\n\n{}\n\n_通过交互学习持续演化_",
-                current_soul.trim_end(),
-                traits_section
-            );
-
-            proposals.push(EvolutionProposal {
-                id: format!("evo_soul_{}", Utc::now().timestamp()),
-                agent_id: agent_id.to_string(),
-                target_file: IdentityFile::Soul,
-                change_type: EvolutionChangeType::TraitAddition,
-                reason: format!(
-                    "基于 {} 个强正面模式，建议增加成长特质",
-                    positive_patterns.len()
-                ),
-                current_content: current_soul.clone(),
-                proposed_content: proposed,
-                confidence: 0.85,
-                evidence,
-                status: ProposalStatus::Pending,
-                created_at: Utc::now().to_rfc3339(),
-            });
-        }
-
-        proposals
-    }
-
-    /// Generate evolution insights
-    fn generate_insights(
-        &self,
-        memories: &[MemoryEntryForAnalysis],
-        reflection_result: &ReflectionResult,
-    ) -> Vec<EvolutionInsight> {
-        let mut insights = Vec::new();
-
-        // Communication style insight
-        let comm_prefs: Vec<_> = memories
-            .iter()
-            .filter(|m| m.memory_type == "preference" &&
-                (m.content.contains("回复") || m.content.contains("语言") || m.content.contains("简洁")))
-            .collect();
-
-        if !comm_prefs.is_empty() {
-            insights.push(EvolutionInsight {
-                category: InsightCategory::CommunicationStyle,
-                observation: format!("用户有 {} 个沟通风格偏好", comm_prefs.len()),
-                recommendation: "在回复中应用这些偏好，提高用户满意度".to_string(),
-                confidence: 0.8,
-            });
-        }
-
-        // Technical expertise insight
-        let tech_memories: Vec<_> = memories
-            .iter()
-            .filter(|m| m.tags.iter().any(|t| t.contains("技术") || t.contains("代码")))
-            .collect();
-
-        if tech_memories.len() >= 5 {
-            insights.push(EvolutionInsight {
-                category: InsightCategory::TechnicalExpertise,
-                observation: format!("积累了 {} 个技术相关记忆", tech_memories.len()),
-                recommendation: "考虑构建技术知识图谱，提高检索效率".to_string(),
-                confidence: 0.7,
-            });
-        }
-
-        // Task efficiency insight from negative patterns
-        let has_task_issues = reflection_result.patterns
-            .iter()
-            .any(|p| p.observation.contains("任务") && matches!(p.sentiment, Sentiment::Negative));
-
-        if has_task_issues {
-            insights.push(EvolutionInsight {
-                category: InsightCategory::TaskEfficiency,
-                observation: "存在任务管理相关问题".to_string(),
-                recommendation: "建议增加任务跟踪和提醒机制".to_string(),
-                confidence: 0.75,
-            });
-        }
-
-        // Knowledge gap insight
-        let lesson_count = memories.iter()
-            .filter(|m| m.memory_type == "lesson")
-            .count();
-
-        if lesson_count > 10 {
-            insights.push(EvolutionInsight {
-                category: InsightCategory::KnowledgeGap,
-                observation: format!("已记录 {} 条经验教训", lesson_count),
-                recommendation: "定期回顾教训，避免重复错误".to_string(),
-                confidence: 0.8,
-            });
-        }
-
-        insights
-    }
-
-    /// Calculate profile enrichment score
-    fn calculate_profile_score(&self, memories: &[MemoryEntryForAnalysis]) -> f32 {
-        let pref_count = memories.iter().filter(|m| m.memory_type == "preference").count();
-        let fact_count = memories.iter().filter(|m| m.memory_type == "fact").count();
-
-        // Score based on diversity and quantity
-        let pref_score = (pref_count as f32 / 10.0).min(1.0) * 0.5;
-        let fact_score = (fact_count as f32 / 20.0).min(1.0) * 0.3;
-        let diversity = if pref_count > 0 && fact_count > 0 { 0.2 } else { 0.0 };
-
-        pref_score + fact_score + diversity
-    }
-
-    /// Get evolution history
-    pub fn get_history(&self, limit: usize) -> Vec<&EvolutionResult> {
-        self.evolution_history.iter().rev().take(limit).collect()
-    }
-
-    /// Get current state
-    pub fn get_state(&self) -> &PersonaEvolverState {
-        &self.state
-    }
-
-    /// Get configuration
-    pub fn get_config(&self) -> &PersonaEvolverConfig {
-        &self.config
-    }
-
-    /// Update configuration
-    pub fn update_config(&mut self, config: PersonaEvolverConfig) {
-        self.config = config;
-    }
-
-    /// Mark proposal as handled (approved/rejected)
-    pub fn proposal_handled(&mut self) {
-        if self.state.pending_proposals > 0 {
-            self.state.pending_proposals -= 1;
-        }
-    }
-}
-
-/// Generate random suffix
-fn rand_suffix() -> String {
-    use std::sync::atomic::{AtomicU64, Ordering};
-    static COUNTER: AtomicU64 = AtomicU64::new(0);
-    let count = COUNTER.fetch_add(1, Ordering::Relaxed);
-    format!("{:04x}", count % 0x10000)
-}
-
-// === Tauri Commands ===
-
-/// Type alias for Tauri state management (shared evolver handle)
-pub type PersonaEvolverStateHandle = Arc<Mutex<PersonaEvolver>>;
-
-/// Initialize persona evolver
-#[tauri::command]
-pub async fn persona_evolver_init(
-    config: Option<PersonaEvolverConfig>,
-    state: tauri::State<'_, PersonaEvolverStateHandle>,
-) -> Result<bool, String> {
-    let mut evolver = state.lock().await;
-    if let Some(cfg) = config {
-        evolver.update_config(cfg);
-    }
-    Ok(true)
-}
-
-/// Run evolution cycle
-#[tauri::command]
-pub async fn persona_evolve(
-    agent_id: String,
-    memories: Vec<MemoryEntryForAnalysis>,
-    reflection_state: tauri::State<'_, super::reflection::ReflectionEngineState>,
-    identity_state: tauri::State<'_, super::identity::IdentityManagerState>,
-    evolver_state: tauri::State<'_, PersonaEvolverStateHandle>,
-) -> Result<EvolutionResult, String> {
-    // 1. Run reflection first
-    let mut reflection = reflection_state.lock().await;
-    let reflection_result = reflection.reflect(&agent_id, &memories);
-    drop(reflection);
-
-    // 2. Get current identity
-    let mut identity = identity_state.lock().await;
-    let current_identity = identity.get_identity(&agent_id);
-    drop(identity);
-
-    // 3. Run evolution
-    let mut evolver = evolver_state.lock().await;
-    let result = evolver.evolve(&agent_id, &memories, &reflection_result, &current_identity);
-
-    // 4. Apply auto profile updates
-    if !result.profile_updates.is_empty() {
-        let mut identity = identity_state.lock().await;
-        for update in &result.profile_updates {
-            identity.update_user_profile(&agent_id, &update.updated);
-        }
-    }
-
-    Ok(result)
-}
-
-/// Get evolution history
-#[tauri::command]
-pub async fn persona_evolution_history(
-    limit: Option<usize>,
-    state: tauri::State<'_, PersonaEvolverStateHandle>,
-) -> Result<Vec<EvolutionResult>, String> {
-    let evolver = state.lock().await;
-    Ok(evolver.get_history(limit.unwrap_or(10)).into_iter().cloned().collect())
-}
-
-/// Get evolver state
-#[tauri::command]
-pub async fn persona_evolver_state(
-    state: tauri::State<'_, PersonaEvolverStateHandle>,
-) -> Result<PersonaEvolverState, String> {
-    let evolver = state.lock().await;
-    Ok(evolver.get_state().clone())
-}
-
-/// Get evolver config
-#[tauri::command]
-pub async fn persona_evolver_config(
-    state: tauri::State<'_, PersonaEvolverStateHandle>,
-) -> Result<PersonaEvolverConfig, String> {
-    let evolver = state.lock().await;
-    Ok(evolver.get_config().clone())
-}
-
-/// Update evolver config
-#[tauri::command]
-pub async fn persona_evolver_update_config(
-    config: PersonaEvolverConfig,
-    state: tauri::State<'_, PersonaEvolverStateHandle>,
-) -> Result<(), String> {
-    let mut evolver = state.lock().await;
-    evolver.update_config(config);
-    Ok(())
-}
-
-/// Apply evolution proposal (approve)
-#[tauri::command]
-pub async fn persona_apply_proposal(
-    proposal: EvolutionProposal,
-    identity_state: tauri::State<'_, super::identity::IdentityManagerState>,
-    evolver_state: tauri::State<'_, PersonaEvolverStateHandle>,
-) -> Result<IdentityFiles, String> {
-    // Apply the proposal through identity manager
-    let mut identity = identity_state.lock().await;
-
-    let result = match proposal.target_file {
-        IdentityFile::Soul => {
-            identity.update_file(&proposal.agent_id, "soul", &proposal.proposed_content)
-        }
-        IdentityFile::Instructions => {
-            identity.update_file(&proposal.agent_id, "instructions", &proposal.proposed_content)
-        }
-    };
-
-    if result.is_err() {
-        return result.map(|_| IdentityFiles {
-            soul: String::new(),
-            instructions: String::new(),
-            user_profile: String::new(),
-            heartbeat: None,
-        });
-    }
-
-    // Update evolver state
-    let mut evolver = evolver_state.lock().await;
-    evolver.proposal_handled();
-
-    // Return updated identity
-    Ok(identity.get_identity(&proposal.agent_id))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_evolve_empty() {
-        let mut evolver = PersonaEvolver::new(None);
-        let memories = vec![];
-        let reflection = ReflectionResult {
-            patterns: vec![],
-            improvements: vec![],
-            identity_proposals: vec![],
-            new_memories: 0,
-            timestamp: Utc::now().to_rfc3339(),
-        };
-        let identity = IdentityFiles {
-            soul: "Test soul".to_string(),
-            instructions: "Test instructions".to_string(),
-            user_profile: "Test profile".to_string(),
-            heartbeat: None,
-        };
-
-        let result = evolver.evolve("test-agent", &memories, &reflection, &identity);
-        assert!(!result.evolved);
-    }
-
-    #[test]
-    fn test_profile_update() {
-        let mut evolver = PersonaEvolver::new(None);
-        let memories = vec![
-            MemoryEntryForAnalysis {
-                memory_type: "preference".to_string(),
-                content: "喜欢简洁的回复".to_string(),
-                importance: 7,
-                access_count: 3,
-                tags: vec!["沟通".to_string()],
-            },
-            MemoryEntryForAnalysis {
-                memory_type: "preference".to_string(),
-                content: "使用中文".to_string(),
-                importance: 8,
-                access_count: 5,
-                tags: vec!["语言".to_string()],
-            },
-            MemoryEntryForAnalysis {
-                memory_type: "preference".to_string(),
-                content: "代码使用 TypeScript".to_string(),
-                importance: 7,
-                access_count: 2,
-                tags: vec!["技术".to_string()],
-            },
-        ];
-
-        let identity = IdentityFiles {
-            soul: "Test".to_string(),
-            instructions: "Test".to_string(),
-            user_profile: "尚未收集到用户偏好信息".to_string(),
-            heartbeat: None,
-        };
-
-        let updates = evolver.extract_profile_updates(&memories, &identity);
-        assert!(!updates.is_empty());
-        assert!(updates[0].updated.contains("用户画像"));
-    }
-}

desktop/src-tauri/src/intelligence/recommender.rs

@@ -1,519 +0,0 @@
-//! Workflow Recommender - Generates workflow recommendations from detected patterns
-//!
-//! This module analyzes behavior patterns and generates actionable workflow recommendations.
-//! It maps detected patterns to pipelines and provides confidence scoring.
-//!
-//! NOTE: Some methods are reserved for future integration with the UI.
-
-#![allow(dead_code)] // Methods reserved for future UI integration
-
-use chrono::Utc;
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use uuid::Uuid;
-
-use super::mesh::WorkflowRecommendation;
-use super::pattern_detector::{BehaviorPattern, PatternType};
-
-// === Types ===
-
-/// Recommendation rule that maps patterns to pipelines
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct RecommendationRule {
-    /// Rule identifier
-    pub id: String,
-    /// Pattern types this rule matches
-    pub pattern_types: Vec<String>,
-    /// Pipeline to recommend
-    pub pipeline_id: String,
-    /// Base confidence for this rule
-    pub base_confidence: f32,
-    /// Human-readable description
-    pub description: String,
-    /// Input mappings (pattern context field -> pipeline input)
-    pub input_mappings: HashMap<String, String>,
-    /// Priority (higher = more important)
-    pub priority: u8,
-}
-
-/// Recommender configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct RecommenderConfig {
-    /// Minimum confidence threshold
-    pub min_confidence: f32,
-    /// Maximum recommendations to generate
-    pub max_recommendations: usize,
-    /// Enable rule-based recommendations
-    pub enable_rules: bool,
-    /// Enable pattern-based recommendations
-    pub enable_patterns: bool,
-}
-
-impl Default for RecommenderConfig {
-    fn default() -> Self {
-        Self {
-            min_confidence: 0.5,
-            max_recommendations: 10,
-            enable_rules: true,
-            enable_patterns: true,
-        }
-    }
-}
-
-// === Workflow Recommender ===
-
-/// Workflow recommendation engine
-pub struct WorkflowRecommender {
-    /// Configuration
-    config: RecommenderConfig,
-    /// Recommendation rules
-    rules: Vec<RecommendationRule>,
-    /// Pipeline registry (pipeline_id -> metadata)
-    #[allow(dead_code)] // Reserved for future pipeline-based recommendations
-    pipeline_registry: HashMap<String, PipelineMetadata>,
-    /// Generated recommendations cache
-    recommendations_cache: Vec<WorkflowRecommendation>,
-}
-
-/// Metadata about a registered pipeline
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct PipelineMetadata {
-    pub id: String,
-    pub name: String,
-    pub description: Option<String>,
-    pub tags: Vec<String>,
-    pub input_schema: Option<serde_json::Value>,
-}
-
-impl WorkflowRecommender {
-    /// Create a new workflow recommender
-    pub fn new(config: Option<RecommenderConfig>) -> Self {
-        let mut recommender = Self {
-            config: config.unwrap_or_default(),
-            rules: Vec::new(),
-            pipeline_registry: HashMap::new(),
-            recommendations_cache: Vec::new(),
-        };
-
-        // Initialize with built-in rules
-        recommender.initialize_default_rules();
-        recommender
-    }
-
-    /// Initialize default recommendation rules
-    fn initialize_default_rules(&mut self) {
-        // Rule: Research + Analysis -> Report Generation
-        self.rules.push(RecommendationRule {
-            id: "rule_research_report".to_string(),
-            pattern_types: vec!["SkillCombination".to_string()],
-            pipeline_id: "research-report-generator".to_string(),
-            base_confidence: 0.7,
-            description: "Generate comprehensive research report".to_string(),
-            input_mappings: HashMap::new(),
-            priority: 8,
-        });
-
-        // Rule: Code + Test -> Quality Check Pipeline
-        self.rules.push(RecommendationRule {
-            id: "rule_code_quality".to_string(),
-            pattern_types: vec!["SkillCombination".to_string()],
-            pipeline_id: "code-quality-check".to_string(),
-            base_confidence: 0.75,
-            description: "Run code quality and test pipeline".to_string(),
-            input_mappings: HashMap::new(),
-            priority: 7,
-        });
-
-        // Rule: Daily morning -> Daily briefing
-        self.rules.push(RecommendationRule {
-            id: "rule_morning_briefing".to_string(),
-            pattern_types: vec!["TemporalTrigger".to_string()],
-            pipeline_id: "daily-briefing".to_string(),
-            base_confidence: 0.6,
-            description: "Generate daily briefing".to_string(),
-            input_mappings: HashMap::new(),
-            priority: 5,
-        });
-
-        // Rule: Task + Deadline -> Priority sort
-        self.rules.push(RecommendationRule {
-            id: "rule_task_priority".to_string(),
-            pattern_types: vec!["InputPattern".to_string()],
-            pipeline_id: "task-priority-sorter".to_string(),
-            base_confidence: 0.65,
-            description: "Sort and prioritize tasks".to_string(),
-            input_mappings: HashMap::new(),
-            priority: 6,
-        });
-    }
-
-    /// Generate recommendations from detected patterns
-    pub fn recommend(&self, patterns: &[&BehaviorPattern]) -> Vec<WorkflowRecommendation> {
-        let mut recommendations = Vec::new();
-
-        if patterns.is_empty() {
-            return recommendations;
-        }
-
-        // Rule-based recommendations
-        if self.config.enable_rules {
-            for rule in &self.rules {
-                if let Some(rec) = self.apply_rule(rule, patterns) {
-                    if rec.confidence >= self.config.min_confidence {
-                        recommendations.push(rec);
-                    }
-                }
-            }
-        }
-
-        // Pattern-based recommendations (direct mapping)
-        if self.config.enable_patterns {
-            for pattern in patterns {
-                if let Some(rec) = self.pattern_to_recommendation(pattern) {
-                    if rec.confidence >= self.config.min_confidence {
-                        recommendations.push(rec);
-                    }
-                }
-            }
-        }
-
-        // Sort by confidence (descending) and priority
-        recommendations.sort_by(|a, b| {
-            let priority_diff = self.get_priority_for_recommendation(b)
-                .cmp(&self.get_priority_for_recommendation(a));
-            if priority_diff != std::cmp::Ordering::Equal {
-                return priority_diff;
-            }
-            b.confidence.partial_cmp(&a.confidence).unwrap()
-        });
-
-        // Limit recommendations
-        recommendations.truncate(self.config.max_recommendations);
-
-        recommendations
-    }
-
-    /// Apply a recommendation rule to patterns
-    fn apply_rule(
-        &self,
-        rule: &RecommendationRule,
-        patterns: &[&BehaviorPattern],
-    ) -> Option<WorkflowRecommendation> {
-        let mut matched_patterns: Vec<String> = Vec::new();
-        let mut total_confidence = 0.0;
-        let mut match_count = 0;
-
-        for pattern in patterns {
-            let pattern_type_name = self.get_pattern_type_name(&pattern.pattern_type);
-
-            if rule.pattern_types.contains(&pattern_type_name) {
-                matched_patterns.push(pattern.id.clone());
-                total_confidence += pattern.confidence;
-                match_count += 1;
-            }
-        }
-
-        if matched_patterns.is_empty() {
-            return None;
-        }
-
-        // Calculate combined confidence
-        let avg_pattern_confidence = total_confidence / match_count as f32;
-        let final_confidence = (rule.base_confidence * 0.6 + avg_pattern_confidence * 0.4).min(1.0);
-
-        // Build suggested inputs from pattern context
-        let suggested_inputs = self.build_suggested_inputs(&matched_patterns, patterns, rule);
-
-        Some(WorkflowRecommendation {
-            id: format!("rec_{}", Uuid::new_v4()),
-            pipeline_id: rule.pipeline_id.clone(),
-            confidence: final_confidence,
-            reason: rule.description.clone(),
-            suggested_inputs,
-            patterns_matched: matched_patterns,
-            timestamp: Utc::now(),
-        })
-    }
-
-    /// Convert a single pattern to a recommendation
-    fn pattern_to_recommendation(&self, pattern: &BehaviorPattern) -> Option<WorkflowRecommendation> {
-        let (pipeline_id, reason) = match &pattern.pattern_type {
-            PatternType::TaskPipelineMapping { task_type, pipeline_id } => {
-                (pipeline_id.clone(), format!("Detected task type: {}", task_type))
-            }
-            PatternType::SkillCombination { skill_ids } => {
-                // Find a pipeline that uses these skills
-                let pipeline_id = self.find_pipeline_for_skills(skill_ids)?;
-                (pipeline_id, format!("Skills often used together: {}", skill_ids.join(", ")))
-            }
-            PatternType::InputPattern { keywords, intent } => {
-                // Find a pipeline for this intent
-                let pipeline_id = self.find_pipeline_for_intent(intent)?;
-                (pipeline_id, format!("Intent detected: {} ({})", intent, keywords.join(", ")))
-            }
-            PatternType::TemporalTrigger { hand_id, time_pattern } => {
-                (format!("scheduled_{}", hand_id), format!("Scheduled at: {}", time_pattern))
-            }
-        };
-
-        Some(WorkflowRecommendation {
-            id: format!("rec_{}", Uuid::new_v4()),
-            pipeline_id,
-            confidence: pattern.confidence,
-            reason,
-            suggested_inputs: HashMap::new(),
-            patterns_matched: vec![pattern.id.clone()],
-            timestamp: Utc::now(),
-        })
-    }
-
-    /// Get string name for pattern type
-    fn get_pattern_type_name(&self, pattern_type: &PatternType) -> String {
-        match pattern_type {
-            PatternType::SkillCombination { .. } => "SkillCombination".to_string(),
-            PatternType::TemporalTrigger { .. } => "TemporalTrigger".to_string(),
-            PatternType::TaskPipelineMapping { .. } => "TaskPipelineMapping".to_string(),
-            PatternType::InputPattern { .. } => "InputPattern".to_string(),
-        }
-    }
-
-    /// Get priority for a recommendation
-    fn get_priority_for_recommendation(&self, rec: &WorkflowRecommendation) -> u8 {
-        self.rules
-            .iter()
-            .find(|r| r.pipeline_id == rec.pipeline_id)
-            .map(|r| r.priority)
-            .unwrap_or(5)
-    }
-
-    /// Build suggested inputs from patterns and rule
-    fn build_suggested_inputs(
-        &self,
-        matched_pattern_ids: &[String],
-        patterns: &[&BehaviorPattern],
-        rule: &RecommendationRule,
-    ) -> HashMap<String, serde_json::Value> {
-        let mut inputs = HashMap::new();
-
-        for pattern_id in matched_pattern_ids {
-            if let Some(pattern) = patterns.iter().find(|p| p.id == *pattern_id) {
-                // Add context-based inputs
-                if let Some(ref topics) = pattern.context.recent_topics {
-                    if !topics.is_empty() {
-                        inputs.insert(
-                            "topics".to_string(),
-                            serde_json::Value::Array(
-                                topics.iter().map(|t| serde_json::Value::String(t.clone())).collect()
-                            ),
-                        );
-                    }
-                }
-
-                if let Some(ref intent) = pattern.context.intent {
-                    inputs.insert("intent".to_string(), serde_json::Value::String(intent.clone()));
-                }
-
-                // Add pattern-specific inputs
-                match &pattern.pattern_type {
-                    PatternType::InputPattern { keywords, .. } => {
-                        inputs.insert(
-                            "keywords".to_string(),
-                            serde_json::Value::Array(
-                                keywords.iter().map(|k| serde_json::Value::String(k.clone())).collect()
-                            ),
-                        );
-                    }
-                    PatternType::SkillCombination { skill_ids } => {
-                        inputs.insert(
-                            "skills".to_string(),
-                            serde_json::Value::Array(
-                                skill_ids.iter().map(|s| serde_json::Value::String(s.clone())).collect()
-                            ),
-                        );
-                    }
-                    _ => {}
-                }
-            }
-        }
-
-        // Apply rule mappings
-        for (source, target) in &rule.input_mappings {
-            if let Some(value) = inputs.get(source) {
-                inputs.insert(target.clone(), value.clone());
-            }
-        }
-
-        inputs
-    }
-
-    /// Find a pipeline that uses the given skills
-    fn find_pipeline_for_skills(&self, skill_ids: &[String]) -> Option<String> {
-        // In production, this would query the pipeline registry
-        // For now, return a default
-        if skill_ids.len() >= 2 {
-            Some("skill-orchestration-pipeline".to_string())
-        } else {
-            None
-        }
-    }
-
-    /// Find a pipeline for an intent
-    fn find_pipeline_for_intent(&self, intent: &str) -> Option<String> {
-        // Map common intents to pipelines
-        match intent {
-            "research" => Some("research-pipeline".to_string()),
-            "analysis" => Some("analysis-pipeline".to_string()),
-            "report" => Some("report-generation".to_string()),
-            "code" => Some("code-generation".to_string()),
-            "task" | "tasks" => Some("task-management".to_string()),
-            _ => None,
-        }
-    }
-
-    /// Register a pipeline
-    pub fn register_pipeline(&mut self, metadata: PipelineMetadata) {
-        self.pipeline_registry.insert(metadata.id.clone(), metadata);
-    }
-
-    /// Unregister a pipeline
-    pub fn unregister_pipeline(&mut self, pipeline_id: &str) {
-        self.pipeline_registry.remove(pipeline_id);
-    }
-
-    /// Add a custom recommendation rule
-    pub fn add_rule(&mut self, rule: RecommendationRule) {
-        self.rules.push(rule);
-        // Sort by priority
-        self.rules.sort_by(|a, b| b.priority.cmp(&a.priority));
-    }
-
-    /// Remove a rule
-    pub fn remove_rule(&mut self, rule_id: &str) {
-        self.rules.retain(|r| r.id != rule_id);
-    }
-
-    /// Get all rules
-    pub fn get_rules(&self) -> &[RecommendationRule] {
-        &self.rules
-    }
-
-    /// Update configuration
-    pub fn update_config(&mut self, config: RecommenderConfig) {
-        self.config = config;
-    }
-
-    /// Get configuration
-    pub fn get_config(&self) -> &RecommenderConfig {
-        &self.config
-    }
-
-    /// Get recommendation count
-    pub fn recommendation_count(&self) -> usize {
-        self.recommendations_cache.len()
-    }
-
-    /// Clear recommendation cache
-    pub fn clear_cache(&mut self) {
-        self.recommendations_cache.clear();
-    }
-
-    /// Accept a recommendation (remove from cache and return it)
-    /// Returns the accepted recommendation if found
-    pub fn accept_recommendation(&mut self, recommendation_id: &str) -> Option<WorkflowRecommendation> {
-        if let Some(pos) = self.recommendations_cache.iter().position(|r| r.id == recommendation_id) {
-            Some(self.recommendations_cache.remove(pos))
-        } else {
-            None
-        }
-    }
-
-    /// Dismiss a recommendation (remove from cache without acting on it)
-    /// Returns true if the recommendation was found and dismissed
-    pub fn dismiss_recommendation(&mut self, recommendation_id: &str) -> bool {
-        if let Some(pos) = self.recommendations_cache.iter().position(|r| r.id == recommendation_id) {
-            self.recommendations_cache.remove(pos);
-            true
-        } else {
-            false
-        }
-    }
-
-    /// Get a recommendation by ID
-    pub fn get_recommendation(&self, recommendation_id: &str) -> Option<&WorkflowRecommendation> {
-        self.recommendations_cache.iter().find(|r| r.id == recommendation_id)
-    }
-
-    /// Load recommendations from file
-    pub fn load_from_file(&mut self, path: &str) -> Result<(), String> {
-        let content = std::fs::read_to_string(path)
-            .map_err(|e| format!("Failed to read file: {}", e))?;
-
-        let recommendations: Vec<WorkflowRecommendation> = serde_json::from_str(&content)
-            .map_err(|e| format!("Failed to parse recommendations: {}", e))?;
-
-        self.recommendations_cache = recommendations;
-        Ok(())
-    }
-
-    /// Save recommendations to file
-    pub fn save_to_file(&self, path: &str) -> Result<(), String> {
-        let content = serde_json::to_string_pretty(&self.recommendations_cache)
-            .map_err(|e| format!("Failed to serialize recommendations: {}", e))?;
-
-        std::fs::write(path, content)
-            .map_err(|e| format!("Failed to write file: {}", e))?;
-
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_recommender_creation() {
-        let recommender = WorkflowRecommender::new(None);
-        assert!(!recommender.get_rules().is_empty());
-    }
-
-    #[test]
-    fn test_recommend_from_empty_patterns() {
-        let recommender = WorkflowRecommender::new(None);
-        let recommendations = recommender.recommend(&[]);
-        assert!(recommendations.is_empty());
-    }
-
-    #[test]
-    fn test_rule_priority() {
-        let mut recommender = WorkflowRecommender::new(None);
-
-        recommender.add_rule(RecommendationRule {
-            id: "high_priority".to_string(),
-            pattern_types: vec!["SkillCombination".to_string()],
-            pipeline_id: "important-pipeline".to_string(),
-            base_confidence: 0.9,
-            description: "High priority rule".to_string(),
-            input_mappings: HashMap::new(),
-            priority: 10,
-        });
-
-        let rules = recommender.get_rules();
-        assert!(rules.iter().any(|r| r.priority == 10));
-    }
-
-    #[test]
-    fn test_register_pipeline() {
-        let mut recommender = WorkflowRecommender::new(None);
-
-        recommender.register_pipeline(PipelineMetadata {
-            id: "test-pipeline".to_string(),
-            name: "Test Pipeline".to_string(),
-            description: Some("A test pipeline".to_string()),
-            tags: vec!["test".to_string()],
-            input_schema: None,
-        });
-
-        assert!(recommender.pipeline_registry.contains_key("test-pipeline"));
-    }
-}

desktop/src-tauri/src/intelligence/trigger_evaluator.rs

@@ -1,845 +0,0 @@
-//! Trigger Evaluator - Evaluates context-aware triggers for Hands
-//!
-//! This module extends the basic trigger system with semantic matching:
-//! Supports MemoryQuery, ContextCondition, and IdentityState triggers.
-//!
-//! NOTE: This module is not yet integrated into the main application.
-//! Components are still being developed and will be connected in a future release.
-
-#![allow(dead_code)] // Module not yet integrated - components under development
-
-use std::sync::Arc;
-use std::pin::Pin;
-use tokio::sync::Mutex;
-use chrono::{DateTime, Utc, Timelike, Datelike};
-use serde::{Deserialize, Serialize};
-use serde_json::Value as JsonValue;
-use zclaw_memory::MemoryStore;
-
-// === ReDoS Protection Constants ===
-
-/// Maximum allowed length for regex patterns (prevents memory exhaustion)
-const MAX_REGEX_PATTERN_LENGTH: usize = 500;
-
-/// Maximum allowed nesting depth for regex quantifiers/groups
-const MAX_REGEX_NESTING_DEPTH: usize = 10;
-
-/// Error type for regex validation failures
-#[derive(Debug, Clone, PartialEq)]
-pub enum RegexValidationError {
-    /// Pattern exceeds maximum length
-    TooLong { length: usize, max: usize },
-    /// Pattern has excessive nesting depth
-    TooDeeplyNested { depth: usize, max: usize },
-    /// Pattern contains dangerous ReDoS-prone constructs
-    DangerousPattern(String),
-    /// Invalid regex syntax
-    InvalidSyntax(String),
-}
-
-impl std::fmt::Display for RegexValidationError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            RegexValidationError::TooLong { length, max } => {
-                write!(f, "Regex pattern too long: {} bytes (max: {})", length, max)
-            }
-            RegexValidationError::TooDeeplyNested { depth, max } => {
-                write!(f, "Regex pattern too deeply nested: {} levels (max: {})", depth, max)
-            }
-            RegexValidationError::DangerousPattern(reason) => {
-                write!(f, "Dangerous regex pattern detected: {}", reason)
-            }
-            RegexValidationError::InvalidSyntax(err) => {
-                write!(f, "Invalid regex syntax: {}", err)
-            }
-        }
-    }
-}
-
-impl std::error::Error for RegexValidationError {}
-
-/// Validate a regex pattern for ReDoS safety
-///
-/// This function checks for:
-/// 1. Pattern length (prevents memory exhaustion)
-/// 2. Nesting depth (prevents exponential backtracking)
-/// 3. Dangerous patterns (nested quantifiers on overlapping character classes)
-fn validate_regex_pattern(pattern: &str) -> Result<(), RegexValidationError> {
-    // Check length
-    if pattern.len() > MAX_REGEX_PATTERN_LENGTH {
-        return Err(RegexValidationError::TooLong {
-            length: pattern.len(),
-            max: MAX_REGEX_PATTERN_LENGTH,
-        });
-    }
-
-    // Check nesting depth by counting unescaped parentheses and brackets
-    let nesting_depth = calculate_nesting_depth(pattern);
-    if nesting_depth > MAX_REGEX_NESTING_DEPTH {
-        return Err(RegexValidationError::TooDeeplyNested {
-            depth: nesting_depth,
-            max: MAX_REGEX_NESTING_DEPTH,
-        });
-    }
-
-    // Check for dangerous ReDoS patterns:
-    // - Nested quantifiers on overlapping patterns like (a+)+
-    // - Alternation with overlapping patterns like (a|a)+
-    if contains_dangerous_redos_pattern(pattern) {
-        return Err(RegexValidationError::DangerousPattern(
-            "Pattern contains nested quantifiers on overlapping character classes".to_string()
-        ));
-    }
-
-    Ok(())
-}
-
-/// Calculate the maximum nesting depth of groups in a regex pattern
-fn calculate_nesting_depth(pattern: &str) -> usize {
-    let chars: Vec<char> = pattern.chars().collect();
-    let mut max_depth = 0;
-    let mut current_depth = 0;
-    let mut i = 0;
-
-    while i < chars.len() {
-        let c = chars[i];
-
-        // Check for escape sequence
-        if c == '\\' && i + 1 < chars.len() {
-            // Skip the escaped character
-            i += 2;
-            continue;
-        }
-
-        // Handle character classes [...]
-        if c == '[' {
-            current_depth += 1;
-            max_depth = max_depth.max(current_depth);
-            // Find matching ]
-            i += 1;
-            while i < chars.len() {
-                if chars[i] == '\\' && i + 1 < chars.len() {
-                    i += 2;
-                    continue;
-                }
-                if chars[i] == ']' {
-                    current_depth -= 1;
-                    break;
-                }
-                i += 1;
-            }
-        }
-        // Handle groups (...)
-        else if c == '(' {
-            // Skip non-capturing groups and lookaheads for simplicity
-            // (?:...), (?=...), (?!...), (?<=...), (?<!...), (?P<name>...)
-            current_depth += 1;
-            max_depth = max_depth.max(current_depth);
-        } else if c == ')' {
-            if current_depth > 0 {
-                current_depth -= 1;
-            }
-        }
-
-        i += 1;
-    }
-
-    max_depth
-}
-
-/// Check for dangerous ReDoS patterns
-///
-/// Detects patterns like:
-/// - (a+)+ - nested quantifiers
-/// - (a*)+ - nested quantifiers
-/// - (a+)* - nested quantifiers
-/// - (.*)* - nested quantifiers on wildcard
-fn contains_dangerous_redos_pattern(pattern: &str) -> bool {
-    let chars: Vec<char> = pattern.chars().collect();
-    let mut i = 0;
-
-    while i < chars.len() {
-        // Look for quantified patterns followed by another quantifier
-        if i > 0 {
-            let prev = chars[i - 1];
-
-            // Check if current char is a quantifier
-            if matches!(chars[i], '+' | '*' | '?') {
-                // Look back to see what's being quantified
-                if prev == ')' {
-                    // Find the matching opening paren
-                    let mut depth = 1;
-                    let mut j = i - 2;
-                    while j > 0 && depth > 0 {
-                        if chars[j] == ')' {
-                            depth += 1;
-                        } else if chars[j] == '(' {
-                            depth -= 1;
-                        } else if chars[j] == '\\' && j > 0 {
-                            j -= 1; // Skip escaped char
-                        }
-                        j -= 1;
-                    }
-
-                    // Check if the group content ends with a quantifier
-                    // This would indicate nested quantification
-                    // Note: j is usize, so we don't check >= 0 (always true)
-                    // The loop above ensures j is valid if depth reached 0
-                    let mut k = i - 2;
-                    while k > j + 1 {
-                        if chars[k] == '\\' && k > 0 {
-                            k -= 1;
-                        } else if matches!(chars[k], '+' | '*' | '?') {
-                            // Found nested quantifier
-                            return true;
-                        } else if chars[k] == ')' {
-                            // Skip nested groups
-                            let mut nested_depth = 1;
-                            k -= 1;
-                            while k > j + 1 && nested_depth > 0 {
-                                if chars[k] == ')' {
-                                    nested_depth += 1;
-                                } else if chars[k] == '(' {
-                                    nested_depth -= 1;
-                                } else if chars[k] == '\\' && k > 0 {
-                                    k -= 1;
-                                }
-                                k -= 1;
-                            }
-                        }
-                        k -= 1;
-                    }
-                }
-            }
-        }
-        i += 1;
-    }
-
-    false
-}
-
-/// Safely compile a regex pattern with ReDoS protection
-///
-/// This function validates the pattern for safety before compilation.
-/// Returns a compiled regex or an error describing why validation failed.
-pub fn compile_safe_regex(pattern: &str) -> Result<regex::Regex, RegexValidationError> {
-    validate_regex_pattern(pattern)?;
-
-    regex::Regex::new(pattern).map_err(|e| RegexValidationError::InvalidSyntax(e.to_string()))
-}
-
-// === Extended Trigger Types ===
-
-/// Memory query trigger configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct MemoryQueryConfig {
-    /// Memory type to filter (e.g., "task", "preference")
-    pub memory_type: Option<String>,
-    /// Content pattern to match (regex or substring)
-    pub content_pattern: String,
-    /// Minimum count of matching memories
-    pub min_count: usize,
-    /// Minimum importance threshold
-    pub min_importance: Option<i32>,
-    /// Time window for memories (hours)
-    pub time_window_hours: Option<u64>,
-}
-
-/// Context condition configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ContextConditionConfig {
-    /// Conditions to check
-    pub conditions: Vec<ContextConditionClause>,
-    /// How to combine conditions (All, Any, None)
-    pub combination: ConditionCombination,
-}
-
-/// Single context condition clause
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ContextConditionClause {
-    /// Field to check
-    pub field: ContextField,
-    /// Comparison operator
-    pub operator: ComparisonOperator,
-    /// Value to compare against
-    pub value: JsonValue,
-}
-
-/// Context fields that can be checked
-#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
-pub enum ContextField {
-    /// Current hour of day (0-23)
-    TimeOfDay,
-    /// Day of week (0=Monday, 6=Sunday)
-    DayOfWeek,
-    /// Currently active project (if any)
-    ActiveProject,
-    /// Topics discussed recently
-    RecentTopic,
-    /// Number of pending tasks
-    PendingTasks,
-    /// Count of memories in storage
-    MemoryCount,
-    /// Hours since last interaction
-    LastInteractionHours,
-    /// Current conversation intent
-    ConversationIntent,
-}
-
-/// Comparison operators for context conditions
-#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
-pub enum ComparisonOperator {
-    Equals,
-    NotEquals,
-    Contains,
-    GreaterThan,
-    LessThan,
-    Exists,
-    NotExists,
-    Matches, // regex match
-}
-
-/// How to combine multiple conditions
-#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
-pub enum ConditionCombination {
-    /// All conditions must true
-    All,
-    /// Any one condition being true is enough
-    Any,
-    /// None of the conditions should be true
-    None,
-}
-
-/// Identity state trigger configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct IdentityStateConfig {
-    /// Identity file to check
-    pub file: IdentityFile,
-    /// Content pattern to match (regex)
-    pub content_pattern: Option<String>,
-    /// Trigger on any change to the file
-    pub any_change: bool,
-}
-
-/// Identity files that can be monitored
-#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
-pub enum IdentityFile {
-    Soul,
-    Instructions,
-    User,
-}
-
-/// Composite trigger configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct CompositeTriggerConfig {
-    /// Sub-triggers to combine
-    pub triggers: Vec<ExtendedTriggerType>,
-    /// How to combine results
-    pub combination: ConditionCombination,
-}
-
-/// Extended trigger type that includes semantic triggers
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(tag = "type", rename_all = "snake_case")]
-pub enum ExtendedTriggerType {
-    /// Standard interval trigger
-    Interval {
-        /// Interval in seconds
-        seconds: u64,
-    },
-    /// Time-of-day trigger
-    TimeOfDay {
-        /// Hour (0-23)
-        hour: u8,
-        /// Optional minute (0-59)
-        minute: Option<u8>,
-    },
-    /// Memory query trigger
-    MemoryQuery(MemoryQueryConfig),
-    /// Context condition trigger
-    ContextCondition(ContextConditionConfig),
-    /// Identity state trigger
-    IdentityState(IdentityStateConfig),
-    /// Composite trigger
-    Composite(CompositeTriggerConfig),
-}
-
-// === Trigger Evaluator ===
-
-/// Evaluator for context-aware triggers
-pub struct TriggerEvaluator {
-    /// Memory store for memory queries
-    memory_store: Arc<MemoryStore>,
-    /// Identity manager for identity triggers
-    identity_manager: Arc<Mutex<super::identity::AgentIdentityManager>>,
-    /// Heartbeat engine for context
-    heartbeat_engine: Arc<Mutex<super::heartbeat::HeartbeatEngine>>,
-    /// Cached context data
-    context_cache: Arc<Mutex<TriggerContextCache>>,
-}
-
-/// Cached context for trigger evaluation
-#[derive(Debug, Clone, Default)]
-pub struct TriggerContextCache {
-    /// Last known active project
-    pub active_project: Option<String>,
-    /// Recent topics discussed
-    pub recent_topics: Vec<String>,
-    /// Last conversation intent
-    pub conversation_intent: Option<String>,
-    /// Last update time
-    pub last_updated: Option<DateTime<Utc>>,
-}
-
-impl TriggerEvaluator {
-    /// Create a new trigger evaluator
-    pub fn new(
-        memory_store: Arc<MemoryStore>,
-        identity_manager: Arc<Mutex<super::identity::AgentIdentityManager>>,
-        heartbeat_engine: Arc<Mutex<super::heartbeat::HeartbeatEngine>>,
-    ) -> Self {
-        Self {
-            memory_store,
-            identity_manager,
-            heartbeat_engine,
-            context_cache: Arc::new(Mutex::new(TriggerContextCache::default())),
-        }
-    }
-
-    /// Evaluate a trigger
-    pub async fn evaluate(
-        &self,
-        trigger: &ExtendedTriggerType,
-        agent_id: &str,
-    ) -> Result<bool, String> {
-        match trigger {
-            ExtendedTriggerType::Interval { .. } => Ok(true),
-            ExtendedTriggerType::TimeOfDay { hour, minute } => {
-                let now = Utc::now();
-                let current_hour = now.hour() as u8;
-                let current_minute = now.minute() as u8;
-
-                if current_hour != *hour {
-                    return Ok(false);
-                }
-
-                if let Some(min) = minute {
-                    if current_minute != *min {
-                        return Ok(false);
-                    }
-                }
-
-                Ok(true)
-            }
-            ExtendedTriggerType::MemoryQuery(config) => {
-                self.evaluate_memory_query(config, agent_id).await
-            }
-            ExtendedTriggerType::ContextCondition(config) => {
-                self.evaluate_context_condition(config, agent_id).await
-            }
-            ExtendedTriggerType::IdentityState(config) => {
-                self.evaluate_identity_state(config, agent_id).await
-            }
-            ExtendedTriggerType::Composite(config) => {
-                self.evaluate_composite(config, agent_id, None).await
-            }
-        }
-    }
-
-    /// Evaluate memory query trigger
-    async fn evaluate_memory_query(
-        &self,
-        config: &MemoryQueryConfig,
-        _agent_id: &str,
-    ) -> Result<bool, String> {
-        // TODO: Implement proper memory search when MemoryStore supports it
-        // For now, use KV store to check if we have enough keys matching pattern
-        // This is a simplified implementation
-
-        // Memory search is not fully implemented in current MemoryStore
-        // Return false to indicate no matches until proper search is available
-        tracing::warn!(
-            pattern = %config.content_pattern,
-            min_count = config.min_count,
-            "Memory query trigger evaluation not fully implemented"
-        );
-
-        Ok(false)
-    }
-
-    /// Evaluate context condition trigger
-    async fn evaluate_context_condition(
-        &self,
-        config: &ContextConditionConfig,
-        agent_id: &str,
-    ) -> Result<bool, String> {
-        let context = self.get_cached_context(agent_id).await;
-
-        let mut results = Vec::new();
-
-        for condition in &config.conditions {
-            let result = self.evaluate_condition_clause(condition, &context);
-            results.push(result);
-        }
-
-        // Combine results based on combination mode
-        let final_result = match config.combination {
-            ConditionCombination::All => results.iter().all(|r| *r),
-            ConditionCombination::Any => results.iter().any(|r| *r),
-            ConditionCombination::None => results.iter().all(|r| !*r),
-        };
-
-        Ok(final_result)
-    }
-
-    /// Evaluate a single condition clause
-    fn evaluate_condition_clause(
-        &self,
-        clause: &ContextConditionClause,
-        context: &TriggerContextCache,
-    ) -> bool {
-        match clause.field {
-            ContextField::TimeOfDay => {
-                let now = Utc::now();
-                let current_hour = now.hour() as i32;
-                self.compare_values(current_hour, &clause.operator, &clause.value)
-            }
-            ContextField::DayOfWeek => {
-                let now = Utc::now();
-                let current_day = now.weekday().num_days_from_monday() as i32;
-                self.compare_values(current_day, &clause.operator, &clause.value)
-            }
-            ContextField::ActiveProject => {
-                if let Some(project) = &context.active_project {
-                    self.compare_values(project.clone(), &clause.operator, &clause.value)
-                } else {
-                    matches!(clause.operator, ComparisonOperator::NotExists)
-                }
-            }
-            ContextField::RecentTopic => {
-                if let Some(topic) = context.recent_topics.first() {
-                    self.compare_values(topic.clone(), &clause.operator, &clause.value)
-                } else {
-                    matches!(clause.operator, ComparisonOperator::NotExists)
-                }
-            }
-            ContextField::PendingTasks => {
-                // Would need to query memory store
-                false // Not implemented yet
-            }
-            ContextField::MemoryCount => {
-                // Would need to query memory store
-                false // Not implemented yet
-            }
-            ContextField::LastInteractionHours => {
-                if let Some(last_updated) = context.last_updated {
-                    let hours = (Utc::now() - last_updated).num_hours();
-                    self.compare_values(hours as i32, &clause.operator, &clause.value)
-                } else {
-                    false
-                }
-            }
-            ContextField::ConversationIntent => {
-                if let Some(intent) = &context.conversation_intent {
-                    self.compare_values(intent.clone(), &clause.operator, &clause.value)
-                } else {
-                    matches!(clause.operator, ComparisonOperator::NotExists)
-                }
-            }
-        }
-    }
-
-    /// Compare values using operator
-    fn compare_values<T>(&self, actual: T, operator: &ComparisonOperator, expected: &JsonValue) -> bool
-    where
-        T: Into<JsonValue>,
-    {
-        let actual_value = actual.into();
-
-        match operator {
-            ComparisonOperator::Equals => &actual_value == expected,
-            ComparisonOperator::NotEquals => &actual_value != expected,
-            ComparisonOperator::Contains => {
-                if let (Some(actual_str), Some(expected_str)) =
-                    (actual_value.as_str(), expected.as_str())
-                {
-                    actual_str.contains(expected_str)
-                } else {
-                    false
-                }
-            }
-            ComparisonOperator::GreaterThan => {
-                if let (Some(actual_num), Some(expected_num)) =
-                    (actual_value.as_i64(), expected.as_i64())
-                {
-                    actual_num > expected_num
-                } else if let (Some(actual_num), Some(expected_num)) =
-                    (actual_value.as_f64(), expected.as_f64())
-                {
-                    actual_num > expected_num
-                } else {
-                    false
-                }
-            }
-            ComparisonOperator::LessThan => {
-                if let (Some(actual_num), Some(expected_num)) =
-                    (actual_value.as_i64(), expected.as_i64())
-                {
-                    actual_num < expected_num
-                } else if let (Some(actual_num), Some(expected_num)) =
-                    (actual_value.as_f64(), expected.as_f64())
-                {
-                    actual_num < expected_num
-                } else {
-                    false
-                }
-            }
-            ComparisonOperator::Exists => !actual_value.is_null(),
-            ComparisonOperator::NotExists => actual_value.is_null(),
-            ComparisonOperator::Matches => {
-                if let (Some(actual_str), Some(expected_str)) =
-                    (actual_value.as_str(), expected.as_str())
-                {
-                    compile_safe_regex(expected_str)
-                        .map(|re| re.is_match(actual_str))
-                        .unwrap_or_else(|e| {
-                            tracing::warn!(
-                                pattern = %expected_str,
-                                error = %e,
-                                "Regex pattern validation failed, treating as no match"
-                            );
-                            false
-                        })
-                } else {
-                    false
-                }
-            }
-        }
-    }
-
-    /// Evaluate identity state trigger
-    async fn evaluate_identity_state(
-        &self,
-        config: &IdentityStateConfig,
-        agent_id: &str,
-    ) -> Result<bool, String> {
-        let mut manager = self.identity_manager.lock().await;
-        let identity = manager.get_identity(agent_id);
-
-        // Get the target file content
-        let content = match config.file {
-            IdentityFile::Soul => identity.soul,
-            IdentityFile::Instructions => identity.instructions,
-            IdentityFile::User => identity.user_profile,
-        };
-
-        // Check content pattern if specified
-        if let Some(pattern) = &config.content_pattern {
-            let re = compile_safe_regex(pattern)
-                .map_err(|e| format!("Invalid regex pattern: {}", e))?;
-            if !re.is_match(&content) {
-                return Ok(false);
-            }
-        }
-
-        // If any_change is true, we would need to track changes
-        // For now, just return true
-
-        Ok(true)
-    }
-
-    /// Get cached context for an agent
-    async fn get_cached_context(&self, _agent_id: &str) -> TriggerContextCache {
-        self.context_cache.lock().await.clone()
-    }
-
-    /// Evaluate composite trigger
-    fn evaluate_composite<'a>(
-        &'a self,
-        config: &'a CompositeTriggerConfig,
-        agent_id: &'a str,
-        _depth: Option<usize>,
-    ) -> Pin<Box<dyn std::future::Future<Output = Result<bool, String>> + 'a>> {
-        Box::pin(async move {
-            let mut results = Vec::new();
-
-            for trigger in &config.triggers {
-                let result = self.evaluate(trigger, agent_id).await?;
-                results.push(result);
-            }
-
-            // Combine results based on combination mode
-            let final_result = match config.combination {
-                ConditionCombination::All => results.iter().all(|r| *r),
-                ConditionCombination::Any => results.iter().any(|r| *r),
-                ConditionCombination::None => results.iter().all(|r| !*r),
-            };
-
-            Ok(final_result)
-        })
-    }
-}
-
-// === Unit Tests ===
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    mod regex_validation {
-        use super::*;
-
-        #[test]
-        fn test_valid_simple_pattern() {
-            let pattern = r"hello";
-            assert!(compile_safe_regex(pattern).is_ok());
-        }
-
-        #[test]
-        fn test_valid_pattern_with_quantifiers() {
-            let pattern = r"\d+";
-            assert!(compile_safe_regex(pattern).is_ok());
-        }
-
-        #[test]
-        fn test_valid_pattern_with_groups() {
-            let pattern = r"(foo|bar)\d{2,4}";
-            assert!(compile_safe_regex(pattern).is_ok());
-        }
-
-        #[test]
-        fn test_valid_character_class() {
-            let pattern = r"[a-zA-Z0-9_]+";
-            assert!(compile_safe_regex(pattern).is_ok());
-        }
-
-        #[test]
-        fn test_pattern_too_long() {
-            let pattern = "a".repeat(501);
-            let result = compile_safe_regex(&pattern);
-            assert!(matches!(result, Err(RegexValidationError::TooLong { .. })));
-        }
-
-        #[test]
-        fn test_pattern_at_max_length() {
-            let pattern = "a".repeat(500);
-            let result = compile_safe_regex(&pattern);
-            assert!(result.is_ok());
-        }
-
-        #[test]
-        fn test_nested_quantifier_detection_simple() {
-            // Classic ReDoS pattern: (a+)+
-            // Our implementation detects this as dangerous
-            let pattern = r"(a+)+";
-            let result = validate_regex_pattern(pattern);
-            assert!(
-                matches!(result, Err(RegexValidationError::DangerousPattern(_))),
-                "Expected nested quantifier pattern to be detected as dangerous"
-            );
-        }
-
-        #[test]
-        fn test_deeply_nested_groups() {
-            // Create a pattern with too many nested groups
-            let pattern = "(".repeat(15) + &"a".repeat(10) + &")".repeat(15);
-            let result = compile_safe_regex(&pattern);
-            assert!(matches!(result, Err(RegexValidationError::TooDeeplyNested { .. })));
-        }
-
-        #[test]
-        fn test_reasonably_nested_groups() {
-            // Pattern with acceptable nesting
-            let pattern = "(((foo|bar)))";
-            let result = compile_safe_regex(pattern);
-            assert!(result.is_ok());
-        }
-
-        #[test]
-        fn test_invalid_regex_syntax() {
-            let pattern = r"[unclosed";
-            let result = compile_safe_regex(pattern);
-            assert!(matches!(result, Err(RegexValidationError::InvalidSyntax(_))));
-        }
-
-        #[test]
-        fn test_escaped_characters_in_pattern() {
-            let pattern = r"\[hello\]";
-            let result = compile_safe_regex(pattern);
-            assert!(result.is_ok());
-        }
-
-        #[test]
-        fn test_complex_valid_pattern() {
-            // Email-like pattern (simplified)
-            let pattern = r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}";
-            let result = compile_safe_regex(pattern);
-            assert!(result.is_ok());
-        }
-    }
-
-    mod nesting_depth_calculation {
-        use super::*;
-
-        #[test]
-        fn test_no_nesting() {
-            assert_eq!(calculate_nesting_depth("abc"), 0);
-        }
-
-        #[test]
-        fn test_single_group() {
-            assert_eq!(calculate_nesting_depth("(abc)"), 1);
-        }
-
-        #[test]
-        fn test_nested_groups() {
-            assert_eq!(calculate_nesting_depth("((abc))"), 2);
-        }
-
-        #[test]
-        fn test_character_class() {
-            assert_eq!(calculate_nesting_depth("[abc]"), 1);
-        }
-
-        #[test]
-        fn test_mixed_nesting() {
-            assert_eq!(calculate_nesting_depth("([a-z]+)"), 2);
-        }
-
-        #[test]
-        fn test_escaped_parens() {
-            // Escaped parens shouldn't count toward nesting
-            assert_eq!(calculate_nesting_depth(r"\(abc\)"), 0);
-        }
-
-        #[test]
-        fn test_multiple_groups_same_level() {
-            assert_eq!(calculate_nesting_depth("(abc)(def)"), 1);
-        }
-    }
-
-    mod dangerous_pattern_detection {
-        use super::*;
-
-        #[test]
-        fn test_simple_quantifier_not_dangerous() {
-            assert!(!contains_dangerous_redos_pattern(r"a+"));
-        }
-
-        #[test]
-        fn test_simple_group_not_dangerous() {
-            assert!(!contains_dangerous_redos_pattern(r"(abc)"));
-        }
-
-        #[test]
-        fn test_quantified_group_not_dangerous() {
-            assert!(!contains_dangerous_redos_pattern(r"(abc)+"));
-        }
-
-        #[test]
-        fn test_alternation_not_dangerous() {
-            assert!(!contains_dangerous_redos_pattern(r"(a|b)+"));
-        }
-    }
-}
-

desktop/src-tauri/src/intelligence_hooks.rs

@@ -0,0 +1,153 @@
+//! Intelligence Hooks - Pre/Post conversation integration
+//!
+//! Bridges the intelligence layer modules (identity, memory, heartbeat, reflection)
+//! into the kernel's chat flow at the Tauri command boundary.
+//!
+//! Architecture: kernel_commands.rs → intelligence_hooks → intelligence modules → Viking/Kernel
+
+use tracing::debug;
+
+use crate::intelligence::identity::IdentityManagerState;
+use crate::intelligence::heartbeat::HeartbeatEngineState;
+use crate::intelligence::reflection::ReflectionEngineState;
+
+/// Run pre-conversation intelligence hooks
+///
+/// 1. Build memory context from VikingStorage (FTS5 + TF-IDF + Embedding)
+/// 2. Build identity-enhanced system prompt (SOUL.md + instructions)
+///
+/// Returns the enhanced system prompt that should be passed to the kernel.
+pub async fn pre_conversation_hook(
+    agent_id: &str,
+    user_message: &str,
+    identity_state: &IdentityManagerState,
+) -> Result<String, String> {
+    // Step 1: Build memory context from Viking storage
+    let memory_context = build_memory_context(agent_id, user_message).await
+        .unwrap_or_default();
+
+    // Step 2: Build identity-enhanced system prompt
+    let enhanced_prompt = build_identity_prompt(agent_id, &memory_context, identity_state)
+        .await
+        .unwrap_or_default();
+
+    Ok(enhanced_prompt)
+}
+
+/// Run post-conversation intelligence hooks
+///
+/// 1. Record interaction for heartbeat engine
+/// 2. Record conversation for reflection engine, trigger reflection if needed
+pub async fn post_conversation_hook(
+    agent_id: &str,
+    _heartbeat_state: &HeartbeatEngineState,
+    reflection_state: &ReflectionEngineState,
+) {
+    // Step 1: Record interaction for heartbeat
+    crate::intelligence::heartbeat::record_interaction(agent_id);
+    debug!("[intelligence_hooks] Recorded interaction for agent: {}", agent_id);
+
+    // Step 2: Record conversation for reflection
+    // tokio::sync::Mutex::lock() returns MutexGuard directly (panics on poison)
+    let mut engine = reflection_state.lock().await;
+
+    engine.record_conversation();
+    debug!(
+        "[intelligence_hooks] Conversation count updated for agent: {}",
+        agent_id
+    );
+
+    if engine.should_reflect() {
+        debug!(
+            "[intelligence_hooks] Reflection threshold reached for agent: {}",
+            agent_id
+        );
+        let reflection_result = engine.reflect(agent_id, &[]);
+        debug!(
+            "[intelligence_hooks] Reflection completed: {} patterns, {} suggestions",
+            reflection_result.patterns.len(),
+            reflection_result.improvements.len()
+        );
+    }
+}
+
+/// Build memory context by searching VikingStorage for relevant memories
+async fn build_memory_context(
+    agent_id: &str,
+    user_message: &str,
+) -> Result<String, String> {
+    // Try Viking storage (has FTS5 + TF-IDF + Embedding)
+    let storage = crate::viking_commands::get_storage().await?;
+
+    // FindOptions from zclaw_growth
+    let options = zclaw_growth::FindOptions {
+        scope: Some(format!("agent://{}", agent_id)),
+        limit: Some(8),
+        min_similarity: Some(0.2),
+    };
+
+    // find is on the VikingStorage trait — call via trait to dispatch correctly
+    let results: Vec<zclaw_growth::MemoryEntry> =
+        zclaw_growth::VikingStorage::find(storage.as_ref(), user_message, options)
+            .await
+            .map_err(|e| format!("Memory search failed: {}", e))?;
+
+    if results.is_empty() {
+        return Ok(String::new());
+    }
+
+    // Format memories into context string
+    let mut context = String::from("## 相关记忆\n\n");
+    let mut token_estimate: usize = 0;
+    let max_tokens: usize = 500;
+
+    for entry in &results {
+        // Prefer overview (L1 summary) over full content
+        // overview is Option<String> — use as_deref to get Option<&str>
+        let overview_str = entry.overview.as_deref().unwrap_or("");
+        let text = if !overview_str.is_empty() {
+            overview_str
+        } else {
+            &entry.content
+        };
+
+        // Truncate long entries
+        let truncated = if text.len() > 100 {
+            format!("{}...", &text[..100])
+        } else {
+            text.to_string()
+        };
+
+        // Simple token estimate (~1.5 tokens per CJK char, ~0.25 per other)
+        let tokens: usize = truncated.chars()
+            .map(|c: char| if c.is_ascii() { 1 } else { 2 })
+            .sum();
+
+        if token_estimate + tokens > max_tokens {
+            break;
+        }
+
+        context.push_str(&format!("- [{}] {}\n", entry.memory_type, truncated));
+        token_estimate += tokens;
+    }
+
+    Ok(context)
+}
+
+/// Build identity-enhanced system prompt
+async fn build_identity_prompt(
+    agent_id: &str,
+    memory_context: &str,
+    identity_state: &IdentityManagerState,
+) -> Result<String, String> {
+    // IdentityManagerState is Arc<tokio::sync::Mutex<AgentIdentityManager>>
+    // tokio::sync::Mutex::lock() returns MutexGuard directly
+    let mut manager = identity_state.lock().await;
+
+    let prompt = manager.build_system_prompt(
+        agent_id,
+        if memory_context.is_empty() { None } else { Some(memory_context) },
+    );
+
+    Ok(prompt)
+}

desktop/src-tauri/src/kernel_commands.rs

@@ -1,7 +1,7 @@
 //! ZCLAW Kernel commands for Tauri
 //!
 //! These commands provide direct access to the internal ZCLAW Kernel,
-//! eliminating the need for external OpenFang process.
+//! eliminating the need for external ZCLAW process.
 
 use std::path::PathBuf;
 use std::sync::Arc;
@@ -416,6 +416,9 @@ pub struct StreamChatRequest {
 pub async fn agent_chat_stream(
     app: AppHandle,
     state: State<'_, KernelState>,
+    identity_state: State<'_, crate::intelligence::IdentityManagerState>,
+    heartbeat_state: State<'_, crate::intelligence::HeartbeatEngineState>,
+    reflection_state: State<'_, crate::intelligence::ReflectionEngineState>,
     request: StreamChatRequest,
 ) -> Result<(), String> {
     // Validate inputs
@@ -428,7 +431,15 @@ pub async fn agent_chat_stream(
         .map_err(|_| "Invalid agent ID format".to_string())?;
 
     let session_id = request.session_id.clone();
-    let message = request.message;
+    let agent_id_str = request.agent_id.clone();
+    let message = request.message.clone();
+
+    // PRE-CONVERSATION: Build intelligence-enhanced system prompt
+    let enhanced_prompt = crate::intelligence_hooks::pre_conversation_hook(
+        &request.agent_id,
+        &request.message,
+        &identity_state,
+    ).await.unwrap_or_default();
 
     // Get the streaming receiver while holding the lock, then release it
     let mut rx = {
@@ -437,12 +448,18 @@ pub async fn agent_chat_stream(
             .ok_or_else(|| "Kernel not initialized. Call kernel_init first.".to_string())?;
 
         // Start the stream - this spawns a background task
-        kernel.send_message_stream(&id, message)
+        // Use intelligence-enhanced system prompt if available
+        let prompt_arg = if enhanced_prompt.is_empty() { None } else { Some(enhanced_prompt) };
+        kernel.send_message_stream_with_prompt(&id, message, prompt_arg)
             .await
             .map_err(|e| format!("Failed to start streaming: {}", e))?
     };
     // Lock is released here
 
+    // Clone Arc references before spawning (State<'_, T> borrows can't enter the spawn)
+    let hb_state = heartbeat_state.inner().clone();
+    let rf_state = reflection_state.inner().clone();
+
     // Spawn a task to process stream events
     tokio::spawn(async move {
         use zclaw_runtime::LoopEvent;
@@ -472,6 +489,12 @@ pub async fn agent_chat_stream(
                 LoopEvent::Complete(result) => {
                     println!("[agent_chat_stream] Complete: input_tokens={}, output_tokens={}",
                         result.input_tokens, result.output_tokens);
+
+                    // POST-CONVERSATION: record interaction + trigger reflection
+                    crate::intelligence_hooks::post_conversation_hook(
+                        &agent_id_str, &hb_state, &rf_state,
+                    ).await;
+
                     StreamChatEvent::Complete {
                         input_tokens: result.input_tokens,
                         output_tokens: result.output_tokens,
@@ -1078,3 +1101,155 @@ pub async fn approval_respond(
     kernel.respond_to_approval(&id, approved, reason).await
         .map_err(|e| format!("Failed to respond to approval: {}", e))
 }
+
+/// Approve a hand execution (alias for approval_respond with approved=true)
+#[tauri::command]
+pub async fn hand_approve(
+    state: State<'_, KernelState>,
+    _hand_name: String,
+    run_id: String,
+    approved: bool,
+    reason: Option<String>,
+) -> Result<serde_json::Value, String> {
+    let kernel_lock = state.lock().await;
+    let kernel = kernel_lock.as_ref()
+        .ok_or_else(|| "Kernel not initialized".to_string())?;
+
+    // run_id maps to approval id
+    kernel.respond_to_approval(&run_id, approved, reason).await
+        .map_err(|e| format!("Failed to approve hand: {}", e))?;
+
+    Ok(serde_json::json!({ "status": if approved { "approved" } else { "rejected" } }))
+}
+
+/// Cancel a hand execution
+#[tauri::command]
+pub async fn hand_cancel(
+    state: State<'_, KernelState>,
+    _hand_name: String,
+    run_id: String,
+) -> Result<serde_json::Value, String> {
+    let kernel_lock = state.lock().await;
+    let kernel = kernel_lock.as_ref()
+        .ok_or_else(|| "Kernel not initialized".to_string())?;
+
+    kernel.cancel_approval(&run_id).await
+        .map_err(|e| format!("Failed to cancel hand: {}", e))?;
+
+    Ok(serde_json::json!({ "status": "cancelled" }))
+}
+
+// ============================================================
+// Scheduled Task Commands
+// ============================================================
+
+/// Request to create a scheduled task (maps to kernel trigger)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CreateScheduledTaskRequest {
+    pub name: String,
+    pub schedule: String,
+    pub schedule_type: String,
+    pub target: Option<ScheduledTaskTarget>,
+    pub description: Option<String>,
+    pub enabled: Option<bool>,
+}
+
+/// Target for a scheduled task
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ScheduledTaskTarget {
+    #[serde(rename = "type")]
+    pub target_type: String,
+    pub id: String,
+}
+
+/// Response for scheduled task creation
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ScheduledTaskResponse {
+    pub id: String,
+    pub name: String,
+    pub schedule: String,
+    pub status: String,
+}
+
+/// Create a scheduled task (backed by kernel TriggerManager)
+///
+/// Tasks are stored in the kernel's trigger system. Automatic execution
+/// requires a scheduler loop (not yet implemented in embedded kernel mode).
+#[tauri::command]
+pub async fn scheduled_task_create(
+    state: State<'_, KernelState>,
+    request: CreateScheduledTaskRequest,
+) -> Result<ScheduledTaskResponse, String> {
+    let kernel_lock = state.lock().await;
+    let kernel = kernel_lock.as_ref()
+        .ok_or_else(|| "Kernel not initialized".to_string())?;
+
+    // Build TriggerConfig from request
+    let trigger_type = match request.schedule_type.as_str() {
+        "cron" | "schedule" => zclaw_hands::TriggerType::Schedule {
+            cron: request.schedule.clone(),
+        },
+        "interval" => zclaw_hands::TriggerType::Schedule {
+            cron: request.schedule.clone(), // interval as simplified cron
+        },
+        "once" => zclaw_hands::TriggerType::Schedule {
+            cron: request.schedule.clone(),
+        },
+        _ => return Err(format!("Unsupported schedule type: {}", request.schedule_type)),
+    };
+
+    let target_id = request.target.as_ref().map(|t| t.id.clone()).unwrap_or_default();
+    let task_id = format!("sched_{}", chrono::Utc::now().timestamp_millis());
+
+    let config = zclaw_hands::TriggerConfig {
+        id: task_id.clone(),
+        name: request.name.clone(),
+        hand_id: target_id,
+        trigger_type,
+        enabled: request.enabled.unwrap_or(true),
+        max_executions_per_hour: 60,
+    };
+
+    let entry = kernel.create_trigger(config).await
+        .map_err(|e| format!("Failed to create scheduled task: {}", e))?;
+
+    Ok(ScheduledTaskResponse {
+        id: entry.config.id,
+        name: entry.config.name,
+        schedule: request.schedule,
+        status: "active".to_string(),
+    })
+}
+
+/// List all scheduled tasks (kernel triggers of Schedule type)
+#[tauri::command]
+pub async fn scheduled_task_list(
+    state: State<'_, KernelState>,
+) -> Result<Vec<ScheduledTaskResponse>, String> {
+    let kernel_lock = state.lock().await;
+    let kernel = kernel_lock.as_ref()
+        .ok_or_else(|| "Kernel not initialized".to_string())?;
+
+    let triggers = kernel.list_triggers().await;
+    let tasks: Vec<ScheduledTaskResponse> = triggers
+        .into_iter()
+        .filter(|t| matches!(t.config.trigger_type, zclaw_hands::TriggerType::Schedule { .. }))
+        .map(|t| {
+            let schedule = match t.config.trigger_type {
+                zclaw_hands::TriggerType::Schedule { cron } => cron,
+                _ => String::new(),
+            };
+            ScheduledTaskResponse {
+                id: t.config.id,
+                name: t.config.name,
+                schedule,
+                status: if t.config.enabled { "active".to_string() } else { "paused".to_string() },
+            }
+        })
+        .collect();
+
+    Ok(tasks)
+}

desktop/src-tauri/src/memory/mod.rs

@@ -15,5 +15,6 @@ pub mod crypto;
 // Re-export main types for convenience
 pub use persistent::{
     PersistentMemory, PersistentMemoryStore, MemorySearchQuery, MemoryStats,
-    generate_memory_id,
+    generate_memory_id, configure_embedding_client, is_embedding_configured,
+    EmbedFn,
 };

desktop/src-tauri/src/memory/persistent.rs

@@ -11,12 +11,69 @@
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 use std::sync::Arc;
-use tokio::sync::Mutex;
+use tokio::sync::{Mutex, OnceCell};
 use uuid::Uuid;
 use tauri::Manager;
 use sqlx::{SqliteConnection, Connection, Row, sqlite::SqliteRow};
 use chrono::Utc;
 
+/// Embedding function type: text -> vector of f32
+pub type EmbedFn = Arc<dyn Fn(&str) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<Vec<f32>, String>> + Send>> + Send + Sync>;
+
+/// Global embedding function for PersistentMemoryStore
+static EMBEDDING_FN: OnceCell<EmbedFn> = OnceCell::const_new();
+
+/// Configure the global embedding function for memory search
+pub fn configure_embedding_client(fn_impl: EmbedFn) {
+    let _ = EMBEDDING_FN.set(fn_impl);
+    tracing::info!("[PersistentMemoryStore] Embedding client configured");
+}
+
+/// Check if embedding is available
+pub fn is_embedding_configured() -> bool {
+    EMBEDDING_FN.get().is_some()
+}
+
+/// Generate embedding for text using the configured client
+async fn embed_text(text: &str) -> Result<Vec<f32>, String> {
+    let client = EMBEDDING_FN.get()
+        .ok_or_else(|| "Embedding client not configured".to_string())?;
+    client(text).await
+}
+
+/// Deserialize f32 vector from BLOB (4 bytes per f32, little-endian)
+fn deserialize_embedding(blob: &[u8]) -> Vec<f32> {
+    blob.chunks_exact(4)
+        .map(|chunk| f32::from_le_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]))
+        .collect()
+}
+
+/// Serialize f32 vector to BLOB
+fn serialize_embedding(vec: &[f32]) -> Vec<u8> {
+    let mut bytes = Vec::with_capacity(vec.len() * 4);
+    for val in vec {
+        bytes.extend_from_slice(&val.to_le_bytes());
+    }
+    bytes
+}
+
+/// Compute cosine similarity between two vectors
+fn cosine_similarity(a: &[f32], b: &[f32]) -> f32 {
+    if a.is_empty() || b.is_empty() || a.len() != b.len() {
+        return 0.0;
+    }
+    let mut dot = 0.0f32;
+    let mut norm_a = 0.0f32;
+    let mut norm_b = 0.0f32;
+    for i in 0..a.len() {
+        dot += a[i] * b[i];
+        norm_a += a[i] * a[i];
+        norm_b += b[i] * b[i];
+    }
+    let denom = (norm_a * norm_b).sqrt();
+    if denom == 0.0 { 0.0 } else { (dot / denom).clamp(0.0, 1.0) }
+}
+
 /// Memory entry stored in SQLite
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct PersistentMemory {
@@ -32,6 +89,7 @@ pub struct PersistentMemory {
     pub last_accessed_at: String,
     pub access_count: i32,
     pub embedding: Option<Vec<u8>>, // Vector embedding for semantic search
+    pub overview: Option<String>,   // L1 summary (1-2 sentences, ~200 tokens)
 }
 
 // Manual implementation of FromRow since sqlx::FromRow derive has issues with Option<Vec<u8>>
@@ -50,12 +108,13 @@ impl<'r> sqlx::FromRow<'r, SqliteRow> for PersistentMemory {
             last_accessed_at: row.try_get("last_accessed_at")?,
             access_count: row.try_get("access_count")?,
             embedding: row.try_get("embedding")?,
+            overview: row.try_get("overview").ok(),
         })
     }
 }
 
 /// Memory search options
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct MemorySearchQuery {
     pub agent_id: Option<String>,
     pub memory_type: Option<String>,
@@ -149,11 +208,34 @@ impl PersistentMemoryStore {
         .await
         .map_err(|e| format!("Failed to create schema: {}", e))?;
 
+        // Migration: add overview column (L1 summary)
+        let _ = sqlx::query("ALTER TABLE memories ADD COLUMN overview TEXT")
+            .execute(&mut *conn)
+            .await;
+
         Ok(())
     }
 
     /// Store a new memory
     pub async fn store(&self, memory: &PersistentMemory) -> Result<(), String> {
+        // Generate embedding if client is configured and memory doesn't have one
+        let embedding = if memory.embedding.is_some() {
+            memory.embedding.clone()
+        } else if is_embedding_configured() {
+            match embed_text(&memory.content).await {
+                Ok(vec) => {
+                    tracing::debug!("[PersistentMemoryStore] Generated embedding for {} ({} dims)", memory.id, vec.len());
+                    Some(serialize_embedding(&vec))
+                }
+                Err(e) => {
+                    tracing::debug!("[PersistentMemoryStore] Embedding generation failed: {}", e);
+                    None
+                }
+            }
+        } else {
+            None
+        };
+
         let mut conn = self.conn.lock().await;
 
         sqlx::query(
@@ -161,8 +243,8 @@ impl PersistentMemoryStore {
             INSERT INTO memories (
                 id, agent_id, memory_type, content, importance, source,
                 tags, conversation_id, created_at, last_accessed_at,
-                access_count, embedding
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                access_count, embedding, overview
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
             "#,
         )
         .bind(&memory.id)
@@ -176,7 +258,8 @@ impl PersistentMemoryStore {
         .bind(&memory.created_at)
         .bind(&memory.last_accessed_at)
         .bind(memory.access_count)
-        .bind(&memory.embedding)
+        .bind(&embedding)
+        .bind(&memory.overview)
         .execute(&mut *conn)
         .await
         .map_err(|e| format!("Failed to store memory: {}", e))?;
@@ -212,7 +295,7 @@ impl PersistentMemoryStore {
         Ok(result)
     }
 
-    /// Search memories with simple query
+    /// Search memories with semantic ranking when embeddings are available
     pub async fn search(&self, query: MemorySearchQuery) -> Result<Vec<PersistentMemory>, String> {
         let mut conn = self.conn.lock().await;
 
@@ -239,11 +322,14 @@ impl PersistentMemoryStore {
             params.push(format!("%{}%", query_text));
         }
 
-        sql.push_str(" ORDER BY created_at DESC");
+        // When using embedding ranking, fetch more candidates
+        let effective_limit = if query.query.is_some() && is_embedding_configured() {
+            query.limit.unwrap_or(50).max(20) // Fetch more for re-ranking
+        } else {
+            query.limit.unwrap_or(50)
+        };
 
-        if let Some(limit) = query.limit {
-            sql.push_str(&format!(" LIMIT {}", limit));
-        }
+        sql.push_str(&format!(" LIMIT {}", effective_limit));
 
         if let Some(offset) = query.offset {
             sql.push_str(&format!(" OFFSET {}", offset));
@@ -255,11 +341,41 @@ impl PersistentMemoryStore {
             query_builder = query_builder.bind(param);
         }
 
-        let results = query_builder
+        let mut results = query_builder
             .fetch_all(&mut *conn)
             .await
             .map_err(|e| format!("Failed to search memories: {}", e))?;
 
+        // Apply semantic ranking if query and embedding are available
+        if let Some(query_text) = &query.query {
+            if is_embedding_configured() {
+                if let Ok(query_embedding) = embed_text(query_text).await {
+                    // Score each result by cosine similarity
+                    let mut scored: Vec<(f32, PersistentMemory)> = results
+                        .into_iter()
+                        .map(|mem| {
+                            let score = mem.embedding.as_ref()
+                                .map(|blob| {
+                                    let vec = deserialize_embedding(blob);
+                                    cosine_similarity(&query_embedding, &vec)
+                                })
+                                .unwrap_or(0.0);
+                            (score, mem)
+                        })
+                        .collect();
+
+                    // Sort by score descending
+                    scored.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap_or(std::cmp::Ordering::Equal));
+
+                    // Apply the original limit
+                    results = scored.into_iter()
+                        .take(query.limit.unwrap_or(20))
+                        .map(|(_, mem)| mem)
+                        .collect();
+                }
+            }
+        }
+
         Ok(results)
     }
 

desktop/src-tauri/src/memory_commands.rs

@@ -3,7 +3,7 @@
 //! Phase 1 of Intelligence Layer Migration:
 //! Provides frontend API for memory storage and retrieval
 
-use crate::memory::{PersistentMemory, PersistentMemoryStore, MemorySearchQuery, MemoryStats, generate_memory_id};
+use crate::memory::{PersistentMemory, PersistentMemoryStore, MemorySearchQuery, MemoryStats, generate_memory_id, configure_embedding_client, is_embedding_configured, EmbedFn};
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 use tauri::{AppHandle, State};
@@ -52,6 +52,9 @@ pub async fn memory_init(
 }
 
 /// Store a new memory
+///
+/// Writes to both PersistentMemoryStore (backward compat) and SqliteStorage (FTS5+Embedding).
+/// SqliteStorage write failure is logged but does not block the operation.
 #[tauri::command]
 pub async fn memory_store(
     entry: MemoryEntryInput,
@@ -64,28 +67,61 @@ pub async fn memory_store(
         .ok_or_else(|| "Memory store not initialized. Call memory_init first.".to_string())?;
 
     let now = Utc::now().to_rfc3339();
+    let id = generate_memory_id();
     let memory = PersistentMemory {
-        id: generate_memory_id(),
-        agent_id: entry.agent_id,
-        memory_type: entry.memory_type,
-        content: entry.content,
+        id: id.clone(),
+        agent_id: entry.agent_id.clone(),
+        memory_type: entry.memory_type.clone(),
+        content: entry.content.clone(),
         importance: entry.importance.unwrap_or(5),
         source: entry.source.unwrap_or_else(|| "auto".to_string()),
-        tags: serde_json::to_string(&entry.tags.unwrap_or_default())
+        tags: serde_json::to_string(&entry.tags.clone().unwrap_or_default())
             .unwrap_or_else(|_| "[]".to_string()),
-        conversation_id: entry.conversation_id,
+        conversation_id: entry.conversation_id.clone(),
         created_at: now.clone(),
         last_accessed_at: now,
         access_count: 0,
         embedding: None,
+        overview: None,
     };
 
-    let id = memory.id.clone();
+    // Write to PersistentMemoryStore (primary)
     store.store(&memory).await?;
 
+    // Also write to SqliteStorage via VikingStorage for FTS5 + Embedding search
+    if let Ok(storage) = crate::viking_commands::get_storage().await {
+        let memory_type = parse_memory_type(&entry.memory_type);
+        let keywords = entry.tags.unwrap_or_default();
+
+        let viking_entry = zclaw_growth::MemoryEntry::new(
+            &entry.agent_id,
+            memory_type,
+            &entry.memory_type,
+            entry.content,
+        )
+        .with_importance(entry.importance.unwrap_or(5) as u8)
+        .with_keywords(keywords);
+
+        match zclaw_growth::VikingStorage::store(storage.as_ref(), &viking_entry).await {
+            Ok(()) => tracing::debug!("[memory_store] Also stored in SqliteStorage"),
+            Err(e) => tracing::warn!("[memory_store] SqliteStorage write failed (non-blocking): {}", e),
+        }
+    }
+
     Ok(id)
 }
 
+/// Parse a string memory_type into zclaw_growth::MemoryType
+fn parse_memory_type(type_str: &str) -> zclaw_growth::MemoryType {
+    match type_str.to_lowercase().as_str() {
+        "preference" => zclaw_growth::MemoryType::Preference,
+        "knowledge" | "fact" | "task" | "todo" | "lesson" | "event" => zclaw_growth::MemoryType::Knowledge,
+        "skill" | "experience" => zclaw_growth::MemoryType::Experience,
+        "session" | "conversation" => zclaw_growth::MemoryType::Session,
+        _ => zclaw_growth::MemoryType::Knowledge,
+    }
+}
+
 /// Get a memory by ID
 #[tauri::command]
 pub async fn memory_get(
@@ -213,3 +249,223 @@ pub async fn memory_db_path(
 
     Ok(store.path().to_string_lossy().to_string())
 }
+
+/// Configure embedding for PersistentMemoryStore (chat memory search)
+/// This is called alongside viking_configure_embedding to enable vector search in chat flow
+#[tauri::command]
+pub async fn memory_configure_embedding(
+    provider: String,
+    api_key: String,
+    model: Option<String>,
+    endpoint: Option<String>,
+) -> Result<bool, String> {
+    // Create an llm::EmbeddingClient and wrap it in Arc for the closure
+    let config = crate::llm::EmbeddingConfig {
+        provider,
+        api_key,
+        endpoint,
+        model,
+    };
+    let client = std::sync::Arc::new(crate::llm::EmbeddingClient::new(config));
+
+    let embed_fn: EmbedFn = {
+        let client = client.clone();
+        Arc::new(move |text: &str| {
+            let client = client.clone();
+            let text = text.to_string();
+            Box::pin(async move {
+                let response = client.embed(&text).await?;
+                Ok(response.embedding)
+            })
+        })
+    };
+
+    configure_embedding_client(embed_fn);
+
+    tracing::info!("[MemoryCommands] Embedding configured for PersistentMemoryStore");
+    Ok(true)
+}
+
+/// Check if embedding is configured for PersistentMemoryStore
+#[tauri::command]
+pub fn memory_is_embedding_configured() -> bool {
+    is_embedding_configured()
+}
+
+/// Build layered memory context for chat prompt injection
+///
+/// Uses SqliteStorage (FTS5 + TF-IDF + Embedding) for high-quality semantic search,
+/// with fallback to PersistentMemoryStore if Viking storage is unavailable.
+///
+/// Performs L0→L1→L2 progressive loading:
+/// - L0: Search all matching memories (vector similarity when available)
+/// - L1: Use overview/summary when available, fall back to truncated content
+/// - L2: Full content only for top-ranked items
+#[tauri::command]
+pub async fn memory_build_context(
+    agent_id: String,
+    query: String,
+    max_tokens: Option<usize>,
+    state: State<'_, MemoryStoreState>,
+) -> Result<BuildContextResult, String> {
+    let budget = max_tokens.unwrap_or(500);
+
+    // Try SqliteStorage (Viking) first — has FTS5 + TF-IDF + Embedding
+    let entries = match crate::viking_commands::get_storage().await {
+        Ok(storage) => {
+            let options = zclaw_growth::FindOptions {
+                scope: Some(format!("agent://{}", agent_id)),
+                limit: Some((budget / 25).max(8)),
+                min_similarity: Some(0.2),
+            };
+
+            match zclaw_growth::VikingStorage::find(storage.as_ref(), &query, options).await {
+                Ok(entries) => entries,
+                Err(e) => {
+                    tracing::warn!("[memory_build_context] Viking search failed, falling back: {}", e);
+                    Vec::new()
+                }
+            }
+        }
+        Err(_) => {
+            tracing::debug!("[memory_build_context] Viking storage unavailable, falling back to PersistentMemoryStore");
+            Vec::new()
+        }
+    };
+
+    // If Viking found results, use them (they have overview/embedding ranking)
+    if !entries.is_empty() {
+        let mut used_tokens = 0;
+        let mut items: Vec<String> = Vec::new();
+        let mut memories_used = 0;
+
+        for entry in &entries {
+            if used_tokens >= budget {
+                break;
+            }
+
+            // Prefer overview (L1 summary) over full content
+            let overview_str = entry.overview.as_deref().unwrap_or("");
+            let display_content = if !overview_str.is_empty() {
+                overview_str.to_string()
+            } else {
+                truncate_for_l1(&entry.content)
+            };
+
+            let item_tokens = estimate_tokens_text(&display_content);
+            if used_tokens + item_tokens > budget {
+                continue;
+            }
+
+            items.push(format!("- [{}] {}", entry.memory_type, display_content));
+            used_tokens += item_tokens;
+            memories_used += 1;
+        }
+
+        let system_prompt_addition = if items.is_empty() {
+            String::new()
+        } else {
+            format!("## 相关记忆\n{}", items.join("\n"))
+        };
+
+        return Ok(BuildContextResult {
+            system_prompt_addition,
+            total_tokens: used_tokens,
+            memories_used,
+        });
+    }
+
+    // Fallback: PersistentMemoryStore (LIKE-based search)
+    let state_guard = state.lock().await;
+    let store = state_guard
+        .as_ref()
+        .ok_or_else(|| "Memory store not initialized".to_string())?;
+
+    let limit = budget / 25;
+    let search_query = MemorySearchQuery {
+        agent_id: Some(agent_id.clone()),
+        query: Some(query.clone()),
+        limit: Some(limit.max(20)),
+        min_importance: Some(3),
+        ..Default::default()
+    };
+
+    let memories = store.search(search_query).await?;
+
+    if memories.is_empty() {
+        return Ok(BuildContextResult {
+            system_prompt_addition: String::new(),
+            total_tokens: 0,
+            memories_used: 0,
+        });
+    }
+
+    // Build layered context with token budget
+    let mut used_tokens = 0;
+    let mut items: Vec<String> = Vec::new();
+    let mut memories_used = 0;
+
+    for memory in &memories {
+        if used_tokens >= budget {
+            break;
+        }
+
+        let display_content = if let Some(ref overview) = memory.overview {
+            if !overview.is_empty() {
+                overview.clone()
+            } else {
+                truncate_for_l1(&memory.content)
+            }
+        } else {
+            truncate_for_l1(&memory.content)
+        };
+
+        let item_tokens = estimate_tokens_text(&display_content);
+        if used_tokens + item_tokens > budget {
+            continue;
+        }
+
+        items.push(format!("- [{}] {}", memory.memory_type, display_content));
+        used_tokens += item_tokens;
+        memories_used += 1;
+    }
+
+    let system_prompt_addition = if items.is_empty() {
+        String::new()
+    } else {
+        format!("## 相关记忆\n{}", items.join("\n"))
+    };
+
+    Ok(BuildContextResult {
+        system_prompt_addition,
+        total_tokens: used_tokens,
+        memories_used,
+    })
+}
+
+/// Result of building layered memory context
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildContextResult {
+    pub system_prompt_addition: String,
+    pub total_tokens: usize,
+    pub memories_used: usize,
+}
+
+/// Truncate content for L1 overview display (~50 tokens)
+fn truncate_for_l1(content: &str) -> String {
+    let char_limit = 100; // ~50 tokens for mixed CJK/ASCII
+    if content.chars().count() <= char_limit {
+        content.to_string()
+    } else {
+        let truncated: String = content.chars().take(char_limit).collect();
+        format!("{}...", truncated)
+    }
+}
+
+/// Estimate token count for text
+fn estimate_tokens_text(text: &str) -> usize {
+    let cjk_count = text.chars().filter(|c| ('\u{4E00}'..='\u{9FFF}').contains(c)).count();
+    let other_count = text.chars().count() - cjk_count;
+    (cjk_count as f32 * 1.5 + other_count as f32 * 0.4).ceil() as usize
+}

desktop/src-tauri/src/summarizer_adapter.rs

@@ -0,0 +1,133 @@
+//! Summarizer Adapter - Bridges zclaw_growth::SummaryLlmDriver with Tauri LLM Client
+//!
+//! Implements the SummaryLlmDriver trait using the local LlmClient,
+//! enabling L0/L1 summary generation via the user's configured LLM.
+
+use zclaw_growth::{MemoryEntry, SummaryLlmDriver, summarizer::{overview_prompt, abstract_prompt}};
+
+/// Tauri-side implementation of SummaryLlmDriver using llm::LlmClient
+pub struct TauriSummaryDriver {
+    endpoint: String,
+    api_key: String,
+    model: Option<String>,
+}
+
+impl TauriSummaryDriver {
+    /// Create a new Tauri summary driver
+    pub fn new(endpoint: String, api_key: String, model: Option<String>) -> Self {
+        Self {
+            endpoint,
+            api_key,
+            model,
+        }
+    }
+
+    /// Check if the driver is configured (has endpoint and api_key)
+    pub fn is_configured(&self) -> bool {
+        !self.endpoint.is_empty() && !self.api_key.is_empty()
+    }
+
+    /// Call the LLM API with a simple prompt
+    async fn call_llm(&self, prompt: String) -> Result<String, String> {
+        let client = reqwest::Client::new();
+
+        let model = self.model.clone().unwrap_or_else(|| "glm-4-flash".to_string());
+
+        let request = serde_json::json!({
+            "model": model,
+            "messages": [
+                { "role": "user", "content": prompt }
+            ],
+            "temperature": 0.3,
+            "max_tokens": 200,
+        });
+
+        let response = client
+            .post(format!("{}/chat/completions", self.endpoint))
+            .header("Authorization", format!("Bearer {}", self.api_key))
+            .header("Content-Type", "application/json")
+            .json(&request)
+            .send()
+            .await
+            .map_err(|e| format!("Summary LLM request failed: {}", e))?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let body = response.text().await.unwrap_or_default();
+            return Err(format!("Summary LLM error {}: {}", status, body));
+        }
+
+        let json: serde_json::Value = response
+            .json()
+            .await
+            .map_err(|e| format!("Failed to parse summary response: {}", e))?;
+
+        json.get("choices")
+            .and_then(|c| c.get(0))
+            .and_then(|c| c.get("message"))
+            .and_then(|m| m.get("content"))
+            .and_then(|c| c.as_str())
+            .map(|s| s.to_string())
+            .ok_or_else(|| "Invalid summary LLM response format".to_string())
+    }
+}
+
+#[async_trait::async_trait]
+impl SummaryLlmDriver for TauriSummaryDriver {
+    async fn generate_overview(&self, entry: &MemoryEntry) -> Result<String, String> {
+        let prompt = overview_prompt(entry);
+        self.call_llm(prompt).await
+    }
+
+    async fn generate_abstract(&self, entry: &MemoryEntry) -> Result<String, String> {
+        let prompt = abstract_prompt(entry);
+        self.call_llm(prompt).await
+    }
+}
+
+/// Global summary driver instance (lazy-initialized)
+static SUMMARY_DRIVER: tokio::sync::OnceCell<std::sync::Arc<TauriSummaryDriver>> =
+    tokio::sync::OnceCell::const_new();
+
+/// Configure the global summary driver
+pub fn configure_summary_driver(driver: TauriSummaryDriver) {
+    let _ = SUMMARY_DRIVER.set(std::sync::Arc::new(driver));
+    tracing::info!("[SummarizerAdapter] Summary driver configured");
+}
+
+/// Check if summary driver is available
+pub fn is_summary_driver_configured() -> bool {
+    SUMMARY_DRIVER
+        .get()
+        .map(|d| d.is_configured())
+        .unwrap_or(false)
+}
+
+/// Get the global summary driver
+pub fn get_summary_driver() -> Option<std::sync::Arc<TauriSummaryDriver>> {
+    SUMMARY_DRIVER.get().cloned()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use zclaw_growth::MemoryType;
+
+    #[test]
+    fn test_summary_driver_not_configured_by_default() {
+        assert!(!is_summary_driver_configured());
+    }
+
+    #[test]
+    fn test_summary_driver_configure_and_check() {
+        let driver = TauriSummaryDriver::new(
+            "https://example.com/v1".to_string(),
+            "test-key".to_string(),
+            None,
+        );
+        assert!(driver.is_configured());
+
+        let empty_driver = TauriSummaryDriver::new(String::new(), String::new(), None);
+        assert!(!empty_driver.is_configured());
+    }
+}

desktop/src-tauri/src/viking_commands.rs

@@ -67,6 +67,13 @@ pub struct VikingAddResult {
     pub status: String,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EmbeddingConfigResult {
+    pub provider: String,
+    pub configured: bool,
+}
+
 // === Global Storage Instance ===
 
 /// Global storage instance
@@ -100,12 +107,20 @@ pub async fn init_storage() -> Result<(), String> {
     Ok(())
 }
 
-/// Get the storage instance (public for use by other modules)
+/// Get the storage instance, initializing on first access if needed
 pub async fn get_storage() -> Result<Arc<SqliteStorage>, String> {
+    if let Some(storage) = STORAGE.get() {
+        return Ok(storage.clone());
+    }
+
+    // Attempt lazy initialization
+    tracing::info!("[VikingCommands] Storage not yet initialized, attempting lazy init...");
+    init_storage().await?;
+
     STORAGE
         .get()
         .cloned()
-        .ok_or_else(|| "Storage not initialized. Call init_storage() first.".to_string())
+        .ok_or_else(|| "Storage initialization failed. Check logs for details.".to_string())
 }
 
 /// Get storage directory for status
@@ -217,12 +232,24 @@ pub async fn viking_find(
     Ok(entries
         .into_iter()
         .enumerate()
-        .map(|(i, entry)| VikingFindResult {
-            uri: entry.uri,
-            score: 1.0 - (i as f64 * 0.1), // Simple scoring based on rank
-            content: entry.content,
-            level: "L1".to_string(),
-            overview: None,
+        .map(|(i, entry)| {
+            // Use overview (L1) when available, full content otherwise (L2)
+            let (content, level, overview) = if let Some(ref ov) = entry.overview {
+                if !ov.is_empty() {
+                    (ov.clone(), "L1".to_string(), None)
+                } else {
+                    (entry.content.clone(), "L2".to_string(), None)
+                }
+            } else {
+                (entry.content.clone(), "L2".to_string(), None)
+            };
+            VikingFindResult {
+                uri: entry.uri,
+                score: 1.0 - (i as f64 * 0.1), // Simple scoring based on rank
+                content,
+                level,
+                overview,
+            }
         })
         .collect())
 }
@@ -309,7 +336,7 @@ pub async fn viking_ls(path: String) -> Result<Vec<VikingResource>, String> {
 
 /// Read memory content
 #[tauri::command]
-pub async fn viking_read(uri: String, _level: Option<String>) -> Result<String, String> {
+pub async fn viking_read(uri: String, level: Option<String>) -> Result<String, String> {
     let storage = get_storage().await?;
 
     let entry = storage
@@ -318,7 +345,34 @@ pub async fn viking_read(uri: String, _level: Option<String>) -> Result<String,
         .map_err(|e| format!("Failed to read memory: {}", e))?;
 
     match entry {
-        Some(e) => Ok(e.content),
+        Some(e) => {
+            // Support level-based content retrieval
+            let content = match level.as_deref() {
+                Some("L0") | Some("l0") => {
+                    // L0: abstract_summary (keywords)
+                    e.abstract_summary
+                        .filter(|s| !s.is_empty())
+                        .unwrap_or_else(|| {
+                            // Fallback: first 50 chars of overview
+                            e.overview
+                                .as_ref()
+                                .map(|ov| ov.chars().take(50).collect())
+                                .unwrap_or_else(|| e.content.chars().take(50).collect())
+                        })
+                }
+                Some("L1") | Some("l1") => {
+                    // L1: overview (1-2 sentence summary)
+                    e.overview
+                        .filter(|s| !s.is_empty())
+                        .unwrap_or_else(|| truncate_text(&e.content, 200))
+                }
+                _ => {
+                    // L2 or default: full content
+                    e.content
+                }
+            };
+            Ok(content)
+        }
         None => Err(format!("Memory not found: {}", uri)),
     }
 }
@@ -442,6 +496,16 @@ pub async fn viking_inject_prompt(
 
 // === Helper Functions ===
 
+/// Truncate text to approximately max_chars characters
+fn truncate_text(text: &str, max_chars: usize) -> String {
+    if text.chars().count() <= max_chars {
+        text.to_string()
+    } else {
+        let truncated: String = text.chars().take(max_chars).collect();
+        format!("{}...", truncated)
+    }
+}
+
 /// Parse URI to extract components
 fn parse_uri(uri: &str) -> Result<(String, MemoryType, String), String> {
     // Expected format: agent://{agent_id}/{type}/{category}
@@ -462,6 +526,136 @@ fn parse_uri(uri: &str) -> Result<(String, MemoryType, String), String> {
     Ok((agent_id, memory_type, category))
 }
 
+/// Configure embedding for semantic memory search
+/// Configures both SqliteStorage (VikingPanel) and PersistentMemoryStore (chat flow)
+#[tauri::command]
+pub async fn viking_configure_embedding(
+    provider: String,
+    api_key: String,
+    model: Option<String>,
+    endpoint: Option<String>,
+) -> Result<EmbeddingConfigResult, String> {
+    let storage = get_storage().await?;
+
+    // 1. Configure SqliteStorage (VikingPanel / VikingCommands)
+    let config_viking = crate::llm::EmbeddingConfig {
+        provider: provider.clone(),
+        api_key: api_key.clone(),
+        endpoint: endpoint.clone(),
+        model: model.clone(),
+    };
+
+    let client_viking = crate::llm::EmbeddingClient::new(config_viking);
+    let adapter = crate::embedding_adapter::TauriEmbeddingAdapter::new(client_viking);
+
+    storage
+        .configure_embedding(std::sync::Arc::new(adapter))
+        .await
+        .map_err(|e| format!("Failed to configure embedding: {}", e))?;
+
+    // 2. Configure PersistentMemoryStore (chat flow)
+    let config_memory = crate::llm::EmbeddingConfig {
+        provider: provider.clone(),
+        api_key,
+        endpoint,
+        model,
+    };
+    let client_memory = std::sync::Arc::new(crate::llm::EmbeddingClient::new(config_memory));
+
+    let embed_fn: crate::memory::EmbedFn = {
+        let client_arc = client_memory.clone();
+        std::sync::Arc::new(move |text: &str| {
+            let client = client_arc.clone();
+            let text = text.to_string();
+            Box::pin(async move {
+                let response = client.embed(&text).await?;
+                Ok(response.embedding)
+            })
+        })
+    };
+
+    crate::memory::configure_embedding_client(embed_fn);
+
+    tracing::info!("[VikingCommands] Embedding configured with provider: {} (both storage systems)", provider);
+
+    Ok(EmbeddingConfigResult {
+        provider,
+        configured: true,
+    })
+}
+
+/// Configure summary driver for L0/L1 auto-generation
+#[tauri::command]
+pub async fn viking_configure_summary_driver(
+    endpoint: String,
+    api_key: String,
+    model: Option<String>,
+) -> Result<bool, String> {
+    let driver = crate::summarizer_adapter::TauriSummaryDriver::new(endpoint, api_key, model);
+    crate::summarizer_adapter::configure_summary_driver(driver);
+
+    tracing::info!("[VikingCommands] Summary driver configured");
+    Ok(true)
+}
+
+/// Store a memory and optionally generate L0/L1 summaries in the background
+#[tauri::command]
+pub async fn viking_store_with_summaries(
+    uri: String,
+    content: String,
+) -> Result<VikingAddResult, String> {
+    let storage = get_storage().await?;
+    let (agent_id, memory_type, category) = parse_uri(&uri)?;
+
+    let entry = MemoryEntry::new(&agent_id, memory_type, &category, content);
+
+    // Store the entry immediately (L2 full content)
+    storage
+        .store(&entry)
+        .await
+        .map_err(|e| format!("Failed to store memory: {}", e))?;
+
+    // Background: generate L0/L1 summaries if driver is configured
+    if crate::summarizer_adapter::is_summary_driver_configured() {
+        let entry_uri = entry.uri.clone();
+        let storage_clone = storage.clone();
+
+        tokio::spawn(async move {
+            if let Some(driver) = crate::summarizer_adapter::get_summary_driver() {
+                let (overview, abstract_summary) =
+                    zclaw_growth::summarizer::generate_summaries(driver.as_ref(), &entry).await;
+
+                if overview.is_some() || abstract_summary.is_some() {
+                    // Update the entry with summaries
+                    let updated = MemoryEntry {
+                        overview,
+                        abstract_summary,
+                        ..entry
+                    };
+
+                    if let Err(e) = storage_clone.store(&updated).await {
+                        tracing::debug!(
+                            "[VikingCommands] Failed to update summaries for {}: {}",
+                            entry_uri,
+                            e
+                        );
+                    } else {
+                        tracing::debug!(
+                            "[VikingCommands] Updated L0/L1 summaries for {}",
+                            entry_uri
+                        );
+                    }
+                }
+            }
+        });
+    }
+
+    Ok(VikingAddResult {
+        uri,
+        status: "added".to_string(),
+    })
+}
+
 // === Tests ===
 
 #[cfg(test)]

desktop/src/App.tsx

@@ -21,13 +21,15 @@ import { Loader2 } from 'lucide-react';
 import { isTauriRuntime, getLocalGatewayStatus, startLocalGateway } from './lib/tauri-gateway';
 import { useOnboarding } from './lib/use-onboarding';
 import { intelligenceClient } from './lib/intelligence-client';
+import { loadEmbeddingConfig } from './lib/embedding-client';
+import { invoke } from '@tauri-apps/api/core';
 import { useProposalNotifications, ProposalNotificationHandler } from './lib/useProposalNotifications';
 import { useToast } from './components/ui/Toast';
 import type { Clone } from './store/agentStore';
 
 type View = 'main' | 'settings';
 
-// Bootstrap component that ensures OpenFang is running before rendering main UI
+// Bootstrap component that ensures ZCLAW is running before rendering main UI
 function BootstrapScreen({ status }: { status: string }) {
   return (
     <div className="h-screen flex items-center justify-center bg-gray-50">
@@ -125,7 +127,7 @@ function App() {
     // Don't clear pendingApprovalRun - keep it for reference
   }, []);
 
-  // Bootstrap: Start OpenFang Gateway before rendering main UI
+  // Bootstrap: Start ZCLAW Gateway before rendering main UI
   useEffect(() => {
     let mounted = true;
 
@@ -140,7 +142,7 @@ function App() {
             const isRunning = status.portStatus === 'busy' || status.listenerPids.length > 0;
 
             if (!isRunning && status.cliAvailable) {
-              setBootstrapStatus('Starting OpenFang Gateway...');
+              setBootstrapStatus('Starting ZCLAW Gateway...');
               console.log('[App] Local gateway not running, auto-starting...');
 
             await startLocalGateway();
@@ -230,7 +232,43 @@ function App() {
         // Non-critical, continue without heartbeat
       }
 
-      // Step 5: Bootstrap complete
+      // Step 5: Restore embedding config to Rust backend
+      try {
+        const embConfig = loadEmbeddingConfig();
+        if (embConfig.enabled && embConfig.provider !== 'local' && embConfig.apiKey) {
+          setBootstrapStatus('Restoring embedding configuration...');
+          await invoke('viking_configure_embedding', {
+            provider: embConfig.provider,
+            apiKey: embConfig.apiKey,
+            model: embConfig.model || undefined,
+            endpoint: embConfig.endpoint || undefined,
+          });
+          console.log('[App] Embedding configuration restored to backend');
+        }
+      } catch (embErr) {
+        console.warn('[App] Failed to restore embedding config:', embErr);
+        // Non-critical, semantic search will fall back to TF-IDF
+      }
+
+      // Step 5b: Configure summary driver using active LLM (for L0/L1 generation)
+      try {
+        const { getDefaultModelConfig } = await import('./store/connectionStore');
+        const modelConfig = getDefaultModelConfig();
+        if (modelConfig && modelConfig.apiKey && modelConfig.baseUrl) {
+          setBootstrapStatus('Configuring summary driver...');
+          await invoke('viking_configure_summary_driver', {
+            endpoint: modelConfig.baseUrl,
+            apiKey: modelConfig.apiKey,
+            model: modelConfig.model || undefined,
+          });
+          console.log('[App] Summary driver configured with active LLM');
+        }
+      } catch (sumErr) {
+        console.warn('[App] Failed to configure summary driver:', sumErr);
+        // Non-critical, summaries won't be auto-generated
+      }
+
+      // Step 6: Bootstrap complete
       setBootstrapping(false);
     } catch (err) {
       console.error('[App] Bootstrap failed:', err);

desktop/src/components/ApprovalsPanel.tsx

@@ -1,10 +1,10 @@
 /**
- * ApprovalsPanel - OpenFang Execution Approvals UI
+ * ApprovalsPanel - ZCLAW Execution Approvals UI
  *
  * Displays pending, approved, and rejected approval requests
  * for Hand executions that require human approval.
  *
- * Design based on OpenFang Dashboard v0.4.0
+ * Design based on ZCLAW Dashboard v0.4.0
  */
 
 import { useState, useEffect, useCallback } from 'react';

desktop/src/components/AuditLogsPanel.tsx

@@ -1,5 +1,5 @@
 /**
- * AuditLogsPanel - OpenFang Audit Logs UI with Merkle Hash Chain Verification
+ * AuditLogsPanel - ZCLAW Audit Logs UI with Merkle Hash Chain Verification
  *
  * Phase 3.4 Enhancement: Full-featured audit log viewer with:
  * - Complete log entry display
@@ -51,7 +51,7 @@ export interface AuditLogFilter {
 }
 
 interface EnhancedAuditLogEntry extends AuditLogEntry {
-  // Extended fields from OpenFang
+  // Extended fields from ZCLAW
   targetResource?: string;
   operationDetails?: Record<string, unknown>;
   ipAddress?: string;
@@ -633,7 +633,7 @@ export function AuditLogsPanel() {
     setVerificationResult(null);
 
     try {
-      // Call OpenFang API to verify the chain
+      // Call ZCLAW API to verify the chain
       const result = await client.verifyAuditLogChain(log.id);
 
       const verification: MerkleVerificationResult = {

desktop/src/components/CloneManager.tsx

@@ -42,7 +42,7 @@ export function CloneManager() {
     role: '默认助手',
     nickname: a.name,
     scenarios: [] as string[],
-    workspaceDir: '~/.openfang/zclaw-workspace',
+    workspaceDir: '~/.zclaw/zclaw-workspace',
     userName: quickConfig.userName || '未设置',
     userRole: '',
     restrictFiles: true,

desktop/src/components/ConnectionStatus.tsx

@@ -3,7 +3,7 @@
  *
  * Displays the current Gateway connection status with visual indicators.
  * Supports automatic reconnect and manual reconnect button.
- * Includes health status indicator for OpenFang backend.
+ * Includes health status indicator for ZCLAW backend.
  */
 
 import { useState, useEffect } from 'react';
@@ -230,7 +230,7 @@ export function ConnectionIndicator({ className = '' }: { className?: string })
 }
 
 /**
- * HealthStatusIndicator - Displays OpenFang backend health status
+ * HealthStatusIndicator - Displays ZCLAW backend health status
  */
 export function HealthStatusIndicator({
   className = '',

desktop/src/components/CreateTriggerModal.tsx

@@ -3,7 +3,7 @@
  *
  * Supports trigger types:
  * - webhook: External HTTP request trigger
- * - event: OpenFang internal event trigger
+ * - event: ZCLAW internal event trigger
  * - message: Chat message pattern trigger
  */
 
@@ -119,7 +119,7 @@ const triggerTypeOptions: Array<{
   {
     value: 'event',
     label: 'Event',
-    description: 'OpenFang internal event trigger',
+    description: 'ZCLAW internal event trigger',
     icon: Bell,
   },
   {

desktop/src/components/HandList.tsx

@@ -64,7 +64,7 @@ export function HandList({ selectedHandId, onSelectHand }: HandListProps) {
       <div className="p-4 text-center">
         <Zap className="w-8 h-8 mx-auto text-gray-300 mb-2" />
         <p className="text-xs text-gray-400 mb-1">暂无可用 Hands</p>
-        <p className="text-xs text-gray-300">连接 OpenFang 后显示</p>
+        <p className="text-xs text-gray-300">连接 ZCLAW 后显示</p>
       </div>
     );
   }

desktop/src/components/HandsPanel.tsx

@@ -1,10 +1,10 @@
 /**
- * HandsPanel - OpenFang Hands Management UI
+ * HandsPanel - ZCLAW Hands Management UI
  *
- * Displays available OpenFang Hands (autonomous capability packages)
+ * Displays available ZCLAW Hands (autonomous capability packages)
  * with detailed status, requirements, and activation controls.
  *
- * Design based on OpenFang Dashboard v0.4.0
+ * Design based on ZCLAW Dashboard v0.4.0
  */
 
 import { useState, useEffect, useCallback } from 'react';
@@ -528,7 +528,7 @@ export function HandsPanel() {
         </div>
         <p className="text-sm text-gray-500 dark:text-gray-400 mb-3">暂无可用的 Hands</p>
         <p className="text-xs text-gray-400 dark:text-gray-500">
-          请连接到 OpenFang 以查看可用的自主能力包。
+          请连接到 ZCLAW 以查看可用的自主能力包。
         </p>
       </div>
     );

desktop/src/components/RightPanel.tsx

@@ -441,7 +441,7 @@ export function RightPanel() {
                       ))}
                     </div>
                   </div>
-                  <AgentRow label="Workspace" value={selectedClone?.workspaceDir || workspaceInfo?.path || '~/.openfang/zclaw-workspace'} />
+                  <AgentRow label="Workspace" value={selectedClone?.workspaceDir || workspaceInfo?.path || '~/.zclaw/zclaw-workspace'} />
                   <AgentRow label="Resolved" value={selectedClone?.workspaceResolvedPath || workspaceInfo?.resolvedPath || '-'} />
                   <AgentRow label="File Restriction" value={selectedClone?.restrictFiles ? 'Enabled' : 'Disabled'} />
                   <AgentRow label="Opt-in" value={selectedClone?.privacyOptIn ? 'Joined' : 'Not joined'} />
@@ -739,7 +739,7 @@ function createAgentDraft(
     nickname: clone.nickname || '',
     model: clone.model || currentModel,
     scenarios: clone.scenarios?.join(', ') || '',
-    workspaceDir: clone.workspaceDir || '~/.openfang/zclaw-workspace',
+    workspaceDir: clone.workspaceDir || '~/.zclaw/zclaw-workspace',
     userName: clone.userName || '',
     userRole: clone.userRole || '',
     restrictFiles: clone.restrictFiles ?? true,

desktop/src/components/SchedulerPanel.tsx

@@ -1,9 +1,9 @@
 /**
- * SchedulerPanel - OpenFang Scheduler UI
+ * SchedulerPanel - ZCLAW Scheduler UI
  *
  * Displays scheduled jobs, event triggers, workflows, and run history.
  *
- * Design based on OpenFang Dashboard v0.4.0
+ * Design based on ZCLAW Dashboard v0.4.0
  */
 
 import { useState, useEffect, useCallback } from 'react';

desktop/src/components/SecurityLayersPanel.tsx

@@ -30,7 +30,7 @@ import type { SecurityLayer, SecurityStatus } from '../store/securityStore';
 import { useSecurityStore } from '../store/securityStore';
 import { useConnectionStore } from '../store/connectionStore';
 
-// OpenFang 16-layer security architecture definitions
+// ZCLAW 16-layer security architecture definitions
 export const SECURITY_LAYERS: Array<{
   id: string;
   name: string;
@@ -482,7 +482,7 @@ export function calculateSecurityScore(layers: SecurityLayer[]): number {
   return Math.round((activeCount / SECURITY_LAYERS.length) * 100);
 }
 
-// ZCLAW 默认安全状态（独立于 OpenFang）
+// ZCLAW 默认安全状态（本地检测）
 export function getDefaultSecurityStatus(): SecurityStatus {
   // ZCLAW 默认启用的安全层
   const defaultEnabledLayers = [
@@ -687,7 +687,7 @@ export function SecurityStatusPanel({ className = '' }: SecurityStatusPanelProps
           </span>
         </div>
         <p className="text-xs text-gray-500 mt-1">
-          {!connected && 'ZCLAW 默认安全配置。连接 OpenFang 后可获取完整安全状态。'}
+          {!connected && 'ZCLAW 默认安全配置。连接后可获取实时安全状态。'}
         </p>
       </div>
 

desktop/src/components/SecurityStatus.tsx

@@ -1,9 +1,8 @@
 import { useEffect } from 'react';
 import { Shield, ShieldCheck, ShieldAlert, ShieldX, RefreshCw, Loader2, AlertCircle } from 'lucide-react';
-import { useConnectionStore } from '../store/connectionStore';
 import { useSecurityStore } from '../store/securityStore';
 
-// OpenFang 16-layer security architecture names (Chinese)
+// ZCLAW 16-layer security architecture names (Chinese)
 const SECURITY_LAYER_NAMES: Record<string, string> = {
   // Layer 1: Network
   'network.firewall': '网络防火墙',
@@ -76,30 +75,14 @@ function getSecurityLabel(level: 'critical' | 'high' | 'medium' | 'low') {
 }
 
 export function SecurityStatus() {
-  const connectionState = useConnectionStore((s) => s.connectionState);
   const securityStatus = useSecurityStore((s) => s.securityStatus);
   const securityStatusLoading = useSecurityStore((s) => s.securityStatusLoading);
   const securityStatusError = useSecurityStore((s) => s.securityStatusError);
   const loadSecurityStatus = useSecurityStore((s) => s.loadSecurityStatus);
-  const connected = connectionState === 'connected';
 
   useEffect(() => {
-    if (connected) {
-      loadSecurityStatus();
-    }
-  }, [connected]);
-
-  if (!connected) {
-    return (
-      <div className="rounded-xl border border-gray-200 bg-white p-4 shadow-sm">
-        <div className="flex items-center gap-2 mb-3">
-          <Shield className="w-4 h-4 text-gray-400" />
-          <span className="text-sm font-semibold text-gray-900">安全状态</span>
-        </div>
-        <p className="text-xs text-gray-400">连接后可用</p>
-      </div>
-    );
-  }
+    loadSecurityStatus();
+  }, [loadSecurityStatus]);
 
   // Loading state
   if (securityStatusLoading && !securityStatus) {
@@ -131,9 +114,9 @@ export function SecurityStatus() {
             <RefreshCw className="w-3.5 h-3.5" />
           </button>
         </div>
-        <p className="text-xs text-gray-500 mb-2">API 不可用</p>
+        <p className="text-xs text-gray-500 mb-2">安全状态检测失败</p>
         <p className="text-xs text-gray-400">
-          OpenFang 安全状态 API ({'/api/security/status'}) 在当前版本可能未实现
+          本地安全检测模块加载失败，请检查安全组件是否正确初始化
         </p>
       </div>
     );

desktop/src/components/Settings/About.tsx

@@ -34,10 +34,10 @@ export function About() {
       </div>
 
       <div className="mt-12 text-center text-xs text-gray-400">
-        2026 ZCLAW | Powered by OpenFang
+        2026 ZCLAW
       </div>
       <div className="text-center text-xs text-gray-400 space-y-1">
-        <p>基于 OpenFang Rust Agent OS 构建</p>
+        <p>基于 Rust Agent OS 构建</p>
         <div className="flex justify-center gap-4 mt-3">
           <a href="#" className="text-orange-500 hover:text-orange-600">隐私政策</a>
           <a href="#" className="text-orange-500 hover:text-orange-600">用户协议</a>

desktop/src/components/Settings/IMChannels.tsx

@@ -382,7 +382,7 @@ export function IMChannels() {
           <div className="text-xs text-blue-700 dark:text-blue-300">
             <p className="font-medium mb-1">高级配置</p>
             <p>账号绑定、消息路由等高级功能需要在 Gateway 配置文件中完成。</p>
-            <p className="mt-1">配置文件路径: <code className="bg-blue-100 dark:bg-blue-800 px-1 rounded">~/.openfang/openfang.toml</code></p>
+            <p className="mt-1">配置文件路径: <code className="bg-blue-100 dark:bg-blue-800 px-1 rounded">~/.zclaw/zclaw.toml</code></p>
           </div>
         </div>
       </div>

desktop/src/components/Settings/ModelsAPI.tsx

@@ -266,13 +266,30 @@ export function ModelsAPI() {
   };
 
   // 保存 Embedding 配置
-  const handleSaveEmbeddingConfig = () => {
+  const handleSaveEmbeddingConfig = async () => {
     const configToSave = {
       ...embeddingConfig,
       enabled: embeddingConfig.provider !== 'local' && embeddingConfig.apiKey.trim() !== '',
     };
     setEmbeddingConfig(configToSave);
     saveEmbeddingConfig(configToSave);
+
+    // Push config to Rust backend for semantic memory search
+    if (configToSave.enabled) {
+      try {
+        await invoke('viking_configure_embedding', {
+          provider: configToSave.provider,
+          apiKey: configToSave.apiKey,
+          model: configToSave.model || undefined,
+          endpoint: configToSave.endpoint || undefined,
+        });
+        setEmbeddingTestResult({ success: true, message: 'Embedding 配置已应用到语义记忆搜索' });
+      } catch (error) {
+        setEmbeddingTestResult({ success: false, message: `配置保存成功但应用失败: ${error}` });
+      }
+    } else {
+      setEmbeddingTestResult(null);
+    }
   };
 
   // 测试 Embedding API

desktop/src/components/Settings/Privacy.tsx

@@ -24,7 +24,7 @@ export function Privacy() {
         <h3 className="font-medium mb-2 text-gray-900">本地数据路径</h3>
         <div className="text-xs text-gray-500 mb-3">所有工作区文件、对话记录和 Agent 输出均存储在此本地目录。</div>
         <div className="p-3 bg-gray-50 border border-gray-200 rounded-lg text-xs text-gray-600 font-mono">
-          {workspaceInfo?.resolvedPath || workspaceInfo?.path || quickConfig.workspaceDir || '~/.openfang/zclaw-workspace'}
+          {workspaceInfo?.resolvedPath || workspaceInfo?.path || quickConfig.workspaceDir || '~/.zclaw/zclaw-workspace'}
         </div>
       </div>
 

desktop/src/components/Settings/UsageStats.tsx

@@ -1,19 +1,15 @@
 import { useEffect, useState } from 'react';
 import { useAgentStore } from '../../store/agentStore';
-import { useConnectionStore } from '../../store/connectionStore';
 import { BarChart3, TrendingUp, Clock, Zap } from 'lucide-react';
 
 export function UsageStats() {
   const usageStats = useAgentStore((s) => s.usageStats);
   const loadUsageStats = useAgentStore((s) => s.loadUsageStats);
-  const connectionState = useConnectionStore((s) => s.connectionState);
   const [timeRange, setTimeRange] = useState<'7d' | '30d' | 'all'>('7d');
 
   useEffect(() => {
-    if (connectionState === 'connected') {
-      loadUsageStats();
-    }
-  }, [connectionState]);
+    loadUsageStats();
+  }, [loadUsageStats]);
 
   const stats = usageStats || { totalSessions: 0, totalMessages: 0, totalTokens: 0, byModel: {} };
   const models = Object.entries(stats.byModel || {});
@@ -56,7 +52,7 @@ export function UsageStats() {
           </button>
         </div>
       </div>
-      <div className="text-xs text-gray-500 mb-4">本设备所有已保存对话的 Token 用量汇总。</div>
+      <div className="text-xs text-gray-500 mb-4">本设备所有已保存对话的使用统计。</div>
 
       {/* 主要统计卡片 */}
       <div className="grid grid-cols-4 gap-4 mb-8">
@@ -89,6 +85,9 @@ export function UsageStats() {
       {/* 总 Token 使用量概览 */}
       <div className="bg-white rounded-xl border border-gray-200 p-5 shadow-sm mb-6">
         <h3 className="text-sm font-semibold mb-4 text-gray-900">Token 使用概览</h3>
+        {stats.totalTokens === 0 ? (
+          <p className="text-xs text-gray-400">Token 用量将在后续版本中支持</p>
+        ) : (
         <div className="flex items-center gap-4">
           <div className="flex-1">
             <div className="flex justify-between text-xs text-gray-500 mb-1">
@@ -111,6 +110,7 @@ export function UsageStats() {
             <div className="text-xs text-gray-500">总计</div>
           </div>
         </div>
+        )}
       </div>
 
       {/* 按模型分组 */}

desktop/src/components/Settings/Workspace.tsx

@@ -7,18 +7,18 @@ export function Workspace() {
   const workspaceInfo = useConfigStore((s) => s.workspaceInfo);
   const loadWorkspaceInfo = useConfigStore((s) => s.loadWorkspaceInfo);
   const saveQuickConfig = useConfigStore((s) => s.saveQuickConfig);
-  const [projectDir, setProjectDir] = useState('~/.openfang/zclaw-workspace');
+  const [projectDir, setProjectDir] = useState('~/.zclaw/zclaw-workspace');
 
   useEffect(() => {
     loadWorkspaceInfo().catch(silentErrorHandler('Workspace'));
   }, []);
 
   useEffect(() => {
-    setProjectDir(quickConfig.workspaceDir || workspaceInfo?.path || '~/.openfang/zclaw-workspace');
+    setProjectDir(quickConfig.workspaceDir || workspaceInfo?.path || '~/.zclaw/zclaw-workspace');
   }, [quickConfig.workspaceDir, workspaceInfo?.path]);
 
   const handleWorkspaceBlur = async () => {
-    const nextValue = projectDir.trim() || '~/.openfang/zclaw-workspace';
+    const nextValue = projectDir.trim() || '~/.zclaw/zclaw-workspace';
     setProjectDir(nextValue);
     await saveQuickConfig({ workspaceDir: nextValue });
     await loadWorkspaceInfo();

desktop/src/components/SkillMarket.tsx

@@ -375,8 +375,10 @@ export function SkillMarket({
           />
         </div>
 
-        {/* Suggestions - placeholder for future AI-powered recommendations */}
-
+        {/* AI 智能推荐功能开发中 */}
+        <div className="text-xs text-gray-400 dark:text-gray-500 text-center py-1">
+          AI 智能推荐即将推出
+        </div>
       </div>
 
       {/* Category Filter */}

desktop/src/components/TriggersPanel.tsx

@@ -1,7 +1,7 @@
 /**
- * TriggersPanel - OpenFang Triggers Management UI
+ * TriggersPanel - ZCLAW Triggers Management UI
  *
- * Displays available OpenFang Triggers and allows creating and toggling them.
+ * Displays available ZCLAW Triggers and allows creating and toggling them.
  */
 
 import { useState, useEffect, useCallback } from 'react';

desktop/src/components/VikingPanel.tsx

@@ -1,8 +1,8 @@
 /**
- * VikingPanel - OpenViking Semantic Memory UI
+ * VikingPanel - ZCLAW Semantic Memory UI
  *
  * Provides interface for semantic search and knowledge base management.
- * OpenViking is an optional sidecar for semantic memory operations.
+ * Uses native Rust SqliteStorage with TF-IDF semantic search.
  */
 import { useState, useEffect } from 'react';
 import {
@@ -11,16 +11,13 @@ import {
   AlertCircle,
   CheckCircle,
   FileText,
-  Server,
-  Play,
-  Square,
+  Database,
 } from 'lucide-react';
 import {
   getVikingStatus,
   findVikingResources,
-  getVikingServerStatus,
-  startVikingServer,
-  stopVikingServer,
+  listVikingResources,
+  readVikingResource,
 } from '../lib/viking-client';
 import type { VikingStatus, VikingFindResult } from '../lib/viking-client';
 
@@ -30,17 +27,28 @@ export function VikingPanel() {
   const [searchQuery, setSearchQuery] = useState('');
   const [searchResults, setSearchResults] = useState<VikingFindResult[]>([]);
   const [isSearching, setIsSearching] = useState(false);
-  const [serverRunning, setServerRunning] = useState(false);
   const [message, setMessage] = useState<{ type: 'success' | 'error'; text: string } | null>(null);
+  const [memoryCount, setMemoryCount] = useState<number | null>(null);
+  const [expandedUri, setExpandedUri] = useState<string | null>(null);
+  const [expandedContent, setExpandedContent] = useState<string | null>(null);
+  const [isLoadingL2, setIsLoadingL2] = useState(false);
 
   const loadStatus = async () => {
     setIsLoading(true);
+    setMessage(null);
     try {
       const vikingStatus = await getVikingStatus();
       setStatus(vikingStatus);
 
-      const serverStatus = await getVikingServerStatus();
-      setServerRunning(serverStatus.running);
+      if (vikingStatus.available) {
+        // Load memory count
+        try {
+          const resources = await listVikingResources('/');
+          setMemoryCount(resources.length);
+        } catch {
+          setMemoryCount(null);
+        }
+      }
     } catch (error) {
       console.error('Failed to load Viking status:', error);
       setStatus({ available: false, error: String(error) });
@@ -74,22 +82,22 @@ export function VikingPanel() {
     }
   };
 
-  const handleServerToggle = async () => {
+  const handleExpandL2 = async (uri: string) => {
+    if (expandedUri === uri) {
+      setExpandedUri(null);
+      setExpandedContent(null);
+      return;
+    }
+
+    setExpandedUri(uri);
+    setIsLoadingL2(true);
     try {
-      if (serverRunning) {
-        await stopVikingServer();
-        setServerRunning(false);
-        setMessage({ type: 'success', text: '服务器已停止' });
-      } else {
-        await startVikingServer();
-        setServerRunning(true);
-        setMessage({ type: 'success', text: '服务器已启动' });
-      }
-    } catch (error) {
-      setMessage({
-        type: 'error',
-        text: `操作失败: ${error instanceof Error ? error.message : '未知错误'}`,
-      });
+      const fullContent = await readVikingResource(uri, 'L2');
+      setExpandedContent(fullContent);
+    } catch {
+      setExpandedContent(null);
+    } finally {
+      setIsLoadingL2(false);
     }
   };
 
@@ -100,7 +108,7 @@ export function VikingPanel() {
         <div>
           <h1 className="text-xl font-bold text-gray-900 dark:text-white">语义记忆</h1>
           <p className="text-xs text-gray-500 dark:text-gray-400 mt-1">
-            OpenViking 语义搜索引擎
+            ZCLAW 语义记忆搜索引擎
           </p>
         </div>
         <div className="flex gap-2 items-center">
@@ -125,10 +133,9 @@ export function VikingPanel() {
           <div className="flex items-start gap-2">
             <AlertCircle className="w-4 h-4 text-amber-500 mt-0.5" />
             <div className="text-xs text-amber-700 dark:text-amber-300">
-              <p className="font-medium">OpenViking CLI 不可用</p>
+              <p className="font-medium">语义记忆存储不可用</p>
               <p className="mt-1">
-                请安装 OpenViking CLI 或设置{' '}
-                <code className="bg-amber-100 dark:bg-amber-800 px-1 rounded">ZCLAW_VIKING_BIN</code> 环境变量。
+                本地 SQLite 存储初始化失败。请检查数据目录权限后重启应用。
               </p>
               {status?.error && (
                 <p className="mt-1 text-amber-600 dark:text-amber-400 font-mono text-xs">
@@ -158,47 +165,37 @@ export function VikingPanel() {
         </div>
       )}
 
-      {/* Server Control */}
+      {/* Storage Info */}
       {status?.available && (
         <div className="bg-white dark:bg-gray-800 rounded-xl border border-gray-200 dark:border-gray-700 p-4 mb-6 shadow-sm">
-          <div className="flex items-center justify-between">
-            <div className="flex items-center gap-3">
-              <div
-                className={`w-10 h-10 rounded-xl flex items-center justify-center ${
-                  serverRunning
-                    ? 'bg-gradient-to-br from-green-500 to-emerald-500 text-white'
-                    : 'bg-gray-200 dark:bg-gray-700 text-gray-400'
-                }`}
-              >
-                <Server className="w-4 h-4" />
+          <div className="flex items-center gap-3 mb-3">
+            <div className="w-10 h-10 rounded-xl bg-gradient-to-br from-blue-500 to-indigo-500 flex items-center justify-center">
+              <Database className="w-4 h-4 text-white" />
+            </div>
+            <div>
+              <div className="text-sm font-medium text-gray-900 dark:text-white">
+                本地存储
               </div>
-              <div>
-                <div className="text-sm font-medium text-gray-900 dark:text-white">
-                  Viking Server
-                </div>
-                <div className="text-xs text-gray-500 dark:text-gray-400">
-                  {serverRunning ? '运行中' : '已停止'}
-                </div>
+              <div className="text-xs text-gray-500 dark:text-gray-400">
+                {status.version || 'Native'} · {status.dataDir || '默认路径'}
               </div>
             </div>
-            <button
-              onClick={handleServerToggle}
-              className={`px-4 py-2 rounded-lg flex items-center gap-2 text-sm transition-colors ${
-                serverRunning
-                  ? 'bg-red-100 text-red-600 hover:bg-red-200 dark:bg-red-900/30 dark:text-red-400'
-                  : 'bg-green-100 text-green-600 hover:bg-green-200 dark:bg-green-900/30 dark:text-green-400'
-              }`}
-            >
-              {serverRunning ? (
-                <>
-                  <Square className="w-4 h-4" /> 停止
-                </>
-              ) : (
-                <>
-                  <Play className="w-4 h-4" /> 启动
-                </>
-              )}
-            </button>
+          </div>
+          <div className="flex gap-4 text-xs">
+            <div className="flex items-center gap-1.5 text-gray-600 dark:text-gray-300">
+              <CheckCircle className="w-3.5 h-3.5 text-green-500" />
+              <span>SQLite + FTS5</span>
+            </div>
+            <div className="flex items-center gap-1.5 text-gray-600 dark:text-gray-300">
+              <CheckCircle className="w-3.5 h-3.5 text-green-500" />
+              <span>TF-IDF 语义评分</span>
+            </div>
+            {memoryCount !== null && (
+              <div className="flex items-center gap-1.5 text-gray-600 dark:text-gray-300">
+                <CheckCircle className="w-3.5 h-3.5 text-green-500" />
+                <span>{memoryCount} 条记忆</span>
+              </div>
+            )}
           </div>
         </div>
       )}
@@ -251,21 +248,43 @@ export function VikingPanel() {
                     <span className="text-sm font-medium text-gray-900 dark:text-white truncate">
                       {result.uri}
                     </span>
-                    <span className="text-xs text-gray-400 bg-gray-100 dark:bg-gray-700 px-2 py-0.5 rounded">
+                    <span className={`text-xs px-2 py-0.5 rounded ${
+                      result.level === 'L1'
+                        ? 'text-green-600 bg-green-100 dark:bg-green-900/30 dark:text-green-400'
+                        : 'text-gray-400 bg-gray-100 dark:bg-gray-700'
+                    }`}>
                       {result.level}
                     </span>
                     <span className="text-xs text-blue-600 dark:text-blue-400">
                       {Math.round(result.score * 100)}%
                     </span>
                   </div>
-                  {result.overview && (
-                    <p className="text-xs text-gray-500 dark:text-gray-400 mt-1 line-clamp-2">
-                      {result.overview}
-                    </p>
-                  )}
-                  <p className="text-xs text-gray-600 dark:text-gray-300 mt-2 line-clamp-3 font-mono">
+                  <p className="text-xs text-gray-600 dark:text-gray-300 mt-2 line-clamp-3">
                     {result.content}
                   </p>
+                  {result.level === 'L1' && (
+                    <button
+                      onClick={() => handleExpandL2(result.uri)}
+                      className="mt-1.5 text-xs text-blue-500 hover:text-blue-600 dark:text-blue-400 dark:hover:text-blue-300 transition-colors"
+                    >
+                      {expandedUri === result.uri ? '收起全文' : '展开全文'}
+                    </button>
+                  )}
+                  {expandedUri === result.uri && (
+                    <div className="mt-2 p-3 bg-gray-50 dark:bg-gray-900/50 rounded-lg border border-gray-200 dark:border-gray-700">
+                      {isLoadingL2 ? (
+                        <div className="flex items-center gap-2 text-xs text-gray-400">
+                          <RefreshCw className="w-3 h-3 animate-spin" /> 加载中...
+                        </div>
+                      ) : expandedContent ? (
+                        <p className="text-xs text-gray-600 dark:text-gray-300 whitespace-pre-wrap font-mono">
+                          {expandedContent}
+                        </p>
+                      ) : (
+                        <p className="text-xs text-gray-400">加载失败</p>
+                      )}
+                    </div>
+                  )}
                 </div>
               </div>
             </div>
@@ -275,11 +294,11 @@ export function VikingPanel() {
 
       {/* Info Section */}
       <div className="mt-6 p-4 bg-gray-50 dark:bg-gray-800/50 rounded-lg border border-gray-200 dark:border-gray-700">
-        <h3 className="text-sm font-medium text-gray-900 dark:text-white mb-2">关于 OpenViking</h3>
+        <h3 className="text-sm font-medium text-gray-900 dark:text-white mb-2">关于语义记忆</h3>
         <ul className="text-xs text-gray-500 dark:text-gray-400 space-y-1">
-          <li>• 语义搜索引擎，支持自然语言查询</li>
-          <li>• 自动提取和索引知识资源</li>
-          <li>• 支持多种文档格式和代码文件</li>
+          <li>• 基于本地 SQLite + TF-IDF 的语义搜索引擎</li>
+          <li>• 自动提取和索引对话中的知识资源</li>
+          <li>• 支持自然语言查询知识库</li>
           <li>• 可作为本地知识库增强 AI 对话</li>
         </ul>
       </div>

desktop/src/components/WorkflowEditor.tsx

@@ -1,10 +1,10 @@
 /**
- * WorkflowEditor - OpenFang Workflow Editor Component
+ * WorkflowEditor - ZCLAW Workflow Editor Component
  *
  * Allows creating and editing multi-step workflows that chain
  * multiple Hands together for complex task automation.
  *
- * Design based on OpenFang Dashboard v0.4.0
+ * Design based on ZCLAW Dashboard v0.4.0
  */
 
 import { useState, useEffect, useCallback } from 'react';

desktop/src/components/WorkflowHistory.tsx

@@ -1,10 +1,10 @@
 /**
- * WorkflowHistory - OpenFang Workflow Execution History Component
+ * WorkflowHistory - ZCLAW Workflow Execution History Component
  *
  * Displays the execution history of a specific workflow,
  * showing run details, status, and results.
  *
- * Design based on OpenFang Dashboard v0.4.0
+ * Design based on ZCLAW Dashboard v0.4.0
  */
 
 import { useState, useEffect, useCallback } from 'react';

desktop/src/components/WorkflowList.tsx

@@ -1,15 +1,16 @@
 /**
- * WorkflowList - OpenFang Workflow Management UI
+ * WorkflowList - ZCLAW Workflow Management UI
  *
- * Displays available OpenFang Workflows and allows executing them.
+ * Displays available ZCLAW Workflows and allows executing them.
  *
- * Design based on OpenFang Dashboard v0.4.0
+ * Design based on ZCLAW Dashboard v0.4.0
  */
 
 import { useState, useEffect, useCallback } from 'react';
 import { useWorkflowStore, type Workflow } from '../store/workflowStore';
 import { WorkflowEditor } from './WorkflowEditor';
 import { WorkflowHistory } from './WorkflowHistory';
+import { WorkflowBuilder } from './WorkflowBuilder';
 import {
   Play,
   Edit,
@@ -467,18 +468,8 @@ export function WorkflowList() {
           </div>
         )
       ) : (
-        // Visual Builder View (placeholder)
-        <div className="p-8 text-center bg-white dark:bg-gray-800 rounded-lg border border-gray-200 dark:border-gray-700">
-          <div className="w-12 h-12 bg-gray-100 dark:bg-gray-700 rounded-full flex items-center justify-center mx-auto mb-3">
-            <GitBranch className="w-6 h-6 text-gray-400" />
-          </div>
-          <p className="text-sm text-gray-500 dark:text-gray-400 mb-2">
-            可视化工作流编辑器
-          </p>
-          <p className="text-xs text-gray-400 dark:text-gray-500">
-            拖拽式工作流编辑器即将推出！
-          </p>
-        </div>
+        // Visual Builder View
+        <WorkflowBuilder />
       )}
 
       {/* Execute Modal */}

desktop/src/hooks/useAutomationEvents.ts

@@ -1,7 +1,7 @@
 /**
  * useAutomationEvents - WebSocket Event Hook for Automation System
  *
- * Subscribes to hand and workflow events from OpenFang WebSocket
+ * Subscribes to hand and workflow events from ZCLAW WebSocket
  * and updates the corresponding stores.
  *
  * @module hooks/useAutomationEvents

desktop/src/lib/api-fallbacks.ts

@@ -1,7 +1,7 @@
 /**
  * API Fallbacks for ZCLAW Gateway
  *
- * Provides sensible default data when OpenFang API endpoints return 404.
+ * Provides sensible default data when ZCLAW API endpoints return 404.
  * This allows the UI to function gracefully even when backend features
  * are not yet implemented.
  */
@@ -178,7 +178,7 @@ export function getUsageStatsFallback(sessions: SessionForStats[] = []): UsageSt
 
 /**
  * Convert skills to plugin status when /api/plugins/status returns 404.
- * OpenFang uses Skills instead of traditional plugins.
+ * ZCLAW uses Skills instead of traditional plugins.
  */
 export function getPluginStatusFallback(skills: SkillForPlugins[] = []): PluginStatusFallback[] {
   if (skills.length === 0) {
@@ -215,7 +215,7 @@ export function getScheduledTasksFallback(triggers: TriggerForTasks[] = []): Sch
 
 /**
  * Default security status when /api/security/status returns 404.
- * OpenFang has 16 security layers - show them with conservative defaults.
+ * ZCLAW has 16 security layers - show them with conservative defaults.
  */
 export function getSecurityStatusFallback(): SecurityStatusFallback {
   const layers: SecurityLayerFallback[] = [

desktop/src/lib/config-parser.ts

@@ -1,7 +1,7 @@
 /**
- * OpenFang Configuration Parser
+ * ZCLAW Configuration Parser
  *
- * Provides configuration parsing, validation, and serialization for OpenFang TOML files.
+ * Provides configuration parsing, validation, and serialization for ZCLAW TOML files.
  *
  * @module lib/config-parser
  */
@@ -9,7 +9,7 @@
 import { tomlUtils, TomlParseError } from './toml-utils';
 import { DEFAULT_MODEL_ID, DEFAULT_PROVIDER } from '../constants/models';
 import type {
-  OpenFangConfig,
+  ZclawConfig,
   ConfigValidationResult,
   ConfigValidationError,
   ConfigValidationWarning,
@@ -64,7 +64,7 @@ const REQUIRED_FIELDS: Array<{ path: string; description: string }> = [
 /**
  * Default configuration values
  */
-const DEFAULT_CONFIG: Partial<OpenFangConfig> = {
+const DEFAULT_CONFIG: Partial<ZclawConfig> = {
   server: {
     host: '127.0.0.1',
     port: 4200,
@@ -74,7 +74,7 @@ const DEFAULT_CONFIG: Partial<OpenFangConfig> = {
   },
   agent: {
     defaults: {
-      workspace: '~/.openfang/workspace',
+      workspace: '~/.zclaw/workspace',
       default_model: DEFAULT_MODEL_ID,
     },
   },
@@ -89,7 +89,7 @@ const DEFAULT_CONFIG: Partial<OpenFangConfig> = {
  */
 export const configParser = {
   /**
-   * Parse TOML content into an OpenFang configuration object
+   * Parse TOML content into a ZCLAW configuration object
    *
    * @param content - The TOML content to parse
    * @param envVars - Optional environment variables for resolution
@@ -101,13 +101,13 @@ export const configParser = {
    * const config = configParser.parseConfig(tomlContent, { OPENAI_API_KEY: 'sk-...' });
    * ```
    */
-  parseConfig: (content: string, envVars?: Record<string, string | undefined>): OpenFangConfig => {
+  parseConfig: (content: string, envVars?: Record<string, string | undefined>): ZclawConfig => {
     try {
       // First resolve environment variables
       const resolved = tomlUtils.resolveEnvVars(content, envVars);
 
       // Parse TOML
-      const parsed = tomlUtils.parse<OpenFangConfig>(resolved);
+      const parsed = tomlUtils.parse<ZclawConfig>(resolved);
       return parsed;
     } catch (error) {
       if (error instanceof TomlParseError) {
@@ -121,7 +121,7 @@ export const configParser = {
   },
 
   /**
-   * Validate an OpenFang configuration object
+   * Validate a ZCLAW configuration object
    *
    * @param config - The configuration object to validate
    * @returns Validation result with errors and warnings
@@ -238,7 +238,7 @@ export const configParser = {
   parseAndValidate: (
     content: string,
     envVars?: Record<string, string | undefined>
-  ): OpenFangConfig => {
+  ): ZclawConfig => {
     const config = configParser.parseConfig(content, envVars);
     const result = configParser.validateConfig(config);
     if (!result.valid) {
@@ -261,7 +261,7 @@ export const configParser = {
    * const toml = configParser.stringifyConfig(config);
    * ```
    */
-  stringifyConfig: (config: OpenFangConfig): string => {
+  stringifyConfig: (config: ZclawConfig): string => {
     return tomlUtils.stringify(config as unknown as Record<string, unknown>);
   },
 
@@ -276,8 +276,8 @@ export const configParser = {
    * const fullConfig = configParser.mergeWithDefaults(partialConfig);
    * ```
    */
-  mergeWithDefaults: (config: Partial<OpenFangConfig>): OpenFangConfig => {
-    return deepMerge(DEFAULT_CONFIG, config) as unknown as OpenFangConfig;
+  mergeWithDefaults: (config: Partial<ZclawConfig>): ZclawConfig => {
+    return deepMerge(DEFAULT_CONFIG, config) as unknown as ZclawConfig;
   },
 
   /**
@@ -307,19 +307,19 @@ export const configParser = {
   /**
    * Get default configuration
    *
-   * @returns Default OpenFang configuration
+   * @returns Default ZCLAW configuration
    */
-  getDefaults: (): OpenFangConfig => {
-    return JSON.parse(JSON.stringify(DEFAULT_CONFIG)) as OpenFangConfig;
+  getDefaults: (): ZclawConfig => {
+    return JSON.parse(JSON.stringify(DEFAULT_CONFIG)) as ZclawConfig;
   },
 
   /**
    * Check if a configuration object is valid
    *
    * @param config - The configuration to check
-   * @returns Type guard for OpenFangConfig
+   * @returns Type guard for ZclawConfig
    */
-  isOpenFangConfig: (config: unknown): config is OpenFangConfig => {
+  isZclawConfig: (config: unknown): config is ZclawConfig => {
     const result = configParser.validateConfig(config);
     return result.valid;
   },

desktop/src/lib/gateway-api.ts

@@ -7,13 +7,13 @@
  *   - Agents (Clones)
  *   - Stats & Workspace
  *   - Config (Quick Config, Channels, Skills, Scheduler, Models)
- *   - Hands (OpenFang)
- *   - Workflows (OpenFang)
- *   - Sessions (OpenFang)
- *   - Triggers (OpenFang)
- *   - Audit (OpenFang)
- *   - Security (OpenFang)
- *   - Approvals (OpenFang)
+ *   - Hands (ZCLAW)
+ *   - Workflows (ZCLAW)
+ *   - Sessions (ZCLAW)
+ *   - Triggers (ZCLAW)
+ *   - Audit (ZCLAW)
+ *   - Security (ZCLAW)
+ *   - Approvals (ZCLAW)
  *
  * These methods are installed onto GatewayClient.prototype via installApiMethods().
  * The GatewayClient core class exposes restGet/restPost/restPut/restDelete/restPatch
@@ -179,7 +179,7 @@ export function installApiMethods(ClientClass: { prototype: GatewayClient }): vo
       const storedAutoStart = localStorage.getItem('zclaw-autoStart');
       const storedShowToolCalls = localStorage.getItem('zclaw-showToolCalls');
 
-      // Map OpenFang config to frontend expected format
+      // Map ZCLAW config to frontend expected format
       return {
         quickConfig: {
           agentName: 'ZCLAW',
@@ -220,15 +220,15 @@ export function installApiMethods(ClientClass: { prototype: GatewayClient }): vo
       localStorage.setItem('zclaw-showToolCalls', String(config.showToolCalls));
     }
 
-    // Map frontend config back to OpenFang format
-    const openfangConfig = {
+    // Map frontend config back to ZCLAW format
+    const zclawConfig = {
       data_dir: config.workspaceDir,
       default_model: config.defaultModel ? {
         model: config.defaultModel,
         provider: config.defaultProvider || 'bailian',
       } : undefined,
     };
-    return this.restPut('/api/config', openfangConfig);
+    return this.restPut('/api/config', zclawConfig);
   };
 
   // ─── Skills ───
@@ -333,7 +333,7 @@ export function installApiMethods(ClientClass: { prototype: GatewayClient }): vo
     return this.restPatch(`/api/scheduler/tasks/${id}`, { enabled });
   };
 
-  // ─── OpenFang Hands API ───
+  // ─── ZCLAW Hands API ───
 
   proto.listHands = async function (this: GatewayClient): Promise<{
     hands: {
@@ -407,7 +407,7 @@ export function installApiMethods(ClientClass: { prototype: GatewayClient }): vo
     return this.restGet(`/api/hands/${name}/runs?${params}`);
   };
 
-  // ─── OpenFang Workflows API ───
+  // ─── ZCLAW Workflows API ───
 
   proto.listWorkflows = async function (this: GatewayClient): Promise<{ workflows: { id: string; name: string; steps: number }[] }> {
     return this.restGet('/api/workflows');
@@ -476,7 +476,7 @@ export function installApiMethods(ClientClass: { prototype: GatewayClient }): vo
     return this.restDelete(`/api/workflows/${id}`);
   };
 
-  // ─── OpenFang Session API ───
+  // ─── ZCLAW Session API ───
 
   proto.listSessions = async function (this: GatewayClient, opts?: { limit?: number; offset?: number }): Promise<{
     sessions: Array<{
@@ -539,7 +539,7 @@ export function installApiMethods(ClientClass: { prototype: GatewayClient }): vo
     return this.restGet(`/api/sessions/${sessionId}/messages?${params}`);
   };
 
-  // ─── OpenFang Triggers API ───
+  // ─── ZCLAW Triggers API ───
 
   proto.listTriggers = async function (this: GatewayClient): Promise<{ triggers: { id: string; type: string; enabled: boolean }[] }> {
     return this.restGet('/api/triggers');
@@ -580,7 +580,7 @@ export function installApiMethods(ClientClass: { prototype: GatewayClient }): vo
     return this.restDelete(`/api/triggers/${id}`);
   };
 
-  // ─── OpenFang Audit API ───
+  // ─── ZCLAW Audit API ───
 
   proto.getAuditLogs = async function (this: GatewayClient, opts?: { limit?: number; offset?: number }): Promise<{ logs: unknown[] }> {
     const params = new URLSearchParams();
@@ -598,7 +598,7 @@ export function installApiMethods(ClientClass: { prototype: GatewayClient }): vo
     return this.restGet(`/api/audit/verify/${logId}`);
   };
 
-  // ─── OpenFang Security API ───
+  // ─── ZCLAW Security API ───
 
   proto.getSecurityStatus = async function (this: GatewayClient): Promise<{ layers: { name: string; enabled: boolean }[] }> {
     try {
@@ -626,7 +626,7 @@ export function installApiMethods(ClientClass: { prototype: GatewayClient }): vo
     }
   };
 
-  // ─── OpenFang Approvals API ───
+  // ─── ZCLAW Approvals API ───
 
   proto.listApprovals = async function (this: GatewayClient, status?: string): Promise<{
     approvals: {

desktop/src/lib/gateway-client.ts

@@ -1,7 +1,7 @@
-/**
+/**
  * ZCLAW Gateway Client (Browser/Tauri side)
  *
- * Core WebSocket client for OpenFang Kernel protocol.
+ * Core WebSocket client for ZCLAW Kernel protocol.
  * Handles connection management, WebSocket framing, heartbeat,
  * event dispatch, and chat/stream operations.
  *
@@ -22,7 +22,7 @@ export type {
   GatewayPong,
   GatewayFrame,
   AgentStreamDelta,
-  OpenFangStreamEvent,
+  ZclawStreamEvent,
   ConnectionState,
   EventCallback,
 } from './gateway-types';
@@ -51,7 +51,7 @@ import type {
   GatewayFrame,
   GatewayResponse,
   GatewayEvent,
-  OpenFangStreamEvent,
+  ZclawStreamEvent,
   ConnectionState,
   EventCallback,
   AgentStreamDelta,
@@ -158,7 +158,7 @@ function createIdempotencyKey(): string {
 
 export class GatewayClient {
   private ws: WebSocket | null = null;
-  private openfangWs: WebSocket | null = null;  // OpenFang stream WebSocket
+  private zclawWs: WebSocket | null = null;  // ZCLAW stream WebSocket
   private state: ConnectionState = 'disconnected';
   private requestId = 0;
   private pendingRequests = new Map<string, {
@@ -243,20 +243,20 @@ export class GatewayClient {
 
   // === Connection ===
 
-  /** Connect using REST API only (for OpenFang mode) */
+  /** Connect using REST API only (for ZCLAW mode) */
   async connectRest(): Promise<void> {
     if (this.state === 'connected') {
       return;
     }
     this.setState('connecting');
     try {
-      // Check if OpenFang API is healthy
+      // Check if ZCLAW API is healthy
       const health = await this.restGet<{ status: string; version?: string }>('/api/health');
       if (health.status === 'ok') {
         this.reconnectAttempts = 0;
         this.setState('connected');
         this.startHeartbeat(); // Start heartbeat after successful connection
-        this.log('info', `Connected to OpenFang via REST API${health.version ? ` (v${health.version})` : ''}`);
+        this.log('info', `Connected to ZCLAW via REST API${health.version ? ` (v${health.version})` : ''}`);
         this.emitEvent('connected', { version: health.version });
       } else {
         throw new Error('Health check failed');
@@ -264,7 +264,7 @@ export class GatewayClient {
     } catch (err: unknown) {
       this.setState('disconnected');
       const errorMessage = err instanceof Error ? err.message : String(err);
-      throw new Error(`Failed to connect to OpenFang: ${errorMessage}`);
+      throw new Error(`Failed to connect to ZCLAW: ${errorMessage}`);
     }
   }
 
@@ -273,7 +273,7 @@ export class GatewayClient {
       return Promise.resolve();
     }
 
-    // Check if URL is for OpenFang (port 4200 or 50051) - use REST mode
+    // Check if URL is for ZCLAW (port 4200 or 50051) - use REST mode
     if (this.url.includes(':4200') || this.url.includes(':50051')) {
       return this.connectRest();
     }
@@ -389,10 +389,10 @@ export class GatewayClient {
 
   // === High-level API ===
 
-  // Default agent ID for OpenFang (will be set dynamically from /api/agents)
+  // Default agent ID for ZCLAW (will be set dynamically from /api/agents)
   private defaultAgentId: string = '';
 
-  /** Try to fetch default agent ID from OpenFang /api/agents endpoint */
+  /** Try to fetch default agent ID from ZCLAW /api/agents endpoint */
   async fetchDefaultAgentId(): Promise<string | null> {
     try {
       // Use /api/agents endpoint which returns array of agents
@@ -422,7 +422,7 @@ export class GatewayClient {
     return this.defaultAgentId;
   }
 
-  /** Send message to agent (OpenFang chat API) */
+  /** Send message to agent (ZCLAW chat API) */
   async chat(message: string, opts?: {
     sessionKey?: string;
     agentId?: string;
@@ -432,24 +432,24 @@ export class GatewayClient {
     temperature?: number;
     maxTokens?: number;
   }): Promise<{ runId: string; sessionId?: string; response?: string }> {
-    // OpenFang uses /api/agents/{agentId}/message endpoint
+    // ZCLAW uses /api/agents/{agentId}/message endpoint
     let agentId = opts?.agentId || this.defaultAgentId;
 
-    // If no agent ID, try to fetch from OpenFang status
+    // If no agent ID, try to fetch from ZCLAW status
     if (!agentId) {
       await this.fetchDefaultAgentId();
       agentId = this.defaultAgentId;
     }
 
     if (!agentId) {
-      throw new Error('No agent available. Please ensure OpenFang has at least one agent.');
+      throw new Error('No agent available. Please ensure ZCLAW has at least one agent.');
     }
 
     const result = await this.restPost<{ response?: string; input_tokens?: number; output_tokens?: number }>(`/api/agents/${agentId}/message`, {
       message,
       session_id: opts?.sessionKey,
     });
-    // OpenFang returns { response, input_tokens, output_tokens }
+    // ZCLAW returns { response, input_tokens, output_tokens }
     return {
       runId: createIdempotencyKey(),
       sessionId: opts?.sessionKey,
@@ -457,7 +457,7 @@ export class GatewayClient {
     };
   }
 
-  /** Send message with streaming response (OpenFang WebSocket) */
+  /** Send message with streaming response (ZCLAW WebSocket) */
   async chatStream(
     message: string,
     callbacks: {
@@ -472,20 +472,20 @@ export class GatewayClient {
       agentId?: string;
     }
   ): Promise<{ runId: string }> {
-    let agentId = opts?.agentId || this.defaultAgentId;
+    const agentId = opts?.agentId || this.defaultAgentId;
     const runId = createIdempotencyKey();
     const sessionId = opts?.sessionKey || `session_${Date.now()}`;
 
-    // If no agent ID, try to fetch from OpenFang status (async, but we'll handle it in connectOpenFangStream)
+    // If no agent ID, try to fetch from ZCLAW status (async, but we'll handle it in connectZclawStream)
     if (!agentId) {
       // Try to get default agent asynchronously
       this.fetchDefaultAgentId().then(() => {
         const resolvedAgentId = this.defaultAgentId;
         if (resolvedAgentId) {
           this.streamCallbacks.set(runId, callbacks);
-          this.connectOpenFangStream(resolvedAgentId, runId, sessionId, message);
+          this.connectZclawStream(resolvedAgentId, runId, sessionId, message);
         } else {
-          callbacks.onError('No agent available. Please ensure OpenFang has at least one agent.');
+          callbacks.onError('No agent available. Please ensure ZCLAW has at least one agent.');
           callbacks.onComplete();
         }
       }).catch((err) => {
@@ -498,22 +498,22 @@ export class GatewayClient {
     // Store callbacks for this run
     this.streamCallbacks.set(runId, callbacks);
 
-    // Connect to OpenFang WebSocket if not connected
-    this.connectOpenFangStream(agentId, runId, sessionId, message);
+    // Connect to ZCLAW WebSocket if not connected
+    this.connectZclawStream(agentId, runId, sessionId, message);
 
     return { runId };
   }
 
-  /** Connect to OpenFang streaming WebSocket */
-  private connectOpenFangStream(
+  /** Connect to ZCLAW streaming WebSocket */
+  private connectZclawStream(
     agentId: string,
     runId: string,
     sessionId: string,
     message: string
   ): void {
     // Close existing connection if any
-    if (this.openfangWs && this.openfangWs.readyState !== WebSocket.CLOSED) {
-      this.openfangWs.close();
+    if (this.zclawWs && this.zclawWs.readyState !== WebSocket.CLOSED) {
+      this.zclawWs.close();
     }
 
     // Build WebSocket URL
@@ -528,34 +528,34 @@ export class GatewayClient {
       wsUrl = httpUrl.replace(/^http/, 'ws') + `/api/agents/${agentId}/ws`;
     }
 
-    this.log('info', `Connecting to OpenFang stream: ${wsUrl}`);
+    this.log('info', `Connecting to ZCLAW stream: ${wsUrl}`);
 
     try {
-      this.openfangWs = new WebSocket(wsUrl);
+      this.zclawWs = new WebSocket(wsUrl);
 
-      this.openfangWs.onopen = () => {
-        this.log('info', 'OpenFang WebSocket connected');
-        // Send chat message using OpenFang actual protocol
+      this.zclawWs.onopen = () => {
+        this.log('info', 'ZCLAW WebSocket connected');
+        // Send chat message using ZCLAW actual protocol
         const chatRequest = {
           type: 'message',
           content: message,
           session_id: sessionId,
         };
-        this.openfangWs?.send(JSON.stringify(chatRequest));
+        this.zclawWs?.send(JSON.stringify(chatRequest));
       };
 
-      this.openfangWs.onmessage = (event) => {
+      this.zclawWs.onmessage = (event) => {
         try {
           const data = JSON.parse(event.data);
-          this.handleOpenFangStreamEvent(runId, data, sessionId);
+          this.handleZclawStreamEvent(runId, data, sessionId);
         } catch (err: unknown) {
           const errorMessage = err instanceof Error ? err.message : String(err);
           this.log('error', `Failed to parse stream event: ${errorMessage}`);
         }
       };
 
-      this.openfangWs.onerror = (_event) => {
-        this.log('error', 'OpenFang WebSocket error');
+      this.zclawWs.onerror = (_event) => {
+        this.log('error', 'ZCLAW WebSocket error');
         const callbacks = this.streamCallbacks.get(runId);
         if (callbacks) {
           callbacks.onError('WebSocket connection failed');
@@ -563,14 +563,14 @@ export class GatewayClient {
         }
       };
 
-      this.openfangWs.onclose = (event) => {
-        this.log('info', `OpenFang WebSocket closed: ${event.code} ${event.reason}`);
+      this.zclawWs.onclose = (event) => {
+        this.log('info', `ZCLAW WebSocket closed: ${event.code} ${event.reason}`);
         const callbacks = this.streamCallbacks.get(runId);
         if (callbacks && event.code !== 1000) {
           callbacks.onError(`Connection closed: ${event.reason || 'unknown'}`);
         }
         this.streamCallbacks.delete(runId);
-        this.openfangWs = null;
+        this.zclawWs = null;
       };
     } catch (err: unknown) {
       const errorMessage = err instanceof Error ? err.message : String(err);
@@ -583,13 +583,13 @@ export class GatewayClient {
     }
   }
 
-  /** Handle OpenFang stream events */
-  private handleOpenFangStreamEvent(runId: string, data: OpenFangStreamEvent, sessionId: string): void {
+  /** Handle ZCLAW stream events */
+  private handleZclawStreamEvent(runId: string, data: ZclawStreamEvent, sessionId: string): void {
     const callbacks = this.streamCallbacks.get(runId);
     if (!callbacks) return;
 
     switch (data.type) {
-      // OpenFang actual event types
+      // ZCLAW actual event types
       case 'text_delta':
         // Stream delta content
         if (data.content) {
@@ -602,8 +602,8 @@ export class GatewayClient {
         if (data.phase === 'done') {
           callbacks.onComplete();
           this.streamCallbacks.delete(runId);
-          if (this.openfangWs) {
-            this.openfangWs.close(1000, 'Stream complete');
+          if (this.zclawWs) {
+            this.zclawWs.close(1000, 'Stream complete');
           }
         }
         break;
@@ -617,8 +617,8 @@ export class GatewayClient {
         // Mark complete if phase done wasn't sent
         callbacks.onComplete();
         this.streamCallbacks.delete(runId);
-        if (this.openfangWs) {
-          this.openfangWs.close(1000, 'Stream complete');
+        if (this.zclawWs) {
+          this.zclawWs.close(1000, 'Stream complete');
         }
         break;
 
@@ -649,14 +649,14 @@ export class GatewayClient {
       case 'error':
         callbacks.onError(data.message || data.code || data.content || 'Unknown error');
         this.streamCallbacks.delete(runId);
-        if (this.openfangWs) {
-          this.openfangWs.close(1011, 'Error');
+        if (this.zclawWs) {
+          this.zclawWs.close(1011, 'Error');
         }
         break;
 
       case 'connected':
         // Connection established
-        this.log('info', `OpenFang agent connected: ${data.agent_id}`);
+        this.log('info', `ZCLAW agent connected: ${data.agent_id}`);
         break;
 
       case 'agents_updated':
@@ -687,12 +687,12 @@ export class GatewayClient {
       callbacks.onError('Stream cancelled');
       this.streamCallbacks.delete(runId);
     }
-    if (this.openfangWs && this.openfangWs.readyState === WebSocket.OPEN) {
-      this.openfangWs.close(1000, 'User cancelled');
+    if (this.zclawWs && this.zclawWs.readyState === WebSocket.OPEN) {
+      this.zclawWs.close(1000, 'User cancelled');
     }
   }
 
-  // === REST API Helpers (OpenFang) ===
+  // === REST API Helpers (ZCLAW) ===
 
   public getRestBaseUrl(): string {
     // In browser dev mode, use Vite proxy (empty string = relative path)

desktop/src/lib/gateway-config.ts

@@ -1,5 +1,5 @@
 /**
- * OpenFang Gateway Configuration Types
+ * ZCLAW Gateway Configuration Types
  *
  * Types for gateway configuration and model choices.
  */

desktop/src/lib/gateway-storage.ts

@@ -42,7 +42,7 @@ export function isLocalhost(url: string): boolean {
 
 // === URL Constants ===
 
-// OpenFang endpoints (port 50051 - actual running port)
+// ZCLAW endpoints (port 50051 - actual running port)
 // Note: REST API uses relative path to leverage Vite proxy for CORS bypass
 export const DEFAULT_GATEWAY_URL = `${DEFAULT_WS_PROTOCOL}127.0.0.1:50051/ws`;
 export const REST_API_URL = ''; // Empty = use relative path (Vite proxy)

desktop/src/lib/gateway-types.ts

@@ -66,8 +66,8 @@ export interface AgentStreamDelta {
   workflowResult?: unknown;
 }
 
-/** OpenFang WebSocket stream event types */
-export interface OpenFangStreamEvent {
+/** ZCLAW WebSocket stream event types */
+export interface ZclawStreamEvent {
   type: 'text_delta' | 'phase' | 'response' | 'typing' | 'tool_call' | 'tool_result' | 'hand' | 'workflow' | 'error' | 'connected' | 'agents_updated';
   content?: string;
   phase?: 'streaming' | 'done';

desktop/src/lib/health-check.ts

@@ -2,7 +2,7 @@
  * Health Check Library
  *
  * Provides Tauri health check command wrappers and utilities
- * for monitoring the health status of the OpenFang backend.
+ * for monitoring the health status of the ZCLAW backend.
  */
 
 import { invoke } from '@tauri-apps/api/core';
@@ -19,7 +19,7 @@ export interface HealthCheckResult {
   details?: Record<string, unknown>;
 }
 
-export interface OpenFangHealthResponse {
+export interface ZclawHealthResponse {
   healthy: boolean;
   message?: string;
   details?: Record<string, unknown>;
@@ -43,7 +43,7 @@ export async function performHealthCheck(): Promise<HealthCheckResult> {
   }
 
   try {
-    const response = await invoke<OpenFangHealthResponse>('openfang_health_check');
+    const response = await invoke<ZclawHealthResponse>('zclaw_health_check');
 
     return {
       status: response.healthy ? 'healthy' : 'unhealthy',

desktop/src/lib/intelligence-backend.ts

@@ -239,6 +239,14 @@ export const memory = {
   async dbPath(): Promise<string> {
     return invoke('memory_db_path');
   },
+
+  async buildContext(
+    agentId: string,
+    query: string,
+    maxTokens: number | null,
+  ): Promise<{ systemPromptAddition: string; totalTokens: number; memoriesUsed: number }> {
+    return invoke('memory_build_context', { agentId, query, maxTokens });
+  },
 };
 
 // === Heartbeat API ===

desktop/src/lib/intelligence-client.ts

@@ -771,7 +771,7 @@ function saveSnapshotsToStorage(snapshots: IdentitySnapshot[]): void {
 }
 
 const fallbackIdentities = loadIdentitiesFromStorage();
-let fallbackProposals = loadProposalsFromStorage();
+const fallbackProposals = loadProposalsFromStorage();
 let fallbackSnapshots = loadSnapshotsFromStorage();
 
 const fallbackIdentity = {
@@ -1073,6 +1073,27 @@ export const intelligenceClient = {
       }
       return fallbackMemory.dbPath();
     },
+
+    buildContext: async (
+      agentId: string,
+      query: string,
+      maxTokens?: number,
+    ): Promise<{ systemPromptAddition: string; totalTokens: number; memoriesUsed: number }> => {
+      if (isTauriEnv()) {
+        return intelligence.memory.buildContext(agentId, query, maxTokens ?? null);
+      }
+      // Fallback: use basic search
+      const memories = await fallbackMemory.search({
+        agentId,
+        query,
+        limit: 8,
+        minImportance: 3,
+      });
+      const addition = memories.length > 0
+        ? `## 相关记忆\n${memories.map(m => `- [${m.type}] ${m.content}`).join('\n')}`
+        : '';
+      return { systemPromptAddition: addition, totalTokens: 0, memoriesUsed: memories.length };
+    },
   },
 
   heartbeat: {

desktop/src/lib/kernel-client.ts

@@ -2,7 +2,7 @@
  * ZCLAW Kernel Client (Tauri Internal)
  *
  * Client for communicating with the internal ZCLAW Kernel via Tauri commands.
- * This replaces the external OpenFang Gateway WebSocket connection.
+ * This replaces the external ZCLAW Gateway WebSocket connection.
  *
  * Phase 5 of Intelligence Layer Migration.
  */
@@ -648,24 +648,14 @@ export class KernelClient {
    * Approve a hand execution
    */
   async approveHand(name: string, runId: string, approved: boolean, reason?: string): Promise<{ status: string }> {
-    try {
-      return await invoke('hand_approve', { handName: name, runId, approved, reason });
-    } catch {
-      this.log('warn', `hand_approve not yet implemented, returning fallback`);
-      return { status: approved ? 'approved' : 'rejected' };
-    }
+    return await invoke('hand_approve', { handName: name, runId, approved, reason });
   }
 
   /**
    * Cancel a hand execution
    */
   async cancelHand(name: string, runId: string): Promise<{ status: string }> {
-    try {
-      return await invoke('hand_cancel', { handName: name, runId });
-    } catch {
-      this.log('warn', `hand_cancel not yet implemented, returning fallback`);
-      return { status: 'cancelled' };
-    }
+    return await invoke('hand_cancel', { handName: name, runId });
   }
 
   /**

desktop/src/lib/llm-service.ts

@@ -9,7 +9,7 @@
  * Supports multiple backends:
  * - OpenAI (GPT-4, GPT-3.5)
  * - Volcengine (Doubao)
- * - OpenFang Gateway (passthrough)
+ * - ZCLAW Gateway (passthrough)
  *
  * Part of ZCLAW L4 Self-Evolution capability.
  */
@@ -284,7 +284,7 @@ class VolcengineLLMAdapter implements LLMServiceAdapter {
   }
 }
 
-// === Gateway Adapter (pass through to OpenFang or internal Kernel) ===
+// === Gateway Adapter (pass through to ZCLAW or internal Kernel) ===
 
 class GatewayLLMAdapter implements LLMServiceAdapter {
   private config: LLMConfig;
@@ -346,7 +346,7 @@ class GatewayLLMAdapter implements LLMServiceAdapter {
       }
     }
 
-    // External Gateway mode: Use OpenFang's chat endpoint
+    // External Gateway mode: Use ZCLAW's chat endpoint
     const agentId = localStorage.getItem('zclaw-default-agent-id') || 'default';
 
     const response = await fetch(`/api/agents/${agentId}/message`, {
@@ -403,7 +403,7 @@ class GatewayLLMAdapter implements LLMServiceAdapter {
   }
 
   isAvailable(): boolean {
-    // Gateway is available if we're in browser (can connect to OpenFang)
+    // Gateway is available if we're in browser (can connect to ZCLAW)
     return typeof window !== 'undefined';
   }
 
@@ -460,7 +460,7 @@ export function loadConfig(): LLMConfig {
     // Ignore parse errors
   }
 
-  // Default to gateway (OpenFang passthrough) for L4 self-evolution
+  // Default to gateway (ZCLAW passthrough) for L4 self-evolution
   return DEFAULT_CONFIGS.gateway;
 }
 

desktop/src/lib/personality-presets.ts

@@ -239,12 +239,7 @@ export function generateWelcomeMessage(config: {
   const { userName, agentName, emoji, personality, scenarios } = config;
 
   // Build greeting
-  let greeting = '';
-  if (userName) {
-    greeting = `你好，${userName}！`;
-  } else {
-    greeting = '你好！';
-  }
+  const greeting = userName ? `你好，${userName}！` : '你好！';
 
   // Build introduction
   let intro = `我是${emoji ? ' ' + emoji : ''} ${agentName}`;

desktop/src/lib/security-utils.ts

@@ -41,7 +41,7 @@ export function escapeHtml(input: string): string {
   if (typeof input !== 'string') {
     return '';
   }
-  return input.replace(/[&<>"'`=\/]/g, char => HTML_ENTITIES[char] || char);
+  return input.replace(/[&<>"'`=/]/g, (char) => HTML_ENTITIES[char] || char);
 }
 
 /**
@@ -502,12 +502,13 @@ export function sanitizeFilename(filename: string): string {
   }
 
   // Remove path separators
-  let sanitized = filename.replace(/[\/\\]/g, '_');
+  let sanitized = filename.replace(/[/\\]/g, '_');
 
   // Remove null bytes
   sanitized = sanitized.replace(/\0/g, '');
 
   // Remove control characters
+  // eslint-disable-next-line no-control-regex
   sanitized = sanitized.replace(/[\x00-\x1f\x7f]/g, '');
 
   // Remove dangerous characters

desktop/src/lib/toml-utils.ts

@@ -1,7 +1,7 @@
 /**
  * TOML Utility Functions
  *
- * Provides TOML parsing and serialization capabilities for OpenFang configuration files.
+ * Provides TOML parsing and serialization capabilities for ZCLAW configuration files.
  * Supports environment variable interpolation in the format ${VAR_NAME}.
  *
  * @module toml-utils

desktop/src/lib/workflow-builder/yaml-converter.ts

@@ -369,7 +369,7 @@ export function yamlToCanvas(yamlString: string): WorkflowCanvas {
 
   // Convert steps to nodes
   if (pipeline.spec.steps) {
-    let x = 300;
+    const x = 300;
     let y = 50;
 
     for (const step of pipeline.spec.steps) {

desktop/src/store/agentStore.ts

@@ -6,6 +6,7 @@
  */
 import { create } from 'zustand';
 import type { GatewayClient } from '../lib/gateway-client';
+import { useChatStore } from './chatStore';
 
 // === Types ===
 
@@ -209,14 +210,25 @@ export const useAgentStore = create<AgentStore>((set, get) => ({
   },
 
   loadUsageStats: async () => {
-    const client = getClient();
-    if (!client) {
-      console.warn('[AgentStore] Client not initialized, skipping loadUsageStats');
-      return;
-    }
-
     try {
-      const stats = await client.getUsageStats();
+      const { conversations } = useChatStore.getState();
+
+      let totalMessages = 0;
+      for (const conversation of conversations) {
+        for (const message of conversation.messages) {
+          if (message.role === 'user' || message.role === 'assistant') {
+            totalMessages += 1;
+          }
+        }
+      }
+
+      const stats: UsageStats = {
+        totalSessions: conversations.length,
+        totalMessages,
+        totalTokens: 0,
+        byModel: {},
+      };
+
       set({ usageStats: stats });
     } catch {
       // Usage stats are non-critical, ignore errors silently

desktop/src/store/chatStore.ts

@@ -330,53 +330,28 @@ export const useChatStore = create<ChatState>()(
       return;
     }
 
-    // Check context compaction threshold before adding new message
-    try {
-      const messages = get().messages.map(m => ({ role: m.role, content: m.content }));
-      const check = await intelligenceClient.compactor.checkThreshold(messages);
-      if (check.should_compact) {
-        log.debug(`Context compaction triggered (${check.urgency}): ${check.current_tokens} tokens`);
-        const result = await intelligenceClient.compactor.compact(
-          get().messages.map(m => ({
-            role: m.role,
-            content: m.content,
-            id: m.id,
-            timestamp: m.timestamp instanceof Date ? m.timestamp.toISOString() : m.timestamp
-          })),
-          agentId,
-          get().currentConversationId ?? undefined
-        );
-        // Replace messages with compacted version
-        const compactedMsgs: Message[] = result.compacted_messages.map((m, i) => ({
-          id: m.id || `compacted_${i}_${Date.now()}`,
-          role: m.role as Message['role'],
-          content: m.content,
-          timestamp: m.timestamp ? new Date(m.timestamp) : new Date(),
-        }));
-        set({ messages: compactedMsgs });
-      }
-    } catch (err) {
-      log.warn('Context compaction check failed:', err);
-    }
+    // Context compaction is handled by the kernel (AgentLoop with_compaction_threshold).
+    // Frontend no longer performs duplicate compaction — see crates/zclaw-runtime/src/compaction.rs.
 
-    // Build memory-enhanced content
+    // Build memory-enhanced content using layered context (L0/L1/L2)
     let enhancedContent = content;
     try {
-      const relevantMemories = await intelligenceClient.memory.search({
+      const contextResult = await intelligenceClient.memory.buildContext(
         agentId,
-        query: content,
-        limit: 8,
-        minImportance: 3,
-      });
-      const memoryContext = relevantMemories.length > 0
-        ? `\n\n## 相关记忆\n${relevantMemories.map(m => `- [${m.type}] ${m.content}`).join('\n')}`
-        : '';
-      const systemPrompt = await intelligenceClient.identity.buildPrompt(agentId, memoryContext);
-      if (systemPrompt) {
-        enhancedContent = `<context>\n${systemPrompt}\n</context>\n\n${content}`;
+        content,
+        500, // token budget for memory context
+      );
+      if (contextResult.systemPromptAddition) {
+        const systemPrompt = await intelligenceClient.identity.buildPrompt(
+          agentId,
+          contextResult.systemPromptAddition,
+        );
+        if (systemPrompt) {
+          enhancedContent = `<context>\n${systemPrompt}\n</context>\n\n${content}`;
+        }
       }
     } catch (err) {
-      log.warn('Memory enhancement failed, proceeding without:', err);
+      log.warn('Memory context build failed, proceeding without:', err);
     }
 
     // Add user message (original content for display)
@@ -415,7 +390,7 @@ export const useChatStore = create<ChatState>()(
       // Declare runId before chatStream so callbacks can access it
       let runId = `run_${Date.now()}`;
 
-      // Try streaming first (OpenFang WebSocket)
+      // Try streaming first (ZCLAW WebSocket)
       const result = await client.chatStream(
         enhancedContent,
         {
@@ -571,7 +546,7 @@ export const useChatStore = create<ChatState>()(
           && m.streaming
           && (
             (delta.runId && m.runId === delta.runId)
-            || (!delta.runId && m.runId == null)
+            || (!delta.runId && m.runId === null)
           )
         ))
         || [...state.messages]
@@ -616,7 +591,7 @@ export const useChatStore = create<ChatState>()(
           }));
         }
       } else if (delta.stream === 'hand') {
-        // Handle Hand trigger events from OpenFang
+        // Handle Hand trigger events from ZCLAW
         const handMsg: Message = {
           id: `hand_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
           role: 'hand',
@@ -631,7 +606,7 @@ export const useChatStore = create<ChatState>()(
         };
         set((s) => ({ messages: [...s.messages, handMsg] }));
       } else if (delta.stream === 'workflow') {
-        // Handle Workflow execution events from OpenFang
+        // Handle Workflow execution events from ZCLAW
         const workflowMsg: Message = {
           id: `workflow_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
           role: 'workflow',

desktop/src/store/configStore.ts

@@ -8,6 +8,7 @@ import { create } from 'zustand';
 import type { GatewayModelChoice } from '../lib/gateway-config';
 import { setStoredGatewayUrl, setStoredGatewayToken } from '../lib/gateway-client';
 import type { GatewayClient } from '../lib/gateway-client';
+import { invoke } from '@tauri-apps/api/core';
 
 // === Types ===
 
@@ -654,9 +655,20 @@ function createConfigClientFromKernel(client: KernelClient): ConfigStoreClient {
     createChannel: async () => null,
     updateChannel: async () => null,
     deleteChannel: async () => {},
-    listScheduledTasks: async () => ({ tasks: [] }),
-    createScheduledTask: async () => {
-      throw new Error('Scheduled tasks not supported in KernelClient');
+    listScheduledTasks: async () => {
+      try {
+        const tasks = await invoke<ScheduledTask[]>('scheduled_task_list');
+        return { tasks };
+      } catch {
+        return { tasks: [] };
+      }
+    },
+    createScheduledTask: async (task) => {
+      const result = await invoke<{ id: string; name: string; schedule: string; status: string }>(
+        'scheduled_task_create',
+        { request: task },
+      );
+      return { ...result, status: result.status as 'active' | 'paused' | 'completed' | 'error' };
     },
     listModels: async () => {
       try {

desktop/src/store/gatewayStore.ts

@@ -249,7 +249,7 @@ interface GatewayFacade {
   modelsLoading: boolean;
   modelsError: string | null;
 
-  // OpenFang Data
+  // ZCLAW Data
   hands: Hand[];
   handRuns: Record<string, HandRun[]>;
   workflows: Workflow[];

desktop/src/store/handStore.ts

@@ -2,7 +2,7 @@
  * handStore.ts - Hand, Trigger, and Approval management store
  *
  * Extracted from gatewayStore.ts for Phase 11 Store Refactoring.
- * Manages OpenFang Hands, Triggers, and Approval workflows.
+ * Manages ZCLAW Hands, Triggers, and Approval workflows.
  */
 import { create } from 'zustand';
 import type { GatewayClient } from '../lib/gateway-client';

desktop/src/store/securityStore.ts

@@ -1,10 +1,11 @@
 /**
  * securityStore.ts - Security Status and Audit Log Management
  *
- * Extracted from gatewayStore.ts for Store Refactoring.
- * Manages OpenFang security layers, security status, and audit logs.
+ * Manages ZCLAW security layers, security status, and audit logs.
+ * Uses local security checks (security-index.ts + Tauri commands) instead of REST API.
  */
 import { create } from 'zustand';
+import { invoke } from '@tauri-apps/api/core';
 import type { GatewayClient } from '../lib/gateway-client';
 
 // === Types ===
@@ -29,7 +30,7 @@ export interface AuditLogEntry {
   actor?: string;
   result?: 'success' | 'failure';
   details?: Record<string, unknown>;
-  // Merkle hash chain fields (OpenFang)
+  // Merkle hash chain fields
   hash?: string;
   previousHash?: string;
 }
@@ -45,6 +46,160 @@ function calculateSecurityLevel(enabledCount: number, totalCount: number): 'crit
   return 'low';                          // 0-5 layers
 }
 
+/**
+ * Check if OS Keyring (secure store) is available via Tauri command.
+ * Returns false if not in Tauri environment or if keyring is unavailable.
+ */
+async function checkKeyringAvailable(): Promise<boolean> {
+  try {
+    return await invoke<boolean>('secure_store_is_available');
+  } catch {
+    // Not in Tauri environment or command failed
+    return false;
+  }
+}
+
+/**
+ * Check if the ZCLAW Kernel is initialized via Tauri command.
+ */
+async function checkKernelInitialized(): Promise<boolean> {
+  try {
+    const status = await invoke<{ initialized: boolean }>('kernel_status');
+    return status.initialized;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Build the 16-layer security model from local security checks.
+ */
+async function buildLocalSecurityLayers(): Promise<SecurityLayer[]> {
+  // Gather local security status
+  let auditEnabled = false;
+  let keychainAvailable = false;
+  let chatStorageInitialized = false;
+
+  try {
+    const { getSecurityStatus } = await import('../lib/security-index');
+    const status = await getSecurityStatus();
+    auditEnabled = status.auditEnabled;
+    keychainAvailable = status.keychainAvailable;
+    chatStorageInitialized = status.chatStorageInitialized;
+  } catch {
+    // Security module not available - use defaults
+  }
+
+  // Check OS Keyring availability directly via Tauri
+  const keyringAvailable = await checkKeyringAvailable();
+  const kernelInitialized = await checkKernelInitialized();
+
+  // Use keychainAvailable from security-index as primary, keyringAvailable as fallback
+  const hasSecureStorage = keychainAvailable || keyringAvailable;
+
+  // Map local security capabilities to the 16-layer security model
+  const layers: SecurityLayer[] = [
+    {
+      name: 'input.validation',
+      enabled: true,
+      description: 'security-utils.ts provides input validation and sanitization',
+    },
+    {
+      name: 'output.filter',
+      enabled: true,
+      description: 'security-utils.ts provides output sanitization and content filtering',
+    },
+    {
+      name: 'rate.limit',
+      enabled: true,
+      description: 'security-utils.ts provides rate limiting',
+    },
+    {
+      name: 'auth.identity',
+      enabled: hasSecureStorage,
+      description: hasSecureStorage
+        ? 'OS Keyring available for secure identity storage'
+        : 'OS Keyring not available',
+    },
+    {
+      name: 'incident.response',
+      enabled: auditEnabled,
+      description: auditEnabled
+        ? 'Automated incident detection and alerting via audit events'
+        : 'Requires audit logging for incident response',
+    },
+    {
+      name: 'session.management',
+      enabled: true,
+      description: 'Session management is always active',
+    },
+    {
+      name: 'auth.rbac',
+      enabled: hasSecureStorage,
+      description: hasSecureStorage
+        ? 'Device authentication and role-based access available'
+        : 'Requires OS Keyring for device authentication',
+    },
+    {
+      name: 'encryption',
+      enabled: chatStorageInitialized,
+      description: chatStorageInitialized
+        ? 'Encrypted chat storage is initialized (AES-256-GCM)'
+        : 'Encrypted storage not yet initialized',
+    },
+    {
+      name: 'audit.logging',
+      enabled: auditEnabled,
+      description: auditEnabled
+        ? 'Security audit logging is active'
+        : 'Audit logging is disabled',
+    },
+    {
+      name: 'integrity',
+      enabled: auditEnabled,
+      description: auditEnabled
+        ? 'Integrity verification enabled via audit log'
+        : 'Requires audit logging for integrity verification',
+    },
+    {
+      name: 'sandbox',
+      enabled: true,
+      description: 'Tauri sandbox provides process isolation',
+    },
+    {
+      name: 'network.security',
+      enabled: true,
+      description: 'WSS enforced, CSP headers active',
+    },
+    {
+      name: 'resource.limits',
+      enabled: true,
+      description: 'Path validation and timeout limits active',
+    },
+    {
+      name: 'capability.gates',
+      enabled: kernelInitialized,
+      description: kernelInitialized
+        ? 'Kernel capability gates active'
+        : 'Kernel not yet initialized',
+    },
+    {
+      name: 'prompt.defense',
+      enabled: true,
+      description: 'Input sanitization includes prompt injection defense',
+    },
+    {
+      name: 'anomaly.detection',
+      enabled: auditEnabled,
+      description: auditEnabled
+        ? 'Anomaly detection via security audit events'
+        : 'Requires audit logging for anomaly detection',
+    },
+  ];
+
+  return layers;
+}
+
 // === Client Interface ===
 
 interface SecurityClient {
@@ -81,32 +236,22 @@ export const useSecurityStore = create<SecurityStore>((set, get) => ({
   client: null,
 
   loadSecurityStatus: async () => {
-    const client = get().client;
-    if (!client) return;
-
     set({ securityStatusLoading: true, securityStatusError: null });
     try {
-      const result = await client.getSecurityStatus();
-      if (result?.layers) {
-        const layers = result.layers as SecurityLayer[];
-        const enabledCount = layers.filter(l => l.enabled).length;
-        const totalCount = layers.length;
-        const securityLevel = calculateSecurityLevel(enabledCount, totalCount);
-        set({
-          securityStatus: { layers, enabledCount, totalCount, securityLevel },
-          securityStatusLoading: false,
-          securityStatusError: null,
-        });
-      } else {
-        set({
-          securityStatusLoading: false,
-          securityStatusError: 'API returned no data',
-        });
-      }
+      const layers = await buildLocalSecurityLayers();
+      const enabledCount = layers.filter(l => l.enabled).length;
+      const totalCount = layers.length;
+      const securityLevel = calculateSecurityLevel(enabledCount, totalCount);
+      set({
+        securityStatus: { layers, enabledCount, totalCount, securityLevel },
+        securityStatusLoading: false,
+        securityStatusError: null,
+      });
     } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err);
       set({
         securityStatusLoading: false,
-        securityStatusError: (err instanceof Error ? err.message : String(err)) || 'Security API not available',
+        securityStatusError: message || 'Failed to detect security status',
       });
     }
   },

desktop/src/types/agent.ts

@@ -1,12 +1,12 @@
 /**
- * Agent Type Definitions for OpenFang
+ * Agent Type Definitions for ZCLAW
  *
  * These types define the Agent entity structure and related configurations
- * for the OpenFang desktop client.
+ * for the ZCLAW desktop client.
  */
 
 /**
- * Represents an Agent instance in OpenFang runtime
+ * Represents an Agent instance in ZCLAW runtime
  */
 export interface Agent {
   /** Unique identifier for the agent */

desktop/src/types/api-responses.ts

@@ -1,8 +1,8 @@
 /**
- * API Response Types for OpenFang/ZCLAW
+ * API Response Types for ZCLAW
  *
  * Standard response envelope types for all API interactions with the
- * OpenFang Kernel. These types provide a consistent interface for
+ * ZCLAW Kernel. These types provide a consistent interface for
  * handling API responses, errors, and pagination across the application.
  *
  * @module types/api-responses

desktop/src/types/config.ts

@@ -1,7 +1,7 @@
 /**
- * OpenFang Configuration Type Definitions
+ * ZCLAW Configuration Type Definitions
  *
- * TypeScript types for OpenFang TOML configuration files.
+ * TypeScript types for ZCLAW TOML configuration files.
  * These types correspond to the configuration schema in config/config.toml.
  *
  * @module types/config
@@ -491,9 +491,9 @@ export interface DevelopmentConfig {
 // ============================================================
 
 /**
- * Complete OpenFang configuration
+ * Complete ZCLAW configuration
  */
-export interface OpenFangConfig {
+export interface ZclawConfig {
   /** Server settings */
   server: ServerConfig;
   /** Agent settings */

desktop/src/types/errors.ts

@@ -1,8 +1,8 @@
 /**
- * Error Type Hierarchy for OpenFang/ZCLAW
+ * Error Type Hierarchy for ZCLAW
  *
  * Comprehensive error types for type-safe error handling across
- * the OpenFang desktop client application.
+ * the ZCLAW desktop client application.
  *
  * @module types/errors
  */
@@ -193,7 +193,7 @@ export class ForbiddenError extends AppError {
 /**
  * RBAC Permission denied error
  *
- * Specific to OpenFang's role-based access control system.
+ * Specific to ZCLAW's role-based access control system.
  */
 export class RBACPermissionDeniedError extends AppError {
   constructor(
@@ -285,7 +285,7 @@ export class JsonParseError extends AppError {
 /**
  * TOML parsing errors
  *
- * Specific to OpenFang's TOML configuration format.
+ * Specific to ZCLAW's TOML configuration format.
  */
 export class TomlParseError extends AppError {
   constructor(
@@ -518,7 +518,7 @@ export class KeyringUnavailableError extends StorageError {
 /**
  * Hand execution errors
  *
- * Specific to OpenFang's Hands system for autonomous capabilities.
+ * Specific to ZCLAW's Hands system for autonomous capabilities.
  */
 export class HandExecutionError extends AppError {
   public readonly handId: string;

desktop/src/types/hands.ts

@@ -1,5 +1,5 @@
 /**
- * OpenFang Hands and Workflow Types
+ * ZCLAW Hands and Workflow Types
  *
  * ZCLAW 提供 8 个自主能力包 (Hands)：
  * - Clip: 视频处理

desktop/src/types/index.ts

@@ -1,8 +1,8 @@
 /**
- * OpenFang Type Definitions
+ * ZCLAW Type Definitions
  *
  * This module exports all TypeScript type definitions for the
- * OpenFang desktop client application.
+ * ZCLAW desktop client application.
  *
  * @module types
  */

desktop/src/types/session.ts

@@ -1,8 +1,8 @@
 /**
- * Session Type Definitions for OpenFang
+ * Session Type Definitions for ZCLAW
  *
  * These types define the Session and message structures
- * for conversation management in the OpenFang desktop client.
+ * for conversation management in the ZCLAW desktop client.
  */
 
 /**

desktop/src/types/settings.ts

@@ -1,8 +1,8 @@
 /**
- * Settings Type Definitions for OpenFang
+ * Settings Type Definitions for ZCLAW
  *
  * These types define the configuration and settings structures
- * for the OpenFang desktop client.
+ * for the ZCLAW desktop client.
  */
 
 /**
@@ -33,7 +33,7 @@ export interface QuickConfig {
   workspaceDir?: string;
 
   // Gateway Configuration
-  /** URL for the OpenFang gateway server */
+  /** URL for the ZCLAW gateway server */
   gatewayUrl?: string;
   /** Authentication token for gateway */
   gatewayToken?: string;

desktop/src/types/workflow.ts

@@ -1,14 +1,14 @@
 /**
- * Workflow Type Definitions for OpenFang
+ * Workflow Type Definitions for ZCLAW
  *
  * This module defines all TypeScript types related to workflow
- * management, execution, and monitoring in the OpenFang system.
+ * management, execution, and monitoring in the ZCLAW system.
  *
  * @module types/workflow
  */
 
 /**
- * Types of workflow steps available in OpenFang
+ * Types of workflow steps available in ZCLAW
  */
 export type WorkflowStepType =
   | 'hand'      // Execute a Hand (autonomous capability)

desktop/tests/config-parser.test.ts

@@ -10,11 +10,11 @@ import {
   ConfigParseError,
   ConfigValidationFailedError,
 } from '../src/lib/config-parser';
-import type { OpenFangConfig } from '../src/types/config';
+import type { ZclawConfig } from '../src/types/config';
 
 describe('configParser', () => {
   const validToml = `
-# Valid OpenFang configuration
+# Valid ZCLAW configuration
 [server]
 host = "127.0.0.1"
 port = 4200
@@ -23,7 +23,7 @@ websocket_port = 4200
 websocket_path = "/ws"
 
 [agent.defaults]
-workspace = "~/.openfang/workspace"
+workspace = "~/.zclaw/workspace"
 default_model = "gpt-4"
 
 [llm]
@@ -44,7 +44,7 @@ default_model = "gpt-4"
       });
       expect(config.agent).toBeDefined();
       expect(config.agent.defaults).toEqual({
-        workspace: '~/.openfang/workspace',
+        workspace: '~/.zclaw/workspace',
         default_model: 'gpt-4',
       });
       expect(config.llm).toEqual({
@@ -57,14 +57,14 @@ default_model = "gpt-4"
 
   describe('validateConfig', () => {
     it('should validate correct configuration', () => {
-      const config: OpenFangConfig = {
+      const config: ZclawConfig = {
         server: {
           host: '127.0.0.1',
           port: 4200,
         },
         agent: {
           defaults: {
-            workspace: '~/.openfang/workspace',
+            workspace: '~/.zclaw/workspace',
             default_model: 'gpt-4',
           },
         },
@@ -102,7 +102,7 @@ default_model = "gpt-4"
         },
         agent: {
           defaults: {
-            workspace: '~/.openfang/workspace',
+            workspace: '~/.zclaw/workspace',
             default_model: 'gpt-4',
           },
         },
@@ -127,7 +127,7 @@ default_model = "gpt-4"
         },
         agent: {
           defaults: {
-            workspace: '~/.openfang/workspace',
+            workspace: '~/.zclaw/workspace',
             default_model: '',
           },
         },
@@ -163,14 +163,14 @@ host = "127.0.0.1"
 
   describe('stringifyConfig', () => {
     it('should stringify configuration to TOML', () => {
-      const config: OpenFangConfig = {
+      const config: ZclawConfig = {
         server: {
           host: '127.0.0.1',
           port: 4200,
         },
         agent: {
           defaults: {
-            workspace: '~/.openfang/workspace',
+            workspace: '~/.zclaw/workspace',
             default_model: 'gpt-4',
           },
         },
@@ -232,16 +232,16 @@ port = 4200
     });
   });
 
-  describe('isOpenFangConfig', () => {
+  describe('isZclawConfig', () => {
     it('should return true for valid config', () => {
-      const config: OpenFangConfig = {
+      const config: ZclawConfig = {
         server: {
           host: '127.0.0.1',
           port: 4200,
         },
         agent: {
           defaults: {
-            workspace: '~/.openfang/workspace',
+            workspace: '~/.zclaw/workspace',
             default_model: 'gpt-4',
           },
         },
@@ -251,12 +251,12 @@ port = 4200
         },
       };
 
-      expect(configParser.isOpenFangConfig(config)).toBe(true);
+      expect(configParser.isZclawConfig(config)).toBe(true);
     });
 
     it('should return false for invalid config', () => {
-      expect(configParser.isOpenFangConfig(null)).toBe(false);
-      expect(configParser.isOpenFangConfig({})).toBe(false);
+      expect(configParser.isZclawConfig(null)).toBe(false);
+      expect(configParser.isZclawConfig({})).toBe(false);
     });
   });
 });

desktop/tests/e2e/zclaw-compat/fixtures/openfang-responses.ts

@@ -1,11 +1,11 @@
 /**
- * OpenFang 真实响应数据模板
+ * ZCLAW 真实响应数据模板
  *
- * 用于 E2E 测试的 OpenFang API 响应数据模板。
- * 基于 OpenFang Gateway Protocol v3 规范。
+ * 用于 E2E 测试的 ZCLAW API 响应数据模板。
+ * 基于 ZCLAW Gateway Protocol v3 规范。
  */
 
-export const openFangResponses = {
+export const zclawResponses = {
   health: {
     status: 'ok',
     version: '0.4.0',
@@ -155,7 +155,7 @@ export const openFangResponses = {
   },
 
   config: {
-    data_dir: '/Users/user/.openfang',
+    data_dir: '/Users/user/.zclaw',
     default_model: 'qwen3.5-plus',
     log_level: 'info',
   },

desktop/tests/e2e/zclaw-compat/specs/api-endpoints.spec.ts

@@ -1,77 +1,77 @@
 /**
- * OpenFang API 端点兼容性测试
+ * ZCLAW API 端点兼容性测试
  *
- * 验证 ZCLAW 前端与 OpenFang 后端的 REST API 兼容性。
+ * 验证 ZCLAW 前端与 ZCLAW 后端的 REST API 兼容性。
  */
 
 import { test, expect, Page } from '@playwright/test';
-import { openFangResponses } from '../fixtures/openfang-responses';
+import { zclawResponses } from '../fixtures/zclaw-responses';
 
 const BASE_URL = 'http://localhost:1420';
 
 async function setupMockAPI(page: Page) {
   await page.route('**/api/health', async route => {
-    await route.fulfill({ json: openFangResponses.health });
+    await route.fulfill({ json: zclawResponses.health });
   });
 
   await page.route('**/api/status', async route => {
-    await route.fulfill({ json: openFangResponses.status });
+    await route.fulfill({ json: zclawResponses.status });
   });
 
   await page.route('**/api/agents', async route => {
     if (route.request().method() === 'GET') {
-      await route.fulfill({ json: openFangResponses.agents });
+      await route.fulfill({ json: zclawResponses.agents });
     } else if (route.request().method() === 'POST') {
       await route.fulfill({ json: { clone: { id: 'new-agent-001', name: 'New Agent' } } });
     }
   });
 
   await page.route('**/api/agents/*', async route => {
-    await route.fulfill({ json: openFangResponses.agent });
+    await route.fulfill({ json: zclawResponses.agent });
   });
 
   await page.route('**/api/models', async route => {
-    await route.fulfill({ json: openFangResponses.models });
+    await route.fulfill({ json: zclawResponses.models });
   });
 
   await page.route('**/api/hands', async route => {
-    await route.fulfill({ json: openFangResponses.hands });
+    await route.fulfill({ json: zclawResponses.hands });
   });
 
   await page.route('**/api/hands/*', async route => {
     if (route.request().method() === 'GET') {
-      await route.fulfill({ json: openFangResponses.hand });
+      await route.fulfill({ json: zclawResponses.hand });
     } else if (route.request().url().includes('/activate')) {
-      await route.fulfill({ json: openFangResponses.handActivation });
+      await route.fulfill({ json: zclawResponses.handActivation });
     }
   });
 
   await page.route('**/api/workflows', async route => {
-    await route.fulfill({ json: openFangResponses.workflows });
+    await route.fulfill({ json: zclawResponses.workflows });
   });
 
   await page.route('**/api/workflows/*', async route => {
-    await route.fulfill({ json: openFangResponses.workflow });
+    await route.fulfill({ json: zclawResponses.workflow });
   });
 
   await page.route('**/api/sessions', async route => {
-    await route.fulfill({ json: openFangResponses.sessions });
+    await route.fulfill({ json: zclawResponses.sessions });
   });
 
   await page.route('**/api/config', async route => {
-    await route.fulfill({ json: openFangResponses.config });
+    await route.fulfill({ json: zclawResponses.config });
   });
 
   await page.route('**/api/channels', async route => {
-    await route.fulfill({ json: openFangResponses.channels });
+    await route.fulfill({ json: zclawResponses.channels });
   });
 
   await page.route('**/api/skills', async route => {
-    await route.fulfill({ json: openFangResponses.skills });
+    await route.fulfill({ json: zclawResponses.skills });
   });
 }
 
-test.describe('OpenFang API 端点兼容性测试', () => {
+test.describe('ZCLAW API 端点兼容性测试', () => {
 
   test.describe('API-01: Health 端点', () => {
     test('应返回正确的健康状态', async ({ page }) => {

desktop/tests/e2e/zclaw-compat/specs/protocol-compat.spec.ts

@@ -1,15 +1,15 @@
 /**
- * OpenFang 协议兼容性测试
+ * ZCLAW 协议兼容性测试
  *
- * 验证 ZCLAW 前端与 OpenFang 后端的协议兼容性。
+ * 验证 ZCLAW 前端与 ZCLAW 后端的协议兼容性。
  */
 
 import { test, expect } from '@playwright/test';
-import { openFangResponses, streamEvents, gatewayFrames } from '../fixtures/openfang-responses';
+import { zclawResponses, streamEvents, gatewayFrames } from '../fixtures/zclaw-responses';
 
 const BASE_URL = 'http://localhost:1420';
 
-test.describe('OpenFang 协议兼容性测试', () => {
+test.describe('ZCLAW 协议兼容性测试', () => {
 
   test.describe('PROTO-01: 流事件类型解析', () => {
     test('应正确解析 text_delta 事件', () => {

desktop/tests/setup.ts

@@ -23,8 +23,8 @@ vi.mock('../src/lib/tauri-gateway', () => ({
   getLocalGatewayAuth: vi.fn(),
   prepareLocalGatewayForTauri: vi.fn(),
   approveLocalGatewayDevicePairing: vi.fn(),
-  getOpenFangProcessList: vi.fn(),
-  getOpenFangProcessLogs: vi.fn(),
+  getZclawProcessList: vi.fn(),
+  getZclawProcessLogs: vi.fn(),
   getUnsupportedLocalGatewayStatus: vi.fn(() => ({
     supported: false,
     cliAvailable: false,

desktop/tests/store/chatStore.test.ts

@@ -572,40 +572,6 @@ describe('chatStore', () => {
     });
   });
 
-  describe('dispatchSwarmTask', () => {
-    it('should return task id on success', async () => {
-      const { dispatchSwarmTask } = useChatStore.getState();
-
-      const result = await dispatchSwarmTask('Test task');
-
-      expect(result).toBe('task-1');
-    });
-
-    it('should add swarm result message', async () => {
-      const { dispatchSwarmTask } = useChatStore.getState();
-
-      await dispatchSwarmTask('Test task');
-
-      const state = useChatStore.getState();
-      const swarmMsg = state.messages.find(m => m.role === 'assistant');
-      expect(swarmMsg).toBeDefined();
-    });
-
-    it('should return null on failure', async () => {
-      const { dispatchSwarmTask } = useChatStore.getState();
-
-      // Mock the agent-swarm module to throw
-      vi.doMock('../../src/lib/agent-swarm', () => ({
-        getAgentSwarm: vi.fn(() => {
-          throw new Error('Swarm error');
-        }),
-      }));
-
-      // Since we can't easily re-mock, just verify the function exists
-      expect(typeof dispatchSwarmTask).toBe('function');
-    });
-  });
-
   describe('message types', () => {
     it('should handle tool message', () => {
       const { addMessage } = useChatStore.getState();

desktop/vite.config.ts

@@ -29,8 +29,8 @@ export default defineConfig(async () => ({
       ignored: ["**/src-tauri/**"],
     },
     proxy: {
-      // Proxy /api requests to OpenFang Kernel (port 50051 - actual running port)
-      // OpenFang is managed by Tauri app - started via gateway_start command
+      // Proxy /api requests to ZCLAW Kernel (port 50051 - actual running port)
+      // ZCLAW is managed by Tauri app - started via gateway_start command
       '/api': {
         target: 'http://127.0.0.1:50051',
         changeOrigin: true,