@sinm/kai 1.9.2 → 1.9.3

package/dist-cli/kai-cli.js

@@ -34,7 +34,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/shared/ipc-events.ts
-var IPC_SEND_USER_MESSAGE, IPC_STOP_RUN, IPC_CREATE_NEW_SESSION, IPC_COMPACT_CONVERSATION, IPC_CANCEL_QUEUED_MESSAGES, IPC_REQUEST_CONVERSATION_SNAPSHOT, IPC_CONVERSATION_EVENT, IPC_GET_SETTINGS, IPC_SAVE_SETTINGS, IPC_FETCH_MODELS, IPC_GET_MCP_SERVERS, IPC_SAVE_MCP_SERVERS, IPC_TEST_MCP_SERVER, IPC_GET_SKILLS, IPC_GET_SKILL, IPC_TOGGLE_SKILL, IPC_CREATE_AGENT, IPC_GET_AGENT, IPC_GET_AGENT_CONFIG, IPC_LIST_AGENTS, IPC_UPDATE_AGENT, IPC_DELETE_AGENT, IPC_SET_AGENT_AVATAR, IPC_REMOVE_AGENT_AVATAR, IPC_OPTIMIZE_AGENT_DESCRIPTION, IPC_GET_AGENT_CHANNELS, IPC_UPDATE_AGENT_CHANNELS, IPC_SWITCH_CHANNEL, IPC_CREATE_CONVERSATION, IPC_GET_CONVERSATION, IPC_LIST_CONVERSATIONS, IPC_GET_CONVERSATION_AGENTS, IPC_UPDATE_CONVERSATION, IPC_DELETE_CONVERSATION, IPC_CREATE_GROUP, IPC_GET_GROUP, IPC_UPDATE_GROUP, IPC_DELETE_GROUP, IPC_SET_GROUP_AVATAR, IPC_REMOVE_GROUP_AVATAR, IPC_GET_GROUP_MEMBERS, IPC_GET_TEAM_MEMORY, IPC_SAVE_GROUP_FILE, IPC_GET_GROUP_SETTINGS, IPC_GET_GROUP_MEMORY, IPC_LIST_GROUP_THREADS, IPC_GET_GROUP_THREAD, IPC_CREATE_GROUP_THREAD, IPC_UPDATE_GROUP_THREAD, IPC_DELETE_GROUP_THREAD, IPC_ARCHIVE_GROUP_THREAD, IPC_GET_MESSAGES, IPC_GET_MESSAGE, IPC_CREATE_LLM_CHANNEL, IPC_GET_LLM_CHANNEL, IPC_LIST_LLM_CHANNELS, IPC_UPDATE_LLM_CHANNEL, IPC_DELETE_LLM_CHANNEL, IPC_SET_DEFAULT_LLM_CHANNEL, IPC_GET_WORKSPACE_FILE, IPC_UPDATE_WORKSPACE_FILE, IPC_LIST_WORKSPACE_FILES, IPC_OPEN_WORKSPACE_DIR, IPC_OPEN_CHAT_DATA_DIR, IPC_GET_SEARCH_ENGINES, IPC_ADD_CUSTOM_ENGINE, IPC_UPDATE_CUSTOM_ENGINE, IPC_DELETE_CUSTOM_ENGINE, IPC_SET_DEFAULT_ENGINE, IPC_CREATE_SCHEDULED_TASK, IPC_GET_SCHEDULED_TASK, IPC_LIST_SCHEDULED_TASKS, IPC_UPDATE_SCHEDULED_TASK, IPC_DELETE_SCHEDULED_TASK, IPC_TOGGLE_SCHEDULED_TASK, IPC_LIST_TASK_EXECUTIONS, IPC_TASK_EXECUTION_EVENT, IPC_TRIGGER_MEMORY_UPDATE, IPC_GET_NIGHTLY_MEMORY_CONFIG, IPC_UPDATE_NIGHTLY_MEMORY_CONFIG, IPC_RUN_NIGHTLY_MEMORY_NOW, IPC_LIST_NIGHTLY_MEMORY_EXECUTIONS, IPC_OPEN_EXTERNAL_URL, IPC_OPEN_LOCAL_PATH, IPC_READ_FILE_CONTENT, IPC_SHOW_LOCAL_ITEM_IN_FOLDER, IPC_COPY_IMAGE_TO_CLIPBOARD, IPC_UPLOAD_ATTACHMENT, IPC_OPEN_ATTACHMENT, IPC_MEMORY_UPDATE_PROGRESS, IPC_HEALTH_GET_ALL, IPC_HEALTH_GET, IPC_HEALTH_UPDATE, IPC_REMOTE_ACCESS_START, IPC_REMOTE_ACCESS_STOP, IPC_REMOTE_ACCESS_ROTATE, IPC_REMOTE_ACCESS_STATUS, IPC_GET_APP_INFO, IPC_GET_RELEASE_NOTES, IPC_UPDATE_CHECK, IPC_UPDATE_DOWNLOAD, IPC_UPDATE_INSTALL, IPC_UPDATE_STATUS, IPC_UPDATE_STATUS_EVENT, IPC_UPDATE_AVAILABLE_EVENT, IPC_UPDATE_ERROR_EVENT, IPC_GET_PINNED, IPC_TOGGLE_PIN, IPC_CHANNEL_LIST, IPC_CHANNEL_BIND, IPC_CHANNEL_UPDATE_TARGET, IPC_CHANNEL_UNBIND, IPC_CHANNEL_TEST, IPC_CHANNEL_RECONNECT, IPC_CHANNEL_STATUS, IPC_CHANNEL_QRCODE, IPC_CHANNEL_QRCODE_POLL, IPC_CHANNEL_WECHAT_PERSONAL_QRCODE, IPC_CHANNEL_WECHAT_PERSONAL_QRCODE_POLL, IPC_TELEMETRY_TRACK, IPC_TELEMETRY_FEEDBACK, IPC_TELEMETRY_SET_ENABLED, IPC_TELEMETRY_IS_ENABLED;
+var IPC_SEND_USER_MESSAGE, IPC_STOP_RUN, IPC_CREATE_NEW_SESSION, IPC_COMPACT_CONVERSATION, IPC_CANCEL_QUEUED_MESSAGES, IPC_REQUEST_CONVERSATION_SNAPSHOT, IPC_CONVERSATION_EVENT, IPC_GET_SETTINGS, IPC_SAVE_SETTINGS, IPC_FETCH_MODELS, IPC_GET_MCP_SERVERS, IPC_SAVE_MCP_SERVERS, IPC_TEST_MCP_SERVER, IPC_GET_SKILLS, IPC_GET_SKILL, IPC_TOGGLE_SKILL, IPC_CREATE_AGENT, IPC_GET_AGENT, IPC_GET_AGENT_CONFIG, IPC_LIST_AGENTS, IPC_UPDATE_AGENT, IPC_DELETE_AGENT, IPC_SET_AGENT_AVATAR, IPC_REMOVE_AGENT_AVATAR, IPC_OPTIMIZE_AGENT_DESCRIPTION, IPC_GET_AGENT_CHANNELS, IPC_UPDATE_AGENT_CHANNELS, IPC_SWITCH_CHANNEL, IPC_CREATE_CONVERSATION, IPC_GET_CONVERSATION, IPC_LIST_CONVERSATIONS, IPC_GET_CONVERSATION_AGENTS, IPC_UPDATE_CONVERSATION, IPC_DELETE_CONVERSATION, IPC_CREATE_GROUP, IPC_GET_GROUP, IPC_UPDATE_GROUP, IPC_DELETE_GROUP, IPC_SET_GROUP_AVATAR, IPC_REMOVE_GROUP_AVATAR, IPC_GET_GROUP_MEMBERS, IPC_GET_TEAM_MEMORY, IPC_SAVE_GROUP_FILE, IPC_GET_GROUP_SETTINGS, IPC_GET_GROUP_MEMORY, IPC_LIST_GROUP_THREADS, IPC_GET_GROUP_THREAD, IPC_CREATE_GROUP_THREAD, IPC_UPDATE_GROUP_THREAD, IPC_DELETE_GROUP_THREAD, IPC_ARCHIVE_GROUP_THREAD, IPC_GET_MESSAGES, IPC_GET_MESSAGE, IPC_CREATE_LLM_CHANNEL, IPC_GET_LLM_CHANNEL, IPC_LIST_LLM_CHANNELS, IPC_UPDATE_LLM_CHANNEL, IPC_DELETE_LLM_CHANNEL, IPC_SET_DEFAULT_LLM_CHANNEL, IPC_GET_WORKSPACE_FILE, IPC_UPDATE_WORKSPACE_FILE, IPC_LIST_WORKSPACE_FILES, IPC_OPEN_WORKSPACE_DIR, IPC_OPEN_CHAT_DATA_DIR, IPC_GET_SEARCH_ENGINES, IPC_ADD_CUSTOM_ENGINE, IPC_UPDATE_CUSTOM_ENGINE, IPC_DELETE_CUSTOM_ENGINE, IPC_SET_DEFAULT_ENGINE, IPC_CREATE_SCHEDULED_TASK, IPC_GET_SCHEDULED_TASK, IPC_LIST_SCHEDULED_TASKS, IPC_UPDATE_SCHEDULED_TASK, IPC_DELETE_SCHEDULED_TASK, IPC_TOGGLE_SCHEDULED_TASK, IPC_LIST_TASK_EXECUTIONS, IPC_TASK_EXECUTION_EVENT, IPC_TRIGGER_MEMORY_UPDATE, IPC_GET_NIGHTLY_MEMORY_CONFIG, IPC_UPDATE_NIGHTLY_MEMORY_CONFIG, IPC_RUN_NIGHTLY_MEMORY_NOW, IPC_LIST_NIGHTLY_MEMORY_EXECUTIONS, IPC_OPEN_EXTERNAL_URL, IPC_OPEN_LOCAL_PATH, IPC_READ_FILE_CONTENT, IPC_SHOW_LOCAL_ITEM_IN_FOLDER, IPC_COPY_IMAGE_TO_CLIPBOARD, IPC_UPLOAD_ATTACHMENT, IPC_OPEN_ATTACHMENT, IPC_MEMORY_UPDATE_PROGRESS, IPC_HEALTH_GET_ALL, IPC_HEALTH_GET, IPC_HEALTH_UPDATE, IPC_REMOTE_ACCESS_START, IPC_REMOTE_ACCESS_STOP, IPC_REMOTE_ACCESS_ROTATE, IPC_REMOTE_ACCESS_STATUS, IPC_GET_APP_INFO, IPC_GET_RELEASE_NOTES, IPC_UPDATE_CHECK, IPC_UPDATE_DOWNLOAD, IPC_UPDATE_INSTALL, IPC_UPDATE_STATUS, IPC_UPDATE_STATUS_EVENT, IPC_UPDATE_AVAILABLE_EVENT, IPC_UPDATE_PROGRESS_EVENT, IPC_UPDATE_DOWNLOADED_EVENT, IPC_UPDATE_ERROR_EVENT, IPC_GET_PINNED, IPC_TOGGLE_PIN, IPC_CHANNEL_LIST, IPC_CHANNEL_BIND, IPC_CHANNEL_UPDATE_TARGET, IPC_CHANNEL_UNBIND, IPC_CHANNEL_TEST, IPC_CHANNEL_RECONNECT, IPC_CHANNEL_STATUS, IPC_CHANNEL_QRCODE, IPC_CHANNEL_QRCODE_POLL, IPC_CHANNEL_WECHAT_PERSONAL_QRCODE, IPC_CHANNEL_WECHAT_PERSONAL_QRCODE_POLL, IPC_TELEMETRY_TRACK, IPC_TELEMETRY_FEEDBACK, IPC_TELEMETRY_SET_ENABLED, IPC_TELEMETRY_IS_ENABLED;
 var init_ipc_events = __esm({
   "src/shared/ipc-events.ts"() {
     "use strict";
@@ -143,6 +143,8 @@ var init_ipc_events = __esm({
     IPC_UPDATE_STATUS = "UPDATE_STATUS";
     IPC_UPDATE_STATUS_EVENT = "UPDATE_STATUS_EVENT";
     IPC_UPDATE_AVAILABLE_EVENT = "UPDATE_AVAILABLE_EVENT";
+    IPC_UPDATE_PROGRESS_EVENT = "UPDATE_PROGRESS_EVENT";
+    IPC_UPDATE_DOWNLOADED_EVENT = "UPDATE_DOWNLOADED_EVENT";
     IPC_UPDATE_ERROR_EVENT = "UPDATE_ERROR_EVENT";
     IPC_GET_PINNED = "GET_PINNED";
     IPC_TOGGLE_PIN = "TOGGLE_PIN";
@@ -85613,29 +85615,48 @@ var init_agent_identity = __esm({
   }
 });
 
-// src/adapters/storage/agent-file-store.ts
-function getAgentRootDir(agentId) {
-  const workspaceDir = getAgentWorkspaceDir(agentId);
-  return (0, import_path5.join)(workspaceDir, "..");
-}
-function getMetaPath(agentId) {
-  return (0, import_path5.join)(getAgentRootDir(agentId), META_FILE);
+// src/adapters/storage/json-file.ts
+async function atomicWriteJson(path10, data2) {
+  await atomicWriteText(path10, `${JSON.stringify(data2, null, 2)}
+`);
 }
-function getConfigPath(agentId) {
-  return (0, import_path5.join)(getAgentRootDir(agentId), CONFIG_FILE);
+async function readJsonFile2(path10) {
+  if (!(0, import_fs5.existsSync)(path10)) return null;
+  const raw = await (0, import_promises3.readFile)(path10, "utf-8");
+  return JSON.parse(raw);
 }
-async function atomicWriteJson(path10, data2) {
+async function atomicWriteText(path10, content) {
   const dir = (0, import_path5.dirname)(path10);
   await (0, import_promises3.mkdir)(dir, { recursive: true });
   const tmp = `${path10}.tmp`;
-  await (0, import_promises3.writeFile)(tmp, `${JSON.stringify(data2, null, 2)}
-`, "utf-8");
+  await (0, import_promises3.writeFile)(tmp, content, "utf-8");
   await (0, import_promises3.rename)(tmp, path10);
 }
-async function readJsonFile2(path10) {
+async function readTextFile(path10) {
   if (!(0, import_fs5.existsSync)(path10)) return null;
-  const raw = await (0, import_promises3.readFile)(path10, "utf-8");
-  return JSON.parse(raw);
+  const content = await (0, import_promises3.readFile)(path10, "utf-8");
+  return content || null;
+}
+var import_path5, import_promises3, import_fs5;
+var init_json_file = __esm({
+  "src/adapters/storage/json-file.ts"() {
+    "use strict";
+    import_path5 = require("path");
+    import_promises3 = require("fs/promises");
+    import_fs5 = require("fs");
+  }
+});
+
+// src/adapters/storage/agent-file-store.ts
+function getAgentRootDir(agentId) {
+  const workspaceDir = getAgentWorkspaceDir(agentId);
+  return (0, import_path6.join)(workspaceDir, "..");
+}
+function getMetaPath(agentId) {
+  return (0, import_path6.join)(getAgentRootDir(agentId), META_FILE);
+}
+function getConfigPath(agentId) {
+  return (0, import_path6.join)(getAgentRootDir(agentId), CONFIG_FILE);
 }
 function normalizeFallbacks(channelConfig) {
   return [...channelConfig?.channels ?? []].filter((entry) => entry.priority > 0).sort((a, b) => a.priority - b.priority).map((entry, index2) => ({
@@ -85734,17 +85755,18 @@ function deriveChannelConfig(agentId, config3) {
   }
   return buildChannelConfigFromModels(agentId, config3.models);
 }
-var import_path5, import_promises3, import_fs5, META_FILE, CONFIG_FILE, SCHEMA_VERSION, AgentFileStore, agentFileStore;
+var import_path6, import_promises4, import_fs6, META_FILE, CONFIG_FILE, SCHEMA_VERSION, AgentFileStore, agentFileStore;
 var init_agent_file_store = __esm({
   "src/adapters/storage/agent-file-store.ts"() {
     "use strict";
-    import_path5 = require("path");
-    import_promises3 = require("fs/promises");
-    import_fs5 = require("fs");
+    import_path6 = require("path");
+    import_promises4 = require("fs/promises");
+    import_fs6 = require("fs");
     init_AgentConfigModel();
     init_agentConfigUtils();
     init_workspace();
     init_agent_identity();
+    init_json_file();
     META_FILE = "meta.json";
     CONFIG_FILE = "config.json";
     SCHEMA_VERSION = 1;
@@ -85752,9 +85774,9 @@ var init_agent_file_store = __esm({
       metaCache = /* @__PURE__ */ new Map();
       configCache = /* @__PURE__ */ new Map();
       async listMeta() {
-        const parentDir = (0, import_path5.dirname)(getAgentRootDir("placeholder"));
-        if (!(0, import_fs5.existsSync)(parentDir)) return [];
-        const entries = await (0, import_promises3.readdir)(parentDir, { withFileTypes: true });
+        const parentDir = (0, import_path6.dirname)(getAgentRootDir("placeholder"));
+        if (!(0, import_fs6.existsSync)(parentDir)) return [];
+        const entries = await (0, import_promises4.readdir)(parentDir, { withFileTypes: true });
         const agents = await Promise.all(
           entries.filter((entry) => entry.isDirectory()).map(async (entry) => this.readMeta(entry.name))
         );
@@ -85789,12 +85811,12 @@ var init_agent_file_store = __esm({
         this.configCache.set(config3.agentId, fromConfigFile(config3.agentId, file2));
       }
       async exists(agentId) {
-        return (0, import_fs5.existsSync)(getMetaPath(agentId)) && (0, import_fs5.existsSync)(getConfigPath(agentId));
+        return (0, import_fs6.existsSync)(getMetaPath(agentId)) && (0, import_fs6.existsSync)(getConfigPath(agentId));
       }
       async delete(agentId) {
         this.metaCache.delete(agentId);
         this.configCache.delete(agentId);
-        await (0, import_promises3.rm)(getAgentRootDir(agentId), { force: true, recursive: true });
+        await (0, import_promises4.rm)(getAgentRootDir(agentId), { force: true, recursive: true });
       }
       clear(agentId) {
         if (agentId) {
@@ -105511,56 +105533,31 @@ var require_index_cjs = __commonJS({
 
 // src/adapters/storage/group-file-store.ts
 function getGroupsRootDir() {
-  return (0, import_path8.join)(config.getAppDataPath(), "groups");
+  return (0, import_path9.join)(config.getAppDataPath(), "groups");
 }
 function getGroupDir(groupId) {
-  return (0, import_path8.join)(getGroupsRootDir(), groupId);
+  return (0, import_path9.join)(getGroupsRootDir(), groupId);
 }
 function getMetaPath2(groupId) {
-  return (0, import_path8.join)(getGroupDir(groupId), META_FILE2);
+  return (0, import_path9.join)(getGroupDir(groupId), META_FILE2);
 }
 function getConfigPath2(groupId) {
-  return (0, import_path8.join)(getGroupDir(groupId), CONFIG_FILE2);
+  return (0, import_path9.join)(getGroupDir(groupId), CONFIG_FILE2);
 }
 function getMembersPath(groupId) {
-  return (0, import_path8.join)(getGroupDir(groupId), MEMBERS_FILE);
+  return (0, import_path9.join)(getGroupDir(groupId), MEMBERS_FILE);
 }
 function getGroupMemoryPath(groupId) {
-  return (0, import_path8.join)(getGroupDir(groupId), GROUP_MEMORY_FILE);
+  return (0, import_path9.join)(getGroupDir(groupId), GROUP_MEMORY_FILE);
 }
 function getLegacyTeamMemoryPath(groupId) {
-  return (0, import_path8.join)(getGroupDir(groupId), TEAM_MEMORY_FILE);
+  return (0, import_path9.join)(getGroupDir(groupId), TEAM_MEMORY_FILE);
 }
 function getGroupSettingsPath(groupId) {
-  return (0, import_path8.join)(getGroupDir(groupId), GROUP_SETTINGS_FILE);
+  return (0, import_path9.join)(getGroupDir(groupId), GROUP_SETTINGS_FILE);
 }
 function getGroupMemoryDir(groupId) {
-  return (0, import_path8.join)(getGroupDir(groupId), GROUP_MEMORY_DIR);
-}
-async function atomicWriteJson2(path10, data2) {
-  const dir = (0, import_path8.dirname)(path10);
-  await (0, import_promises5.mkdir)(dir, { recursive: true });
-  const tmp = `${path10}.tmp`;
-  await (0, import_promises5.writeFile)(tmp, `${JSON.stringify(data2, null, 2)}
-`, "utf-8");
-  await (0, import_promises5.rename)(tmp, path10);
-}
-async function readJsonFile3(path10) {
-  if (!(0, import_fs8.existsSync)(path10)) return null;
-  const raw = await (0, import_promises5.readFile)(path10, "utf-8");
-  return JSON.parse(raw);
-}
-async function atomicWriteText(path10, content) {
-  const dir = (0, import_path8.dirname)(path10);
-  await (0, import_promises5.mkdir)(dir, { recursive: true });
-  const tmp = `${path10}.tmp`;
-  await (0, import_promises5.writeFile)(tmp, content, "utf-8");
-  await (0, import_promises5.rename)(tmp, path10);
-}
-async function readTextFile(path10) {
-  if (!(0, import_fs8.existsSync)(path10)) return null;
-  const content = await (0, import_promises5.readFile)(path10, "utf-8");
-  return content || null;
+  return (0, import_path9.join)(getGroupDir(groupId), GROUP_MEMORY_DIR);
 }
 function metaToIGroup(meta3, groupConfig, members, groupMemory, groupSettings) {
   return {
@@ -105585,15 +105582,16 @@ function metaToIGroup(meta3, groupConfig, members, groupMemory, groupSettings) {
     updatedAt: meta3.updatedAt
   };
 }
-var import_path8, import_promises5, import_fs8, META_FILE2, CONFIG_FILE2, MEMBERS_FILE, TEAM_MEMORY_FILE, GROUP_MEMORY_FILE, GROUP_SETTINGS_FILE, GROUP_MEMORY_DIR, SCHEMA_VERSION2, ALLOWED_SAVE_FILENAMES, GroupFileStore, groupFileStore;
+var import_path9, import_promises6, import_fs9, META_FILE2, CONFIG_FILE2, MEMBERS_FILE, TEAM_MEMORY_FILE, GROUP_MEMORY_FILE, GROUP_SETTINGS_FILE, GROUP_MEMORY_DIR, SCHEMA_VERSION2, ALLOWED_SAVE_FILENAMES, GroupFileStore, groupFileStore;
 var init_group_file_store = __esm({
   "src/adapters/storage/group-file-store.ts"() {
     "use strict";
-    import_path8 = require("path");
-    import_promises5 = require("fs/promises");
-    import_fs8 = require("fs");
+    import_path9 = require("path");
+    import_promises6 = require("fs/promises");
+    import_fs9 = require("fs");
     init_config();
     init_id2();
+    init_json_file();
     META_FILE2 = "meta.json";
     CONFIG_FILE2 = "config.json";
     MEMBERS_FILE = "members.json";
@@ -105608,8 +105606,8 @@ var init_group_file_store = __esm({
       // --- Read operations ---
       async list() {
         const rootDir = getGroupsRootDir();
-        if (!(0, import_fs8.existsSync)(rootDir)) return [];
-        const entries = await (0, import_promises5.readdir)(rootDir, { withFileTypes: true });
+        if (!(0, import_fs9.existsSync)(rootDir)) return [];
+        const entries = await (0, import_promises6.readdir)(rootDir, { withFileTypes: true });
         const groups = await Promise.all(
           entries.filter((entry) => entry.isDirectory()).map((entry) => this.get(entry.name))
         );
@@ -105618,9 +105616,9 @@ var init_group_file_store = __esm({
       async get(groupId) {
         const cached2 = this.cache.get(groupId);
         if (cached2) return cached2;
-        const meta3 = await readJsonFile3(getMetaPath2(groupId));
+        const meta3 = await readJsonFile2(getMetaPath2(groupId));
         if (!meta3) return null;
-        const configFile = await readJsonFile3(getConfigPath2(groupId));
+        const configFile = await readJsonFile2(getConfigPath2(groupId));
         const defaultConfig = {
           version: SCHEMA_VERSION2,
           strategy: "sequential",
@@ -105628,7 +105626,7 @@ var init_group_file_store = __esm({
           timeout: 3e5,
           updatedAt: meta3.updatedAt
         };
-        const membersFile = await readJsonFile3(getMembersPath(groupId));
+        const membersFile = await readJsonFile2(getMembersPath(groupId));
         const members = membersFile?.members ?? [];
         const groupMemory = await this.readGroupMemoryContent(groupId);
         const groupSettings = await readTextFile(getGroupSettingsPath(groupId));
@@ -105637,7 +105635,7 @@ var init_group_file_store = __esm({
         return group;
       }
       async exists(groupId) {
-        return (0, import_fs8.existsSync)(getMetaPath2(groupId));
+        return (0, import_fs9.existsSync)(getMetaPath2(groupId));
       }
       // --- Write operations ---
       async create(name21, speakerId, memberIds, groupConfig, avatar) {
@@ -105663,18 +105661,18 @@ var init_group_file_store = __esm({
           members: memberIds,
           updatedAt: now2
         };
-        await (0, import_promises5.mkdir)(getGroupDir(id), { recursive: true });
+        await (0, import_promises6.mkdir)(getGroupDir(id), { recursive: true });
         await Promise.all([
-          atomicWriteJson2(getMetaPath2(id), meta3),
-          atomicWriteJson2(getConfigPath2(id), configFile),
-          atomicWriteJson2(getMembersPath(id), members)
+          atomicWriteJson(getMetaPath2(id), meta3),
+          atomicWriteJson(getConfigPath2(id), configFile),
+          atomicWriteJson(getMembersPath(id), members)
         ]);
         const group = metaToIGroup(meta3, configFile, memberIds, null, null);
         this.cache.set(id, group);
         return id;
       }
       async update(groupId, updates) {
-        const meta3 = await readJsonFile3(getMetaPath2(groupId));
+        const meta3 = await readJsonFile2(getMetaPath2(groupId));
         if (!meta3) throw new Error(`Group not found: ${groupId}`);
         const now2 = Date.now();
         meta3.updatedAt = now2;
@@ -105682,7 +105680,7 @@ var init_group_file_store = __esm({
         if (updates.avatar !== void 0) meta3.avatar = updates.avatar;
         const speakerValue = updates.defaultSpeakerId ?? updates.speakerId;
         if (speakerValue !== void 0) meta3.speakerId = speakerValue;
-        const writes = [atomicWriteJson2(getMetaPath2(groupId), meta3)];
+        const writes = [atomicWriteJson(getMetaPath2(groupId), meta3)];
         if (updates.config !== void 0) {
           const configFile = {
             version: SCHEMA_VERSION2,
@@ -105691,14 +105689,14 @@ var init_group_file_store = __esm({
             timeout: updates.config.timeout ?? 3e5,
             updatedAt: now2
           };
-          writes.push(atomicWriteJson2(getConfigPath2(groupId), configFile));
+          writes.push(atomicWriteJson(getConfigPath2(groupId), configFile));
         }
         if (updates.memberIds !== void 0) {
           const membersFile = {
             members: updates.memberIds,
             updatedAt: now2
           };
-          writes.push(atomicWriteJson2(getMembersPath(groupId), membersFile));
+          writes.push(atomicWriteJson(getMembersPath(groupId), membersFile));
         }
         await Promise.all(writes);
         this.cache.delete(groupId);
@@ -105706,13 +105704,13 @@ var init_group_file_store = __esm({
       async delete(groupId) {
         this.cache.delete(groupId);
         const dir = getGroupDir(groupId);
-        if ((0, import_fs8.existsSync)(dir)) {
-          await (0, import_promises5.rm)(dir, { force: true, recursive: true });
+        if ((0, import_fs9.existsSync)(dir)) {
+          await (0, import_promises6.rm)(dir, { force: true, recursive: true });
         }
       }
       // --- Members ---
       async getMembers(groupId) {
-        const membersFile = await readJsonFile3(getMembersPath(groupId));
+        const membersFile = await readJsonFile2(getMembersPath(groupId));
         return membersFile?.members ?? [];
       }
       // --- Group Settings ---
@@ -105738,13 +105736,13 @@ var init_group_file_store = __esm({
         const content = await this.readGroupMemoryContent(groupId);
         let updatedAt = null;
         const memoryPath = getGroupMemoryPath(groupId);
-        if ((0, import_fs8.existsSync)(memoryPath)) {
-          const s = await (0, import_promises5.stat)(memoryPath);
+        if ((0, import_fs9.existsSync)(memoryPath)) {
+          const s = await (0, import_promises6.stat)(memoryPath);
           updatedAt = s.mtime;
         } else {
           const legacyPath = getLegacyTeamMemoryPath(groupId);
-          if ((0, import_fs8.existsSync)(legacyPath)) {
-            const s = await (0, import_promises5.stat)(legacyPath);
+          if ((0, import_fs9.existsSync)(legacyPath)) {
+            const s = await (0, import_promises6.stat)(legacyPath);
             updatedAt = s.mtime;
           }
         }
@@ -105759,14 +105757,14 @@ var init_group_file_store = __esm({
       /** Read the last N days of memory/YYYY-MM-DD.md files. Returns content with last 50 lines per file. */
       async readRecentDailyMemory(groupId, days = 2) {
         const memDir = getGroupMemoryDir(groupId);
-        if (!(0, import_fs8.existsSync)(memDir)) return "";
+        if (!(0, import_fs9.existsSync)(memDir)) return "";
         const today = /* @__PURE__ */ new Date();
         const results = [];
         for (let i = 0; i < days; i++) {
           const d = new Date(today);
           d.setDate(d.getDate() - i);
           const filename = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}.md`;
-          const filePath = (0, import_path8.join)(memDir, filename);
+          const filePath = (0, import_path9.join)(memDir, filename);
           const content = await readTextFile(filePath);
           if (content) {
             const lines = content.split("\n");
@@ -105778,24 +105776,24 @@ var init_group_file_store = __esm({
       }
       // --- saveGroupFile (for IPC / frontend) ---
       async saveGroupFile(groupId, filename, content) {
-        if (filename !== (0, import_path8.basename)(filename)) {
+        if (filename !== (0, import_path9.basename)(filename)) {
           throw new Error(`saveGroupFile: nested paths not allowed: ${filename}`);
         }
         if (!ALLOWED_SAVE_FILENAMES.has(filename)) {
           throw new Error(`saveGroupFile: filename not allowed: ${filename}`);
         }
-        const filePath = (0, import_path8.join)(getGroupDir(groupId), filename);
+        const filePath = (0, import_path9.join)(getGroupDir(groupId), filename);
         if (!content) {
-          if ((0, import_fs8.existsSync)(filePath)) {
-            await (0, import_promises5.unlink)(filePath);
+          if ((0, import_fs9.existsSync)(filePath)) {
+            await (0, import_promises6.unlink)(filePath);
           }
         } else {
           await atomicWriteText(filePath, content);
         }
-        const meta3 = await readJsonFile3(getMetaPath2(groupId));
+        const meta3 = await readJsonFile2(getMetaPath2(groupId));
         if (meta3) {
           meta3.updatedAt = Date.now();
-          await atomicWriteJson2(getMetaPath2(groupId), meta3);
+          await atomicWriteJson(getMetaPath2(groupId), meta3);
         }
         this.cache.delete(groupId);
       }
@@ -105822,11 +105820,11 @@ var init_group_file_store = __esm({
           members: data2.members,
           updatedAt: data2.updatedAt
         };
-        await (0, import_promises5.mkdir)(getGroupDir(data2.id), { recursive: true });
+        await (0, import_promises6.mkdir)(getGroupDir(data2.id), { recursive: true });
         const writes = [
-          atomicWriteJson2(getMetaPath2(data2.id), meta3),
-          atomicWriteJson2(getConfigPath2(data2.id), configFile),
-          atomicWriteJson2(getMembersPath(data2.id), membersFile)
+          atomicWriteJson(getMetaPath2(data2.id), meta3),
+          atomicWriteJson(getConfigPath2(data2.id), configFile),
+          atomicWriteJson(getMembersPath(data2.id), membersFile)
         ];
         if (data2.teamMemory) {
           writes.push(atomicWriteText(getGroupMemoryPath(data2.id), data2.teamMemory));
@@ -105834,12 +105832,12 @@ var init_group_file_store = __esm({
         await Promise.all(writes);
         const legacyPath = getLegacyTeamMemoryPath(data2.id);
         const newPath = getGroupMemoryPath(data2.id);
-        if ((0, import_fs8.existsSync)(legacyPath) && !(0, import_fs8.existsSync)(newPath)) {
-          await (0, import_promises5.rename)(legacyPath, newPath);
+        if ((0, import_fs9.existsSync)(legacyPath) && !(0, import_fs9.existsSync)(newPath)) {
+          await (0, import_promises6.rename)(legacyPath, newPath);
         }
-        const metaJsonPath = (0, import_path8.join)(getGroupDir(data2.id), "team-memory.meta.json");
-        if ((0, import_fs8.existsSync)(metaJsonPath)) {
-          await (0, import_promises5.unlink)(metaJsonPath).catch(() => {
+        const metaJsonPath = (0, import_path9.join)(getGroupDir(data2.id), "team-memory.meta.json");
+        if ((0, import_fs9.existsSync)(metaJsonPath)) {
+          await (0, import_promises6.unlink)(metaJsonPath).catch(() => {
           });
         }
       }
@@ -105858,29 +105856,21 @@ var init_group_file_store = __esm({
 
 // src/adapters/storage/thread-file-store.ts
 function getThreadsRootDir(groupId) {
-  return (0, import_path9.join)(getGroupDir(groupId), "threads");
+  return (0, import_path10.join)(getGroupDir(groupId), "threads");
 }
 function getThreadDir(groupId, threadId) {
-  return (0, import_path9.join)(getThreadsRootDir(groupId), threadId);
+  return (0, import_path10.join)(getThreadsRootDir(groupId), threadId);
 }
 function getMetaPath3(groupId, threadId) {
-  return (0, import_path9.join)(getThreadDir(groupId, threadId), META_FILE3);
+  return (0, import_path10.join)(getThreadDir(groupId, threadId), META_FILE3);
 }
 function getConfigPath3(groupId, threadId) {
-  return (0, import_path9.join)(getThreadDir(groupId, threadId), CONFIG_FILE3);
+  return (0, import_path10.join)(getThreadDir(groupId, threadId), CONFIG_FILE3);
 }
-async function atomicWriteJson3(path10, data2) {
-  const dir = (0, import_path9.dirname)(path10);
-  await (0, import_promises6.mkdir)(dir, { recursive: true });
-  const tmp = `${path10}.tmp`;
-  await (0, import_promises6.writeFile)(tmp, `${JSON.stringify(data2, null, 2)}
-`, "utf-8");
-  await (0, import_promises6.rename)(tmp, path10);
-}
-async function readJsonFile4(path10) {
-  if (!(0, import_fs9.existsSync)(path10)) return null;
+async function readJsonFile3(path10) {
+  if (!(0, import_fs10.existsSync)(path10)) return null;
   try {
-    const raw = await (0, import_promises6.readFile)(path10, "utf-8");
+    const raw = await (0, import_promises7.readFile)(path10, "utf-8");
     return JSON.parse(raw);
   } catch (e) {
     logger9.warn("Failed to parse:", path10, e);
@@ -105930,31 +105920,32 @@ function threadToConfigFile(thread) {
   };
 }
 async function findGroupIdForThread(threadId) {
-  const groupsRoot = (0, import_path9.join)(config.getAppDataPath(), "groups");
-  if (!(0, import_fs9.existsSync)(groupsRoot)) return null;
-  const entries = await (0, import_promises6.readdir)(groupsRoot, { withFileTypes: true });
+  const groupsRoot = (0, import_path10.join)(config.getAppDataPath(), "groups");
+  if (!(0, import_fs10.existsSync)(groupsRoot)) return null;
+  const entries = await (0, import_promises7.readdir)(groupsRoot, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const threadsDir = (0, import_path9.join)(groupsRoot, entry.name, "threads");
-    if (!(0, import_fs9.existsSync)(threadsDir)) continue;
-    const threadMetaPath = (0, import_path9.join)(threadsDir, threadId, META_FILE3);
-    if ((0, import_fs9.existsSync)(threadMetaPath)) {
+    const threadsDir = (0, import_path10.join)(groupsRoot, entry.name, "threads");
+    if (!(0, import_fs10.existsSync)(threadsDir)) continue;
+    const threadMetaPath = (0, import_path10.join)(threadsDir, threadId, META_FILE3);
+    if ((0, import_fs10.existsSync)(threadMetaPath)) {
       return entry.name;
     }
   }
   return null;
 }
-var import_path9, import_promises6, import_fs9, logger9, META_FILE3, CONFIG_FILE3, SCHEMA_VERSION3, ThreadFileStore, threadFileStore;
+var import_path10, import_promises7, import_fs10, logger9, META_FILE3, CONFIG_FILE3, SCHEMA_VERSION3, ThreadFileStore, threadFileStore;
 var init_thread_file_store = __esm({
   "src/adapters/storage/thread-file-store.ts"() {
     "use strict";
-    import_path9 = require("path");
-    import_promises6 = require("fs/promises");
-    import_fs9 = require("fs");
+    import_path10 = require("path");
+    import_promises7 = require("fs/promises");
+    import_fs10 = require("fs");
     init_id2();
     init_config();
     init_group_file_store();
     init_logger();
+    init_json_file();
     logger9 = createLogger("thread-file-store");
     META_FILE3 = "meta.json";
     CONFIG_FILE3 = "config.json";
@@ -105978,8 +105969,8 @@ var init_thread_file_store = __esm({
           createdAt: now2,
           updatedAt: now2
         };
-        await (0, import_promises6.mkdir)(getThreadDir(groupId, id), { recursive: true });
-        await atomicWriteJson3(getMetaPath3(groupId, id), meta3);
+        await (0, import_promises7.mkdir)(getThreadDir(groupId, id), { recursive: true });
+        await atomicWriteJson(getMetaPath3(groupId, id), meta3);
         const thread = {
           id,
           groupId,
@@ -105998,7 +105989,7 @@ var init_thread_file_store = __esm({
             temperature: params.config.temperature,
             updatedAt: now2
           };
-          await atomicWriteJson3(getConfigPath3(groupId, id), configFile);
+          await atomicWriteJson(getConfigPath3(groupId, id), configFile);
         }
         this.cache.set(id, thread);
         this.groupIndex.set(id, groupId);
@@ -106019,9 +106010,9 @@ var init_thread_file_store = __esm({
       async findByGroupIdAndId(groupId, threadId) {
         const cached2 = this.cache.get(threadId);
         if (cached2) return cached2;
-        const meta3 = await readJsonFile4(getMetaPath3(groupId, threadId));
+        const meta3 = await readJsonFile3(getMetaPath3(groupId, threadId));
         if (!meta3) return null;
-        const configFile = await readJsonFile4(getConfigPath3(groupId, threadId));
+        const configFile = await readJsonFile3(getConfigPath3(groupId, threadId));
         const thread = metaFileToThread(meta3, configFile ?? void 0);
         this.cache.set(threadId, thread);
         this.groupIndex.set(threadId, groupId);
@@ -106029,10 +106020,10 @@ var init_thread_file_store = __esm({
       }
       async listByGroupId(groupId) {
         const threadsDir = getThreadsRootDir(groupId);
-        if (!(0, import_fs9.existsSync)(threadsDir)) return [];
+        if (!(0, import_fs10.existsSync)(threadsDir)) return [];
         let entries;
         try {
-          entries = await (0, import_promises6.readdir)(threadsDir, { withFileTypes: true });
+          entries = await (0, import_promises7.readdir)(threadsDir, { withFileTypes: true });
         } catch {
           return [];
         }
@@ -106052,7 +106043,7 @@ var init_thread_file_store = __esm({
         if (this.cache.has(threadId)) return true;
         const groupId = this.groupIndex.get(threadId) ?? await findGroupIdForThread(threadId);
         if (!groupId) return false;
-        return (0, import_fs9.existsSync)(getMetaPath3(groupId, threadId));
+        return (0, import_fs10.existsSync)(getMetaPath3(groupId, threadId));
       }
       async countByGroupId(groupId) {
         const threads = await this.listByGroupId(groupId);
@@ -106069,11 +106060,11 @@ var init_thread_file_store = __esm({
         if (patch.config !== void 0) current.config = patch.config;
         current.updatedAt = now2;
         const meta3 = threadToMetaFile(current);
-        await atomicWriteJson3(getMetaPath3(current.groupId, threadId), meta3);
+        await atomicWriteJson(getMetaPath3(current.groupId, threadId), meta3);
         const configFile = threadToConfigFile(current);
         if (configFile) {
           configFile.updatedAt = now2;
-          await atomicWriteJson3(getConfigPath3(current.groupId, threadId), configFile);
+          await atomicWriteJson(getConfigPath3(current.groupId, threadId), configFile);
         }
         this.cache.set(threadId, current);
         this.groupIndex.set(threadId, current.groupId);
@@ -106086,8 +106077,8 @@ var init_thread_file_store = __esm({
         this.cache.delete(threadId);
         this.groupIndex.delete(threadId);
         const dir = getThreadDir(current.groupId, threadId);
-        if ((0, import_fs9.existsSync)(dir)) {
-          await (0, import_promises6.rm)(dir, { force: true, recursive: true });
+        if ((0, import_fs10.existsSync)(dir)) {
+          await (0, import_promises7.rm)(dir, { force: true, recursive: true });
         }
         return true;
       }
@@ -106098,8 +106089,8 @@ var init_thread_file_store = __esm({
           this.cache.delete(thread.id);
           this.groupIndex.delete(thread.id);
           const dir = getThreadDir(groupId, thread.id);
-          if ((0, import_fs9.existsSync)(dir)) {
-            await (0, import_promises6.rm)(dir, { force: true, recursive: true });
+          if ((0, import_fs10.existsSync)(dir)) {
+            await (0, import_promises7.rm)(dir, { force: true, recursive: true });
           }
           count++;
         }
@@ -107035,19 +107026,19 @@ var require_token_io = __commonJS({
       getUserDataDir: () => getUserDataDir
     });
     module2.exports = __toCommonJS2(token_io_exports);
-    var import_path31 = __toESM2(require("path"));
-    var import_fs22 = __toESM2(require("fs"));
+    var import_path32 = __toESM2(require("path"));
+    var import_fs23 = __toESM2(require("fs"));
     var import_os4 = __toESM2(require("os"));
     var import_token_error = require_token_error();
     function findRootDir() {
       try {
         let dir = process.cwd();
-        while (dir !== import_path31.default.dirname(dir)) {
-          const pkgPath = import_path31.default.join(dir, ".vercel");
-          if (import_fs22.default.existsSync(pkgPath)) {
+        while (dir !== import_path32.default.dirname(dir)) {
+          const pkgPath = import_path32.default.join(dir, ".vercel");
+          if (import_fs23.default.existsSync(pkgPath)) {
             return dir;
           }
-          dir = import_path31.default.dirname(dir);
+          dir = import_path32.default.dirname(dir);
         }
       } catch (e) {
         throw new import_token_error.VercelOidcTokenError(
@@ -107062,9 +107053,9 @@ var require_token_io = __commonJS({
       }
       switch (import_os4.default.platform()) {
         case "darwin":
-          return import_path31.default.join(import_os4.default.homedir(), "Library/Application Support");
+          return import_path32.default.join(import_os4.default.homedir(), "Library/Application Support");
         case "linux":
-          return import_path31.default.join(import_os4.default.homedir(), ".local/share");
+          return import_path32.default.join(import_os4.default.homedir(), ".local/share");
         case "win32":
           if (process.env.LOCALAPPDATA) {
             return process.env.LOCALAPPDATA;
@@ -123933,15 +123924,15 @@ ${failureStats.recentFailures.slice(-3).map((f) => `  - ${f.toolName}(${f.toolCa
     failureStats.recentFailures = [];
   }
 }
-var import_path13, import_promises10, logger12, failureStats, FAILURE_REPORT_THRESHOLD, FAILURE_REPORT_INTERVAL, ToolResultSpillStrategy;
+var import_path14, import_promises11, logger12, failureStats, FAILURE_REPORT_THRESHOLD, FAILURE_REPORT_INTERVAL, ToolResultSpillStrategy;
 var init_ToolResultSpillStrategy = __esm({
   "src/core/agent/kernel/compression/strategies/ToolResultSpillStrategy.ts"() {
     "use strict";
     init_token_estimator();
     init_constants2();
     init_workspace();
-    import_path13 = __toESM(require("path"));
-    import_promises10 = __toESM(require("fs/promises"));
+    import_path14 = __toESM(require("path"));
+    import_promises11 = __toESM(require("fs/promises"));
     init_logger();
     logger12 = createLogger("tool-result-spill");
     failureStats = {
@@ -124029,11 +124020,11 @@ ${preview}${lines.length > 50 ? `
       async saveToolResultToFile(agentId, toolCallId, content) {
         const workspaceDir = getAgentWorkspaceDir(agentId);
         const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-        const toolResultsDir = import_path13.default.join(workspaceDir, "tool_results", today);
-        await import_promises10.default.mkdir(toolResultsDir, { recursive: true });
+        const toolResultsDir = import_path14.default.join(workspaceDir, "tool_results", today);
+        await import_promises11.default.mkdir(toolResultsDir, { recursive: true });
         const filename = `${toolCallId}.json`;
-        const filepath = import_path13.default.join(toolResultsDir, filename);
-        await import_promises10.default.writeFile(filepath, content, "utf-8");
+        const filepath = import_path14.default.join(toolResultsDir, filename);
+        await import_promises11.default.writeFile(filepath, content, "utf-8");
         return `tool_results/${today}/${filename}`;
       }
     };
@@ -125156,9 +125147,9 @@ function getWorkdirArg(args2) {
   return typeof workdir === "string" && workdir.length > 0 ? workdir : null;
 }
 function resolveFilePath(filePath, scope) {
-  if ((0, import_path14.isAbsolute)(filePath)) return filePath;
+  if ((0, import_path15.isAbsolute)(filePath)) return filePath;
   const baseDir = scope?.groupId ? getGroupDir(scope.groupId) : scope?.agentId ? getAgentWorkspaceDir(scope.agentId) : process.cwd();
-  return (0, import_path14.resolve)(baseDir, filePath);
+  return (0, import_path15.resolve)(baseDir, filePath);
 }
 function normalizeToolArgsForDisplay(toolName, args2, agentId, groupId) {
   if (!isFilePathTool(toolName)) return args2;
@@ -125166,15 +125157,15 @@ function normalizeToolArgsForDisplay(toolName, args2, agentId, groupId) {
   if (!path10) return args2;
   const workdir = getWorkdirArg(args2);
   if (workdir) {
-    return replaceToolPathArg(args2, (0, import_path14.isAbsolute)(path10) ? path10 : (0, import_path14.resolve)(workdir, path10));
+    return replaceToolPathArg(args2, (0, import_path15.isAbsolute)(path10) ? path10 : (0, import_path15.resolve)(workdir, path10));
   }
   return replaceToolPathArg(args2, resolveFilePath(path10, { agentId, groupId }));
 }
-var import_path14;
+var import_path15;
 var init_display = __esm({
   "src/core/tools/shared/display.ts"() {
     "use strict";
-    import_path14 = require("path");
+    import_path15 = require("path");
     init_workspace();
     init_group_file_store();
     init_tool_args();
@@ -130094,11 +130085,10 @@ var require_gray_matter = __commonJS({
 });
 
 // src/core/skill/SkillManager.ts
-function getAgentDir2(agentId) {
+function validateAgentId(agentId) {
   if (!/^[a-zA-Z0-9_-]{1,64}$/.test(agentId)) {
     throw new Error(`Invalid agentId: ${agentId}`);
   }
-  return (0, import_path15.join)(config.getAppDataPath(), "agents", agentId);
 }
 function normalizeAllowedTools(value) {
   if (!value) return void 0;
@@ -130109,9 +130099,9 @@ function normalizeAllowedTools(value) {
 async function scanSkillsFromPaths(paths) {
   const skillMap = /* @__PURE__ */ new Map();
   async function readSkillFile(skillsDir, skillName) {
-    const skillMdPath = (0, import_path15.join)(skillsDir, skillName, "SKILL.md");
+    const skillMdPath = (0, import_path16.join)(skillsDir, skillName, "SKILL.md");
     try {
-      const fileContent = await (0, import_promises11.readFile)(skillMdPath, "utf-8");
+      const fileContent = await (0, import_promises12.readFile)(skillMdPath, "utf-8");
       const { data: data2, content } = (0, import_gray_matter.default)(fileContent);
       if (!data2.description) return null;
       if (data2.name && data2.name !== skillName) {
@@ -130134,9 +130124,9 @@ async function scanSkillsFromPaths(paths) {
       return null;
     }
   }
-  for (const skillsDir of paths.reverse()) {
+  for (const skillsDir of [...paths].reverse()) {
     try {
-      const entries = await (0, import_promises11.readdir)(skillsDir, { withFileTypes: true });
+      const entries = await (0, import_promises12.readdir)(skillsDir, { withFileTypes: true });
       const skillDirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
       const results = await Promise.all(
         skillDirs.map((skillName) => readSkillFile(skillsDir, skillName))
@@ -130155,12 +130145,33 @@ async function scanSkillsFromPaths(paths) {
   }
   return Array.from(skillMap.values());
 }
-var import_path15, import_promises11, import_os3, import_gray_matter, logger18, SkillManager;
+function buildSkillSearchPaths({
+  appDataPath,
+  homeDir,
+  agentId,
+  projectPath
+}) {
+  const paths = [];
+  if (projectPath) {
+    paths.push((0, import_path16.join)(projectPath, ".kai", "skills"));
+    paths.push((0, import_path16.join)(projectPath, ".agents", "skills"));
+  }
+  if (agentId) {
+    paths.push((0, import_path16.join)(appDataPath, "agents", agentId, "skills"));
+  }
+  paths.push((0, import_path16.join)(appDataPath, "skills"));
+  paths.push((0, import_path16.join)(homeDir, ".agents", "skills"));
+  paths.push((0, import_path16.join)(homeDir, ".claude", "skills"));
+  paths.push((0, import_path16.join)(homeDir, ".openclaw", "skills"));
+  paths.push((0, import_path16.join)(homeDir, ".codex", "skills"));
+  return paths;
+}
+var import_path16, import_promises12, import_os3, import_gray_matter, logger18, SkillManager;
 var init_SkillManager = __esm({
   "src/core/skill/SkillManager.ts"() {
     "use strict";
-    import_path15 = require("path");
-    import_promises11 = require("fs/promises");
+    import_path16 = require("path");
+    import_promises12 = require("fs/promises");
     import_os3 = require("os");
     import_gray_matter = __toESM(require_gray_matter());
     init_config();
@@ -130188,17 +130199,15 @@ var init_SkillManager = __esm({
         if (cached2 && Date.now() - cached2.timestamp < this.CACHE_TTL) {
           return cached2.skills;
         }
-        const paths = [];
-        if (projectPath) {
-          paths.push((0, import_path15.join)(projectPath, ".kai", "skills"));
-          paths.push((0, import_path15.join)(projectPath, ".agents", "skills"));
-        }
         if (agentId) {
-          const agentDir = getAgentDir2(agentId);
-          paths.push((0, import_path15.join)(agentDir, "skills"));
+          validateAgentId(agentId);
         }
-        paths.push((0, import_path15.join)(config.getAppDataPath(), "skills"));
-        paths.push((0, import_path15.join)((0, import_os3.homedir)(), ".agents", "skills"));
+        const paths = buildSkillSearchPaths({
+          appDataPath: config.getAppDataPath(),
+          homeDir: (0, import_os3.homedir)(),
+          agentId,
+          projectPath
+        });
         const skills = await scanSkillsFromPaths(paths);
         const skillsConfig = config.get("skills") || {};
         const result = skills.map((skill) => ({
@@ -130279,24 +130288,24 @@ async function listSkillResources(skillDir) {
   const MAX_FILES_PER_DIR = 10;
   async function walk(dir, category) {
     try {
-      const entries = await (0, import_promises12.readdir)(dir, { withFileTypes: true });
+      const entries = await (0, import_promises13.readdir)(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (resources[category].length >= MAX_FILES_PER_DIR) break;
-        const fullPath = (0, import_path16.join)(dir, entry.name);
+        const fullPath = (0, import_path17.join)(dir, entry.name);
         if (entry.isDirectory() && !entry.isSymbolicLink()) {
           await walk(fullPath, category);
         } else if (!entry.isSymbolicLink()) {
-          resources[category].push((0, import_path16.relative)(skillDir, fullPath));
+          resources[category].push((0, import_path17.relative)(skillDir, fullPath));
         }
       }
     } catch {
     }
   }
-  await walk((0, import_path16.join)(skillDir, "scripts"), "scripts");
-  await walk((0, import_path16.join)(skillDir, "references"), "references");
-  await walk((0, import_path16.join)(skillDir, "assets"), "assets");
+  await walk((0, import_path17.join)(skillDir, "scripts"), "scripts");
+  await walk((0, import_path17.join)(skillDir, "references"), "references");
+  await walk((0, import_path17.join)(skillDir, "assets"), "assets");
   try {
-    const entries = await (0, import_promises12.readdir)(skillDir, { withFileTypes: true });
+    const entries = await (0, import_promises13.readdir)(skillDir, { withFileTypes: true });
     for (const entry of entries) {
       if (resources.other.length >= 5) break;
       if (entry.name === "SKILL.md" || entry.isDirectory()) continue;
@@ -130352,12 +130361,12 @@ ${otherXml}
     `</skill_content>`
   ].filter(Boolean).join("\n");
 }
-var import_path16, import_promises12, import_child_process2, import_util6, import_gray_matter2, logger19, execAsync, skillManager, SHELL_REGEX;
+var import_path17, import_promises13, import_child_process2, import_util6, import_gray_matter2, logger19, execAsync, skillManager, SHELL_REGEX;
 var init_skill = __esm({
   "src/core/skill/index.ts"() {
     "use strict";
-    import_path16 = require("path");
-    import_promises12 = require("fs/promises");
+    import_path17 = require("path");
+    import_promises13 = require("fs/promises");
     import_child_process2 = require("child_process");
     import_util6 = require("util");
     import_gray_matter2 = __toESM(require_gray_matter());
@@ -131810,7 +131819,7 @@ var init_TaskOrchestrator = __esm({
               status: "failed",
               blocks: [{
                 type: "text",
-                text: "\u76EE\u6807\u6210\u5458\u4E0D\u5B58\u5728\uFF0C\u5DF2\u8DF3\u8FC7\u8BE5\u76EE\u6807\uFF0C\u8BF7\u4ECE\u76EE\u6807\u5217\u8868\u4E2D\u79FB\u9664\u65E0\u6548 agentId \u540E\u518D\u8BD5\u3002",
+                text: "\u76EE\u6807\u6210\u5458\u4E0D\u5B58\u5728\uFF0C\u5DF2\u8DF3\u8FC7\u8BE5\u76EE\u6807\u3002",
                 id: `broadcast-error-${agentId}`
               }],
               error: `Agent ${agentId} \u4E0D\u5728\u5F53\u524D\u7FA4\u804A\u6210\u5458\u4E2D\u3002\u5F53\u524D\u6210\u5458 ID\uFF1A${memberIds.join(", ")}\u3002`
@@ -134037,6 +134046,29 @@ var init_StreamingPersistScheduler = __esm({
 });
 
 // src/core/message/queue/MessageProcessor.ts
+function settlePendingBlocks(blocks, now2 = Date.now()) {
+  let changed = false;
+  const settled = blocks.map((block) => {
+    if (!block.isPending) return block;
+    changed = true;
+    if (block.type !== "tool" || block.toolCall.status !== "pending") {
+      return { ...block, isPending: false };
+    }
+    const endedAt = now2;
+    return {
+      ...block,
+      isPending: false,
+      toolCall: {
+        ...block.toolCall,
+        status: "error",
+        error: "\u7528\u6237\u5DF2\u505C\u6B62\u6267\u884C",
+        endedAt,
+        durationMs: endedAt - block.toolCall.startedAt
+      }
+    };
+  });
+  return changed ? settled : blocks;
+}
 function normalizeUsage(usage) {
   const normalized = {};
   for (const key of TOKEN_USAGE_KEYS) {
@@ -134299,6 +134331,7 @@ var init_MessageProcessor = __esm({
         try {
           if (err instanceof DOMException ? err.name === "AbortError" : err instanceof Error && err.name === "AbortError") {
             if (streamingBlocks.length > 0) {
+              ctx.streamingBlocks = settlePendingBlocks(streamingBlocks);
               await this.persistErrorMessage(ctx);
             }
             eventBus.emit({
@@ -136556,7 +136589,7 @@ var init_entities = __esm({
 });
 
 // src/adapters/scheduler/MemoryUpdateExecutor.ts
-var import_path17, MemoryUpdateExecutor;
+var import_path18, MemoryUpdateExecutor;
 var init_MemoryUpdateExecutor = __esm({
   "src/adapters/scheduler/MemoryUpdateExecutor.ts"() {
     "use strict";
@@ -136564,7 +136597,7 @@ var init_MemoryUpdateExecutor = __esm({
     init_ipc_events();
     init_entities();
     init_workspace();
-    import_path17 = __toESM(require("path"));
+    import_path18 = __toESM(require("path"));
     MemoryUpdateExecutor = class _MemoryUpdateExecutor {
       type = "memory-update";
       async execute(task, ctx) {
@@ -136720,13 +136753,13 @@ var init_MemoryUpdateExecutor = __esm({
         return result;
       }
       toRelativeWorkspacePath(workspaceDir, absolutePath) {
-        const normalizedWorkspace = import_path17.default.resolve(workspaceDir);
-        const normalizedTarget = import_path17.default.resolve(absolutePath);
-        const relativePath = import_path17.default.relative(normalizedWorkspace, normalizedTarget);
-        if (!relativePath || relativePath.startsWith("..") || import_path17.default.isAbsolute(relativePath)) {
+        const normalizedWorkspace = import_path18.default.resolve(workspaceDir);
+        const normalizedTarget = import_path18.default.resolve(absolutePath);
+        const relativePath = import_path18.default.relative(normalizedWorkspace, normalizedTarget);
+        if (!relativePath || relativePath.startsWith("..") || import_path18.default.isAbsolute(relativePath)) {
           return null;
         }
-        return relativePath.split(import_path17.default.sep).join("/");
+        return relativePath.split(import_path18.default.sep).join("/");
       }
       summarizeDiff(diff) {
         if (!diff) return void 0;
@@ -140703,31 +140736,31 @@ function getKaiRoot() {
   return config.getAppDataPath();
 }
 function getDbPath() {
-  return (0, import_path20.join)(config.getAppDataPath(), "kai.db");
+  return (0, import_path21.join)(config.getAppDataPath(), "kai.db");
 }
 function getThreadsRoot(groupId) {
-  return (0, import_path20.join)(getGroupDir(groupId), "threads");
+  return (0, import_path21.join)(getGroupDir(groupId), "threads");
 }
 function getThreadMetaPath(groupId, threadId) {
-  return (0, import_path20.join)(getThreadsRoot(groupId), threadId, "meta.json");
+  return (0, import_path21.join)(getThreadsRoot(groupId), threadId, "meta.json");
 }
-async function atomicWriteJson5(filePath, data2) {
-  await (0, import_promises21.mkdir)((0, import_path20.dirname)(filePath), { recursive: true });
+async function atomicWriteJson3(filePath, data2) {
+  await (0, import_promises22.mkdir)((0, import_path21.dirname)(filePath), { recursive: true });
   const tmp = `${filePath}.tmp`;
-  await (0, import_promises21.writeFile)(tmp, `${JSON.stringify(data2, null, 2)}
+  await (0, import_promises22.writeFile)(tmp, `${JSON.stringify(data2, null, 2)}
 `, "utf-8");
-  await (0, import_promises21.rename)(tmp, filePath);
+  await (0, import_promises22.rename)(tmp, filePath);
 }
 async function isMigrationNeeded() {
-  const groupsRoot = (0, import_path20.join)(getKaiRoot(), "groups");
-  if ((0, import_fs13.existsSync)(groupsRoot)) {
+  const groupsRoot = (0, import_path21.join)(getKaiRoot(), "groups");
+  if ((0, import_fs14.existsSync)(groupsRoot)) {
     try {
       const { readdir: readdir9 } = await import("fs/promises");
       const entries = await readdir9(groupsRoot, { withFileTypes: true });
       const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
       if (dirs.length > 0) {
         const allMigrated = dirs.every(
-          (g) => (0, import_fs13.existsSync)((0, import_path20.join)(getGroupDir(g), "threads"))
+          (g) => (0, import_fs14.existsSync)((0, import_path21.join)(getGroupDir(g), "threads"))
         );
         if (allMigrated) return false;
       }
@@ -140772,7 +140805,7 @@ async function migrateGroupsToThreads() {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const backupPath = `${dbPath}.bak.${timestamp}`;
   logger33.debug(`Backing up database to ${backupPath}`);
-  await (0, import_promises21.copyFile)(dbPath, backupPath);
+  await (0, import_promises22.copyFile)(dbPath, backupPath);
   try {
     logger33.debug("Rebuilding messages table (removing FK)");
     await sequelize.transaction(async (t) => {
@@ -140897,20 +140930,20 @@ async function migrateGroupsToThreads() {
         createdAt,
         updatedAt
       };
-      await atomicWriteJson5(getThreadMetaPath(groupId, threadId), threadMeta);
+      await atomicWriteJson3(getThreadMetaPath(groupId, threadId), threadMeta);
     }
     logger33.debug("Thread files created");
     let groupsWithThread = 0;
     for (const conv of groupConversations) {
       const row = conv;
       const groupId = row.target_id;
-      const threadsDir = (0, import_path20.join)(getGroupDir(groupId), "threads");
-      if (!(0, import_fs13.existsSync)(threadsDir)) continue;
+      const threadsDir = (0, import_path21.join)(getGroupDir(groupId), "threads");
+      if (!(0, import_fs14.existsSync)(threadsDir)) continue;
       try {
         const { readdir: readdirAsync } = await import("fs/promises");
         const threadDirs = (await readdirAsync(threadsDir, { withFileTypes: true })).filter((e) => e.isDirectory());
         const hasMeta = threadDirs.some(
-          (td) => (0, import_fs13.existsSync)((0, import_path20.join)(threadsDir, td.name, "meta.json"))
+          (td) => (0, import_fs14.existsSync)((0, import_path21.join)(threadsDir, td.name, "meta.json"))
         );
         if (hasMeta) groupsWithThread++;
       } catch {
@@ -140943,10 +140976,10 @@ async function migrateGroupsToThreads() {
     );
   } catch (error48) {
     logger33.error("Migration failed:", error48);
-    if ((0, import_fs13.existsSync)(backupPath)) {
+    if ((0, import_fs14.existsSync)(backupPath)) {
       logger33.debug("Restoring database from backup...");
       try {
-        await (0, import_promises21.copyFile)(backupPath, dbPath);
+        await (0, import_promises22.copyFile)(backupPath, dbPath);
         logger33.debug("Database restored from backup");
       } catch (restoreError) {
         logger33.error(
@@ -140961,15 +140994,15 @@ async function migrateGroupsToThreads() {
 async function rollbackThreads() {
   const sequelize = getSequelize();
   const dbPath = getDbPath();
-  const groupsRoot = (0, import_path20.join)(getKaiRoot(), "groups");
-  if (!(0, import_fs13.existsSync)(groupsRoot)) {
+  const groupsRoot = (0, import_path21.join)(getKaiRoot(), "groups");
+  if (!(0, import_fs14.existsSync)(groupsRoot)) {
     logger33.debug("No groups directory, nothing to rollback.");
     return;
   }
   const { readdir: readdir9 } = await import("fs/promises");
   const dirs = (await readdir9(groupsRoot, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
   const hasThreads = dirs.some(
-    (g) => (0, import_fs13.existsSync)((0, import_path20.join)(getGroupDir(g), "threads"))
+    (g) => (0, import_fs14.existsSync)((0, import_path21.join)(getGroupDir(g), "threads"))
   );
   if (!hasThreads) {
     logger33.debug("No threads directories found, nothing to rollback.");
@@ -140984,13 +141017,13 @@ async function rollbackThreads() {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const backupPath = `${dbPath}.bak.rollback.${timestamp}`;
   logger33.debug(`Backing up database to ${backupPath}`);
-  await (0, import_promises21.copyFile)(dbPath, backupPath);
+  await (0, import_promises22.copyFile)(dbPath, backupPath);
   try {
     logger33.debug("Restoring group conversations from thread files");
     let restored = 0;
     for (const groupId of dirs) {
-      const threadsDir = (0, import_path20.join)(getGroupDir(groupId), "threads");
-      if (!(0, import_fs13.existsSync)(threadsDir)) continue;
+      const threadsDir = (0, import_path21.join)(getGroupDir(groupId), "threads");
+      if (!(0, import_fs14.existsSync)(threadsDir)) continue;
       let threadDirs;
       try {
         threadDirs = (await readdir9(threadsDir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
@@ -140999,8 +141032,8 @@ async function rollbackThreads() {
       }
       for (const threadId of threadDirs) {
         const metaPath = getThreadMetaPath(groupId, threadId);
-        if (!(0, import_fs13.existsSync)(metaPath)) continue;
-        const raw = await (0, import_promises21.readFile)(metaPath, "utf-8");
+        if (!(0, import_fs14.existsSync)(metaPath)) continue;
+        const raw = await (0, import_promises22.readFile)(metaPath, "utf-8");
         const meta3 = JSON.parse(raw);
         if (!meta3.isDefault) {
           const orphanCount = await sequelize.query(
@@ -141127,9 +141160,9 @@ async function rollbackThreads() {
     logger33.debug("Messages table rebuilt with FK restored");
     logger33.debug("Removing threads directories");
     for (const groupId of dirs) {
-      const threadsDir = (0, import_path20.join)(getGroupDir(groupId), "threads");
-      if ((0, import_fs13.existsSync)(threadsDir)) {
-        await (0, import_promises21.rm)(threadsDir, { recursive: true, force: true });
+      const threadsDir = (0, import_path21.join)(getGroupDir(groupId), "threads");
+      if ((0, import_fs14.existsSync)(threadsDir)) {
+        await (0, import_promises22.rm)(threadsDir, { recursive: true, force: true });
       }
     }
     const finalRows = await sequelize.query(
@@ -141147,10 +141180,10 @@ async function rollbackThreads() {
     );
   } catch (error48) {
     logger33.error("Rollback failed:", error48);
-    if ((0, import_fs13.existsSync)(backupPath)) {
+    if ((0, import_fs14.existsSync)(backupPath)) {
       logger33.debug("Restoring database from backup...");
       try {
-        await (0, import_promises21.copyFile)(backupPath, dbPath);
+        await (0, import_promises22.copyFile)(backupPath, dbPath);
         logger33.debug("Database restored from backup");
       } catch (restoreError) {
         logger33.error(
@@ -141162,13 +141195,13 @@ async function rollbackThreads() {
     throw error48;
   }
 }
-var import_path20, import_fs13, import_promises21, logger33;
+var import_path21, import_fs14, import_promises22, logger33;
 var init_threads_migration = __esm({
   "src/adapters/db/migration/threads-migration.ts"() {
     "use strict";
-    import_path20 = require("path");
-    import_fs13 = require("fs");
-    import_promises21 = require("fs/promises");
+    import_path21 = require("path");
+    import_fs14 = require("fs");
+    import_promises22 = require("fs/promises");
     init_lib();
     init_sequelize();
     init_config();
@@ -141186,13 +141219,13 @@ __export(cron_sqlite_migration_exports, {
   migrateCronSqliteToFileStore: () => migrateCronSqliteToFileStore
 });
 function getDataCronDir2() {
-  return (0, import_path21.join)(config.getAppDataPath(), "data", CRON_DIR2);
+  return (0, import_path22.join)(config.getAppDataPath(), "data", CRON_DIR2);
 }
 function getAgentsDir2() {
-  return (0, import_path21.join)(config.getAppDataPath(), "agents");
+  return (0, import_path22.join)(config.getAppDataPath(), "agents");
 }
 function getGroupsDir2() {
-  return (0, import_path21.join)(config.getAppDataPath(), "groups");
+  return (0, import_path22.join)(config.getAppDataPath(), "groups");
 }
 function parseDatetime(value) {
   if (!value) return 0;
@@ -141210,17 +141243,17 @@ function parseScriptArgs(raw) {
 }
 async function writeJsonAtomic(filePath, data2) {
   const dir = filePath.substring(0, filePath.lastIndexOf("/"));
-  await (0, import_promises22.mkdir)(dir, { recursive: true });
+  await (0, import_promises23.mkdir)(dir, { recursive: true });
   const tmp = `${filePath}.tmp`;
-  await (0, import_promises22.writeFile)(tmp, JSON.stringify(data2, null, 2), "utf-8");
-  await (0, import_promises22.rename)(tmp, filePath);
+  await (0, import_promises23.writeFile)(tmp, JSON.stringify(data2, null, 2), "utf-8");
+  await (0, import_promises23.rename)(tmp, filePath);
 }
 function getTaskDir2(task) {
   if (task.type === "agent" && task.agentId) {
-    return (0, import_path21.join)(getAgentsDir2(), task.agentId, CRON_DIR2);
+    return (0, import_path22.join)(getAgentsDir2(), task.agentId, CRON_DIR2);
   }
   if (task.type === "group" && task.groupId) {
-    return (0, import_path21.join)(getGroupsDir2(), task.groupId, CRON_DIR2);
+    return (0, import_path22.join)(getGroupsDir2(), task.groupId, CRON_DIR2);
   }
   return getDataCronDir2();
 }
@@ -141257,8 +141290,8 @@ async function migrateTasks(sequelize) {
         continue;
       }
       const dir = getTaskDir2(task);
-      const filePath = (0, import_path21.join)(dir, `${task.id}.json`);
-      if ((0, import_fs14.existsSync)(filePath)) {
+      const filePath = (0, import_path22.join)(dir, `${task.id}.json`);
+      if ((0, import_fs15.existsSync)(filePath)) {
         logger34.debug(`Task ${task.id} already exists in filesystem, skipping`);
         continue;
       }
@@ -141290,10 +141323,10 @@ async function migrateExecutions(sequelize) {
   for (const [taskId, execs] of byTask) {
     try {
       const taskDir = await findTaskBaseDir(taskId);
-      const execDir = (0, import_path21.join)(taskDir, taskId);
+      const execDir = (0, import_path22.join)(taskDir, taskId);
       for (const row of execs) {
-        const filePath = (0, import_path21.join)(execDir, `${row.id}.json`);
-        if ((0, import_fs14.existsSync)(filePath)) continue;
+        const filePath = (0, import_path22.join)(execDir, `${row.id}.json`);
+        if ((0, import_fs15.existsSync)(filePath)) continue;
         const execution = {
           id: row.id,
           taskId: row.task_id,
@@ -141385,28 +141418,28 @@ function rowToTask(row, conversationMap) {
   };
 }
 async function findTaskBaseDir(taskId) {
-  const directGlobalPath = (0, import_path21.join)(getDataCronDir2(), `${taskId}.json`);
-  if ((0, import_fs14.existsSync)(directGlobalPath)) return getDataCronDir2();
+  const directGlobalPath = (0, import_path22.join)(getDataCronDir2(), `${taskId}.json`);
+  if ((0, import_fs15.existsSync)(directGlobalPath)) return getDataCronDir2();
   const agentsDir = getAgentsDir2();
-  if ((0, import_fs14.existsSync)(agentsDir)) {
+  if ((0, import_fs15.existsSync)(agentsDir)) {
     try {
-      const owners = await (0, import_promises22.readdir)(agentsDir);
+      const owners = await (0, import_promises23.readdir)(agentsDir);
       for (const ownerId of owners) {
-        const cronDir = (0, import_path21.join)(agentsDir, ownerId, CRON_DIR2);
-        const filePath = (0, import_path21.join)(cronDir, `${taskId}.json`);
-        if ((0, import_fs14.existsSync)(filePath)) return cronDir;
+        const cronDir = (0, import_path22.join)(agentsDir, ownerId, CRON_DIR2);
+        const filePath = (0, import_path22.join)(cronDir, `${taskId}.json`);
+        if ((0, import_fs15.existsSync)(filePath)) return cronDir;
       }
     } catch {
     }
   }
   const groupsDir = getGroupsDir2();
-  if ((0, import_fs14.existsSync)(groupsDir)) {
+  if ((0, import_fs15.existsSync)(groupsDir)) {
     try {
-      const owners = await (0, import_promises22.readdir)(groupsDir);
+      const owners = await (0, import_promises23.readdir)(groupsDir);
       for (const ownerId of owners) {
-        const cronDir = (0, import_path21.join)(groupsDir, ownerId, CRON_DIR2);
-        const filePath = (0, import_path21.join)(cronDir, `${taskId}.json`);
-        if ((0, import_fs14.existsSync)(filePath)) return cronDir;
+        const cronDir = (0, import_path22.join)(groupsDir, ownerId, CRON_DIR2);
+        const filePath = (0, import_path22.join)(cronDir, `${taskId}.json`);
+        if ((0, import_fs15.existsSync)(filePath)) return cronDir;
       }
     } catch {
     }
@@ -141439,14 +141472,14 @@ async function migrateCronSqliteToFileStore() {
   logger34.debug(`Migrated ${tasksMigrated} tasks and ${execsMigrated} executions to filesystem`);
   await dropLegacyTables(sequelize);
 }
-var import_path21, import_promises22, import_fs14, logger34, CRON_DIR2;
+var import_path22, import_promises23, import_fs15, logger34, CRON_DIR2;
 var init_cron_sqlite_migration = __esm({
   "src/adapters/db/migration/cron-sqlite-migration.ts"() {
     "use strict";
     init_lib();
-    import_path21 = require("path");
-    import_promises22 = require("fs/promises");
-    import_fs14 = require("fs");
+    import_path22 = require("path");
+    import_promises23 = require("fs/promises");
+    import_fs15 = require("fs");
     init_config();
     init_logger();
     logger34 = createLogger("cron-sqlite-migration");
@@ -160932,8 +160965,8 @@ var require_snapshot_utils = __commonJS({
 var require_snapshot_recorder = __commonJS({
   "node_modules/undici/lib/mock/snapshot-recorder.js"(exports2, module2) {
     "use strict";
-    var { writeFile: writeFile15, readFile: readFile18, mkdir: mkdir15 } = require("node:fs/promises");
-    var { dirname: dirname9, resolve: resolve9 } = require("node:path");
+    var { writeFile: writeFile13, readFile: readFile17, mkdir: mkdir15 } = require("node:fs/promises");
+    var { dirname: dirname8, resolve: resolve9 } = require("node:path");
     var { setTimeout: setTimeout2, clearTimeout: clearTimeout2 } = require("node:timers");
     var { InvalidArgumentError: InvalidArgumentError3, UndiciError } = require_errors3();
     var { hashId, isUrlExcludedFactory, normalizeHeaders: normalizeHeaders3, createHeaderFilters } = require_snapshot_utils();
@@ -161134,7 +161167,7 @@ var require_snapshot_recorder = __commonJS({
           throw new InvalidArgumentError3("Snapshot path is required");
         }
         try {
-          const data2 = await readFile18(resolve9(path10), "utf8");
+          const data2 = await readFile17(resolve9(path10), "utf8");
           const parsed = JSON.parse(data2);
           if (Array.isArray(parsed)) {
             this.#snapshots.clear();
@@ -161164,12 +161197,12 @@ var require_snapshot_recorder = __commonJS({
           throw new InvalidArgumentError3("Snapshot path is required");
         }
         const resolvedPath = resolve9(path10);
-        await mkdir15(dirname9(resolvedPath), { recursive: true });
+        await mkdir15(dirname8(resolvedPath), { recursive: true });
         const data2 = Array.from(this.#snapshots.entries()).map(([hash2, snapshot]) => ({
           hash: hash2,
           snapshot
         }));
-        await writeFile15(resolvedPath, JSON.stringify(data2, null, 2), { flush: true });
+        await writeFile13(resolvedPath, JSON.stringify(data2, null, 2), { flush: true });
       }
       /**
        * Clears all recorded snapshots
@@ -189923,7 +189956,7 @@ var McpManager = class {
     this.clients.set(id, client);
     const tools = await client.listTools();
     for (const tool2 of tools) {
-      const namespacedName = `${id}:${tool2.name}`;
+      const namespacedName = `${id}_${tool2.name}`;
       this.tools.set(namespacedName, { client, tool: tool2, serverId: id, originalName: tool2.name });
     }
   }
@@ -190302,27 +190335,27 @@ var eventBridge = new EventBridge();
 
 // src/adapters/storage/SessionCleaner.ts
 init_config();
-var import_path6 = __toESM(require("path"));
-var import_promises4 = __toESM(require("fs/promises"));
-var import_fs6 = require("fs");
+var import_path7 = __toESM(require("path"));
+var import_promises5 = __toESM(require("fs/promises"));
+var import_fs7 = require("fs");
 init_logger();
 var logger7 = createLogger("SessionCleaner");
 var SessionCleaner = class {
   async cleanOldSessions(maxAgeDays = 30) {
-    const sessionsDir = import_path6.default.join(config.getAppDataPath(), "sessions");
-    if (!(0, import_fs6.existsSync)(sessionsDir)) {
+    const sessionsDir = import_path7.default.join(config.getAppDataPath(), "sessions");
+    if (!(0, import_fs7.existsSync)(sessionsDir)) {
       return 0;
     }
     try {
-      const dirs = await import_promises4.default.readdir(sessionsDir);
+      const dirs = await import_promises5.default.readdir(sessionsDir);
       const cutoffTime = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
       let cleaned = 0;
       for (const dir of dirs) {
-        const fullPath = import_path6.default.join(sessionsDir, dir);
+        const fullPath = import_path7.default.join(sessionsDir, dir);
         try {
-          const stat5 = await import_promises4.default.stat(fullPath);
+          const stat5 = await import_promises5.default.stat(fullPath);
           if (stat5.isDirectory() && stat5.mtimeMs < cutoffTime) {
-            await import_promises4.default.rm(fullPath, { recursive: true, force: true });
+            await import_promises5.default.rm(fullPath, { recursive: true, force: true });
             cleaned++;
             logger7.debug("Removed old session:", dir);
           }
@@ -190655,12 +190688,12 @@ function extractQuoteText(quote) {
 
 // src/adapters/channel/wecom/WeComBotAdapter.ts
 init_logger();
-var import_promises8 = require("node:fs/promises");
+var import_promises9 = require("node:fs/promises");
 var import_node_path = require("node:path");
 
 // src/adapters/storage/AttachmentStorage.ts
-var import_fs7 = require("fs");
-var import_path7 = require("path");
+var import_fs8 = require("fs");
+var import_path8 = require("path");
 init_config();
 
 // src/shared/utils/mime-types.ts
@@ -190746,10 +190779,10 @@ var logger8 = createLogger("attachment-storage");
 var AttachmentStorage = class {
   baseDir;
   constructor() {
-    this.baseDir = (0, import_path7.join)(config.getAppDataPath(), "attachments");
+    this.baseDir = (0, import_path8.join)(config.getAppDataPath(), "attachments");
   }
   async ensureBaseDir() {
-    await import_fs7.promises.mkdir(this.baseDir, { recursive: true });
+    await import_fs8.promises.mkdir(this.baseDir, { recursive: true });
   }
   getDateFolder() {
     const now2 = /* @__PURE__ */ new Date();
@@ -190758,16 +190791,16 @@ var AttachmentStorage = class {
   async saveAttachment(fileBuffer, originalFilename, providedMimeType) {
     await this.ensureBaseDir();
     const dateFolder = this.getDateFolder();
-    const datePath = (0, import_path7.join)(this.baseDir, dateFolder);
-    await import_fs7.promises.mkdir(datePath, { recursive: true });
+    const datePath = (0, import_path8.join)(this.baseDir, dateFolder);
+    await import_fs8.promises.mkdir(datePath, { recursive: true });
     const timestamp = Date.now();
     const sanitized = sanitizeFilename(originalFilename);
     const filename = `${timestamp}_${sanitized}`;
-    const absolutePath = (0, import_path7.join)(datePath, filename);
-    const relativePath = (0, import_path7.join)(dateFolder, filename);
-    await import_fs7.promises.writeFile(absolutePath, fileBuffer);
-    const stats = await import_fs7.promises.stat(absolutePath);
-    const ext = (0, import_path7.extname)(originalFilename).toLowerCase();
+    const absolutePath = (0, import_path8.join)(datePath, filename);
+    const relativePath = (0, import_path8.join)(dateFolder, filename);
+    await import_fs8.promises.writeFile(absolutePath, fileBuffer);
+    const stats = await import_fs8.promises.stat(absolutePath);
+    const ext = (0, import_path8.extname)(originalFilename).toLowerCase();
     const mimeType = providedMimeType?.trim() || getMimeType(ext);
     return {
       id: `${timestamp}`,
@@ -190779,12 +190812,12 @@ var AttachmentStorage = class {
     };
   }
   async getAttachmentPath(relativePath) {
-    return (0, import_path7.join)(this.baseDir, relativePath);
+    return (0, import_path8.join)(this.baseDir, relativePath);
   }
   async deleteAttachment(relativePath) {
-    const absolutePath = (0, import_path7.join)(this.baseDir, relativePath);
+    const absolutePath = (0, import_path8.join)(this.baseDir, relativePath);
     try {
-      await import_fs7.promises.unlink(absolutePath);
+      await import_fs8.promises.unlink(absolutePath);
     } catch (error48) {
       logger8.error("Failed to delete attachment:", error48);
     }
@@ -190800,8 +190833,8 @@ var AttachmentStorage = class {
 
 // src/adapters/storage/SessionStorage.ts
 init_config();
-var import_path10 = __toESM(require("path"));
-var import_promises7 = __toESM(require("fs/promises"));
+var import_path11 = __toESM(require("path"));
+var import_promises8 = __toESM(require("fs/promises"));
 init_thread_file_store();
 init_agent_file_store();
 init_logger();
@@ -190816,14 +190849,14 @@ var SessionStorage = class {
    */
   async getConversationsFile(conversationId) {
     const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    const dir = import_path10.default.resolve(
+    const dir = import_path11.default.resolve(
       config.getAppDataPath(),
       `conversations/${conversationId}/messages`
     );
-    await import_promises7.default.mkdir(dir, { recursive: true }).catch((err) => {
+    await import_promises8.default.mkdir(dir, { recursive: true }).catch((err) => {
       logger10.warn("Failed to create messages directory:", dir, err);
     });
-    return import_path10.default.resolve(dir, `${today}.jsonl`);
+    return import_path11.default.resolve(dir, `${today}.jsonl`);
   }
   // ---------------------------------------------------------------------------
   // 单聊：~/.kai/agents/{agentId}/context.json
@@ -190832,7 +190865,7 @@ var SessionStorage = class {
    * 获取单聊上下文文件路径（纯函数）。
    */
   getAgentContextPath(agentId) {
-    return import_path10.default.join(getAgentRootDir(agentId), "context.json");
+    return import_path11.default.join(getAgentRootDir(agentId), "context.json");
   }
   /**
    * 读取单聊上下文。
@@ -190840,7 +190873,7 @@ var SessionStorage = class {
   async getAgentContext(agentId) {
     const file2 = this.getAgentContextPath(agentId);
     try {
-      const content = await import_promises7.default.readFile(file2, "utf-8");
+      const content = await import_promises8.default.readFile(file2, "utf-8");
       return JSON.parse(content);
     } catch (error48) {
       if (isErrnoException(error48) && error48.code === "ENOENT") {
@@ -190855,11 +190888,11 @@ var SessionStorage = class {
    */
   async saveAgentContext(agentId, messages) {
     const agentDir = getAgentRootDir(agentId);
-    await import_promises7.default.mkdir(agentDir, { recursive: true });
+    await import_promises8.default.mkdir(agentDir, { recursive: true });
     const file2 = this.getAgentContextPath(agentId);
     const tmp = `${file2}.tmp`;
-    await import_promises7.default.writeFile(tmp, JSON.stringify(messages, null, 2), "utf-8");
-    await import_promises7.default.rename(tmp, file2);
+    await import_promises8.default.writeFile(tmp, JSON.stringify(messages, null, 2), "utf-8");
+    await import_promises8.default.rename(tmp, file2);
   }
   // ---------------------------------------------------------------------------
   // 群聊：groups/{groupId}/threads/{threadId}/context.json
@@ -190868,7 +190901,7 @@ var SessionStorage = class {
    * 获取线程上下文文件路径（纯函数，无副作用）。
    */
   getThreadContextPath(groupId, threadId) {
-    return import_path10.default.join(getThreadDir(groupId, threadId), "context.json");
+    return import_path11.default.join(getThreadDir(groupId, threadId), "context.json");
   }
   /**
    * 读取线程上下文（群聊）。
@@ -190876,7 +190909,7 @@ var SessionStorage = class {
   async getThreadContext(groupId, threadId) {
     const file2 = this.getThreadContextPath(groupId, threadId);
     try {
-      const content = await import_promises7.default.readFile(file2, "utf-8");
+      const content = await import_promises8.default.readFile(file2, "utf-8");
       return JSON.parse(content);
     } catch (error48) {
       if (isErrnoException(error48) && error48.code === "ENOENT") {
@@ -190891,11 +190924,11 @@ var SessionStorage = class {
    */
   async saveThreadContext(groupId, threadId, messages) {
     const threadDir = getThreadDir(groupId, threadId);
-    await import_promises7.default.mkdir(threadDir, { recursive: true });
+    await import_promises8.default.mkdir(threadDir, { recursive: true });
     const file2 = this.getThreadContextPath(groupId, threadId);
     const tmp = `${file2}.tmp`;
-    await import_promises7.default.writeFile(tmp, JSON.stringify(messages, null, 2), "utf-8");
-    await import_promises7.default.rename(tmp, file2);
+    await import_promises8.default.writeFile(tmp, JSON.stringify(messages, null, 2), "utf-8");
+    await import_promises8.default.rename(tmp, file2);
   }
   // ---------------------------------------------------------------------------
   // 通用
@@ -190906,14 +190939,14 @@ var SessionStorage = class {
     const file2 = await this.getConversationsFile(conversationId);
     let startSeq = 1;
     try {
-      const existing = await import_promises7.default.readFile(file2, "utf-8");
+      const existing = await import_promises8.default.readFile(file2, "utf-8");
       startSeq = existing.trim().split("\n").filter(Boolean).length + 1;
     } catch {
     }
     const lines = filtered.map(
       (m, i) => JSON.stringify({ seq: startSeq + i, role: m.role, content: m.content, timestamp: Date.now() })
     );
-    await import_promises7.default.appendFile(file2, lines.join("\n") + "\n", "utf-8");
+    await import_promises8.default.appendFile(file2, lines.join("\n") + "\n", "utf-8");
   }
 };
 
@@ -191024,7 +191057,7 @@ var WeComBotAdapter = class {
     if (!this.client) {
       throw new Error("Client not initialized");
     }
-    const buffer = await (0, import_promises8.readFile)(filePath);
+    const buffer = await (0, import_promises9.readFile)(filePath);
     const filename = (0, import_node_path.basename)(filePath);
     const mediaType = isImageExtension((0, import_node_path.extname)(filePath)) ? "image" : "file";
     const uploaded = await this.client.uploadMedia(buffer, { type: mediaType, filename });
@@ -191742,7 +191775,7 @@ var WeChatPersonalClient = class {
 
 // src/adapters/channel/wechat-personal/WeChatPersonalAdapter.ts
 init_logger();
-var import_promises9 = require("node:fs/promises");
+var import_promises10 = require("node:fs/promises");
 var import_node_path2 = require("node:path");
 var log7 = createLogger("WeChatPersonalAdapter");
 var WeChatPersonalAdapter = class {
@@ -191810,7 +191843,7 @@ var WeChatPersonalAdapter = class {
     if (!this.client) {
       throw new Error("Client not initialized");
     }
-    const buffer = await (0, import_promises9.readFile)(filePath);
+    const buffer = await (0, import_promises10.readFile)(filePath);
     const filename = (0, import_node_path2.basename)(filePath);
     const mediaType = isImageExtension((0, import_node_path2.extname)(filePath)) ? "image" : "file";
     await this.client.sendFile(chatId, buffer, filename, mediaType);
@@ -191901,15 +191934,15 @@ var WeChatPersonalAdapter = class {
 };
 
 // src/adapters/channel/shared/ChannelConfigStore.ts
-var import_fs10 = require("fs");
-var import_path11 = require("path");
+var import_fs11 = require("fs");
+var import_path12 = require("path");
 init_logger();
 init_config();
 var log8 = createLogger("ChannelConfigStore");
 var ChannelConfigStore = class {
   baseDir;
   constructor(baseDir) {
-    this.baseDir = baseDir ?? (0, import_path11.join)(config.getAppDataPath(), "channels");
+    this.baseDir = baseDir ?? (0, import_path12.join)(config.getAppDataPath(), "channels");
     this.ensureDir();
   }
   /** 文件名：{type}_{connectionId}.json */
@@ -191918,24 +191951,31 @@ var ChannelConfigStore = class {
   }
   /** 确保存储目录存在 */
   ensureDir() {
-    if (!(0, import_fs10.existsSync)(this.baseDir)) {
-      (0, import_fs10.mkdirSync)(this.baseDir, { recursive: true });
+    if (!(0, import_fs11.existsSync)(this.baseDir)) {
+      (0, import_fs11.mkdirSync)(this.baseDir, { recursive: true });
       log8.info(`Created channels directory: ${this.baseDir}`);
     }
   }
+  readConfig(filePath) {
+    const raw = (0, import_fs11.readFileSync)(filePath, "utf-8");
+    const config3 = JSON.parse(raw);
+    if (!config3.createdAt) {
+      const stat5 = (0, import_fs11.statSync)(filePath);
+      config3.createdAt = stat5.birthtimeMs || stat5.mtimeMs;
+    }
+    return config3;
+  }
   /** 列出所有已配置的接入 */
   async list() {
-    if (!(0, import_fs10.existsSync)(this.baseDir)) {
+    if (!(0, import_fs11.existsSync)(this.baseDir)) {
       return [];
     }
-    const files = (0, import_fs10.readdirSync)(this.baseDir).filter((f) => f.endsWith(".json"));
+    const files = (0, import_fs11.readdirSync)(this.baseDir).filter((f) => f.endsWith(".json"));
     const configs = [];
     for (const file2 of files) {
       try {
-        const filePath = (0, import_path11.join)(this.baseDir, file2);
-        const raw = (0, import_fs10.readFileSync)(filePath, "utf-8");
-        const config3 = JSON.parse(raw);
-        configs.push(config3);
+        const filePath = (0, import_path12.join)(this.baseDir, file2);
+        configs.push(this.readConfig(filePath));
       } catch (err) {
         log8.error(`Failed to read channel config ${file2}:`, err);
       }
@@ -191945,12 +191985,11 @@ var ChannelConfigStore = class {
   }
   /** 获取指定接入配置 */
   async get(connectionId) {
-    const files = (0, import_fs10.readdirSync)(this.baseDir).filter((f) => f.endsWith(".json"));
+    const files = (0, import_fs11.readdirSync)(this.baseDir).filter((f) => f.endsWith(".json"));
     for (const file2 of files) {
-      const filePath = (0, import_path11.join)(this.baseDir, file2);
+      const filePath = (0, import_path12.join)(this.baseDir, file2);
       try {
-        const raw = (0, import_fs10.readFileSync)(filePath, "utf-8");
-        const config3 = JSON.parse(raw);
+        const config3 = this.readConfig(filePath);
         if (config3.connectionId === connectionId) {
           return config3;
         }
@@ -191963,9 +192002,9 @@ var ChannelConfigStore = class {
   /** 保存接入配置 */
   async save(config3) {
     this.ensureDir();
-    const filePath = (0, import_path11.join)(this.baseDir, this.filename(config3));
+    const filePath = (0, import_path12.join)(this.baseDir, this.filename(config3));
     const raw = JSON.stringify(config3, null, 2);
-    (0, import_fs10.writeFileSync)(filePath, raw, "utf-8");
+    (0, import_fs11.writeFileSync)(filePath, raw, "utf-8");
     log8.info(`Saved channel config: ${filePath}`);
   }
   /** 删除接入配置 */
@@ -191975,8 +192014,8 @@ var ChannelConfigStore = class {
       log8.warn(`Channel config not found for deletion: ${connectionId}`);
       return;
     }
-    const filePath = (0, import_path11.join)(this.baseDir, this.filename(config3));
-    (0, import_fs10.unlinkSync)(filePath);
+    const filePath = (0, import_path12.join)(this.baseDir, this.filename(config3));
+    (0, import_fs11.unlinkSync)(filePath);
     log8.info(`Deleted channel config: ${filePath}`);
   }
   /** 获取存储目录路径 */
@@ -192052,8 +192091,8 @@ var DedupeModule = class {
 };
 
 // src/adapters/channel/shared/LocalSecretStore.ts
-var import_fs11 = require("fs");
-var import_path12 = require("path");
+var import_fs12 = require("fs");
+var import_path13 = require("path");
 init_logger();
 init_crypto();
 init_constants();
@@ -192063,9 +192102,9 @@ var LocalSecretStore = class {
   baseDir;
   encryptionKey = null;
   constructor(baseDir) {
-    this.baseDir = baseDir ?? (0, import_path12.join)(config.getAppDataPath(), "channels", "secrets");
-    if (!(0, import_fs11.existsSync)(this.baseDir)) {
-      (0, import_fs11.mkdirSync)(this.baseDir, { recursive: true });
+    this.baseDir = baseDir ?? (0, import_path13.join)(config.getAppDataPath(), "channels", "secrets");
+    if (!(0, import_fs12.existsSync)(this.baseDir)) {
+      (0, import_fs12.mkdirSync)(this.baseDir, { recursive: true });
     }
     this.migrateColonFilenames();
   }
@@ -192075,17 +192114,17 @@ var LocalSecretStore = class {
    */
   migrateColonFilenames() {
     try {
-      const files = (0, import_fs11.readdirSync)(this.baseDir);
+      const files = (0, import_fs12.readdirSync)(this.baseDir);
       for (const file2 of files) {
         const sanitized = sanitizeFilename(file2, { allowUnicode: false });
         if (sanitized !== file2) {
-          const oldPath = (0, import_path12.join)(this.baseDir, file2);
-          const newPath = (0, import_path12.join)(this.baseDir, sanitized);
-          if (!(0, import_fs11.existsSync)(newPath)) {
-            (0, import_fs11.renameSync)(oldPath, newPath);
+          const oldPath = (0, import_path13.join)(this.baseDir, file2);
+          const newPath = (0, import_path13.join)(this.baseDir, sanitized);
+          if (!(0, import_fs12.existsSync)(newPath)) {
+            (0, import_fs12.renameSync)(oldPath, newPath);
             log10.info(`Migrated secret file: ${file2} \u2192 ${sanitized}`);
           } else {
-            (0, import_fs11.unlinkSync)(oldPath);
+            (0, import_fs12.unlinkSync)(oldPath);
             log10.info(`Removed legacy secret file (new exists): ${file2}`);
           }
         }
@@ -192099,13 +192138,13 @@ var LocalSecretStore = class {
    */
   getEncryptionKey() {
     if (this.encryptionKey) return this.encryptionKey;
-    const configDir = (0, import_path12.join)(config.getAppDataPath(), CONFIG.CONFIG_DIR);
-    const saltPath = (0, import_path12.join)(configDir, CONFIG.SALT_FILE);
-    const machineIdPath = (0, import_path12.join)(configDir, CONFIG.MACHINE_ID_FILE);
-    if (!(0, import_fs11.existsSync)(saltPath) || !(0, import_fs11.existsSync)(machineIdPath)) {
+    const configDir = (0, import_path13.join)(config.getAppDataPath(), CONFIG.CONFIG_DIR);
+    const saltPath = (0, import_path13.join)(configDir, CONFIG.SALT_FILE);
+    const machineIdPath = (0, import_path13.join)(configDir, CONFIG.MACHINE_ID_FILE);
+    if (!(0, import_fs12.existsSync)(saltPath) || !(0, import_fs12.existsSync)(machineIdPath)) {
       throw new Error("\u52A0\u5BC6\u57FA\u7840\u8BBE\u65BD\u672A\u521D\u59CB\u5316\uFF1A\u8BF7\u5148\u542F\u52A8\u5E94\u7528\u5B8C\u6210\u914D\u7F6E\u521D\u59CB\u5316");
     }
-    const salt = (0, import_fs11.readFileSync)(saltPath);
+    const salt = (0, import_fs12.readFileSync)(saltPath);
     const machineId = getMachineId(machineIdPath);
     this.encryptionKey = deriveKey(machineId, salt);
     return this.encryptionKey;
@@ -192115,10 +192154,10 @@ var LocalSecretStore = class {
     return sanitizeFilename(key, { allowUnicode: false }) + ".secret";
   }
   async get(key) {
-    const filePath = (0, import_path12.join)(this.baseDir, this.filename(key));
-    if (!(0, import_fs11.existsSync)(filePath)) return null;
+    const filePath = (0, import_path13.join)(this.baseDir, this.filename(key));
+    if (!(0, import_fs12.existsSync)(filePath)) return null;
     try {
-      const raw = (0, import_fs11.readFileSync)(filePath, "utf-8").trim();
+      const raw = (0, import_fs12.readFileSync)(filePath, "utf-8").trim();
       if (!isEncrypted(raw)) {
         log10.error(`Secret file corrupted (no enc: prefix): ${key}`);
         return null;
@@ -192131,14 +192170,14 @@ var LocalSecretStore = class {
   }
   async set(key, value) {
     const encrypted = encrypt(value, this.getEncryptionKey());
-    const filePath = (0, import_path12.join)(this.baseDir, this.filename(key));
-    (0, import_fs11.writeFileSync)(filePath, encrypted, "utf-8");
+    const filePath = (0, import_path13.join)(this.baseDir, this.filename(key));
+    (0, import_fs12.writeFileSync)(filePath, encrypted, "utf-8");
     log10.info(`Secret saved: ${key}`);
   }
   async delete(key) {
-    const filePath = (0, import_path12.join)(this.baseDir, this.filename(key));
-    if ((0, import_fs11.existsSync)(filePath)) {
-      (0, import_fs11.unlinkSync)(filePath);
+    const filePath = (0, import_path13.join)(this.baseDir, this.filename(key));
+    if ((0, import_fs12.existsSync)(filePath)) {
+      (0, import_fs12.unlinkSync)(filePath);
       log10.info(`Secret deleted: ${key}`);
     }
   }
@@ -192320,7 +192359,7 @@ function checkSendFilePolicy(resolvedPath) {
 }
 
 // src/adapters/channel/shared/ChannelManager.ts
-var import_promises13 = require("node:fs/promises");
+var import_promises14 = require("node:fs/promises");
 init_config();
 var log20 = createLogger("ChannelManager");
 var ChannelManager = class {
@@ -192899,12 +192938,12 @@ var ChannelManager = class {
   }
   /** 黑名单校验：拒绝敏感路径，仅允许真实普通文件且不超过附件大小上限 */
   async assertSendableFilePath(filePath) {
-    const resolvedPath = await (0, import_promises13.realpath)(filePath);
+    const resolvedPath = await (0, import_promises14.realpath)(filePath);
     const policyReject = checkSendFilePolicy(resolvedPath);
     if (policyReject) {
       throw new Error(`sendFile blocked: ${policyReject}`);
     }
-    const fileStat = await (0, import_promises13.stat)(resolvedPath);
+    const fileStat = await (0, import_promises14.stat)(resolvedPath);
     if (!fileStat.isFile()) {
       throw new Error(`sendFile path is not a file: ${filePath}`);
     }
@@ -212978,6 +213017,13 @@ function getAutoUpdater() {
   return autoUpdater;
 }
 var AutoUpdaterManager = class {
+  constructor(deps = {
+    electron: getElectron,
+    autoUpdater: getAutoUpdater
+  }) {
+    this.deps = deps;
+  }
+  deps;
   status = "idle";
   updateInfo = null;
   errorMessage = null;
@@ -212985,12 +213031,16 @@ var AutoUpdaterManager = class {
   dailyCheckRunning = false;
   suppressErrorEvents = false;
   suppressRoutineStatusEvents = false;
-  /** 检测到更新时，从 files 列表中提取的 DMG 下载 URL */
-  dmgUrl = null;
+  progress = null;
+  /** macOS 无签名证书时走浏览器手动下载 DMG；Windows/Linux 走 electron-updater。 */
+  manualDownloadUrl = null;
+  initialized = false;
   init() {
-    const { app } = getElectron();
+    if (this.initialized) return;
+    const { app } = this.deps.electron();
     if (!app.isPackaged) return;
-    const autoUpdater = getAutoUpdater();
+    this.initialized = true;
+    const autoUpdater = this.deps.autoUpdater();
     autoUpdater.autoDownload = false;
     autoUpdater.autoRunAppAfterInstall = true;
     autoUpdater.on("checking-for-update", () => {
@@ -212999,21 +213049,26 @@ var AutoUpdaterManager = class {
     autoUpdater.on("update-available", (info) => {
       this.updateInfo = {
         version: info.version,
-        releaseDate: info.releaseDate ?? null
+        releaseDate: info.releaseDate ?? null,
+        manualDownloadUrl: this.resolveManualDownloadUrl(info)
       };
-      const arch = process.arch;
-      const files = info.files;
-      if (files && files.length > 0) {
-        const matched = arch === "arm64" ? files.find((f) => f.url.toLowerCase().endsWith(".dmg") && f.url.toLowerCase().includes("arm64")) : files.find((f) => f.url.toLowerCase().endsWith(".dmg") && !f.url.toLowerCase().includes("arm64"));
-        if (matched) {
-          this.dmgUrl = `${PUBLISH_BASE_URL}/${matched.url}`;
-        }
-      }
+      this.manualDownloadUrl = this.updateInfo.manualDownloadUrl ?? null;
       this.updateState("available");
-      eventBridge.broadcast(IPC_UPDATE_AVAILABLE_EVENT, {
-        ...this.updateInfo,
-        dmgUrl: this.dmgUrl
-      });
+      eventBridge.broadcast(IPC_UPDATE_AVAILABLE_EVENT, this.updateInfo);
+    });
+    autoUpdater.on("download-progress", (progress) => {
+      this.progress = {
+        percent: progress.percent,
+        bytesPerSecond: progress.bytesPerSecond,
+        transferred: progress.transferred,
+        total: progress.total
+      };
+      this.updateState("downloading");
+      eventBridge.broadcast(IPC_UPDATE_PROGRESS_EVENT, this.progress);
+    });
+    autoUpdater.on("update-downloaded", () => {
+      this.updateState("downloaded");
+      eventBridge.broadcast(IPC_UPDATE_DOWNLOADED_EVENT);
     });
     autoUpdater.on("update-not-available", () => {
       this.updateState("not-available");
@@ -213029,7 +213084,7 @@ var AutoUpdaterManager = class {
   /** 用户每日首次发送消息后静默检查（延迟 3s） */
   triggerDailyAutoCheck() {
     if (process.env.KAI_RUNTIME === "cli") return;
-    const { app } = getElectron();
+    const { app } = this.deps.electron();
     if (!app.isPackaged) return;
     const enabled = config.get("autoCheckForUpdates");
     if (enabled === false) return;
@@ -213054,15 +213109,16 @@ var AutoUpdaterManager = class {
     }
   }
   async checkForUpdate(options2 = {}) {
-    const { app } = getElectron();
+    const { app } = this.deps.electron();
     if (!app.isPackaged) {
       this.updateState("not-available");
       return;
     }
     this.updateInfo = null;
     this.errorMessage = null;
-    this.dmgUrl = null;
-    const autoUpdater = getAutoUpdater();
+    this.progress = null;
+    this.manualDownloadUrl = null;
+    const autoUpdater = this.deps.autoUpdater();
     const silent = options2.silent === true;
     const previousSuppressErrorEvents = this.suppressErrorEvents;
     const previousSuppressRoutineStatusEvents = this.suppressRoutineStatusEvents;
@@ -213085,30 +213141,39 @@ var AutoUpdaterManager = class {
     }
   }
   /**
-   * 打开 DMG 下载链接（浏览器）
+   * macOS 打开 DMG 下载链接；Windows/Linux 使用 electron-updater 标准下载。
    *
    * 没有开发者证书时，electron-updater 的 zip + ShipIt 路线走不通（签名验证失败）。
    * 改为直接在浏览器下载 DMG，用户手动安装。
    */
   async downloadUpdate() {
-    const url2 = this.dmgUrl;
+    if (process.platform !== "darwin") {
+      await this.deps.autoUpdater().downloadUpdate();
+      return;
+    }
+    const url2 = this.manualDownloadUrl;
     if (!url2) {
       this.errorMessage = "\u672A\u627E\u5230\u4E0B\u8F7D\u94FE\u63A5";
       this.updateState("error");
       eventBridge.broadcast(IPC_UPDATE_ERROR_EVENT, { message: this.errorMessage });
       return;
     }
-    await getElectron().shell.openExternal(url2);
+    await this.deps.electron().shell.openExternal(url2);
   }
-  /** DMG 模式下不可用，保留接口兼容 */
+  /** macOS 手动 DMG 模式下不可用，保留接口兼容 */
   quitAndInstall() {
+    if (process.platform !== "darwin") {
+      this.deps.autoUpdater().quitAndInstall(false, true);
+      return;
+    }
     const message = "\u8BF7\u624B\u52A8\u5B89\u88C5\u4E0B\u8F7D\u7684 DMG \u6587\u4EF6";
     eventBridge.broadcast(IPC_UPDATE_ERROR_EVENT, { message });
   }
   getStatus() {
     return {
       status: this.status,
-      info: this.updateInfo ? { ...this.updateInfo, dmgUrl: this.dmgUrl } : null,
+      info: this.updateInfo,
+      progress: this.progress,
       errorMessage: this.errorMessage
     };
   }
@@ -213117,7 +213182,17 @@ var AutoUpdaterManager = class {
     if (this.suppressRoutineStatusEvents && s !== "available") return;
     eventBridge.broadcast(IPC_UPDATE_STATUS_EVENT, s);
   }
+  resolveManualDownloadUrl(info) {
+    if (process.platform !== "darwin") return null;
+    const files = info.files ?? [];
+    const arch = process.arch;
+    const matched = arch === "arm64" ? files.find((file2) => isDmg(file2.url) && file2.url.toLowerCase().includes("arm64")) : files.find((file2) => isDmg(file2.url) && !file2.url.toLowerCase().includes("arm64"));
+    return matched ? new URL(encodeURI(matched.url), `${PUBLISH_BASE_URL}/`).toString() : null;
+  }
 };
+function isDmg(url2) {
+  return url2.toLowerCase().endsWith(".dmg");
+}
 function getLocalDateString(date5 = /* @__PURE__ */ new Date()) {
   const year = date5.getFullYear();
   const month = String(date5.getMonth() + 1).padStart(2, "0");
@@ -213363,7 +213438,7 @@ function registerChatHandlers() {
 }
 
 // src/electron/main/handlers/conversation-handlers.ts
-var import_promises15 = require("fs/promises");
+var import_promises16 = require("fs/promises");
 init_conversation_event_bus();
 init_message2();
 init_agent_file_store();
@@ -213380,8 +213455,8 @@ init_ThreadManagerPool();
 init_logger();
 
 // src/electron/main/handlers/avatar-storage.ts
-var import_promises14 = require("fs/promises");
-var import_path18 = require("path");
+var import_promises15 = require("fs/promises");
+var import_path19 = require("path");
 var import_sharp = __toESM(require("sharp"));
 var AVATAR_DIR = "avatars";
 var AVATAR_FILE = "avatar.png";
@@ -213391,12 +213466,12 @@ var AVATAR_SIZE = 256;
 async function writeOwnerAvatar(ownerDir, sourcePath) {
   const source = sourcePath.trim();
   if (!source) throw new Error("AVATAR_SOURCE_REQUIRED");
-  const sourceStats = await (0, import_promises14.stat)(source).catch(() => null);
+  const sourceStats = await (0, import_promises15.stat)(source).catch(() => null);
   if (!sourceStats?.isFile()) throw new Error("AVATAR_SOURCE_NOT_FILE");
   if (sourceStats.size > MAX_AVATAR_SOURCE_BYTES) throw new Error("AVATAR_IMAGE_TOO_LARGE");
-  const avatarDir = (0, import_path18.join)(ownerDir, AVATAR_DIR);
-  const avatarPath = (0, import_path18.join)(avatarDir, AVATAR_FILE);
-  await (0, import_promises14.mkdir)(avatarDir, { recursive: true });
+  const avatarDir = (0, import_path19.join)(ownerDir, AVATAR_DIR);
+  const avatarPath = (0, import_path19.join)(avatarDir, AVATAR_FILE);
+  await (0, import_promises15.mkdir)(avatarDir, { recursive: true });
   try {
     await (0, import_sharp.default)(source, { failOn: "error" }).rotate().resize(AVATAR_SIZE, AVATAR_SIZE, { fit: "cover", position: "centre" }).png().toFile(avatarPath);
   } catch (error48) {
@@ -213408,7 +213483,7 @@ async function writeOwnerAvatar(ownerDir, sourcePath) {
   return AVATAR_RELATIVE_PATH;
 }
 async function removeOwnerAvatar(ownerDir) {
-  await (0, import_promises14.rm)((0, import_path18.join)(ownerDir, AVATAR_DIR), { force: true, recursive: true }).catch(() => void 0);
+  await (0, import_promises15.rm)((0, import_path19.join)(ownerDir, AVATAR_DIR), { force: true, recursive: true }).catch(() => void 0);
 }
 
 // src/electron/main/handlers/conversation-handlers.ts
@@ -213675,7 +213750,7 @@ async function handleOpenAttachment(relativePath) {
   await shell2.openPath(absolutePath);
 }
 async function openDir(dir) {
-  await (0, import_promises15.mkdir)(dir, { recursive: true });
+  await (0, import_promises16.mkdir)(dir, { recursive: true });
   const { shell: shell2 } = require("electron");
   const error48 = await shell2.openPath(dir);
   if (error48) throw new Error(error48);
@@ -214513,7 +214588,7 @@ function registerSearchHandlers() {
 }
 
 // src/electron/main/handlers/url-handlers.ts
-var import_promises16 = __toESM(require("node:fs/promises"));
+var import_promises17 = __toESM(require("node:fs/promises"));
 var import_node_path4 = __toESM(require("node:path"));
 init_ipc_events();
 init_config();
@@ -214620,7 +214695,7 @@ async function handleOpenExternalUrl(url2) {
 }
 async function handleOpenLocalPath(inputPath) {
   const resolvedPath = resolveLocalPath(inputPath);
-  const stats = await import_promises16.default.stat(resolvedPath).catch(() => null);
+  const stats = await import_promises17.default.stat(resolvedPath).catch(() => null);
   if (!stats?.isFile()) {
     throw new Error("ERROR_LOCAL_PATH_NOT_FILE");
   }
@@ -214630,7 +214705,7 @@ async function handleOpenLocalPath(inputPath) {
 }
 async function handleReadFileContent(inputPath) {
   const resolvedPath = resolveLocalPath(inputPath);
-  const stats = await import_promises16.default.stat(resolvedPath).catch(() => null);
+  const stats = await import_promises17.default.stat(resolvedPath).catch(() => null);
   if (!stats?.isFile()) {
     throw new Error("ERROR_LOCAL_PATH_NOT_FILE");
   }
@@ -214644,7 +214719,7 @@ async function handleReadFileContent(inputPath) {
       mimeType
     };
   }
-  const buffer = await import_promises16.default.readFile(resolvedPath);
+  const buffer = await import_promises17.default.readFile(resolvedPath);
   const isText2 = !isBufferBinary(buffer);
   const content = isText2 ? buffer.toString("utf-8") : "";
   return {
@@ -214661,7 +214736,7 @@ async function handleShowLocalItemInFolder(localUrlOrPath) {
 }
 async function handleCopyImageToClipboard(localUrlOrPath) {
   const resolvedPath = localUrlOrPath.startsWith("kai://local/") ? resolveKaiLocalPath(localUrlOrPath) : resolveLocalPath(localUrlOrPath);
-  const stats = await import_promises16.default.stat(resolvedPath).catch(() => null);
+  const stats = await import_promises17.default.stat(resolvedPath).catch(() => null);
   if (!stats?.isFile()) {
     throw new Error("ERROR_LOCAL_PATH_NOT_FILE");
   }
@@ -215172,7 +215247,7 @@ function setupHealthIPC() {
 
 // src/electron/main/handlers/app-info-handlers.ts
 init_ipc_events();
-var import_promises17 = __toESM(require("node:fs/promises"));
+var import_promises18 = __toESM(require("node:fs/promises"));
 var import_node_path5 = __toESM(require("node:path"));
 function getReleaseNotesPath() {
   const { app } = require("electron");
@@ -215191,7 +215266,7 @@ async function handleGetAppInfo() {
 }
 async function handleGetReleaseNotes() {
   try {
-    return await import_promises17.default.readFile(getReleaseNotesPath(), "utf-8");
+    return await import_promises18.default.readFile(getReleaseNotesPath(), "utf-8");
   } catch {
     return "";
   }
@@ -215209,12 +215284,12 @@ init_config();
 
 // src/adapters/transport/http-server.ts
 var import_node_http = __toESM(require("node:http"));
-var import_promises18 = __toESM(require("node:fs/promises"));
+var import_promises19 = __toESM(require("node:fs/promises"));
 var import_node_path6 = __toESM(require("node:path"));
 var import_node_os2 = __toESM(require("node:os"));
 var import_node_zlib = __toESM(require("node:zlib"));
 var import_node_fs = require("node:fs");
-var import_promises19 = require("node:stream/promises");
+var import_promises20 = require("node:stream/promises");
 
 // node_modules/ws/wrapper.mjs
 var import_stream5 = __toESM(require_stream(), 1);
@@ -215423,7 +215498,7 @@ function getCacheControl2(filePath) {
 }
 async function fileExists(filePath) {
   try {
-    const stat5 = await import_promises18.default.stat(filePath);
+    const stat5 = await import_promises19.default.stat(filePath);
     return stat5.isFile();
   } catch {
     return false;
@@ -215453,7 +215528,7 @@ async function sendStaticAsset(filePath, response, requestHeaders) {
   }
   response.writeHead(200, headers);
   try {
-    await (0, import_promises19.pipeline)((0, import_node_fs.createReadStream)(actualPath), response);
+    await (0, import_promises20.pipeline)((0, import_node_fs.createReadStream)(actualPath), response);
   } catch (error48) {
     if (!response.headersSent) {
       response.writeHead(500);
@@ -215474,7 +215549,7 @@ async function serveStaticFile(urlPath, response, requestHeaders) {
     return;
   }
   try {
-    const stat5 = await import_promises18.default.stat(resolvedPath);
+    const stat5 = await import_promises19.default.stat(resolvedPath);
     const filePath = stat5.isDirectory() ? import_node_path6.default.join(resolvedPath, "index.html") : resolvedPath;
     if (!await fileExists(filePath)) throw new Error("Not a file");
     await sendStaticAsset(filePath, response, requestHeaders);
@@ -215660,7 +215735,7 @@ var HttpTransportServer = class {
       return;
     }
     try {
-      await import_promises18.default.stat(resolvedPath);
+      await import_promises19.default.stat(resolvedPath);
       const ext = import_node_path6.default.extname(resolvedPath).toLowerCase();
       const mimeType = getMimeType(ext);
       const headers = { "Content-Type": mimeType };
@@ -216100,14 +216175,14 @@ function registerUpdateHandlers() {
 }
 
 // src/adapters/storage/PinnedStore.ts
-var import_path19 = require("path");
-var import_promises20 = require("fs/promises");
-var import_fs12 = require("fs");
+var import_path20 = require("path");
+var import_promises21 = require("fs/promises");
+var import_fs13 = require("fs");
 init_config();
 var FILE_NAME = "pinned.json";
 var SCHEMA_VERSION4 = 1;
 function getPinnedPath() {
-  return (0, import_path19.join)(config.getAppDataPath(), "config", FILE_NAME);
+  return (0, import_path20.join)(config.getAppDataPath(), "config", FILE_NAME);
 }
 function createDefaultPinnedFile() {
   return { version: SCHEMA_VERSION4, agents: {}, groups: {} };
@@ -216141,18 +216216,18 @@ function clonePinnedFile(data2) {
     groups: { ...data2.groups }
   };
 }
-async function atomicWriteJson4(path10, data2) {
-  const dir = (0, import_path19.dirname)(path10);
-  await (0, import_promises20.mkdir)(dir, { recursive: true });
+async function atomicWriteJson2(path10, data2) {
+  const dir = (0, import_path20.dirname)(path10);
+  await (0, import_promises21.mkdir)(dir, { recursive: true });
   const tmp = `${path10}.tmp`;
-  await (0, import_promises20.writeFile)(tmp, `${JSON.stringify(data2, null, 2)}
+  await (0, import_promises21.writeFile)(tmp, `${JSON.stringify(data2, null, 2)}
 `, "utf-8");
-  await (0, import_promises20.rename)(tmp, path10);
+  await (0, import_promises21.rename)(tmp, path10);
 }
-async function readJsonFile5(path10) {
-  if (!(0, import_fs12.existsSync)(path10)) return null;
+async function readJsonFile4(path10) {
+  if (!(0, import_fs13.existsSync)(path10)) return null;
   try {
-    const raw = await (0, import_promises20.readFile)(path10, "utf-8");
+    const raw = await (0, import_promises21.readFile)(path10, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -216162,13 +216237,13 @@ var PinnedStore = class {
   cache = null;
   async load() {
     if (this.cache) return this.cache;
-    const raw = await readJsonFile5(getPinnedPath());
+    const raw = await readJsonFile4(getPinnedPath());
     this.cache = normalizePinnedFile(raw);
     return this.cache;
   }
   async flush() {
     if (!this.cache) return;
-    await atomicWriteJson4(getPinnedPath(), this.cache);
+    await atomicWriteJson2(getPinnedPath(), this.cache);
   }
   async getAll() {
     const data2 = await this.load();
@@ -216300,6 +216375,7 @@ function registerChannelHandlers() {
       botId,
       secretRef: `channel:${connectionId}:secret`,
       target,
+      createdAt: Date.now(),
       ...baseUrl ? { baseUrl } : {}
     };
     await channelManager.register(config3, secret);
@@ -216414,9 +216490,9 @@ function registerHandlers() {
 }
 
 // src/adapters/db/migration/kai-migration.ts
-var import_path22 = require("path");
-var import_fs15 = require("fs");
-var import_promises23 = require("fs/promises");
+var import_path23 = require("path");
+var import_fs16 = require("fs");
+var import_promises24 = require("fs/promises");
 var import_lt2 = __toESM(require_lt());
 init_lib();
 init_agent_file_store();
@@ -216443,12 +216519,12 @@ function getKaiRootDir() {
   return config.getAppDataPath();
 }
 function getKaiConfigPath() {
-  return (0, import_path22.join)(getKaiRootDir(), KAI_CONFIG_FILE);
+  return (0, import_path23.join)(getKaiRootDir(), KAI_CONFIG_FILE);
 }
 function ensureKaiRootDir() {
   const root2 = getKaiRootDir();
-  if (!(0, import_fs15.existsSync)(root2)) {
-    (0, import_fs15.mkdirSync)(root2, { recursive: true });
+  if (!(0, import_fs16.existsSync)(root2)) {
+    (0, import_fs16.mkdirSync)(root2, { recursive: true });
   }
 }
 function isVersionLessThan(current, target) {
@@ -216456,9 +216532,9 @@ function isVersionLessThan(current, target) {
 }
 function readKaiDataFile() {
   const path10 = getKaiConfigPath();
-  if (!(0, import_fs15.existsSync)(path10)) return null;
+  if (!(0, import_fs16.existsSync)(path10)) return null;
   try {
-    return JSON.parse((0, import_fs15.readFileSync)(path10, "utf-8"));
+    return JSON.parse((0, import_fs16.readFileSync)(path10, "utf-8"));
   } catch (error48) {
     logger35.error("Failed to read kai.json:", error48);
     return null;
@@ -216468,9 +216544,9 @@ async function writeKaiDataFile(version3) {
   ensureKaiRootDir();
   const path10 = getKaiConfigPath();
   const tmp = `${path10}.tmp`;
-  await (0, import_promises23.writeFile)(tmp, `${JSON.stringify({ version: version3 }, null, 2)}
+  await (0, import_promises24.writeFile)(tmp, `${JSON.stringify({ version: version3 }, null, 2)}
 `, "utf-8");
-  await (0, import_promises23.rename)(tmp, path10);
+  await (0, import_promises24.rename)(tmp, path10);
 }
 function currentVersion() {
   return readKaiDataFile()?.version ?? "0.0.0";
@@ -216647,18 +216723,18 @@ async function migrateConversationIds() {
     });
     await sequelize.query("PRAGMA foreign_keys = ON");
   }
-  const conversationsDir = (0, import_path22.resolve)(config.getAppDataPath(), "conversations");
-  if ((0, import_fs15.existsSync)(conversationsDir)) {
+  const conversationsDir = (0, import_path23.resolve)(config.getAppDataPath(), "conversations");
+  if ((0, import_fs16.existsSync)(conversationsDir)) {
     try {
-      const entries = (0, import_fs15.readdirSync)(conversationsDir, { withFileTypes: true });
+      const entries = (0, import_fs16.readdirSync)(conversationsDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const oldDir = (0, import_path22.join)(conversationsDir, entry.name);
+        const oldDir = (0, import_path23.join)(conversationsDir, entry.name);
         const targetId = idMap.get(entry.name);
         if (targetId) {
-          const newDir = (0, import_path22.join)(conversationsDir, targetId);
-          if (!(0, import_fs15.existsSync)(newDir)) {
-            (0, import_fs15.renameSync)(oldDir, newDir);
+          const newDir = (0, import_path23.join)(conversationsDir, targetId);
+          if (!(0, import_fs16.existsSync)(newDir)) {
+            (0, import_fs16.renameSync)(oldDir, newDir);
             logger35.debug(`Renamed dir ${entry.name} \u2192 ${targetId}`);
           } else {
             logger35.debug(
@@ -216906,7 +216982,7 @@ init_normalize_tool_schema();
 var import_child_process3 = require("child_process");
 init_dist6();
 init_zod();
-var import_path23 = require("path");
+var import_path24 = require("path");
 init_workspace();
 
 // node_modules/shell-env/index.js
@@ -217061,7 +217137,7 @@ function createShellTool(agentId) {
           };
           if (workdir) {
             const baseDir = agentId ? getAgentWorkspaceDir(agentId) : process.cwd();
-            options2.cwd = (0, import_path23.isAbsolute)(workdir) ? workdir : (0, import_path23.resolve)(baseDir, workdir);
+            options2.cwd = (0, import_path24.isAbsolute)(workdir) ? workdir : (0, import_path24.resolve)(baseDir, workdir);
           } else if (agentId) {
             options2.cwd = getAgentWorkspaceDir(agentId);
           }
@@ -217186,11 +217262,11 @@ function spawnWithAbort(shell2, command, options2, timeoutMs, abortSignal) {
 // src/adapters/tools/filesystem/read-file.ts
 init_dist6();
 init_zod();
-var import_promises24 = require("fs/promises");
-var import_fs16 = require("fs");
+var import_promises25 = require("fs/promises");
+var import_fs17 = require("fs");
 
 // src/adapters/tools/filesystem/resolve-file-path.ts
-var import_path24 = require("path");
+var import_path25 = require("path");
 init_workspace();
 init_group_file_store();
 var GROUP_PROTECTED_JSON_FILES = /* @__PURE__ */ new Set([
@@ -217199,34 +217275,34 @@ var GROUP_PROTECTED_JSON_FILES = /* @__PURE__ */ new Set([
   "members.json"
 ]);
 function containsPathTraversal(p) {
-  return (0, import_path24.normalize)(p).split(/[/\\]+/).some((part) => part === "..");
+  return (0, import_path25.normalize)(p).split(/[/\\]+/).some((part) => part === "..");
 }
 function isWithinBase(resolvedPath, baseDir) {
-  const rel = (0, import_path24.relative)(baseDir, resolvedPath);
-  return !rel.startsWith("..") && !(0, import_path24.isAbsolute)(rel);
+  const rel = (0, import_path25.relative)(baseDir, resolvedPath);
+  return !rel.startsWith("..") && !(0, import_path25.isAbsolute)(rel);
 }
 function isGroupProtectedFile(resolvedPath, groupDir) {
-  if (!isWithinBase((0, import_path24.normalize)(resolvedPath), (0, import_path24.normalize)(groupDir))) {
+  if (!isWithinBase((0, import_path25.normalize)(resolvedPath), (0, import_path25.normalize)(groupDir))) {
     return false;
   }
-  const name21 = (0, import_path24.basename)(resolvedPath);
+  const name21 = (0, import_path25.basename)(resolvedPath);
   return name21.endsWith(".json") && GROUP_PROTECTED_JSON_FILES.has(name21);
 }
 function resolveToolFilePath(workdir, filePath) {
-  if (!workdir || !(0, import_path24.isAbsolute)(workdir)) {
+  if (!workdir || !(0, import_path25.isAbsolute)(workdir)) {
     throw new Error("workdir is required and must be an absolute path");
   }
   if (!filePath) {
     throw new Error("path is required and must be relative to workdir");
   }
-  if ((0, import_path24.isAbsolute)(filePath)) {
+  if ((0, import_path25.isAbsolute)(filePath)) {
     throw new Error("path must be relative to workdir, not absolute");
   }
   if (containsPathTraversal(filePath)) {
     throw new Error(`Path traversal not allowed: ${filePath}`);
   }
-  const normalizedWorkdir = (0, import_path24.normalize)(workdir);
-  const resolvedPath = (0, import_path24.resolve)(normalizedWorkdir, filePath);
+  const normalizedWorkdir = (0, import_path25.normalize)(workdir);
+  const resolvedPath = (0, import_path25.resolve)(normalizedWorkdir, filePath);
   if (!isWithinBase(resolvedPath, normalizedWorkdir)) {
     throw new Error(`Path escapes workdir: ${filePath}`);
   }
@@ -217303,13 +217379,13 @@ function createReadFileTool(_scope = {}, tracker) {
         if (abortSignal?.aborted) throw new DOMException("The operation was aborted", "AbortError");
         try {
           const resolvedPath = resolveToolFilePath(workdir, filePath);
-          if (!(0, import_fs16.existsSync)(resolvedPath)) {
+          if (!(0, import_fs17.existsSync)(resolvedPath)) {
             return { error: `Path does not exist: ${filePath}`, content: "" };
           }
-          const fileStat = await (0, import_promises24.stat)(resolvedPath);
+          const fileStat = await (0, import_promises25.stat)(resolvedPath);
           if (fileStat.isDirectory()) {
             tracker?.markKnown(resolvedPath);
-            const entries = await (0, import_promises24.readdir)(resolvedPath, { withFileTypes: true });
+            const entries = await (0, import_promises25.readdir)(resolvedPath, { withFileTypes: true });
             const lines = entries.sort((a, b) => {
               if (a.isDirectory() && !b.isDirectory()) return -1;
               if (!a.isDirectory() && b.isDirectory()) return 1;
@@ -217332,7 +217408,7 @@ function createReadFileTool(_scope = {}, tracker) {
               content: ""
             };
           }
-          const content = await (0, import_promises24.readFile)(resolvedPath, "utf-8");
+          const content = await (0, import_promises25.readFile)(resolvedPath, "utf-8");
           const allLines = content.split("\n");
           if (allLines.length > 0 && allLines[allLines.length - 1] === "") {
             allLines.pop();
@@ -217366,9 +217442,9 @@ function createReadFileTool(_scope = {}, tracker) {
 // src/adapters/tools/filesystem/write-file.ts
 init_dist6();
 init_zod();
-var import_promises25 = require("fs/promises");
-var import_path25 = require("path");
-var import_fs17 = require("fs");
+var import_promises26 = require("fs/promises");
+var import_path26 = require("path");
+var import_fs18 = require("fs");
 init_group_file_store();
 
 // node_modules/diff/libesm/diff/base.js
@@ -218163,7 +218239,7 @@ function createWriteFileTool(scope = {}, tracker) {
               };
             }
           }
-          const isNewFile = !(0, import_fs17.existsSync)(resolvedPath);
+          const isNewFile = !(0, import_fs18.existsSync)(resolvedPath);
           if (mode === "overwrite" && !isNewFile && tracker && !tracker.isKnown(resolvedPath)) {
             return {
               success: false,
@@ -218173,17 +218249,17 @@ function createWriteFileTool(scope = {}, tracker) {
           let oldContent = "";
           if (!isNewFile) {
             try {
-              oldContent = await (0, import_promises25.readFile)(resolvedPath, "utf-8");
+              oldContent = await (0, import_promises26.readFile)(resolvedPath, "utf-8");
             } catch {
             }
           }
           const nextContent = mode === "append" ? oldContent + content : content;
           const diff = createUnifiedFileDiff(filePath, oldContent, nextContent);
-          await (0, import_promises25.mkdir)((0, import_path25.dirname)(resolvedPath), { recursive: true });
+          await (0, import_promises26.mkdir)((0, import_path26.dirname)(resolvedPath), { recursive: true });
           if (mode === "append") {
-            await (0, import_promises25.appendFile)(resolvedPath, content, "utf-8");
+            await (0, import_promises26.appendFile)(resolvedPath, content, "utf-8");
           } else {
-            await (0, import_promises25.writeFile)(resolvedPath, content, "utf-8");
+            await (0, import_promises26.writeFile)(resolvedPath, content, "utf-8");
           }
           if (isNewFile) {
             tracker?.markKnown(resolvedPath);
@@ -218210,8 +218286,8 @@ function createWriteFileTool(scope = {}, tracker) {
 // src/adapters/tools/filesystem/edit-file.ts
 init_dist6();
 init_zod();
-var import_promises26 = require("fs/promises");
-var import_fs18 = require("fs");
+var import_promises27 = require("fs/promises");
+var import_fs19 = require("fs");
 init_group_file_store();
 function createEditFileTool(scope = {}, tracker) {
   return {
@@ -218239,14 +218315,14 @@ function createEditFileTool(scope = {}, tracker) {
               };
             }
           }
-          if (!(0, import_fs18.existsSync)(resolvedPath)) {
+          if (!(0, import_fs19.existsSync)(resolvedPath)) {
             return { success: false, error: `File does not exist: ${filePath}` };
           }
           const accessError = tracker?.assertKnownForMutation(resolvedPath, "edit", "editFile", filePath);
           if (accessError) {
             return { success: false, error: accessError };
           }
-          const content = await (0, import_promises26.readFile)(resolvedPath, "utf-8");
+          const content = await (0, import_promises27.readFile)(resolvedPath, "utf-8");
           const matchCount = content.split(oldString).length - 1;
           if (matchCount === 0) {
             return { success: false, error: "oldString not found in file" };
@@ -218259,7 +218335,7 @@ function createEditFileTool(scope = {}, tracker) {
           }
           const updatedContent = replaceAll ? content.split(oldString).join(newString) : content.replace(oldString, newString);
           const diff = createUnifiedFileDiff(filePath, content, updatedContent);
-          await (0, import_promises26.writeFile)(resolvedPath, updatedContent, "utf-8");
+          await (0, import_promises27.writeFile)(resolvedPath, updatedContent, "utf-8");
           tracker?.markKnown(resolvedPath);
           return {
             success: true,
@@ -218281,42 +218357,42 @@ function createEditFileTool(scope = {}, tracker) {
 // src/adapters/tools/filesystem/apply-patch.ts
 init_dist6();
 init_zod();
-var import_promises27 = require("fs/promises");
-var import_fs19 = require("fs");
-var import_path26 = require("path");
+var import_promises28 = require("fs/promises");
+var import_fs20 = require("fs");
+var import_path27 = require("path");
 init_group_file_store();
 function containsPathTraversal2(p) {
-  return (0, import_path26.normalize)(p).split(/[/\\]+/).some((part) => part === "..");
+  return (0, import_path27.normalize)(p).split(/[/\\]+/).some((part) => part === "..");
 }
 function isWithinBase2(resolvedPath, baseDir) {
-  const rel = (0, import_path26.relative)(baseDir, resolvedPath);
-  return !rel.startsWith("..") && !(0, import_path26.isAbsolute)(rel);
+  const rel = (0, import_path27.relative)(baseDir, resolvedPath);
+  return !rel.startsWith("..") && !(0, import_path27.isAbsolute)(rel);
 }
 function resolvePatchWorkdir(workdir) {
   if (typeof workdir !== "string" || workdir.length === 0) {
     throw new Error("patch workdir is required and must be an absolute path");
   }
-  if (!(0, import_path26.isAbsolute)(workdir)) {
+  if (!(0, import_path27.isAbsolute)(workdir)) {
     throw new Error("patch workdir must be an absolute path");
   }
-  return (0, import_path26.normalize)(workdir);
+  return (0, import_path27.normalize)(workdir);
 }
 function resolvePatchPath(filePath, workdir) {
-  if ((0, import_path26.isAbsolute)(filePath)) {
+  if ((0, import_path27.isAbsolute)(filePath)) {
     throw new Error(`Patch file paths must be relative to workdir; pass workdir instead of absolute paths: ${filePath}`);
   }
   if (containsPathTraversal2(filePath)) {
     throw new Error(`Path traversal not allowed in patch file path: ${filePath}`);
   }
-  const resolved = (0, import_path26.resolve)(workdir, filePath);
+  const resolved = (0, import_path27.resolve)(workdir, filePath);
   if (!isWithinBase2(resolved, workdir)) {
     throw new Error(`Patch file path escapes workdir: ${filePath}`);
   }
   return resolved;
 }
 function getPatchMutationAccessError(filePatch, resolvedPath, displayPath, tracker) {
-  if (filePatch.action === "add" && !(0, import_fs19.existsSync)(resolvedPath)) return null;
-  if (filePatch.action !== "add" && !(0, import_fs19.existsSync)(resolvedPath)) return null;
+  if (filePatch.action === "add" && !(0, import_fs20.existsSync)(resolvedPath)) return null;
+  if (filePatch.action !== "add" && !(0, import_fs20.existsSync)(resolvedPath)) return null;
   if (filePatch.action === "add") {
     return tracker.assertKnownForMutation(resolvedPath, "replace", "applyPatch", displayPath);
   }
@@ -218488,7 +218564,7 @@ function createApplyPatchTool(scope = {}, tracker) {
           try {
             switch (filePatch.action) {
               case "add": {
-                if ((0, import_fs19.existsSync)(resolvedPath)) {
+                if ((0, import_fs20.existsSync)(resolvedPath)) {
                   results.push({
                     action: "add",
                     path: filePatch.path,
@@ -218498,8 +218574,8 @@ function createApplyPatchTool(scope = {}, tracker) {
                   continue;
                 }
                 const content = (filePatch.content || "").replace(/\n$/, "");
-                await (0, import_promises27.mkdir)((0, import_path26.dirname)(resolvedPath), { recursive: true });
-                await (0, import_promises27.writeFile)(resolvedPath, content, "utf-8");
+                await (0, import_promises28.mkdir)((0, import_path27.dirname)(resolvedPath), { recursive: true });
+                await (0, import_promises28.writeFile)(resolvedPath, content, "utf-8");
                 tracker?.markKnown(resolvedPath);
                 results.push({
                   action: "add",
@@ -218509,7 +218585,7 @@ function createApplyPatchTool(scope = {}, tracker) {
                 break;
               }
               case "update": {
-                if (!(0, import_fs19.existsSync)(resolvedPath)) {
+                if (!(0, import_fs20.existsSync)(resolvedPath)) {
                   results.push({
                     action: "update",
                     path: filePatch.path,
@@ -218518,7 +218594,7 @@ function createApplyPatchTool(scope = {}, tracker) {
                   });
                   continue;
                 }
-                const oldContent = await (0, import_promises27.readFile)(resolvedPath, "utf-8");
+                const oldContent = await (0, import_promises28.readFile)(resolvedPath, "utf-8");
                 let newContent;
                 if (filePatch.hunks && filePatch.hunks.length > 0) {
                   const { result, error: error48 } = applyHunks(oldContent, filePatch.path, filePatch.hunks);
@@ -218558,14 +218634,14 @@ function createApplyPatchTool(scope = {}, tracker) {
                       continue;
                     }
                   }
-                  await (0, import_promises27.mkdir)((0, import_path26.dirname)(newResolvedPath), { recursive: true });
+                  await (0, import_promises28.mkdir)((0, import_path27.dirname)(newResolvedPath), { recursive: true });
                   const moveTargetError = tracker?.assertKnownForMutation(
                     newResolvedPath,
                     "overwrite rename target",
                     "applyPatch",
                     filePatch.moveTo
                   );
-                  if ((0, import_fs19.existsSync)(newResolvedPath) && moveTargetError) {
+                  if ((0, import_fs20.existsSync)(newResolvedPath) && moveTargetError) {
                     results.push({
                       action: "rename",
                       path: `${filePatch.path} \u2192 ${filePatch.moveTo}`,
@@ -218574,8 +218650,8 @@ function createApplyPatchTool(scope = {}, tracker) {
                     });
                     continue;
                   }
-                  await (0, import_promises27.writeFile)(newResolvedPath, newContent, "utf-8");
-                  await (0, import_promises27.unlink)(resolvedPath);
+                  await (0, import_promises28.writeFile)(newResolvedPath, newContent, "utf-8");
+                  await (0, import_promises28.unlink)(resolvedPath);
                   tracker?.markKnown(newResolvedPath);
                   const diff = createUnifiedFileDiff(filePatch.path, oldContent, newContent);
                   results.push({
@@ -218586,7 +218662,7 @@ function createApplyPatchTool(scope = {}, tracker) {
                   });
                 } else {
                   const diff = createUnifiedFileDiff(filePatch.path, oldContent, newContent);
-                  await (0, import_promises27.writeFile)(resolvedPath, newContent, "utf-8");
+                  await (0, import_promises28.writeFile)(resolvedPath, newContent, "utf-8");
                   tracker?.markKnown(resolvedPath);
                   results.push({
                     action: "update",
@@ -218598,7 +218674,7 @@ function createApplyPatchTool(scope = {}, tracker) {
                 break;
               }
               case "delete": {
-                if (!(0, import_fs19.existsSync)(resolvedPath)) {
+                if (!(0, import_fs20.existsSync)(resolvedPath)) {
                   results.push({
                     action: "delete",
                     path: filePatch.path,
@@ -218607,7 +218683,7 @@ function createApplyPatchTool(scope = {}, tracker) {
                   });
                   continue;
                 }
-                await (0, import_promises27.unlink)(resolvedPath);
+                await (0, import_promises28.unlink)(resolvedPath);
                 results.push({
                   action: "delete",
                   path: filePatch.path,
@@ -233315,12 +233391,12 @@ function createWebSearchTool(executor) {
 }
 
 // src/electron/main/utils/icon.ts
-var import_path27 = require("path");
+var import_path28 = require("path");
 function getIconPath() {
   if (process.env.NODE_ENV === "development") {
-    return (0, import_path27.join)(__dirname, "../../resources/icon.png");
+    return (0, import_path28.join)(__dirname, "../../resources/icon.png");
   }
-  return (0, import_path27.join)(process.resourcesPath, "icon.png");
+  return (0, import_path28.join)(process.resourcesPath, "icon.png");
 }
 
 // src/adapters/tools/web/search/electron/search-with-window.ts
@@ -233764,16 +233840,16 @@ function createSchedulerTools(scope) {
 // src/adapters/tools/image/analyze.ts
 init_dist6();
 init_zod();
-var import_promises28 = require("fs/promises");
-var import_fs20 = require("fs");
-var import_path28 = require("path");
+var import_promises29 = require("fs/promises");
+var import_fs21 = require("fs");
+var import_path29 = require("path");
 init_config();
 init_multimodal();
 init_logger();
 var logger37 = createLogger("AnalyzeImageTool");
 function resolveImagePath(imagePath) {
-  if ((0, import_path28.isAbsolute)(imagePath)) return imagePath;
-  return (0, import_path28.resolve)(process.cwd(), imagePath);
+  if ((0, import_path29.isAbsolute)(imagePath)) return imagePath;
+  return (0, import_path29.resolve)(process.cwd(), imagePath);
 }
 function createModelFromCandidate(candidate) {
   const channels = config.get("llmChannels") ?? [];
@@ -233823,9 +233899,9 @@ async function loadImageAsDataUrl(imagePathOrUrl, abortSignal) {
     buffer = Buffer.from(await response.arrayBuffer());
   } else {
     const absPath = resolveImagePath(imagePathOrUrl);
-    if (!(0, import_fs20.existsSync)(absPath)) throw new Error(`\u56FE\u7247\u6587\u4EF6\u4E0D\u5B58\u5728: ${absPath}`);
-    buffer = await (0, import_promises28.readFile)(absPath);
-    mimeType = extToMime((0, import_path28.extname)(absPath));
+    if (!(0, import_fs21.existsSync)(absPath)) throw new Error(`\u56FE\u7247\u6587\u4EF6\u4E0D\u5B58\u5728: ${absPath}`);
+    buffer = await (0, import_promises29.readFile)(absPath);
+    mimeType = extToMime((0, import_path29.extname)(absPath));
   }
   const maxDim = getMaxImageDimension();
   const resized = await resizeImageBuffer(buffer, maxDim);
@@ -233892,9 +233968,9 @@ function createAnalyzeImageTool() {
 // src/adapters/tools/image/generate.ts
 init_dist6();
 init_zod();
-var import_promises29 = require("fs/promises");
-var import_fs21 = require("fs");
-var import_path29 = require("path");
+var import_promises30 = require("fs/promises");
+var import_fs22 = require("fs");
+var import_path30 = require("path");
 init_config();
 init_logger();
 var logger38 = createLogger("GenerateImageTool");
@@ -233931,9 +234007,9 @@ async function loadImageBuffer(imagePathOrUrl, abortSignal) {
     if (!response.ok) throw new Error(`\u83B7\u53D6\u56FE\u7247\u5931\u8D25: ${response.status} ${response.statusText}`);
     return Buffer.from(await response.arrayBuffer());
   }
-  const absPath = (0, import_path29.isAbsolute)(imagePathOrUrl) ? imagePathOrUrl : (0, import_path29.resolve)(process.cwd(), imagePathOrUrl);
-  if (!(0, import_fs21.existsSync)(absPath)) throw new Error(`\u56FE\u7247\u6587\u4EF6\u4E0D\u5B58\u5728: ${absPath}`);
-  return (0, import_promises29.readFile)(absPath);
+  const absPath = (0, import_path30.isAbsolute)(imagePathOrUrl) ? imagePathOrUrl : (0, import_path30.resolve)(process.cwd(), imagePathOrUrl);
+  if (!(0, import_fs22.existsSync)(absPath)) throw new Error(`\u56FE\u7247\u6587\u4EF6\u4E0D\u5B58\u5728: ${absPath}`);
+  return (0, import_promises30.readFile)(absPath);
 }
 function createGenerateImageTool() {
   return {
@@ -234375,8 +234451,8 @@ var ToolOutputArtifactStateSlot = defineExecutionSlot({
 });
 
 // src/adapters/tools/middleware/save-tool-output-artifact.ts
-var import_promises30 = require("fs/promises");
-var import_path30 = require("path");
+var import_promises31 = require("fs/promises");
+var import_path31 = require("path");
 init_workspace();
 init_thread_file_store();
 
@@ -234648,11 +234724,11 @@ async function saveArtifact(ctx, filename, text4) {
   const resultsRoot = resolveToolResultsRoot(ctx);
   const now2 = ctx.runtime.now();
   const today = now2.toISOString().split("T")[0];
-  const dir = (0, import_path30.join)(resultsRoot, today);
-  await (0, import_promises30.mkdir)(dir, { recursive: true });
-  const absolutePath = (0, import_path30.join)(dir, filename);
+  const dir = (0, import_path31.join)(resultsRoot, today);
+  await (0, import_promises31.mkdir)(dir, { recursive: true });
+  const absolutePath = (0, import_path31.join)(dir, filename);
   const content = limitArtifactBytes(text4);
-  await (0, import_promises30.writeFile)(absolutePath, content, "utf-8");
+  await (0, import_promises31.writeFile)(absolutePath, content, "utf-8");
   return {
     absolutePath,
     relativePath: `tool_results/${today}/${filename}`,
@@ -234663,9 +234739,9 @@ async function saveArtifact(ctx, filename, text4) {
 }
 function resolveToolResultsRoot(ctx) {
   if (ctx.groupId && ctx.threadId) {
-    return (0, import_path30.join)(getThreadDir(ctx.groupId, ctx.threadId), "tool_results");
+    return (0, import_path31.join)(getThreadDir(ctx.groupId, ctx.threadId), "tool_results");
   }
-  return (0, import_path30.join)(getAgentWorkspaceDir(ctx.agentId), "tool_results");
+  return (0, import_path31.join)(getAgentWorkspaceDir(ctx.agentId), "tool_results");
 }
 function recordArtifact(ctx, stream, artifact) {
   const state = ctx.runtime.runState.getOrCreate(ToolOutputArtifactStateSlot, () => ({ artifacts: [] }));