@clawos-dev/clawd 0.2.228 → 0.2.230

package/dist/cli.cjs

@@ -7410,7 +7410,7 @@ var require_atomic_sleep = __commonJS({
 var require_sonic_boom = __commonJS({
   "../node_modules/.pnpm/sonic-boom@4.2.1/node_modules/sonic-boom/index.js"(exports2, module2) {
     "use strict";
-    var fs70 = require("fs");
+    var fs71 = require("fs");
     var EventEmitter3 = require("events");
     var inherits = require("util").inherits;
     var path77 = require("path");
@@ -7467,20 +7467,20 @@ var require_sonic_boom = __commonJS({
       const mode = sonic.mode;
       if (sonic.sync) {
         try {
-          if (sonic.mkdir) fs70.mkdirSync(path77.dirname(file), { recursive: true });
-          const fd = fs70.openSync(file, flags, mode);
+          if (sonic.mkdir) fs71.mkdirSync(path77.dirname(file), { recursive: true });
+          const fd = fs71.openSync(file, flags, mode);
           fileOpened(null, fd);
         } catch (err) {
           fileOpened(err);
           throw err;
         }
       } else if (sonic.mkdir) {
-        fs70.mkdir(path77.dirname(file), { recursive: true }, (err) => {
+        fs71.mkdir(path77.dirname(file), { recursive: true }, (err) => {
           if (err) return fileOpened(err);
-          fs70.open(file, flags, mode, fileOpened);
+          fs71.open(file, flags, mode, fileOpened);
         });
       } else {
-        fs70.open(file, flags, mode, fileOpened);
+        fs71.open(file, flags, mode, fileOpened);
       }
     }
     function SonicBoom(opts) {
@@ -7521,8 +7521,8 @@ var require_sonic_boom = __commonJS({
         this.flush = flushBuffer;
         this.flushSync = flushBufferSync;
         this._actualWrite = actualWriteBuffer;
-        fsWriteSync = () => fs70.writeSync(this.fd, this._writingBuf);
-        fsWrite = () => fs70.write(this.fd, this._writingBuf, this.release);
+        fsWriteSync = () => fs71.writeSync(this.fd, this._writingBuf);
+        fsWrite = () => fs71.write(this.fd, this._writingBuf, this.release);
       } else if (contentMode === void 0 || contentMode === kContentModeUtf8) {
         this._writingBuf = "";
         this.write = write;
@@ -7531,15 +7531,15 @@ var require_sonic_boom = __commonJS({
         this._actualWrite = actualWrite;
         fsWriteSync = () => {
           if (Buffer.isBuffer(this._writingBuf)) {
-            return fs70.writeSync(this.fd, this._writingBuf);
+            return fs71.writeSync(this.fd, this._writingBuf);
           }
-          return fs70.writeSync(this.fd, this._writingBuf, "utf8");
+          return fs71.writeSync(this.fd, this._writingBuf, "utf8");
         };
         fsWrite = () => {
           if (Buffer.isBuffer(this._writingBuf)) {
-            return fs70.write(this.fd, this._writingBuf, this.release);
+            return fs71.write(this.fd, this._writingBuf, this.release);
           }
-          return fs70.write(this.fd, this._writingBuf, "utf8", this.release);
+          return fs71.write(this.fd, this._writingBuf, "utf8", this.release);
         };
       } else {
         throw new Error(`SonicBoom supports "${kContentModeUtf8}" and "${kContentModeBuffer}", but passed ${contentMode}`);
@@ -7596,7 +7596,7 @@ var require_sonic_boom = __commonJS({
           }
         }
         if (this._fsync) {
-          fs70.fsyncSync(this.fd);
+          fs71.fsyncSync(this.fd);
         }
         const len = this._len;
         if (this._reopening) {
@@ -7710,7 +7710,7 @@ var require_sonic_boom = __commonJS({
       const onDrain = () => {
         if (!this._fsync) {
           try {
-            fs70.fsync(this.fd, (err) => {
+            fs71.fsync(this.fd, (err) => {
               this._flushPending = false;
               cb(err);
             });
@@ -7812,7 +7812,7 @@ var require_sonic_boom = __commonJS({
       const fd = this.fd;
       this.once("ready", () => {
         if (fd !== this.fd) {
-          fs70.close(fd, (err) => {
+          fs71.close(fd, (err) => {
             if (err) {
               return this.emit("error", err);
             }
@@ -7861,7 +7861,7 @@ var require_sonic_boom = __commonJS({
           buf = this._bufs[0];
         }
         try {
-          const n = Buffer.isBuffer(buf) ? fs70.writeSync(this.fd, buf) : fs70.writeSync(this.fd, buf, "utf8");
+          const n = Buffer.isBuffer(buf) ? fs71.writeSync(this.fd, buf) : fs71.writeSync(this.fd, buf, "utf8");
           const releasedBufObj = releaseWritingBuf(buf, this._len, n);
           buf = releasedBufObj.writingBuf;
           this._len = releasedBufObj.len;
@@ -7877,7 +7877,7 @@ var require_sonic_boom = __commonJS({
         }
       }
       try {
-        fs70.fsyncSync(this.fd);
+        fs71.fsyncSync(this.fd);
       } catch {
       }
     }
@@ -7898,7 +7898,7 @@ var require_sonic_boom = __commonJS({
           buf = mergeBuf(this._bufs[0], this._lens[0]);
         }
         try {
-          const n = fs70.writeSync(this.fd, buf);
+          const n = fs71.writeSync(this.fd, buf);
           buf = buf.subarray(n);
           this._len = Math.max(this._len - n, 0);
           if (buf.length <= 0) {
@@ -7926,13 +7926,13 @@ var require_sonic_boom = __commonJS({
       this._writingBuf = this._writingBuf.length ? this._writingBuf : this._bufs.shift() || "";
       if (this.sync) {
         try {
-          const written = Buffer.isBuffer(this._writingBuf) ? fs70.writeSync(this.fd, this._writingBuf) : fs70.writeSync(this.fd, this._writingBuf, "utf8");
+          const written = Buffer.isBuffer(this._writingBuf) ? fs71.writeSync(this.fd, this._writingBuf) : fs71.writeSync(this.fd, this._writingBuf, "utf8");
           release(null, written);
         } catch (err) {
           release(err);
         }
       } else {
-        fs70.write(this.fd, this._writingBuf, release);
+        fs71.write(this.fd, this._writingBuf, release);
       }
     }
     function actualWriteBuffer() {
@@ -7941,7 +7941,7 @@ var require_sonic_boom = __commonJS({
       this._writingBuf = this._writingBuf.length ? this._writingBuf : mergeBuf(this._bufs.shift(), this._lens.shift());
       if (this.sync) {
         try {
-          const written = fs70.writeSync(this.fd, this._writingBuf);
+          const written = fs71.writeSync(this.fd, this._writingBuf);
           release(null, written);
         } catch (err) {
           release(err);
@@ -7950,7 +7950,7 @@ var require_sonic_boom = __commonJS({
         if (kCopyBuffer) {
           this._writingBuf = Buffer.from(this._writingBuf);
         }
-        fs70.write(this.fd, this._writingBuf, release);
+        fs71.write(this.fd, this._writingBuf, release);
       }
     }
     function actualClose(sonic) {
@@ -7966,12 +7966,12 @@ var require_sonic_boom = __commonJS({
       sonic._lens = [];
       assert(typeof sonic.fd === "number", `sonic.fd must be a number, got ${typeof sonic.fd}`);
       try {
-        fs70.fsync(sonic.fd, closeWrapped);
+        fs71.fsync(sonic.fd, closeWrapped);
       } catch {
       }
       function closeWrapped() {
         if (sonic.fd !== 1 && sonic.fd !== 2) {
-          fs70.close(sonic.fd, done);
+          fs71.close(sonic.fd, done);
         } else {
           done();
         }
@@ -11364,7 +11364,7 @@ function newestSubagentMtimeMs(projectsRoot, cwd, toolSessionId) {
   const dir = import_node_path5.default.join(projectsRoot, cwdToHashDir(cwd), toolSessionId, "subagents");
   let entries;
   try {
-    entries = import_node_fs5.default.readdirSync(dir, { withFileTypes: true });
+    entries = import_node_fs6.default.readdirSync(dir, { withFileTypes: true });
   } catch {
     return null;
   }
@@ -11373,7 +11373,7 @@ function newestSubagentMtimeMs(projectsRoot, cwd, toolSessionId) {
     if (!e.isFile()) continue;
     if (!e.name.startsWith("agent-") || !e.name.endsWith(".jsonl")) continue;
     try {
-      const m2 = import_node_fs5.default.statSync(import_node_path5.default.join(dir, e.name)).mtimeMs;
+      const m2 = import_node_fs6.default.statSync(import_node_path5.default.join(dir, e.name)).mtimeMs;
       if (newest === null || m2 > newest) newest = m2;
     } catch {
     }
@@ -11387,7 +11387,7 @@ function hashDirToCwd(hash) {
 function findTranscriptByToolSessionId(projectsRoot, toolSessionId) {
   let entries;
   try {
-    entries = import_node_fs5.default.readdirSync(projectsRoot, { withFileTypes: true });
+    entries = import_node_fs6.default.readdirSync(projectsRoot, { withFileTypes: true });
   } catch {
     return null;
   }
@@ -11396,7 +11396,7 @@ function findTranscriptByToolSessionId(projectsRoot, toolSessionId) {
     if (!ent.isDirectory()) continue;
     const candidate = import_node_path5.default.join(projectsRoot, ent.name, `${toolSessionId}.jsonl`);
     try {
-      const st = import_node_fs5.default.statSync(candidate);
+      const st = import_node_fs6.default.statSync(candidate);
       if (!best || st.mtimeMs > best.mtime) best = { p: candidate, mtime: st.mtimeMs };
     } catch {
     }
@@ -11407,7 +11407,7 @@ function deriveCwdFromTranscript(filePath) {
   const dirName = import_node_path5.default.basename(import_node_path5.default.dirname(filePath));
   let raw;
   try {
-    raw = import_node_fs5.default.readFileSync(filePath, "utf8");
+    raw = import_node_fs6.default.readFileSync(filePath, "utf8");
   } catch {
     return null;
   }
@@ -11425,7 +11425,7 @@ function deriveCwdFromTranscript(filePath) {
 }
 function safeStatMtime(p2) {
   try {
-    return import_node_fs5.default.statSync(p2).mtimeMs;
+    return import_node_fs6.default.statSync(p2).mtimeMs;
   } catch {
     return 0;
   }
@@ -11433,7 +11433,7 @@ function safeStatMtime(p2) {
 function readJsonlLines(file) {
   let raw;
   try {
-    raw = import_node_fs5.default.readFileSync(file, "utf8");
+    raw = import_node_fs6.default.readFileSync(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw err;
@@ -11664,7 +11664,7 @@ function attachmentDeferredToolsText(a) {
 function readBackupContent(fileHistoryRoot, toolSessionId, backupFileName) {
   if (backupFileName === null) return null;
   try {
-    return import_node_fs5.default.readFileSync(
+    return import_node_fs6.default.readFileSync(
       import_node_path5.default.join(fileHistoryRoot, toolSessionId, backupFileName),
       "utf8"
     );
@@ -11674,17 +11674,17 @@ function readBackupContent(fileHistoryRoot, toolSessionId, backupFileName) {
 }
 function readCurrentContent(filePath) {
   try {
-    return import_node_fs5.default.readFileSync(filePath, "utf8");
+    return import_node_fs6.default.readFileSync(filePath, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return null;
     return null;
   }
 }
-var import_node_fs5, import_node_os3, import_node_path5, TASK_NOTIFICATION_RE, TASK_ID_RE, TOOL_USE_ID_RE, SLASH_COMMAND_RE, LOCAL_COMMAND_RE, SYSTEM_REMINDER_RE, OPENSPEC_BLOCK_RE, SKILL_HINT_RE, ATTACHMENT_SILENT_SUBTYPES, ClaudeHistoryReader;
+var import_node_fs6, import_node_os3, import_node_path5, TASK_NOTIFICATION_RE, TASK_ID_RE, TOOL_USE_ID_RE, SLASH_COMMAND_RE, LOCAL_COMMAND_RE, SYSTEM_REMINDER_RE, OPENSPEC_BLOCK_RE, SKILL_HINT_RE, ATTACHMENT_SILENT_SUBTYPES, ClaudeHistoryReader;
 var init_claude_history = __esm({
   "src/tools/claude-history.ts"() {
     "use strict";
-    import_node_fs5 = __toESM(require("fs"), 1);
+    import_node_fs6 = __toESM(require("fs"), 1);
     import_node_os3 = __toESM(require("os"), 1);
     import_node_path5 = __toESM(require("path"), 1);
     init_lib();
@@ -11717,7 +11717,7 @@ var init_claude_history = __esm({
       async listProjects() {
         let entries;
         try {
-          entries = import_node_fs5.default.readdirSync(this.projectsRoot, { withFileTypes: true });
+          entries = import_node_fs6.default.readdirSync(this.projectsRoot, { withFileTypes: true });
         } catch (err) {
           if (err.code === "ENOENT") return [];
           throw err;
@@ -11726,7 +11726,7 @@ var init_claude_history = __esm({
         for (const ent of entries) {
           if (!ent.isDirectory()) continue;
           const dir = import_node_path5.default.join(this.projectsRoot, ent.name);
-          const files = import_node_fs5.default.readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+          const files = import_node_fs6.default.readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
           const updatedAtMs = files.reduce((m2, f) => Math.max(m2, safeStatMtime(import_node_path5.default.join(dir, f))), 0);
           out.push({
             projectPath: hashDirToCwd(ent.name),
@@ -11742,7 +11742,7 @@ var init_claude_history = __esm({
         const dir = import_node_path5.default.join(this.projectsRoot, cwdToHashDir(args.projectPath));
         let files;
         try {
-          files = import_node_fs5.default.readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+          files = import_node_fs6.default.readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
         } catch (err) {
           if (err.code === "ENOENT") return [];
           throw err;
@@ -11849,7 +11849,7 @@ var init_claude_history = __esm({
         );
         let entries;
         try {
-          entries = import_node_fs5.default.readdirSync(dir, { withFileTypes: true });
+          entries = import_node_fs6.default.readdirSync(dir, { withFileTypes: true });
         } catch (err) {
           if (err.code === "ENOENT") return null;
           return null;
@@ -11920,7 +11920,7 @@ var init_claude_history = __esm({
         );
         let exists = false;
         try {
-          exists = import_node_fs5.default.statSync(file).isFile();
+          exists = import_node_fs6.default.statSync(file).isFile();
         } catch {
           return null;
         }
@@ -12096,13 +12096,13 @@ var init_claude_history = __esm({
 function probeViaWhich() {
   try {
     const out = (0, import_node_child_process2.execFileSync)("which", ["claude"], { encoding: "utf8" }).trim();
-    if (out && import_node_fs15.default.existsSync(out)) return out;
+    if (out && import_node_fs16.default.existsSync(out)) return out;
   } catch {
   }
   return null;
 }
 async function probeClaude(env = process.env) {
-  if (env.CLAUDE_BIN && import_node_fs15.default.existsSync(env.CLAUDE_BIN)) {
+  if (env.CLAUDE_BIN && import_node_fs16.default.existsSync(env.CLAUDE_BIN)) {
     return { available: true, path: env.CLAUDE_BIN };
   }
   const w2 = probeViaWhich();
@@ -12547,13 +12547,13 @@ function encodeClaudeStdin(text) {
   };
   return JSON.stringify(frame) + "\n";
 }
-var import_node_child_process, import_node_child_process2, import_node_fs15, ATTACHMENT_SILENT_SUBTYPES2, unknownTypeHandler, ATTACHMENT_RE, IMAGE_EXT_MIME, CLAUDE_MODEL_IDS, CLAUDE_MODELS, _assertModelIdsAligned, CLAUDE_PERMISSION_MODES, CLAUDE_CAPABILITIES, ClaudeAdapter;
+var import_node_child_process, import_node_child_process2, import_node_fs16, ATTACHMENT_SILENT_SUBTYPES2, unknownTypeHandler, ATTACHMENT_RE, IMAGE_EXT_MIME, CLAUDE_MODEL_IDS, CLAUDE_MODELS, _assertModelIdsAligned, CLAUDE_PERMISSION_MODES, CLAUDE_CAPABILITIES, ClaudeAdapter;
 var init_claude = __esm({
   "src/tools/claude.ts"() {
     "use strict";
     import_node_child_process = require("child_process");
     import_node_child_process2 = require("child_process");
-    import_node_fs15 = __toESM(require("fs"), 1);
+    import_node_fs16 = __toESM(require("fs"), 1);
     init_protocol();
     init_claude_history();
     init_tool_result_extra();
@@ -40310,8 +40310,8 @@ function startRunCaseRecorder(opts) {
   });
   const ensureStream = () => {
     if (stream) return stream;
-    import_node_fs52.default.mkdirSync(dir, { recursive: true });
-    stream = import_node_fs52.default.createWriteStream(opts.recordPath, { flags: "a" });
+    import_node_fs53.default.mkdirSync(dir, { recursive: true });
+    stream = import_node_fs53.default.createWriteStream(opts.recordPath, { flags: "a" });
     stream.on("close", () => closedResolve());
     return stream;
   };
@@ -40336,11 +40336,11 @@ function startRunCaseRecorder(opts) {
   };
   return { tap, close, closed };
 }
-var import_node_fs52, import_node_path65;
+var import_node_fs53, import_node_path65;
 var init_recorder = __esm({
   "src/run-case/recorder.ts"() {
     "use strict";
-    import_node_fs52 = __toESM(require("fs"), 1);
+    import_node_fs53 = __toESM(require("fs"), 1);
     import_node_path65 = __toESM(require("path"), 1);
   }
 });
@@ -40384,7 +40384,7 @@ var init_wire = __esm({
 // src/run-case/controller.ts
 async function runController(opts) {
   const now = opts.now ?? Date.now;
-  const cwd = opts.cwd ?? (0, import_node_fs53.mkdtempSync)(import_node_path66.default.join(import_node_os22.default.tmpdir(), "clawd-runcase-"));
+  const cwd = opts.cwd ?? (0, import_node_fs54.mkdtempSync)(import_node_path66.default.join(import_node_os22.default.tmpdir(), "clawd-runcase-"));
   const ownsCwd = opts.cwd === void 0;
   const recorder = startRunCaseRecorder({ recordPath: opts.record, now });
   const spawnCtx = { cwd };
@@ -40545,17 +40545,17 @@ async function runController(opts) {
   if (sigintHandler) process.off("SIGINT", sigintHandler);
   if (ownsCwd) {
     try {
-      (0, import_node_fs53.rmSync)(cwd, { recursive: true, force: true });
+      (0, import_node_fs54.rmSync)(cwd, { recursive: true, force: true });
     } catch {
     }
   }
   return exitCode ?? 0;
 }
-var import_node_fs53, import_node_os22, import_node_path66;
+var import_node_fs54, import_node_os22, import_node_path66;
 var init_controller = __esm({
   "src/run-case/controller.ts"() {
     "use strict";
-    import_node_fs53 = require("fs");
+    import_node_fs54 = require("fs");
     import_node_os22 = __toESM(require("os"), 1);
     import_node_path66 = __toESM(require("path"), 1);
     init_claude();
@@ -40952,7 +40952,7 @@ Env (advanced):
 
 // src/index.ts
 var import_node_path64 = __toESM(require("path"), 1);
-var import_node_fs51 = __toESM(require("fs"), 1);
+var import_node_fs52 = __toESM(require("fs"), 1);
 var import_node_os21 = __toESM(require("os"), 1);
 
 // ../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/stringify.js
@@ -41093,6 +41093,35 @@ function pinoLevelToString(n) {
   return null;
 }
 
+// src/log-size-cap.ts
+var import_node_fs3 = __toESM(require("fs"), 1);
+function truncateLogFileToTail(file, maxBytes, keepBytes) {
+  let size;
+  try {
+    size = import_node_fs3.default.statSync(file).size;
+  } catch {
+    return;
+  }
+  if (size <= maxBytes) return;
+  let fd;
+  try {
+    fd = import_node_fs3.default.openSync(file, "r");
+  } catch {
+    return;
+  }
+  try {
+    const buf = Buffer.allocUnsafe(keepBytes);
+    import_node_fs3.default.readSync(fd, buf, 0, keepBytes, size - keepBytes);
+    import_node_fs3.default.writeFileSync(file, buf);
+  } catch {
+  } finally {
+    try {
+      import_node_fs3.default.closeSync(fd);
+    } catch {
+    }
+  }
+}
+
 // ../log-client/dist/index.js
 var DEFAULT_BATCH = {
   maxRecords: 100,
@@ -41373,7 +41402,7 @@ function buildRecord(input, identity, source, homeDir, now) {
 var path5 = __toESM(require("path"), 1);
 
 // src/session/store.ts
-var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_fs4 = __toESM(require("fs"), 1);
 var import_node_path3 = __toESM(require("path"), 1);
 init_protocol();
 
@@ -41462,11 +41491,11 @@ var SessionStore = class {
     return import_node_path3.default.join(this.root, `${safeFileName(sessionId)}.json`);
   }
   ensureDir() {
-    import_node_fs3.default.mkdirSync(this.root, { recursive: true });
+    import_node_fs4.default.mkdirSync(this.root, { recursive: true });
   }
   read(sessionId) {
     try {
-      const raw = import_node_fs3.default.readFileSync(this.filePath(sessionId), "utf8");
+      const raw = import_node_fs4.default.readFileSync(this.filePath(sessionId), "utf8");
       const parsed = JSON.parse(raw);
       return SessionFileSchema.parse(parsed);
     } catch (err) {
@@ -41480,13 +41509,13 @@ var SessionStore = class {
     this.ensureDir();
     const target = this.filePath(validated.sessionId);
     const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
-    import_node_fs3.default.writeFileSync(tmp, JSON.stringify(validated, null, 2), { encoding: "utf8", mode: 384 });
-    import_node_fs3.default.renameSync(tmp, target);
+    import_node_fs4.default.writeFileSync(tmp, JSON.stringify(validated, null, 2), { encoding: "utf8", mode: 384 });
+    import_node_fs4.default.renameSync(tmp, target);
     return validated;
   }
   delete(sessionId) {
     try {
-      import_node_fs3.default.unlinkSync(this.filePath(sessionId));
+      import_node_fs4.default.unlinkSync(this.filePath(sessionId));
       return true;
     } catch (err) {
       const code = err?.code;
@@ -41497,7 +41526,7 @@ var SessionStore = class {
   list() {
     let entries;
     try {
-      entries = import_node_fs3.default.readdirSync(this.root);
+      entries = import_node_fs4.default.readdirSync(this.root);
     } catch (err) {
       const code = err?.code;
       if (code === "ENOENT") return [];
@@ -41509,7 +41538,7 @@ var SessionStore = class {
       if (name.includes(".tmp-")) continue;
       const full = import_node_path3.default.join(this.root, name);
       try {
-        const raw = import_node_fs3.default.readFileSync(full, "utf8");
+        const raw = import_node_fs4.default.readFileSync(full, "utf8");
         const parsed = JSON.parse(raw);
         const validated = SessionFileSchema.parse(parsed);
         out.push(validated);
@@ -41582,7 +41611,7 @@ var SessionStoreFactory = class {
 };
 
 // src/session/manager.ts
-var import_node_fs8 = __toESM(require("fs"), 1);
+var import_node_fs9 = __toESM(require("fs"), 1);
 var import_node_path9 = __toESM(require("path"), 1);
 var import_node_os5 = __toESM(require("os"), 1);
 init_protocol();
@@ -41674,13 +41703,13 @@ function composeGuestSandbox(base, userWorkDir, spawnCwd) {
 }
 
 // src/tools/owner-credentials.ts
-var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_fs5 = __toESM(require("fs"), 1);
 var import_node_path4 = __toESM(require("path"), 1);
 function readOwnerCredentials(homeDir, logger) {
   const settingsPath = import_node_path4.default.join(homeDir, ".claude", "settings.json");
   let raw;
   try {
-    raw = import_node_fs4.default.readFileSync(settingsPath, "utf8");
+    raw = import_node_fs5.default.readFileSync(settingsPath, "utf8");
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT") return null;
@@ -42724,7 +42753,7 @@ init_permission_stdio();
 init_claude_history();
 
 // src/ipc-recorder.ts
-var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_fs7 = __toESM(require("fs"), 1);
 var import_node_path6 = __toESM(require("path"), 1);
 function tsForFilename(ms) {
   return new Date(ms).toISOString().replace(/[:.]/g, "-");
@@ -42746,8 +42775,8 @@ function startRecorder(opts) {
   let exited = false;
   const ensureStream = () => {
     if (stream) return stream;
-    import_node_fs6.default.mkdirSync(dir, { recursive: true });
-    stream = import_node_fs6.default.createWriteStream(filePath, { flags: "a" });
+    import_node_fs7.default.mkdirSync(dir, { recursive: true });
+    stream = import_node_fs7.default.createWriteStream(filePath, { flags: "a" });
     stream.on("close", () => closedResolve());
     return stream;
   };
@@ -43215,7 +43244,7 @@ function extractEditPath(input) {
 }
 
 // src/debug/pty-probe.ts
-var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_fs8 = __toESM(require("fs"), 1);
 var import_node_path8 = __toESM(require("path"), 1);
 var PROBE_DIR = "/tmp/clawd-probe";
 var EVENTS_FILE = import_node_path8.default.join(PROBE_DIR, "events.jsonl");
@@ -43223,7 +43252,7 @@ var inited = false;
 function ensureDir() {
   if (inited) return true;
   try {
-    import_node_fs7.default.mkdirSync(PROBE_DIR, { recursive: true });
+    import_node_fs8.default.mkdirSync(PROBE_DIR, { recursive: true });
     inited = true;
     return true;
   } catch {
@@ -43234,7 +43263,7 @@ function probeEvent(event, data = {}) {
   try {
     if (!ensureDir()) return;
     const line = JSON.stringify({ ts: Date.now(), event, ...data }) + "\n";
-    import_node_fs7.default.appendFileSync(EVENTS_FILE, line);
+    import_node_fs8.default.appendFileSync(EVENTS_FILE, line);
   } catch {
   }
 }
@@ -43242,7 +43271,7 @@ function probeDumpReplay(sessionId, payload) {
   try {
     if (!ensureDir()) return "";
     const file = import_node_path8.default.join(PROBE_DIR, `replay-${sessionId}-${Date.now()}.ans`);
-    import_node_fs7.default.writeFileSync(file, payload, "utf8");
+    import_node_fs8.default.writeFileSync(file, payload, "utf8");
     return file;
   } catch {
     return "";
@@ -43490,7 +43519,7 @@ var SessionManager = class {
     const root = this.deps.storeFactory ? import_node_path9.default.join(this.deps.dataDir, "personas") : import_node_path9.default.join(this.deps.dataDir, "sessions");
     let entries;
     try {
-      entries = import_node_fs8.default.readdirSync(root, { withFileTypes: true });
+      entries = import_node_fs9.default.readdirSync(root, { withFileTypes: true });
     } catch (err) {
       const code = err?.code;
       if (code === "ENOENT") return [];
@@ -43513,7 +43542,7 @@ var SessionManager = class {
     );
     let entries;
     try {
-      entries = import_node_fs8.default.readdirSync(root, { withFileTypes: true });
+      entries = import_node_fs9.default.readdirSync(root, { withFileTypes: true });
     } catch (err) {
       const code = err?.code;
       if (code === "ENOENT") return [];
@@ -43632,7 +43661,7 @@ var SessionManager = class {
       callerDisplayName
     );
     if (subSessionMeta?.userWorkDir) {
-      import_node_fs8.default.mkdirSync(subSessionMeta.userWorkDir, { recursive: true });
+      import_node_fs9.default.mkdirSync(subSessionMeta.userWorkDir, { recursive: true });
     }
     if (scope.kind === "persona" && scope.mode === "guest") {
       if (!this.deps.personaRoot || !subSessionMeta?.userWorkDir) {
@@ -43814,7 +43843,7 @@ var SessionManager = class {
       throw new ClawdError(ERROR_CODES.INVALID_CWD, "cwd required when ownerPersonaId is absent");
     }
     try {
-      const stat = import_node_fs8.default.statSync(cwd);
+      const stat = import_node_fs9.default.statSync(cwd);
       if (!stat.isDirectory()) throw new Error("not dir");
     } catch {
       throw new ClawdError(ERROR_CODES.INVALID_CWD, `cwd not a directory: ${cwd}`);
@@ -44377,7 +44406,7 @@ var SessionManager = class {
    */
   createForScope(args) {
     try {
-      const stat = import_node_fs8.default.statSync(args.cwd);
+      const stat = import_node_fs9.default.statSync(args.cwd);
       if (!stat.isDirectory()) throw new Error("not dir");
     } catch {
       throw new ClawdError(ERROR_CODES.INVALID_CWD, `cwd not a directory: ${args.cwd}`);
@@ -45182,13 +45211,13 @@ var SessionManager = class {
 };
 
 // src/persona/store.ts
-var fs9 = __toESM(require("fs"), 1);
+var fs10 = __toESM(require("fs"), 1);
 var path12 = __toESM(require("path"), 1);
 init_protocol();
 var PersonaStore = class {
   constructor(root) {
     this.root = root;
-    fs9.mkdirSync(root, { recursive: true });
+    fs10.mkdirSync(root, { recursive: true });
   }
   root;
   personaDir(personaId) {
@@ -45216,7 +45245,7 @@ var PersonaStore = class {
   }
   write(persona, personality) {
     const dir = this.personaDir(persona.personaId);
-    fs9.mkdirSync(path12.join(dir, ".clawd"), { recursive: true });
+    fs10.mkdirSync(path12.join(dir, ".clawd"), { recursive: true });
     this.atomicWrite(this.claudeMdPath(persona.personaId), personality);
     this.atomicWrite(this.agentsMdPath(persona.personaId), personality);
     this.writeSandboxSettings(persona.personaId, buildGuestSettingsV1());
@@ -45235,9 +45264,9 @@ var PersonaStore = class {
   ensureAgentsMirror(personaId) {
     const claudeMd = this.claudeMdPath(personaId);
     const agentsMd = this.agentsMdPath(personaId);
-    if (!fs9.existsSync(claudeMd)) return false;
-    if (fs9.existsSync(agentsMd)) return false;
-    this.atomicWrite(agentsMd, fs9.readFileSync(claudeMd, "utf8"));
+    if (!fs10.existsSync(claudeMd)) return false;
+    if (fs10.existsSync(agentsMd)) return false;
+    this.atomicWrite(agentsMd, fs10.readFileSync(claudeMd, "utf8"));
     return true;
   }
   /**
@@ -45266,9 +45295,9 @@ var PersonaStore = class {
   /** 读 codex-sandbox.json；不存在/损坏 → null。 */
   readCodexSandboxSettings(personaId) {
     const p2 = this.codexSandboxSettingsPath(personaId);
-    if (!fs9.existsSync(p2)) return null;
+    if (!fs10.existsSync(p2)) return null;
     try {
-      return CodexSandboxSettingsSchema.parse(JSON.parse(fs9.readFileSync(p2, "utf8")));
+      return CodexSandboxSettingsSchema.parse(JSON.parse(fs10.readFileSync(p2, "utf8")));
     } catch {
       return null;
     }
@@ -45276,7 +45305,7 @@ var PersonaStore = class {
   /** 覆盖写 codex-sandbox.json（seed/migrate 用）。 */
   writeCodexSandboxSettings(personaId, settings) {
     const dir = path12.join(this.personaDir(personaId), ".clawd");
-    fs9.mkdirSync(dir, { recursive: true });
+    fs10.mkdirSync(dir, { recursive: true });
     this.atomicWrite(this.codexSandboxSettingsPath(personaId), JSON.stringify(settings, null, 2));
   }
   writeMeta(persona) {
@@ -45284,8 +45313,8 @@ var PersonaStore = class {
   }
   read(personaId) {
     const p2 = this.metaPath(personaId);
-    if (!fs9.existsSync(p2)) return null;
-    const raw = JSON.parse(fs9.readFileSync(p2, "utf8"));
+    if (!fs10.existsSync(p2)) return null;
+    const raw = JSON.parse(fs10.readFileSync(p2, "utf8"));
     if (raw && typeof raw === "object" && "tokenMap" in raw) {
       delete raw.tokenMap;
       this.atomicWrite(p2, JSON.stringify(raw, null, 2));
@@ -45293,13 +45322,13 @@ var PersonaStore = class {
     return PersonaFileSchema.parse(raw);
   }
   has(personaId) {
-    return fs9.existsSync(this.metaPath(personaId));
+    return fs10.existsSync(this.metaPath(personaId));
   }
   readPersonality(personaId) {
     const claudeMd = this.claudeMdPath(personaId);
-    if (fs9.existsSync(claudeMd)) return fs9.readFileSync(claudeMd, "utf8");
+    if (fs10.existsSync(claudeMd)) return fs10.readFileSync(claudeMd, "utf8");
     const agentsMd = this.agentsMdPath(personaId);
-    if (fs9.existsSync(agentsMd)) return fs9.readFileSync(agentsMd, "utf8");
+    if (fs10.existsSync(agentsMd)) return fs10.readFileSync(agentsMd, "utf8");
     return null;
   }
   /**
@@ -45308,9 +45337,9 @@ var PersonaStore = class {
    */
   readSandboxSettings(personaId) {
     const p2 = this.sandboxSettingsPath(personaId);
-    if (!fs9.existsSync(p2)) return null;
+    if (!fs10.existsSync(p2)) return null;
     try {
-      return JSON.parse(fs9.readFileSync(p2, "utf8"));
+      return JSON.parse(fs10.readFileSync(p2, "utf8"));
     } catch {
       return null;
     }
@@ -45339,10 +45368,10 @@ var PersonaStore = class {
    */
   readEnabledPlugins(personaId) {
     const p2 = this.claudeSettingsPath(personaId);
-    if (!fs9.existsSync(p2)) return [];
+    if (!fs10.existsSync(p2)) return [];
     let raw;
     try {
-      raw = JSON.parse(fs9.readFileSync(p2, "utf8"));
+      raw = JSON.parse(fs10.readFileSync(p2, "utf8"));
     } catch {
       return [];
     }
@@ -45356,22 +45385,22 @@ var PersonaStore = class {
     return out;
   }
   list() {
-    if (!fs9.existsSync(this.root)) return [];
-    return fs9.readdirSync(this.root).filter((name) => {
-      return fs9.existsSync(path12.join(this.root, name, ".clawd", "persona.json"));
+    if (!fs10.existsSync(this.root)) return [];
+    return fs10.readdirSync(this.root).filter((name) => {
+      return fs10.existsSync(path12.join(this.root, name, ".clawd", "persona.json"));
     });
   }
   remove(personaId) {
     const dir = this.personaDir(personaId);
-    if (fs9.existsSync(dir)) fs9.rmSync(dir, { recursive: true, force: true });
+    if (fs10.existsSync(dir)) fs10.rmSync(dir, { recursive: true, force: true });
   }
   personaDirPath(personaId) {
     return this.personaDir(personaId);
   }
   atomicWrite(file, content) {
     const tmp = `${file}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-    fs9.writeFileSync(tmp, content, { mode: 384 });
-    fs9.renameSync(tmp, file);
+    fs10.writeFileSync(tmp, content, { mode: 384 });
+    fs10.renameSync(tmp, file);
   }
 };
 
@@ -45417,7 +45446,7 @@ var PersonaRegistry = class {
 var import_node_crypto3 = __toESM(require("crypto"), 1);
 
 // src/skills/scanner.ts
-var import_node_fs9 = __toESM(require("fs"), 1);
+var import_node_fs10 = __toESM(require("fs"), 1);
 var import_node_os6 = __toESM(require("os"), 1);
 var import_node_path10 = __toESM(require("path"), 1);
 
@@ -45528,7 +45557,7 @@ function parseDescription(content) {
 }
 function isDirLikeSync(p2) {
   try {
-    return import_node_fs9.default.statSync(p2).isDirectory();
+    return import_node_fs10.default.statSync(p2).isDirectory();
   } catch {
     return false;
   }
@@ -45536,7 +45565,7 @@ function isDirLikeSync(p2) {
 function scanSkillDir(dir, source, seen, out, pluginName) {
   let entries;
   try {
-    entries = import_node_fs9.default.readdirSync(dir, { withFileTypes: true });
+    entries = import_node_fs10.default.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -45545,10 +45574,10 @@ function scanSkillDir(dir, source, seen, out, pluginName) {
     if (!ent.isDirectory() && !(ent.isSymbolicLink() && isDirLikeSync(entryPath))) continue;
     let content;
     try {
-      content = import_node_fs9.default.readFileSync(import_node_path10.default.join(entryPath, "SKILL.md"), "utf8");
+      content = import_node_fs10.default.readFileSync(import_node_path10.default.join(entryPath, "SKILL.md"), "utf8");
     } catch {
       try {
-        content = import_node_fs9.default.readFileSync(import_node_path10.default.join(entryPath, "skill.md"), "utf8");
+        content = import_node_fs10.default.readFileSync(import_node_path10.default.join(entryPath, "skill.md"), "utf8");
       } catch {
         continue;
       }
@@ -45572,7 +45601,7 @@ function listSkillsForDir(dir, source) {
 function scanCommandDir(dir, source, seen, out, pluginName) {
   let entries;
   try {
-    entries = import_node_fs9.default.readdirSync(dir, { withFileTypes: true });
+    entries = import_node_fs10.default.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -45582,7 +45611,7 @@ function scanCommandDir(dir, source, seen, out, pluginName) {
       const ns = ent.name;
       let subEntries;
       try {
-        subEntries = import_node_fs9.default.readdirSync(entryPath, { withFileTypes: true });
+        subEntries = import_node_fs10.default.readdirSync(entryPath, { withFileTypes: true });
       } catch {
         continue;
       }
@@ -45591,7 +45620,7 @@ function scanCommandDir(dir, source, seen, out, pluginName) {
         const sePath = import_node_path10.default.join(entryPath, se.name);
         let content;
         try {
-          content = import_node_fs9.default.readFileSync(sePath, "utf8");
+          content = import_node_fs10.default.readFileSync(sePath, "utf8");
         } catch {
           continue;
         }
@@ -45608,7 +45637,7 @@ function scanCommandDir(dir, source, seen, out, pluginName) {
     } else if (ent.name.endsWith(".md")) {
       let content;
       try {
-        content = import_node_fs9.default.readFileSync(entryPath, "utf8");
+        content = import_node_fs10.default.readFileSync(entryPath, "utf8");
       } catch {
         continue;
       }
@@ -45627,7 +45656,7 @@ function readInstalledPlugins(home) {
   const file = import_node_path10.default.join(home, ".claude", "plugins", "installed_plugins.json");
   let raw;
   try {
-    raw = import_node_fs9.default.readFileSync(file, "utf8");
+    raw = import_node_fs10.default.readFileSync(file, "utf8");
   } catch {
     return [];
   }
@@ -45788,7 +45817,7 @@ var PersonaManager = class {
 };
 
 // src/persona/seed.ts
-var fs11 = __toESM(require("fs"), 1);
+var fs12 = __toESM(require("fs"), 1);
 var path14 = __toESM(require("path"), 1);
 var import_node_url = require("url");
 var import_meta = {};
@@ -45959,7 +45988,7 @@ function bundleSiblingFromArgv(argv1, sibling) {
   if (!argv1) return null;
   let real = argv1;
   try {
-    real = fs11.realpathSync(argv1);
+    real = fs12.realpathSync(argv1);
   } catch {
   }
   return path14.resolve(path14.dirname(real), sibling);
@@ -45976,7 +46005,7 @@ function findDefaultsRoot(logger) {
   if (fromArgv) candidates.push(fromArgv);
   for (const c of candidates) {
     try {
-      if (fs11.statSync(c).isDirectory()) {
+      if (fs12.statSync(c).isDirectory()) {
         logger?.info("persona.defaults-root.resolved", { root: c });
         return c;
       }
@@ -45994,7 +46023,7 @@ function seedDefaultPersonas(args) {
       continue;
     }
     const bundleDir = path14.join(args.defaultsRoot, entry.personaId);
-    if (!fs11.existsSync(bundleDir)) {
+    if (!fs12.existsSync(bundleDir)) {
       args.logger.warn("persona.seed.skip", {
         personaId: entry.personaId,
         reason: "bundle-missing",
@@ -46003,7 +46032,7 @@ function seedDefaultPersonas(args) {
       continue;
     }
     const claudeMdPath = path14.join(bundleDir, "CLAUDE.md");
-    if (!fs11.existsSync(claudeMdPath)) {
+    if (!fs12.existsSync(claudeMdPath)) {
       args.logger.warn("persona.seed.skip", {
         personaId: entry.personaId,
         reason: "no-CLAUDE.md",
@@ -46011,7 +46040,7 @@ function seedDefaultPersonas(args) {
       });
       continue;
     }
-    const personality = fs11.readFileSync(claudeMdPath, "utf8");
+    const personality = fs12.readFileSync(claudeMdPath, "utf8");
     const now = Date.now();
     const persona = {
       personaId: entry.personaId,
@@ -46040,14 +46069,14 @@ function skipNodeModulesUnder(srcRoot) {
   return (src) => !path14.relative(srcRoot, src).split(path14.sep).includes("node_modules");
 }
 function copyBundleExtras(srcDir, dstDir) {
-  for (const entry of fs11.readdirSync(srcDir, { withFileTypes: true })) {
+  for (const entry of fs12.readdirSync(srcDir, { withFileTypes: true })) {
     if (entry.name === "CLAUDE.md" || entry.name === ".clawd") continue;
     const srcPath = path14.join(srcDir, entry.name);
     const dstPath = path14.join(dstDir, entry.name);
     if (entry.isDirectory()) {
-      fs11.cpSync(srcPath, dstPath, { recursive: true, dereference: true, filter: skipNodeModulesUnder(srcPath) });
+      fs12.cpSync(srcPath, dstPath, { recursive: true, dereference: true, filter: skipNodeModulesUnder(srcPath) });
     } else if (entry.isFile()) {
-      fs11.copyFileSync(srcPath, dstPath);
+      fs12.copyFileSync(srcPath, dstPath);
     }
   }
 }
@@ -46056,15 +46085,15 @@ function refreshDaemonManagedDirs(args) {
   const entries = args.entries ?? DEFAULT_PERSONAS;
   for (const entry of entries) {
     const bundleDir = path14.join(args.defaultsRoot, entry.personaId);
-    if (!fs11.existsSync(bundleDir)) continue;
+    if (!fs12.existsSync(bundleDir)) continue;
     const personaDir = args.store.personaDirPath(entry.personaId);
-    if (!fs11.existsSync(personaDir)) continue;
+    if (!fs12.existsSync(personaDir)) continue;
     for (const relPath of DAEMON_MANAGED_PATHS) {
       const srcPath = path14.join(bundleDir, relPath);
-      if (!fs11.existsSync(srcPath)) continue;
+      if (!fs12.existsSync(srcPath)) continue;
       const dstPath = path14.join(personaDir, relPath);
       try {
-        fs11.cpSync(srcPath, dstPath, { recursive: true, force: true, dereference: true, filter: skipNodeModulesUnder(srcPath) });
+        fs12.cpSync(srcPath, dstPath, { recursive: true, force: true, dereference: true, filter: skipNodeModulesUnder(srcPath) });
         args.logger.info("persona.refresh.synced", {
           personaId: entry.personaId,
           path: relPath
@@ -46132,7 +46161,7 @@ function findDeployKitRoot(logger) {
   if (fromArgv) candidates.push(fromArgv);
   for (const c of candidates) {
     try {
-      if (fs11.statSync(c).isDirectory()) {
+      if (fs12.statSync(c).isDirectory()) {
         logger?.info("persona.deploy-kit-root.resolved", { root: c });
         return c;
       }
@@ -46144,7 +46173,7 @@ function findDeployKitRoot(logger) {
 }
 function seedDeployKit(args) {
   const dst = path14.join(args.dataDir, "deploy-kit");
-  fs11.cpSync(args.deployKitBundleRoot, dst, {
+  fs12.cpSync(args.deployKitBundleRoot, dst, {
     recursive: true,
     dereference: true,
     force: false,
@@ -46154,34 +46183,34 @@ function seedDeployKit(args) {
 }
 function refreshDeployKit(args) {
   const dst = path14.join(args.dataDir, "deploy-kit");
-  if (!fs11.existsSync(dst)) {
+  if (!fs12.existsSync(dst)) {
     seedDeployKit(args);
     return;
   }
   for (const sub of ["scripts", "contract"]) {
     const s = path14.join(args.deployKitBundleRoot, sub);
-    if (fs11.existsSync(s)) {
-      fs11.cpSync(s, path14.join(dst, sub), { recursive: true, force: true, dereference: true });
+    if (fs12.existsSync(s)) {
+      fs12.cpSync(s, path14.join(dst, sub), { recursive: true, force: true, dereference: true });
     }
   }
   const secretsSrc = path14.join(args.deployKitBundleRoot, ".secrets");
-  if (fs11.existsSync(secretsSrc)) {
-    fs11.mkdirSync(path14.join(dst, ".secrets"), { recursive: true });
-    for (const f of fs11.readdirSync(secretsSrc)) {
+  if (fs12.existsSync(secretsSrc)) {
+    fs12.mkdirSync(path14.join(dst, ".secrets"), { recursive: true });
+    for (const f of fs12.readdirSync(secretsSrc)) {
       if (f.endsWith(".local")) continue;
-      fs11.copyFileSync(path14.join(secretsSrc, f), path14.join(dst, ".secrets", f));
+      fs12.copyFileSync(path14.join(secretsSrc, f), path14.join(dst, ".secrets", f));
     }
   }
   args.logger.info("deploy-kit.refresh.done", { dst });
 }
 
 // src/share-md-viewer/load.ts
-var import_node_fs11 = __toESM(require("fs"), 1);
+var import_node_fs12 = __toESM(require("fs"), 1);
 var import_node_path11 = __toESM(require("path"), 1);
 var import_node_url2 = require("url");
 
 // src/share-md-viewer/asset-loader.ts
-var import_node_fs10 = __toESM(require("fs"), 1);
+var import_node_fs11 = __toESM(require("fs"), 1);
 function htmlEscape(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
@@ -46189,12 +46218,12 @@ function createViewerAssetLoader(opts) {
   let viewerTemplate;
   let errorTemplate;
   try {
-    viewerTemplate = import_node_fs10.default.readFileSync(opts.viewerHtmlPath, "utf8");
+    viewerTemplate = import_node_fs11.default.readFileSync(opts.viewerHtmlPath, "utf8");
   } catch (err) {
     throw new Error(`viewer asset not found at ${opts.viewerHtmlPath}: ${err.message}`);
   }
   try {
-    errorTemplate = import_node_fs10.default.readFileSync(opts.errorHtmlPath, "utf8");
+    errorTemplate = import_node_fs11.default.readFileSync(opts.errorHtmlPath, "utf8");
   } catch (err) {
     throw new Error(`viewer error asset not found at ${opts.errorHtmlPath}: ${err.message}`);
   }
@@ -46222,7 +46251,7 @@ function tryLoadViewerAssets(logger) {
   if (process.argv[1]) {
     let real = process.argv[1];
     try {
-      real = import_node_fs11.default.realpathSync(process.argv[1]);
+      real = import_node_fs12.default.realpathSync(process.argv[1]);
     } catch {
     }
     candidates.push(import_node_path11.default.dirname(real));
@@ -46231,7 +46260,7 @@ function tryLoadViewerAssets(logger) {
     const viewerHtmlPath = import_node_path11.default.join(root, "share-md-viewer.html");
     const errorHtmlPath = import_node_path11.default.join(root, "share-md-viewer-error.html");
     try {
-      if (import_node_fs11.default.statSync(viewerHtmlPath).isFile() && import_node_fs11.default.statSync(errorHtmlPath).isFile()) {
+      if (import_node_fs12.default.statSync(viewerHtmlPath).isFile() && import_node_fs12.default.statSync(errorHtmlPath).isFile()) {
         logger?.info("share-md-viewer.assets-root.resolved", { root });
         return createViewerAssetLoader({ viewerHtmlPath, errorHtmlPath });
       }
@@ -46246,17 +46275,17 @@ function tryLoadViewerAssets(logger) {
 }
 
 // src/share-ui/load.ts
-var import_node_fs13 = __toESM(require("fs"), 1);
+var import_node_fs14 = __toESM(require("fs"), 1);
 var import_node_path13 = __toESM(require("path"), 1);
 var import_node_url3 = require("url");
 
 // src/share-ui/asset-loader.ts
-var import_node_fs12 = __toESM(require("fs"), 1);
+var import_node_fs13 = __toESM(require("fs"), 1);
 var import_node_path12 = __toESM(require("path"), 1);
 function createShareUiAssetLoader(opts) {
   let indexHtml;
   try {
-    indexHtml = import_node_fs12.default.readFileSync(opts.indexHtmlPath, "utf8");
+    indexHtml = import_node_fs13.default.readFileSync(opts.indexHtmlPath, "utf8");
   } catch (err) {
     throw new Error(`share-ui index.html not found at ${opts.indexHtmlPath}: ${err.message}`);
   }
@@ -46269,7 +46298,7 @@ function createShareUiAssetLoader(opts) {
       const resolved = import_node_path12.default.resolve(assetsDir, rel);
       if (resolved !== assetsDir && !resolved.startsWith(assetsDir + import_node_path12.default.sep)) return null;
       try {
-        if (import_node_fs12.default.statSync(resolved).isFile()) return resolved;
+        if (import_node_fs13.default.statSync(resolved).isFile()) return resolved;
       } catch {
       }
       return null;
@@ -46283,7 +46312,7 @@ function bundleDirFromArgv(argv1) {
   if (!argv1) return null;
   let real = argv1;
   try {
-    real = import_node_fs13.default.realpathSync(argv1);
+    real = import_node_fs14.default.realpathSync(argv1);
   } catch {
   }
   return import_node_path13.default.dirname(real);
@@ -46304,7 +46333,7 @@ function tryLoadShareUi(logger) {
     const indexHtmlPath = import_node_path13.default.join(shareUiDir, "guest.html");
     const assetsDir = import_node_path13.default.join(shareUiDir, "assets");
     try {
-      if (import_node_fs13.default.statSync(indexHtmlPath).isFile() && import_node_fs13.default.statSync(assetsDir).isDirectory()) {
+      if (import_node_fs14.default.statSync(indexHtmlPath).isFile() && import_node_fs14.default.statSync(assetsDir).isDirectory()) {
         logger?.info("share-ui.assets-root.resolved", { root: shareUiDir });
         return createShareUiAssetLoader({ indexHtmlPath, assetsDir });
       }
@@ -46386,20 +46415,20 @@ function buildVisitorLogin(deps) {
 }
 
 // src/visitor/visitor-store.ts
-var import_node_fs14 = __toESM(require("fs"), 1);
+var import_node_fs15 = __toESM(require("fs"), 1);
 var import_node_path14 = __toESM(require("path"), 1);
 function createVisitorStore(opts) {
   const file = import_node_path14.default.join(opts.dir, "visitors.json");
   const read = () => {
     try {
-      return JSON.parse(import_node_fs14.default.readFileSync(file, "utf8"));
+      return JSON.parse(import_node_fs15.default.readFileSync(file, "utf8"));
     } catch {
       return [];
     }
   };
   const write = (rows) => {
-    import_node_fs14.default.mkdirSync(opts.dir, { recursive: true });
-    import_node_fs14.default.writeFileSync(file, JSON.stringify(rows, null, 2));
+    import_node_fs15.default.mkdirSync(opts.dir, { recursive: true });
+    import_node_fs15.default.writeFileSync(file, JSON.stringify(rows, null, 2));
   };
   return {
     upsert(r) {
@@ -46433,7 +46462,7 @@ init_claude();
 
 // src/tools/codex.ts
 var import_node_child_process4 = require("child_process");
-var import_node_fs16 = __toESM(require("fs"), 1);
+var import_node_fs17 = __toESM(require("fs"), 1);
 
 // src/tools/codex-session.ts
 var import_node_child_process3 = require("child_process");
@@ -46866,10 +46895,10 @@ function sanitizeCodexModel(model) {
   return CODEX_MODELS.some((m2) => m2.id === model) ? model : void 0;
 }
 async function probeCodex(env = process.env) {
-  if (env.CODEX_BIN && import_node_fs16.default.existsSync(env.CODEX_BIN)) return { available: true, path: env.CODEX_BIN };
+  if (env.CODEX_BIN && import_node_fs17.default.existsSync(env.CODEX_BIN)) return { available: true, path: env.CODEX_BIN };
   try {
     const out = (0, import_node_child_process4.execFileSync)("which", ["codex"], { encoding: "utf8" }).trim();
-    if (out && import_node_fs16.default.existsSync(out)) return { available: true, path: out };
+    if (out && import_node_fs17.default.existsSync(out)) return { available: true, path: out };
   } catch {
   }
   return { available: false };
@@ -46915,7 +46944,7 @@ var CodexAdapter = class {
 
 // src/tools/claude-tui.ts
 var import_node_crypto5 = require("crypto");
-var import_node_fs17 = __toESM(require("fs"), 1);
+var import_node_fs18 = __toESM(require("fs"), 1);
 var import_node_os7 = __toESM(require("os"), 1);
 var import_node_path15 = __toESM(require("path"), 1);
 var import_headless = __toESM(require_xterm_headless(), 1);
@@ -48161,7 +48190,7 @@ function jsonlExistsForCtx(ctx) {
   const home = import_node_os7.default.homedir();
   const file = import_node_path15.default.join(home, ".claude", "projects", cwdToHashDir(ctx.cwd), `${ctx.toolSessionId}.jsonl`);
   try {
-    return import_node_fs17.default.statSync(file).isFile();
+    return import_node_fs18.default.statSync(file).isFile();
   } catch {
     return false;
   }
@@ -48230,7 +48259,7 @@ var PersonaDispatchManager = class {
 };
 
 // src/dispatch/mcp-config.ts
-var import_node_fs18 = __toESM(require("fs"), 1);
+var import_node_fs19 = __toESM(require("fs"), 1);
 var import_node_path16 = __toESM(require("path"), 1);
 function dispatchMcpConfigPath(dataDir) {
   return import_node_path16.default.join(dataDir, "dispatch.mcp.json");
@@ -48248,13 +48277,13 @@ function writeDispatchMcpConfig(args) {
       }
     }
   };
-  import_node_fs18.default.mkdirSync(args.dataDir, { recursive: true });
-  import_node_fs18.default.writeFileSync(cfgPath, JSON.stringify(content, null, 2), "utf8");
+  import_node_fs19.default.mkdirSync(args.dataDir, { recursive: true });
+  import_node_fs19.default.writeFileSync(cfgPath, JSON.stringify(content, null, 2), "utf8");
   return cfgPath;
 }
 
 // src/ticket/mcp-config.ts
-var import_node_fs19 = __toESM(require("fs"), 1);
+var import_node_fs20 = __toESM(require("fs"), 1);
 var import_node_path17 = __toESM(require("path"), 1);
 function ticketMcpConfigPath(dataDir) {
   return import_node_path17.default.join(dataDir, "ticket.mcp.json");
@@ -48277,13 +48306,13 @@ function writeTicketMcpConfig(args) {
       }
     }
   };
-  import_node_fs19.default.mkdirSync(args.dataDir, { recursive: true });
-  import_node_fs19.default.writeFileSync(cfgPath, JSON.stringify(content, null, 2), "utf8");
+  import_node_fs20.default.mkdirSync(args.dataDir, { recursive: true });
+  import_node_fs20.default.writeFileSync(cfgPath, JSON.stringify(content, null, 2), "utf8");
   return cfgPath;
 }
 
 // src/shift/mcp-config.ts
-var import_node_fs20 = __toESM(require("fs"), 1);
+var import_node_fs21 = __toESM(require("fs"), 1);
 var import_node_path18 = __toESM(require("path"), 1);
 function shiftMcpConfigPath(dataDir) {
   return import_node_path18.default.join(dataDir, "shift.mcp.json");
@@ -48301,13 +48330,13 @@ async function writeShiftMcpConfig(args) {
       }
     }
   };
-  await import_node_fs20.default.promises.mkdir(args.dataDir, { recursive: true });
-  await import_node_fs20.default.promises.writeFile(cfgPath, JSON.stringify(content, null, 2), "utf8");
+  await import_node_fs21.default.promises.mkdir(args.dataDir, { recursive: true });
+  await import_node_fs21.default.promises.writeFile(cfgPath, JSON.stringify(content, null, 2), "utf8");
   return cfgPath;
 }
 
 // src/inbox/mcp-config.ts
-var import_node_fs21 = __toESM(require("fs"), 1);
+var import_node_fs22 = __toESM(require("fs"), 1);
 var import_node_path19 = __toESM(require("path"), 1);
 function inboxMcpConfigPath(dataDir) {
   return import_node_path19.default.join(dataDir, "inbox.mcp.json");
@@ -48325,8 +48354,8 @@ async function writeInboxMcpConfig(args) {
       }
     }
   };
-  await import_node_fs21.default.promises.mkdir(args.dataDir, { recursive: true });
-  await import_node_fs21.default.promises.writeFile(cfgPath, JSON.stringify(content, null, 2), "utf8");
+  await import_node_fs22.default.promises.mkdir(args.dataDir, { recursive: true });
+  await import_node_fs22.default.promises.writeFile(cfgPath, JSON.stringify(content, null, 2), "utf8");
   return cfgPath;
 }
 
@@ -49311,7 +49340,7 @@ async function listCodexSkills(cwd, deps = {}) {
 }
 
 // src/workspace/browser.ts
-var import_node_fs22 = __toESM(require("fs"), 1);
+var import_node_fs23 = __toESM(require("fs"), 1);
 var import_node_os8 = __toESM(require("os"), 1);
 var import_node_path21 = __toESM(require("path"), 1);
 init_protocol();
@@ -49327,7 +49356,7 @@ function resolveInsideCwd(cwd, subpath) {
 }
 function ensureCwd(cwd) {
   try {
-    const stat = import_node_fs22.default.statSync(cwd);
+    const stat = import_node_fs23.default.statSync(cwd);
     if (!stat.isDirectory()) {
       throw new ClawdError(ERROR_CODES.INVALID_CWD, `not a directory: ${cwd}`);
     }
@@ -49341,7 +49370,7 @@ var WorkspaceBrowser = class {
     const cwd = args.cwd && args.cwd.length > 0 ? args.cwd : import_node_os8.default.homedir();
     ensureCwd(cwd);
     const full = resolveInsideCwd(cwd, args.path);
-    const dirents = import_node_fs22.default.readdirSync(full, { withFileTypes: true });
+    const dirents = import_node_fs23.default.readdirSync(full, { withFileTypes: true });
     const entries = [];
     for (const d of dirents) {
       if (!args.showHidden && d.name.startsWith(".")) continue;
@@ -49351,7 +49380,7 @@ var WorkspaceBrowser = class {
         mtime: ""
       };
       try {
-        const st = import_node_fs22.default.statSync(import_node_path21.default.join(full, d.name));
+        const st = import_node_fs23.default.statSync(import_node_path21.default.join(full, d.name));
         entry.mtime = new Date(st.mtimeMs).toISOString();
         if (d.isFile()) entry.size = st.size;
       } catch {
@@ -49367,14 +49396,14 @@ var WorkspaceBrowser = class {
   read(args) {
     ensureCwd(args.cwd);
     const full = resolveInsideCwd(args.cwd, args.path);
-    const st = import_node_fs22.default.statSync(full);
+    const st = import_node_fs23.default.statSync(full);
     if (!st.isFile()) {
       throw new ClawdError(ERROR_CODES.INVALID_PATH, `not a file: ${args.path}`);
     }
     if (st.size > MAX_FILE_BYTES) {
       throw new ClawdError(ERROR_CODES.FILE_TOO_LARGE, `file > ${MAX_FILE_BYTES} bytes`);
     }
-    const buf = import_node_fs22.default.readFileSync(full);
+    const buf = import_node_fs23.default.readFileSync(full);
     const isBinary = buf.includes(0);
     if (isBinary) {
       return {
@@ -49396,20 +49425,20 @@ var WorkspaceBrowser = class {
 };
 
 // src/skills/agents-scanner.ts
-var import_node_fs23 = __toESM(require("fs"), 1);
+var import_node_fs24 = __toESM(require("fs"), 1);
 var import_node_os9 = __toESM(require("os"), 1);
 var import_node_path22 = __toESM(require("path"), 1);
 var DEFAULT_POLICY_DIR_DARWIN = "/Library/Application Support/ClaudeCode/.claude/agents";
 function isDirLikeSync2(p2) {
   try {
-    return import_node_fs23.default.statSync(p2).isDirectory();
+    return import_node_fs24.default.statSync(p2).isDirectory();
   } catch {
     return false;
   }
 }
 function fileExistsSync(p2) {
   try {
-    return import_node_fs23.default.statSync(p2).isFile();
+    return import_node_fs24.default.statSync(p2).isFile();
   } catch {
     return false;
   }
@@ -49417,7 +49446,7 @@ function fileExistsSync(p2) {
 function parseAgentFile(filePath) {
   let content;
   try {
-    content = import_node_fs23.default.readFileSync(filePath, "utf8");
+    content = import_node_fs24.default.readFileSync(filePath, "utf8");
   } catch {
     return {};
   }
@@ -49430,7 +49459,7 @@ function parseAgentFile(filePath) {
 function scanAgentsDir(dir, source, seen, out) {
   let entries;
   try {
-    entries = import_node_fs23.default.readdirSync(dir, { withFileTypes: true });
+    entries = import_node_fs24.default.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -49457,7 +49486,7 @@ function scanPluginAgentsTree(root, pluginName, seen, out) {
   function walk2(dir, namespaces) {
     let entries;
     try {
-      entries = import_node_fs23.default.readdirSync(dir, { withFileTypes: true });
+      entries = import_node_fs24.default.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -49493,7 +49522,7 @@ function readInstalledPlugins2(home) {
   let raw = null;
   for (const candidate of [v2, v1]) {
     try {
-      raw = import_node_fs23.default.readFileSync(candidate, "utf8");
+      raw = import_node_fs24.default.readFileSync(candidate, "utf8");
       break;
     } catch {
     }
@@ -49524,7 +49553,7 @@ function walkUpProjectAgentsDirs(startCwd, home, seen, out) {
     scanAgentsDir(import_node_path22.default.join(cur, ".claude", "agents"), "project", seen, out);
     let hasGit = false;
     try {
-      hasGit = import_node_fs23.default.existsSync(import_node_path22.default.join(cur, ".git"));
+      hasGit = import_node_fs24.default.existsSync(import_node_path22.default.join(cur, ".git"));
     } catch {
     }
     if (hasGit) return;
@@ -49587,13 +49616,13 @@ var AgentsScanner = class {
 };
 
 // src/observer/session-observer.ts
-var import_node_fs25 = __toESM(require("fs"), 1);
+var import_node_fs26 = __toESM(require("fs"), 1);
 var import_node_os11 = __toESM(require("os"), 1);
 var import_node_path24 = __toESM(require("path"), 1);
 init_claude_history();
 
 // src/observer/subagent-meta-observer.ts
-var import_node_fs24 = __toESM(require("fs"), 1);
+var import_node_fs25 = __toESM(require("fs"), 1);
 var import_node_os10 = __toESM(require("os"), 1);
 var import_node_path23 = __toESM(require("path"), 1);
 init_claude_history();
@@ -49638,7 +49667,7 @@ var SubagentMetaObserver = class {
   attachWatcher(w2) {
     if (w2.watcher) return;
     try {
-      w2.watcher = import_node_fs24.default.watch(w2.dirPath, { persistent: false }, (_evt, name) => {
+      w2.watcher = import_node_fs25.default.watch(w2.dirPath, { persistent: false }, (_evt, name) => {
         if (!name) return;
         const m2 = META_RE.exec(String(name));
         if (!m2) return;
@@ -49650,7 +49679,7 @@ var SubagentMetaObserver = class {
   scan(w2) {
     let entries;
     try {
-      entries = import_node_fs24.default.readdirSync(w2.dirPath);
+      entries = import_node_fs25.default.readdirSync(w2.dirPath);
     } catch {
       return;
     }
@@ -49667,7 +49696,7 @@ var SubagentMetaObserver = class {
     const file = import_node_path23.default.join(w2.dirPath, name);
     let raw;
     try {
-      raw = import_node_fs24.default.readFileSync(file, "utf8");
+      raw = import_node_fs25.default.readFileSync(file, "utf8");
     } catch {
       return;
     }
@@ -49731,7 +49760,7 @@ var SessionObserver = class {
     const filePath = this.resolveJsonlPath(args.cwd, args.toolSessionId, args.jsonlPath);
     let size = 0;
     try {
-      size = import_node_fs25.default.statSync(filePath).size;
+      size = import_node_fs26.default.statSync(filePath).size;
     } catch {
     }
     const w2 = {
@@ -49744,16 +49773,16 @@ var SessionObserver = class {
       adapter: args.adapter,
       prevIsRejectSentinel: false,
       toolSessionId: args.toolSessionId,
-      sawFile: import_node_fs25.default.existsSync(filePath),
+      sawFile: import_node_fs26.default.existsSync(filePath),
       lastRelocateScanMs: 0,
       pendingCwdDerive: false,
       lastDeriveMs: 0
     };
     try {
-      import_node_fs25.default.mkdirSync(import_node_path24.default.dirname(filePath), { recursive: true });
+      import_node_fs26.default.mkdirSync(import_node_path24.default.dirname(filePath), { recursive: true });
     } catch {
     }
-    w2.watcher = import_node_fs25.default.watch(import_node_path24.default.dirname(filePath), { persistent: false }, (_event, changedName) => {
+    w2.watcher = import_node_fs26.default.watch(import_node_path24.default.dirname(filePath), { persistent: false }, (_event, changedName) => {
       if (!changedName || !w2.filePath.endsWith(changedName)) return;
       this.poll(w2);
     });
@@ -49776,7 +49805,7 @@ var SessionObserver = class {
   // 异常静默吞，不阻塞 watcher 启动
   hydrateMetaTail(w2, maxLines = 200) {
     try {
-      const raw = import_node_fs25.default.readFileSync(w2.filePath, "utf8");
+      const raw = import_node_fs26.default.readFileSync(w2.filePath, "utf8");
       if (!raw) return;
       const allLines = raw.split("\n").filter((l) => l.trim().length > 0);
       if (allLines.length === 0) return;
@@ -49800,7 +49829,7 @@ var SessionObserver = class {
   poll(w2) {
     let size = 0;
     try {
-      size = import_node_fs25.default.statSync(w2.filePath).size;
+      size = import_node_fs26.default.statSync(w2.filePath).size;
     } catch {
       if (w2.sawFile) this.maybeRelocate(w2);
       return;
@@ -49811,11 +49840,11 @@ var SessionObserver = class {
       w2.buf = "";
     }
     if (size === w2.lastSize) return;
-    const fd = import_node_fs25.default.openSync(w2.filePath, "r");
+    const fd = import_node_fs26.default.openSync(w2.filePath, "r");
     try {
       const len = size - w2.lastSize;
       const buf = Buffer.alloc(len);
-      import_node_fs25.default.readSync(fd, buf, 0, len, w2.lastSize);
+      import_node_fs26.default.readSync(fd, buf, 0, len, w2.lastSize);
       w2.lastSize = size;
       w2.buf += buf.toString("utf8");
       let newlineIndex;
@@ -49838,7 +49867,7 @@ var SessionObserver = class {
         }
       }
     } finally {
-      import_node_fs25.default.closeSync(fd);
+      import_node_fs26.default.closeSync(fd);
     }
     if (w2.pendingCwdDerive) this.maybeDeriveCwd(w2);
   }
@@ -49859,7 +49888,7 @@ var SessionObserver = class {
     }
     w2.filePath = found;
     try {
-      w2.watcher = import_node_fs25.default.watch(import_node_path24.default.dirname(found), { persistent: false }, (_event, changedName) => {
+      w2.watcher = import_node_fs26.default.watch(import_node_path24.default.dirname(found), { persistent: false }, (_event, changedName) => {
         if (!changedName || !w2.filePath.endsWith(changedName)) return;
         this.poll(w2);
       });
@@ -50710,14 +50739,14 @@ async function authenticate(token, deps) {
 }
 
 // src/permission/capability-store.ts
-var fs29 = __toESM(require("fs"), 1);
+var fs30 = __toESM(require("fs"), 1);
 var path29 = __toESM(require("path"), 1);
 var CAPABILITIES_FILE_NAME = "capabilities.json";
 var FILE_VERSION = 1;
 var CapabilityStore = class {
   constructor(dataDir) {
     this.dataDir = dataDir;
-    fs29.mkdirSync(dataDir, { recursive: true });
+    fs30.mkdirSync(dataDir, { recursive: true });
     this.cache = this.readFromDisk();
   }
   dataDir;
@@ -50747,7 +50776,7 @@ var CapabilityStore = class {
     const file = this.filePath();
     let raw;
     try {
-      raw = fs29.readFileSync(file, "utf8");
+      raw = fs30.readFileSync(file, "utf8");
     } catch (err) {
       if (err?.code === "ENOENT") return [];
       return [];
@@ -50775,10 +50804,10 @@ var CapabilityStore = class {
   }
   atomicWrite(file, content) {
     const tmp = `${file}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-    fs29.writeFileSync(tmp, content, { mode: 384 });
-    fs29.renameSync(tmp, file);
+    fs30.writeFileSync(tmp, content, { mode: 384 });
+    fs30.renameSync(tmp, file);
     try {
-      fs29.chmodSync(file, 384);
+      fs30.chmodSync(file, 384);
     } catch {
     }
   }
@@ -50871,14 +50900,14 @@ var CapabilityManager = class {
 };
 
 // src/permission/cleanup.ts
-var fs30 = __toESM(require("fs"), 1);
+var fs31 = __toESM(require("fs"), 1);
 function cleanupGuestSessionsForCapability(cap, factory) {
   const removed = [];
   for (const g2 of cap.grants) {
     if (g2.resource.type !== "persona") continue;
     const dir = factory.vmGuestRoot(g2.resource.id, cap.id);
     try {
-      fs30.rmSync(dir, { recursive: true, force: true });
+      fs31.rmSync(dir, { recursive: true, force: true });
       removed.push(dir);
     } catch {
     }
@@ -50887,13 +50916,13 @@ function cleanupGuestSessionsForCapability(cap, factory) {
 }
 
 // src/inbox/inbox-store.ts
-var fs31 = __toESM(require("fs"), 1);
+var fs32 = __toESM(require("fs"), 1);
 var path30 = __toESM(require("path"), 1);
 var INBOX_SUBDIR = "inbox";
 var InboxStore = class {
   constructor(dataDir) {
     this.dataDir = dataDir;
-    fs31.mkdirSync(this.dirPath(), { recursive: true });
+    fs32.mkdirSync(this.dirPath(), { recursive: true });
   }
   dataDir;
   /**
@@ -50905,7 +50934,7 @@ var InboxStore = class {
     const file = this.filePath(peerDeviceId);
     let raw;
     try {
-      raw = fs31.readFileSync(file, "utf8");
+      raw = fs32.readFileSync(file, "utf8");
     } catch (err) {
       if (err?.code === "ENOENT") return [];
       return [];
@@ -50921,7 +50950,7 @@ var InboxStore = class {
     const dir = this.dirPath();
     let entries;
     try {
-      entries = fs31.readdirSync(dir);
+      entries = fs32.readdirSync(dir);
     } catch (err) {
       if (err?.code === "ENOENT") return [];
       return [];
@@ -50937,9 +50966,9 @@ var InboxStore = class {
     if (existing.some((m2) => m2.id === message.id)) return;
     const file = this.filePath(message.peerDeviceId);
     const line = JSON.stringify(message) + "\n";
-    fs31.appendFileSync(file, line, { mode: 384 });
+    fs32.appendFileSync(file, line, { mode: 384 });
     try {
-      fs31.chmodSync(file, 384);
+      fs32.chmodSync(file, 384);
     } catch {
     }
   }
@@ -50969,7 +50998,7 @@ var InboxStore = class {
   removeByPeerDeviceId(peerDeviceId) {
     const file = this.filePath(peerDeviceId);
     try {
-      fs31.unlinkSync(file);
+      fs32.unlinkSync(file);
     } catch (err) {
       if (err?.code === "ENOENT") return;
     }
@@ -50978,10 +51007,10 @@ var InboxStore = class {
     const file = this.filePath(peerDeviceId);
     const tmp = `${file}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
     const content = messages.map((m2) => JSON.stringify(m2)).join("\n") + (messages.length > 0 ? "\n" : "");
-    fs31.writeFileSync(tmp, content, { mode: 384 });
-    fs31.renameSync(tmp, file);
+    fs32.writeFileSync(tmp, content, { mode: 384 });
+    fs32.renameSync(tmp, file);
     try {
-      fs31.chmodSync(file, 384);
+      fs32.chmodSync(file, 384);
     } catch {
     }
   }
@@ -51077,7 +51106,7 @@ var InboxManager = class {
 };
 
 // src/state/contact-store.ts
-var fs32 = __toESM(require("fs"), 1);
+var fs33 = __toESM(require("fs"), 1);
 var path31 = __toESM(require("path"), 1);
 var FILE_NAME = "contacts.json";
 var ContactStore = class {
@@ -51091,7 +51120,7 @@ var ContactStore = class {
     const file = path31.join(this.dataDir, FILE_NAME);
     let raw;
     try {
-      raw = fs32.readFileSync(file, "utf8");
+      raw = fs33.readFileSync(file, "utf8");
     } catch (err) {
       if (err?.code !== "ENOENT") this.renameBak(file);
       return;
@@ -51170,13 +51199,13 @@ var ContactStore = class {
       null,
       2
     );
-    fs32.mkdirSync(this.dataDir, { recursive: true });
-    fs32.writeFileSync(tmp, content, { mode: 384 });
-    fs32.renameSync(tmp, file);
+    fs33.mkdirSync(this.dataDir, { recursive: true });
+    fs33.writeFileSync(tmp, content, { mode: 384 });
+    fs33.renameSync(tmp, file);
   }
   renameBak(file) {
     try {
-      fs32.renameSync(file, `${file}.bak`);
+      fs33.renameSync(file, `${file}.bak`);
     } catch {
     }
   }
@@ -51330,7 +51359,7 @@ async function autoReverseContact(args) {
 }
 
 // src/migrations/2026-05-20-flatten-sessions.ts
-var fs33 = __toESM(require("fs"), 1);
+var fs34 = __toESM(require("fs"), 1);
 var path32 = __toESM(require("path"), 1);
 var MIGRATION_FLAG_NAME = ".migration.v1.done";
 function migrateFlattenSessions(opts) {
@@ -51350,7 +51379,7 @@ function migrateFlattenSessions(opts) {
       if (!entry.endsWith(".json")) continue;
       const src = path32.join(defaultDir, entry);
       const dst = path32.join(sessionsDir, entry);
-      fs33.renameSync(src, dst);
+      fs34.renameSync(src, dst);
       movedBare += 1;
     }
     rmdirIfEmpty(defaultDir);
@@ -51362,10 +51391,10 @@ function migrateFlattenSessions(opts) {
     const ownerSrc = path32.join(personaDir, "owner");
     if (existsSync3(ownerSrc) && isDir(ownerSrc)) {
       const ownerDst = path32.join(dataDir, "personas", pid, ".clawd", "sessions", "owner");
-      fs33.mkdirSync(ownerDst, { recursive: true });
+      fs34.mkdirSync(ownerDst, { recursive: true });
       for (const file of readdirSafe(ownerSrc)) {
         if (!file.endsWith(".json")) continue;
-        fs33.renameSync(path32.join(ownerSrc, file), path32.join(ownerDst, file));
+        fs34.renameSync(path32.join(ownerSrc, file), path32.join(ownerDst, file));
         movedVmOwner += 1;
       }
       rmdirIfEmpty(ownerSrc);
@@ -51373,18 +51402,18 @@ function migrateFlattenSessions(opts) {
     const listenerSrc = path32.join(personaDir, "listener");
     if (existsSync3(listenerSrc) && isDir(listenerSrc)) {
       const archiveDst = path32.join(dataDir, ".legacy", `listener-${pid}`);
-      fs33.mkdirSync(archiveDst, { recursive: true });
+      fs34.mkdirSync(archiveDst, { recursive: true });
       for (const file of readdirSafe(listenerSrc)) {
         if (!file.endsWith(".json")) continue;
-        fs33.renameSync(path32.join(listenerSrc, file), path32.join(archiveDst, file));
+        fs34.renameSync(path32.join(listenerSrc, file), path32.join(archiveDst, file));
         archivedListener += 1;
       }
       rmdirIfEmpty(listenerSrc);
     }
     rmdirIfEmpty(personaDir);
   }
-  fs33.mkdirSync(sessionsDir, { recursive: true });
-  fs33.writeFileSync(flagPath, JSON.stringify({ migratedAt: now() }, null, 2));
+  fs34.mkdirSync(sessionsDir, { recursive: true });
+  fs34.writeFileSync(flagPath, JSON.stringify({ migratedAt: now() }, null, 2));
   return {
     skipped: false,
     flagWritten: true,
@@ -51395,7 +51424,7 @@ function migrateFlattenSessions(opts) {
 }
 function existsSync3(p2) {
   try {
-    fs33.statSync(p2);
+    fs34.statSync(p2);
     return true;
   } catch {
     return false;
@@ -51403,27 +51432,27 @@ function existsSync3(p2) {
 }
 function isDir(p2) {
   try {
-    return fs33.statSync(p2).isDirectory();
+    return fs34.statSync(p2).isDirectory();
   } catch {
     return false;
   }
 }
 function readdirSafe(p2) {
   try {
-    return fs33.readdirSync(p2);
+    return fs34.readdirSync(p2);
   } catch {
     return [];
   }
 }
 function rmdirIfEmpty(p2) {
   try {
-    fs33.rmdirSync(p2);
+    fs34.rmdirSync(p2);
   } catch {
   }
 }
 
 // src/transport/http-router.ts
-var import_node_fs27 = __toESM(require("fs"), 1);
+var import_node_fs28 = __toESM(require("fs"), 1);
 var import_node_path28 = __toESM(require("path"), 1);
 
 // src/attachment/mime.ts
@@ -51603,7 +51632,7 @@ function verifySignedUrl(secret, absPath, eRaw, s, now = Date.now) {
 }
 
 // src/attachment/upload.ts
-var import_node_fs26 = __toESM(require("fs"), 1);
+var import_node_fs27 = __toESM(require("fs"), 1);
 var import_node_path26 = __toESM(require("path"), 1);
 var import_node_crypto8 = __toESM(require("crypto"), 1);
 var import_promises2 = require("stream/promises");
@@ -51625,7 +51654,7 @@ async function writeUploadedAttachment(args) {
   assertValidFileName(args.fileName);
   const attachmentsRoot = import_node_path26.default.join(args.sessionDir, ".attachments");
   try {
-    import_node_fs26.default.mkdirSync(attachmentsRoot, { recursive: true });
+    import_node_fs27.default.mkdirSync(attachmentsRoot, { recursive: true });
   } catch (err) {
     throw new UploadError("STORAGE_ERROR", `mkdir failed: ${err.message}`);
   }
@@ -51646,18 +51675,18 @@ async function writeUploadedAttachment(args) {
           yield buf;
         }
       },
-      import_node_fs26.default.createWriteStream(tmpPath, { mode: 384 })
+      import_node_fs27.default.createWriteStream(tmpPath, { mode: 384 })
     );
   } catch (err) {
     try {
-      import_node_fs26.default.unlinkSync(tmpPath);
+      import_node_fs27.default.unlinkSync(tmpPath);
     } catch {
     }
     throw new UploadError("STORAGE_ERROR", `write failed: ${err.message}`);
   }
   if (actualSize !== args.contentLength) {
     try {
-      import_node_fs26.default.unlinkSync(tmpPath);
+      import_node_fs27.default.unlinkSync(tmpPath);
     } catch {
     }
     throw new UploadError(
@@ -51670,24 +51699,24 @@ async function writeUploadedAttachment(args) {
   let finalFileName;
   let hashDirExists = false;
   try {
-    hashDirExists = import_node_fs26.default.statSync(hashDir).isDirectory();
+    hashDirExists = import_node_fs27.default.statSync(hashDir).isDirectory();
   } catch {
   }
   if (hashDirExists) {
-    const existing = import_node_fs26.default.readdirSync(hashDir).filter((n) => !n.startsWith("."));
+    const existing = import_node_fs27.default.readdirSync(hashDir).filter((n) => !n.startsWith("."));
     finalFileName = existing[0] ?? args.fileName;
     try {
-      import_node_fs26.default.unlinkSync(tmpPath);
+      import_node_fs27.default.unlinkSync(tmpPath);
     } catch {
     }
   } else {
     try {
-      import_node_fs26.default.mkdirSync(hashDir, { recursive: true });
+      import_node_fs27.default.mkdirSync(hashDir, { recursive: true });
       finalFileName = args.fileName;
-      import_node_fs26.default.renameSync(tmpPath, import_node_path26.default.join(hashDir, finalFileName));
+      import_node_fs27.default.renameSync(tmpPath, import_node_path26.default.join(hashDir, finalFileName));
     } catch (err) {
       try {
-        import_node_fs26.default.unlinkSync(tmpPath);
+        import_node_fs27.default.unlinkSync(tmpPath);
       } catch {
       }
       throw new UploadError("STORAGE_ERROR", `rename failed: ${err.message}`);
@@ -51967,7 +51996,7 @@ function createHttpRouter(deps) {
       }
       let buf;
       try {
-        buf = await import_node_fs27.default.promises.readFile(abs);
+        buf = await import_node_fs28.default.promises.readFile(abs);
       } catch {
         sendJson(res, 404, { code: "NOT_FOUND", message: "asset not found" });
         return true;
@@ -52407,7 +52436,7 @@ function withCtx(ctx, body) {
 function streamFile(res, absPath, logger) {
   let stat;
   try {
-    stat = import_node_fs27.default.statSync(absPath);
+    stat = import_node_fs28.default.statSync(absPath);
   } catch (err) {
     const code = err?.code;
     if (code === "ENOENT") {
@@ -52430,7 +52459,7 @@ function streamFile(res, absPath, logger) {
     // 防止浏览器把任意 mime 当 html 渲染
     "X-Content-Type-Options": "nosniff"
   });
-  const stream = import_node_fs27.default.createReadStream(absPath);
+  const stream = import_node_fs28.default.createReadStream(absPath);
   stream.on("error", (err) => {
     logger?.warn("streamFile read error", { absPath, err: err.message });
     res.destroy();
@@ -52439,7 +52468,7 @@ function streamFile(res, absPath, logger) {
 }
 
 // src/attachment/gc.ts
-var import_node_fs28 = __toESM(require("fs"), 1);
+var import_node_fs29 = __toESM(require("fs"), 1);
 var import_node_path29 = __toESM(require("path"), 1);
 var DEFAULT_TTL_MS = 30 * 24 * 3600 * 1e3;
 function runAttachmentGc(args) {
@@ -52462,7 +52491,7 @@ function runAttachmentGc(args) {
     const attRoot = import_node_path29.default.join(sessionDir, ".attachments");
     let hashDirs;
     try {
-      hashDirs = import_node_fs28.default.readdirSync(attRoot);
+      hashDirs = import_node_fs29.default.readdirSync(attRoot);
     } catch (err) {
       if (err.code === "ENOENT") continue;
       args.logger?.warn("attachment gc: readdir failed", { attRoot, err: err.message });
@@ -52472,7 +52501,7 @@ function runAttachmentGc(args) {
       const hashDirAbs = import_node_path29.default.join(attRoot, hashDir);
       let files;
       try {
-        files = import_node_fs28.default.readdirSync(hashDirAbs);
+        files = import_node_fs29.default.readdirSync(hashDirAbs);
       } catch {
         continue;
       }
@@ -52480,7 +52509,7 @@ function runAttachmentGc(args) {
         const file = import_node_path29.default.join(hashDirAbs, name);
         let stat;
         try {
-          stat = import_node_fs28.default.statSync(file);
+          stat = import_node_fs29.default.statSync(file);
         } catch {
           continue;
         }
@@ -52489,25 +52518,25 @@ function runAttachmentGc(args) {
         if (age < ttlMs) continue;
         if (liveAbs.has(file)) continue;
         try {
-          import_node_fs28.default.unlinkSync(file);
+          import_node_fs29.default.unlinkSync(file);
         } catch (err) {
           args.logger?.warn("attachment gc: unlink failed", { file, err: err.message });
         }
       }
       try {
-        if (import_node_fs28.default.readdirSync(hashDirAbs).length === 0) import_node_fs28.default.rmdirSync(hashDirAbs);
+        if (import_node_fs29.default.readdirSync(hashDirAbs).length === 0) import_node_fs29.default.rmdirSync(hashDirAbs);
       } catch {
       }
     }
     try {
-      if (import_node_fs28.default.readdirSync(attRoot).length === 0) import_node_fs28.default.rmdirSync(attRoot);
+      if (import_node_fs29.default.readdirSync(attRoot).length === 0) import_node_fs29.default.rmdirSync(attRoot);
     } catch {
     }
   }
 }
 
 // src/attachment/group.ts
-var import_node_fs29 = __toESM(require("fs"), 1);
+var import_node_fs30 = __toESM(require("fs"), 1);
 var import_node_path30 = __toESM(require("path"), 1);
 var import_node_crypto9 = __toESM(require("crypto"), 1);
 init_protocol();
@@ -52533,7 +52562,7 @@ var GroupFileStore = class {
   readFile(scope, sessionId) {
     const file = this.filePath(scope, sessionId);
     try {
-      const raw = import_node_fs29.default.readFileSync(file, "utf8");
+      const raw = import_node_fs30.default.readFileSync(file, "utf8");
       const parsed = JSON.parse(raw);
       if (!Array.isArray(parsed)) {
         this.logger?.warn("GroupFileStore.readFile: not an array; resetting session entries", {
@@ -52559,10 +52588,10 @@ var GroupFileStore = class {
   }
   writeFile(scope, sessionId, entries) {
     const file = this.filePath(scope, sessionId);
-    import_node_fs29.default.mkdirSync(import_node_path30.default.dirname(file), { recursive: true });
+    import_node_fs30.default.mkdirSync(import_node_path30.default.dirname(file), { recursive: true });
     const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-    import_node_fs29.default.writeFileSync(tmp, JSON.stringify(entries, null, 2), { mode: 384 });
-    import_node_fs29.default.renameSync(tmp, file);
+    import_node_fs30.default.writeFileSync(tmp, JSON.stringify(entries, null, 2), { mode: 384 });
+    import_node_fs30.default.renameSync(tmp, file);
   }
   /** 拉一份当前 session 的清单。读盘 → cache；之后调用复用 cache */
   list(scope, sessionId) {
@@ -52648,7 +52677,7 @@ var GroupFileStore = class {
 };
 
 // src/discovery/state-file.ts
-var import_node_fs30 = __toESM(require("fs"), 1);
+var import_node_fs31 = __toESM(require("fs"), 1);
 var import_node_path31 = __toESM(require("path"), 1);
 function defaultStateFilePath(dataDir) {
   return import_node_path31.default.join(dataDir, "state.json");
@@ -52673,7 +52702,7 @@ var StateFileManager = class {
   }
   read() {
     try {
-      const raw = import_node_fs30.default.readFileSync(this.file, "utf8");
+      const raw = import_node_fs31.default.readFileSync(this.file, "utf8");
       const parsed = JSON.parse(raw);
       return parsed;
     } catch {
@@ -52687,20 +52716,20 @@ var StateFileManager = class {
     return { status: "stale", existing };
   }
   write(state) {
-    import_node_fs30.default.mkdirSync(import_node_path31.default.dirname(this.file), { recursive: true });
+    import_node_fs31.default.mkdirSync(import_node_path31.default.dirname(this.file), { recursive: true });
     const tmp = `${this.file}.tmp.${process.pid}.${Date.now()}`;
-    import_node_fs30.default.writeFileSync(tmp, JSON.stringify(state, null, 2), { mode: 384 });
-    import_node_fs30.default.renameSync(tmp, this.file);
+    import_node_fs31.default.writeFileSync(tmp, JSON.stringify(state, null, 2), { mode: 384 });
+    import_node_fs31.default.renameSync(tmp, this.file);
     if (process.platform !== "win32") {
       try {
-        import_node_fs30.default.chmodSync(this.file, 384);
+        import_node_fs31.default.chmodSync(this.file, 384);
       } catch {
       }
     }
   }
   delete() {
     try {
-      import_node_fs30.default.unlinkSync(this.file);
+      import_node_fs31.default.unlinkSync(this.file);
     } catch {
     }
   }
@@ -52714,13 +52743,13 @@ function readSpawnedByDesktopFromEnv(env = process.env) {
 }
 
 // src/tunnel/tunnel-manager.ts
-var import_node_fs34 = __toESM(require("fs"), 1);
+var import_node_fs35 = __toESM(require("fs"), 1);
 var import_node_path35 = __toESM(require("path"), 1);
 var import_node_crypto10 = __toESM(require("crypto"), 1);
 var import_node_child_process9 = require("child_process");
 
 // src/tunnel/tunnel-store.ts
-var import_node_fs31 = __toESM(require("fs"), 1);
+var import_node_fs32 = __toESM(require("fs"), 1);
 var import_node_path32 = __toESM(require("path"), 1);
 var TunnelStore = class {
   constructor(filePath) {
@@ -52729,7 +52758,7 @@ var TunnelStore = class {
   filePath;
   async get() {
     try {
-      const raw = await import_node_fs31.default.promises.readFile(this.filePath, "utf8");
+      const raw = await import_node_fs32.default.promises.readFile(this.filePath, "utf8");
       const obj = JSON.parse(raw);
       if (!isPersistedTunnel(obj)) return null;
       return obj;
@@ -52741,21 +52770,21 @@ var TunnelStore = class {
   }
   async set(v2) {
     const dir = import_node_path32.default.dirname(this.filePath);
-    await import_node_fs31.default.promises.mkdir(dir, { recursive: true });
+    await import_node_fs32.default.promises.mkdir(dir, { recursive: true });
     const data = JSON.stringify(v2, null, 2);
     const tmp = `${this.filePath}.tmp.${process.pid}.${Date.now()}`;
-    await import_node_fs31.default.promises.writeFile(tmp, data, { mode: 384 });
+    await import_node_fs32.default.promises.writeFile(tmp, data, { mode: 384 });
     if (process.platform !== "win32") {
       try {
-        await import_node_fs31.default.promises.chmod(tmp, 384);
+        await import_node_fs32.default.promises.chmod(tmp, 384);
       } catch {
       }
     }
-    await import_node_fs31.default.promises.rename(tmp, this.filePath);
+    await import_node_fs32.default.promises.rename(tmp, this.filePath);
   }
   async clear() {
     try {
-      await import_node_fs31.default.promises.unlink(this.filePath);
+      await import_node_fs32.default.promises.unlink(this.filePath);
     } catch (err) {
       const code = err?.code;
       if (code !== "ENOENT") throw err;
@@ -52850,7 +52879,7 @@ function escape(v2) {
 }
 
 // src/tunnel/frpc-binary.ts
-var import_node_fs32 = __toESM(require("fs"), 1);
+var import_node_fs33 = __toESM(require("fs"), 1);
 var import_node_os13 = __toESM(require("os"), 1);
 var import_node_path33 = __toESM(require("path"), 1);
 var import_node_child_process7 = require("child_process");
@@ -52884,7 +52913,7 @@ function frpcDownloadUrl(version2, p2) {
 }
 async function ensureFrpcBinary(opts) {
   if (opts.override) {
-    if (!import_node_fs32.default.existsSync(opts.override)) {
+    if (!import_node_fs33.default.existsSync(opts.override)) {
       throw new Error(`frpc binary not found at override path: ${opts.override}`);
     }
     return opts.override;
@@ -52892,10 +52921,10 @@ async function ensureFrpcBinary(opts) {
   const version2 = opts.version ?? FRPC_VERSION;
   const platform = opts.platform ?? detectPlatform();
   const binDir = import_node_path33.default.join(opts.dataDir, "bin");
-  import_node_fs32.default.mkdirSync(binDir, { recursive: true });
+  import_node_fs33.default.mkdirSync(binDir, { recursive: true });
   cleanupStaleArtifacts(binDir);
   const stableBin = import_node_path33.default.join(binDir, "frpc");
-  if (import_node_fs32.default.existsSync(stableBin)) return stableBin;
+  if (import_node_fs33.default.existsSync(stableBin)) return stableBin;
   const partialBin = `${stableBin}.partial`;
   const tarballPath = import_node_path33.default.join(binDir, `frp_${version2}_${platform.os}_${platform.arch}.tar.gz.partial`);
   try {
@@ -52906,8 +52935,8 @@ async function ensureFrpcBinary(opts) {
     } else {
       await extractFrpcFromTarball(tarballPath, binDir, version2, platform, partialBin);
     }
-    import_node_fs32.default.chmodSync(partialBin, 493);
-    import_node_fs32.default.renameSync(partialBin, stableBin);
+    import_node_fs33.default.chmodSync(partialBin, 493);
+    import_node_fs33.default.renameSync(partialBin, stableBin);
   } finally {
     safeUnlink(tarballPath);
     safeUnlink(partialBin);
@@ -52917,7 +52946,7 @@ async function ensureFrpcBinary(opts) {
 function cleanupStaleArtifacts(binDir) {
   let entries;
   try {
-    entries = import_node_fs32.default.readdirSync(binDir);
+    entries = import_node_fs33.default.readdirSync(binDir);
   } catch {
     return;
   }
@@ -52925,7 +52954,7 @@ function cleanupStaleArtifacts(binDir) {
     if (name.endsWith(".partial") || name.startsWith("extract-")) {
       const full = import_node_path33.default.join(binDir, name);
       try {
-        import_node_fs32.default.rmSync(full, { recursive: true, force: true });
+        import_node_fs33.default.rmSync(full, { recursive: true, force: true });
       } catch {
       }
     }
@@ -52933,7 +52962,7 @@ function cleanupStaleArtifacts(binDir) {
 }
 function safeUnlink(p2) {
   try {
-    import_node_fs32.default.unlinkSync(p2);
+    import_node_fs33.default.unlinkSync(p2);
   } catch {
   }
 }
@@ -52944,13 +52973,13 @@ async function downloadToFile(url, dest, fetchImpl) {
   if (!res.ok || !res.body) {
     throw new Error(`download failed: ${res.status} ${res.statusText}`);
   }
-  const out = import_node_fs32.default.createWriteStream(dest);
+  const out = import_node_fs33.default.createWriteStream(dest);
   const nodeStream = import_node_stream3.Readable.fromWeb(res.body);
   await (0, import_promises4.pipeline)(nodeStream, out);
 }
 async function extractFrpcFromTarball(tarball, binDir, version2, platform, destBin) {
   const work = import_node_path33.default.join(binDir, `extract-${process.pid}-${Date.now()}`);
-  import_node_fs32.default.mkdirSync(work, { recursive: true });
+  import_node_fs33.default.mkdirSync(work, { recursive: true });
   try {
     await new Promise((resolve6, reject) => {
       const proc = (0, import_node_child_process7.spawn)("tar", ["xzf", tarball, "-C", work], { stdio: "pipe" });
@@ -52959,17 +52988,17 @@ async function extractFrpcFromTarball(tarball, binDir, version2, platform, destB
     });
     const dirName = `frp_${version2}_${platform.os}_${platform.arch}`;
     const src = import_node_path33.default.join(work, dirName, "frpc");
-    if (!import_node_fs32.default.existsSync(src)) {
+    if (!import_node_fs33.default.existsSync(src)) {
       throw new Error(`frpc not found inside tarball at ${src}`);
     }
-    import_node_fs32.default.copyFileSync(src, destBin);
+    import_node_fs33.default.copyFileSync(src, destBin);
   } finally {
-    import_node_fs32.default.rmSync(work, { recursive: true, force: true });
+    import_node_fs33.default.rmSync(work, { recursive: true, force: true });
   }
 }
 
 // src/tunnel/frpc-process.ts
-var import_node_fs33 = __toESM(require("fs"), 1);
+var import_node_fs34 = __toESM(require("fs"), 1);
 var import_node_path34 = __toESM(require("path"), 1);
 var import_node_child_process8 = require("child_process");
 function frpcPidFilePath(dataDir) {
@@ -52977,13 +53006,13 @@ function frpcPidFilePath(dataDir) {
 }
 function writeFrpcPid(dataDir, pid) {
   try {
-    import_node_fs33.default.writeFileSync(frpcPidFilePath(dataDir), String(pid), { mode: 384 });
+    import_node_fs34.default.writeFileSync(frpcPidFilePath(dataDir), String(pid), { mode: 384 });
   } catch {
   }
 }
 function clearFrpcPid(dataDir) {
   try {
-    import_node_fs33.default.unlinkSync(frpcPidFilePath(dataDir));
+    import_node_fs34.default.unlinkSync(frpcPidFilePath(dataDir));
   } catch {
   }
 }
@@ -52999,7 +53028,7 @@ function defaultIsPidAlive(pid) {
 }
 function defaultReadPidFile(file) {
   try {
-    return import_node_fs33.default.readFileSync(file, "utf8");
+    return import_node_fs34.default.readFileSync(file, "utf8");
   } catch {
     return null;
   }
@@ -53039,7 +53068,7 @@ async function killStaleFrpc(deps) {
   }
   if (victims.size === 0) {
     try {
-      import_node_fs33.default.unlinkSync(pidFile);
+      import_node_fs34.default.unlinkSync(pidFile);
     } catch {
     }
     return;
@@ -53050,7 +53079,7 @@ async function killStaleFrpc(deps) {
   }
   await sleep2(deps.reapWaitMs ?? 300);
   try {
-    import_node_fs33.default.unlinkSync(pidFile);
+    import_node_fs34.default.unlinkSync(pidFile);
   } catch {
   }
 }
@@ -53225,14 +53254,14 @@ var TunnelManager = class {
         localPort,
         logLevel: "info"
       });
-      await import_node_fs34.default.promises.writeFile(tomlPath, toml, { mode: 384 });
+      await import_node_fs35.default.promises.writeFile(tomlPath, toml, { mode: 384 });
       const proc = (this.deps.spawnImpl ?? import_node_child_process9.spawn)(frpcBin, ["-c", tomlPath], {
         stdio: ["ignore", "pipe", "pipe"]
       });
       const logDir = import_node_path35.default.join(this.deps.dataDir, "log");
-      import_node_fs34.default.mkdirSync(logDir, { recursive: true });
+      import_node_fs35.default.mkdirSync(logDir, { recursive: true });
       const logFilePath = import_node_path35.default.join(logDir, "frpc.log");
-      const logStream = import_node_fs34.default.createWriteStream(logFilePath, { flags: "a", mode: 384 });
+      const logStream = import_node_fs35.default.createWriteStream(logFilePath, { flags: "a", mode: 384 });
       logStream.on("error", () => {
       });
       const tee = (chunk) => {
@@ -53314,7 +53343,7 @@ async function waitForFrpcReady(proc, timeoutMs) {
 }
 
 // src/sshd/sshd-manager.ts
-var import_node_fs38 = __toESM(require("fs"), 1);
+var import_node_fs39 = __toESM(require("fs"), 1);
 var import_node_path39 = __toESM(require("path"), 1);
 var import_node_child_process11 = require("child_process");
 
@@ -53340,7 +53369,7 @@ function buildSshdConfig(input) {
 }
 
 // src/sshd/sshd-process.ts
-var import_node_fs35 = __toESM(require("fs"), 1);
+var import_node_fs36 = __toESM(require("fs"), 1);
 var import_node_path36 = __toESM(require("path"), 1);
 var import_node_child_process10 = require("child_process");
 function sshdPidFilePath(dataDir) {
@@ -53349,14 +53378,14 @@ function sshdPidFilePath(dataDir) {
 function writeSshdPid(dataDir, pid) {
   try {
     const p2 = sshdPidFilePath(dataDir);
-    import_node_fs35.default.mkdirSync(import_node_path36.default.dirname(p2), { recursive: true, mode: 448 });
-    import_node_fs35.default.writeFileSync(p2, String(pid), { mode: 384 });
+    import_node_fs36.default.mkdirSync(import_node_path36.default.dirname(p2), { recursive: true, mode: 448 });
+    import_node_fs36.default.writeFileSync(p2, String(pid), { mode: 384 });
   } catch {
   }
 }
 function clearSshdPid(dataDir) {
   try {
-    import_node_fs35.default.unlinkSync(sshdPidFilePath(dataDir));
+    import_node_fs36.default.unlinkSync(sshdPidFilePath(dataDir));
   } catch {
   }
 }
@@ -53372,7 +53401,7 @@ function defaultIsPidAlive2(pid) {
 }
 function defaultReadPidFile2(file) {
   try {
-    return import_node_fs35.default.readFileSync(file, "utf8");
+    return import_node_fs36.default.readFileSync(file, "utf8");
   } catch {
     return null;
   }
@@ -53412,7 +53441,7 @@ async function killStaleSshd(deps) {
   }
   if (victims.size === 0) {
     try {
-      import_node_fs35.default.unlinkSync(pidFile);
+      import_node_fs36.default.unlinkSync(pidFile);
     } catch {
     }
     return;
@@ -53423,7 +53452,7 @@ async function killStaleSshd(deps) {
   }
   await sleep2(deps.reapWaitMs ?? 300);
   try {
-    import_node_fs35.default.unlinkSync(pidFile);
+    import_node_fs36.default.unlinkSync(pidFile);
   } catch {
   }
 }
@@ -53456,7 +53485,7 @@ async function defaultScanSshdPidsByCmdline(configPath, logger) {
 }
 
 // src/sshd/jail-script.ts
-var import_node_fs36 = __toESM(require("fs"), 1);
+var import_node_fs37 = __toESM(require("fs"), 1);
 var import_node_path37 = __toESM(require("path"), 1);
 var CLAWD_SSH_JAIL_SCRIPT = String.raw`#!/usr/bin/env bash
 # clawd-ssh-jail — SSH reverse access sandbox wrapper (managed by clawd; do not edit)
@@ -53595,14 +53624,14 @@ esac
 `;
 function ensureJailScript(dataDir) {
   const binDir = import_node_path37.default.join(dataDir, "bin");
-  import_node_fs36.default.mkdirSync(binDir, { recursive: true, mode: 493 });
+  import_node_fs37.default.mkdirSync(binDir, { recursive: true, mode: 493 });
   const target = import_node_path37.default.join(binDir, "clawd-ssh-jail");
-  import_node_fs36.default.writeFileSync(target, CLAWD_SSH_JAIL_SCRIPT, { mode: 493 });
+  import_node_fs37.default.writeFileSync(target, CLAWD_SSH_JAIL_SCRIPT, { mode: 493 });
   return target;
 }
 
 // src/sshd/clawd-shim.ts
-var import_node_fs37 = __toESM(require("fs"), 1);
+var import_node_fs38 = __toESM(require("fs"), 1);
 var import_node_path38 = __toESM(require("path"), 1);
 function shellQuote(s) {
   return `'${s.replace(/'/g, "'\\''")}'`;
@@ -53619,9 +53648,9 @@ exec ${shellQuote(execPath)} ${shellQuote(cliPath)} "$@"
 }
 function ensureClawdShim(dataDir, execPath, cliPath) {
   const binDir = import_node_path38.default.join(dataDir, "bin");
-  import_node_fs37.default.mkdirSync(binDir, { recursive: true, mode: 493 });
+  import_node_fs38.default.mkdirSync(binDir, { recursive: true, mode: 493 });
   const target = import_node_path38.default.join(binDir, "clawd");
-  import_node_fs37.default.writeFileSync(target, buildClawdShim(execPath, cliPath), { mode: 493 });
+  import_node_fs38.default.writeFileSync(target, buildClawdShim(execPath, cliPath), { mode: 493 });
   return target;
 }
 
@@ -53648,17 +53677,17 @@ var SshdManager = class {
       ownPid: process.pid,
       logger
     });
-    import_node_fs38.default.mkdirSync(this.sshdDir, { recursive: true, mode: 448 });
-    import_node_fs38.default.mkdirSync(import_node_path39.default.join(this.sshdDir, "authorized_keys.d"), { recursive: true, mode: 448 });
+    import_node_fs39.default.mkdirSync(this.sshdDir, { recursive: true, mode: 448 });
+    import_node_fs39.default.mkdirSync(import_node_path39.default.join(this.sshdDir, "authorized_keys.d"), { recursive: true, mode: 448 });
     ensureJailScript(this.deps.dataDir);
     ensureClawdShim(this.deps.dataDir, process.execPath, process.argv[1] ?? "");
     const hostKeyPath = import_node_path39.default.join(this.sshdDir, "host_key");
-    if (!import_node_fs38.default.existsSync(hostKeyPath)) {
+    if (!import_node_fs39.default.existsSync(hostKeyPath)) {
       await this.generateHostKey(hostKeyPath);
     }
     const akFile = import_node_path39.default.join(this.sshdDir, "authorized_keys.d", "clawd-contacts");
-    if (!import_node_fs38.default.existsSync(akFile)) {
-      import_node_fs38.default.writeFileSync(akFile, "", { mode: 384 });
+    if (!import_node_fs39.default.existsSync(akFile)) {
+      import_node_fs39.default.writeFileSync(akFile, "", { mode: 384 });
     }
     const configPath = import_node_path39.default.join(this.sshdDir, "sshd_config");
     const config = buildSshdConfig({
@@ -53668,14 +53697,14 @@ var SshdManager = class {
       authorizedKeysFile: akFile,
       pidFilePath: import_node_path39.default.join(this.sshdDir, "sshd.pid")
     });
-    import_node_fs38.default.writeFileSync(configPath, config, { mode: 384 });
+    import_node_fs39.default.writeFileSync(configPath, config, { mode: 384 });
     const sshdBin = this.deps.sshdBin ?? "/usr/sbin/sshd";
     const proc = (this.deps.spawnImpl ?? import_node_child_process11.spawn)(sshdBin, ["-D", "-e", "-f", configPath], {
       stdio: ["ignore", "pipe", "pipe"]
     });
     const sshdLogDir = import_node_path39.default.join(this.deps.dataDir, "log");
-    import_node_fs38.default.mkdirSync(sshdLogDir, { recursive: true });
-    const logStream = import_node_fs38.default.createWriteStream(import_node_path39.default.join(sshdLogDir, "sshd.log"), {
+    import_node_fs39.default.mkdirSync(sshdLogDir, { recursive: true });
+    const logStream = import_node_fs39.default.createWriteStream(import_node_path39.default.join(sshdLogDir, "sshd.log"), {
       flags: "a",
       mode: 384
     });
@@ -53768,7 +53797,7 @@ ${tail}` : ready.error;
       p2.on("error", reject);
     });
     try {
-      import_node_fs38.default.chmodSync(hostKeyPath, 384);
+      import_node_fs39.default.chmodSync(hostKeyPath, 384);
     } catch {
     }
   }
@@ -53811,7 +53840,7 @@ async function waitForSshdReady(proc, timeoutMs) {
 }
 
 // src/sshd/authorized-keys.ts
-var import_node_fs39 = __toESM(require("fs"), 1);
+var import_node_fs40 = __toESM(require("fs"), 1);
 var import_node_path40 = __toESM(require("path"), 1);
 var JAIL_BIN_PATH_ENV = "CLAWD_JAIL_BIN_PATH";
 var AUTHORIZED_KEYS_FILE = "clawd-contacts";
@@ -53821,7 +53850,7 @@ function jailBinPath() {
 function rebuildAuthorizedKeys(store, sshdDir) {
   const akDir = import_node_path40.default.join(sshdDir, "authorized_keys.d");
   const target = import_node_path40.default.join(akDir, AUTHORIZED_KEYS_FILE);
-  import_node_fs39.default.mkdirSync(akDir, { recursive: true, mode: 448 });
+  import_node_fs40.default.mkdirSync(akDir, { recursive: true, mode: 448 });
   const lines = ["# managed by clawd; do not edit", ""];
   for (const c of store.list()) {
     if (!c.sshAllowed) continue;
@@ -53835,25 +53864,25 @@ function rebuildAuthorizedKeys(store, sshdDir) {
   }
   const body = lines.join("\n") + "\n";
   const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
-  import_node_fs39.default.writeFileSync(tmp, body, { mode: 384 });
-  import_node_fs39.default.renameSync(tmp, target);
+  import_node_fs40.default.writeFileSync(tmp, body, { mode: 384 });
+  import_node_fs40.default.renameSync(tmp, target);
 }
 function readIssuedPubkey(sshdDir, deviceId) {
   const safeId = deviceId.replace(/[\/\\]/g, "_");
   const p2 = import_node_path40.default.join(sshdDir, "keys", `${safeId}.ed25519.pub`);
   try {
-    return import_node_fs39.default.readFileSync(p2, "utf8");
+    return import_node_fs40.default.readFileSync(p2, "utf8");
   } catch {
     return null;
   }
 }
 
 // src/sshd/contact-key-puller.ts
-var import_node_fs41 = __toESM(require("fs"), 1);
+var import_node_fs42 = __toESM(require("fs"), 1);
 var import_node_path42 = __toESM(require("path"), 1);
 
 // src/sshd/contact-ssh-log.ts
-var import_node_fs40 = __toESM(require("fs"), 1);
+var import_node_fs41 = __toESM(require("fs"), 1);
 var import_node_path41 = __toESM(require("path"), 1);
 function createContactSshLog(dataDir) {
   const file = import_node_path41.default.join(dataDir, "log", "contact-ssh.log");
@@ -53869,8 +53898,8 @@ function createContactSshLog(dataDir) {
     }
     line += "\n";
     try {
-      import_node_fs40.default.mkdirSync(import_node_path41.default.dirname(file), { recursive: true });
-      import_node_fs40.default.appendFileSync(file, line, { mode: 384 });
+      import_node_fs41.default.mkdirSync(import_node_path41.default.dirname(file), { recursive: true });
+      import_node_fs41.default.appendFileSync(file, line, { mode: 384 });
     } catch {
     }
   }
@@ -53959,12 +53988,12 @@ async function pullContactSshKeyOnce(deps) {
 }
 function writeKeyFile(dataDir, deviceId, pem) {
   const p2 = safeContactKeyPath(dataDir, deviceId);
-  import_node_fs41.default.mkdirSync(import_node_path42.default.dirname(p2), { recursive: true, mode: 448 });
-  import_node_fs41.default.writeFileSync(p2, pem, { mode: 384 });
+  import_node_fs42.default.mkdirSync(import_node_path42.default.dirname(p2), { recursive: true, mode: 448 });
+  import_node_fs42.default.writeFileSync(p2, pem, { mode: 384 });
 }
 function removeKeyFile(dataDir, deviceId) {
   try {
-    import_node_fs41.default.unlinkSync(safeContactKeyPath(dataDir, deviceId));
+    import_node_fs42.default.unlinkSync(safeContactKeyPath(dataDir, deviceId));
     return true;
   } catch {
     return false;
@@ -54299,7 +54328,7 @@ function deriveStableDeviceKey(opts = {}) {
 }
 
 // src/auth-store.ts
-var import_node_fs42 = __toESM(require("fs"), 1);
+var import_node_fs43 = __toESM(require("fs"), 1);
 var import_node_path44 = __toESM(require("path"), 1);
 var import_node_crypto12 = __toESM(require("crypto"), 1);
 var AUTH_FILE_NAME = "auth.json";
@@ -54340,7 +54369,7 @@ function defaultGenerateOwnerPrincipalId() {
 }
 function readAuthFile(file) {
   try {
-    const raw = import_node_fs42.default.readFileSync(file, "utf8");
+    const raw = import_node_fs43.default.readFileSync(file, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.token !== "string" || parsed.token.length === 0) {
       return null;
@@ -54360,16 +54389,16 @@ function readAuthFile(file) {
   }
 }
 function writeAuthFile(file, content) {
-  import_node_fs42.default.mkdirSync(import_node_path44.default.dirname(file), { recursive: true });
-  import_node_fs42.default.writeFileSync(file, JSON.stringify(content, null, 2), { mode: 384 });
+  import_node_fs43.default.mkdirSync(import_node_path44.default.dirname(file), { recursive: true });
+  import_node_fs43.default.writeFileSync(file, JSON.stringify(content, null, 2), { mode: 384 });
   try {
-    import_node_fs42.default.chmodSync(file, 384);
+    import_node_fs43.default.chmodSync(file, 384);
   } catch {
   }
 }
 
 // src/owner-profile.ts
-var import_node_fs43 = __toESM(require("fs"), 1);
+var import_node_fs44 = __toESM(require("fs"), 1);
 var import_node_os15 = __toESM(require("os"), 1);
 var import_node_path45 = __toESM(require("path"), 1);
 var PROFILE_FILENAME = "profile.json";
@@ -54378,7 +54407,7 @@ function loadOwnerDisplayName(dataDir) {
   const profilePath = import_node_path45.default.join(dataDir, PROFILE_FILENAME);
   let raw;
   try {
-    raw = import_node_fs43.default.readFileSync(profilePath, "utf8");
+    raw = import_node_fs44.default.readFileSync(profilePath, "utf8");
   } catch {
     return fallback;
   }
@@ -54401,7 +54430,7 @@ function loadOwnerDisplayName(dataDir) {
 }
 
 // src/feishu-auth/owner-identity-store.ts
-var import_node_fs44 = __toESM(require("fs"), 1);
+var import_node_fs45 = __toESM(require("fs"), 1);
 var import_node_path46 = __toESM(require("path"), 1);
 var OWNER_IDENTITY_FILE_NAME = "owner-identity.json";
 var OwnerIdentityStore = class {
@@ -54412,7 +54441,7 @@ var OwnerIdentityStore = class {
   read() {
     let raw;
     try {
-      raw = import_node_fs44.default.readFileSync(this.file, "utf8");
+      raw = import_node_fs45.default.readFileSync(this.file, "utf8");
     } catch {
       return null;
     }
@@ -54440,16 +54469,16 @@ var OwnerIdentityStore = class {
     };
   }
   write(record) {
-    import_node_fs44.default.mkdirSync(import_node_path46.default.dirname(this.file), { recursive: true });
-    import_node_fs44.default.writeFileSync(this.file, JSON.stringify(record, null, 2), { mode: 384 });
+    import_node_fs45.default.mkdirSync(import_node_path46.default.dirname(this.file), { recursive: true });
+    import_node_fs45.default.writeFileSync(this.file, JSON.stringify(record, null, 2), { mode: 384 });
     try {
-      import_node_fs44.default.chmodSync(this.file, 384);
+      import_node_fs45.default.chmodSync(this.file, 384);
     } catch {
     }
   }
   clear() {
     try {
-      import_node_fs44.default.unlinkSync(this.file);
+      import_node_fs45.default.unlinkSync(this.file);
     } catch (err) {
       const code = err?.code;
       if (code !== "ENOENT") throw err;
@@ -54782,7 +54811,7 @@ function verifyConnectToken(args) {
 }
 
 // src/feishu-auth/server-key.ts
-var fs54 = __toESM(require("fs"), 1);
+var fs55 = __toESM(require("fs"), 1);
 var path55 = __toESM(require("path"), 1);
 var FILE_NAME2 = "server-signing-key.json";
 var ServerKeyStore = class {
@@ -54796,7 +54825,7 @@ var ServerKeyStore = class {
   /** 读缓存的公钥；无缓存 / 损坏 → null（调用方决定是否触发拉取） */
   read() {
     try {
-      const raw = fs54.readFileSync(this.filePath(), "utf8");
+      const raw = fs55.readFileSync(this.filePath(), "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.publicKeyPem === "string" && parsed.publicKeyPem.includes("PUBLIC KEY")) {
         return parsed.publicKeyPem;
@@ -54811,12 +54840,12 @@ var ServerKeyStore = class {
       publicKeyPem,
       fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs54.mkdirSync(this.dataDir, { recursive: true });
-    fs54.writeFileSync(this.filePath(), JSON.stringify(content, null, 2), { mode: 384 });
+    fs55.mkdirSync(this.dataDir, { recursive: true });
+    fs55.writeFileSync(this.filePath(), JSON.stringify(content, null, 2), { mode: 384 });
   }
   clear() {
     try {
-      fs54.unlinkSync(this.filePath());
+      fs55.unlinkSync(this.filePath());
     } catch {
     }
   }
@@ -54829,12 +54858,12 @@ init_protocol();
 init_protocol();
 
 // src/session/fork.ts
-var import_node_fs45 = __toESM(require("fs"), 1);
+var import_node_fs46 = __toESM(require("fs"), 1);
 var import_node_os16 = __toESM(require("os"), 1);
 var import_node_path47 = __toESM(require("path"), 1);
 init_claude_history();
 function readJsonlEntries(file) {
-  const raw = import_node_fs45.default.readFileSync(file, "utf8");
+  const raw = import_node_fs46.default.readFileSync(file, "utf8");
   const out = [];
   for (const line of raw.split("\n")) {
     const t = line.trim();
@@ -54850,7 +54879,7 @@ function forkSession(input) {
   const baseDir = input.baseDir ?? import_node_path47.default.join(import_node_os16.default.homedir(), ".claude");
   let projectDir = import_node_path47.default.join(baseDir, "projects", cwdToHashDir(input.cwd));
   let sourceFile = import_node_path47.default.join(projectDir, `${input.toolSessionId}.jsonl`);
-  if (!import_node_fs45.default.existsSync(sourceFile)) {
+  if (!import_node_fs46.default.existsSync(sourceFile)) {
     const found = findTranscriptByToolSessionId(
       import_node_path47.default.join(baseDir, "projects"),
       input.toolSessionId
@@ -54889,8 +54918,8 @@ function forkSession(input) {
     forkedLines.push(JSON.stringify(forked));
   }
   const forkedFilePath = import_node_path47.default.join(projectDir, `${forkedToolSessionId}.jsonl`);
-  import_node_fs45.default.mkdirSync(projectDir, { recursive: true });
-  import_node_fs45.default.writeFileSync(forkedFilePath, forkedLines.join("\n") + "\n", { mode: 384 });
+  import_node_fs46.default.mkdirSync(projectDir, { recursive: true });
+  import_node_fs46.default.writeFileSync(forkedFilePath, forkedLines.join("\n") + "\n", { mode: 384 });
   return { forkedToolSessionId, forkedFilePath };
 }
 
@@ -55524,14 +55553,14 @@ init_protocol();
 
 // src/workspace/git.ts
 var import_node_child_process12 = require("child_process");
-var import_node_fs46 = __toESM(require("fs"), 1);
+var import_node_fs47 = __toESM(require("fs"), 1);
 var import_node_path48 = __toESM(require("path"), 1);
 var import_node_util = require("util");
 var pexec = (0, import_node_util.promisify)(import_node_child_process12.execFile);
 function normalizePath(p2) {
   const resolved = import_node_path48.default.resolve(p2);
   try {
-    return import_node_fs46.default.realpathSync(resolved);
+    return import_node_fs47.default.realpathSync(resolved);
   } catch {
     return resolved;
   }
@@ -55942,7 +55971,7 @@ function buildContactHandlers(deps) {
 init_protocol();
 
 // src/sshd/key-issue.ts
-var import_node_fs47 = __toESM(require("fs"), 1);
+var import_node_fs48 = __toESM(require("fs"), 1);
 var import_node_path49 = __toESM(require("path"), 1);
 var import_node_child_process13 = require("child_process");
 function safeDeviceId(deviceId) {
@@ -55951,13 +55980,13 @@ function safeDeviceId(deviceId) {
 async function issueContactSshKey(deviceId, sshdDir, opts = {}) {
   const safeId = safeDeviceId(deviceId);
   const keysDir = import_node_path49.default.join(sshdDir, "keys");
-  import_node_fs47.default.mkdirSync(keysDir, { recursive: true, mode: 448 });
+  import_node_fs48.default.mkdirSync(keysDir, { recursive: true, mode: 448 });
   const privPath = import_node_path49.default.join(keysDir, `${safeId}.ed25519`);
   const pubPath = `${privPath}.pub`;
-  if (import_node_fs47.default.existsSync(privPath) && import_node_fs47.default.existsSync(pubPath)) {
+  if (import_node_fs48.default.existsSync(privPath) && import_node_fs48.default.existsSync(pubPath)) {
     return {
-      privateKeyPem: import_node_fs47.default.readFileSync(privPath, "utf8"),
-      publicKeyLine: import_node_fs47.default.readFileSync(pubPath, "utf8").trim()
+      privateKeyPem: import_node_fs48.default.readFileSync(privPath, "utf8"),
+      publicKeyLine: import_node_fs48.default.readFileSync(pubPath, "utf8").trim()
     };
   }
   const bin = opts.keygenBin ?? "/usr/bin/ssh-keygen";
@@ -55971,16 +56000,16 @@ async function issueContactSshKey(deviceId, sshdDir, opts = {}) {
     p2.on("error", reject);
   });
   try {
-    import_node_fs47.default.chmodSync(privPath, 384);
+    import_node_fs48.default.chmodSync(privPath, 384);
   } catch {
   }
   try {
-    import_node_fs47.default.chmodSync(pubPath, 420);
+    import_node_fs48.default.chmodSync(pubPath, 420);
   } catch {
   }
   return {
-    privateKeyPem: import_node_fs47.default.readFileSync(privPath, "utf8"),
-    publicKeyLine: import_node_fs47.default.readFileSync(pubPath, "utf8").trim()
+    privateKeyPem: import_node_fs48.default.readFileSync(privPath, "utf8"),
+    publicKeyLine: import_node_fs48.default.readFileSync(pubPath, "utf8").trim()
   };
 }
 
@@ -57261,7 +57290,7 @@ function buildExtensionHandlers(deps) {
 }
 
 // src/app-builder/project-store.ts
-var import_node_fs48 = require("fs");
+var import_node_fs49 = require("fs");
 var import_node_child_process14 = require("child_process");
 var import_node_path56 = require("path");
 init_protocol();
@@ -57289,7 +57318,7 @@ var ProjectStore = class {
   async list() {
     let entries;
     try {
-      entries = await import_node_fs48.promises.readdir(this.projectsRoot());
+      entries = await import_node_fs49.promises.readdir(this.projectsRoot());
     } catch (err) {
       if (err.code === "ENOENT") return [];
       throw err;
@@ -57297,7 +57326,7 @@ var ProjectStore = class {
     const out = [];
     for (const name of entries) {
       try {
-        const raw = await import_node_fs48.promises.readFile(this.metaPath(name), "utf8");
+        const raw = await import_node_fs49.promises.readFile(this.metaPath(name), "utf8");
         const json = JSON.parse(raw);
         let migrated = false;
         if (typeof json.devCommand !== "string" || json.devCommand.length === 0) {
@@ -57308,7 +57337,7 @@ var ProjectStore = class {
         if (parsed.success) {
           out.push(parsed.data);
           if (migrated) {
-            void import_node_fs48.promises.writeFile(this.metaPath(name), JSON.stringify(parsed.data, null, 2) + "\n", "utf8").catch(() => {
+            void import_node_fs49.promises.writeFile(this.metaPath(name), JSON.stringify(parsed.data, null, 2) + "\n", "utf8").catch(() => {
             });
           }
         }
@@ -57352,8 +57381,8 @@ var ProjectStore = class {
       throw new Error(`invalid name "${name}": ${validated.error.message}`);
     }
     const dir = this.projectDir(name);
-    await import_node_fs48.promises.mkdir(dir, { recursive: true });
-    await import_node_fs48.promises.writeFile(this.metaPath(name), JSON.stringify(meta, null, 2) + "\n", "utf8");
+    await import_node_fs49.promises.mkdir(dir, { recursive: true });
+    await import_node_fs49.promises.writeFile(this.metaPath(name), JSON.stringify(meta, null, 2) + "\n", "utf8");
     return meta;
   }
   /**
@@ -57396,7 +57425,7 @@ var ProjectStore = class {
   }
   async delete(name) {
     const dir = this.projectDir(name);
-    await import_node_fs48.promises.rm(dir, { recursive: true, force: true });
+    await import_node_fs49.promises.rm(dir, { recursive: true, force: true });
   }
   async updatePort(name, newPort) {
     if (newPort < PROJECT_PORT_MIN || newPort > PROJECT_PORT_MAX) {
@@ -57412,7 +57441,7 @@ var ProjectStore = class {
       throw new Error(`port ${newPort} already used / \u5DF2\u88AB project "${conflict.name}" \u5360\u7528`);
     }
     const updated = { ...target, port: newPort };
-    await import_node_fs48.promises.writeFile(this.metaPath(name), JSON.stringify(updated, null, 2) + "\n", "utf8");
+    await import_node_fs49.promises.writeFile(this.metaPath(name), JSON.stringify(updated, null, 2) + "\n", "utf8");
     return updated;
   }
   /**
@@ -57429,7 +57458,7 @@ var ProjectStore = class {
     if (!validated.success) {
       throw new Error(`invalid prodUrl "${url}": ${validated.error.message}`);
     }
-    await import_node_fs48.promises.writeFile(this.metaPath(name), JSON.stringify(validated.data, null, 2) + "\n", "utf8");
+    await import_node_fs49.promises.writeFile(this.metaPath(name), JSON.stringify(validated.data, null, 2) + "\n", "utf8");
     return validated.data;
   }
   /**
@@ -57450,7 +57479,7 @@ var ProjectStore = class {
     if (!validated.success) {
       throw new Error(`invalid publishJob: ${validated.error.message}`);
     }
-    await import_node_fs48.promises.writeFile(this.metaPath(name), JSON.stringify(validated.data, null, 2) + "\n", "utf8");
+    await import_node_fs49.promises.writeFile(this.metaPath(name), JSON.stringify(validated.data, null, 2) + "\n", "utf8");
     return validated.data;
   }
   /** 清掉 .clawd-project.json.publishJob 字段。其他字段保持原样。 */
@@ -57465,7 +57494,7 @@ var ProjectStore = class {
     if (!validated.success) {
       throw new Error(`failed to clear publishJob: ${validated.error.message}`);
     }
-    await import_node_fs48.promises.writeFile(this.metaPath(name), JSON.stringify(validated.data, null, 2) + "\n", "utf8");
+    await import_node_fs49.promises.writeFile(this.metaPath(name), JSON.stringify(validated.data, null, 2) + "\n", "utf8");
     return validated.data;
   }
 };
@@ -57586,7 +57615,7 @@ var PublishJobRegistry = class {
 
 // src/app-builder/publish-job-runner.ts
 var import_node_child_process16 = require("child_process");
-var import_node_fs49 = require("fs");
+var import_node_fs50 = require("fs");
 var import_node_path57 = require("path");
 
 // src/app-builder/publish-stage-parser.ts
@@ -57622,7 +57651,7 @@ async function startPublishJob(deps, args) {
   const logPath = (0, import_node_path57.join)(projDir, ".publish.log");
   let logStream = null;
   try {
-    logStream = (0, import_node_fs49.createWriteStream)(logPath, { flags: "w" });
+    logStream = (0, import_node_fs50.createWriteStream)(logPath, { flags: "w" });
   } catch {
     logStream = null;
   }
@@ -57880,7 +57909,7 @@ async function recoverInterruptedJobs(deps) {
 // src/handlers/app-builder.ts
 init_protocol();
 var import_node_path58 = require("path");
-var import_node_fs50 = require("fs");
+var import_node_fs51 = require("fs");
 var APP_BUILDER_PERSONAS = ["persona-app-builder", "persona-dataclaw-builder"];
 var DEV_SERVER_READY_TIMEOUT_MS = 3e4;
 async function recoverInterruptedPublishJobs(store, logger) {
@@ -57961,7 +57990,7 @@ function buildAppBuilderHandlers(deps) {
   async function listAllUsersProjects() {
     if (!deps.usersRoot || !deps.getStore) return [];
     const getStore = deps.getStore;
-    const userIds = await import_node_fs50.promises.readdir(deps.usersRoot).catch(() => []);
+    const userIds = await import_node_fs51.promises.readdir(deps.usersRoot).catch(() => []);
     const perUser = await Promise.all(
       userIds.map((uid) => getStore(uid).list().catch(() => []))
     );
@@ -59468,7 +59497,7 @@ async function startDaemon(config) {
     homeDir: import_node_os21.default.homedir()
   });
   const logDir = import_node_path64.default.join(config.dataDir, "log");
-  import_node_fs51.default.mkdirSync(logDir, { recursive: true });
+  import_node_fs52.default.mkdirSync(logDir, { recursive: true });
   const logger = createLogger({
     level: config.logLevel,
     file: import_node_path64.default.join(logDir, "clawd.log"),
@@ -59482,6 +59511,24 @@ async function startDaemon(config) {
   logger.info("screen-idle probe logger enabled", {
     file: import_node_path64.default.join(logDir, "screen-idle-probe.log")
   });
+  const CAP_TARGETS = [
+    import_node_path64.default.join(logDir, "clawd.log"),
+    import_node_path64.default.join(logDir, "screen-idle-probe.log")
+  ];
+  const LOG_CAP_MAX_BYTES = 10 * 1024 * 1024;
+  const LOG_CAP_KEEP_BYTES = 5 * 1024 * 1024;
+  const runLogCap = () => {
+    for (const f of CAP_TARGETS) {
+      try {
+        truncateLogFileToTail(f, LOG_CAP_MAX_BYTES, LOG_CAP_KEEP_BYTES);
+      } catch (e) {
+        logger.warn("log-cap failed", { file: f, err: String(e) });
+      }
+    }
+  };
+  runLogCap();
+  const logCapTimer = setInterval(runLogCap, 10 * 60 * 1e3);
+  logCapTimer.unref();
   const stateMgr = new StateFileManager({ dataDir: config.dataDir });
   const pre = stateMgr.preflight();
   if (pre.status === "active") {
@@ -59648,7 +59695,7 @@ async function startDaemon(config) {
     import_node_path64.default.join(here, "..", "dist", "dispatch", "mcp-server.cjs")
     // dev tsx src/index → ../dist/dispatch/mcp-server.cjs
   ];
-  const dispatchServerScriptPath = dispatchServerCandidates.find((p2) => import_node_fs51.default.existsSync(p2));
+  const dispatchServerScriptPath = dispatchServerCandidates.find((p2) => import_node_fs52.default.existsSync(p2));
   let dispatchMcpConfigPath2;
   if (dispatchServerScriptPath) {
     const dispatchLogPath = import_node_path64.default.join(logDir, "dispatch-mcp-server.log");
@@ -59671,7 +59718,7 @@ async function startDaemon(config) {
     import_node_path64.default.join(here, "ticket", "mcp-server.cjs"),
     import_node_path64.default.join(here, "..", "dist", "ticket", "mcp-server.cjs")
   ];
-  const ticketServerScriptPath = ticketServerCandidates.find((p2) => import_node_fs51.default.existsSync(p2));
+  const ticketServerScriptPath = ticketServerCandidates.find((p2) => import_node_fs52.default.existsSync(p2));
   let ticketMcpConfigPath2;
   if (ticketServerScriptPath) {
     const ticketLogPath = import_node_path64.default.join(logDir, "ticket-mcp-server.log");
@@ -59696,7 +59743,7 @@ async function startDaemon(config) {
     import_node_path64.default.join(here, "shift", "mcp-server.cjs"),
     import_node_path64.default.join(here, "..", "dist", "shift", "mcp-server.cjs")
   ];
-  const shiftServerScriptPath = shiftServerCandidates.find((p2) => import_node_fs51.default.existsSync(p2));
+  const shiftServerScriptPath = shiftServerCandidates.find((p2) => import_node_fs52.default.existsSync(p2));
   let shiftMcpConfigPath2;
   if (shiftServerScriptPath) {
     const shiftLogPath = import_node_path64.default.join(logDir, "shift-mcp-server.log");
@@ -59720,7 +59767,7 @@ async function startDaemon(config) {
     import_node_path64.default.join(here, "inbox", "mcp-server.cjs"),
     import_node_path64.default.join(here, "..", "dist", "inbox", "mcp-server.cjs")
   ];
-  const inboxServerScriptPath = inboxServerCandidates.find((p2) => import_node_fs51.default.existsSync(p2));
+  const inboxServerScriptPath = inboxServerCandidates.find((p2) => import_node_fs52.default.existsSync(p2));
   let inboxMcpConfigPath2;
   if (inboxServerScriptPath) {
     const inboxLogPath = import_node_path64.default.join(logDir, "inbox-mcp-server.log");
@@ -59810,7 +59857,7 @@ async function startDaemon(config) {
         const absPath = import_node_path64.default.isAbsolute(input.relPath) ? input.relPath : import_node_path64.default.join(input.cwd, input.relPath);
         let size = 0;
         try {
-          size = import_node_fs51.default.statSync(absPath).size;
+          size = import_node_fs52.default.statSync(absPath).size;
         } catch (err) {
           logger.warn("attachment.onFileEdit stat failed", {
             sessionId: input.sessionId,
@@ -59953,11 +60000,26 @@ async function startDaemon(config) {
     // deviceId 从 auth.json 稳定读；apiUrl 走同一份 clawosApi；apiKey 复用 CLAWD_TICKETS_API_KEY。
     // 失败即登录失败（fail-hard，login-flow.spec §upsert 失败）。
     getDeviceId: () => authFile.deviceId,
-    upsertBinding: (opts) => upsertDeviceBinding({
-      apiUrl: config.clawosApi ?? DEFAULT_CLAWOS_API,
-      apiKey: resolveClawdTicketsApiKey(),
-      ...opts
-    })
+    upsertBinding: async (opts) => {
+      try {
+        await upsertDeviceBinding({
+          apiUrl: config.clawosApi ?? DEFAULT_CLAWOS_API,
+          apiKey: resolveClawdTicketsApiKey(),
+          ...opts
+        });
+        logger.info("device-binding upsert succeeded", {
+          deviceId: opts.deviceId,
+          unionId: opts.unionId
+        });
+      } catch (err) {
+        logger.warn("device-binding upsert failed", {
+          deviceId: opts.deviceId,
+          unionId: opts.unionId,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        throw err;
+      }
+    }
   });
   const visitorStore = createVisitorStore({ dir: config.dataDir });
   const exchangeVisitorToken = buildVisitorLogin({
@@ -60323,6 +60385,12 @@ async function startDaemon(config) {
       handleLoginCallback: async (params) => {
         const result = await loginFlow.handleCallback(params);
         if (result.ok) {
+          logger.info("feishu-login succeeded", {
+            deviceId: authFile.deviceId,
+            ownerId: result.identity.ownerId,
+            unionId: result.identity.unionId,
+            displayName: result.identity.displayName
+          });
           feishuActive = true;
           ownerId = result.identity.ownerId;
           ownerProvider = result.identity.provider;
@@ -60334,6 +60402,11 @@ async function startDaemon(config) {
           void reportDevice();
           void fetchServerKey();
         } else {
+          logger.warn("feishu-login failed", {
+            reason: result.reason,
+            deviceId: authFile.deviceId,
+            hasToken: Boolean(params.token)
+          });
           wsServer?.broadcastToOwners({ type: "auth:login:failed", reason: result.reason });
         }
         return result;
@@ -60553,7 +60626,7 @@ ${bar}
 `);
       try {
         const connectPath = import_node_path64.default.join(config.dataDir, "connect.txt");
-        import_node_fs51.default.writeFileSync(connectPath, lines.join("\n") + "\n", { mode: 384 });
+        import_node_fs52.default.writeFileSync(connectPath, lines.join("\n") + "\n", { mode: 384 });
       } catch {
       }
     } catch (err) {
@@ -60657,7 +60730,7 @@ ${bar}
 function migrateDropPersonsDir(dataDir) {
   const dir = import_node_path64.default.join(dataDir, "persons");
   try {
-    import_node_fs51.default.rmSync(dir, { recursive: true, force: true });
+    import_node_fs52.default.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }