@fangyb/ahchat-bridge 0.1.40 → 0.1.42

package/dist/index.js

@@ -3801,7 +3801,7 @@ function ensureDir(dirPath) {
 
 // src/start.ts
 import os15 from "os";
-import path33 from "path";
+import path34 from "path";
 import crypto5 from "crypto";
 
 // ../logger/src/types.ts
@@ -4604,11 +4604,11 @@ var RotatingFileStream = class extends Writable {
   timeout;
   timeoutPromise;
   constructor(generator, options) {
-    const { encoding, history, maxFiles, maxSize, path: path34 } = options;
+    const { encoding, history, maxFiles, maxSize, path: path35 } = options;
     super({ decodeStrings: true, defaultEncoding: encoding });
     this.createGzip = createGzip;
     this.exec = exec;
-    this.filename = path34 + generator(null);
+    this.filename = path35 + generator(null);
     this.fsCreateReadStream = createReadStream;
     this.fsCreateWriteStream = createWriteStream;
     this.fsOpen = open;
@@ -4620,7 +4620,7 @@ var RotatingFileStream = class extends Writable {
     this.options = options;
     this.stdout = process.stdout;
     if (maxFiles || maxSize)
-      options.history = path34 + (history ? history : this.generator(null) + ".txt");
+      options.history = path35 + (history ? history : this.generator(null) + ".txt");
     this.on("close", () => this.finished ? null : this.emit("finish"));
     this.on("finish", () => this.finished = this.clear());
     (async () => {
@@ -4748,9 +4748,9 @@ var RotatingFileStream = class extends Writable {
     return this.move();
   }
   async findName() {
-    const { interval, path: path34, intervalBoundary } = this.options;
+    const { interval, path: path35, intervalBoundary } = this.options;
     for (let index = 1; index < 1e3; ++index) {
-      const filename = path34 + this.generator(interval && intervalBoundary ? new Date(this.prev) : this.rotation, index);
+      const filename = path35 + this.generator(interval && intervalBoundary ? new Date(this.prev) : this.rotation, index);
       if (!await exists(filename))
         return filename;
     }
@@ -4780,11 +4780,11 @@ var RotatingFileStream = class extends Writable {
     return this.unlink(filename);
   }
   async classical() {
-    const { compress, path: path34, rotate } = this.options;
+    const { compress, path: path35, rotate } = this.options;
     let rotatedName = "";
     for (let count = rotate; count > 0; --count) {
-      const currName = path34 + this.generator(count);
-      const prevName = count === 1 ? this.filename : path34 + this.generator(count - 1);
+      const currName = path35 + this.generator(count);
+      const prevName = count === 1 ? this.filename : path35 + this.generator(count - 1);
       if (!await exists(prevName))
         continue;
       if (!rotatedName)
@@ -5908,6 +5908,25 @@ Transform tasks into verifiable goals:
 - "Refactor X" \u2192 ensure tests pass before and after.
 For multi-step tasks, state a brief plan with verification checks.
 `.trim();
+var GROUP_ONLY_SECTION_HEADERS = [
+  "# \u7FA4\u804A\u516C\u7406\uFF08Group Chat Axiom \u2014 \u6700\u9AD8\u4F18\u5148\u7EA7\uFF09",
+  "# Runtime payload \u2014 how to read unread messages",
+  "# Group chat \u2014 when to speak",
+  "# Group chat \u2014 recency & commitment",
+  "# Length & conciseness in group chat",
+  "# Group chat \u2014 shared task board",
+  "# Group chat \u2014 batched inbox handling",
+  "# \u7FA4\u804A\u4EA7\u7269\u7EAA\u5F8B\uFF08What to capture in group chats\uFF09",
+  "# When a user joins or leaves your group"
+];
+function stripGroupOnlySections(full, headers) {
+  const headerSet = new Set(headers);
+  return full.split(/\n(?=# )/).filter((section) => !headerSet.has(section.split("\n", 1)[0].trim())).join("\n").trim();
+}
+var PLATFORM_AGENT_RULES_SINGLE = stripGroupOnlySections(
+  PLATFORM_AGENT_RULES,
+  GROUP_ONLY_SECTION_HEADERS
+);
 var FAN_OUT_TRACE_TTL_MS = 10 * 6e4;
 var MAX_FILE_SIZE = 20 * 1024 * 1024;
 var MAX_IMAGE_SIZE = 10 * 1024 * 1024;
@@ -6057,6 +6076,14 @@ function assertArrayPayloadField(type, payload, field) {
     throw invalidWsMessage(type, field);
   }
 }
+function assertWorkdirSignalsPayloadField(type, payload, field) {
+  assertArrayPayloadField(type, payload, field);
+  for (const [index, item] of payload[field].entries()) {
+    if (!isPlainRecord(item) || typeof item.toolName !== "string") {
+      throw invalidWsMessage(type, `${field}[${index}].toolName`);
+    }
+  }
+}
 function assertRecordPayloadField(type, payload, field) {
   if (!isPlainRecord(payload[field])) {
     throw invalidWsMessage(type, field);
@@ -6137,6 +6164,9 @@ function validateWSMessageShape(msg) {
         "traceId"
       ]);
       assertArrayPayloadField(type, payload, "contentBlocks");
+      if ("workdirSignals" in payload && payload.workdirSignals !== void 0) {
+        assertWorkdirSignalsPayloadField(type, payload, "workdirSignals");
+      }
       return;
     }
     case "agent:turn_complete": {
@@ -8311,14 +8341,14 @@ function agentIdArray(value) {
 function normalizeModelScopeSkill(value) {
   if (!isRecord2(value)) return null;
   const id = stringValue(value.id);
-  const path34 = stringValue(value.path);
+  const path35 = stringValue(value.path);
   const name = stringValue(value.name);
   const displayName = stringValue(value.displayName, name);
   const url2 = stringValue(value.url);
-  if (!id || !path34 || !name || !displayName || !url2) return null;
+  if (!id || !path35 || !name || !displayName || !url2) return null;
   return {
     id,
-    path: path34,
+    path: path35,
     name,
     displayName,
     description: stringValue(value.description),
@@ -8705,9 +8735,9 @@ var AgentMemoryStore = class {
 import { spawn as nodeSpawn } from "child_process";
 import { createHash } from "crypto";
 import fsSync from "fs";
-import fs6 from "fs/promises";
+import fs7 from "fs/promises";
 import os7 from "os";
-import path13 from "path";
+import path14 from "path";
 import * as sdk2 from "@anthropic-ai/claude-agent-sdk";
 
 // src/attachmentText.ts
@@ -9581,6 +9611,8 @@ var HttpMcpAuditClient = class {
 };
 
 // src/neuralMcpServer.ts
+import fs5 from "fs/promises";
+import path10 from "path";
 import * as sdk from "@anthropic-ai/claude-agent-sdk";
 
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
@@ -10349,10 +10381,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path34) {
-  if (!path34)
+function getElementAtPath(obj, path35) {
+  if (!path35)
     return obj;
-  return path34.reduce((acc, key) => acc?.[key], obj);
+  return path35.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -10761,11 +10793,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path34, issues) {
+function prefixIssues(path35, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path34);
+    iss.path.unshift(path35);
     return iss;
   });
 }
@@ -10912,16 +10944,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path34 = []) => {
+  const processError = (error52, path35 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path34, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path35, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path34, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path35, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path34, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path35, ...issue2.path]);
       } else {
-        const fullpath = [...path34, ...issue2.path];
+        const fullpath = [...path35, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -10948,17 +10980,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path34 = []) => {
+  const processError = (error52, path35 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path34, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path35, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path34, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path35, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path34, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path35, ...issue2.path]);
       } else {
-        const fullpath = [...path34, ...issue2.path];
+        const fullpath = [...path35, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -10990,8 +11022,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path34 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path34) {
+  const path35 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path35) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -23683,13 +23715,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path34 = ref.slice(1).split("/").filter(Boolean);
-  if (path34.length === 0) {
+  const path35 = ref.slice(1).split("/").filter(Boolean);
+  if (path35.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path34[0] === defsKey) {
-    const key = path34[1];
+  if (path35[0] === defsKey) {
+    const key = path35[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -24619,6 +24651,138 @@ function normalizeDocumentText(value) {
 var logger9 = createModuleLogger("neural.mcpServer");
 var VIDEO_GENERATION_SKILL_ID = OFFICIAL_MEDIA_SKILL_IDS[0];
 var AUTO_LOCAL_ENHANCER_LIMIT = 2;
+var WORKDIR_ATTACHMENT_MARKER_KIND = "ahchat_workdir_attachment";
+var WORKDIR_FIND_DEFAULT_MAX_RESULTS = 20;
+var WORKDIR_FIND_MAX_RESULTS = 50;
+var WORKDIR_FIND_MAX_SCANNED_FILES = 5e3;
+var WORKDIR_FIND_MAX_DEPTH = 8;
+var WORKDIR_FIND_SKIP_DIRS = /* @__PURE__ */ new Set([
+  ".ahchat-attachments",
+  ".git",
+  ".next",
+  ".turbo",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules"
+]);
+var WORKDIR_FILE_MIME_BY_EXT = {
+  ".csv": "text/csv",
+  ".doc": "application/msword",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".gif": "image/gif",
+  ".htm": "text/html",
+  ".html": "text/html",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".json": "application/json",
+  ".m4a": "audio/mp4",
+  ".md": "text/markdown",
+  ".mp3": "audio/mpeg",
+  ".mp4": "video/mp4",
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".ppt": "application/vnd.ms-powerpoint",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain",
+  ".wav": "audio/wav",
+  ".webm": "video/webm",
+  ".webp": "image/webp",
+  ".xls": "application/vnd.ms-excel",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+};
+function normalizeWorkdirRelativePath(value) {
+  return value.split(path10.sep).join("/");
+}
+function inferWorkdirFileMimeType(filePath) {
+  return WORKDIR_FILE_MIME_BY_EXT[path10.extname(filePath).toLowerCase()] ?? "application/octet-stream";
+}
+function boundedWorkdirResultLimit(value) {
+  if (!Number.isFinite(value)) return WORKDIR_FIND_DEFAULT_MAX_RESULTS;
+  return Math.min(WORKDIR_FIND_MAX_RESULTS, Math.max(1, Math.floor(value)));
+}
+async function resolveWorkdirRoot(cwd) {
+  const rawCwd = (cwd ?? process.cwd()).trim();
+  if (!rawCwd) throw new Error("\u5F53\u524D scope \u6CA1\u6709\u53EF\u7528\u5DE5\u4F5C\u76EE\u5F55\u3002");
+  const resolvedCwd = path10.resolve(rawCwd);
+  const stat3 = await fs5.stat(resolvedCwd).catch(() => null);
+  if (!stat3?.isDirectory()) throw new Error(`\u5DE5\u4F5C\u76EE\u5F55\u4E0D\u53EF\u7528\uFF1A${resolvedCwd}`);
+  return { cwd: resolvedCwd, realCwd: await fs5.realpath(resolvedCwd) };
+}
+async function resolveWorkdirFilePath(requestedPath, cwd) {
+  const trimmed = requestedPath.trim();
+  if (!trimmed) throw new Error("path \u4E0D\u80FD\u4E3A\u7A7A\u3002");
+  const root = await resolveWorkdirRoot(cwd);
+  const candidate = path10.resolve(root.cwd, trimmed);
+  let realTarget;
+  try {
+    realTarget = await fs5.realpath(candidate);
+  } catch {
+    throw new Error(`\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${trimmed}`);
+  }
+  if (!isPathInside(root.realCwd, realTarget)) {
+    throw new Error("\u53EA\u80FD\u8BBF\u95EE\u5F53\u524D scope \u5DE5\u4F5C\u76EE\u5F55\u5185\u7684\u6587\u4EF6\u3002");
+  }
+  const stat3 = await fs5.stat(realTarget);
+  if (!stat3.isFile()) throw new Error(`\u4E0D\u662F\u53EF\u53D1\u9001\u6587\u4EF6\uFF1A${trimmed}`);
+  const relativePath = normalizeWorkdirRelativePath(path10.relative(root.realCwd, realTarget));
+  return {
+    absolutePath: realTarget,
+    fileName: path10.basename(realTarget),
+    relativePath,
+    size: stat3.size,
+    mtimeMs: stat3.mtimeMs
+  };
+}
+function formatWorkdirFileSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+async function findWorkdirFiles(args) {
+  const root = await resolveWorkdirRoot(args.cwd);
+  const needle = args.query?.trim().toLowerCase() ?? "";
+  const limit = boundedWorkdirResultLimit(args.maxResults);
+  const results = [];
+  let scanned = 0;
+  async function walk(dir, depth) {
+    if (results.length >= limit || scanned >= WORKDIR_FIND_MAX_SCANNED_FILES || depth > WORKDIR_FIND_MAX_DEPTH) return;
+    let entries;
+    try {
+      entries = await fs5.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (results.length >= limit || scanned >= WORKDIR_FIND_MAX_SCANNED_FILES) break;
+      if (entry.isDirectory()) {
+        if (!WORKDIR_FIND_SKIP_DIRS.has(entry.name)) {
+          await walk(path10.join(dir, entry.name), depth + 1);
+        }
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      scanned++;
+      const absolutePath = path10.join(dir, entry.name);
+      const relativePath = normalizeWorkdirRelativePath(path10.relative(root.realCwd, absolutePath));
+      if (needle && !relativePath.toLowerCase().includes(needle) && !entry.name.toLowerCase().includes(needle)) {
+        continue;
+      }
+      const stat3 = await fs5.stat(absolutePath).catch(() => null);
+      if (!stat3?.isFile()) continue;
+      results.push({
+        relativePath,
+        fileName: entry.name,
+        size: stat3.size,
+        mtimeMs: stat3.mtimeMs
+      });
+    }
+  }
+  await walk(root.realCwd, 0);
+  return results.sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, limit);
+}
 function formatSkillEntry(entry, index) {
   return [
     `${index + 1}. ${entry.displayName} (${entry.name})`,
@@ -25573,6 +25737,122 @@ ${result.warnings.map((warning) => `- ${warning}`).join("\n")}
     },
     {}
   );
+  const findWorkdirFilesTool = sdk.tool(
+    "find_workdir_files",
+    `Find files inside the current scope working directory only.
+Use this when the user asks you to locate a generated/output file before sending it as an attachment. It returns relative paths that can be passed to send_workdir_file.`,
+    {
+      query: external_exports.string().optional().describe("Optional case-insensitive substring to match against file names or relative paths."),
+      max_results: external_exports.number().int().min(1).max(WORKDIR_FIND_MAX_RESULTS).optional().describe(
+        `Maximum files to return. Defaults to ${WORKDIR_FIND_DEFAULT_MAX_RESULTS}, hard max ${WORKDIR_FIND_MAX_RESULTS}.`
+      )
+    },
+    async (args) => {
+      const query4 = args.query?.trim();
+      const maxResults = boundedWorkdirResultLimit(args.max_results);
+      logger9.info("find_workdir_files tool called", {
+        agentId: deps.agentId,
+        scope: currentScopeKey,
+        query: query4 ?? null,
+        maxResults
+      });
+      try {
+        const files = await findWorkdirFiles({
+          cwd: deps.cwd,
+          query: query4,
+          maxResults
+        });
+        if (files.length === 0) {
+          return {
+            content: [{
+              type: "text",
+              text: `[find_workdir_files] \u672A\u627E\u5230\u5339\u914D\u6587\u4EF6\u3002scope=${currentScopeKey}`
+            }]
+          };
+        }
+        const lines = files.map((file2, index) => {
+          const modified = new Date(file2.mtimeMs).toISOString();
+          return `${index + 1}. ${file2.relativePath} (${formatWorkdirFileSize(file2.size)}, modified ${modified})`;
+        });
+        return {
+          content: [{
+            type: "text",
+            text: [
+              `[find_workdir_files] \u627E\u5230 ${files.length} \u4E2A\u6587\u4EF6\uFF08\u53EA\u80FD\u53D1\u9001\u5F53\u524D scope \u5DE5\u4F5C\u76EE\u5F55\u5185\u6587\u4EF6\uFF09\uFF1A`,
+              ...lines,
+              "",
+              '\u8981\u53D1\u7ED9\u7528\u6237\u65F6\uFF0C\u8C03\u7528 send_workdir_file(path="<\u4E0A\u9762\u7684\u76F8\u5BF9\u8DEF\u5F84>")\u3002'
+            ].join("\n")
+          }]
+        };
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        logger9.error("find_workdir_files failed", {
+          agentId: deps.agentId,
+          scope: currentScopeKey,
+          query: query4 ?? null,
+          error: e
+        });
+        return {
+          content: [{ type: "text", text: `[find_workdir_files] failed: ${message}` }],
+          isError: true
+        };
+      }
+    },
+    {}
+  );
+  const sendWorkdirFileTool = sdk.tool(
+    "send_workdir_file",
+    `Send a real file from the current scope working directory as a clickable AHChat attachment on this visible reply.
+Only files inside the current scope cwd are allowed. Directories, missing files, and paths outside cwd are rejected. Pass a relative path from find_workdir_files when possible.`,
+    {
+      path: external_exports.string().min(1).describe("File path to send. Prefer a relative path returned by find_workdir_files; absolute paths are accepted only when they are inside the current scope cwd.")
+    },
+    async (args) => {
+      const requestedPath = args.path.trim();
+      logger9.info("send_workdir_file tool called", {
+        agentId: deps.agentId,
+        scope: currentScopeKey,
+        path: requestedPath
+      });
+      try {
+        const file2 = await resolveWorkdirFilePath(requestedPath, deps.cwd);
+        const marker = {
+          ok: true,
+          kind: WORKDIR_ATTACHMENT_MARKER_KIND,
+          path: file2.absolutePath,
+          relative_path: file2.relativePath,
+          file_name: file2.fileName,
+          mime_type: inferWorkdirFileMimeType(file2.absolutePath),
+          size: file2.size,
+          attachment_source: "agent_explicit_send"
+        };
+        return {
+          content: [{
+            type: "text",
+            text: [
+              JSON.stringify(marker),
+              "",
+              `[send_workdir_file] \u5DF2\u51C6\u5907\u53D1\u9001\u9644\u4EF6\uFF1A${file2.relativePath} (${formatWorkdirFileSize(file2.size)})\u3002\u8BF7\u5728\u672C\u8F6E\u53EF\u89C1\u56DE\u590D\u91CC\u7B80\u77ED\u8BF4\u660E\u9644\u4EF6\u5DF2\u9644\u4E0A\uFF0C\u4E0D\u8981\u91CD\u590D\u8F93\u51FA\u6587\u4EF6\u5168\u6587\u3002`
+            ].join("\n")
+          }]
+        };
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        logger9.error("send_workdir_file failed", {
+          agentId: deps.agentId,
+          scope: currentScopeKey,
+          path: requestedPath,
+          error: e
+        });
+        return {
+          content: [{ type: "text", text: `[send_workdir_file] failed: ${message}` }],
+          isError: true
+        };
+      }
+    },
+    {}
+  );
   const createGroupIssueTool = deps.serverApiUrl ? sdk.tool(
     "create_group_issue",
     `\u628A\u5F53\u524D\u7FA4\u91CC\u7684\u771F\u5B9E\u95EE\u9898\u5199\u5165\u95EE\u9898\u9762\u677F\u3002
@@ -26860,7 +27140,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
       system_prompt: external_exports.string().describe("\u8BE5 Agent \u7684 system prompt\uFF0C\u5B9A\u4E49\u4EBA\u683C\u3001\u4E13\u957F\u3001\u884C\u4E3A\u51C6\u5219\u3002\u4E0D\u80FD\u4E3A\u7A7A\u3002"),
       tier: external_exports.enum(["smart", "balanced", "fast"]).describe("\u80FD\u529B\u6863\u4F4D\uFF1Asmart\uFF08\u65D7\u8230\uFF0C\u590D\u6742\u4EFB\u52A1\uFF09\u3001balanced\uFF08\u6807\u51C6\uFF0C\u5E38\u89C4\u4EFB\u52A1\uFF09\u3001fast\uFF08\u8F7B\u91CF\uFF0C\u7B80\u5355\u4EFB\u52A1\uFF09\u3002"),
       avatar: external_exports.string().optional().describe(
-        "\u5934\u50CF key\uFF0C\u4ECE\u4EE5\u4E0B\u9009\u4E00\u4E2A\u6700\u5339\u914D\u89D2\u8272\u7684\uFF1Aavatar_dev\uFF08\u5F00\u53D1\uFF09, avatar_pm\uFF08\u4EA7\u54C1/\u7BA1\u7406\uFF09, avatar_designer\uFF08\u8BBE\u8BA1\uFF09, avatar_qa\uFF08\u6D4B\u8BD5/QA\uFF09, avatar_writer\uFF08\u5199\u4F5C/\u6587\u6863\uFF09, avatar_analyst\uFF08\u5206\u6790/\u6570\u636E\uFF09, avatar_coach\uFF08\u654F\u6377\u6559\u7EC3/\u5E26\u6559\uFF09, avatar_scientist\uFF08\u7814\u7A76/\u7B97\u6CD5\uFF09, avatar_lawyer\uFF08\u6CD5\u52A1/\u5408\u89C4\uFF09, avatar_human_man\uFF08\u901A\u7528\u7537\u6027\uFF09, avatar_human_woman\uFF08\u901A\u7528\u5973\u6027\uFF09, avatar_human_nerd\uFF08\u6781\u5BA2\uFF09, avatar_human_cool\uFF08\u9177\uFF09, avatar_human_cowboy\uFF08\u72C2\u91CE\uFF09, avatar_human_artist\uFF08\u827A\u672F\u5BB6\uFF09\u3002\u7559\u7A7A\u5219\u7528\u9ED8\u8BA4 avatar_default\uFF08\u{1F916}\uFF09\u3002"
+        "\u53EF\u9009\u5934\u50CF key\u3002\u901A\u5E38\u7559\u7A7A\uFF0C\u7531\u7CFB\u7EDF\u6839\u636E Agent \u540D\u5B57\u3001\u89D2\u8272\u548C\u63D0\u793A\u8BCD\u81EA\u52A8\u5206\u914D\u673A\u5668\u4EBA\u5934\u50CF\u5E76\u5F02\u6B65\u751F\u6210\u6700\u7EC8\u5934\u50CF\u3002\u4E0D\u8981\u7ED9 Agent \u4F7F\u7528 avatar_human_*\uFF0C\u8FD9\u4E9B\u53EA\u7ED9\u771F\u5B9E\u4EBA\u7C7B\u7528\u6237\u4F7F\u7528\u3002"
       ),
       initial_instruction: external_exports.string().optional().describe(
         '\u53EF\u9009\u3002\u521B\u5EFA\u540E\u7ACB\u5373\u4E0B\u53D1\u7ED9\u65B0 Agent \u7684\u4E00\u53E5\u8BDD\u6307\u4EE4\u3002\u5178\u578B\uFF1A"\u8BF7\u7528 1-2 \u53E5\u8BDD\u5411\u7528\u6237\u505A\u81EA\u6211\u4ECB\u7ECD\uFF0C\u8BF4\u660E\u4F60\u7684\u4E13\u957F"\u3002\u53EA\u5728\u7528\u6237\u660E\u786E\u8981"\u521B\u5EFA\u4E00\u4E2A\u5355 Agent"\u4E14\u5E0C\u671B\u8BE5 Agent \u7ACB\u5373\u9732\u9762\u65F6\u4F20\u3002\u56E2\u961F\u573A\u666F\u8BF7\u52FF\u4F20\u2014\u2014\u7531 Leader \u5728\u7FA4\u91CC\u6253\u62DB\u547C\u3002'
@@ -27203,7 +27483,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
       system_prompt: external_exports.string().optional().describe("\u65B0\u7684 system prompt\uFF08\u5B9A\u4E49\u4EBA\u683C\u3001\u4E13\u957F\u3001\u884C\u4E3A\u51C6\u5219\uFF09\u3002"),
       tier: external_exports.enum(["smart", "balanced", "fast"]).optional().describe("\u80FD\u529B\u6863\u4F4D\u3002\u4F20\u6B64\u53C2\u6570\u4F1A\u66F4\u65B0\u8BE5 Agent \u4F7F\u7528\u7684\u6A21\u578B\u3002"),
       avatar: external_exports.string().optional().describe(
-        "\u5934\u50CF key\uFF08\u5982 avatar_dev / avatar_pm / avatar_human_man \u7B49\uFF09\u3002"
+        "\u5934\u50CF key\uFF08\u5982 avatar_dev / avatar_pm / avatar_default \u7B49\uFF09\u3002\u4E0D\u8981\u7ED9 Agent \u4F7F\u7528 avatar_human_*\uFF0C\u8FD9\u4E9B\u53EA\u7ED9\u771F\u5B9E\u4EBA\u7C7B\u7528\u6237\u4F7F\u7528\u3002"
       ),
       machine_bridge_key: external_exports.string().optional().describe(
         '\u53EF\u9009\u3002\u65B0\u7684\u8FD0\u884C\u673A\u5668 bridgeKey\uFF0C\u6765\u81EA list_contacts \u7684"\u53EF\u7528\u673A\u5668"\u3002\u7701\u7565\u8868\u793A\u4E0D\u6539\uFF1B\u4F20 auto \u6216\u7A7A\u5B57\u7B26\u4E32\u6E05\u9664\u673A\u5668\u504F\u597D\u3002'
@@ -27904,7 +28184,13 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
     },
     {}
   ) : null;
-  const tools = [neuralSend, neuralListScopes, readDocumentTool];
+  const tools = [
+    neuralSend,
+    neuralListScopes,
+    readDocumentTool,
+    findWorkdirFilesTool,
+    sendWorkdirFileTool
+  ];
   if (readChatHistory) tools.push(readChatHistory);
   if (selfNote) tools.push(selfNote);
   if (listContacts) tools.push(listContacts);
@@ -27936,7 +28222,7 @@ nextOffset=${json2.nextOffset}\uFF08\u7EE7\u7EED\u67E5\u8BE2\u65F6\u4F20 offset=
     version: "2.3.0",
     tools
   });
-  const toolNames = ["neural_send", "neural_list_scopes", "read_document"];
+  const toolNames = ["neural_send", "neural_list_scopes", "read_document", "find_workdir_files", "send_workdir_file"];
   if (readChatHistory) toolNames.push("read_chat_history");
   if (selfNote) toolNames.push("self_note");
   if (listContacts) toolNames.push("list_contacts");
@@ -28199,9 +28485,11 @@ function buildGroupInboxPrompt(entries, opts = {}) {
 
 // src/sdkEventMapper.ts
 var logger11 = createModuleLogger("sdk.mapper");
+var DEBUG_ONLY_SYSTEM_SUBTYPES = /* @__PURE__ */ new Set(["status", "thinking_tokens"]);
 var HIGH_WATERMARK_INPUT_TOKENS = 12e4;
 var WARN_THRESHOLD_INPUT_TOKENS = 1e5;
 var LIVE_INPUT_PREVIEW_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit"]);
+var WORKDIR_MUTATION_TOOL_NAMES = /* @__PURE__ */ new Set(["write", "edit", "multiedit", "notebookedit", "bash"]);
 var CONTEXT_OVERFLOW_LOCK_MS = 6e4;
 function parseJsonRecord(text) {
   try {
@@ -28223,6 +28511,17 @@ function isSuccessfulOfficialMediaOutput(toolName, output) {
   if (!["succeeded", "success", "completed", "done"].includes(state)) return false;
   return Array.isArray(parsed.images) && parsed.images.length > 0 || typeof parsed.video_url === "string" || typeof parsed.videoUrl === "string";
 }
+function isWorkdirMutationToolName(toolName) {
+  return WORKDIR_MUTATION_TOOL_NAMES.has(toolName.trim().toLowerCase());
+}
+function recordWorkdirSignal(proc, toolName, isError) {
+  if (isError || !isGroupTask(proc) || !isWorkdirMutationToolName(toolName)) return;
+  const signals = proc.workdirSignals ?? [];
+  if (!signals.some((signal) => signal.toolName === toolName)) {
+    signals.push({ toolName });
+  }
+  proc.workdirSignals = signals;
+}
 function isContextOverflowText(text) {
   const trimmed = text.trim();
   return /^prompt is too long\b/i.test(trimmed) || /context length .* exceed/i.test(trimmed);
@@ -28727,6 +29026,7 @@ function countByStatus(todos) {
 function emitGroupSegment(proc, emit, base, content, contentBlocks, isSilent = false) {
   const groupId = proc.currentTask?.groupId;
   if (!groupId) return;
+  const workdirSignals = proc.workdirSignals?.length ? [...proc.workdirSignals] : void 0;
   proc.segmentCount += 1;
   logger11.info("Group segment emitted", {
     agentId: base.agentId,
@@ -28736,6 +29036,7 @@ function emitGroupSegment(proc, emit, base, content, contentBlocks, isSilent = f
     contentLen: content.length,
     blockCount: contentBlocks.length,
     blockTypes: contentBlocks.map((b) => b.type),
+    workdirSignalCount: workdirSignals?.length ?? 0,
     traceId: base.traceId,
     isAuditOnly: content.length === 0,
     isSilent
@@ -28748,9 +29049,11 @@ function emitGroupSegment(proc, emit, base, content, contentBlocks, isSilent = f
       groupId,
       content,
       contentBlocks: [...contentBlocks],
+      ...workdirSignals ? { workdirSignals } : {},
       ...isSilent ? { isSilent: true } : {}
     }
   });
+  proc.workdirSignals = [];
 }
 function flushTextSegmentOnBlockStop(proc, emit, base) {
   const trimmed = proc.segmentBuffer.trim();
@@ -28769,7 +29072,7 @@ function flushTextSegmentOnBlockStop(proc, emit, base) {
         traceId: base.traceId
       });
     }
-  } else if (proc.contentBlocks.length > 0) {
+  } else if (proc.contentBlocks.length > 0 || (proc.workdirSignals?.length ?? 0) > 0) {
     const blockCount = proc.contentBlocks.length;
     emitGroupSegment(proc, emit, base, "", proc.contentBlocks, true);
     proc.contentBlocks = [];
@@ -28859,7 +29162,8 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted, onPost
             proc.activeSubagentTaskIds?.delete(subagentTaskId);
           }
         }
-        logger11.info("SDK system subtype unhandled", {
+        const logUnhandledSystemSubtype = DEBUG_ONLY_SYSTEM_SUBTYPES.has(String(sysMsg.subtype ?? "")) ? logger11.debug.bind(logger11) : logger11.info.bind(logger11);
+        logUnhandledSystemSubtype("SDK system subtype unhandled", {
           agentId: proc.agentId,
           scope: proc.scope.kind === "single" ? "single" : proc.scope.groupId,
           subtype: sysMsg.subtype ?? "(none)",
@@ -28916,6 +29220,8 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted, onPost
                   input: {}
                 }
               });
+            }
+            if (shouldStreamInternals(proc) && !proc.suppressCurrentToolUse && toolName !== "ExitPlanMode" && !isAskUserQuestionToolName(toolName)) {
               proc.contentBlocks.push({
                 type: "tool_use",
                 ...toolUseId ? { toolUseId } : {},
@@ -29256,6 +29562,7 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted, onPost
                 }
               }
             }
+            recordWorkdirSignal(proc, toolName, isError);
             proc.activeToolUseStartedAt = void 0;
             proc.currentToolUseId = null;
           }
@@ -29317,7 +29624,7 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted, onPost
         if (isNoReplyText(trimmed, { allowSdkSyntheticNoResponse: groupMode })) {
           checkInputTokenWatermark(proc, watermarkUsage, base.traceId);
           emitUsageReported(proc, emit, base, usage);
-          if (groupMode && proc.contentBlocks.length > 0) {
+          if (groupMode && (proc.contentBlocks.length > 0 || (proc.workdirSignals?.length ?? 0) > 0)) {
             emitGroupSegment(
               proc,
               emit,
@@ -29362,11 +29669,12 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted, onPost
             proc.segmentBuffer = proc.accumulatedText;
             flushTextSegmentOnBlockStop(proc, emit, base);
           }
-          if (proc.contentBlocks.length > 0) {
+          if (proc.contentBlocks.length > 0 || (proc.workdirSignals?.length ?? 0) > 0) {
             logger11.info("Group turn trailing audit segment", {
               agentId: proc.agentId,
               replyMessageId: base.replyMessageId,
               blockCount: proc.contentBlocks.length,
+              workdirSignalCount: proc.workdirSignals?.length ?? 0,
               traceId: base.traceId
             });
             emitGroupSegment(proc, emit, base, "", proc.contentBlocks, true);
@@ -29511,6 +29819,7 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted, onPost
           payload: { ...wireBase(base), error: errorText }
         });
         proc.contentBlocks = [];
+        proc.workdirSignals = [];
         proc.accumulatedText = "";
         proc.accumulatedThinking = "";
         proc.segmentBuffer = "";
@@ -29543,6 +29852,7 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted, onPost
               proc.apiErrorEmitted = true;
             }
             proc.contentBlocks = [];
+            proc.workdirSignals = [];
             proc.accumulatedText = "";
             proc.accumulatedThinking = "";
             proc.segmentBuffer = "";
@@ -29569,6 +29879,7 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted, onPost
               proc.apiErrorEmitted = true;
             }
             proc.contentBlocks = [];
+            proc.workdirSignals = [];
             proc.accumulatedText = "";
             proc.accumulatedThinking = "";
             proc.segmentBuffer = "";
@@ -29605,6 +29916,7 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted, onPost
               });
             }
             proc.contentBlocks = [];
+            proc.workdirSignals = [];
             proc.accumulatedText = "";
             proc.accumulatedThinking = "";
             proc.segmentBuffer = "";
@@ -29646,6 +29958,7 @@ function resetAccumulators(proc) {
   proc.activeToolUseStartedAt = void 0;
   proc.segmentBuffer = "";
   proc.segmentCount = 0;
+  proc.workdirSignals = [];
   proc.accumulatedToolInput = "";
   proc.apiErrorEmitted = false;
   proc.peakContextUsage = void 0;
@@ -29657,24 +29970,24 @@ function resetAccumulators(proc) {
 }
 
 // src/forkHistoryReplay.ts
-import * as fs5 from "fs/promises";
-import * as path10 from "path";
+import * as fs6 from "fs/promises";
+import * as path11 from "path";
 var logger12 = createModuleLogger("bridge.forkHistoryReplay");
 function metaPath(dataDir, agentId) {
-  return path10.join(dataDir, "fork-meta", `${agentId}.json`);
+  return path11.join(dataDir, "fork-meta", `${agentId}.json`);
 }
 async function writeForkMeta(dataDir, agentId, meta3) {
   const fp = metaPath(dataDir, agentId);
-  await fs5.mkdir(path10.dirname(fp), { recursive: true });
-  await fs5.writeFile(fp, JSON.stringify(meta3), "utf-8");
+  await fs6.mkdir(path11.dirname(fp), { recursive: true });
+  await fs6.writeFile(fp, JSON.stringify(meta3), "utf-8");
   logger12.info("Fork meta written", { agentId, fp, sourceConversationId: meta3.sourceConversationId });
 }
 async function consumeForkMeta(dataDir, agentId) {
   const fp = metaPath(dataDir, agentId);
   try {
-    const raw = await fs5.readFile(fp, "utf-8");
+    const raw = await fs6.readFile(fp, "utf-8");
     const meta3 = JSON.parse(raw);
-    await fs5.unlink(fp);
+    await fs6.unlink(fp);
     logger12.info("Fork meta consumed (one-shot)", { agentId, sourceConversationId: meta3.sourceConversationId });
     return meta3;
   } catch {
@@ -29701,20 +30014,20 @@ function buildForkHistorySection(messages) {
 
 // src/sessionSlug.ts
 import os6 from "os";
-import path11 from "path";
-var CLAUDE_PROJECTS_DIR = path11.join(os6.homedir(), ".claude", "projects");
+import path12 from "path";
+var CLAUDE_PROJECTS_DIR = path12.join(os6.homedir(), ".claude", "projects");
 function cwdToSlug(cwd) {
   return cwd.replace(/[^a-zA-Z0-9-]/g, "-");
 }
 function sessionDirForCwd(cwd) {
-  return path11.join(CLAUDE_PROJECTS_DIR, cwdToSlug(cwd));
+  return path12.join(CLAUDE_PROJECTS_DIR, cwdToSlug(cwd));
 }
 function sessionFilePath(cwd, sessionId) {
-  return path11.join(sessionDirForCwd(cwd), `${sessionId}.jsonl`);
+  return path12.join(sessionDirForCwd(cwd), `${sessionId}.jsonl`);
 }
 
 // src/workdirMapper.ts
-import path12 from "path";
+import path13 from "path";
 function extractAhchatWorkspaceParts(requestedPath) {
   const normalized = requestedPath.trim().replace(/\\/g, "/");
   const marker = "/.ahchat/users/";
@@ -29750,15 +30063,15 @@ function extractAhchatWorkspaceParts(requestedPath) {
 function extractAhchatWorkspaceSuffix(requestedPath) {
   const parts = extractAhchatWorkspaceParts(requestedPath);
   if (!parts || parts.length === 0) return null;
-  return path12.join(...parts);
+  return path13.join(...parts);
 }
 function remapServerWorkspacePath(requestedPath, workspacesDir) {
   const parts = extractAhchatWorkspaceParts(requestedPath);
   if (!parts) return { path: requestedPath, remapped: false };
-  const remappedPath = parts.length > 0 ? path12.join(workspacesDir, ...parts) : workspacesDir;
+  const remappedPath = parts.length > 0 ? path13.join(workspacesDir, ...parts) : workspacesDir;
   return {
     path: remappedPath,
-    remapped: path12.normalize(requestedPath) !== path12.normalize(remappedPath)
+    remapped: path13.normalize(requestedPath) !== path13.normalize(remappedPath)
   };
 }
 
@@ -29841,7 +30154,7 @@ function missingSubscriptionMessage(subscriptionId) {
 }
 var NODE_USER_UID = 1e3;
 var POST_MERGE_CONTINUATION_ROUTE_MS = 15e3;
-var SCOPE_PROMPT_FINGERPRINT_REVISION = "workdir-scope-mcp-abi-prompt-v4";
+var SCOPE_PROMPT_FINGERPRINT_REVISION = "workdir-scope-mcp-abi-prompt-v6";
 var BINARY_ATTACHMENT_EXT_RE = /\.(?:7z|bmp|csv|doc|docx|gif|jpeg|jpg|m4a|mov|mp3|mp4|pdf|png|ppt|pptx|rar|rtf|wav|webm|webp|xls|xlsx|zip)$/i;
 var IMAGE_READ_EXT_RE = /\.(?:bmp|gif|jpeg|jpg|png|webp)$/i;
 var DOCUMENT_READING_RULES = `DOCUMENT READING:
@@ -29857,6 +30170,72 @@ var MEDIA_GENERATION_RULES = `MEDIA GENERATION:
 - Keep media replies short. Do not print raw media URLs, request_id, task_id, polling logs, or "let me check again" narration unless the user explicitly asks for diagnostics.
 - When a media task is submitted or completed, write only a natural one-line note such as "\u5DF2\u5F00\u59CB\u751F\u6210\uFF0C\u6211\u4F1A\u5728\u8FD9\u91CC\u66F4\u65B0\u7ED3\u679C\u3002" or "\u751F\u6210\u597D\u4E86\uFF0C\u53EF\u4EE5\u5728\u5361\u7247\u91CC\u67E5\u770B\u3002"; let the media card show status, preview, download, copy, and regenerate actions.
 - If the user asks whether a Seedance task is ready, call mcp__seedance__seedance_check_task once and answer from that result. Do not loop, sleep, or invent external Seedance API endpoints.`;
+var SMITH_ALLOWED_TOOLS = [
+  // creation / configuration (Smith-only)
+  "mcp__neural__create_agent",
+  "mcp__neural__update_agent_profile",
+  "mcp__neural__recommend_agent_skills",
+  "mcp__neural__read_skill",
+  // diagnostics (log detective)
+  "mcp__neural__fetch_logs",
+  // friend approval (Smith-only)
+  "mcp__neural__list_friends",
+  "mcp__neural__accept_friend",
+  "mcp__neural__add_friend",
+  // team assembly
+  "mcp__neural__list_contacts",
+  "mcp__neural__create_group",
+  "mcp__neural__add_to_group",
+  "mcp__neural__transfer_group_owner",
+  "mcp__neural__leave_group",
+  // neural bridge — cross-scope coordination when Smith is pulled into a group
+  "mcp__neural__neural_send",
+  "mcp__neural__neural_list_scopes",
+  // bounded current-scope workdir attachments
+  "mcp__neural__find_workdir_files",
+  "mcp__neural__send_workdir_file",
+  // interaction / planning
+  "AskUserQuestion",
+  "Write"
+];
+function isVisionMcpServerName(serverName) {
+  return serverName === "vision";
+}
+function selectSmithVisionMcp(resolved) {
+  const resolvedMcpServers = resolved.mcpServers ?? {};
+  const resolvedAllowedTools = resolved.allowedTools ?? [];
+  const resolvedToolAbi = resolved.toolAbi ?? [];
+  const visionServerNames = /* @__PURE__ */ new Set();
+  for (const server of resolvedToolAbi) {
+    if (server.providerId === "volcengine_vision" || isVisionMcpServerName(server.serverName)) {
+      visionServerNames.add(server.serverName);
+    }
+  }
+  for (const toolName of resolvedAllowedTools) {
+    const parsed = parseMcpRuntimeToolName(toolName);
+    if (parsed && isVisionMcpServerName(parsed.serverName)) {
+      visionServerNames.add(parsed.serverName);
+    }
+  }
+  for (const serverName of Object.keys(resolvedMcpServers)) {
+    if (isVisionMcpServerName(serverName)) {
+      visionServerNames.add(serverName);
+    }
+  }
+  if (visionServerNames.size === 0) {
+    return { mcpServers: {}, allowedTools: [], toolAbi: [] };
+  }
+  return {
+    mcpServers: Object.fromEntries(
+      Object.entries(resolvedMcpServers).filter(([serverName]) => visionServerNames.has(serverName))
+    ),
+    allowedTools: resolvedAllowedTools.filter((toolName) => {
+      const parsed = parseMcpRuntimeToolName(toolName);
+      return Boolean(parsed && visionServerNames.has(parsed.serverName));
+    }),
+    toolAbi: resolvedToolAbi.filter((server) => visionServerNames.has(server.serverName))
+  };
+}
 function resolveVisionMcpToolHints(externalMcp) {
   let describe3 = null;
   let ocr = null;
@@ -29924,7 +30303,7 @@ function uniqueNormalizedPaths(paths) {
   for (const item of paths) {
     const trimmed = item.trim();
     if (!trimmed) continue;
-    const normalized = path13.normalize(trimmed);
+    const normalized = path14.normalize(trimmed);
     const key = process.platform === "win32" ? normalized.toLowerCase() : normalized;
     if (seen.has(key)) continue;
     seen.add(key);
@@ -29954,7 +30333,7 @@ function resolveReadToolImagePath(input, cwd) {
   if (typeof raw !== "string" || raw.trim().length === 0) return null;
   const trimmed = raw.trim();
   if (!IMAGE_READ_EXT_RE.test(trimmed)) return null;
-  const abs = path13.isAbsolute(trimmed) ? path13.normalize(trimmed) : path13.resolve(cwd, trimmed);
+  const abs = path14.isAbsolute(trimmed) ? path14.normalize(trimmed) : path14.resolve(cwd, trimmed);
   return { raw: trimmed, abs };
 }
 function usesIsolatedProjectBackend(cfg) {
@@ -29973,14 +30352,14 @@ function buildModelGatewayBaseUrl(serverApiUrl, subscriptionId) {
 }
 async function chownForRootSpawn(targetPath, target) {
   try {
-    await fs6.chown(targetPath, NODE_USER_UID, NODE_USER_UID);
+    await fs7.chown(targetPath, NODE_USER_UID, NODE_USER_UID);
   } catch (error51) {
     logger14.error("Best-effort root chown failed", { error: error51, target, path: targetPath });
   }
 }
 function readCronLockSnapshot() {
   try {
-    const lockPath2 = path13.join(os7.homedir(), ".claude", "scheduled_tasks.lock");
+    const lockPath2 = path14.join(os7.homedir(), ".claude", "scheduled_tasks.lock");
     if (!fsSync.existsSync(lockPath2)) {
       return { exists: false, sessionId: null, pid: null };
     }
@@ -30252,8 +30631,8 @@ var AgentManager = class {
     this.emit = emit;
     if (typeof options === "function") {
       this.queryFn = options;
-      this.workspacesDir = path13.join(os7.homedir(), ".ahchat", "workspaces");
-      this.agentConfigDir = path13.join(os7.homedir(), ".ahchat", "agent-config");
+      this.workspacesDir = path14.join(os7.homedir(), ".ahchat", "workspaces");
+      this.agentConfigDir = path14.join(os7.homedir(), ".ahchat", "agent-config");
       this.queryConfig = DEFAULT_QUERY_CONFIG;
       this.askQuestionRegistry = new AskQuestionRegistry();
       this.groupRegistry = null;
@@ -30270,13 +30649,13 @@ var AgentManager = class {
       this.bridgeToken = null;
       this.currentBridgeKey = null;
       this.defaultModel = null;
-      this.dataDir = path13.join(os7.homedir(), ".ahchat");
+      this.dataDir = path14.join(os7.homedir(), ".ahchat");
       this.workdirOverrideStore = null;
       this.officeCliRuntime = null;
     } else {
       this.queryFn = options?.queryFn ?? null;
-      this.workspacesDir = options?.workspacesDir ?? path13.join(os7.homedir(), ".ahchat", "workspaces");
-      this.agentConfigDir = options?.agentConfigDir ?? path13.join(os7.homedir(), ".ahchat", "agent-config");
+      this.workspacesDir = options?.workspacesDir ?? path14.join(os7.homedir(), ".ahchat", "workspaces");
+      this.agentConfigDir = options?.agentConfigDir ?? path14.join(os7.homedir(), ".ahchat", "agent-config");
       this.queryConfig = options?.queryConfig ?? DEFAULT_QUERY_CONFIG;
       this.askQuestionRegistry = options?.askQuestionRegistry ?? new AskQuestionRegistry();
       this.groupRegistry = options?.groupRegistry ?? null;
@@ -30293,7 +30672,7 @@ var AgentManager = class {
       this.mcpAuditRecorder = options?.mcpAuditRecorder ?? new HttpMcpAuditClient(this.serverApiUrl, this.bridgeToken);
       this.mcpBillingPreflightChecker = options?.mcpBillingPreflightChecker ?? new HttpMcpBillingClient(this.serverApiUrl, this.bridgeToken);
       this.defaultModel = options?.defaultModel ?? null;
-      this.dataDir = options?.dataDir ?? path13.join(os7.homedir(), ".ahchat");
+      this.dataDir = options?.dataDir ?? path14.join(os7.homedir(), ".ahchat");
       this.workdirOverrideStore = options?.workdirOverrideStore ?? null;
       this.officeCliRuntime = options?.officeCliRuntime ?? null;
     }
@@ -30326,9 +30705,9 @@ var AgentManager = class {
     const normalized = requestedCwd.trim();
     const ahchatSuffix = extractAhchatWorkspaceSuffix(normalized);
     if (ahchatSuffix) {
-      return path13.join(this.workspacesDir, ahchatSuffix);
+      return path14.join(this.workspacesDir, ahchatSuffix);
     }
-    return path13.join(this.workspacesDir, this.localScopeDirName(agentConfig, scope));
+    return path14.join(this.workspacesDir, this.localScopeDirName(agentConfig, scope));
   }
   localScopeDirName(agentConfig, scope) {
     if (scope.kind === "group") return `Group-${scope.groupId}`;
@@ -30339,9 +30718,9 @@ var AgentManager = class {
     if (scope.kind === "group") {
       const groupCwd = this.groupRegistry?.getById(scope.groupId)?.workingDirectory?.trim();
       if (groupCwd) return groupCwd;
-      return path13.join(this.workspacesDir, this.localScopeDirName(agentConfig, scope));
+      return path14.join(this.workspacesDir, this.localScopeDirName(agentConfig, scope));
     }
-    const local = path13.join(this.workspacesDir, this.localScopeDirName(agentConfig, scope));
+    const local = path14.join(this.workspacesDir, this.localScopeDirName(agentConfig, scope));
     return agentConfig.workingDirectory?.trim() || local;
   }
   runtimeCwdInput(agentConfig, scope, cwd) {
@@ -30353,7 +30732,7 @@ var AgentManager = class {
       if (requested && (!agentCwd || !this.isSameRuntimeCwd(requested, agentCwd))) {
         return requested;
       }
-      return path13.join(this.workspacesDir, this.localScopeDirName(agentConfig, scope));
+      return path14.join(this.workspacesDir, this.localScopeDirName(agentConfig, scope));
     }
     return agentConfig.workingDirectory?.trim() || requested || this.scopeCwdInput(agentConfig, scope);
   }
@@ -30388,7 +30767,7 @@ var AgentManager = class {
     let cwd = this.remapServerWorkspaceCwd(agentConfig, scope, requestedCwd);
     let fallbackForensicsId;
     if (!isFullyQualifiedAbsolutePath(cwd)) {
-      const fallback = path13.join(this.workspacesDir, this.localScopeDirName(agentConfig, scope));
+      const fallback = path14.join(this.workspacesDir, this.localScopeDirName(agentConfig, scope));
       logger14.error(
         "Working directory is not usable on this machine; using local sandbox fallback",
         {
@@ -30424,7 +30803,7 @@ var AgentManager = class {
       cwd = this.fallbackCwd(agentConfig, scope, cwd);
     }
     try {
-      await fs6.mkdir(cwd, { recursive: true });
+      await fs7.mkdir(cwd, { recursive: true });
       return cwd;
     } catch (e) {
       const fallback = this.fallbackCwd(agentConfig, scope, cwd);
@@ -30451,7 +30830,7 @@ var AgentManager = class {
         },
         outcome: { result: "second_layer_fallback" }
       });
-      await fs6.mkdir(fallback, { recursive: true });
+      await fs7.mkdir(fallback, { recursive: true });
       return fallback;
     }
   }
@@ -30645,25 +31024,25 @@ var AgentManager = class {
   }
   settingsPathForConfig(cfg, effectiveConfigDir) {
     if (!usesIsolatedProjectBackend(cfg)) return void 0;
-    return path13.join(effectiveConfigDir, "settings.json");
+    return path14.join(effectiveConfigDir, "settings.json");
   }
   isSameRuntimeCwd(a, b) {
-    const left = path13.normalize(a);
-    const right = path13.normalize(b);
+    const left = path14.normalize(a);
+    const right = path14.normalize(b);
     return process.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right;
   }
   sessionProjectDirs(agentConfig, effectiveConfigDir) {
     return uniqueNormalizedPaths([
-      path13.join(effectiveConfigDir, "api-key-agents", agentConfig.id, "projects"),
-      path13.join(effectiveConfigDir, "projects"),
-      path13.join(os7.homedir(), ".claude", "projects")
+      path14.join(effectiveConfigDir, "api-key-agents", agentConfig.id, "projects"),
+      path14.join(effectiveConfigDir, "projects"),
+      path14.join(os7.homedir(), ".claude", "projects")
     ]);
   }
   sessionPathsForCwd(projectsDirs, cwd, sessionId) {
     return uniqueNormalizedPaths(
       projectsDirs.flatMap(
         (projectsDir) => claudeProjectSlugCandidates(cwd).map(
-          (slug) => path13.join(projectsDir, slug, `${sessionId}.jsonl`)
+          (slug) => path14.join(projectsDir, slug, `${sessionId}.jsonl`)
         )
       )
     );
@@ -30684,7 +31063,7 @@ var AgentManager = class {
       }
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const candidate = path13.join(projectsDir, entry.name, `${sessionId}.jsonl`);
+        const candidate = path14.join(projectsDir, entry.name, `${sessionId}.jsonl`);
         if (fsSync.existsSync(candidate)) found.push(candidate);
       }
     }
@@ -30699,12 +31078,12 @@ var AgentManager = class {
     }
     const currentPathSet = new Set(
       currentCwdPaths.map(
-        (candidate) => process.platform === "win32" ? path13.normalize(candidate).toLowerCase() : path13.normalize(candidate)
+        (candidate) => process.platform === "win32" ? path14.normalize(candidate).toLowerCase() : path14.normalize(candidate)
       )
     );
     const foundElsewhere = this.findSessionJsonlFiles(projectsDirs, sessionId).filter(
       (candidate) => {
-        const normalized = process.platform === "win32" ? path13.normalize(candidate).toLowerCase() : path13.normalize(candidate);
+        const normalized = process.platform === "win32" ? path14.normalize(candidate).toLowerCase() : path14.normalize(candidate);
         return !currentPathSet.has(normalized);
       }
     );
@@ -30725,7 +31104,7 @@ var AgentManager = class {
     return null;
   }
   scopePromptFingerprint(agentConfig, scope, agentCwd, scopesSection, externalMcpFingerprint, runtimeToolPolicyFingerprint = "") {
-    const hash2 = createHash("sha256").update(SCOPE_PROMPT_FINGERPRINT_REVISION).update("\0").update(agentConfig.id).update("\0").update(agentConfig.name).update("\0").update(scopeKey(scope)).update("\0").update(path13.normalize(agentCwd)).update("\0").update(scopesSection).update("\0").update(externalMcpFingerprint);
+    const hash2 = createHash("sha256").update(SCOPE_PROMPT_FINGERPRINT_REVISION).update("\0").update(agentConfig.id).update("\0").update(agentConfig.name).update("\0").update(scopeKey(scope)).update("\0").update(path14.normalize(agentCwd)).update("\0").update(scopesSection).update("\0").update(externalMcpFingerprint);
     if (runtimeToolPolicyFingerprint) {
       hash2.update("\0runtimeToolPolicy\0").update(runtimeToolPolicyFingerprint);
     }
@@ -31082,7 +31461,7 @@ var AgentManager = class {
     const scopedInstructions = cfg.instructions?.trim() && scope.kind === "group" ? `# Agent project instructions
 ${cfg.instructions.trim()}` : "";
     if (cfg.instructions?.trim() && scope.kind === "single") {
-      await fs6.writeFile(path13.join(agentCwd, "CLAUDE.md"), cfg.instructions.trim(), "utf-8");
+      await fs7.writeFile(path14.join(agentCwd, "CLAUDE.md"), cfg.instructions.trim(), "utf-8");
       logger14.info("CLAUDE.md written", {
         agentId: agentConfig.id,
         scope: scopeKey(scope),
@@ -31091,10 +31470,10 @@ ${cfg.instructions.trim()}` : "";
     }
     let effectiveConfigDir = this.agentConfigDir;
     if (cfg.subscriptionType !== "system" && cfg.apiKey) {
-      effectiveConfigDir = path13.join(this.agentConfigDir, "api-key-agents", agentConfig.id);
+      effectiveConfigDir = path14.join(this.agentConfigDir, "api-key-agents", agentConfig.id);
       let isNew = false;
       try {
-        await fs6.access(effectiveConfigDir);
+        await fs7.access(effectiveConfigDir);
       } catch (e) {
         logger14.debug("Agent API key config dir missing; creating isolated dir", {
           error: e,
@@ -31102,7 +31481,7 @@ ${cfg.instructions.trim()}` : "";
         });
         isNew = true;
       }
-      await fs6.mkdir(effectiveConfigDir, { recursive: true });
+      await fs7.mkdir(effectiveConfigDir, { recursive: true });
       if (isNew) {
         this.sessionStore.delete(agentConfig.id, scope);
         this.dispatchMemory.deleteScope(agentConfig.id, scope);
@@ -31110,18 +31489,18 @@ ${cfg.instructions.trim()}` : "";
           agentId: agentConfig.id
         });
       }
-      const settingsPath = path13.join(effectiveConfigDir, "settings.json");
+      const settingsPath = path14.join(effectiveConfigDir, "settings.json");
       const envEntries = buildAnthropicCredentialEnv(cfg);
       if (cfg.apiBaseUrl) envEntries.ANTHROPIC_BASE_URL = cfg.apiBaseUrl;
       let existingSettings = {};
       if (fsSync.existsSync(settingsPath)) {
         try {
-          const raw = await fs6.readFile(settingsPath, "utf-8");
+          const raw = await fs7.readFile(settingsPath, "utf-8");
           existingSettings = JSON.parse(raw);
         } catch (error51) {
           logger14.error("Failed to read existing API-key agent settings; starting fresh", {
             agentId: agentConfig.id,
-            settingsPath,
+            settingsFile: "settings.json",
             error: error51
           });
         }
@@ -31131,10 +31510,10 @@ ${cfg.instructions.trim()}` : "";
       if (envEntries.ANTHROPIC_AUTH_TOKEN) delete mergedEnv.ANTHROPIC_API_KEY;
       if (envEntries.ANTHROPIC_API_KEY) delete mergedEnv.ANTHROPIC_AUTH_TOKEN;
       const mergedSettings = { ...existingSettings, env: mergedEnv };
-      await fs6.writeFile(settingsPath, JSON.stringify(mergedSettings, null, 2), "utf-8");
+      await fs7.writeFile(settingsPath, JSON.stringify(mergedSettings, null, 2), "utf-8");
       logger14.info("API-key agent using isolated config dir", {
         agentId: agentConfig.id,
-        dir: effectiveConfigDir,
+        configDirKind: "api-key-agent",
         isNew,
         hasBaseUrl: !!cfg.apiBaseUrl,
         settingsWritten: Object.keys(envEntries)
@@ -31228,12 +31607,23 @@ ${cfg.instructions.trim()}` : "";
         });
       }
     }
-    const externalMcp = this.mcpRegistry?.buildForAgent({
+    const resolvedExternalMcp = this.mcpRegistry?.buildForAgent({
       agentId: agentConfig.id,
       capabilityTier: cfg.capabilityTier,
       isSmith: smithAgent,
       cwd: agentCwd
     }) ?? { mcpServers: {}, allowedTools: [], toolAbi: [] };
+    const externalMcp = smithAgent ? selectSmithVisionMcp(resolvedExternalMcp) : resolvedExternalMcp;
+    if (smithAgent && (Object.keys(resolvedExternalMcp.mcpServers).length !== Object.keys(externalMcp.mcpServers).length || resolvedExternalMcp.allowedTools.length !== externalMcp.allowedTools.length || (resolvedExternalMcp.toolAbi?.length ?? 0) !== (externalMcp.toolAbi?.length ?? 0))) {
+      logger14.info("Smith external MCP filtered by fixed tool whitelist", {
+        agentId: agentConfig.id,
+        scope: scopeKey(scope),
+        serverNames: Object.keys(resolvedExternalMcp.mcpServers),
+        allowedToolCount: resolvedExternalMcp.allowedTools.length,
+        retainedServerNames: Object.keys(externalMcp.mcpServers),
+        retainedAllowedToolCount: externalMcp.allowedTools.length
+      });
+    }
     const visionMcpTools = resolveVisionMcpToolHints(externalMcp);
     logger14.info("External MCP resolved for runtime", {
       agentId: agentConfig.id,
@@ -31306,6 +31696,7 @@ ${cfg.instructions.trim()}` : "";
     logger14.info("Creating Agent query", {
       agentId: agentConfig.id,
       scope: scopeKey(scope),
+      systemPromptMode: smithAgent ? "string" : "preset",
       cwd: agentCwd,
       resume: !!savedSessionId,
       sessionId: savedSessionId,
@@ -31326,71 +31717,65 @@ ${cfg.instructions.trim()}` : "";
     });
     const planModeRef = { active: false, denyCount: 0 };
     const mediaGenerationTurnGuard = createOfficialMediaGenerationTurnGuard();
+    const platformRules = scope.kind === "group" ? PLATFORM_AGENT_RULES : PLATFORM_AGENT_RULES_SINGLE;
+    const appendText = [
+      platformRules,
+      nativeReadToolDisabled ? buildNativeReadDisabledRules(visionMcpTools) : "",
+      DOCUMENT_READING_RULES,
+      MEDIA_GENERATION_RULES,
+      agentConfig.systemPrompt,
+      scopedInstructions,
+      notebookSection,
+      forkHistorySection,
+      scopesSection
+    ].filter((s) => typeof s === "string" && s.trim().length > 0).join("\n\n");
+    const systemPrompt = smithAgent ? appendText : { type: "preset", preset: "claude_code", append: appendText };
+    const universalAllowedTools = [
+      ...nativeReadToolDisabled ? [] : ["Read"],
+      "Edit",
+      "Write",
+      "Bash",
+      "Glob",
+      "Grep",
+      ...builtinWebSearchAllowed ? ["WebSearch"] : [],
+      "WebFetch",
+      "TodoWrite",
+      "TaskCreate",
+      "TaskUpdate",
+      "AskUserQuestion",
+      "mcp__neural__neural_send",
+      "mcp__neural__neural_list_scopes",
+      "mcp__neural__find_workdir_files",
+      "mcp__neural__send_workdir_file",
+      "mcp__neural__self_note",
+      "mcp__neural__list_contacts",
+      "mcp__neural__create_group",
+      "mcp__neural__add_to_group",
+      "mcp__neural__leave_group",
+      "mcp__neural__remove_from_group",
+      "mcp__neural__create_group_issue",
+      "mcp__neural__resolve_group_issue",
+      "mcp__neural__list_group_tasks",
+      "mcp__neural__update_group_task",
+      "mcp__neural__transfer_group_owner",
+      "mcp__neural__post_to_moments",
+      "mcp__neural__post_to_forum",
+      "mcp__neural__read_moments",
+      "mcp__neural__read_chat_history",
+      "mcp__neural__read_document",
+      "mcp__neural__list_available_skills",
+      "mcp__neural__list_skill_index"
+    ];
     const options = {
       cwd: agentCwd,
-      systemPrompt: {
-        type: "preset",
-        preset: "claude_code",
-        append: [
-          PLATFORM_AGENT_RULES,
-          nativeReadToolDisabled ? buildNativeReadDisabledRules(visionMcpTools) : "",
-          DOCUMENT_READING_RULES,
-          MEDIA_GENERATION_RULES,
-          agentConfig.systemPrompt,
-          scopedInstructions,
-          notebookSection,
-          forkHistorySection,
-          scopesSection
-        ].filter((s) => typeof s === "string" && s.trim().length > 0).join("\n\n")
-      },
+      systemPrompt,
       permissionMode: "bypassPermissions",
       allowDangerouslySkipPermissions: true,
       // allowedTools is the visibility whitelist passed to Claude Code. MCP tools
       // with always_ask must still be included here so the model can request them;
       // the MCP server policy/permission layer decides whether execution asks.
       allowedTools: [
-        ...nativeReadToolDisabled ? [] : ["Read"],
-        "Edit",
-        "Write",
-        "Bash",
-        "Glob",
-        "Grep",
-        ...builtinWebSearchAllowed ? ["WebSearch"] : [],
-        "WebFetch",
-        "TodoWrite",
-        "TaskCreate",
-        "TaskUpdate",
-        "AskUserQuestion",
-        "mcp__neural__neural_send",
-        "mcp__neural__neural_list_scopes",
-        "mcp__neural__self_note",
-        "mcp__neural__list_contacts",
-        "mcp__neural__create_group",
-        "mcp__neural__add_to_group",
-        "mcp__neural__leave_group",
-        "mcp__neural__remove_from_group",
-        "mcp__neural__create_group_issue",
-        "mcp__neural__resolve_group_issue",
-        "mcp__neural__list_group_tasks",
-        "mcp__neural__update_group_task",
-        "mcp__neural__transfer_group_owner",
-        "mcp__neural__post_to_moments",
-        "mcp__neural__post_to_forum",
-        "mcp__neural__read_moments",
-        "mcp__neural__read_chat_history",
-        "mcp__neural__read_document",
-        "mcp__neural__list_available_skills",
-        "mcp__neural__list_skill_index",
-        ...isSmithAgent2(agentConfig) ? [
-          "mcp__neural__create_agent",
-          "mcp__neural__update_agent_profile",
-          "mcp__neural__recommend_agent_skills",
-          "mcp__neural__read_skill",
-          "mcp__neural__list_friends",
-          "mcp__neural__accept_friend",
-          "mcp__neural__add_friend",
-          "mcp__neural__fetch_logs"
-        ] : [],
+        ...smithAgent ? SMITH_ALLOWED_TOOLS : universalAllowedTools,
         ...externalMcp.allowedTools
       ],
       // Server-side WebSearch bypasses canUseTool; disallowedTools removes it from model context.
@@ -31402,7 +31787,7 @@ ${cfg.instructions.trim()}` : "";
       // instructions as the workflow body (replacing the default code-implementation
       // phases). The SDK wraps it with read-only enforcement + ExitPlanMode protocol.
       planModeInstructions: (() => {
-        const planTools = [
+        const planTools = (smithAgent ? ["AskUserQuestion", "Write (plan file only)"] : [
           ...nativeReadToolDisabled ? [] : ["Read"],
           "Glob",
           "Grep",
@@ -31410,19 +31795,19 @@ ${cfg.instructions.trim()}` : "";
           "WebFetch",
           "AskUserQuestion",
           "Write (plan file only)"
-        ].join(", ");
-        const researchTools = [
+        ]).join(", ");
+        const researchTools = (smithAgent ? ["AskUserQuestion"] : [
           ...nativeReadToolDisabled ? [] : ["Read"],
           "Grep",
           ...builtinWebSearchAllowed ? ["WebSearch"] : []
-        ].join(", ");
-        const unavailableTools = [
+        ]).join(", ");
+        const unavailableTools = (smithAgent ? ["Read", "Edit", "Bash", "Glob", "Grep", "WebFetch", "TodoWrite", "ExitPlanMode"] : [
           "Edit",
           "Bash",
           "TodoWrite",
           "ExitPlanMode",
           ...nativeReadToolDisabled ? ["Read"] : []
-        ].join(", ");
+        ]).join(", ");
         const smithTools = smithAgent ? "\nSMITH-SPECIFIC TOOLS (available in plan mode): mcp__neural__recommend_agent_skills, mcp__neural__read_skill, mcp__neural__fetch_logs, mcp__neural__create_agent, mcp__neural__update_agent_profile \u2014 use these to recommend initial skill sets, research existing skills, check logs, plan agent creation, and adjust Agent profiles." : "";
         return `You are a PLANNER, NOT an executor. The user will execute your plan later.
 
@@ -31652,17 +32037,17 @@ Do NOT use "..." as content \u2014 write specific, project-relevant content.`;
       }
     };
     const userPromptTrimmed = (agentConfig.systemPrompt ?? "").trim();
-    const appendStr = options.systemPrompt.append;
     logger14.info("Platform rules attached", {
       agentId: agentConfig.id,
       scope: scopeKey(scope),
-      platformRulesLen: PLATFORM_AGENT_RULES.length,
+      systemPromptMode: smithAgent ? "string" : "preset",
+      platformRulesLen: platformRules.length,
       userPromptLen: userPromptTrimmed.length,
       hasUserPrompt: userPromptTrimmed.length > 0,
       notebookLen: notebookSection.length,
       forkHistoryLen: forkHistorySection.length,
       scopesLen: scopesSection.length,
-      appendLen: appendStr.length,
+      appendLen: appendText.length,
       hasCreateAgentTool: smithAgent,
       hasLogDetectiveTools: smithAgent && this.skillStore !== null
     });
@@ -31682,7 +32067,7 @@ Do NOT use "..." as content \u2014 write specific, project-relevant content.`;
     if (isRunningAsRoot()) {
       await chownForRootSpawn(effectiveConfigDir, "configDir");
       await chownForRootSpawn(agentCwd, "agentCwd");
-      const settingsFilePath = path13.join(effectiveConfigDir, "settings.json");
+      const settingsFilePath = path14.join(effectiveConfigDir, "settings.json");
       await chownForRootSpawn(settingsFilePath, "settingsFile");
       options.spawnClaudeCodeProcess = (spawnOptions) => {
         const env2 = { ...spawnOptions.env, HOME: "/home/node" };
@@ -31732,6 +32117,7 @@ Do NOT use "..." as content \u2014 write specific, project-relevant content.`;
       mcpAuditRecorder: this.mcpAuditRecorder,
       segmentBuffer: "",
       segmentCount: 0,
+      workdirSignals: [],
       accumulatedToolInput: "",
       planModeRef,
       mediaGenerationTurnGuard,
@@ -31751,7 +32137,7 @@ Do NOT use "..." as content \u2014 write specific, project-relevant content.`;
       mergedTasks: [],
       planModeBuffer: [],
       createdAt: Date.now(),
-      supportsVision: modelInputMode === "vision",
+      supportsVision: cfg.supportsVision === true,
       modelInputMode,
       visionMcpTools,
       quietFlushTimer: null,
@@ -31939,7 +32325,7 @@ ${trimmed}`;
   promptWorkdir(agentConfig, scope, requestedCwd) {
     const remapped = this.remapServerWorkspaceCwd(agentConfig, scope, requestedCwd);
     if (!isFullyQualifiedAbsolutePath(remapped)) {
-      return path13.join(this.workspacesDir, this.localScopeDirName(agentConfig, scope));
+      return path14.join(this.workspacesDir, this.localScopeDirName(agentConfig, scope));
     }
     return remapped;
   }
@@ -32644,12 +33030,12 @@ ${lines.join("\n")}`;
   }
   async materializeAttachment(runtime, attachment, buffer) {
     const safeFileName = this.safeAttachmentFileName(attachment.fileName);
-    const attachmentDir = path13.join(runtime.cwd, ".ahchat-attachments", attachment.id);
+    const attachmentDir = path14.join(runtime.cwd, ".ahchat-attachments", attachment.id);
     let filePath = await this.resolveExistingWorkspaceAttachmentPath(runtime, attachment);
     if (!filePath) {
-      await fs6.mkdir(attachmentDir, { recursive: true });
-      filePath = path13.join(attachmentDir, safeFileName);
-      await fs6.writeFile(filePath, buffer);
+      await fs7.mkdir(attachmentDir, { recursive: true });
+      filePath = path14.join(attachmentDir, safeFileName);
+      await fs7.writeFile(filePath, buffer);
     }
     const materialized = { filePath };
     if (isReadableDocumentPath(filePath)) {
@@ -32678,10 +33064,10 @@ ${lines.join("\n")}`;
     const rawPath = typeof localWorkspacePath === "string" && localWorkspacePath.trim() ? localWorkspacePath : workspacePath;
     if (typeof rawPath !== "string" || !rawPath.trim()) return null;
     const remapped = remapServerWorkspacePath(rawPath, this.workspacesDir);
-    const candidate = path13.resolve(remapped.path);
+    const candidate = path14.resolve(remapped.path);
     if (!this.isPathInsideBase(candidate, runtime.cwd)) return null;
     try {
-      const stat3 = await fs6.stat(candidate);
+      const stat3 = await fs7.stat(candidate);
       return stat3.isFile() ? candidate : null;
     } catch (e) {
       logger14.warn("Workspace attachment path unavailable", {
@@ -32696,13 +33082,13 @@ ${lines.join("\n")}`;
     }
   }
   isPathInsideBase(filePath, basePath) {
-    const resolvedFile = path13.resolve(filePath);
-    const resolvedBase = path13.resolve(basePath);
-    const relative = path13.relative(resolvedBase, resolvedFile);
-    return relative === "" || !relative.startsWith("..") && !path13.isAbsolute(relative);
+    const resolvedFile = path14.resolve(filePath);
+    const resolvedBase = path14.resolve(basePath);
+    const relative = path14.relative(resolvedBase, resolvedFile);
+    return relative === "" || !relative.startsWith("..") && !path14.isAbsolute(relative);
   }
   safeAttachmentFileName(fileName) {
-    const baseName = path13.basename(fileName).replace(/[\0/:\\]/g, "_").trim();
+    const baseName = path14.basename(fileName).replace(/[\0/:\\]/g, "_").trim();
     return baseName || "attachment";
   }
   emitTaskPushError(runtime, task, error51) {
@@ -32765,6 +33151,7 @@ ${lines.join("\n")}`;
     proc.currentToolName = null;
     proc.segmentBuffer = "";
     proc.segmentCount = 0;
+    proc.workdirSignals = [];
   }
   clearPostMergeContinuationTimer(runtime) {
     if (runtime.postMergeContinuationTimer) {
@@ -35078,8 +35465,8 @@ async function readJson(res) {
     return null;
   }
 }
-function apiUrl(baseUrl, path34) {
-  return new URL(path34, baseUrl).toString();
+function apiUrl(baseUrl, path35) {
+  return new URL(path35, baseUrl).toString();
 }
 async function fetchServerSkillSet(options) {
   try {
@@ -35333,8 +35720,8 @@ var HttpAgentRegistry = class {
   lastRefreshCount = null;
   apiUrl(suffix) {
     const base = this.serverApiUrl.replace(/\/$/, "");
-    const path34 = suffix.startsWith("/") ? suffix : `/${suffix}`;
-    return `${base}${path34}`;
+    const path35 = suffix.startsWith("/") ? suffix : `/${suffix}`;
+    return `${base}${path35}`;
   }
   async refresh() {
     const attempt = async () => {
@@ -35437,8 +35824,8 @@ var HttpSubscriptionRegistry = class {
   lastRefreshCount = null;
   apiUrl(suffix) {
     const base = this.serverApiUrl.replace(/\/$/, "");
-    const path34 = suffix.startsWith("/") ? suffix : `/${suffix}`;
-    return `${base}${path34}`;
+    const path35 = suffix.startsWith("/") ? suffix : `/${suffix}`;
+    return `${base}${path35}`;
   }
   rebuildPrimaryAlias() {
     this.subscriptions.delete(PRIMARY_COMPANY_SUBSCRIPTION_ID);
@@ -35516,8 +35903,8 @@ var HttpSubscriptionRegistry = class {
 };
 
 // src/mcpRegistry.ts
-import fs7 from "fs";
-import path14 from "path";
+import fs8 from "fs";
+import path15 from "path";
 import { fileURLToPath } from "url";
 var logger19 = createModuleLogger("mcp.registry");
 var AHCHAT_BUILTIN_MCP_COMMAND = "ahchat-builtin";
@@ -35535,11 +35922,12 @@ var HttpMcpRegistry = class {
   localStore;
   serverConnections = /* @__PURE__ */ new Map();
   localConnections = /* @__PURE__ */ new Map();
+  missingSecretWarnedKeys = /* @__PURE__ */ new Set();
   lastRefreshCount = null;
   apiUrl(suffix) {
     const base = this.serverApiUrl.replace(/\/$/, "");
-    const path34 = suffix.startsWith("/") ? suffix : `/${suffix}`;
-    return `${base}${path34}`;
+    const path35 = suffix.startsWith("/") ? suffix : `/${suffix}`;
+    return `${base}${path35}`;
   }
   async refresh() {
     this.refreshLocal();
@@ -35635,13 +36023,19 @@ var HttpMcpRegistry = class {
       return false;
     });
   }
+  warnMissingSecretOnce(connection) {
+    const key = `${connection.id}:${connection.providerId}:${connection.serverName}`;
+    if (this.missingSecretWarnedKeys.has(key)) return;
+    this.missingSecretWarnedKeys.add(key);
+    logger19.warn("Skipping MCP connection without required secret", {
+      id: connection.id,
+      providerId: connection.providerId,
+      serverName: connection.serverName
+    });
+  }
   toSdkServerConfig(connection, ctx) {
     if (mcpConnectionRequiresSecret(connection) && !connection.hasAuthSecret) {
-      logger19.warn("Skipping MCP connection without required secret", {
-        id: connection.id,
-        providerId: connection.providerId,
-        serverName: connection.serverName
-      });
+      this.warnMissingSecretOnce(connection);
       return null;
     }
     const policies = toolPolicies(connection);
@@ -35725,13 +36119,13 @@ function resolveVisionMcpExecutable(extraArgs, options = {}) {
   return resolveBundledMcpExecutable("visionMcpCli", extraArgs, options);
 }
 function resolveBundledMcpExecutable(cliBaseName, extraArgs, options = {}) {
-  const currentDir = options.currentDir ?? path14.dirname(fileURLToPath(import.meta.url));
+  const currentDir = options.currentDir ?? path15.dirname(fileURLToPath(import.meta.url));
   const cwd = options.cwd ?? process.cwd();
   const execPath = options.execPath ?? process.execPath;
-  const existsSync3 = options.existsSync ?? fs7.existsSync;
+  const existsSync3 = options.existsSync ?? fs8.existsSync;
   const distCliPath = firstExistingPath(
     [
-      path14.join(currentDir, `${cliBaseName}.cjs`)
+      path15.join(currentDir, `${cliBaseName}.cjs`)
     ],
     existsSync3
   );
@@ -35744,7 +36138,7 @@ function resolveBundledMcpExecutable(cliBaseName, extraArgs, options = {}) {
   }
   const sourceCliPath = firstExistingPath(
     [
-      path14.join(currentDir, `${cliBaseName}.ts`)
+      path15.join(currentDir, `${cliBaseName}.ts`)
     ],
     existsSync3
   );
@@ -35753,9 +36147,9 @@ function resolveBundledMcpExecutable(cliBaseName, extraArgs, options = {}) {
   }
   const workspaceDistCliPath = firstExistingPath(
     [
-      path14.resolve(currentDir, `../../bridge/dist/${cliBaseName}.cjs`),
-      path14.resolve(cwd, `packages/desktop/dist/${cliBaseName}.cjs`),
-      path14.resolve(cwd, `packages/bridge/dist/${cliBaseName}.cjs`)
+      path15.resolve(currentDir, `../../bridge/dist/${cliBaseName}.cjs`),
+      path15.resolve(cwd, `packages/desktop/dist/${cliBaseName}.cjs`),
+      path15.resolve(cwd, `packages/bridge/dist/${cliBaseName}.cjs`)
     ],
     existsSync3
   );
@@ -35768,8 +36162,8 @@ function resolveBundledMcpExecutable(cliBaseName, extraArgs, options = {}) {
   }
   const workspaceSourceCliPath = firstExistingPath(
     [
-      path14.resolve(currentDir, `../../bridge/src/${cliBaseName}.ts`),
-      path14.resolve(cwd, `packages/bridge/src/${cliBaseName}.ts`)
+      path15.resolve(currentDir, `../../bridge/src/${cliBaseName}.ts`),
+      path15.resolve(cwd, `packages/bridge/src/${cliBaseName}.ts`)
     ],
     existsSync3
   );
@@ -35790,7 +36184,7 @@ function firstExistingPath(paths, existsSync3) {
 function shouldRunExecPathAsNode(execPath, options) {
   if (typeof options.isElectron === "boolean") return options.isElectron;
   if (process.versions.electron) return true;
-  return path14.basename(execPath).toLowerCase().includes("electron");
+  return path15.basename(execPath).toLowerCase().includes("electron");
 }
 function uniqueServerName(serverName, usedNames) {
   if (!usedNames.has(serverName)) return serverName;
@@ -35828,19 +36222,19 @@ function toolPolicies(connection) {
 }
 
 // src/localMcpStore.ts
-import fs8 from "fs";
-import path15 from "path";
+import fs9 from "fs";
+import path16 from "path";
 var logger20 = createModuleLogger("bridge.localMcpStore");
 var LocalMcpStore = class {
   constructor(dataDir) {
     this.dataDir = dataDir;
-    this.filePath = path15.join(dataDir, LOCAL_MCP_CONNECTIONS_FILENAME);
+    this.filePath = path16.join(dataDir, LOCAL_MCP_CONNECTIONS_FILENAME);
   }
   dataDir;
   filePath;
   list() {
     try {
-      const raw = fs8.readFileSync(this.filePath, "utf8");
+      const raw = fs9.readFileSync(this.filePath, "utf8");
       return normalizeLocalMcpConnectionsFile(JSON.parse(raw)).connections;
     } catch (error51) {
       if (isNodeErrorCode(error51, "ENOENT")) return [];
@@ -35849,14 +36243,14 @@ var LocalMcpStore = class {
     }
   }
   watch(onChange) {
-    fs8.mkdirSync(this.dataDir, { recursive: true });
+    fs9.mkdirSync(this.dataDir, { recursive: true });
     const listener = () => {
       void Promise.resolve(onChange()).catch((error51) => {
         logger20.error("Local MCP change handler failed", { filePath: this.filePath, error: error51 });
       });
     };
-    fs8.watchFile(this.filePath, { interval: 1e3 }, listener);
-    return () => fs8.unwatchFile(this.filePath, listener);
+    fs9.watchFile(this.filePath, { interval: 1e3 }, listener);
+    return () => fs9.unwatchFile(this.filePath, listener);
   }
 };
 function isNodeErrorCode(error51, code) {
@@ -35864,13 +36258,13 @@ function isNodeErrorCode(error51, code) {
 }
 
 // src/localSkillStore.ts
-import fs9 from "fs";
-import path16 from "path";
+import fs10 from "fs";
+import path17 from "path";
 var logger21 = createModuleLogger("bridge.localSkillStore");
 var LocalSkillStore = class {
   constructor(dataDir, runtimeScope = {}) {
     this.dataDir = dataDir;
-    this.filePath = path16.join(dataDir, LOCAL_SKILLS_FILENAME);
+    this.filePath = path17.join(dataDir, LOCAL_SKILLS_FILENAME);
     this.runtimeScope = runtimeScope;
   }
   dataDir;
@@ -35881,7 +36275,7 @@ var LocalSkillStore = class {
   }
   readAll() {
     try {
-      const raw = fs9.readFileSync(this.filePath, "utf8");
+      const raw = fs10.readFileSync(this.filePath, "utf8");
       return normalizeLocalSkillsFile(JSON.parse(raw)).skills;
     } catch (error51) {
       if (isNodeErrorCode2(error51, "ENOENT")) return [];
@@ -35925,24 +36319,24 @@ var LocalSkillStore = class {
     return nextEntry;
   }
   watch(onChange) {
-    fs9.mkdirSync(this.dataDir, { recursive: true });
+    fs10.mkdirSync(this.dataDir, { recursive: true });
     const listener = () => {
       void Promise.resolve(onChange()).catch((error51) => {
         logger21.error("Local skill change handler failed", { filePath: this.filePath, error: error51 });
       });
     };
-    fs9.watchFile(this.filePath, { interval: 1e3 }, listener);
-    return () => fs9.unwatchFile(this.filePath, listener);
+    fs10.watchFile(this.filePath, { interval: 1e3 }, listener);
+    return () => fs10.unwatchFile(this.filePath, listener);
   }
   write(skills) {
-    fs9.mkdirSync(this.dataDir, { recursive: true });
+    fs10.mkdirSync(this.dataDir, { recursive: true });
     const payload = normalizeLocalSkillsFile({ version: 1, skills });
     const tmpPath = `${this.filePath}.tmp`;
-    fs9.writeFileSync(tmpPath, `${JSON.stringify(payload, null, 2)}
+    fs10.writeFileSync(tmpPath, `${JSON.stringify(payload, null, 2)}
 `, { encoding: "utf8", mode: 384 });
-    fs9.renameSync(tmpPath, this.filePath);
+    fs10.renameSync(tmpPath, this.filePath);
     try {
-      fs9.chmodSync(this.filePath, 384);
+      fs10.chmodSync(this.filePath, 384);
     } catch (error51) {
       logger21.warn("Failed to harden local skill file permissions", { filePath: this.filePath, error: error51 });
     }
@@ -36626,9 +37020,9 @@ var ServerConnector = class {
 };
 
 // src/contextDumper.ts
-import fs10 from "fs/promises";
+import fs11 from "fs/promises";
 import os9 from "os";
-import path17 from "path";
+import path18 from "path";
 import * as sdk3 from "@anthropic-ai/claude-agent-sdk";
 var logger24 = createModuleLogger("bridge.contextDumper");
 var TRUNCATE_THRESHOLD = 5e4;
@@ -36658,11 +37052,11 @@ function cwdToProjectSlug(cwd) {
 }
 function resolveJsonlPathInProjectsDir(projectsDir, sessionId, cwd) {
   const slug = cwdToProjectSlug(cwd);
-  return path17.join(projectsDir, slug, `${sessionId}.jsonl`);
+  return path18.join(projectsDir, slug, `${sessionId}.jsonl`);
 }
 function resolveProjectDirInProjectsDir(projectsDir, cwd) {
   const slug = cwdToProjectSlug(cwd);
-  return path17.join(projectsDir, slug);
+  return path18.join(projectsDir, slug);
 }
 function errorCode(e) {
   if (e instanceof Error && "code" in e) {
@@ -36673,7 +37067,7 @@ function errorCode(e) {
 }
 async function isReadableFile(filePath) {
   try {
-    const stat3 = await fs10.stat(filePath);
+    const stat3 = await fs11.stat(filePath);
     return stat3.isFile();
   } catch (e) {
     const code = errorCode(e);
@@ -36688,7 +37082,7 @@ function uniquePaths(paths) {
   for (const p of paths) {
     const trimmed = p.trim();
     if (!trimmed) continue;
-    const key = path17.normalize(trimmed);
+    const key = path18.normalize(trimmed);
     if (seen.has(key)) continue;
     seen.add(key);
     out.push(trimmed);
@@ -36704,7 +37098,7 @@ function inferAhchatUserAgentConfigDir(workdir) {
   const userSlug = afterMarker.split("/").find(Boolean);
   if (!userSlug) return null;
   const userDataDir2 = normalized.slice(0, markerIndex + marker.length + userSlug.length);
-  return path17.join(path17.normalize(userDataDir2), "agent-config");
+  return path18.join(path18.normalize(userDataDir2), "agent-config");
 }
 function inferredAgentConfigDirsFromWorkdirs(workdirs) {
   return uniquePaths(workdirs.map((workdir) => inferAhchatUserAgentConfigDir(workdir) ?? ""));
@@ -36717,19 +37111,19 @@ function claudeProjectsDirs(opts) {
   ]);
   return uniquePaths([
     ...configDirs.flatMap((configDir) => [
-      path17.join(configDir, "api-key-agents", opts.agentId, "projects"),
-      path17.join(configDir, "projects")
+      path18.join(configDir, "api-key-agents", opts.agentId, "projects"),
+      path18.join(configDir, "projects")
     ]),
-    path17.join(os9.homedir(), ".claude", "projects")
+    path18.join(os9.homedir(), ".claude", "projects")
   ]);
 }
 function fallbackBridgeWorkspacePath(requestedCwd, workspacesDir, fallbackSegment) {
   const suffix = extractAhchatWorkspaceSuffix(requestedCwd);
-  if (suffix) return path17.join(workspacesDir, suffix);
+  if (suffix) return path18.join(workspacesDir, suffix);
   const normalized = requestedCwd.trim();
-  const basename = normalized ? path17.basename(path17.normalize(normalized)) : "";
-  const segment = basename && basename !== "." && basename !== path17.sep ? basename : fallbackSegment;
-  return path17.join(workspacesDir, segment);
+  const basename = normalized ? path18.basename(path18.normalize(normalized)) : "";
+  const segment = basename && basename !== "." && basename !== path18.sep ? basename : fallbackSegment;
+  return path18.join(workspacesDir, segment);
 }
 function cwdCandidatesForBridge(requestedCwd, opts) {
   const candidates = [requestedCwd];
@@ -36765,11 +37159,11 @@ async function resolveDumpWorkdir(requestedCwd, opts) {
     return remapped.path;
   }
   try {
-    await fs10.mkdir(requestedCwd, { recursive: true });
+    await fs11.mkdir(requestedCwd, { recursive: true });
     return requestedCwd;
   } catch (e) {
     const fallback = fallbackBridgeWorkspacePath(requestedCwd, opts.workspacesDir, opts.fallbackSegment);
-    if (path17.normalize(fallback) === path17.normalize(requestedCwd)) throw e;
+    if (path18.normalize(fallback) === path18.normalize(requestedCwd)) throw e;
     logger24.warn("Dump workdir inaccessible; using local Bridge workspace fallback", {
       agentId: opts.agentId,
       requested: requestedCwd,
@@ -36783,7 +37177,7 @@ async function findJsonlInClaudeProjects(sessionId, projectsDirs) {
   for (const projectsDir of projectsDirs) {
     let dirs;
     try {
-      dirs = await fs10.readdir(projectsDir, { withFileTypes: true });
+      dirs = await fs11.readdir(projectsDir, { withFileTypes: true });
     } catch (e) {
       const code = errorCode(e);
       if (code === "ENOENT" || code === "ENOTDIR") continue;
@@ -36792,7 +37186,7 @@ async function findJsonlInClaudeProjects(sessionId, projectsDirs) {
     }
     for (const dir of dirs) {
       if (!dir.isDirectory()) continue;
-      const candidate = path17.join(projectsDir, dir.name, `${sessionId}.jsonl`);
+      const candidate = path18.join(projectsDir, dir.name, `${sessionId}.jsonl`);
       if (await isReadableFile(candidate)) return candidate;
     }
   }
@@ -36801,7 +37195,7 @@ async function findJsonlInClaudeProjects(sessionId, projectsDirs) {
 async function latestJsonlInProjectDir(projectDir) {
   let entries;
   try {
-    entries = await fs10.readdir(projectDir, { withFileTypes: true });
+    entries = await fs11.readdir(projectDir, { withFileTypes: true });
   } catch (e) {
     const code = errorCode(e);
     if (code === "ENOENT" || code === "ENOTDIR") return null;
@@ -36811,15 +37205,15 @@ async function latestJsonlInProjectDir(projectDir) {
   let latest = null;
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
-    const jsonlPath = path17.join(projectDir, entry.name);
+    const jsonlPath = path18.join(projectDir, entry.name);
     let stat3;
     try {
-      stat3 = await fs10.stat(jsonlPath);
+      stat3 = await fs11.stat(jsonlPath);
     } catch (e) {
       logger24.warn("Discovered JSONL stat failed", { jsonlPath, error: e });
       continue;
     }
-    const sessionId = path17.basename(entry.name, ".jsonl");
+    const sessionId = path18.basename(entry.name, ".jsonl");
     const discovered = { sessionId, jsonlPath, lastModified: stat3.mtimeMs };
     if (!latest || discovered.lastModified > latest.lastModified) {
       latest = discovered;
@@ -36828,8 +37222,8 @@ async function latestJsonlInProjectDir(projectDir) {
   return latest;
 }
 function isAgentIsolatedProjectsDir(projectsDir, agentId) {
-  const normalized = path17.normalize(projectsDir).toLowerCase();
-  const marker = path17.normalize(path17.join("api-key-agents", agentId, "projects")).toLowerCase();
+  const normalized = path18.normalize(projectsDir).toLowerCase();
+  const marker = path18.normalize(path18.join("api-key-agents", agentId, "projects")).toLowerCase();
   return normalized.endsWith(marker);
 }
 async function discoverLatestJsonlForScope(opts) {
@@ -36848,7 +37242,7 @@ async function discoverLatestJsonlForScope(opts) {
       if (!isAgentIsolatedProjectsDir(projectsDir, opts.agentId)) continue;
       let dirs;
       try {
-        dirs = await fs10.readdir(projectsDir, { withFileTypes: true });
+        dirs = await fs11.readdir(projectsDir, { withFileTypes: true });
       } catch (e) {
         const code = errorCode(e);
         if (code === "ENOENT" || code === "ENOTDIR") continue;
@@ -36857,7 +37251,7 @@ async function discoverLatestJsonlForScope(opts) {
       }
       for (const dir of dirs) {
         if (!dir.isDirectory()) continue;
-        const latest = await latestJsonlInProjectDir(path17.join(projectsDir, dir.name));
+        const latest = await latestJsonlInProjectDir(path18.join(projectsDir, dir.name));
         if (latest) discovered.push(latest);
       }
     }
@@ -36894,7 +37288,7 @@ function friendlyScopeError(e) {
 }
 var RENDERABLE_TYPES = /* @__PURE__ */ new Set(["user", "assistant", "system", "attachment"]);
 async function readJsonlEntries(filePath) {
-  const raw = await fs10.readFile(filePath, "utf-8");
+  const raw = await fs11.readFile(filePath, "utf-8");
   const entries = [];
   for (const line of raw.split("\n")) {
     const trimmed = line.trim();
@@ -37250,8 +37644,8 @@ async function dumpAgentContext(agentId, deps) {
     agentId,
     workdirOverrideStore: deps.workdirOverrideStore
   });
-  const dumpDir = path17.join(localWorkdir, "sessioninfo");
-  await fs10.mkdir(dumpDir, { recursive: true });
+  const dumpDir = path18.join(localWorkdir, "sessioninfo");
+  await fs11.mkdir(dumpDir, { recursive: true });
   const groupWorkdirs = deps.groupRegistry?.getMyGroups(agentId).map((group) => group.workingDirectory) ?? [];
   const inferredAgentConfigDirs = inferredAgentConfigDirsFromWorkdirs([
     workdir,
@@ -37329,7 +37723,7 @@ async function dumpAgentContext(agentId, deps) {
         projectsDirs,
         sessionStore: deps.sessionStore
       });
-      resolvedSessionId = recovered ? path17.basename(jsonlPath, ".jsonl") : resolvedSessionId;
+      resolvedSessionId = recovered ? path18.basename(jsonlPath, ".jsonl") : resolvedSessionId;
       if (recovered) {
         try {
           const info = await sdk3.getSessionInfo(resolvedSessionId);
@@ -37378,10 +37772,10 @@ async function dumpAgentContext(agentId, deps) {
         jsonlPath
       });
       const filename = scopeFilename(agent.name, scopeKey2, groupName);
-      const filePath = path17.join(dumpDir, filename);
-      await fs10.writeFile(filePath, html, "utf-8");
+      const filePath = path18.join(dumpDir, filename);
+      await fs11.writeFile(filePath, html, "utf-8");
       dumpedFiles.push(filename);
-      const stat3 = await fs10.stat(filePath);
+      const stat3 = await fs11.stat(filePath);
       logger24.info("Scope context dumped", {
         agentId,
         scopeKey: scopeKey2,
@@ -37421,9 +37815,9 @@ async function dumpAgentContext(agentId, deps) {
 // src/clipboardFiles.ts
 import { execFile as execFile2 } from "child_process";
 import crypto3 from "crypto";
-import fs11 from "fs/promises";
+import fs12 from "fs/promises";
 import os10 from "os";
-import path18 from "path";
+import path19 from "path";
 import { promisify as promisify2 } from "util";
 var logger25 = createModuleLogger("bridge.clipboardFiles");
 var execFileAsync2 = promisify2(execFile2);
@@ -37434,28 +37828,28 @@ function isRecord5(value) {
 }
 function normalizeLocalPath(targetPath) {
   const trimmed = targetPath.trim();
-  const expanded = trimmed === "~" || trimmed.startsWith("~/") || trimmed.startsWith("~\\") ? path18.join(os10.homedir(), trimmed.slice(2)) : trimmed;
-  return path18.normalize(path18.resolve(expanded));
+  const expanded = trimmed === "~" || trimmed.startsWith("~/") || trimmed.startsWith("~\\") ? path19.join(os10.homedir(), trimmed.slice(2)) : trimmed;
+  return path19.normalize(path19.resolve(expanded));
 }
 function normalizeClipboardIdentityKey(value) {
   return process.platform === "win32" ? value.toLowerCase() : value;
 }
 async function resolveClipboardPathKey(resolvedPath) {
   try {
-    return normalizeClipboardIdentityKey(await fs11.realpath(resolvedPath));
+    return normalizeClipboardIdentityKey(await fs12.realpath(resolvedPath));
   } catch (e) {
     logger25.debug("Clipboard realpath read skipped", { error: e, path: resolvedPath });
     return normalizeClipboardIdentityKey(resolvedPath);
   }
 }
 function looksLikeWindowsShortFileName(fileName) {
-  return /~\d/i.test(path18.basename(fileName));
+  return /~\d/i.test(path19.basename(fileName));
 }
 function fileContentHash(buffer) {
   return crypto3.createHash("sha256").update(buffer).digest("hex");
 }
 function mimeTypeForFileName(fileName) {
-  const ext = path18.extname(fileName).toLowerCase();
+  const ext = path19.extname(fileName).toLowerCase();
   if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
   if (ext === ".png") return "image/png";
   if (ext === ".webp") return "image/webp";
@@ -37520,7 +37914,7 @@ async function readWindowsClipboardPathCandidates() {
   }
 }
 async function filePayloadFromPath(resolvedPath) {
-  const stat3 = await fs11.stat(resolvedPath);
+  const stat3 = await fs12.stat(resolvedPath);
   if (!stat3.isFile()) return null;
   if (stat3.size > MAX_CLIPBOARD_FILE_SIZE) {
     logger25.warn("Clipboard file skipped because it is too large", {
@@ -37529,10 +37923,10 @@ async function filePayloadFromPath(resolvedPath) {
     });
     return null;
   }
-  const buffer = await fs11.readFile(resolvedPath);
+  const buffer = await fs12.readFile(resolvedPath);
   const mimeType = mimeTypeForFileName(resolvedPath);
   return {
-    fileName: path18.basename(resolvedPath),
+    fileName: path19.basename(resolvedPath),
     mimeType,
     contentBase64: buffer.toString("base64"),
     size: buffer.length,
@@ -37556,7 +37950,7 @@ async function readClipboardFiles() {
   const contentIndexes = /* @__PURE__ */ new Map();
   for (const resolvedPath of pathCandidates) {
     try {
-      const stat3 = await fs11.stat(resolvedPath);
+      const stat3 = await fs12.stat(resolvedPath);
       if (stat3.isDirectory()) {
         skippedDirectoryCount += 1;
         continue;
@@ -37605,8 +37999,8 @@ async function readClipboardFiles() {
 }
 
 // src/listDir.ts
-import fs12 from "fs/promises";
-import path19 from "path";
+import fs13 from "fs/promises";
+import path20 from "path";
 var logger26 = createModuleLogger("bridge.listDir");
 function shouldIncludeEntry(name) {
   if (!name.startsWith(".")) return true;
@@ -37615,16 +38009,16 @@ function shouldIncludeEntry(name) {
 async function listDirectoryEntries(dirPath) {
   const resolvedDirPath = resolveUserPath(dirPath);
   logger26.info("listDirectoryEntries start", { path: dirPath, resolvedPath: resolvedDirPath });
-  const raw = await fs12.readdir(resolvedDirPath, { withFileTypes: true });
+  const raw = await fs13.readdir(resolvedDirPath, { withFileTypes: true });
   const entries = [];
   for (const entry of raw) {
     if (!shouldIncludeEntry(entry.name)) continue;
-    const fullPath = path19.join(resolvedDirPath, entry.name);
+    const fullPath = path20.join(resolvedDirPath, entry.name);
     const isDir = entry.isDirectory();
     let size;
     let mtime;
     try {
-      const stat3 = await fs12.stat(fullPath);
+      const stat3 = await fs13.stat(fullPath);
       mtime = stat3.mtime.toISOString();
       if (!isDir) size = stat3.size;
     } catch (statErr) {
@@ -37653,20 +38047,20 @@ function normalizeRelativePath(relativePath) {
   return normalized;
 }
 function ensureInsideBase(baseDir, targetPath) {
-  const relative = path19.relative(baseDir, targetPath);
-  if (relative.startsWith("..") || path19.isAbsolute(relative)) {
+  const relative = path20.relative(baseDir, targetPath);
+  if (relative.startsWith("..") || path20.isAbsolute(relative)) {
     throw new Error("path is outside working directory");
   }
 }
 function ensureNotBaseDir(baseDir, targetPath) {
-  if (path19.relative(baseDir, targetPath) === "") {
+  if (path20.relative(baseDir, targetPath) === "") {
     throw new Error("refusing to delete working directory root");
   }
 }
 async function ensureRealPathInsideBase(baseDir, targetPath) {
   const [realBase, realTarget] = await Promise.all([
-    fs12.realpath(baseDir),
-    fs12.realpath(targetPath)
+    fs13.realpath(baseDir),
+    fs13.realpath(targetPath)
   ]);
   ensureInsideBase(realBase, realTarget);
   return realTarget;
@@ -37674,11 +38068,11 @@ async function ensureRealPathInsideBase(baseDir, targetPath) {
 async function writeWorkdirFile(opts) {
   const resolvedBaseDir = resolveUserPath(opts.baseDir);
   const safeRelativePath = normalizeRelativePath(opts.relativePath);
-  const targetPath = path19.resolve(resolvedBaseDir, safeRelativePath);
+  const targetPath = path20.resolve(resolvedBaseDir, safeRelativePath);
   ensureInsideBase(resolvedBaseDir, targetPath);
   const buffer = Buffer.from(opts.contentBase64, "base64");
-  await fs12.mkdir(path19.dirname(targetPath), { recursive: true });
-  await fs12.writeFile(targetPath, buffer, { flag: opts.overwrite ? "w" : "wx" });
+  await fs13.mkdir(path20.dirname(targetPath), { recursive: true });
+  await fs13.writeFile(targetPath, buffer, { flag: opts.overwrite ? "w" : "wx" });
   logger26.info("writeWorkdirFile ok", {
     baseDir: opts.baseDir,
     path: targetPath,
@@ -37690,12 +38084,12 @@ async function writeWorkdirFile(opts) {
 async function readWorkdirFile(filePath, baseDir) {
   const resolvedPath = resolveUserPath(filePath);
   const safePath = baseDir ? await ensureRealPathInsideBase(resolveUserPath(baseDir), resolvedPath) : resolvedPath;
-  const stat3 = await fs12.stat(safePath);
+  const stat3 = await fs13.stat(safePath);
   if (!stat3.isFile()) throw new Error("path is not a file");
-  const buffer = await fs12.readFile(safePath);
+  const buffer = await fs13.readFile(safePath);
   logger26.info("readWorkdirFile ok", { path: filePath, baseDir, resolvedPath: safePath, size: buffer.length });
   return {
-    fileName: path19.basename(safePath),
+    fileName: path20.basename(safePath),
     contentBase64: buffer.toString("base64"),
     size: buffer.length
   };
@@ -37705,9 +38099,9 @@ async function allocateTrashPath(trashDir, name) {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   for (let index = 0; index < 1e3; index += 1) {
     const suffix = index === 0 ? "" : `-${index}`;
-    const candidate = path19.join(trashDir, `${stamp}-${safeName}${suffix}`);
+    const candidate = path20.join(trashDir, `${stamp}-${safeName}${suffix}`);
     try {
-      await fs12.lstat(candidate);
+      await fs13.lstat(candidate);
     } catch (e) {
       if (e instanceof Error && "code" in e && e.code === "ENOENT") return candidate;
       throw e;
@@ -37723,15 +38117,15 @@ async function trashWorkdirPath(opts) {
   const resolvedBaseDir = resolveUserPath(opts.baseDir);
   const resolvedTargetPath = resolveUserPath(opts.targetPath);
   const [realBase, realTarget] = await Promise.all([
-    fs12.realpath(resolvedBaseDir),
-    fs12.realpath(resolvedTargetPath)
+    fs13.realpath(resolvedBaseDir),
+    fs13.realpath(resolvedTargetPath)
   ]);
   ensureInsideBase(realBase, realTarget);
   ensureNotBaseDir(realBase, realTarget);
-  const trashDir = path19.join(resolvedBaseDir, ".ahchat-trash");
-  await fs12.mkdir(trashDir, { recursive: true });
-  const trashedPath = await allocateTrashPath(trashDir, path19.basename(resolvedTargetPath));
-  await fs12.rename(resolvedTargetPath, trashedPath);
+  const trashDir = path20.join(resolvedBaseDir, ".ahchat-trash");
+  await fs13.mkdir(trashDir, { recursive: true });
+  const trashedPath = await allocateTrashPath(trashDir, path20.basename(resolvedTargetPath));
+  await fs13.rename(resolvedTargetPath, trashedPath);
   logger26.info("trashWorkdirPath ok", {
     path: opts.targetPath,
     baseDir: opts.baseDir,
@@ -37742,8 +38136,8 @@ async function trashWorkdirPath(opts) {
 }
 
 // src/logScanner.ts
-import fs13 from "fs";
-import path20 from "path";
+import fs14 from "fs";
+import path21 from "path";
 import os11 from "os";
 import readline from "readline";
 var logger27 = createModuleLogger("bridge.logScanner");
@@ -37751,18 +38145,18 @@ var MAX_LIMIT = 2e3;
 function listLogFiles(logsDir, baseName) {
   let names;
   try {
-    names = fs13.readdirSync(logsDir);
+    names = fs14.readdirSync(logsDir);
   } catch (e) {
     logger27.warn("listLogFiles: readdir failed", { logsDir, error: e });
     return [];
   }
   const escapedBaseName = baseName.replace(".", "\\.");
   const pattern = new RegExp(`^${escapedBaseName}(?:[.-].+)?$`);
-  return names.filter((n) => pattern.test(n)).map((n) => path20.join(logsDir, n));
+  return names.filter((n) => pattern.test(n)).map((n) => path21.join(logsDir, n));
 }
 async function scanFile(filePath, source, filter, state) {
-  const file2 = path20.basename(filePath);
-  const stream = fs13.createReadStream(filePath, { encoding: "utf-8" });
+  const file2 = path21.basename(filePath);
+  const stream = fs14.createReadStream(filePath, { encoding: "utf-8" });
   const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
   let lineNum = 0;
   for await (const line of rl) {
@@ -37805,7 +38199,7 @@ async function scanLocalLogs(logsDir, baseName, filter) {
   };
 }
 async function scanBridgeLogs(filter) {
-  const logDir = path20.join(loadBridgeConfig().dataDir || path20.join(os11.homedir(), ".ahchat"), "logs");
+  const logDir = path21.join(loadBridgeConfig().dataDir || path21.join(os11.homedir(), ".ahchat"), "logs");
   logger27.info("scanBridgeLogs start", {
     logDir,
     startIso: filter.startIso,
@@ -37824,34 +38218,73 @@ async function scanBridgeLogs(filter) {
 }
 
 // src/logUploader.ts
-import fs14 from "fs";
+import fs15 from "fs";
 import fsp from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 var logger28 = createModuleLogger("bridge.logUploader");
+var STALE_RATE_LIMIT_SKIP_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
 var DEFAULT_LOG_UPLOAD_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var DEFAULT_BATCH_SIZE = 200;
+var MAX_UPLOAD_CHUNK_BODY_BYTES = 448 * 1024;
+var MAX_UPLOAD_RETRY_AFTER_MS = 24 * 60 * 60 * 1e3;
+var LogUploadHttpError = class extends Error {
+  status;
+  scope;
+  retryAfterMs;
+  constructor(status, bodyText) {
+    const parsed = parseUploadErrorBody(bodyText);
+    const summary = parsed.error ?? bodyText;
+    super(`upload failed HTTP ${status}: ${summary.slice(0, 160)}`);
+    this.name = "LogUploadHttpError";
+    this.status = status;
+    if (parsed.scope) this.scope = parsed.scope;
+    if (parsed.retryAfterMs !== void 0) this.retryAfterMs = parsed.retryAfterMs;
+  }
+};
+function normalizeRetryAfterMs(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return void 0;
+  return Math.min(Math.ceil(value), MAX_UPLOAD_RETRY_AFTER_MS);
+}
+function parseUploadErrorBody(bodyText) {
+  try {
+    const parsed = JSON.parse(bodyText);
+    if (typeof parsed !== "object" || parsed === null) return {};
+    const body = parsed;
+    return {
+      ...typeof body.error === "string" && body.error.length > 0 ? { error: body.error } : {},
+      ...typeof body.scope === "string" && body.scope.length > 0 ? { scope: body.scope } : {},
+      ...(() => {
+        const retryAfterMs = normalizeRetryAfterMs(body.retryAfterMs);
+        return retryAfterMs === void 0 ? {} : { retryAfterMs };
+      })()
+    };
+  } catch (e) {
+    logger28.debug("Failed to parse log upload error body", { error: e });
+    return {};
+  }
+}
 function defaultLogFile(dataDir) {
-  return path21.join(dataDir, "logs", "bridge.log");
+  return path22.join(dataDir, "logs", "bridge.log");
 }
 function defaultCursorFile(dataDir) {
-  return path21.join(dataDir, "log-upload-cursor.json");
+  return path22.join(dataDir, "log-upload-cursor.json");
 }
 function uploadedFileName(logFile, explicit) {
   const trimmed = explicit?.trim();
-  return trimmed || path21.basename(logFile);
+  return trimmed || path22.basename(logFile);
 }
 function normalizeTarget(file2, dataDir) {
   const fileName = uploadedFileName(file2.logFile, file2.uploadedFileName);
   const safeName = fileName.replace(/[^a-zA-Z0-9._-]/g, "_");
   return {
     logFile: file2.logFile,
-    cursorFile: file2.cursorFile ?? path21.join(dataDir, `log-upload-cursor-${safeName}.json`),
+    cursorFile: file2.cursorFile ?? path22.join(dataDir, `log-upload-cursor-${safeName}.json`),
     uploadedFileName: fileName
   };
 }
 function cursorFileForLog(dataDir, fileName) {
   const safeName = fileName.replace(/[^a-zA-Z0-9._-]/g, "_");
-  return path21.join(dataDir, `log-upload-cursor-${safeName}.json`);
+  return path22.join(dataDir, `log-upload-cursor-${safeName}.json`);
 }
 function logFileFingerprint(stat3) {
   if (typeof stat3.dev === "number" && typeof stat3.ino === "number" && stat3.ino > 0) {
@@ -37860,8 +38293,8 @@ function logFileFingerprint(stat3) {
   return void 0;
 }
 async function listRotatedBridgeTargets(primary, dataDir) {
-  const logDir = path21.dirname(primary.logFile);
-  const baseName = path21.basename(primary.logFile);
+  const logDir = path22.dirname(primary.logFile);
+  const baseName = path22.basename(primary.logFile);
   let names;
   try {
     names = await fsp.readdir(logDir);
@@ -37874,7 +38307,7 @@ async function listRotatedBridgeTargets(primary, dataDir) {
   return names.filter((name) => pattern.test(name)).sort().map((name) => {
     if (name === baseName) return primary;
     return {
-      logFile: path21.join(logDir, name),
+      logFile: path22.join(logDir, name),
       cursorFile: cursorFileForLog(dataDir, name),
       uploadedFileName: name
     };
@@ -37902,11 +38335,11 @@ async function readCursor(filePath) {
   }
 }
 async function writeCursor(filePath, cursor) {
-  await fsp.mkdir(path21.dirname(filePath), { recursive: true });
+  await fsp.mkdir(path22.dirname(filePath), { recursive: true });
   await fsp.writeFile(filePath, JSON.stringify(cursor), "utf8");
 }
 async function readStreamText(filePath, start) {
-  const stream = fs14.createReadStream(filePath, { start, encoding: "utf8" });
+  const stream = fs15.createReadStream(filePath, { start, encoding: "utf8" });
   let raw = "";
   for await (const chunk of stream) {
     raw += chunk;
@@ -37919,26 +38352,38 @@ function parseProcessedLines(raw, cursor, fileName, fingerprint) {
     return { entries: [], nextCursor: cursor, advanced: false, reason: "partial_line" };
   }
   const processed = raw.slice(0, lastNewline + 1);
-  const lines = processed.split(/\r?\n/);
+  const linePattern = /.*?\n/g;
   const entries = [];
   let lineNum = cursor.lineNum;
-  for (let i = 0; i < lines.length - 1; i += 1) {
-    const line = lines[i] ?? "";
+  let offset = cursor.offset;
+  let match;
+  while ((match = linePattern.exec(processed)) !== null) {
+    const rawLine = match[0];
+    const line = rawLine.endsWith("\r\n") ? rawLine.slice(0, -2) : rawLine.slice(0, -1);
     lineNum += 1;
+    offset += Buffer.byteLength(rawLine, "utf8");
+    const cursorAfter = {
+      offset,
+      lineNum,
+      ...fingerprint ? { fingerprint } : {}
+    };
     if (line.length === 0) continue;
     const parsed = parseLogLine(line);
     if (!parsed) continue;
     entries.push({
-      ...parsed,
-      raw: line,
-      file: fileName,
-      lineNum
+      entry: {
+        ...parsed,
+        raw: line,
+        file: fileName,
+        lineNum
+      },
+      cursorAfter
     });
   }
   return {
     entries,
     nextCursor: {
-      offset: cursor.offset + Buffer.byteLength(processed, "utf8"),
+      offset,
       lineNum,
       ...fingerprint ? { fingerprint } : {}
     },
@@ -37946,15 +38391,35 @@ function parseProcessedLines(raw, cursor, fileName, fingerprint) {
     reason: "advanced"
   };
 }
-function chunkEntries(entries, size) {
-  const chunks = [];
-  for (let i = 0; i < entries.length; i += size) {
-    chunks.push(entries.slice(i, i + size));
+function logEntryTimeRange(entries) {
+  let minTime = Number.POSITIVE_INFINITY;
+  let maxTime = Number.NEGATIVE_INFINITY;
+  let minTs = "";
+  let maxTs = "";
+  for (const entry of entries) {
+    const parsed = Date.parse(entry.ts);
+    if (!Number.isFinite(parsed)) return null;
+    if (parsed < minTime) {
+      minTime = parsed;
+      minTs = entry.ts;
+    }
+    if (parsed > maxTime) {
+      maxTime = parsed;
+      maxTs = entry.ts;
+    }
   }
-  return chunks;
+  if (!minTs || !maxTs) return null;
+  return { minTs, maxTs, maxTime };
+}
+function isStaleRateLimitedChunk(entries, nowMs) {
+  const range = logEntryTimeRange(entries);
+  if (!range) return null;
+  if (nowMs - range.maxTime <= STALE_RATE_LIMIT_SKIP_AGE_MS) return null;
+  return { minTs: range.minTs, maxTs: range.maxTs };
 }
 var BridgeLogUploader = class {
   options;
+  retryAfterByTarget = /* @__PURE__ */ new Map();
   timer = null;
   running = false;
   stopped = false;
@@ -37971,7 +38436,7 @@ var BridgeLogUploader = class {
       bridgeId: options.bridgeId,
       hostname: options.hostname,
       intervalMs: options.intervalMs ?? DEFAULT_LOG_UPLOAD_INTERVAL_MS,
-      batchSize: options.batchSize ?? DEFAULT_BATCH_SIZE,
+      batchSize: Math.max(1, Math.floor(options.batchSize ?? DEFAULT_BATCH_SIZE)),
       primaryTarget,
       extraTargets: (options.extraLogFiles ?? []).map((file2) => normalizeTarget(file2, options.dataDir)),
       includeRotatedBridgeLogs: options.includeRotatedBridgeLogs ?? true
@@ -38013,13 +38478,26 @@ var BridgeLogUploader = class {
       bridgeEntryCount: 0,
       uploadedChunkCount: 0,
       accepted: 0,
-      skipped: 0
+      skipped: 0,
+      dropped: 0
     };
     try {
       const targets = await this.resolveTargets();
       summary.targetCount = targets.length;
       for (const target of targets) {
+        const targetKey = this.targetKey(target);
         try {
+          const retryUntil = this.retryAfterByTarget.get(targetKey);
+          const now = Date.now();
+          if (retryUntil && retryUntil > now) {
+            summary.idleTargetCount += 1;
+            logger28.debug("Bridge log upload target backoff active", {
+              logFile: target.logFile,
+              retryAfterMs: retryUntil - now
+            });
+            continue;
+          }
+          if (retryUntil) this.retryAfterByTarget.delete(targetKey);
           const cursor = await readCursor(target.cursorFile);
           const batch = await this.readNewEntries(target, cursor);
           if (!batch.advanced) {
@@ -38031,28 +38509,45 @@ var BridgeLogUploader = class {
           summary.advancedTargetCount += 1;
           summary.parsedEntryCount += batch.entries.length;
           if (batch.entries.length > 0) {
-            const result = await this.uploadEntries(batch.entries);
+            const result = await this.uploadEntries(batch.entries, target.cursorFile, batch.nextCursor);
             summary.bridgeEntryCount += result.bridgeEntryCount;
             summary.uploadedChunkCount += result.uploadedChunkCount;
             summary.accepted += result.accepted;
             summary.skipped += result.skipped;
+            summary.dropped += result.dropped;
+          } else {
+            await writeCursor(target.cursorFile, batch.nextCursor);
           }
-          await writeCursor(target.cursorFile, batch.nextCursor);
+          this.retryAfterByTarget.delete(targetKey);
         } catch (e) {
           summary.failedTargetCount += 1;
-          logger28.warn("Bridge log upload target failed", { error: e, logFile: target.logFile });
+          if (e instanceof LogUploadHttpError && e.retryAfterMs !== void 0) {
+            this.retryAfterByTarget.set(targetKey, Date.now() + e.retryAfterMs);
+            logger28.warn("Bridge log upload target failed", {
+              error: e,
+              logFile: target.logFile,
+              status: e.status,
+              quotaScope: e.scope,
+              retryAfterMs: e.retryAfterMs
+            });
+          } else {
+            logger28.warn("Bridge log upload target failed", { error: e, logFile: target.logFile });
+          }
         }
       }
     } catch (e) {
       logger28.warn("Bridge log upload cycle failed", { error: e });
     } finally {
-      logger28.info("Bridge log upload cycle summary", {
+      logger28.debug("Bridge log upload cycle summary", {
         ...summary,
         durationMs: Date.now() - startedAt
       });
       this.running = false;
     }
   }
+  targetKey(target) {
+    return `${target.logFile}\0${target.cursorFile}`;
+  }
   async resolveTargets() {
     const bridgeTargets = this.options.includeRotatedBridgeLogs ? await listRotatedBridgeTargets(this.options.primaryTarget, this.options.dataDir) : [this.options.primaryTarget];
     const seen = /* @__PURE__ */ new Set();
@@ -38085,15 +38580,40 @@ var BridgeLogUploader = class {
     const raw = await readStreamText(target.logFile, normalizedCursor.offset);
     return parseProcessedLines(raw, normalizedCursor, target.uploadedFileName, fingerprint);
   }
-  async uploadEntries(entries) {
-    const bridgeEntries = entries.filter((entry) => entry.source === "bridge");
+  uploadBodyBytes(entries) {
+    return Buffer.byteLength(JSON.stringify({
+      bridgeId: this.options.bridgeId,
+      hostname: this.options.hostname,
+      entries
+    }), "utf8");
+  }
+  chunkUploadEntries(entries) {
+    const chunks = [];
+    let current = [];
+    for (const entry of entries) {
+      const next = [...current, entry];
+      const nextBodyBytes = this.uploadBodyBytes(next.map((item) => item.entry));
+      if (current.length > 0 && (current.length >= this.options.batchSize || nextBodyBytes > MAX_UPLOAD_CHUNK_BODY_BYTES)) {
+        chunks.push(current);
+        current = [entry];
+      } else {
+        current = next;
+      }
+    }
+    if (current.length > 0) chunks.push(current);
+    return chunks;
+  }
+  async uploadEntries(entries, cursorFile, finalCursor) {
+    const bridgeEntries = entries.filter((item) => item.entry.source === "bridge");
     const result = {
       bridgeEntryCount: bridgeEntries.length,
       uploadedChunkCount: 0,
       accepted: 0,
-      skipped: 0
+      skipped: 0,
+      dropped: 0
     };
-    for (const chunk of chunkEntries(bridgeEntries, this.options.batchSize)) {
+    for (const chunk of this.chunkUploadEntries(bridgeEntries)) {
+      const payloadEntries = chunk.map((item) => item.entry);
       const res = await fetch(`${this.options.serverApiUrl}/api/logs/upload`, {
         method: "POST",
         headers: {
@@ -38103,7 +38623,7 @@ var BridgeLogUploader = class {
         body: JSON.stringify({
           bridgeId: this.options.bridgeId,
           hostname: this.options.hostname,
-          entries: chunk
+          entries: payloadEntries
         })
       });
       if (!res.ok) {
@@ -38111,20 +38631,34 @@ var BridgeLogUploader = class {
           logger28.debug("Failed to read log upload error body", { error: e });
           return "";
         });
-        throw new Error(`upload failed HTTP ${res.status}: ${body2.slice(0, 160)}`);
+        const staleChunk = res.status === 429 ? isStaleRateLimitedChunk(payloadEntries, Date.now()) : null;
+        if (staleChunk) {
+          result.dropped += chunk.length;
+          logger28.warn("Skipping stale bridge log upload chunk after rate limit", {
+            status: res.status,
+            entryCount: chunk.length,
+            minEntryTs: staleChunk.minTs,
+            maxEntryTs: staleChunk.maxTs
+          });
+          continue;
+        }
+        throw new LogUploadHttpError(res.status, body2);
       }
       const body = await res.json();
       result.uploadedChunkCount += 1;
       result.accepted += typeof body.accepted === "number" ? body.accepted : 0;
       result.skipped += typeof body.skipped === "number" ? body.skipped : 0;
+      const last = chunk[chunk.length - 1];
+      if (last) await writeCursor(cursorFile, last.cursorAfter);
     }
+    await writeCursor(cursorFile, finalCursor);
     return result;
   }
 };
 
 // src/skillStore.ts
-import fs15 from "fs";
-import path22 from "path";
+import fs16 from "fs";
+import path23 from "path";
 var logger29 = createModuleLogger("bridge.skillStore");
 var MANAGED_CACHE_MARKER = "<!-- ahchat-skill-cache";
 var SAFE_SKILL_NAME_RE = /^[a-zA-Z0-9_-]+$/;
@@ -38153,9 +38687,9 @@ var SkillStore = class {
   skillsDir;
   indexPath;
   constructor(dataDir) {
-    this.skillsDir = path22.join(dataDir, "skills");
-    this.indexPath = path22.join(this.skillsDir, INDEX_FILE_NAME);
-    fs15.mkdirSync(this.skillsDir, { recursive: true });
+    this.skillsDir = path23.join(dataDir, "skills");
+    this.indexPath = path23.join(this.skillsDir, INDEX_FILE_NAME);
+    fs16.mkdirSync(this.skillsDir, { recursive: true });
     logger29.info("SkillStore initialized", { skillsDir: this.skillsDir });
   }
   read(name) {
@@ -38163,9 +38697,9 @@ var SkillStore = class {
       logger29.warn("Skill read: unsafe name", { name });
       return "";
     }
-    const filePath = path22.join(this.skillsDir, `${name}.md`);
+    const filePath = path23.join(this.skillsDir, `${name}.md`);
     try {
-      const content = fs15.readFileSync(filePath, "utf-8");
+      const content = fs16.readFileSync(filePath, "utf-8");
       logger29.info("Skill read", { name, bytes: content.length });
       return content;
     } catch (e) {
@@ -38176,7 +38710,7 @@ var SkillStore = class {
   allowedNames() {
     const names = /* @__PURE__ */ new Set();
     try {
-      for (const entry of fs15.readdirSync(this.skillsDir, { withFileTypes: true })) {
+      for (const entry of fs16.readdirSync(this.skillsDir, { withFileTypes: true })) {
         if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
         const name = entry.name.slice(0, -3);
         if (isSafeSkillName(name)) names.add(name);
@@ -38191,20 +38725,20 @@ var SkillStore = class {
     if (!isSafeSkillName(name)) {
       throw new Error(`Unsafe skill name: ${name}`);
     }
-    const filePath = path22.join(this.skillsDir, `${name}.md`);
+    const filePath = path23.join(this.skillsDir, `${name}.md`);
     const tmpPath = `${filePath}.tmp`;
     let existing = "";
     try {
-      existing = fs15.readFileSync(filePath, "utf-8");
+      existing = fs16.readFileSync(filePath, "utf-8");
     } catch (e) {
       if (!isNotFoundError(e)) logger29.warn("Skill seed existing read failed", { name, filePath, error: e });
     }
     if (existing === content) {
-      logger29.info("Skill already in sync", { name, bytes: content.length });
+      logger29.debug("Skill already in sync", { name, bytes: content.length });
       return;
     }
-    fs15.writeFileSync(tmpPath, content, "utf-8");
-    fs15.renameSync(tmpPath, filePath);
+    fs16.writeFileSync(tmpPath, content, "utf-8");
+    fs16.renameSync(tmpPath, filePath);
     logger29.info("Skill seeded/re-synced", {
       name,
       bytes: content.length,
@@ -38236,7 +38770,7 @@ var SkillStore = class {
         const content = this.readExisting(name);
         if (!isPrunableManagedSkillCache(content)) continue;
         try {
-          fs15.unlinkSync(path22.join(this.skillsDir, `${name}.md`));
+          fs16.unlinkSync(path23.join(this.skillsDir, `${name}.md`));
           pruned += 1;
           logger29.info("Managed skill cache pruned", { name });
         } catch (e) {
@@ -38254,7 +38788,7 @@ var SkillStore = class {
     const tmpPath = `${this.indexPath}.tmp`;
     let existing = "";
     try {
-      existing = fs15.readFileSync(this.indexPath, "utf-8");
+      existing = fs16.readFileSync(this.indexPath, "utf-8");
     } catch (e) {
       if (!isNotFoundError(e)) logger29.warn("Runtime skill index existing read failed", { error: e });
     }
@@ -38262,8 +38796,8 @@ var SkillStore = class {
       logger29.info("Runtime skill index already in sync", { count: safeEntries.length });
       return;
     }
-    fs15.writeFileSync(tmpPath, content, "utf-8");
-    fs15.renameSync(tmpPath, this.indexPath);
+    fs16.writeFileSync(tmpPath, content, "utf-8");
+    fs16.renameSync(tmpPath, this.indexPath);
     logger29.info("Runtime skill index synced", { count: safeEntries.length });
   }
   pruneManagedSkillsBySource(source, desiredNames) {
@@ -38273,7 +38807,7 @@ var SkillStore = class {
       const content = this.readExisting(name);
       if (managedSkillCacheSource(content) !== source) continue;
       try {
-        fs15.unlinkSync(path22.join(this.skillsDir, `${name}.md`));
+        fs16.unlinkSync(path23.join(this.skillsDir, `${name}.md`));
         pruned += 1;
         logger29.info("Managed skill cache pruned by source", { name, source });
       } catch (e) {
@@ -38284,7 +38818,7 @@ var SkillStore = class {
   }
   listIndexEntries() {
     try {
-      const parsed = JSON.parse(fs15.readFileSync(this.indexPath, "utf-8"));
+      const parsed = JSON.parse(fs16.readFileSync(this.indexPath, "utf-8"));
       if (!Array.isArray(parsed)) return [];
       return parsed.map(normalizeSkillIndexEntry).filter((entry) => entry !== null);
     } catch (e) {
@@ -38297,7 +38831,7 @@ var SkillStore = class {
   }
   readExisting(name) {
     try {
-      return fs15.readFileSync(path22.join(this.skillsDir, `${name}.md`), "utf-8");
+      return fs16.readFileSync(path23.join(this.skillsDir, `${name}.md`), "utf-8");
     } catch (e) {
       if (!isNotFoundError(e)) logger29.warn("Managed skill cache read failed", { name, error: e });
       return "";
@@ -38343,8 +38877,8 @@ function normalizeSkillIndexEntry(value) {
 
 // src/lockfile.ts
 import * as childProcess from "child_process";
-import fs16 from "fs";
-import path23 from "path";
+import fs17 from "fs";
+import path24 from "path";
 var logger30 = createModuleLogger("bridge.lockfile");
 var lockPath = null;
 var releaseRegistered = false;
@@ -38419,8 +38953,8 @@ function readProcessCommand(pid) {
       return readWindowsProcessCommand(pid);
     }
     const procCmdline = `/proc/${pid}/cmdline`;
-    if (fs16.existsSync(procCmdline)) {
-      return fs16.readFileSync(procCmdline, "utf-8").replace(/\0/g, " ");
+    if (fs17.existsSync(procCmdline)) {
+      return fs17.readFileSync(procCmdline, "utf-8").replace(/\0/g, " ");
     }
     return childProcess.execFileSync("ps", ["-p", String(pid), "-o", "comm=", "-o", "args="], {
       encoding: "utf-8",
@@ -38446,10 +38980,10 @@ function isLiveBridgeLockOwner(pid) {
   return false;
 }
 function acquireLock(dataDir) {
-  const file2 = path23.join(dataDir, "bridge.lock");
+  const file2 = path24.join(dataDir, "bridge.lock");
   lockPath = file2;
-  if (fs16.existsSync(file2)) {
-    const raw = fs16.readFileSync(file2, "utf-8").trim();
+  if (fs17.existsSync(file2)) {
+    const raw = fs17.readFileSync(file2, "utf-8").trim();
     const pid = Number.parseInt(raw, 10);
     if (Number.isFinite(pid) && pid > 0) {
       if (isLiveBridgeLockOwner(pid)) {
@@ -38458,8 +38992,8 @@ function acquireLock(dataDir) {
       logger30.info("Removing stale bridge.lock", { pid, path: file2 });
     }
   }
-  fs16.mkdirSync(path23.dirname(file2), { recursive: true });
-  fs16.writeFileSync(file2, String(process.pid), "utf-8");
+  fs17.mkdirSync(path24.dirname(file2), { recursive: true });
+  fs17.writeFileSync(file2, String(process.pid), "utf-8");
   logger30.info("Acquired bridge lock", { path: file2, pid: process.pid });
   if (!releaseRegistered) {
     releaseRegistered = true;
@@ -38468,10 +39002,10 @@ function acquireLock(dataDir) {
 }
 function releaseLock() {
   try {
-    if (lockPath && fs16.existsSync(lockPath)) {
-      const current = fs16.readFileSync(lockPath, "utf-8").trim();
+    if (lockPath && fs17.existsSync(lockPath)) {
+      const current = fs17.readFileSync(lockPath, "utf-8").trim();
       if (current === String(process.pid)) {
-        fs16.unlinkSync(lockPath);
+        fs17.unlinkSync(lockPath);
         logger30.info("Released bridge lock", { path: lockPath });
       }
     }
@@ -38483,17 +39017,17 @@ function releaseLock() {
 }
 
 // src/localWorkdirOverrideStore.ts
-import fs17 from "fs";
-import path24 from "path";
+import fs18 from "fs";
+import path25 from "path";
 var logger31 = createModuleLogger("bridge.localWorkdirOverride");
 var LocalWorkdirOverrideStore = class {
   filePath;
   constructor(dataDir) {
-    this.filePath = path24.join(dataDir, LOCAL_WORKDIR_OVERRIDES_FILENAME);
+    this.filePath = path25.join(dataDir, LOCAL_WORKDIR_OVERRIDES_FILENAME);
   }
   read() {
     try {
-      const raw = fs17.readFileSync(this.filePath, "utf8");
+      const raw = fs18.readFileSync(this.filePath, "utf8");
       return normalizeLocalWorkdirOverridesFile(JSON.parse(raw)).overrides;
     } catch (error51) {
       if (error51 instanceof Error && "code" in error51 && error51.code === "ENOENT") return [];
@@ -38512,9 +39046,9 @@ var LocalWorkdirOverrideStore = class {
     if (!args.localWorkdir.trim()) throw new Error("local workdir is required");
     const current = { version: 1, overrides: this.read() };
     const next = upsertLocalWorkdirOverride(current, args);
-    fs17.mkdirSync(args.localWorkdir, { recursive: true });
-    fs17.mkdirSync(path24.dirname(this.filePath), { recursive: true });
-    fs17.writeFileSync(this.filePath, `${JSON.stringify(next, null, 2)}
+    fs18.mkdirSync(args.localWorkdir, { recursive: true });
+    fs18.mkdirSync(path25.dirname(this.filePath), { recursive: true });
+    fs18.writeFileSync(this.filePath, `${JSON.stringify(next, null, 2)}
 `, "utf8");
     const saved = next.overrides.find(
       (item) => item.targetKind === args.targetKind && item.targetId === args.targetId
@@ -38931,8 +39465,8 @@ async function handleGroupArchivedPush(deps, payload) {
 }
 
 // src/sessionStore.ts
-import fs18 from "fs";
-import path25 from "path";
+import fs19 from "fs";
+import path26 from "path";
 var logger34 = createModuleLogger("session.store");
 var SessionStore = class {
   filePath;
@@ -38940,8 +39474,8 @@ var SessionStore = class {
   cache;
   fingerprints;
   constructor(dataDir) {
-    this.filePath = path25.join(dataDir, "sessions.json");
-    this.fingerprintPath = path25.join(dataDir, "session-fingerprints.json");
+    this.filePath = path26.join(dataDir, "sessions.json");
+    this.fingerprintPath = path26.join(dataDir, "session-fingerprints.json");
     this.cache = this.loadFromDisk();
     this.fingerprints = this.loadMapFromDisk(this.fingerprintPath, "session fingerprints");
   }
@@ -38999,8 +39533,8 @@ var SessionStore = class {
   }
   loadFromDisk() {
     try {
-      if (!fs18.existsSync(this.filePath)) return {};
-      const raw = fs18.readFileSync(this.filePath, "utf-8");
+      if (!fs19.existsSync(this.filePath)) return {};
+      const raw = fs19.readFileSync(this.filePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
       const map2 = parsed;
@@ -39024,8 +39558,8 @@ var SessionStore = class {
   }
   loadMapFromDisk(filePath, label) {
     try {
-      if (!fs18.existsSync(filePath)) return {};
-      const raw = fs18.readFileSync(filePath, "utf-8");
+      if (!fs19.existsSync(filePath)) return {};
+      const raw = fs19.readFileSync(filePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
       const out = {};
@@ -39040,18 +39574,18 @@ var SessionStore = class {
   }
   saveToDisk() {
     try {
-      const dir = path25.dirname(this.filePath);
-      fs18.mkdirSync(dir, { recursive: true });
-      fs18.writeFileSync(this.filePath, JSON.stringify(this.cache, null, 2), "utf-8");
+      const dir = path26.dirname(this.filePath);
+      fs19.mkdirSync(dir, { recursive: true });
+      fs19.writeFileSync(this.filePath, JSON.stringify(this.cache, null, 2), "utf-8");
     } catch (e) {
       logger34.error("Failed to save sessions file", { error: e, path: this.filePath });
     }
   }
   saveFingerprintsToDisk() {
     try {
-      const dir = path25.dirname(this.fingerprintPath);
-      fs18.mkdirSync(dir, { recursive: true });
-      fs18.writeFileSync(
+      const dir = path26.dirname(this.fingerprintPath);
+      fs19.mkdirSync(dir, { recursive: true });
+      fs19.writeFileSync(
         this.fingerprintPath,
         JSON.stringify(this.fingerprints, null, 2),
         "utf-8"
@@ -39066,8 +39600,8 @@ var SessionStore = class {
 };
 
 // src/workdirEnsure.ts
-import fs19 from "fs";
-import path26 from "path";
+import fs20 from "fs";
+import path27 from "path";
 function resolveBridgeWorkdirPath(requestedPath, workspacesDir, workdirOverrideStore, target) {
   const overridden = target ? workdirOverrideStore?.resolvePath(requestedPath, target) : workdirOverrideStore?.resolvePath(requestedPath);
   if (overridden?.overridden) {
@@ -39079,15 +39613,15 @@ function ensureBridgeWorkdirExists(requestedPath, workspacesDir, workdirOverride
   const trimmed = requestedPath.trim();
   if (!trimmed) return null;
   const resolved = resolveBridgeWorkdirPath(trimmed, workspacesDir, workdirOverrideStore, target);
-  if (!path26.isAbsolute(resolved.path)) return { ...resolved, ensured: false };
-  fs19.mkdirSync(resolved.path, { recursive: true });
+  if (!path27.isAbsolute(resolved.path)) return { ...resolved, ensured: false };
+  fs20.mkdirSync(resolved.path, { recursive: true });
   return { ...resolved, ensured: true };
 }
 
 // src/claudeRuntime.ts
 import { accessSync as accessSync2, constants as constants3, existsSync as existsSync2, readdirSync as readdirSync2, realpathSync } from "fs";
 import { createRequire } from "module";
-import path27 from "path";
+import path28 from "path";
 var logger35 = createModuleLogger("bridge.claudeRuntime");
 var require2 = createRequire(import.meta.url);
 var CLAUDE_RUNTIME_VERSION_TIMEOUT_MS = 3e4;
@@ -39097,7 +39631,7 @@ function normalizePath(value) {
   const trimmed = value?.trim();
   if (!trimmed) return void 0;
   const expanded = resolveUserPath(trimmed);
-  return path27.isAbsolute(expanded) ? expanded : path27.resolve(expanded);
+  return path28.isAbsolute(expanded) ? expanded : path28.resolve(expanded);
 }
 function canExecute2(candidate) {
   try {
@@ -39181,16 +39715,16 @@ function resolveClaudeAgentSdkDir() {
   const sdkEntry = safeResolve("@anthropic-ai/claude-agent-sdk");
   if (!sdkEntry) return void 0;
   try {
-    return path27.dirname(realpathSync(sdkEntry));
+    return path28.dirname(realpathSync(sdkEntry));
   } catch {
-    return path27.dirname(sdkEntry);
+    return path28.dirname(sdkEntry);
   }
 }
 function findPnpmStoreDir(fromDir) {
   let current = fromDir;
-  while (current !== path27.dirname(current)) {
-    if (path27.basename(current) === ".pnpm") return current;
-    current = path27.dirname(current);
+  while (current !== path28.dirname(current)) {
+    if (path28.basename(current) === ".pnpm") return current;
+    current = path28.dirname(current);
   }
   return void 0;
 }
@@ -39208,7 +39742,7 @@ function resolvePnpmRuntimeBinary(sdkDir, target) {
   for (const entry of entries) {
     if (!entry.startsWith(`${encodedName}@`)) continue;
     const version2 = entry.slice(encodedName.length + 1);
-    const candidate = path27.join(
+    const candidate = path28.join(
       pnpmStoreDir,
       entry,
       "node_modules",
@@ -39240,8 +39774,8 @@ function resolveSdkRuntimeBinary(target) {
   const scopedPackageName = target.packageName.split("/")[1] ?? target.packageName;
   const candidates = [
     safeResolve(`${target.packageName}/${target.binaryName}`, [sdkDir]),
-    path27.join(sdkDir, "..", scopedPackageName, target.binaryName),
-    path27.join(sdkDir, "node_modules", ...target.packageName.split("/"), target.binaryName),
+    path28.join(sdkDir, "..", scopedPackageName, target.binaryName),
+    path28.join(sdkDir, "node_modules", ...target.packageName.split("/"), target.binaryName),
     resolvePnpmRuntimeBinary(sdkDir, target)
   ].filter((candidate) => Boolean(candidate));
   return candidates.find((candidate) => existsSync2(candidate));
@@ -39373,8 +39907,8 @@ function logClaudeRuntimeResolution(resolution) {
 }
 
 // src/forkAgentFiles.ts
-import * as fs20 from "fs/promises";
-import * as path28 from "path";
+import * as fs21 from "fs/promises";
+import * as path29 from "path";
 var logger36 = createModuleLogger("bridge.forkAgentFiles");
 async function forkAgentFiles(sourceAgentId, newAgentId, sourceWorkdir, newWorkdir, dataDir, sessionStore, sourceConversationId) {
   logger36.info("Fork file copy starting", {
@@ -39386,15 +39920,15 @@ async function forkAgentFiles(sourceAgentId, newAgentId, sourceWorkdir, newWorkd
     sourceConversationId
   });
   try {
-    const stat3 = await fs20.stat(sourceWorkdir).catch(() => null);
+    const stat3 = await fs21.stat(sourceWorkdir).catch(() => null);
     if (stat3?.isDirectory()) {
-      await fs20.cp(sourceWorkdir, newWorkdir, { recursive: true });
+      await fs21.cp(sourceWorkdir, newWorkdir, { recursive: true });
       logger36.info("Workdir copied", {
         from: sourceWorkdir,
         to: newWorkdir
       });
     } else {
-      await fs20.mkdir(newWorkdir, { recursive: true });
+      await fs21.mkdir(newWorkdir, { recursive: true });
       logger36.info("Workdir created (source did not exist)", {
         newWorkdir
       });
@@ -39403,14 +39937,14 @@ async function forkAgentFiles(sourceAgentId, newAgentId, sourceWorkdir, newWorkd
     logger36.error("Workdir copy failed", { error: e });
     throw e;
   }
-  const srcNotebook = path28.join(dataDir, "agent-memory", sourceAgentId, "notebook.md");
-  const dstNotebookDir = path28.join(dataDir, "agent-memory", newAgentId);
-  const dstNotebook = path28.join(dstNotebookDir, "notebook.md");
+  const srcNotebook = path29.join(dataDir, "agent-memory", sourceAgentId, "notebook.md");
+  const dstNotebookDir = path29.join(dataDir, "agent-memory", newAgentId);
+  const dstNotebook = path29.join(dstNotebookDir, "notebook.md");
   try {
-    const nbStat = await fs20.stat(srcNotebook).catch(() => null);
+    const nbStat = await fs21.stat(srcNotebook).catch(() => null);
     if (nbStat?.isFile()) {
-      await fs20.mkdir(dstNotebookDir, { recursive: true });
-      await fs20.copyFile(srcNotebook, dstNotebook);
+      await fs21.mkdir(dstNotebookDir, { recursive: true });
+      await fs21.copyFile(srcNotebook, dstNotebook);
       logger36.info("Notebook copied", {
         from: srcNotebook,
         to: dstNotebook
@@ -39428,12 +39962,12 @@ async function forkAgentFiles(sourceAgentId, newAgentId, sourceWorkdir, newWorkd
   if (sourceSessionId) {
     try {
       const srcPath = sessionFilePath(sourceWorkdir, sourceSessionId);
-      const srcStat = await fs20.stat(srcPath).catch(() => null);
+      const srcStat = await fs21.stat(srcPath).catch(() => null);
       if (srcStat?.isFile()) {
         const dstDir = sessionDirForCwd(newWorkdir);
-        await fs20.mkdir(dstDir, { recursive: true });
-        const dstPath = path28.join(dstDir, `${sourceSessionId}.jsonl`);
-        await fs20.copyFile(srcPath, dstPath);
+        await fs21.mkdir(dstDir, { recursive: true });
+        const dstPath = path29.join(dstDir, `${sourceSessionId}.jsonl`);
+        await fs21.copyFile(srcPath, dstPath);
         sessionStore.set(newAgentId, { kind: "single" }, sourceSessionId);
         sessionCopied = true;
         logger36.info("Session JSONL copied and registered", {
@@ -39479,7 +40013,7 @@ async function forkAgentFiles(sourceAgentId, newAgentId, sourceWorkdir, newWorkd
 
 // src/feedbackCodexAnalyzer.ts
 import { spawn, spawnSync } from "child_process";
-import path29 from "path";
+import path30 from "path";
 var logger37 = createModuleLogger("feedbackCodexAnalyzer");
 var DEFAULT_TIMEOUT_MS2 = 10 * 60 * 1e3;
 var MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
@@ -39504,12 +40038,12 @@ function resolveFeedbackCodexOptions(defaultWorkdir, env2 = process.env) {
   const logDataDir = readOptionalEnv("AHCHAT_FEEDBACK_LOG_DATA_DIR", env2) ?? DEFAULT_LOG_DATA_DIR;
   return {
     executable: readOptionalEnv("AHCHAT_FEEDBACK_CODEX_EXECUTABLE", env2) ?? readOptionalEnv("CODEX_EXECUTABLE", env2) ?? "codex",
-    workdir: path29.resolve(readOptionalEnv("AHCHAT_FEEDBACK_CODEX_WORKDIR", env2) ?? defaultWorkdir),
+    workdir: path30.resolve(readOptionalEnv("AHCHAT_FEEDBACK_CODEX_WORKDIR", env2) ?? defaultWorkdir),
     model: readOptionalEnv("AHCHAT_FEEDBACK_CODEX_MODEL", env2),
     timeoutMs: readPositiveIntEnv("AHCHAT_FEEDBACK_CODEX_TIMEOUT_MS", DEFAULT_TIMEOUT_MS2, env2),
     logSshTarget: readOptionalEnv("AHCHAT_FEEDBACK_LOG_SSH_TARGET", env2) ?? DEFAULT_LOG_SSH_TARGET,
     logDataDir,
-    logServerLogDir: readOptionalEnv("AHCHAT_FEEDBACK_LOG_SERVER_LOG_DIR", env2) ?? path29.posix.join(logDataDir, "logs"),
+    logServerLogDir: readOptionalEnv("AHCHAT_FEEDBACK_LOG_SERVER_LOG_DIR", env2) ?? path30.posix.join(logDataDir, "logs"),
     logUploadTable: readOptionalEnv("AHCHAT_FEEDBACK_LOG_UPLOAD_TABLE", env2) ?? DEFAULT_LOG_UPLOAD_TABLE
   };
 }
@@ -39702,7 +40236,7 @@ function buildFeedbackAnalysisPrompt(payload, options, attachments) {
    - \u751F\u4EA7\u65E5\u5FD7\u76EE\u6807\uFF1A${options.logSshTarget}
    - AHChat \u6570\u636E\u76EE\u5F55\uFF1A${options.logDataDir}
    - \u670D\u52A1\u7AEF\u65E5\u5FD7\u76EE\u5F55\uFF1A${options.logServerLogDir}
-   - Bridge \u4E0A\u4F20\u65E5\u5FD7\u6570\u636E\u5E93\uFF1A${path29.posix.join(options.logDataDir, "data.db")}
+   - Bridge \u4E0A\u4F20\u65E5\u5FD7\u6570\u636E\u5E93\uFF1A${path30.posix.join(options.logDataDir, "data.db")}
    - \u4E0A\u4F20\u65E5\u5FD7\u8868\uFF1A${options.logUploadTable}
    - \u5982\u679C\u76EE\u6807\u673A\u5668\u4E0A\u7684\u5B9A\u65F6\u4EFB\u52A1\u6216\u670D\u52A1\u914D\u7F6E\u663E\u793A\u65E5\u5FD7\u76EE\u5F55\u4E0D\u540C\uFF0C\u4EE5\u5B9E\u9645\u914D\u7F6E\u4E3A\u51C6\u3002
    - \u53EA\u505A\u53EA\u8BFB\u67E5\u8BE2\uFF1B\u4E0D\u8981\u590D\u5236\u6570\u636E\u5E93\uFF1B\u53EF\u7528 ssh \u5230\u76EE\u6807\u673A\u5668\u540E\u901A\u8FC7 python3/sqlite3 \u67E5\u8BE2\u3002
@@ -39877,15 +40411,15 @@ async function analyzeFeedbackWithLocalCodex(payload, options, attachments = [])
 }
 
 // src/modelQuerier.ts
-import fs21 from "fs/promises";
+import fs22 from "fs/promises";
 import os12 from "os";
-import path30 from "path";
+import path31 from "path";
 import * as sdk4 from "@anthropic-ai/claude-agent-sdk";
 var logger38 = createModuleLogger("bridge.modelQuerier");
 async function listModels(queryFn, opts = {}) {
   const t0 = Date.now();
-  const cwd = opts.cwd ?? path30.join(os12.homedir(), ".ahchat", "workspaces", "_list_models");
-  await fs21.mkdir(cwd, { recursive: true });
+  const cwd = opts.cwd ?? path31.join(os12.homedir(), ".ahchat", "workspaces", "_list_models");
+  await fs22.mkdir(cwd, { recursive: true });
   const fn = queryFn ?? sdk4.query;
   const ic = new InputController();
   ic.push("Reply with exactly: PING", "");
@@ -39950,9 +40484,9 @@ async function listModels(queryFn, opts = {}) {
 import { execFile as execFile3 } from "child_process";
 import crypto4 from "crypto";
 import fsSync2 from "fs";
-import fs22 from "fs/promises";
+import fs23 from "fs/promises";
 import os13 from "os";
-import path31 from "path";
+import path32 from "path";
 import { promisify as promisify3 } from "util";
 var execFileAsync3 = promisify3(execFile3);
 var logger39 = createModuleLogger("bridge.officeRuntimeSetup");
@@ -40012,7 +40546,7 @@ async function fetchUrl(url2, outputPath, timeoutMs) {
     const res = await fetch(url2, { signal: controller.signal });
     if (!res.ok) return false;
     const bytes = Buffer.from(await res.arrayBuffer());
-    await fs22.writeFile(outputPath, bytes);
+    await fs23.writeFile(outputPath, bytes);
     return true;
   } catch (error51) {
     logger39.error("OfficeCLI runtime download failed", { error: error51, url: url2 });
@@ -40034,7 +40568,7 @@ function parseChecksumManifest(raw, asset) {
   return null;
 }
 async function sha256(filePath) {
-  return crypto4.createHash("sha256").update(await fs22.readFile(filePath)).digest("hex");
+  return crypto4.createHash("sha256").update(await fs23.readFile(filePath)).digest("hex");
 }
 async function runBestEffort(command, args) {
   try {
@@ -40062,10 +40596,10 @@ async function installManagedOfficeCliRuntime(env2) {
   const githubBase = `https://github.com/${REPO}/releases/download/${version2}`;
   const mirrorAssetBase = `${mirrorBase(env2)}/releases/download/${version2}`;
   const timeoutMs = readTimeoutMs(env2);
-  await fs22.mkdir(binDir, { recursive: true });
-  const tmpDir = await fs22.mkdtemp(path31.join(os13.tmpdir(), "ahchat-officecli-"));
-  const tmpBinary = path31.join(tmpDir, asset);
-  const tmpSums = path31.join(tmpDir, "SHA256SUMS");
+  await fs23.mkdir(binDir, { recursive: true });
+  const tmpDir = await fs23.mkdtemp(path32.join(os13.tmpdir(), "ahchat-officecli-"));
+  const tmpBinary = path32.join(tmpDir, asset);
+  const tmpSums = path32.join(tmpDir, "SHA256SUMS");
   try {
     const binarySource = await fetchWithFallback(
       `${mirrorAssetBase}/${asset}`,
@@ -40081,21 +40615,21 @@ async function installManagedOfficeCliRuntime(env2) {
       timeoutMs
     );
     if (!checksumSource) throw new Error(`Could not download SHA256SUMS for OfficeCLI ${version2}`);
-    const expected = parseChecksumManifest(await fs22.readFile(tmpSums, "utf-8"), asset);
+    const expected = parseChecksumManifest(await fs23.readFile(tmpSums, "utf-8"), asset);
     if (!expected) throw new Error(`SHA256SUMS does not contain ${asset}`);
     const actual = await sha256(tmpBinary);
     if (expected !== actual) {
       throw new Error(`Checksum mismatch for ${asset}: expected ${expected}, got ${actual}`);
     }
-    const staged = path31.join(binDir, `${path31.basename(target)}.new`);
-    await fs22.copyFile(tmpBinary, staged);
-    await fs22.chmod(staged, 493);
+    const staged = path32.join(binDir, `${path32.basename(target)}.new`);
+    await fs23.copyFile(tmpBinary, staged);
+    await fs23.chmod(staged, 493);
     await codesignIfNeeded(staged);
-    await fs22.rm(target, { force: true });
-    await fs22.rename(staged, target);
+    await fs23.rm(target, { force: true });
+    await fs23.rename(staged, target);
     return { path: target, asset, binarySource, checksumSource };
   } finally {
-    await fs22.rm(tmpDir, { recursive: true, force: true });
+    await fs23.rm(tmpDir, { recursive: true, force: true });
   }
 }
 async function ensureOfficeCliRuntime(env2 = process.env) {
@@ -40133,9 +40667,9 @@ async function ensureOfficeCliRuntime(env2 = process.env) {
 }
 
 // src/promptOptimizer.ts
-import fs23 from "fs/promises";
+import fs24 from "fs/promises";
 import os14 from "os";
-import path32 from "path";
+import path33 from "path";
 import * as sdk5 from "@anthropic-ai/claude-agent-sdk";
 var logger40 = createModuleLogger("bridge.promptOptimizer");
 var OPTIMIZER_SYSTEM_PROMPT = `You are an expert prompt editor for ALL-CAN Agent creation.
@@ -40179,8 +40713,8 @@ async function optimizePrompt(queryFn, opts) {
   const prompt = opts.systemPrompt.trim();
   if (!prompt) throw new Error("systemPrompt is required");
   const t0 = Date.now();
-  const cwd = opts.cwd ?? path32.join(os14.homedir(), ".ahchat", "workspaces", "_prompt_optimizer");
-  await fs23.mkdir(cwd, { recursive: true });
+  const cwd = opts.cwd ?? path33.join(os14.homedir(), ".ahchat", "workspaces", "_prompt_optimizer");
+  await fs24.mkdir(cwd, { recursive: true });
   const fn = queryFn ?? sdk5.query;
   const ic = new InputController();
   ic.push(buildUserPrompt(opts), "");
@@ -40442,10 +40976,10 @@ function agentRuntimeConfigSnapshot(rawConfig) {
   };
 }
 async function syncClaudeCredentialsToNodeAccessibleDir(agentConfigDir) {
-  const rootClaudeDir = path33.join(process.env.HOME ?? "/root", ".claude");
-  const fs24 = await import("fs/promises");
+  const rootClaudeDir = path34.join(process.env.HOME ?? "/root", ".claude");
+  const fs25 = await import("fs/promises");
   try {
-    await fs24.access(rootClaudeDir);
+    await fs25.access(rootClaudeDir);
   } catch (e) {
     logger42.info("No /root/.claude to sync", { rootClaudeDir });
     logger42.debug("Root Claude dir access failed", { error: e });
@@ -40453,10 +40987,10 @@ async function syncClaudeCredentialsToNodeAccessibleDir(agentConfigDir) {
   }
   const filesToSync = [".credentials.json", "settings.json", ".credentials.backup.json"];
   for (const file2 of filesToSync) {
-    const src = path33.join(rootClaudeDir, file2);
-    const dest = path33.join(agentConfigDir, file2);
+    const src = path34.join(rootClaudeDir, file2);
+    const dest = path34.join(agentConfigDir, file2);
     try {
-      await fs24.copyFile(src, dest);
+      await fs25.copyFile(src, dest);
       logger42.info("Synced credential file", { file: file2, from: src, to: dest });
     } catch (e) {
       logger42.debug("Credential file not present, skipping", { file: file2, src });
@@ -40465,26 +40999,26 @@ async function syncClaudeCredentialsToNodeAccessibleDir(agentConfigDir) {
   }
 }
 async function chownRecursive(dirPath, uid, gid) {
-  const fs24 = await import("fs/promises");
+  const fs25 = await import("fs/promises");
   try {
-    await fs24.chown(dirPath, uid, gid);
+    await fs25.chown(dirPath, uid, gid);
   } catch (e) {
     logger42.debug("chown skipped", { error: e, uid, gid });
   }
   let entries;
   try {
-    entries = await fs24.readdir(dirPath, { withFileTypes: true });
+    entries = await fs25.readdir(dirPath, { withFileTypes: true });
   } catch (e) {
     logger42.debug("chown directory read skipped", { error: e });
     return;
   }
   for (const entry of entries) {
-    const fullPath = path33.join(dirPath, entry.name);
+    const fullPath = path34.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       await chownRecursive(fullPath, uid, gid);
     } else {
       try {
-        await fs24.chown(fullPath, uid, gid);
+        await fs25.chown(fullPath, uid, gid);
       } catch (e) {
         logger42.debug("chown skipped", { error: e, uid, gid });
       }
@@ -40496,7 +41030,7 @@ async function startBridge(config2) {
   configureBridgeLogger(config2);
   ensureDir(config2.dataDir);
   ensureDir(config2.agentConfigDir);
-  const workspacesDir = path33.join(config2.dataDir, "workspaces");
+  const workspacesDir = path34.join(config2.dataDir, "workspaces");
   ensureDir(workspacesDir);
   process.env.CLAUDE_CONFIG_DIR = config2.agentConfigDir;
   installBridgeFetchAuth(config2.serverApiUrl, config2.bridgeToken);
@@ -40591,7 +41125,7 @@ Bridge token (register this machine at Settings \u2192 \u5DF2\u8FDE\u63A5\u7684\
   wsMetrics.start(5e3);
   const sessionStore = new SessionStore(config2.dataDir);
   const workdirOverrideStore = new LocalWorkdirOverrideStore(config2.dataDir);
-  const memoryRoot = path33.join(config2.dataDir, "agent-memory");
+  const memoryRoot = path34.join(config2.dataDir, "agent-memory");
   const memoryStore = new AgentMemoryStore(memoryRoot, config2.serverApiUrl, config2.bridgeToken);
   logger42.info("Agent memory store initialized", { rootDir: memoryRoot });
   const smithNotebook = memoryStore.read(SMITH_AGENT_ID);