duclaw-cli 1.8.47 → 1.8.48

package/dist/bundle.js

@@ -115,7 +115,7 @@ var require_package = __commonJS({
 var require_main = __commonJS({
   "node_modules/.pnpm/dotenv@17.3.1/node_modules/dotenv/lib/main.js"(exports2, module2) {
     var fs3 = require("fs");
-    var path19 = require("path");
+    var path20 = require("path");
     var os = require("os");
     var crypto2 = require("crypto");
     var packageJson = require_package();
@@ -261,7 +261,7 @@ var require_main = __commonJS({
           possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
         }
       } else {
-        possibleVaultPath = path19.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path20.resolve(process.cwd(), ".env.vault");
       }
       if (fs3.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
@@ -269,7 +269,7 @@ var require_main = __commonJS({
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path19.join(os.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path20.join(os.homedir(), envPath.slice(1)) : envPath;
     }
     function _configVault(options) {
       const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
@@ -286,7 +286,7 @@ var require_main = __commonJS({
       return { parsed };
     }
     function configDotenv(options) {
-      const dotenvPath = path19.resolve(process.cwd(), ".env");
+      const dotenvPath = path20.resolve(process.cwd(), ".env");
       let encoding = "utf8";
       let processEnv = process.env;
       if (options && options.processEnv != null) {
@@ -314,13 +314,13 @@ var require_main = __commonJS({
       }
       let lastError;
       const parsedAll = {};
-      for (const path20 of optionPaths) {
+      for (const path21 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs3.readFileSync(path20, { encoding }));
+          const parsed = DotenvModule.parse(fs3.readFileSync(path21, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
-            _debug(`Failed to load ${path20} ${e.message}`);
+            _debug(`Failed to load ${path21} ${e.message}`);
           }
           lastError = e;
         }
@@ -333,7 +333,7 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative4 = path19.relative(process.cwd(), filePath);
+            const relative4 = path20.relative(process.cwd(), filePath);
             shortPaths.push(relative4);
           } catch (e) {
             if (debug) {
@@ -8237,8 +8237,8 @@ var require_MODULE_LOAD = __commonJS({
        * @param moduleArguments - Optional arguments to pass to the module
        * @see https://redis.io/commands/module-load/
        */
-      parseCommand(parser, path19, moduleArguments) {
-        parser.push("MODULE", "LOAD", path19);
+      parseCommand(parser, path20, moduleArguments) {
+        parser.push("MODULE", "LOAD", path20);
         if (moduleArguments) {
           parser.push(...moduleArguments);
         }
@@ -23539,10 +23539,10 @@ var require_ARRAPPEND = __commonJS({
        * @param json - The first value to append
        * @param jsons - Additional values to append
        */
-      parseCommand(parser, key, path19, json, ...jsons) {
+      parseCommand(parser, key, path20, json, ...jsons) {
         parser.push("JSON.ARRAPPEND");
         parser.pushKey(key);
-        parser.push(path19, (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        parser.push(path20, (0, generic_transformers_1.transformRedisJsonArgument)(json));
         for (let i = 0; i < jsons.length; i++) {
           parser.push((0, generic_transformers_1.transformRedisJsonArgument)(jsons[i]));
         }
@@ -23572,10 +23572,10 @@ var require_ARRINDEX = __commonJS({
        * @param options.range.start - Starting index for the search
        * @param options.range.stop - Optional ending index for the search
        */
-      parseCommand(parser, key, path19, json, options) {
+      parseCommand(parser, key, path20, json, options) {
         parser.push("JSON.ARRINDEX");
         parser.pushKey(key);
-        parser.push(path19, (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        parser.push(path20, (0, generic_transformers_1.transformRedisJsonArgument)(json));
         if (options?.range) {
           parser.push(options.range.start.toString());
           if (options.range.stop !== void 0) {
@@ -23607,10 +23607,10 @@ var require_ARRINSERT = __commonJS({
        * @param json - The first value to insert
        * @param jsons - Additional values to insert
        */
-      parseCommand(parser, key, path19, index, json, ...jsons) {
+      parseCommand(parser, key, path20, index, json, ...jsons) {
         parser.push("JSON.ARRINSERT");
         parser.pushKey(key);
-        parser.push(path19, index.toString(), (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        parser.push(path20, index.toString(), (0, generic_transformers_1.transformRedisJsonArgument)(json));
         for (let i = 0; i < jsons.length; i++) {
           parser.push((0, generic_transformers_1.transformRedisJsonArgument)(jsons[i]));
         }
@@ -23700,10 +23700,10 @@ var require_ARRTRIM = __commonJS({
        * @param start - Starting index (inclusive)
        * @param stop - Ending index (inclusive)
        */
-      parseCommand(parser, key, path19, start, stop) {
+      parseCommand(parser, key, path20, start, stop) {
         parser.push("JSON.ARRTRIM");
         parser.pushKey(key);
-        parser.push(path19, start.toString(), stop.toString());
+        parser.push(path20, start.toString(), stop.toString());
       },
       transformReply: void 0
     };
@@ -23868,10 +23868,10 @@ var require_MERGE3 = __commonJS({
        * @param path - Path to merge into
        * @param value - JSON value to merge
        */
-      parseCommand(parser, key, path19, value) {
+      parseCommand(parser, key, path20, value) {
         parser.push("JSON.MERGE");
         parser.pushKey(key);
-        parser.push(path19, (0, generic_transformers_1.transformRedisJsonArgument)(value));
+        parser.push(path20, (0, generic_transformers_1.transformRedisJsonArgument)(value));
       },
       transformReply: void 0
     };
@@ -23894,10 +23894,10 @@ var require_MGET2 = __commonJS({
        * @param keys - Array of keys containing JSON documents
        * @param path - Path to retrieve from each document
        */
-      parseCommand(parser, keys, path19) {
+      parseCommand(parser, keys, path20) {
         parser.push("JSON.MGET");
         parser.pushKeys(keys);
-        parser.push(path19);
+        parser.push(path20);
       },
       transformReply(reply) {
         return reply.map((json) => (0, generic_transformers_1.transformRedisJsonNullReply)(json));
@@ -23952,10 +23952,10 @@ var require_NUMINCRBY = __commonJS({
        * @param path - Path to the numeric value
        * @param by - Amount to increment by
        */
-      parseCommand(parser, key, path19, by) {
+      parseCommand(parser, key, path20, by) {
         parser.push("JSON.NUMINCRBY");
         parser.pushKey(key);
-        parser.push(path19, by.toString());
+        parser.push(path20, by.toString());
       },
       transformReply: {
         2: (reply) => {
@@ -23987,10 +23987,10 @@ var require_NUMMULTBY = __commonJS({
        * @param path - Path to the numeric value
        * @param by - Amount to multiply by
        */
-      parseCommand(parser, key, path19, by) {
+      parseCommand(parser, key, path20, by) {
         parser.push("JSON.NUMMULTBY");
         parser.pushKey(key);
-        parser.push(path19, by.toString());
+        parser.push(path20, by.toString());
       },
       transformReply: NUMINCRBY_1.default.transformReply
     };
@@ -24074,10 +24074,10 @@ var require_SET2 = __commonJS({
        * @deprecated options.NX - Use options.condition instead
        * @deprecated options.XX - Use options.condition instead
        */
-      parseCommand(parser, key, path19, json, options) {
+      parseCommand(parser, key, path20, json, options) {
         parser.push("JSON.SET");
         parser.pushKey(key);
-        parser.push(path19, (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        parser.push(path20, (0, generic_transformers_1.transformRedisJsonArgument)(json));
         if (options?.condition) {
           parser.push(options?.condition);
         } else if (options?.NX) {
@@ -24165,10 +24165,10 @@ var require_TOGGLE = __commonJS({
        * @param key - The key containing the JSON document
        * @param path - Path to the boolean value
        */
-      parseCommand(parser, key, path19) {
+      parseCommand(parser, key, path20) {
         parser.push("JSON.TOGGLE");
         parser.pushKey(key);
-        parser.push(path19);
+        parser.push(path20);
       },
       transformReply: void 0
     };
@@ -30242,7 +30242,7 @@ function printHelp() {
 `);
 }
 function printVersion() {
-  console.log(`duclaw-cli v${true ? "1.8.47" : "unknown"}`);
+  console.log(`duclaw-cli v${true ? "1.8.48" : "unknown"}`);
 }
 function getDuclawTemplate() {
   return {
@@ -30757,10 +30757,530 @@ var feishuChannelPlugin = {
   }
 };
 
+// src/mobile/mobileStore.ts
+var import_node_crypto = require("node:crypto");
+
+// src/db/createDB.ts
+var import_better_sqlite3 = __toESM(require("better-sqlite3"));
+var import_node_path2 = require("node:path");
+var _db = null;
+var _tableEnsured = false;
+var createSqliteDB = () => {
+  if (!_db) {
+    const dbDir = getDuclawDataDir();
+    _db = new import_better_sqlite3.default((0, import_node_path2.join)(dbDir, "duclaw.db"));
+    _db.pragma("journal_mode = WAL");
+  }
+  if (!_tableEnsured) {
+    _tableEnsured = true;
+    _ensure_table_exist();
+  }
+  return _db;
+};
+var _ensure_table_exist = () => {
+  create_workspace_table();
+  create_mailbox_table();
+  create_mailbox_events_table();
+  create_ceo_followups_table();
+  create_agent_events_table();
+  create_mobile_tables();
+};
+var create_workspace_table = () => {
+  const db3 = createSqliteDB();
+  db3.exec(`
+        CREATE TABLE IF NOT EXISTS workspace (
+        id TEXT PRIMARY KEY,
+        team_name TEXT NOT NULL,
+        teammate_name TEXT,
+        team_workpath TEXT NOT NULL,
+        created_at INTEGER DEFAULT (strftime('%s', 'now')),
+        updated_at INTEGER DEFAULT (strftime('%s', 'now'))
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_team ON workspace(team_name);
+    `);
+};
+var create_mailbox_table = () => {
+  const db3 = createSqliteDB();
+  db3.exec(`
+        CREATE TABLE IF NOT EXISTS mailbox (
+        id TEXT PRIMARY KEY,
+        to_mailbox_id TEXT NOT NULL,
+        from_mailbox_id TEXT NOT NULL,
+        content TEXT NOT NULL,
+        status TEXT DEFAULT ('pending') NOT NULL,
+        origin_user_id TEXT,
+        origin_platform TEXT,
+        thread_id TEXT,
+        parent_message_id TEXT,
+        work_item_id TEXT,
+        work_item_role TEXT,
+        upstream_message_id TEXT,
+        send_time INTEGER DEFAULT ((strftime('%s', 'now')) * 1000),
+        created_at INTEGER DEFAULT ((strftime('%s', 'now')) * 1000),
+        updated_at INTEGER DEFAULT ((strftime('%s', 'now')) * 1000)
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_mailbox ON mailbox(to_mailbox_id);
+    `);
+  try {
+    db3.exec(`ALTER TABLE mailbox ADD COLUMN origin_user_id TEXT`);
+  } catch (_) {
+  }
+  try {
+    db3.exec(`ALTER TABLE mailbox ADD COLUMN origin_platform TEXT`);
+  } catch (_) {
+  }
+  try {
+    db3.exec(`ALTER TABLE mailbox ADD COLUMN thread_id TEXT`);
+  } catch (_) {
+  }
+  try {
+    db3.exec(`ALTER TABLE mailbox ADD COLUMN parent_message_id TEXT`);
+  } catch (_) {
+  }
+  try {
+    db3.exec(`ALTER TABLE mailbox ADD COLUMN work_item_id TEXT`);
+  } catch (_) {
+  }
+  try {
+    db3.exec(`ALTER TABLE mailbox ADD COLUMN work_item_role TEXT`);
+  } catch (_) {
+  }
+  try {
+    db3.exec(`ALTER TABLE mailbox ADD COLUMN upstream_message_id TEXT`);
+  } catch (_) {
+  }
+  const columns = db3.prepare(`PRAGMA table_info(mailbox)`).all();
+  const hasThreadId = columns.some((column) => column.name === "thread_id");
+  const hasParentMessageId = columns.some((column) => column.name === "parent_message_id");
+  const hasWorkItemId = columns.some((column) => column.name === "work_item_id");
+  const hasUpstreamMessageId = columns.some((column) => column.name === "upstream_message_id");
+  if (hasThreadId) {
+    db3.exec(`
+            CREATE INDEX IF NOT EXISTS idx_mailbox_thread
+            ON mailbox(thread_id, send_time DESC)
+        `);
+    db3.exec(`UPDATE mailbox SET thread_id = id WHERE thread_id IS NULL`);
+  }
+  if (hasParentMessageId) {
+    db3.exec(`
+            CREATE INDEX IF NOT EXISTS idx_mailbox_parent
+            ON mailbox(parent_message_id)
+        `);
+  }
+  if (hasWorkItemId) {
+    db3.exec(`
+            CREATE INDEX IF NOT EXISTS idx_mailbox_work_item
+            ON mailbox(work_item_id, send_time DESC)
+        `);
+  }
+  if (hasUpstreamMessageId) {
+    db3.exec(`
+            CREATE INDEX IF NOT EXISTS idx_mailbox_upstream
+            ON mailbox(upstream_message_id)
+        `);
+  }
+};
+var create_mailbox_events_table = () => {
+  const db3 = createSqliteDB();
+  db3.exec(`
+        CREATE TABLE IF NOT EXISTS mailbox_events (
+        id TEXT PRIMARY KEY,
+        message_id TEXT,
+        mailbox_id TEXT NOT NULL,
+        actor_mailbox_id TEXT,
+        counterpart_mailbox_id TEXT,
+        event_type TEXT NOT NULL,
+        detail_json TEXT,
+        created_at INTEGER DEFAULT ((strftime('%s', 'now')) * 1000)
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_mailbox_events_mailbox_created
+        ON mailbox_events(mailbox_id, created_at DESC);
+
+        CREATE INDEX IF NOT EXISTS idx_mailbox_events_message_created
+        ON mailbox_events(message_id, created_at DESC);
+    `);
+  try {
+    db3.exec(`ALTER TABLE mailbox_events ADD COLUMN actor_mailbox_id TEXT`);
+  } catch (_) {
+  }
+  try {
+    db3.exec(`ALTER TABLE mailbox_events ADD COLUMN counterpart_mailbox_id TEXT`);
+  } catch (_) {
+  }
+  try {
+    db3.exec(`ALTER TABLE mailbox_events ADD COLUMN detail_json TEXT`);
+  } catch (_) {
+  }
+};
+var create_ceo_followups_table = () => {
+  const db3 = createSqliteDB();
+  db3.exec(`
+        CREATE TABLE IF NOT EXISTS ceo_followups (
+        id TEXT PRIMARY KEY,
+        source_message_id TEXT NOT NULL UNIQUE,
+        status TEXT DEFAULT ('pending') NOT NULL,
+        origin_user_id TEXT NOT NULL,
+        origin_platform TEXT NOT NULL,
+        from_mailbox_id TEXT NOT NULL,
+        thread_id TEXT,
+        parent_message_id TEXT,
+        work_item_id TEXT,
+        content TEXT NOT NULL,
+        attempts INTEGER DEFAULT 0 NOT NULL,
+        last_error TEXT,
+        created_at INTEGER DEFAULT ((strftime('%s', 'now')) * 1000),
+        updated_at INTEGER DEFAULT ((strftime('%s', 'now')) * 1000),
+        completed_at INTEGER
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_ceo_followups_status_created
+        ON ceo_followups(status, created_at);
+
+        CREATE INDEX IF NOT EXISTS idx_ceo_followups_user_status
+        ON ceo_followups(origin_user_id, status, created_at);
+    `);
+};
+var create_agent_events_table = () => {
+  const db3 = createSqliteDB();
+  db3.exec(`
+        CREATE TABLE IF NOT EXISTS agent_events (
+        id TEXT PRIMARY KEY,
+        user_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        source TEXT NOT NULL,
+        source_id TEXT NOT NULL,
+        status TEXT DEFAULT ('pending') NOT NULL,
+        payload_json TEXT NOT NULL,
+        created_at INTEGER DEFAULT ((strftime('%s', 'now')) * 1000),
+        injected_at INTEGER,
+        handled_at INTEGER,
+        updated_at INTEGER DEFAULT ((strftime('%s', 'now')) * 1000),
+        UNIQUE(type, source, source_id)
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_agent_events_user_status_created
+        ON agent_events(user_id, status, created_at);
+
+        CREATE INDEX IF NOT EXISTS idx_agent_events_source
+        ON agent_events(type, source, source_id);
+    `);
+};
+var create_mobile_tables = () => {
+  const db3 = createSqliteDB();
+  db3.exec(`
+        CREATE TABLE IF NOT EXISTS mobile_messages (
+        id TEXT PRIMARY KEY,
+        thread_id TEXT NOT NULL,
+        user_id TEXT NOT NULL,
+        goal_id TEXT,
+        client_message_id TEXT,
+        role TEXT NOT NULL,
+        text TEXT NOT NULL,
+        status TEXT NOT NULL,
+        attachments_json TEXT,
+        metadata_json TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_mobile_messages_thread_created
+        ON mobile_messages(thread_id, created_at DESC);
+
+        CREATE TABLE IF NOT EXISTS mobile_runs (
+        thread_id TEXT PRIMARY KEY,
+        user_id TEXT NOT NULL,
+        goal_id TEXT,
+        running INTEGER DEFAULT 0 NOT NULL,
+        interrupted INTEGER,
+        logs_json TEXT NOT NULL,
+        last_result TEXT,
+        error TEXT,
+        updated_at INTEGER NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS mobile_attachments (
+        id TEXT PRIMARY KEY,
+        type TEXT,
+        name TEXT,
+        mime_type TEXT,
+        size INTEGER,
+        path TEXT,
+        url TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+        );
+    `);
+};
+
+// src/mobile/mobileStore.ts
+var lastMobileMessageTimestamp = 0;
+var nextMobileMessageTimestamp = () => {
+  const now = Date.now();
+  lastMobileMessageTimestamp = Math.max(now, lastMobileMessageTimestamp + 1);
+  return lastMobileMessageTimestamp;
+};
+var parseJson = (value, fallback) => {
+  if (!value) return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+};
+var clampLimit = (limit) => {
+  if (!Number.isFinite(limit)) return 20;
+  return Math.max(1, Math.min(100, Math.floor(limit ?? 20)));
+};
+var rowToMessage = (row) => ({
+  id: row.id,
+  threadId: row.thread_id,
+  userId: row.user_id,
+  goalId: row.goal_id ?? void 0,
+  clientMessageId: row.client_message_id ?? void 0,
+  role: row.role,
+  text: row.text,
+  status: row.status,
+  attachments: parseJson(row.attachments_json, void 0),
+  metadata: parseJson(row.metadata_json, void 0),
+  createdAt: row.created_at,
+  updatedAt: row.updated_at
+});
+var rowToAttachment = (row) => ({
+  id: row.id,
+  type: row.type ?? void 0,
+  name: row.name ?? void 0,
+  mimeType: row.mime_type ?? void 0,
+  size: row.size ?? void 0,
+  path: row.path ?? void 0,
+  url: row.url ?? void 0
+});
+var rowToRun = (row) => ({
+  threadId: row.thread_id,
+  userId: row.user_id,
+  goalId: row.goal_id ?? void 0,
+  running: row.running === 1,
+  interrupted: row.interrupted === null ? void 0 : row.interrupted === 1,
+  logs: parseJson(row.logs_json, []),
+  lastResult: row.last_result ?? void 0,
+  error: row.error ?? void 0,
+  updatedAt: row.updated_at
+});
+var saveMobileAttachment = (attachment) => {
+  const now = Date.now();
+  const saved = {
+    ...attachment,
+    id: attachment.id ?? (0, import_node_crypto.randomUUID)()
+  };
+  createSqliteDB().prepare(`
+            INSERT OR REPLACE INTO mobile_attachments
+            (id, type, name, mime_type, size, path, url, created_at, updated_at)
+            VALUES (@id, @type, @name, @mimeType, @size, @path, @url, @createdAt, @updatedAt)
+        `).run({
+    id: saved.id,
+    type: saved.type ?? null,
+    name: saved.name ?? null,
+    mimeType: saved.mimeType ?? null,
+    size: saved.size ?? null,
+    path: saved.path ?? null,
+    url: saved.url ?? null,
+    createdAt: now,
+    updatedAt: now
+  });
+  return saved;
+};
+var getMobileAttachment = (id) => {
+  const row = createSqliteDB().prepare(`SELECT id, type, name, mime_type, size, path, url FROM mobile_attachments WHERE id = ?`).get(id);
+  return row ? rowToAttachment(row) : void 0;
+};
+var appendMobileMessage = (input) => {
+  const now = nextMobileMessageTimestamp();
+  const message = {
+    ...input,
+    id: input.id ?? (0, import_node_crypto.randomUUID)(),
+    createdAt: now,
+    updatedAt: now
+  };
+  createSqliteDB().prepare(`
+            INSERT OR REPLACE INTO mobile_messages
+            (id, thread_id, user_id, goal_id, client_message_id, role, text, status, attachments_json, metadata_json, created_at, updated_at)
+            VALUES (@id, @threadId, @userId, @goalId, @clientMessageId, @role, @text, @status, @attachmentsJson, @metadataJson, @createdAt, @updatedAt)
+        `).run({
+    id: message.id,
+    threadId: message.threadId,
+    userId: message.userId,
+    goalId: message.goalId ?? null,
+    clientMessageId: message.clientMessageId ?? null,
+    role: message.role,
+    text: message.text,
+    status: message.status,
+    attachmentsJson: message.attachments ? JSON.stringify(message.attachments) : null,
+    metadataJson: message.metadata ? JSON.stringify(message.metadata) : null,
+    createdAt: message.createdAt,
+    updatedAt: message.updatedAt
+  });
+  return message;
+};
+var listMobileMessagesPage = (threadId, options = {}) => {
+  const limit = clampLimit(options.limit);
+  const rows = createSqliteDB().prepare(`
+            SELECT *
+            FROM mobile_messages
+            WHERE thread_id = @threadId
+            ${options.before ? "AND created_at < @before" : ""}
+            ORDER BY created_at DESC
+            LIMIT @limitPlusOne
+        `).all({
+    threadId,
+    before: options.before,
+    limitPlusOne: limit + 1
+  });
+  const hasMore = rows.length > limit;
+  const messages = rows.slice(0, limit).map(rowToMessage).reverse();
+  return {
+    messages,
+    hasMore,
+    nextBefore: messages[0]?.createdAt
+  };
+};
+var listMobileMessages = (threadId) => {
+  return listMobileMessagesPage(threadId, { limit: 100 }).messages;
+};
+var upsertMobileRun = (threadId, patch) => {
+  const existing = getMobileRun(threadId);
+  const run = {
+    threadId,
+    userId: patch.userId ?? existing.userId ?? threadId,
+    goalId: patch.goalId ?? existing.goalId,
+    running: patch.running ?? existing.running ?? false,
+    interrupted: patch.interrupted ?? existing.interrupted,
+    logs: patch.logs ?? existing.logs ?? [],
+    lastResult: patch.lastResult ?? existing.lastResult,
+    error: patch.error,
+    updatedAt: Date.now()
+  };
+  createSqliteDB().prepare(`
+            INSERT OR REPLACE INTO mobile_runs
+            (thread_id, user_id, goal_id, running, interrupted, logs_json, last_result, error, updated_at)
+            VALUES (@threadId, @userId, @goalId, @running, @interrupted, @logsJson, @lastResult, @error, @updatedAt)
+        `).run({
+    threadId: run.threadId,
+    userId: run.userId,
+    goalId: run.goalId ?? null,
+    running: run.running ? 1 : 0,
+    interrupted: run.interrupted === void 0 ? null : run.interrupted ? 1 : 0,
+    logsJson: JSON.stringify(run.logs),
+    lastResult: run.lastResult ?? null,
+    error: run.error ?? null,
+    updatedAt: run.updatedAt
+  });
+  return run;
+};
+var appendMobileRunLog = (threadId, line) => {
+  const existing = getMobileRun(threadId);
+  return upsertMobileRun(threadId, {
+    userId: existing.userId ?? threadId,
+    goalId: existing.goalId,
+    running: existing.running ?? false,
+    interrupted: existing.interrupted,
+    logs: [...existing.logs ?? [], line],
+    lastResult: existing.lastResult,
+    error: existing.error
+  });
+};
+var getMobileRun = (threadId) => {
+  const row = createSqliteDB().prepare(`SELECT * FROM mobile_runs WHERE thread_id = ?`).get(threadId);
+  return row ? rowToRun(row) : {
+    threadId,
+    userId: threadId,
+    running: false,
+    logs: [],
+    updatedAt: Date.now()
+  };
+};
+
+// src/channels/mobile/mobileChannelPlugin.ts
+async function postControlPlaneMobileMessage(ctx, threadId) {
+  const baseUrl = process.env.DUCLAW_CONTROL_PLANE_BASE_URL?.replace(/\/$/, "");
+  const token = process.env.DUCLAW_CONTROL_PLANE_METERING_TOKEN;
+  const tenantId = process.env.DUCLAW_TENANT_ID;
+  if (!baseUrl || !token || !tenantId) return;
+  try {
+    const response = await fetch(`${baseUrl}/internal/runtime/mobile/messages`, {
+      method: "POST",
+      signal: AbortSignal.timeout(2500),
+      headers: {
+        authorization: `Bearer ${token}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        tenantId,
+        threadId,
+        userId: threadId,
+        role: "assistant",
+        text: ctx.text,
+        status: "finished",
+        metadata: {
+          ...ctx.metadata ?? {},
+          accountId: ctx.accountId,
+          source: "mobile-channel"
+        }
+      })
+    });
+    if (!response.ok) {
+      console.warn(`[mobile-channel] control-plane \u56DE\u5199\u5931\u8D25: http=${response.status}`);
+    }
+  } catch (err) {
+    console.warn(`[mobile-channel] control-plane \u56DE\u5199\u5F02\u5E38: ${err.message}`);
+  }
+}
+var mobileChannelPlugin = {
+  id: "mobile-channel",
+  meta: {
+    id: "mobile-channel",
+    label: "mobile channel",
+    blurb: "In-app mobile delivery for Duclaw iOS clients"
+  },
+  config: {
+    resolveAccount: (cfg) => cfg
+  },
+  outbound: {
+    sendText: async (ctx) => {
+      const threadId = ctx.to;
+      await postControlPlaneMobileMessage(ctx, threadId);
+      appendMobileMessage({
+        threadId,
+        userId: threadId,
+        role: "assistant",
+        text: ctx.text,
+        status: "finished",
+        metadata: {
+          ...ctx.metadata ?? {},
+          accountId: ctx.accountId,
+          source: "mobile-channel"
+        }
+      });
+      upsertMobileRun(threadId, {
+        userId: threadId,
+        running: false,
+        lastResult: ctx.text
+      });
+      appendMobileRunLog(threadId, `[\u5B8C\u6210] ${ctx.text.slice(0, 500)}`);
+    }
+  },
+  gateway: {
+    startAccount: async () => void 0,
+    stopAccount: async () => void 0
+  }
+};
+
 // src/channels/index.ts
 var createDefaultChannels = () => {
   const registry2 = createChannelRegistry();
   registerChannel(registry2, feishuChannelPlugin);
+  registerChannel(registry2, mobileChannelPlugin);
   return {
     registry: registry2
   };
@@ -30901,7 +31421,7 @@ var sp2 = __toESM(require("node:path"), 1);
 
 // node_modules/.pnpm/readdirp@5.0.0/node_modules/readdirp/index.js
 var import_promises2 = require("node:fs/promises");
-var import_node_path2 = require("node:path");
+var import_node_path3 = require("node:path");
 var import_node_stream = require("node:stream");
 var EntryTypes = {
   FILE_TYPE: "files",
@@ -30983,7 +31503,7 @@ var ReaddirpStream = class extends import_node_stream.Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? import_promises2.lstat : import_promises2.stat;
     if (wantBigintFsStats) {
-      this._stat = (path19) => statMethod(path19, { bigint: true });
+      this._stat = (path20) => statMethod(path20, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -30991,7 +31511,7 @@ var ReaddirpStream = class extends import_node_stream.Readable {
     this._wantsDir = type ? DIR_TYPES.has(type) : false;
     this._wantsFile = type ? FILE_TYPES.has(type) : false;
     this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
-    this._root = (0, import_node_path2.resolve)(root);
+    this._root = (0, import_node_path3.resolve)(root);
     this._isDirent = !opts.alwaysStat;
     this._statsProp = this._isDirent ? "dirent" : "stats";
     this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
@@ -31008,8 +31528,8 @@ var ReaddirpStream = class extends import_node_stream.Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path19, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path19));
+          const { path: path20, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path20));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -31049,21 +31569,21 @@ var ReaddirpStream = class extends import_node_stream.Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path19, depth) {
+  async _exploreDir(path20, depth) {
     let files;
     try {
-      files = await (0, import_promises2.readdir)(path19, this._rdOptions);
+      files = await (0, import_promises2.readdir)(path20, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path19 };
+    return { files, depth, path: path20 };
   }
-  async _formatEntry(dirent, path19) {
+  async _formatEntry(dirent, path20) {
     let entry;
     const basename4 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = (0, import_node_path2.resolve)((0, import_node_path2.join)(path19, basename4));
-      entry = { path: (0, import_node_path2.relative)(this._root, fullPath), fullPath, basename: basename4 };
+      const fullPath = (0, import_node_path3.resolve)((0, import_node_path3.join)(path20, basename4));
+      entry = { path: (0, import_node_path3.relative)(this._root, fullPath), fullPath, basename: basename4 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -31097,7 +31617,7 @@ var ReaddirpStream = class extends import_node_stream.Readable {
         }
         if (entryRealPathStats.isDirectory()) {
           const len = entryRealPath.length;
-          if (full.startsWith(entryRealPath) && full.substr(len, 1) === import_node_path2.sep) {
+          if (full.startsWith(entryRealPath) && full.substr(len, 1) === import_node_path3.sep) {
             const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
             recursiveError.code = RECURSIVE_ERROR_CODE;
             return this._onError(recursiveError);
@@ -31462,16 +31982,16 @@ var delFromSet = (main2, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path19, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path20, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path19);
-    emitRaw(rawEvent, evPath, { watchedPath: path19 });
-    if (evPath && path19 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path19, evPath), KEY_LISTENERS, sp.join(path19, evPath));
+    listener(path20);
+    emitRaw(rawEvent, evPath, { watchedPath: path20 });
+    if (evPath && path20 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path20, evPath), KEY_LISTENERS, sp.join(path20, evPath));
     }
   };
   try {
-    return (0, import_node_fs.watch)(path19, {
+    return (0, import_node_fs.watch)(path20, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -31487,12 +32007,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path19, fullPath, options, handlers) => {
+var setFsWatchListener = (path20, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path19, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path20, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -31503,7 +32023,7 @@ var setFsWatchListener = (path19, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path19,
+      path20,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -31518,7 +32038,7 @@ var setFsWatchListener = (path19, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await (0, import_promises3.open)(path19, "r");
+          const fd = await (0, import_promises3.open)(path20, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -31549,7 +32069,7 @@ var setFsWatchListener = (path19, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path19, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path20, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -31571,7 +32091,7 @@ var setFsWatchFileListener = (path19, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path19, curr));
+          foreach(cont.listeners, (listener2) => listener2(path20, curr));
         }
       })
     };
@@ -31601,13 +32121,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path19, listener) {
+  _watchWithNodeFs(path20, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path19);
-    const basename4 = sp.basename(path19);
+    const directory = sp.dirname(path20);
+    const basename4 = sp.basename(path20);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename4);
-    const absolutePath = sp.resolve(path19);
+    const absolutePath = sp.resolve(path20);
     const options = {
       persistent: opts.persistent
     };
@@ -31617,12 +32137,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path19, absolutePath, options, {
+      closer = setFsWatchFileListener(path20, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path19, absolutePath, options, {
+      closer = setFsWatchListener(path20, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -31644,7 +32164,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename4))
       return;
-    const listener = async (path19, newStats) => {
+    const listener = async (path20, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -31658,11 +32178,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path19);
+            this.fsw._closeFile(path20);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path19, closer2);
+              this.fsw._addPathCloser(path20, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -31694,7 +32214,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path19, item) {
+  async _handleSymlink(entry, directory, path20, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -31704,7 +32224,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await (0, import_promises3.realpath)(path19);
+        linkPath = await (0, import_promises3.realpath)(path20);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -31714,12 +32234,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path19, entry.stats);
+          this.fsw._emit(EV.CHANGE, path20, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path19, entry.stats);
+        this.fsw._emit(EV.ADD, path20, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -31749,9 +32269,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path19 = sp.join(directory, item);
+      let path20 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path19, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path20, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -31760,8 +32280,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path19 = sp.join(dir, sp.relative(dir, path19));
-        this._addToNodeFs(path19, initialAdd, wh, depth + 1);
+        path20 = sp.join(dir, sp.relative(dir, path20));
+        this._addToNodeFs(path20, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve11, reject) => {
@@ -31830,13 +32350,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path19, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path20, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path19) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path20) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path19);
+    const wh = this.fsw._getWatchHelpers(path20);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -31852,8 +32372,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path19);
-        const targetPath = follow ? await (0, import_promises3.realpath)(path19) : path19;
+        const absPath = sp.resolve(path20);
+        const targetPath = follow ? await (0, import_promises3.realpath)(path20) : path20;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -31863,29 +32383,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await (0, import_promises3.realpath)(path19) : path19;
+        const targetPath = follow ? await (0, import_promises3.realpath)(path20) : path20;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path19, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path20, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path19), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path20), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path19, closer);
+        this.fsw._addPathCloser(path20, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path19;
+        return path20;
       }
     }
   }
@@ -31928,24 +32448,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path19) {
-  if (typeof path19 !== "string")
+function normalizePath(path20) {
+  if (typeof path20 !== "string")
     throw new Error("string expected");
-  path19 = sp2.normalize(path19);
-  path19 = path19.replace(/\\/g, "/");
+  path20 = sp2.normalize(path20);
+  path20 = path20.replace(/\\/g, "/");
   let prepend = false;
-  if (path19.startsWith("//"))
+  if (path20.startsWith("//"))
     prepend = true;
-  path19 = path19.replace(DOUBLE_SLASH_RE, "/");
+  path20 = path20.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path19 = "/" + path19;
-  return path19;
+    path20 = "/" + path20;
+  return path20;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path19 = normalizePath(testString);
+  const path20 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path19, stats)) {
+    if (pattern(path20, stats)) {
       return true;
     }
   }
@@ -31983,19 +32503,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path19) => toUnix(sp2.normalize(toUnix(path19)));
-var normalizeIgnored = (cwd = "") => (path19) => {
-  if (typeof path19 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path19) ? path19 : sp2.join(cwd, path19));
+var normalizePathToUnix = (path20) => toUnix(sp2.normalize(toUnix(path20)));
+var normalizeIgnored = (cwd = "") => (path20) => {
+  if (typeof path20 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path20) ? path20 : sp2.join(cwd, path20));
   } else {
-    return path19;
+    return path20;
   }
 };
-var getAbsolutePath = (path19, cwd) => {
-  if (sp2.isAbsolute(path19)) {
-    return path19;
+var getAbsolutePath = (path20, cwd) => {
+  if (sp2.isAbsolute(path20)) {
+    return path20;
   }
-  return sp2.join(cwd, path19);
+  return sp2.join(cwd, path20);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -32060,10 +32580,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path19, follow, fsw) {
+  constructor(path20, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path19;
-    this.path = path19 = path19.replace(REPLACER_RE, "");
+    const watchPath = path20;
+    this.path = path20 = path20.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -32203,20 +32723,20 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path19) => {
-        const absPath = getAbsolutePath(path19, cwd);
+      paths = paths.map((path20) => {
+        const absPath = getAbsolutePath(path20, cwd);
         return absPath;
       });
     }
-    paths.forEach((path19) => {
-      this._removeIgnoredPath(path19);
+    paths.forEach((path20) => {
+      this._removeIgnoredPath(path20);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path19) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path19, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path20) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path20, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -32238,17 +32758,17 @@ var FSWatcher = class extends import_node_events.EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path19) => {
-      if (!sp2.isAbsolute(path19) && !this._closers.has(path19)) {
+    paths.forEach((path20) => {
+      if (!sp2.isAbsolute(path20) && !this._closers.has(path20)) {
         if (cwd)
-          path19 = sp2.join(cwd, path19);
-        path19 = sp2.resolve(path19);
+          path20 = sp2.join(cwd, path20);
+        path20 = sp2.resolve(path20);
       }
-      this._closePath(path19);
-      this._addIgnoredPath(path19);
-      if (this._watched.has(path19)) {
+      this._closePath(path20);
+      this._addIgnoredPath(path20);
+      if (this._watched.has(path20)) {
         this._addIgnoredPath({
-          path: path19,
+          path: path20,
           recursive: true
         });
       }
@@ -32312,38 +32832,38 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path19, stats) {
+  async _emit(event, path20, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path19 = sp2.normalize(path19);
+      path20 = sp2.normalize(path20);
     if (opts.cwd)
-      path19 = sp2.relative(opts.cwd, path19);
-    const args = [path19];
+      path20 = sp2.relative(opts.cwd, path20);
+    const args = [path20];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path19))) {
+    if (awf && (pw = this._pendingWrites.get(path20))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path19, [event, ...args]);
+        this._pendingUnlinks.set(path20, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path20) => {
+          this._pendingUnlinks.forEach((entry, path21) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path20);
+            this._pendingUnlinks.delete(path21);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path19)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path20)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path19);
+        this._pendingUnlinks.delete(path20);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -32361,16 +32881,16 @@ var FSWatcher = class extends import_node_events.EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path19, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path20, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path19, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path20, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sp2.join(opts.cwd, path19) : path19;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path20) : path20;
       let stats2;
       try {
         stats2 = await (0, import_promises4.stat)(fullPath);
@@ -32401,23 +32921,23 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path19, timeout) {
+  _throttle(actionType, path20, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path19);
+    const actionPath = action.get(path20);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path19);
+      const item = action.get(path20);
       const count = item ? item.count : 0;
-      action.delete(path19);
+      action.delete(path20);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -32425,7 +32945,7 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path19, thr);
+    action.set(path20, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -32439,44 +32959,44 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path19, threshold, event, awfEmit) {
+  _awaitWriteFinish(path20, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path19;
-    if (this.options.cwd && !sp2.isAbsolute(path19)) {
-      fullPath = sp2.join(this.options.cwd, path19);
+    let fullPath = path20;
+    if (this.options.cwd && !sp2.isAbsolute(path20)) {
+      fullPath = sp2.join(this.options.cwd, path20);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       (0, import_node_fs2.stat)(fullPath, (err, curStat) => {
-        if (err || !writes.has(path19)) {
+        if (err || !writes.has(path20)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path19).lastChange = now2;
+          writes.get(path20).lastChange = now2;
         }
-        const pw = writes.get(path19);
+        const pw = writes.get(path20);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path19);
+          writes.delete(path20);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path19)) {
-      writes.set(path19, {
+    if (!writes.has(path20)) {
+      writes.set(path20, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path19);
+          writes.delete(path20);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -32487,8 +33007,8 @@ var FSWatcher = class extends import_node_events.EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path19, stats) {
-    if (this.options.atomic && DOT_RE.test(path19))
+  _isIgnored(path20, stats) {
+    if (this.options.atomic && DOT_RE.test(path20))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -32498,17 +33018,17 @@ var FSWatcher = class extends import_node_events.EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path19, stats);
+    return this._userIgnored(path20, stats);
   }
-  _isntIgnored(path19, stat10) {
-    return !this._isIgnored(path19, stat10);
+  _isntIgnored(path20, stat10) {
+    return !this._isIgnored(path20, stat10);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path19) {
-    return new WatchHelper(path19, this.options.followSymlinks, this);
+  _getWatchHelpers(path20) {
+    return new WatchHelper(path20, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -32540,63 +33060,63 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path19 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path19);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path19) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path19, 100))
+    const path20 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path20);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path20) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path20, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path19);
+    const wp = this._getWatchedDir(path20);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path19, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path20, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path19;
+    let relPath = path20;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path19);
+      relPath = sp2.relative(this.options.cwd, path20);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path19);
+    this._watched.delete(path20);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path19))
-      this._emit(eventName, path19);
-    this._closePath(path19);
+    if (wasTracked && !this._isIgnored(path20))
+      this._emit(eventName, path20);
+    this._closePath(path20);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path19) {
-    this._closeFile(path19);
-    const dir = sp2.dirname(path19);
-    this._getWatchedDir(dir).remove(sp2.basename(path19));
+  _closePath(path20) {
+    this._closeFile(path20);
+    const dir = sp2.dirname(path20);
+    this._getWatchedDir(dir).remove(sp2.basename(path20));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path19) {
-    const closers = this._closers.get(path19);
+  _closeFile(path20) {
+    const closers = this._closers.get(path20);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path19);
+    this._closers.delete(path20);
   }
-  _addPathCloser(path19, closer) {
+  _addPathCloser(path20, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path19);
+    let list = this._closers.get(path20);
     if (!list) {
       list = [];
-      this._closers.set(path19, list);
+      this._closers.set(path20, list);
     }
     list.push(closer);
   }
@@ -32629,7 +33149,7 @@ var chokidar_default = { watch, FSWatcher };
 var import_node_cron = __toESM(require_node_cron());
 
 // src/agent/createAgent.ts
-var import_node_crypto13 = require("node:crypto");
+var import_node_crypto14 = require("node:crypto");
 var import_node_fs7 = require("node:fs");
 
 // src/background/BackgroundManager.ts
@@ -34060,12 +34580,12 @@ function encodeURIPath(str) {
   return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent);
 }
 var EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null));
-var createPathTagFunction = (pathEncoder = encodeURIPath) => function path19(statics, ...params) {
+var createPathTagFunction = (pathEncoder = encodeURIPath) => function path20(statics, ...params) {
   if (statics.length === 1)
     return statics[0];
   let postPath = false;
   const invalidSegments = [];
-  const path20 = statics.reduce((previousValue, currentValue, index) => {
+  const path21 = statics.reduce((previousValue, currentValue, index) => {
     if (/[?#]/.test(currentValue)) {
       postPath = true;
     }
@@ -34082,7 +34602,7 @@ var createPathTagFunction = (pathEncoder = encodeURIPath) => function path19(sta
     }
     return previousValue + currentValue + (index === params.length ? "" : encoded);
   }, "");
-  const pathOnly = path20.split(/[?#]/, 1)[0];
+  const pathOnly = path21.split(/[?#]/, 1)[0];
   const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
   let match2;
   while ((match2 = invalidSegmentPattern.exec(pathOnly)) !== null) {
@@ -34103,10 +34623,10 @@ var createPathTagFunction = (pathEncoder = encodeURIPath) => function path19(sta
     }, "");
     throw new AnthropicError(`Path parameters result in path with invalid segments:
 ${invalidSegments.map((e) => e.error).join("\n")}
-${path20}
+${path21}
 ${underline}`);
   }
-  return path20;
+  return path21;
 };
 var path4 = /* @__PURE__ */ createPathTagFunction(encodeURIPath);
 
@@ -37217,9 +37737,9 @@ var BaseAnthropic = class {
   makeStatusError(status, error, message, headers) {
     return APIError.generate(status, error, message, headers);
   }
-  buildURL(path19, query, defaultBaseURL) {
+  buildURL(path20, query, defaultBaseURL) {
     const baseURL = !__classPrivateFieldGet(this, _BaseAnthropic_instances, "m", _BaseAnthropic_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL;
-    const url = isAbsoluteURL(path19) ? new URL(path19) : new URL(baseURL + (baseURL.endsWith("/") && path19.startsWith("/") ? path19.slice(1) : path19));
+    const url = isAbsoluteURL(path20) ? new URL(path20) : new URL(baseURL + (baseURL.endsWith("/") && path20.startsWith("/") ? path20.slice(1) : path20));
     const defaultQuery = this.defaultQuery();
     if (!isEmptyObj(defaultQuery)) {
       query = { ...defaultQuery, ...query };
@@ -37250,24 +37770,24 @@ var BaseAnthropic = class {
    */
   async prepareRequest(request, { url, options }) {
   }
-  get(path19, opts) {
-    return this.methodRequest("get", path19, opts);
+  get(path20, opts) {
+    return this.methodRequest("get", path20, opts);
   }
-  post(path19, opts) {
-    return this.methodRequest("post", path19, opts);
+  post(path20, opts) {
+    return this.methodRequest("post", path20, opts);
   }
-  patch(path19, opts) {
-    return this.methodRequest("patch", path19, opts);
+  patch(path20, opts) {
+    return this.methodRequest("patch", path20, opts);
   }
-  put(path19, opts) {
-    return this.methodRequest("put", path19, opts);
+  put(path20, opts) {
+    return this.methodRequest("put", path20, opts);
   }
-  delete(path19, opts) {
-    return this.methodRequest("delete", path19, opts);
+  delete(path20, opts) {
+    return this.methodRequest("delete", path20, opts);
   }
-  methodRequest(method, path19, opts) {
+  methodRequest(method, path20, opts) {
     return this.request(Promise.resolve(opts).then((opts2) => {
-      return { method, path: path19, ...opts2 };
+      return { method, path: path20, ...opts2 };
     }));
   }
   request(options, remainingRetries = null) {
@@ -37371,8 +37891,8 @@ var BaseAnthropic = class {
     }));
     return { response, options, controller, requestLogID, retryOfRequestLogID, startTime: startTime2 };
   }
-  getAPIList(path19, Page2, opts) {
-    return this.requestAPIList(Page2, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path19, ...opts2 })) : { method: "get", path: path19, ...opts });
+  getAPIList(path20, Page2, opts) {
+    return this.requestAPIList(Page2, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path20, ...opts2 })) : { method: "get", path: path20, ...opts });
   }
   requestAPIList(Page2, options) {
     const request = this.makeRequest(options, null, void 0);
@@ -37460,8 +37980,8 @@ var BaseAnthropic = class {
   }
   async buildRequest(inputOptions, { retryCount = 0 } = {}) {
     const options = { ...inputOptions };
-    const { method, path: path19, query, defaultBaseURL } = options;
-    const url = this.buildURL(path19, query, defaultBaseURL);
+    const { method, path: path20, query, defaultBaseURL } = options;
+    const url = this.buildURL(path20, query, defaultBaseURL);
     if ("timeout" in options)
       validatePositiveInteger("timeout", options.timeout);
     options.timeout = options.timeout ?? this.timeout;
@@ -37830,12 +38350,12 @@ var toInternalContent = (sdkContent) => {
 
 // src/storage/FileStorage.ts
 var import_promises5 = require("node:fs/promises");
-var import_node_path3 = __toESM(require("node:path"));
+var import_node_path4 = __toESM(require("node:path"));
 var encodeKey = (key) => Buffer.from(key).toString("base64url");
 var normalizePrefix = (prefix) => prefix.replace(/[:/\\]+$/g, "") || "agent";
 var createFileStorage = (options = {}) => {
-  const rootDir = import_node_path3.default.join(options.rootDir || getDuclawDataDir(), "kv", normalizePrefix(options.prefix || "agent"));
-  const fileForKey = (key) => import_node_path3.default.join(rootDir, `${encodeKey(key)}.json`);
+  const rootDir = import_node_path4.default.join(options.rootDir || getDuclawDataDir(), "kv", normalizePrefix(options.prefix || "agent"));
+  const fileForKey = (key) => import_node_path4.default.join(rootDir, `${encodeKey(key)}.json`);
   return {
     async get(key) {
       try {
@@ -38814,14 +39334,14 @@ var taskUpdate = {
 };
 
 // src/tools/tools/Glob.ts
-var import_node_path5 = require("node:path");
+var import_node_path6 = require("node:path");
 var import_promises6 = require("node:fs/promises");
 
 // src/tools/utils/workspaceGuard.ts
-var import_node_path4 = require("node:path");
+var import_node_path5 = require("node:path");
 var validateWorkspacePath = (filePath, workspacePath) => {
-  const resolved = (0, import_node_path4.isAbsolute)(filePath) ? (0, import_node_path4.resolve)(filePath) : (0, import_node_path4.resolve)(process.cwd(), filePath);
-  const workspace = (0, import_node_path4.resolve)(workspacePath);
+  const resolved = (0, import_node_path5.isAbsolute)(filePath) ? (0, import_node_path5.resolve)(filePath) : (0, import_node_path5.resolve)(process.cwd(), filePath);
+  const workspace = (0, import_node_path5.resolve)(workspacePath);
   if (!resolved.startsWith(workspace + "/") && resolved !== workspace) {
     return `\u8DEF\u5F84 ${resolved} \u4E0D\u5728\u5DE5\u4F5C\u533A ${workspace} \u8303\u56F4\u5185\uFF0C\u64CD\u4F5C\u88AB\u62D2\u7EDD\u3002\u8BF7\u5C06\u6587\u4EF6\u653E\u5728\u5DE5\u4F5C\u533A\u76EE\u5F55\u4E0B\u3002`;
   }
@@ -38879,7 +39399,7 @@ var globTool = {
     const pattern = input.pattern;
     const effectiveCwd = getEffectiveCwd(userRequest);
     const searchDir = input.path || effectiveCwd;
-    const resolvedDir = (0, import_node_path5.isAbsolute)(searchDir) ? searchDir : (0, import_node_path5.resolve)(effectiveCwd, searchDir);
+    const resolvedDir = (0, import_node_path6.isAbsolute)(searchDir) ? searchDir : (0, import_node_path6.resolve)(effectiveCwd, searchDir);
     const LIMIT = 100;
     const regex = globToRegex(pattern);
     const files = [];
@@ -38893,7 +39413,7 @@ var globTool = {
     for (const entry of entries) {
       const normalized = entry.replace(/\\/g, "/");
       if (!regex.test(normalized)) continue;
-      const fullPath = (0, import_node_path5.resolve)(resolvedDir, entry);
+      const fullPath = (0, import_node_path6.resolve)(resolvedDir, entry);
       try {
         const s = await (0, import_promises6.stat)(fullPath);
         if (!s.isFile()) continue;
@@ -38916,7 +39436,7 @@ var globTool = {
 };
 
 // src/tools/tools/Grep.ts
-var import_node_path6 = require("node:path");
+var import_node_path7 = require("node:path");
 var import_promises7 = require("node:fs/promises");
 var MAX_LINE_LENGTH = 2e3;
 var DESCRIPTION2 = `
@@ -38989,7 +39509,7 @@ var grepTool = {
     const effectiveCwd = getEffectiveCwd(userRequest);
     const searchDir = input.path || effectiveCwd;
     const includePattern = input.include;
-    const resolvedDir = (0, import_node_path6.isAbsolute)(searchDir) ? searchDir : (0, import_node_path6.resolve)(effectiveCwd, searchDir);
+    const resolvedDir = (0, import_node_path7.isAbsolute)(searchDir) ? searchDir : (0, import_node_path7.resolve)(effectiveCwd, searchDir);
     let regex;
     try {
       regex = new RegExp(pattern);
@@ -39013,7 +39533,7 @@ var grepTool = {
         const fileName = normalized.split("/").pop() || normalized;
         if (!includeRegex.test(fileName)) continue;
       }
-      const fullPath = (0, import_node_path6.resolve)(resolvedDir, entry);
+      const fullPath = (0, import_node_path7.resolve)(resolvedDir, entry);
       let s;
       try {
         s = await (0, import_promises7.stat)(fullPath);
@@ -39156,7 +39676,7 @@ var codeSearchTool = {
 };
 
 // src/tools/tools/Read.ts
-var import_node_path7 = require("node:path");
+var import_node_path8 = require("node:path");
 var import_promises8 = require("node:fs/promises");
 var DEFAULT_READ_LIMIT = 2e3;
 var MAX_LINE_LENGTH2 = 2e3;
@@ -39217,7 +39737,7 @@ var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".heif"
 ]);
 async function isBinaryFile(filePath) {
-  const ext = (0, import_node_path7.extname)(filePath).toLowerCase();
+  const ext = (0, import_node_path8.extname)(filePath).toLowerCase();
   if (BINARY_EXTENSIONS.has(ext)) return true;
   let buffer;
   try {
@@ -39259,20 +39779,20 @@ var readTool = {
   },
   async execute(input, userRequest) {
     let filePath = input.filePath;
-    if (!(0, import_node_path7.isAbsolute)(filePath)) {
-      filePath = (0, import_node_path7.resolve)(getEffectiveCwd(userRequest), filePath);
+    if (!(0, import_node_path8.isAbsolute)(filePath)) {
+      filePath = (0, import_node_path8.resolve)(getEffectiveCwd(userRequest), filePath);
     }
     let fileStat;
     try {
       fileStat = await (0, import_promises8.stat)(filePath);
     } catch {
       try {
-        const dir = (0, import_node_path7.dirname)(filePath);
-        const base = (0, import_node_path7.basename)(filePath);
+        const dir = (0, import_node_path8.dirname)(filePath);
+        const base = (0, import_node_path8.basename)(filePath);
         const dirEntries = await (0, import_promises8.readdir)(dir);
         const suggestions = dirEntries.filter(
           (entry) => entry.toLowerCase().includes(base.toLowerCase()) || base.toLowerCase().includes(entry.toLowerCase())
-        ).map((entry) => (0, import_node_path7.join)(dir, entry)).slice(0, 3);
+        ).map((entry) => (0, import_node_path8.join)(dir, entry)).slice(0, 3);
         if (suggestions.length > 0) {
           return `File not found: ${filePath}
 
@@ -39289,7 +39809,7 @@ ${suggestions.join("\n")}`;
     if (fileStat.size === 0) {
       return `<system-reminder>File exists but has empty contents: ${filePath}</system-reminder>`;
     }
-    const ext = (0, import_node_path7.extname)(filePath).toLowerCase();
+    const ext = (0, import_node_path8.extname)(filePath).toLowerCase();
     if (IMAGE_EXTENSIONS.has(ext)) {
       return `Cannot read image file with this tool. Use the image_understand tool instead to analyze image: ${filePath}`;
     }
@@ -39463,7 +39983,7 @@ var webSearchTool = {
 };
 
 // src/tools/tools/Write.ts
-var import_node_path8 = require("node:path");
+var import_node_path9 = require("node:path");
 var import_promises9 = require("node:fs/promises");
 
 // node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/base.js
@@ -39566,16 +40086,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path19, added, removed, oldPosInc, options) {
-    const last = path19.lastComponent;
+  addToPath(path20, added, removed, oldPosInc, options) {
+    const last = path20.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path19.oldPos + oldPosInc,
+        oldPos: path20.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path19.oldPos + oldPosInc,
+        oldPos: path20.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -39928,8 +40448,8 @@ var writeTool = {
   async execute(input, userRequest) {
     let filePath = input.filePath;
     const content = input.content;
-    if (!(0, import_node_path8.isAbsolute)(filePath)) {
-      filePath = (0, import_node_path8.resolve)(getEffectiveCwd(userRequest), filePath);
+    if (!(0, import_node_path9.isAbsolute)(filePath)) {
+      filePath = (0, import_node_path9.resolve)(getEffectiveCwd(userRequest), filePath);
     }
     if (userRequest?.workspacePath) {
       const rejection = validateWorkspacePath(filePath, userRequest.workspacePath);
@@ -39945,7 +40465,7 @@ var writeTool = {
       }
     } catch {
     }
-    await (0, import_promises9.mkdir)((0, import_node_path8.dirname)(filePath), { recursive: true });
+    await (0, import_promises9.mkdir)((0, import_node_path9.dirname)(filePath), { recursive: true });
     await (0, import_promises9.writeFile)(filePath, content, "utf-8");
     let output = `\u6587\u4EF6\u5199\u5165\u6210\u529F: ${filePath}`;
     if (exists) {
@@ -39967,7 +40487,7 @@ ${trimmed}${suffix}
 };
 
 // src/tools/tools/Edit.ts
-var import_node_path9 = require("node:path");
+var import_node_path10 = require("node:path");
 var import_promises10 = require("node:fs/promises");
 var DESCRIPTION7 = `Performs exact string replacements in files.
 
@@ -40366,8 +40886,8 @@ var editTool = {
     if (oldString === newString) {
       return "\u9519\u8BEF: oldString \u548C newString \u5FC5\u987B\u4E0D\u540C";
     }
-    if (!(0, import_node_path9.isAbsolute)(filePath)) {
-      filePath = (0, import_node_path9.resolve)(getEffectiveCwd(userRequest), filePath);
+    if (!(0, import_node_path10.isAbsolute)(filePath)) {
+      filePath = (0, import_node_path10.resolve)(getEffectiveCwd(userRequest), filePath);
     }
     if (userRequest?.workspacePath) {
       const rejection = validateWorkspacePath(filePath, userRequest.workspacePath);
@@ -40750,7 +41270,7 @@ var isToolUseBlock = (block) => block.type === "tool_use";
 var extractText = (blocks) => blocks.filter(isTextBlock).map((b) => b.text).join("\n");
 
 // src/tools/tools/ImageUnderstandMetering.ts
-var import_node_crypto = require("node:crypto");
+var import_node_crypto2 = require("node:crypto");
 var ImageUnderstandMeteringError = class extends Error {
   constructor(message, statusCode, meteringStatus) {
     super(message);
@@ -40840,7 +41360,7 @@ function inferImageProvider(baseUrl) {
   }
 }
 function fingerprintImageSource(imageSource) {
-  return (0, import_node_crypto.createHash)("sha256").update(imageSource).digest("hex");
+  return (0, import_node_crypto2.createHash)("sha256").update(imageSource).digest("hex");
 }
 function imageSourceKind(imageSource) {
   if (imageSource.startsWith("http://") || imageSource.startsWith("https://")) return "url";
@@ -41407,218 +41927,10 @@ var goalDelete = {
 };
 
 // src/tools/tools/department/DepartmentCreate.ts
-var import_node_crypto6 = require("node:crypto");
+var import_node_crypto7 = require("node:crypto");
 
 // src/department/mailbox/mailbox.ts
-var import_node_crypto5 = require("node:crypto");
-
-// src/db/createDB.ts
-var import_better_sqlite3 = __toESM(require("better-sqlite3"));
-var import_node_path10 = require("node:path");
-var _db = null;
-var _tableEnsured = false;
-var createSqliteDB = () => {
-  if (!_db) {
-    const dbDir = getDuclawDataDir();
-    _db = new import_better_sqlite3.default((0, import_node_path10.join)(dbDir, "duclaw.db"));
-    _db.pragma("journal_mode = WAL");
-  }
-  if (!_tableEnsured) {
-    _tableEnsured = true;
-    _ensure_table_exist();
-  }
-  return _db;
-};
-var _ensure_table_exist = () => {
-  create_workspace_table();
-  create_mailbox_table();
-  create_mailbox_events_table();
-  create_ceo_followups_table();
-  create_agent_events_table();
-};
-var create_workspace_table = () => {
-  const db3 = createSqliteDB();
-  db3.exec(`
-        CREATE TABLE IF NOT EXISTS workspace (
-        id TEXT PRIMARY KEY,
-        team_name TEXT NOT NULL,
-        teammate_name TEXT,
-        team_workpath TEXT NOT NULL,
-        created_at INTEGER DEFAULT (strftime('%s', 'now')),
-        updated_at INTEGER DEFAULT (strftime('%s', 'now'))
-        );
-
-        CREATE INDEX IF NOT EXISTS idx_team ON workspace(team_name);
-    `);
-};
-var create_mailbox_table = () => {
-  const db3 = createSqliteDB();
-  db3.exec(`
-        CREATE TABLE IF NOT EXISTS mailbox (
-        id TEXT PRIMARY KEY,
-        to_mailbox_id TEXT NOT NULL,
-        from_mailbox_id TEXT NOT NULL,
-        content TEXT NOT NULL,
-        status TEXT DEFAULT ('pending') NOT NULL,
-        origin_user_id TEXT,
-        origin_platform TEXT,
-        thread_id TEXT,
-        parent_message_id TEXT,
-        work_item_id TEXT,
-        work_item_role TEXT,
-        upstream_message_id TEXT,
-        send_time INTEGER DEFAULT ((strftime('%s', 'now')) * 1000),
-        created_at INTEGER DEFAULT ((strftime('%s', 'now')) * 1000),
-        updated_at INTEGER DEFAULT ((strftime('%s', 'now')) * 1000)
-        );
-
-        CREATE INDEX IF NOT EXISTS idx_mailbox ON mailbox(to_mailbox_id);
-    `);
-  try {
-    db3.exec(`ALTER TABLE mailbox ADD COLUMN origin_user_id TEXT`);
-  } catch (_) {
-  }
-  try {
-    db3.exec(`ALTER TABLE mailbox ADD COLUMN origin_platform TEXT`);
-  } catch (_) {
-  }
-  try {
-    db3.exec(`ALTER TABLE mailbox ADD COLUMN thread_id TEXT`);
-  } catch (_) {
-  }
-  try {
-    db3.exec(`ALTER TABLE mailbox ADD COLUMN parent_message_id TEXT`);
-  } catch (_) {
-  }
-  try {
-    db3.exec(`ALTER TABLE mailbox ADD COLUMN work_item_id TEXT`);
-  } catch (_) {
-  }
-  try {
-    db3.exec(`ALTER TABLE mailbox ADD COLUMN work_item_role TEXT`);
-  } catch (_) {
-  }
-  try {
-    db3.exec(`ALTER TABLE mailbox ADD COLUMN upstream_message_id TEXT`);
-  } catch (_) {
-  }
-  const columns = db3.prepare(`PRAGMA table_info(mailbox)`).all();
-  const hasThreadId = columns.some((column) => column.name === "thread_id");
-  const hasParentMessageId = columns.some((column) => column.name === "parent_message_id");
-  const hasWorkItemId = columns.some((column) => column.name === "work_item_id");
-  const hasUpstreamMessageId = columns.some((column) => column.name === "upstream_message_id");
-  if (hasThreadId) {
-    db3.exec(`
-            CREATE INDEX IF NOT EXISTS idx_mailbox_thread
-            ON mailbox(thread_id, send_time DESC)
-        `);
-    db3.exec(`UPDATE mailbox SET thread_id = id WHERE thread_id IS NULL`);
-  }
-  if (hasParentMessageId) {
-    db3.exec(`
-            CREATE INDEX IF NOT EXISTS idx_mailbox_parent
-            ON mailbox(parent_message_id)
-        `);
-  }
-  if (hasWorkItemId) {
-    db3.exec(`
-            CREATE INDEX IF NOT EXISTS idx_mailbox_work_item
-            ON mailbox(work_item_id, send_time DESC)
-        `);
-  }
-  if (hasUpstreamMessageId) {
-    db3.exec(`
-            CREATE INDEX IF NOT EXISTS idx_mailbox_upstream
-            ON mailbox(upstream_message_id)
-        `);
-  }
-};
-var create_mailbox_events_table = () => {
-  const db3 = createSqliteDB();
-  db3.exec(`
-        CREATE TABLE IF NOT EXISTS mailbox_events (
-        id TEXT PRIMARY KEY,
-        message_id TEXT,
-        mailbox_id TEXT NOT NULL,
-        actor_mailbox_id TEXT,
-        counterpart_mailbox_id TEXT,
-        event_type TEXT NOT NULL,
-        detail_json TEXT,
-        created_at INTEGER DEFAULT ((strftime('%s', 'now')) * 1000)
-        );
-
-        CREATE INDEX IF NOT EXISTS idx_mailbox_events_mailbox_created
-        ON mailbox_events(mailbox_id, created_at DESC);
-
-        CREATE INDEX IF NOT EXISTS idx_mailbox_events_message_created
-        ON mailbox_events(message_id, created_at DESC);
-    `);
-  try {
-    db3.exec(`ALTER TABLE mailbox_events ADD COLUMN actor_mailbox_id TEXT`);
-  } catch (_) {
-  }
-  try {
-    db3.exec(`ALTER TABLE mailbox_events ADD COLUMN counterpart_mailbox_id TEXT`);
-  } catch (_) {
-  }
-  try {
-    db3.exec(`ALTER TABLE mailbox_events ADD COLUMN detail_json TEXT`);
-  } catch (_) {
-  }
-};
-var create_ceo_followups_table = () => {
-  const db3 = createSqliteDB();
-  db3.exec(`
-        CREATE TABLE IF NOT EXISTS ceo_followups (
-        id TEXT PRIMARY KEY,
-        source_message_id TEXT NOT NULL UNIQUE,
-        status TEXT DEFAULT ('pending') NOT NULL,
-        origin_user_id TEXT NOT NULL,
-        origin_platform TEXT NOT NULL,
-        from_mailbox_id TEXT NOT NULL,
-        thread_id TEXT,
-        parent_message_id TEXT,
-        work_item_id TEXT,
-        content TEXT NOT NULL,
-        attempts INTEGER DEFAULT 0 NOT NULL,
-        last_error TEXT,
-        created_at INTEGER DEFAULT ((strftime('%s', 'now')) * 1000),
-        updated_at INTEGER DEFAULT ((strftime('%s', 'now')) * 1000),
-        completed_at INTEGER
-        );
-
-        CREATE INDEX IF NOT EXISTS idx_ceo_followups_status_created
-        ON ceo_followups(status, created_at);
-
-        CREATE INDEX IF NOT EXISTS idx_ceo_followups_user_status
-        ON ceo_followups(origin_user_id, status, created_at);
-    `);
-};
-var create_agent_events_table = () => {
-  const db3 = createSqliteDB();
-  db3.exec(`
-        CREATE TABLE IF NOT EXISTS agent_events (
-        id TEXT PRIMARY KEY,
-        user_id TEXT NOT NULL,
-        type TEXT NOT NULL,
-        source TEXT NOT NULL,
-        source_id TEXT NOT NULL,
-        status TEXT DEFAULT ('pending') NOT NULL,
-        payload_json TEXT NOT NULL,
-        created_at INTEGER DEFAULT ((strftime('%s', 'now')) * 1000),
-        injected_at INTEGER,
-        handled_at INTEGER,
-        updated_at INTEGER DEFAULT ((strftime('%s', 'now')) * 1000),
-        UNIQUE(type, source, source_id)
-        );
-
-        CREATE INDEX IF NOT EXISTS idx_agent_events_user_status_created
-        ON agent_events(user_id, status, created_at);
-
-        CREATE INDEX IF NOT EXISTS idx_agent_events_source
-        ON agent_events(type, source, source_id);
-    `);
-};
+var import_node_crypto6 = require("node:crypto");
 
 // src/agent/interruptRegistry.ts
 var registry = /* @__PURE__ */ new Map();
@@ -41669,7 +41981,7 @@ var drainInterrupts = (userId) => {
 };
 
 // src/agent/events.ts
-var import_node_crypto2 = require("node:crypto");
+var import_node_crypto3 = require("node:crypto");
 var rowToEvent = (row) => ({
   id: row.id,
   userId: row.userId,
@@ -41686,7 +41998,7 @@ var rowToEvent = (row) => ({
 var recordAgentEvent = (input) => {
   const db3 = createSqliteDB();
   const now = Date.now();
-  const id = `evt_${(0, import_node_crypto2.randomUUID)().slice(0, 12)}`;
+  const id = `evt_${(0, import_node_crypto3.randomUUID)().slice(0, 12)}`;
   const payloadJson = JSON.stringify(input.payload);
   db3.prepare(`
         INSERT INTO agent_events (
@@ -41817,7 +42129,7 @@ ${ceoFollowupInstruction}
 };
 
 // src/department/mailbox/events.ts
-var import_node_crypto3 = require("node:crypto");
+var import_node_crypto4 = require("node:crypto");
 var parseDetail = (detailJson) => {
   if (!detailJson) return void 0;
   try {
@@ -41858,7 +42170,7 @@ var mapMailboxEventRow = (row) => {
 var recordMailboxEvent = (input) => {
   const db3 = createSqliteDB();
   const event = {
-    id: (0, import_node_crypto3.randomUUID)().slice(0, 12),
+    id: (0, import_node_crypto4.randomUUID)().slice(0, 12),
     messageId: input.messageId,
     mailboxId: input.mailboxId,
     actorMailboxId: input.actorMailboxId,
@@ -42142,7 +42454,7 @@ var deleteDepartmentMemberById = (departmentName, memberId) => {
 };
 
 // src/department/mailbox/ceoFollowup.ts
-var import_node_crypto4 = require("node:crypto");
+var import_node_crypto5 = require("node:crypto");
 var rowToFollowup = (row) => ({
   id: row.id,
   sourceMessageId: row.sourceMessageId,
@@ -42189,7 +42501,7 @@ var enqueueCeoFollowupFromMailbox = (message) => {
   if (!message.originUserId || !message.originPlatform) return null;
   const db3 = createSqliteDB();
   const now = Date.now();
-  const id = `cfu_${(0, import_node_crypto4.randomUUID)().slice(0, 12)}`;
+  const id = `cfu_${(0, import_node_crypto5.randomUUID)().slice(0, 12)}`;
   db3.prepare(`
         INSERT INTO ceo_followups (
             id,
@@ -42519,7 +42831,7 @@ var recordMailboxReceivedAgentEvent = (msg) => {
 };
 var sendMessage2 = (fromMailboxId, toMailboxId, content, options) => {
   const db3 = createSqliteDB();
-  const id = (0, import_node_crypto5.randomUUID)().slice(0, 8);
+  const id = (0, import_node_crypto6.randomUUID)().slice(0, 8);
   const threadId = options?.threadId || id;
   const workItemContext = resolveWorkItemContext(fromMailboxId, toMailboxId, id, options);
   const stmt = db3.prepare(`insert into mailbox (
@@ -42662,7 +42974,7 @@ var departmentCreate = {
       return `[departmentCreate] \u4E0D\u5B58\u5728 id=${sourceGoalId} \u7684\u76EE\u6807`;
     }
     let departmentDefinition = {
-      id: (0, import_node_crypto6.randomUUID)().slice(0, 8),
+      id: (0, import_node_crypto7.randomUUID)().slice(0, 8),
       name,
       charter,
       sourceGoalId,
@@ -42929,7 +43241,7 @@ var departmentList = {
 };
 
 // src/tools/tools/department/DepartmentMemberCreate.ts
-var import_node_crypto7 = require("node:crypto");
+var import_node_crypto8 = require("node:crypto");
 var DESCRIPTION24 = `
 \u521B\u5EFA\u90E8\u95E8\u6210\u5458\u3002
 
@@ -42995,7 +43307,7 @@ var departmentMemberCreate = {
       }
     }
     let departmentMember = {
-      id: (0, import_node_crypto7.randomUUID)().slice(0, 8),
+      id: (0, import_node_crypto8.randomUUID)().slice(0, 8),
       name,
       departmentId: department.id,
       mailBoxId: getMailBoxId(department.name, name),
@@ -43186,7 +43498,7 @@ ${replies}`;
 // src/department/learning.ts
 var import_node_fs4 = require("node:fs");
 var import_node_path12 = __toESM(require("node:path"));
-var import_node_crypto8 = require("node:crypto");
+var import_node_crypto9 = require("node:crypto");
 
 // src/skill/SkillValidator.ts
 var import_node_fs3 = require("node:fs");
@@ -43424,7 +43736,7 @@ var listDepartmentMemories = (departmentName) => {
 var createDepartmentMemory = (departmentName, input) => {
   const now = Date.now();
   const memory = {
-    id: (0, import_node_crypto8.randomUUID)().slice(0, 8),
+    id: (0, import_node_crypto9.randomUUID)().slice(0, 8),
     departmentName,
     title: input.title,
     content: input.content,
@@ -43475,7 +43787,7 @@ ${formatSkillValidationIssues(validation)}`);
   }
   const now = Date.now();
   const skill = {
-    id: (0, import_node_crypto8.randomUUID)().slice(0, 8),
+    id: (0, import_node_crypto9.randomUUID)().slice(0, 8),
     departmentName,
     skillName: input.skillName,
     description: input.description,
@@ -43527,7 +43839,7 @@ var createDepartmentProposal = (input) => {
   const records = readJsonArray(proposalsPath());
   const proposal = {
     ...input,
-    id: (0, import_node_crypto8.randomUUID)().slice(0, 8),
+    id: (0, import_node_crypto9.randomUUID)().slice(0, 8),
     status: "pending",
     createdAt: Date.now()
   };
@@ -43862,7 +44174,7 @@ var mailboxFollowup = {
 
 // src/tools/tools/Bash.ts
 var import_node_child_process = require("node:child_process");
-var import_node_crypto9 = require("node:crypto");
+var import_node_crypto10 = require("node:crypto");
 var import_node_fs5 = require("node:fs");
 var DESCRIPTION29 = `\u5728\u7CFB\u7EDF shell \u4E2D\u6267\u884C\u547D\u4EE4\u3002
 
@@ -44066,7 +44378,7 @@ var bashTool = {
         ...options,
         stdio: ["pipe", "pipe", "pipe"]
       });
-      const id = (0, import_node_crypto9.randomUUID)().slice(0, 8);
+      const id = (0, import_node_crypto10.randomUUID)().slice(0, 8);
       const session = {
         id,
         command,
@@ -44647,7 +44959,7 @@ var readDreamHistoryLimit = () => {
 var import_node_fs6 = require("node:fs");
 var import_node_os2 = require("node:os");
 var import_node_path13 = require("node:path");
-var import_node_crypto10 = require("node:crypto");
+var import_node_crypto11 = require("node:crypto");
 var SkillForgeEngine = class {
   proposalStorage;
   draftRoot;
@@ -44681,7 +44993,7 @@ ${formatSkillValidationIssues(validation)}`);
     if (pending.some((p) => p.skillName === skillName)) {
       return null;
     }
-    const id = (0, import_node_crypto10.randomBytes)(4).toString("hex");
+    const id = (0, import_node_crypto11.randomBytes)(4).toString("hex");
     const draftDir = (0, import_node_path13.join)(this.draftRoot, userId, id);
     (0, import_node_fs6.mkdirSync)(draftDir, { recursive: true });
     (0, import_node_fs6.writeFileSync)((0, import_node_path13.join)(draftDir, "SKILL.md"), skillMd, "utf-8");
@@ -44963,7 +45275,7 @@ var skillForgeDrop = (engine) => ({
 });
 
 // src/memory/MemoryEngine.ts
-var import_node_crypto11 = require("node:crypto");
+var import_node_crypto12 = require("node:crypto");
 var MemoryEngine = class {
   storage;
   recallIndexStorage;
@@ -44991,7 +45303,7 @@ var MemoryEngine = class {
     }
     const now = Date.now();
     const memory = {
-      id: (0, import_node_crypto11.randomBytes)(4).toString("hex"),
+      id: (0, import_node_crypto12.randomBytes)(4).toString("hex"),
       userId,
       title,
       content,
@@ -45643,13 +45955,13 @@ var COMPANY_VALUES_PROMPT = `<\u516C\u53F8\u5171\u540C\u4FE1\u5FF5>
 </\u516C\u53F8\u5171\u540C\u4FE1\u5FF5>`;
 
 // src/agent/outboundDedup.ts
-var import_node_crypto12 = require("node:crypto");
+var import_node_crypto13 = require("node:crypto");
 var DEFAULT_WINDOW_MS = 15e3;
 var recentSends = /* @__PURE__ */ new Map();
 var lastSweepAt = 0;
 var normalize3 = (text2) => text2.replace(/\s+/g, " ").trim();
 var keyFor = (userId, normalized) => {
-  const hash = (0, import_node_crypto12.createHash)("sha1").update(normalized).digest("hex");
+  const hash = (0, import_node_crypto13.createHash)("sha1").update(normalized).digest("hex");
   return `${userId}::${hash}`;
 };
 var sweep = (now, windowMs) => {
@@ -45687,7 +45999,7 @@ var isAbortError2 = (error) => {
   return error.name === "AbortError" || error.message.includes("aborted") || error.message.includes("AbortError");
 };
 var llmRequestIdForTurn = (request, messages, system, tools) => {
-  const hash = (0, import_node_crypto13.createHash)("sha256").update(request.requestId).update("\0").update(system).update("\0").update(JSON.stringify(messages)).update("\0").update(JSON.stringify(tools.map((tool) => tool.name).sort())).digest("hex").slice(0, 40);
+  const hash = (0, import_node_crypto14.createHash)("sha256").update(request.requestId).update("\0").update(system).update("\0").update(JSON.stringify(messages)).update("\0").update(JSON.stringify(tools.map((tool) => tool.name).sort())).digest("hex").slice(0, 40);
   return `dreq_${hash}`;
 };
 var getDefaultAgentConfig = (tools, systemPrompt) => {
@@ -46280,7 +46592,8 @@ ${memoryInjection}` : "") + dreamInjection;
                           cfg: {},
                           to: userId2,
                           text: answer,
-                          accountId: request.requestId
+                          accountId: request.requestId,
+                          metadata: request.metadata
                         });
                       } else {
                         console.log(`[outbound-dedup] \u8DF3\u8FC7\u5BF9\u7528\u6237 ${userId2} \u7684\u8FD1\u91CD\u590D\u53D1\u9001\uFF08\u5355\u4E00\u58F0\u97F3\u515C\u5E95\uFF09`);
@@ -46366,7 +46679,8 @@ ${msg}</user-interrupt>`
                 cfg: {},
                 to: request.userId,
                 text: textContent2,
-                accountId: request.requestId
+                accountId: request.requestId,
+                metadata: request.metadata
               });
             } else {
               console.log(`[outbound-dedup] \u8DF3\u8FC7\u5BF9\u7528\u6237 ${request.userId} \u7684\u8FD1\u91CD\u590D\u515C\u5E95\u53D1\u9001`);
@@ -47317,6 +47631,9 @@ var handleCeoFollowupGroup = async (followups) => {
     }
   };
   const config2 = getDefaultAgentConfig();
+  if (originPlatform === "ios") {
+    config2.channelPlugin = mobileChannelPlugin;
+  }
   const mainAgent = createAgent(config2);
   const result = await mainAgent(request);
   console.log(`[mailbox] \u4E3B agent \u5904\u7406\u5B8C ${followups.length} \u5C01\u56DE\u4FE1, user=${originUserId}, alreadySent=${result.alreadySent}`);
@@ -47870,26 +48187,26 @@ var handleParsingNestedValues = (form, key, value) => {
 };
 
 // node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/utils/url.js
-var splitPath = (path19) => {
-  const paths = path19.split("/");
+var splitPath = (path20) => {
+  const paths = path20.split("/");
   if (paths[0] === "") {
     paths.shift();
   }
   return paths;
 };
 var splitRoutingPath = (routePath) => {
-  const { groups, path: path19 } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path19);
+  const { groups, path: path20 } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path20);
   return replaceGroupMarks(paths, groups);
 };
-var extractGroupsFromPath = (path19) => {
+var extractGroupsFromPath = (path20) => {
   const groups = [];
-  path19 = path19.replace(/\{[^}]+\}/g, (match2, index) => {
+  path20 = path20.replace(/\{[^}]+\}/g, (match2, index) => {
     const mark = `@${index}`;
     groups.push([mark, match2]);
     return mark;
   });
-  return { groups, path: path19 };
+  return { groups, path: path20 };
 };
 var replaceGroupMarks = (paths, groups) => {
   for (let i = groups.length - 1; i >= 0; i--) {
@@ -47946,8 +48263,8 @@ var getPath = (request) => {
       const queryIndex = url.indexOf("?", i);
       const hashIndex = url.indexOf("#", i);
       const end = queryIndex === -1 ? hashIndex === -1 ? void 0 : hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
-      const path19 = url.slice(start, end);
-      return tryDecodeURI(path19.includes("%25") ? path19.replace(/%25/g, "%2525") : path19);
+      const path20 = url.slice(start, end);
+      return tryDecodeURI(path20.includes("%25") ? path20.replace(/%25/g, "%2525") : path20);
     } else if (charCode === 63 || charCode === 35) {
       break;
     }
@@ -47964,11 +48281,11 @@ var mergePath = (base, sub, ...rest) => {
   }
   return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
 };
-var checkOptionalParameter = (path19) => {
-  if (path19.charCodeAt(path19.length - 1) !== 63 || !path19.includes(":")) {
+var checkOptionalParameter = (path20) => {
+  if (path20.charCodeAt(path20.length - 1) !== 63 || !path20.includes(":")) {
     return null;
   }
-  const segments = path19.split("/");
+  const segments = path20.split("/");
   const results = [];
   let basePath = "";
   segments.forEach((segment) => {
@@ -48109,9 +48426,9 @@ var HonoRequest = class {
    */
   path;
   bodyCache = {};
-  constructor(request, path19 = "/", matchResult = [[]]) {
+  constructor(request, path20 = "/", matchResult = [[]]) {
     this.raw = request;
-    this.path = path19;
+    this.path = path20;
     this.#matchResult = matchResult;
     this.#validatedData = {};
   }
@@ -48848,8 +49165,8 @@ var Hono = class _Hono {
         return this;
       };
     });
-    this.on = (method, path19, ...handlers) => {
-      for (const p of [path19].flat()) {
+    this.on = (method, path20, ...handlers) => {
+      for (const p of [path20].flat()) {
         this.#path = p;
         for (const m of [method].flat()) {
           handlers.map((handler) => {
@@ -48906,8 +49223,8 @@ var Hono = class _Hono {
    * app.route("/api", app2) // GET /api/user
    * ```
    */
-  route(path19, app) {
-    const subApp = this.basePath(path19);
+  route(path20, app) {
+    const subApp = this.basePath(path20);
     app.routes.map((r) => {
       let handler;
       if (app.errorHandler === errorHandler) {
@@ -48933,9 +49250,9 @@ var Hono = class _Hono {
    * const api = new Hono().basePath('/api')
    * ```
    */
-  basePath(path19) {
+  basePath(path20) {
     const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path19);
+    subApp._basePath = mergePath(this._basePath, path20);
     return subApp;
   }
   /**
@@ -49009,7 +49326,7 @@ var Hono = class _Hono {
    * })
    * ```
    */
-  mount(path19, applicationHandler, options) {
+  mount(path20, applicationHandler, options) {
     let replaceRequest;
     let optionHandler;
     if (options) {
@@ -49036,7 +49353,7 @@ var Hono = class _Hono {
       return [c.env, executionContext];
     };
     replaceRequest ||= (() => {
-      const mergedPath = mergePath(this._basePath, path19);
+      const mergedPath = mergePath(this._basePath, path20);
       const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
       return (request) => {
         const url = new URL(request.url);
@@ -49051,14 +49368,14 @@ var Hono = class _Hono {
       }
       await next();
     };
-    this.#addRoute(METHOD_NAME_ALL, mergePath(path19, "*"), handler);
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path20, "*"), handler);
     return this;
   }
-  #addRoute(method, path19, handler) {
+  #addRoute(method, path20, handler) {
     method = method.toUpperCase();
-    path19 = mergePath(this._basePath, path19);
-    const r = { basePath: this._basePath, path: path19, method, handler };
-    this.router.add(method, path19, [handler, r]);
+    path20 = mergePath(this._basePath, path20);
+    const r = { basePath: this._basePath, path: path20, method, handler };
+    this.router.add(method, path20, [handler, r]);
     this.routes.push(r);
   }
   #handleError(err, c) {
@@ -49071,10 +49388,10 @@ var Hono = class _Hono {
     if (method === "HEAD") {
       return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
     }
-    const path19 = this.getPath(request, { env });
-    const matchResult = this.router.match(method, path19);
+    const path20 = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path20);
     const c = new Context(request, {
-      path: path19,
+      path: path20,
       matchResult,
       env,
       executionCtx,
@@ -49174,7 +49491,7 @@ var Hono = class _Hono {
 
 // node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/router/reg-exp-router/matcher.js
 var emptyParam = [];
-function match(method, path19) {
+function match(method, path20) {
   const matchers = this.buildAllMatchers();
   const match2 = ((method2, path22) => {
     const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
@@ -49190,7 +49507,7 @@ function match(method, path19) {
     return [matcher[1][index], match3];
   });
   this.match = match2;
-  return match2(method, path19);
+  return match2(method, path20);
 }
 
 // node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/router/reg-exp-router/node.js
@@ -49305,12 +49622,12 @@ var Node = class _Node {
 var Trie = class {
   #context = { varIndex: 0 };
   #root = new Node();
-  insert(path19, index, pathErrorCheckOnly) {
+  insert(path20, index, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];
     for (let i = 0; ; ) {
       let replaced = false;
-      path19 = path19.replace(/\{[^}]+\}/g, (m) => {
+      path20 = path20.replace(/\{[^}]+\}/g, (m) => {
         const mark = `@\\${i}`;
         groups[i] = [mark, m];
         i++;
@@ -49321,7 +49638,7 @@ var Trie = class {
         break;
       }
     }
-    const tokens = path19.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    const tokens = path20.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
     for (let i = groups.length - 1; i >= 0; i--) {
       const [mark] = groups[i];
       for (let j = tokens.length - 1; j >= 0; j--) {
@@ -49360,9 +49677,9 @@ var Trie = class {
 // node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/router/reg-exp-router/router.js
 var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
 var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
-function buildWildcardRegExp(path19) {
-  return wildcardRegExpCache[path19] ??= new RegExp(
-    path19 === "*" ? "" : `^${path19.replace(
+function buildWildcardRegExp(path20) {
+  return wildcardRegExpCache[path20] ??= new RegExp(
+    path20 === "*" ? "" : `^${path20.replace(
       /\/\*$|([.\\+*[^\]$()])/g,
       (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
     )}$`
@@ -49384,17 +49701,17 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   );
   const staticMap = /* @__PURE__ */ Object.create(null);
   for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
-    const [pathErrorCheckOnly, path19, handlers] = routesWithStaticPathFlag[i];
+    const [pathErrorCheckOnly, path20, handlers] = routesWithStaticPathFlag[i];
     if (pathErrorCheckOnly) {
-      staticMap[path19] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+      staticMap[path20] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
     } else {
       j++;
     }
     let paramAssoc;
     try {
-      paramAssoc = trie.insert(path19, j, pathErrorCheckOnly);
+      paramAssoc = trie.insert(path20, j, pathErrorCheckOnly);
     } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path19) : e;
+      throw e === PATH_ERROR ? new UnsupportedPathError(path20) : e;
     }
     if (pathErrorCheckOnly) {
       continue;
@@ -49428,12 +49745,12 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   }
   return [regexp, handlerMap, staticMap];
 }
-function findMiddleware(middleware, path19) {
+function findMiddleware(middleware, path20) {
   if (!middleware) {
     return void 0;
   }
   for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-    if (buildWildcardRegExp(k).test(path19)) {
+    if (buildWildcardRegExp(k).test(path20)) {
       return [...middleware[k]];
     }
   }
@@ -49447,7 +49764,7 @@ var RegExpRouter = class {
     this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
     this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
   }
-  add(method, path19, handler) {
+  add(method, path20, handler) {
     const middleware = this.#middleware;
     const routes = this.#routes;
     if (!middleware || !routes) {
@@ -49462,18 +49779,18 @@ var RegExpRouter = class {
         });
       });
     }
-    if (path19 === "/*") {
-      path19 = "*";
+    if (path20 === "/*") {
+      path20 = "*";
     }
-    const paramCount = (path19.match(/\/:/g) || []).length;
-    if (/\*$/.test(path19)) {
-      const re = buildWildcardRegExp(path19);
+    const paramCount = (path20.match(/\/:/g) || []).length;
+    if (/\*$/.test(path20)) {
+      const re = buildWildcardRegExp(path20);
       if (method === METHOD_NAME_ALL) {
         Object.keys(middleware).forEach((m) => {
-          middleware[m][path19] ||= findMiddleware(middleware[m], path19) || findMiddleware(middleware[METHOD_NAME_ALL], path19) || [];
+          middleware[m][path20] ||= findMiddleware(middleware[m], path20) || findMiddleware(middleware[METHOD_NAME_ALL], path20) || [];
         });
       } else {
-        middleware[method][path19] ||= findMiddleware(middleware[method], path19) || findMiddleware(middleware[METHOD_NAME_ALL], path19) || [];
+        middleware[method][path20] ||= findMiddleware(middleware[method], path20) || findMiddleware(middleware[METHOD_NAME_ALL], path20) || [];
       }
       Object.keys(middleware).forEach((m) => {
         if (method === METHOD_NAME_ALL || method === m) {
@@ -49491,7 +49808,7 @@ var RegExpRouter = class {
       });
       return;
     }
-    const paths = checkOptionalParameter(path19) || [path19];
+    const paths = checkOptionalParameter(path20) || [path20];
     for (let i = 0, len = paths.length; i < len; i++) {
       const path22 = paths[i];
       Object.keys(routes).forEach((m) => {
@@ -49518,13 +49835,13 @@ var RegExpRouter = class {
     const routes = [];
     let hasOwnRoute = method === METHOD_NAME_ALL;
     [this.#middleware, this.#routes].forEach((r) => {
-      const ownRoute = r[method] ? Object.keys(r[method]).map((path19) => [path19, r[method][path19]]) : [];
+      const ownRoute = r[method] ? Object.keys(r[method]).map((path20) => [path20, r[method][path20]]) : [];
       if (ownRoute.length !== 0) {
         hasOwnRoute ||= true;
         routes.push(...ownRoute);
       } else if (method !== METHOD_NAME_ALL) {
         routes.push(
-          ...Object.keys(r[METHOD_NAME_ALL]).map((path19) => [path19, r[METHOD_NAME_ALL][path19]])
+          ...Object.keys(r[METHOD_NAME_ALL]).map((path20) => [path20, r[METHOD_NAME_ALL][path20]])
         );
       }
     });
@@ -49544,13 +49861,13 @@ var SmartRouter = class {
   constructor(init) {
     this.#routers = init.routers;
   }
-  add(method, path19, handler) {
+  add(method, path20, handler) {
     if (!this.#routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.#routes.push([method, path19, handler]);
+    this.#routes.push([method, path20, handler]);
   }
-  match(method, path19) {
+  match(method, path20) {
     if (!this.#routes) {
       throw new Error("Fatal error");
     }
@@ -49565,7 +49882,7 @@ var SmartRouter = class {
         for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) {
           router.add(...routes[i2]);
         }
-        res = router.match(method, path19);
+        res = router.match(method, path20);
       } catch (e) {
         if (e instanceof UnsupportedPathError) {
           continue;
@@ -49615,10 +49932,10 @@ var Node2 = class _Node2 {
     }
     this.#patterns = [];
   }
-  insert(method, path19, handler) {
+  insert(method, path20, handler) {
     this.#order = ++this.#order;
     let curNode = this;
-    const parts = splitRoutingPath(path19);
+    const parts = splitRoutingPath(path20);
     const possibleKeys = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const p = parts[i];
@@ -49667,12 +49984,12 @@ var Node2 = class _Node2 {
       }
     }
   }
-  search(method, path19) {
+  search(method, path20) {
     const handlerSets = [];
     this.#params = emptyParams;
     const curNode = this;
     let curNodes = [curNode];
-    const parts = splitPath(path19);
+    const parts = splitPath(path20);
     const curNodesQueue = [];
     const len = parts.length;
     let partOffsets = null;
@@ -49714,13 +50031,13 @@ var Node2 = class _Node2 {
           if (matcher instanceof RegExp) {
             if (partOffsets === null) {
               partOffsets = new Array(len);
-              let offset = path19[0] === "/" ? 1 : 0;
+              let offset = path20[0] === "/" ? 1 : 0;
               for (let p = 0; p < len; p++) {
                 partOffsets[p] = offset;
                 offset += parts[p].length + 1;
               }
             }
-            const restPathString = path19.substring(partOffsets[i]);
+            const restPathString = path20.substring(partOffsets[i]);
             const m = matcher.exec(restPathString);
             if (m) {
               params[name] = m[0];
@@ -49773,18 +50090,18 @@ var TrieRouter = class {
   constructor() {
     this.#node = new Node2();
   }
-  add(method, path19, handler) {
-    const results = checkOptionalParameter(path19);
+  add(method, path20, handler) {
+    const results = checkOptionalParameter(path20);
     if (results) {
       for (let i = 0, len = results.length; i < len; i++) {
         this.#node.insert(method, results[i], handler);
       }
       return;
     }
-    this.#node.insert(method, path19, handler);
+    this.#node.insert(method, path20, handler);
   }
-  match(method, path19) {
-    return this.#node.search(method, path19);
+  match(method, path20) {
+    return this.#node.search(method, path20);
   }
 };
 
@@ -50486,10 +50803,10 @@ var createStreamBody = (stream) => {
   });
   return body;
 };
-var getStats = (path19) => {
+var getStats = (path20) => {
   let stats;
   try {
-    stats = (0, import_fs15.statSync)(path19);
+    stats = (0, import_fs15.statSync)(path20);
   } catch {
   }
   return stats;
@@ -50532,21 +50849,21 @@ var serveStatic = (options = { root: "" }) => {
         return next();
       }
     }
-    let path19 = (0, import_path20.join)(
+    let path20 = (0, import_path20.join)(
       root,
       !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename, c) : filename
     );
-    let stats = getStats(path19);
+    let stats = getStats(path20);
     if (stats && stats.isDirectory()) {
       const indexFile = options.index ?? "index.html";
-      path19 = (0, import_path20.join)(path19, indexFile);
-      stats = getStats(path19);
+      path20 = (0, import_path20.join)(path20, indexFile);
+      stats = getStats(path20);
     }
     if (!stats) {
-      await options.onNotFound?.(path19, c);
+      await options.onNotFound?.(path20, c);
       return next();
     }
-    const mimeType = getMimeType(path19);
+    const mimeType = getMimeType(path20);
     c.header("Content-Type", mimeType || "application/octet-stream");
     if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
       const acceptEncodingSet = new Set(
@@ -50556,12 +50873,12 @@ var serveStatic = (options = { root: "" }) => {
         if (!acceptEncodingSet.has(encoding)) {
           continue;
         }
-        const precompressedStats = getStats(path19 + ENCODINGS[encoding]);
+        const precompressedStats = getStats(path20 + ENCODINGS[encoding]);
         if (precompressedStats) {
           c.header("Content-Encoding", encoding);
           c.header("Vary", "Accept-Encoding", { append: true });
           stats = precompressedStats;
-          path19 = path19 + ENCODINGS[encoding];
+          path20 = path20 + ENCODINGS[encoding];
           break;
         }
       }
@@ -50575,7 +50892,7 @@ var serveStatic = (options = { root: "" }) => {
       result = c.body(null);
     } else if (!range) {
       c.header("Content-Length", size.toString());
-      result = c.body(createStreamBody((0, import_fs15.createReadStream)(path19)), 200);
+      result = c.body(createStreamBody((0, import_fs15.createReadStream)(path20)), 200);
     } else {
       c.header("Accept-Ranges", "bytes");
       c.header("Date", stats.birthtime.toUTCString());
@@ -50586,12 +50903,12 @@ var serveStatic = (options = { root: "" }) => {
         end = size - 1;
       }
       const chunksize = end - start + 1;
-      const stream = (0, import_fs15.createReadStream)(path19, { start, end });
+      const stream = (0, import_fs15.createReadStream)(path20, { start, end });
       c.header("Content-Length", chunksize.toString());
       c.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
       result = c.body(createStreamBody(stream), 206);
     }
-    await options.onFound?.(path19, c);
+    await options.onFound?.(path20, c);
     return result;
   };
 };
@@ -50685,8 +51002,8 @@ var cors = (options) => {
 };
 
 // src/server/index.ts
-var import_promises11 = require("node:fs/promises");
-var import_node_path15 = __toESM(require("node:path"));
+var import_promises12 = require("node:fs/promises");
+var import_node_path16 = __toESM(require("node:path"));
 
 // src/git/worktree.ts
 var import_child_process2 = require("child_process");
@@ -52645,13 +52962,323 @@ var systemRoutes = new Hono2();
 var startTime = Date.now();
 systemRoutes.get("/system/info", (c) => {
   return c.json({
-    version: true ? "1.8.47" : "unknown",
+    version: true ? "1.8.48" : "unknown",
     uptime: Math.floor((Date.now() - startTime) / 1e3),
     env: process.env.NODE_ENV || "development",
     nodeVersion: process.version
   });
 });
 
+// src/server/routes/mobile.ts
+var import_node_crypto15 = require("node:crypto");
+var import_promises11 = require("node:fs/promises");
+var import_node_path15 = __toESM(require("node:path"));
+var mobileRoutes = new Hono2();
+var resolveMobileUserId = (body, headerUserId) => {
+  return body.userId?.trim() || headerUserId?.trim() || "ios:local-user";
+};
+var resolveThreadId = (goalId, mobileUserId) => {
+  if (!goalId) return `ios:user:${mobileUserId}`;
+  const existing = getGoalConversationContext(goalId);
+  if (existing?.originPlatform === "ios" && existing.threadId) return existing.threadId;
+  const threadId = `ios:goal:${goalId}`;
+  ensureGoalConversationContext(goalId, {
+    threadId,
+    originPlatform: "ios",
+    originUserId: threadId,
+    syncReplyToOrigin: false
+  });
+  return threadId;
+};
+var buildGoalPrompt = (goalId, text2) => {
+  if (!goalId) return text2;
+  const goal = getGoalById(goalId);
+  if (!goal) return text2;
+  const lines = [
+    `\u4F60\u73B0\u5728\u5728\u56F4\u7ED5\u4E00\u4E2A iOS App \u4E2D\u7684\u201C\u9700\u6C42\u201D\u7EE7\u7EED\u5BF9\u8BDD\u3002`,
+    ``,
+    `\u3010\u5F53\u524D\u9700\u6C42\u3011${goal.subject}`,
+    goal.description ? `\u3010\u539F\u59CB\u9700\u6C42\u63CF\u8FF0\u3011${goal.description}` : void 0,
+    goal.summary ? `\u3010\u5F53\u524D\u6458\u8981\u3011${goal.summary}` : void 0,
+    goal.currentFocus ? `\u3010\u5F53\u524D\u91CD\u70B9\u3011${goal.currentFocus}` : void 0,
+    goal.nextAction ? `\u3010\u4E0B\u4E00\u6B65\u3011${goal.nextAction}` : void 0,
+    goal.blockers?.length ? `\u3010\u963B\u585E\u9879\u3011${goal.blockers.join("\uFF1B")}` : void 0,
+    goal.tasks.length > 0 ? `
+\u3010\u5F53\u524D\u4EFB\u52A1\u5217\u8868\u3011
+${goal.tasks.map((task) => `- [${task.status}] ${task.subject}`).join("\n")}` : void 0,
+    ``,
+    `\u8BF7\u57FA\u4E8E\u6574\u4E2A\u9700\u6C42\u4E0A\u4E0B\u6587\u56DE\u7B54\u7528\u6237\u3002`,
+    ``,
+    `\u7528\u6237\u6D88\u606F\uFF1A${text2}`
+  ].filter((line) => typeof line === "string");
+  return lines.join("\n");
+};
+var sanitizeFileName = (fileName) => {
+  const cleaned = import_node_path15.default.basename(fileName).replace(/[^\w.\-()\u4e00-\u9fa5 ]+/g, "_").trim();
+  return cleaned || `attachment-${Date.now()}`;
+};
+var inferAttachmentType = (mimeType = "", fileName = "") => {
+  if (mimeType.startsWith("image/")) return "image";
+  const ext = import_node_path15.default.extname(fileName).toLowerCase();
+  if ([".png", ".jpg", ".jpeg", ".gif", ".webp"].includes(ext)) return "image";
+  return "file";
+};
+var resolveAttachments = (attachments) => {
+  return attachments.map((attachment) => getMobileAttachment(attachment.id) ?? attachment);
+};
+var buildContentWithAttachments = (text2, attachments) => {
+  const imageAttachments = attachments.filter((attachment) => attachment.type === "image");
+  const fileAttachments = attachments.filter((attachment) => attachment.type !== "image");
+  const metadata = {
+    attachments
+  };
+  const lines = [];
+  if (text2.trim()) lines.push(text2.trim());
+  if (imageAttachments.length > 0) {
+    const primaryImage = imageAttachments[0];
+    const imageSource = primaryImage.url || primaryImage.path;
+    if (imageSource) {
+      metadata.imageUrl = imageSource;
+      metadata.imageKey = primaryImage.id;
+      metadata.imageKeys = imageAttachments.map((attachment) => attachment.id);
+    }
+    const reminder = imageAttachments.length > 1 ? `\u63A5\u6536\u5230\u7528\u6237\u901A\u8FC7 iOS App \u53D1\u6765\u7684${imageAttachments.length}\u5F20\u56FE\u7247,\u5F53\u524D\u5DF2\u5C06\u7B2C1\u5F20\u56FE\u7247\u5B58\u50A8\u5728\u4E0A\u4E0B\u6587\u4E2D,\u8BF7\u7ED3\u5408\u7528\u6237\u6587\u5B57\u4F18\u5148\u5206\u6790\u8FD9\u5F20\u56FE\u7247(\u4E0D\u9700\u8981\u4F20image_url\u53C2\u6570,\u5DE5\u5177\u4F1A\u81EA\u52A8\u83B7\u53D6\u56FE\u7247)` : `\u63A5\u6536\u5230\u7528\u6237\u901A\u8FC7 iOS App \u53D1\u6765\u7684\u56FE\u7247,\u56FE\u7247\u5DF2\u5B58\u50A8\u5728\u4E0A\u4E0B\u6587\u4E2D,\u8BF7\u4F7F\u7528image_understand\u5DE5\u5177\u5206\u6790\u56FE\u7247(\u4E0D\u9700\u8981\u4F20image_url\u53C2\u6570,\u5DE5\u5177\u4F1A\u81EA\u52A8\u83B7\u53D6\u56FE\u7247)`;
+    lines.push(`<system-reminder>${reminder}</system-reminder>`);
+  }
+  if (fileAttachments.length > 0) {
+    const primaryFile = fileAttachments[0];
+    metadata.fileUrl = primaryFile.url || primaryFile.path;
+    metadata.fileName = primaryFile.name;
+    lines.push([
+      `\u7528\u6237\u901A\u8FC7 iOS App \u53D1\u9001\u4E86${fileAttachments.length > 1 ? `${fileAttachments.length}\u4E2A\u6587\u4EF6` : "\u4E00\u4E2A\u6587\u4EF6"}\u3002`,
+      ...fileAttachments.map((attachment) => {
+        const location = attachment.url || attachment.path || attachment.id;
+        return `\u6587\u4EF6\u540D: ${attachment.name ?? attachment.id}
+\u6587\u4EF6\u4F4D\u7F6E: ${location}`;
+      })
+    ].join("\n"));
+  }
+  if (lines.length === 0) {
+    lines.push("\u7528\u6237\u901A\u8FC7 iOS App \u53D1\u9001\u4E86\u9644\u4EF6\u3002");
+  }
+  return {
+    content: lines.join("\n\n"),
+    metadata
+  };
+};
+mobileRoutes.post("/mobile/attachments", async (c) => {
+  const body = await c.req.json();
+  const dataBase64 = body.dataBase64?.trim();
+  if (!dataBase64) return c.json({ error: "dataBase64 is required" }, 400);
+  const mobileUserId = resolveMobileUserId(body, c.req.header("x-user-id"));
+  const fileName = sanitizeFileName(body.fileName || `attachment-${Date.now()}`);
+  const mimeType = body.mimeType || "application/octet-stream";
+  const type = inferAttachmentType(mimeType, fileName);
+  const attachmentId = (0, import_node_crypto15.randomUUID)();
+  const buffer = Buffer.from(dataBase64, "base64");
+  const dir = import_node_path15.default.join(getDuclawWorkspaceDir(), mobileUserId, "mobile", type === "image" ? "images" : "files");
+  await (0, import_promises11.mkdir)(dir, { recursive: true });
+  const localPath = import_node_path15.default.join(dir, `${attachmentId}-${fileName}`);
+  await (0, import_promises11.writeFile)(localPath, buffer);
+  const attachment = saveMobileAttachment({
+    id: attachmentId,
+    type,
+    name: fileName,
+    mimeType,
+    size: buffer.length,
+    path: localPath,
+    url: localPath
+  });
+  return c.json({
+    ok: true,
+    attachment
+  });
+});
+mobileRoutes.post("/mobile/messages", async (c) => {
+  const body = await c.req.json();
+  const text2 = body.text?.trim() ?? "";
+  const attachments = resolveAttachments(body.attachments ?? []);
+  if (!text2 && attachments.length === 0) {
+    return c.json({ error: "text or attachments is required" }, 400);
+  }
+  if (body.goalId && !getGoalById(body.goalId)) {
+    return c.json({ error: "Goal not found" }, 404);
+  }
+  const mobileUserId = resolveMobileUserId(body, c.req.header("x-user-id"));
+  const threadId = resolveThreadId(body.goalId, mobileUserId);
+  const requestId = body.clientMessageId?.trim() || (0, import_node_crypto15.randomUUID)();
+  const agentText = body.contextText?.trim() || text2;
+  const attachmentContent = buildContentWithAttachments(agentText, attachments);
+  const content = buildGoalPrompt(body.goalId, attachmentContent.content);
+  const teamMetadata = {
+    ...body.teamId?.trim() ? { teamId: body.teamId.trim() } : {},
+    ...body.teamName?.trim() ? { teamName: body.teamName.trim() } : {}
+  };
+  const userMessage2 = appendMobileMessage({
+    threadId,
+    userId: mobileUserId,
+    goalId: body.goalId,
+    clientMessageId: requestId,
+    role: "user",
+    text: text2,
+    attachments,
+    status: "accepted",
+    metadata: {
+      ...teamMetadata,
+      source: "ios"
+    }
+  });
+  if (hasRunningAgent(threadId)) {
+    queueInterrupt(threadId, {
+      content,
+      metadata: {
+        platform: "ios",
+        goalId: body.goalId,
+        ...teamMetadata,
+        clientMessageId: requestId,
+        attachments,
+        ...attachmentContent.metadata
+      }
+    });
+    appendMobileRunLog(threadId, `[\u4E2D\u65AD] \u7528\u6237\u8865\u5145: ${text2.slice(0, 160)}`);
+    const run = upsertMobileRun(threadId, {
+      userId: mobileUserId,
+      goalId: body.goalId,
+      running: true,
+      interrupted: true
+    });
+    appendMobileMessage({
+      threadId,
+      userId: mobileUserId,
+      goalId: body.goalId,
+      role: "system",
+      text: "\u5DF2\u8865\u5145\u7ED9\u6B63\u5728\u5904\u7406\u7684 CEO\u3002",
+      status: "accepted",
+      metadata: {
+        source: "interrupt-ack",
+        ...teamMetadata,
+        clientMessageId: requestId
+      }
+    });
+    return c.json({
+      ok: true,
+      accepted: true,
+      interrupted: true,
+      threadId,
+      message: userMessage2,
+      run
+    }, 202);
+  }
+  const config2 = getDefaultAgentConfig();
+  config2.channelPlugin = mobileChannelPlugin;
+  const agent = createAgent(config2);
+  const request = {
+    platform: "ios",
+    userId: threadId,
+    requestId,
+    departmentAgentId: "",
+    content,
+    metadata: {
+      goalId: body.goalId,
+      mobileUserId,
+      ...teamMetadata,
+      ...attachmentContent.metadata,
+      clientMessageId: requestId,
+      device: "ios"
+    }
+  };
+  markRunning(threadId);
+  upsertMobileRun(threadId, {
+    userId: mobileUserId,
+    goalId: body.goalId,
+    running: true,
+    interrupted: false,
+    logs: ["[\u5F00\u59CB] CEO \u5F00\u59CB\u5904\u7406 iOS \u6D88\u606F"],
+    error: void 0
+  });
+  void agent(request).then((result) => {
+    if (!result.alreadySent && result.content) {
+      appendMobileMessage({
+        threadId,
+        userId: mobileUserId,
+        goalId: body.goalId,
+        role: "assistant",
+        text: result.content,
+        status: "finished",
+        metadata: {
+          ...teamMetadata,
+          source: "agent-result"
+        }
+      });
+    }
+    upsertMobileRun(threadId, {
+      userId: mobileUserId,
+      goalId: body.goalId,
+      running: false,
+      lastResult: result.content,
+      error: void 0
+    });
+    appendMobileRunLog(threadId, `[\u5B8C\u6210] ${result.content.slice(0, 500)}`);
+  }).catch((err) => {
+    appendMobileMessage({
+      threadId,
+      userId: mobileUserId,
+      goalId: body.goalId,
+      role: "system",
+      text: `\u5904\u7406\u5931\u8D25\uFF1A${err.message}`,
+      status: "failed",
+      metadata: {
+        ...teamMetadata,
+        source: "agent-error"
+      }
+    });
+    upsertMobileRun(threadId, {
+      userId: mobileUserId,
+      goalId: body.goalId,
+      running: false,
+      error: err.message
+    });
+    appendMobileRunLog(threadId, `[\u9519\u8BEF] ${err.message}`);
+  });
+  return c.json({
+    ok: true,
+    accepted: true,
+    interrupted: false,
+    threadId,
+    message: userMessage2,
+    run: getMobileRun(threadId)
+  }, 202);
+});
+mobileRoutes.get("/mobile/messages", (c) => {
+  const threadId = c.req.query("threadId");
+  if (!threadId) return c.json({ error: "threadId is required" }, 400);
+  const limit = Number(c.req.query("limit") ?? 20);
+  const before = c.req.query("before") ? Number(c.req.query("before")) : void 0;
+  const page = listMobileMessagesPage(threadId, { limit, before });
+  return c.json({
+    threadId,
+    messages: page.messages,
+    hasMore: page.hasMore,
+    nextBefore: page.nextBefore
+  });
+});
+mobileRoutes.get("/mobile/status", (c) => {
+  const threadId = c.req.query("threadId");
+  if (!threadId) return c.json({ error: "threadId is required" }, 400);
+  return c.json(getMobileRun(threadId));
+});
+mobileRoutes.get("/mobile/threads/:threadId/messages", (c) => {
+  const threadId = c.req.param("threadId");
+  return c.json({
+    threadId,
+    messages: listMobileMessages(threadId)
+  });
+});
+mobileRoutes.get("/mobile/threads/:threadId/status", (c) => {
+  const threadId = c.req.param("threadId");
+  return c.json(getMobileRun(threadId));
+});
+
 // src/server/index.ts
 function createServer() {
   const app = new Hono2();
@@ -52667,9 +53294,10 @@ function createServer() {
   app.route("/api", memoryRoutes);
   app.route("/api", toolRoutes);
   app.route("/api", systemRoutes);
+  app.route("/api", mobileRoutes);
   app.use("/*", serveStatic({ root: webDistRoot }));
   app.get("/*", async (c) => {
-    const indexHtml = await (0, import_promises11.readFile)(import_node_path15.default.join(webDistRoot, "index.html"), "utf8");
+    const indexHtml = await (0, import_promises12.readFile)(import_node_path16.default.join(webDistRoot, "index.html"), "utf8");
     const tenantId = c.req.header("x-tenant-id");
     const assetBase = tenantId ? `/t/${tenantId}` : "";
     const html = indexHtml.replaceAll('"./', `"${assetBase}/`);
@@ -52697,9 +53325,9 @@ function shouldStartCoreChannelGateways(env = process.env) {
 
 // src/runtime/saasAssets.ts
 var import_node_fs9 = require("node:fs");
-var import_promises12 = require("node:fs/promises");
+var import_promises13 = require("node:fs/promises");
 var import_node_os3 = require("node:os");
-var import_node_path16 = __toESM(require("node:path"));
+var import_node_path17 = __toESM(require("node:path"));
 var MAX_CONTEXT_ASSETS = Number(process.env.DUCLAW_SAAS_ASSET_CONTEXT_LIMIT ?? 1e3);
 var MAX_SKILL_ASSETS = Number(process.env.DUCLAW_SAAS_ASSET_SKILL_LIMIT ?? 200);
 async function restoreSaasRuntimeAssets(reason) {
@@ -52730,8 +53358,8 @@ async function restoreContextAsset(context, overwrite) {
   const target = contextPathForSourceKey(context.sourceKey);
   if (!target) return false;
   if (!overwrite && (0, import_node_fs9.existsSync)(target)) return false;
-  await (0, import_promises12.mkdir)(import_node_path16.default.dirname(target), { recursive: true });
-  await (0, import_promises12.writeFile)(target, JSON.stringify(context.payload), "utf8");
+  await (0, import_promises13.mkdir)(import_node_path17.default.dirname(target), { recursive: true });
+  await (0, import_promises13.writeFile)(target, JSON.stringify(context.payload), "utf8");
   return true;
 }
 async function restoreSkillAsset(skill, overwrite) {
@@ -52739,8 +53367,8 @@ async function restoreSkillAsset(skill, overwrite) {
   const target = safeSkillTargetPath(skill.sourcePath, skill.skillName);
   if (!target) return false;
   if (!overwrite && (0, import_node_fs9.existsSync)(target)) return false;
-  await (0, import_promises12.mkdir)(import_node_path16.default.dirname(target), { recursive: true });
-  await (0, import_promises12.writeFile)(target, skill.skillMd, "utf8");
+  await (0, import_promises13.mkdir)(import_node_path17.default.dirname(target), { recursive: true });
+  await (0, import_promises13.writeFile)(target, skill.skillMd, "utf8");
   return true;
 }
 function runtimeAssetClient() {
@@ -52772,30 +53400,30 @@ function runtimeAssetClient() {
 function contextPathForSourceKey(sourceKey) {
   if (sourceKey.startsWith("agent:")) {
     const logicalKey = sourceKey.slice("agent:".length);
-    return import_node_path16.default.join(getDuclawDataDir(), "kv", "agent", `${Buffer.from(logicalKey).toString("base64url")}.json`);
+    return import_node_path17.default.join(getDuclawDataDir(), "kv", "agent", `${Buffer.from(logicalKey).toString("base64url")}.json`);
   }
   if (sourceKey.startsWith("goal-context:")) {
-    return import_node_path16.default.join(getDuclawHomeDir(), "goal-context", `${sourceKey.slice("goal-context:".length)}.json`);
+    return import_node_path17.default.join(getDuclawHomeDir(), "goal-context", `${sourceKey.slice("goal-context:".length)}.json`);
   }
   if (sourceKey.startsWith("tasks:")) {
-    return import_node_path16.default.join(getDuclawHomeDir(), "tasks", `${sourceKey.slice("tasks:".length)}.json`);
+    return import_node_path17.default.join(getDuclawHomeDir(), "tasks", `${sourceKey.slice("tasks:".length)}.json`);
   }
   return null;
 }
 function safeSkillTargetPath(sourcePath, skillName) {
-  const allowedRoots = skillRoots().map((root) => import_node_path16.default.resolve(root));
-  const normalized = import_node_path16.default.resolve(sourcePath);
-  if (allowedRoots.some((root) => normalized === import_node_path16.default.join(root, import_node_path16.default.basename(import_node_path16.default.dirname(normalized)), "SKILL.md"))) {
+  const allowedRoots = skillRoots().map((root) => import_node_path17.default.resolve(root));
+  const normalized = import_node_path17.default.resolve(sourcePath);
+  if (allowedRoots.some((root) => normalized === import_node_path17.default.join(root, import_node_path17.default.basename(import_node_path17.default.dirname(normalized)), "SKILL.md"))) {
     return normalized;
   }
   const safeName = skillName.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 120) || "imported-skill";
-  return import_node_path16.default.join("/home/user/app/skills", safeName, "SKILL.md");
+  return import_node_path17.default.join("/home/user/app/skills", safeName, "SKILL.md");
 }
 function skillRoots() {
   return [
     "/home/user/app/skills",
-    import_node_path16.default.join(getDuclawHomeDir(), "skills"),
-    import_node_path16.default.join((0, import_node_os3.homedir)(), ".agents", "skills")
+    import_node_path17.default.join(getDuclawHomeDir(), "skills"),
+    import_node_path17.default.join((0, import_node_os3.homedir)(), ".agents", "skills")
   ];
 }