@fangyb/ahchat-bridge 0.1.41 → 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)
@@ -8341,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),
@@ -8735,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
@@ -9611,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
@@ -10379,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);
@@ -10791,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;
   });
 }
@@ -10942,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 {
@@ -10978,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;
@@ -11020,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")
@@ -23713,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}`);
     }
@@ -24649,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})`,
@@ -25603,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
@@ -27934,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);
@@ -27966,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");
@@ -29714,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 {
@@ -29758,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/";
@@ -29807,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)
   };
 }
 
@@ -29935,10 +30191,51 @@ var SMITH_ALLOWED_TOOLS = [
   // 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;
@@ -30006,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);
@@ -30036,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) {
@@ -30055,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 };
     }
@@ -30334,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;
@@ -30352,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;
@@ -30375,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;
     }
@@ -30408,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}`;
@@ -30421,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) {
@@ -30435,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);
   }
@@ -30470,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",
         {
@@ -30506,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);
@@ -30533,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;
     }
   }
@@ -30727,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`)
         )
       )
     );
@@ -30766,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);
       }
     }
@@ -30781,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);
       }
     );
@@ -30807,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);
     }
@@ -31164,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),
@@ -31173,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,
@@ -31184,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);
@@ -31192,13 +31489,13 @@ ${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", {
@@ -31213,7 +31510,7 @@ ${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,
         configDirKind: "api-key-agent",
@@ -31316,13 +31613,15 @@ ${cfg.instructions.trim()}` : "";
       isSmith: smithAgent,
       cwd: agentCwd
     }) ?? { mcpServers: {}, allowedTools: [], toolAbi: [] };
-    const externalMcp = smithAgent ? { mcpServers: {}, allowedTools: [], toolAbi: [] } : resolvedExternalMcp;
-    if (smithAgent && (Object.keys(resolvedExternalMcp.mcpServers).length > 0 || resolvedExternalMcp.allowedTools.length > 0 || (resolvedExternalMcp.toolAbi?.length ?? 0) > 0)) {
-      logger14.info("Smith external MCP ignored by fixed tool whitelist", {
+    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
+        allowedToolCount: resolvedExternalMcp.allowedTools.length,
+        retainedServerNames: Object.keys(externalMcp.mcpServers),
+        retainedAllowedToolCount: externalMcp.allowedTools.length
       });
     }
     const visionMcpTools = resolveVisionMcpToolHints(externalMcp);
@@ -31446,6 +31745,8 @@ ${cfg.instructions.trim()}` : "";
       "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",
@@ -31766,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" };
@@ -31836,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,
@@ -32024,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;
   }
@@ -32729,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)) {
@@ -32763,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", {
@@ -32781,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) {
@@ -35164,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 {
@@ -35419,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 () => {
@@ -35523,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);
@@ -35602,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";
@@ -35625,8 +35926,8 @@ var HttpMcpRegistry = 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() {
     this.refreshLocal();
@@ -35818,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
   );
@@ -35837,7 +36138,7 @@ function resolveBundledMcpExecutable(cliBaseName, extraArgs, options = {}) {
   }
   const sourceCliPath = firstExistingPath(
     [
-      path14.join(currentDir, `${cliBaseName}.ts`)
+      path15.join(currentDir, `${cliBaseName}.ts`)
     ],
     existsSync3
   );
@@ -35846,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
   );
@@ -35861,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
   );
@@ -35883,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;
@@ -35921,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 [];
@@ -35942,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) {
@@ -35957,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;
@@ -35974,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 [];
@@ -36018,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 });
     }
@@ -36719,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;
@@ -36751,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) {
@@ -36766,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);
@@ -36781,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);
@@ -36797,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) ?? ""));
@@ -36810,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];
@@ -36858,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,
@@ -36876,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;
@@ -36885,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;
     }
   }
@@ -36894,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;
@@ -36904,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;
@@ -36921,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) {
@@ -36941,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;
@@ -36950,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);
       }
     }
@@ -36987,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();
@@ -37343,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,
@@ -37422,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);
@@ -37471,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,
@@ -37514,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);
@@ -37527,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";
@@ -37613,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", {
@@ -37622,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,
@@ -37649,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;
@@ -37698,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;
@@ -37708,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) {
@@ -37746,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;
@@ -37767,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,
@@ -37783,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
   };
@@ -37798,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;
@@ -37816,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,
@@ -37835,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");
@@ -37844,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) {
@@ -37898,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,
@@ -37917,9 +38218,9 @@ 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;
@@ -37963,27 +38264,27 @@ function parseUploadErrorBody(bodyText) {
   }
 }
 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) {
@@ -37992,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);
@@ -38006,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
     };
@@ -38034,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;
@@ -38356,8 +38657,8 @@ var BridgeLogUploader = class {
 };
 
 // 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_-]+$/;
@@ -38386,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) {
@@ -38396,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) {
@@ -38409,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);
@@ -38424,11 +38725,11 @@ 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 });
     }
@@ -38436,8 +38737,8 @@ var SkillStore = class {
       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,
@@ -38469,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) {
@@ -38487,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 });
     }
@@ -38495,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) {
@@ -38506,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) {
@@ -38517,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) {
@@ -38530,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 "";
@@ -38576,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;
@@ -38652,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",
@@ -38679,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)) {
@@ -38691,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;
@@ -38701,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 });
       }
     }
@@ -38716,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 [];
@@ -38745,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
@@ -39164,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;
@@ -39173,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");
   }
@@ -39232,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;
@@ -39257,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 = {};
@@ -39273,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"
@@ -39299,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) {
@@ -39312,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;
@@ -39330,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 {
@@ -39414,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;
 }
@@ -39441,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",
@@ -39473,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));
@@ -39606,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", {
@@ -39619,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
       });
@@ -39636,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
@@ -39661,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", {
@@ -39712,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;
@@ -39737,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
   };
 }
@@ -39935,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
@@ -40110,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", "");
@@ -40183,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");
@@ -40245,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 });
@@ -40267,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 {
@@ -40295,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}`,
@@ -40314,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) {
@@ -40366,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.
@@ -40412,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), "");
@@ -40675,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 });
@@ -40686,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 });
@@ -40698,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 });
       }
@@ -40729,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);
@@ -40824,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);