@adhdev/daemon-standalone 1.0.58-rc.50 → 1.0.58-rc.51

package/dist/index.js

@@ -36911,10 +36911,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "2193ba9cc0704aaa8d52108c785a8b09e40b05bc" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "2193ba9c" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.58-rc.50" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-30T13:08:27.686Z" : void 0);
+      const commit = readInjected(true ? "8ae4b622b6ab59e300631f175785f024b2cbecb2" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "8ae4b622" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.58-rc.51" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-30T15:26:29.414Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -42679,11 +42679,11 @@ child.on('exit', () => process.exit(0));
     }
     function windowsExtraBinDirs() {
       const dirs = [];
-      const fs67 = require("fs");
+      const fs68 = require("fs");
       const push = (dir) => {
         if (!dir) return;
         try {
-          if (fs67.existsSync(dir)) dirs.push(dir);
+          if (fs68.existsSync(dir)) dirs.push(dir);
         } catch {
         }
       };
@@ -42699,12 +42699,12 @@ child.on('exit', () => process.exit(0));
     }
     function unixExtraBinDirs() {
       const dirs = [];
-      const fs67 = require("fs");
+      const fs68 = require("fs");
       const home = os9.homedir();
       const push = (dir) => {
         if (!dir) return;
         try {
-          if (fs67.existsSync(dir)) dirs.push(dir);
+          if (fs68.existsSync(dir)) dirs.push(dir);
         } catch {
         }
       };
@@ -42743,9 +42743,9 @@ child.on('exit', () => process.exit(0));
         for (const ext of exes) {
           const fullPath = path13.join(p, trimmed + ext);
           try {
-            const fs67 = require("fs");
-            if (fs67.existsSync(fullPath)) {
-              const stat2 = fs67.statSync(fullPath);
+            const fs68 = require("fs");
+            if (fs68.existsSync(fullPath)) {
+              const stat2 = fs68.statSync(fullPath);
               if (stat2.isFile() && (isWin || stat2.mode & 73)) {
                 return fullPath;
               }
@@ -42759,12 +42759,12 @@ child.on('exit', () => process.exit(0));
     function isScriptBinary(binaryPath) {
       if (!path13.isAbsolute(binaryPath)) return false;
       try {
-        const fs67 = require("fs");
-        const resolved = fs67.realpathSync(binaryPath);
+        const fs68 = require("fs");
+        const resolved = fs68.realpathSync(binaryPath);
         const head = Buffer.alloc(8);
-        const fd = fs67.openSync(resolved, "r");
-        fs67.readSync(fd, head, 0, 8, 0);
-        fs67.closeSync(fd);
+        const fd = fs68.openSync(resolved, "r");
+        fs68.readSync(fd, head, 0, 8, 0);
+        fs68.closeSync(fd);
         let i = 0;
         if (head[0] === 239 && head[1] === 187 && head[2] === 191) i = 3;
         return head[i] === 35 && head[i + 1] === 33;
@@ -42775,12 +42775,12 @@ child.on('exit', () => process.exit(0));
     function looksLikeMachOOrElf(filePath) {
       if (!path13.isAbsolute(filePath)) return false;
       try {
-        const fs67 = require("fs");
-        const resolved = fs67.realpathSync(filePath);
+        const fs68 = require("fs");
+        const resolved = fs68.realpathSync(filePath);
         const buf = Buffer.alloc(8);
-        const fd = fs67.openSync(resolved, "r");
-        fs67.readSync(fd, buf, 0, 8, 0);
-        fs67.closeSync(fd);
+        const fd = fs68.openSync(resolved, "r");
+        fs68.readSync(fd, buf, 0, 8, 0);
+        fs68.closeSync(fd);
         let i = 0;
         if (buf[0] === 239 && buf[1] === 187 && buf[2] === 191) i = 3;
         const b = buf.subarray(i);
@@ -71315,8 +71315,8 @@ ${rendered}`, "utf-8");
         if (!(0, import_node_fs3.existsSync)(filePath)) return;
         if (owned) {
           try {
-            const fs67 = require("fs");
-            fs67.unlinkSync(filePath);
+            const fs68 = require("fs");
+            fs68.unlinkSync(filePath);
           } catch {
           }
           return;
@@ -71329,8 +71329,8 @@ ${rendered}`, "utf-8");
         const remaining = (existing.slice(0, openIdx) + existing.slice(closeIdx + CLOSE.length)).replace(/^\s*\n+/, "").replace(/\n+\s*$/, "");
         if (!remaining.trim()) {
           try {
-            const fs67 = require("fs");
-            fs67.unlinkSync(filePath);
+            const fs68 = require("fs");
+            fs68.unlinkSync(filePath);
           } catch {
           }
         } else {
@@ -89179,8 +89179,7 @@ ${cleanBody}`;
         oversized: 0,
         dropped: 0,
         collectorUnavailable: 0,
-        sourcePending: 0,
-        ptyDirtyCoalesced: 0
+        sourcePending: 0
       };
     }
     function redactSessionId(id) {
@@ -89197,17 +89196,22 @@ ${cleanBody}`;
     function markTranscriptSessionDirty(sessionId) {
       activeService?.markDirty(sessionId);
     }
-    function markTranscriptPtyOutputActivity(sessionId) {
-      activeService?.markPtyOutputActivity(sessionId);
+    function startTranscriptStatPolling(sessionId) {
+      activeService?.startPolling(sessionId);
     }
+    function stopTranscriptStatPolling(sessionId) {
+      activeService?.stopPolling(sessionId);
+    }
+    var fs19;
     var import_node_crypto4;
     var MAX_TRACKED_SESSIONS;
-    var TRANSCRIPT_PTY_DIRTY_THROTTLE_MS;
+    var TRANSCRIPT_STAT_POLL_INTERVAL_MS;
     var TranscriptProjectionService;
     var activeService;
     var init_transcript_publisher = __esm2({
       "src/seqscribe/transcript-publisher.ts"() {
         "use strict";
+        fs19 = __toESM2(require("fs"));
         import_node_crypto4 = require("crypto");
         init_logger();
         init_transcript_revision_codec();
@@ -89215,7 +89219,7 @@ ${cleanBody}`;
         init_transcript_observation();
         init_transcript_mode();
         MAX_TRACKED_SESSIONS = 512;
-        TRANSCRIPT_PTY_DIRTY_THROTTLE_MS = 350;
+        TRANSCRIPT_STAT_POLL_INTERVAL_MS = 3e3;
         TranscriptProjectionService = class {
           deps;
           epoch;
@@ -89227,9 +89231,10 @@ ${cleanBody}`;
           inFlight = /* @__PURE__ */ new Set();
           pendingObservation = /* @__PURE__ */ new Map();
           pendingPull = /* @__PURE__ */ new Set();
-          /** PTY-only leading+trailing throttle state; direct dirty triggers bypass it. */
-          ptyDirtyTimers = /* @__PURE__ */ new Map();
-          ptyDirtyTrailing = /* @__PURE__ */ new Set();
+          pollingSessions = /* @__PURE__ */ new Set();
+          knownPaths = /* @__PURE__ */ new Map();
+          lastSignatures = /* @__PURE__ */ new Map();
+          statPollTimer = null;
           constructor(deps) {
             this.deps = deps;
             this.epoch = deps.epoch ?? (0, import_node_crypto4.randomUUID)();
@@ -89246,6 +89251,10 @@ ${cleanBody}`;
               return;
             }
             if (!this.admitSession(sessionId)) return;
+            const sourcePath = observation.provenance?.transcriptProvenance?.sourcePath;
+            if (typeof sourcePath === "string" && sourcePath) {
+              this.knownPaths.set(sessionId, sourcePath);
+            }
             void this.runObserve(sessionId, observation);
           }
           /** PULL trigger — output-activity/status-change hooks that lack a fresh observation. */
@@ -89263,40 +89272,53 @@ ${cleanBody}`;
             if (!this.admitSession(sessionId)) return;
             void this.runPull(sessionId);
           }
-          /**
-           * PTY-output trigger. Pull the leading edge immediately, then collapse all
-           * repaint chunks in the window into one trailing pull. The trailing pull is
-           * mandatory even for a single byte because providers may append their JSONL
-           * record just after writing the corresponding terminal output.
-           */
-          markPtyOutputActivity(sessionId) {
+          startPolling(sessionId) {
             if (!sessionId) return;
             if (this.mode() === "off") return;
-            if (!this.deps.collectObservation) {
-              this.counters.collectorUnavailable++;
-              return;
-            }
-            if (this.ptyDirtyTimers.has(sessionId)) {
-              this.ptyDirtyTrailing.add(sessionId);
-              this.counters.ptyDirtyCoalesced++;
-              return;
+            this.pollingSessions.add(sessionId);
+            if (!this.statPollTimer) {
+              this.statPollTimer = setInterval(() => this.runStatPoll(), TRANSCRIPT_STAT_POLL_INTERVAL_MS);
+              this.statPollTimer.unref?.();
             }
-            this.markDirty(sessionId);
-            this.ptyDirtyTrailing.add(sessionId);
-            this.armPtyDirtyTimer(sessionId);
           }
-          armPtyDirtyTimer(sessionId) {
-            const timer = setTimeout(() => {
-              if (!this.ptyDirtyTrailing.delete(sessionId)) {
-                this.ptyDirtyTimers.delete(sessionId);
-                return;
+          stopPolling(sessionId) {
+            if (!sessionId) return;
+            this.pollingSessions.delete(sessionId);
+            this.knownPaths.delete(sessionId);
+            this.lastSignatures.delete(sessionId);
+            if (this.pollingSessions.size === 0 && this.statPollTimer) {
+              clearInterval(this.statPollTimer);
+              this.statPollTimer = null;
+            }
+          }
+          runStatPoll() {
+            for (const sessionId of this.pollingSessions) {
+              let path64 = this.knownPaths.get(sessionId);
+              if (!path64 && this.deps.resolveSourcePath) {
+                path64 = this.deps.resolveSourcePath(sessionId) ?? void 0;
+                if (path64) this.knownPaths.set(sessionId, path64);
+              }
+              if (!path64) continue;
+              try {
+                const st = fs19.statSync(path64);
+                const sig = `${st.dev}:${st.ino}:${st.size}:${st.mtimeMs}:${st.ctimeMs}`;
+                const lastSig = this.lastSignatures.get(sessionId);
+                if (sig !== lastSig) {
+                  this.lastSignatures.set(sessionId, sig);
+                  if (lastSig !== void 0) {
+                    this.markDirty(sessionId);
+                  }
+                }
+              } catch {
+                const lastSig = this.lastSignatures.get(sessionId);
+                if (lastSig !== "missing") {
+                  this.lastSignatures.set(sessionId, "missing");
+                  if (lastSig !== void 0) {
+                    this.markDirty(sessionId);
+                  }
+                }
               }
-              this.ptyDirtyTimers.delete(sessionId);
-              this.armPtyDirtyTimer(sessionId);
-              this.markDirty(sessionId);
-            }, TRANSCRIPT_PTY_DIRTY_THROTTLE_MS);
-            timer.unref?.();
-            this.ptyDirtyTimers.set(sessionId, timer);
+            }
           }
           /**
            * Explicit alias for the restart/activation seed-read entry point (design
@@ -89407,9 +89429,11 @@ ${cleanBody}`;
           }
           /** Stop deferred PTY work when the singleton is replaced or disarmed. */
           dispose() {
-            for (const timer of this.ptyDirtyTimers.values()) clearTimeout(timer);
-            this.ptyDirtyTimers.clear();
-            this.ptyDirtyTrailing.clear();
+            if (this.statPollTimer) clearInterval(this.statPollTimer);
+            this.statPollTimer = null;
+            this.pollingSessions.clear();
+            this.knownPaths.clear();
+            this.lastSignatures.clear();
           }
         };
         activeService = null;
@@ -92453,13 +92477,13 @@ ${cleanBody}`;
     }
     function ensureAdhdevDir() {
       const d = adhdevDir();
-      if (!fs23.existsSync(d)) fs23.mkdirSync(d, { recursive: true });
+      if (!fs24.existsSync(d)) fs24.mkdirSync(d, { recursive: true });
     }
     function loadExternalSources() {
       const p = sourcesFilePath();
-      if (!fs23.existsSync(p)) return { schema: 1, sources: [] };
+      if (!fs24.existsSync(p)) return { schema: 1, sources: [] };
       try {
-        const raw = JSON.parse(fs23.readFileSync(p, "utf-8"));
+        const raw = JSON.parse(fs24.readFileSync(p, "utf-8"));
         if (!raw || typeof raw !== "object") return { schema: 1, sources: [] };
         const sources = Array.isArray(raw.sources) ? raw.sources.filter(isValidSource) : [];
         return { schema: 1, sources };
@@ -92470,14 +92494,14 @@ ${cleanBody}`;
     function saveExternalSources(file2) {
       ensureAdhdevDir();
       const tmp = sourcesFilePath() + ".tmp";
-      fs23.writeFileSync(tmp, JSON.stringify(file2, null, 2) + "\n", "utf-8");
-      fs23.renameSync(tmp, sourcesFilePath());
+      fs24.writeFileSync(tmp, JSON.stringify(file2, null, 2) + "\n", "utf-8");
+      fs24.renameSync(tmp, sourcesFilePath());
     }
     function loadProvidersActive() {
       const p = activeFilePath();
-      if (!fs23.existsSync(p)) return { schema: 1, active: {} };
+      if (!fs24.existsSync(p)) return { schema: 1, active: {} };
       try {
-        const raw = JSON.parse(fs23.readFileSync(p, "utf-8"));
+        const raw = JSON.parse(fs24.readFileSync(p, "utf-8"));
         if (!raw || typeof raw !== "object") return { schema: 1, active: {} };
         const active = raw.active && typeof raw.active === "object" ? raw.active : {};
         return { schema: 1, active };
@@ -92488,8 +92512,8 @@ ${cleanBody}`;
     function saveProvidersActive(file2) {
       ensureAdhdevDir();
       const tmp = activeFilePath() + ".tmp";
-      fs23.writeFileSync(tmp, JSON.stringify(file2, null, 2) + "\n", "utf-8");
-      fs23.renameSync(tmp, activeFilePath());
+      fs24.writeFileSync(tmp, JSON.stringify(file2, null, 2) + "\n", "utf-8");
+      fs24.renameSync(tmp, activeFilePath());
     }
     function isValidSource(x) {
       if (!x || typeof x !== "object") return false;
@@ -92505,11 +92529,11 @@ ${cleanBody}`;
     }
     function inventoryExternalSources() {
       const root = externalRoot();
-      if (!fs23.existsSync(root)) return [];
+      if (!fs24.existsSync(root)) return [];
       const out = [];
       let entries;
       try {
-        entries = fs23.readdirSync(root, { withFileTypes: true });
+        entries = fs24.readdirSync(root, { withFileTypes: true });
       } catch {
         return [];
       }
@@ -92520,7 +92544,7 @@ ${cleanBody}`;
         const providers = {};
         let categoryEntries;
         try {
-          categoryEntries = fs23.readdirSync(sourceDir, { withFileTypes: true });
+          categoryEntries = fs24.readdirSync(sourceDir, { withFileTypes: true });
         } catch {
           continue;
         }
@@ -92530,7 +92554,7 @@ ${cleanBody}`;
           const categoryDir = path322.join(sourceDir, category);
           let typeEntries;
           try {
-            typeEntries = fs23.readdirSync(categoryDir, { withFileTypes: true });
+            typeEntries = fs24.readdirSync(categoryDir, { withFileTypes: true });
           } catch {
             continue;
           }
@@ -92538,8 +92562,8 @@ ${cleanBody}`;
           for (const typeEntry of typeEntries) {
             if (!typeEntry.isDirectory()) continue;
             const typeDir = path322.join(categoryDir, typeEntry.name);
-            const hasV1 = fs23.existsSync(path322.join(typeDir, "provider.v1.json"));
-            const hasV0 = fs23.existsSync(path322.join(typeDir, "provider.json"));
+            const hasV1 = fs24.existsSync(path322.join(typeDir, "provider.v1.json"));
+            const hasV0 = fs24.existsSync(path322.join(typeDir, "provider.json"));
             if (hasV1 || hasV0) types2.push(typeEntry.name);
           }
           if (types2.length > 0) providers[category] = types2;
@@ -92562,14 +92586,14 @@ ${cleanBody}`;
       }
       return { source: candidates[0], ambiguous: true, candidates };
     }
-    var fs23;
+    var fs24;
     var path322;
     var SOURCES_FILENAME;
     var ACTIVE_FILENAME;
     var init_external_sources = __esm2({
       "src/providers/external-sources.ts"() {
         "use strict";
-        fs23 = __toESM2(require("fs"));
+        fs24 = __toESM2(require("fs"));
         path322 = __toESM2(require("path"));
         init_config();
         SOURCES_FILENAME = "providers-sources.json";
@@ -92617,7 +92641,7 @@ ${cleanBody}`;
     function loadFsmSpec(sourcePath) {
       let raw;
       try {
-        raw = JSON.parse(fs24.readFileSync(sourcePath, "utf8"));
+        raw = JSON.parse(fs25.readFileSync(sourcePath, "utf8"));
       } catch (err) {
         return { ok: false, errors: [`Failed to read/parse spec: ${err.message}`], sourcePath };
       }
@@ -92777,11 +92801,11 @@ ${cleanBody}`;
       errs.push(`${path64} is not a recognized condition`);
       return errs;
     }
-    var fs24;
+    var fs25;
     var init_fsm_loader = __esm2({
       "src/providers/spec/fsm-loader.ts"() {
         "use strict";
-        fs24 = __toESM2(require("fs"));
+        fs25 = __toESM2(require("fs"));
         init_fsm_types();
       }
     });
@@ -93504,8 +93528,8 @@ ${cleanBody}`;
             let cwd = options.cwd;
             if (cwd) {
               try {
-                const fs67 = require("fs");
-                const stat2 = fs67.statSync(cwd);
+                const fs68 = require("fs");
+                const stat2 = fs68.statSync(cwd);
                 if (!stat2.isDirectory()) cwd = os19.homedir();
               } catch {
                 cwd = os19.homedir();
@@ -95626,7 +95650,7 @@ ${tail}`;
     }
     function probeGitAncestry(cwd, ancestor, descendant) {
       try {
-        if (!fs52.existsSync(cwd)) return "undeterminable";
+        if (!fs53.existsSync(cwd)) return "undeterminable";
       } catch {
         return "undeterminable";
       }
@@ -95697,7 +95721,7 @@ ${tail}`;
       };
       if (present()) return true;
       try {
-        if (!fs52.existsSync(submoduleRepoPath) || !fs52.existsSync(baseSubmoduleRepoPath)) return false;
+        if (!fs53.existsSync(submoduleRepoPath) || !fs53.existsSync(baseSubmoduleRepoPath)) return false;
       } catch {
         return false;
       }
@@ -95839,7 +95863,7 @@ ${tail}`;
           return { stdout: String(stdout || ""), stderr: String(stderr || ""), refspec };
         };
         const importCommitFromWorktreeSubmodule = async (submodulePath, worktreeSubmodulePath, commit) => {
-          if (!fs52.existsSync(worktreeSubmodulePath)) return false;
+          if (!fs53.existsSync(worktreeSubmodulePath)) return false;
           try {
             await runGit4(worktreeSubmodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
           } catch {
@@ -95881,7 +95905,7 @@ ${tail}`;
           };
           let submoduleDefaultBranch = "main";
           try {
-            if (!fs52.existsSync(submodulePath)) {
+            if (!fs53.existsSync(submodulePath)) {
               entry.error = `Submodule checkout missing at ${gitlink.path}`;
               entry.publishRequired = true;
               if (options.allowAutoPublishSubmoduleMainCommits === true) {
@@ -96046,7 +96070,7 @@ ${tail}`;
         };
       }
     }
-    var fs52;
+    var fs53;
     var import_node_child_process9;
     var import_path18;
     var GIT2;
@@ -96057,7 +96081,7 @@ ${tail}`;
     var init_mesh_refine_gitlink_utils = __esm2({
       "src/mesh/mesh-refine-gitlink-utils.ts"() {
         "use strict";
-        fs52 = __toESM2(require("fs"));
+        fs53 = __toESM2(require("fs"));
         import_node_child_process9 = require("child_process");
         import_path18 = require("path");
         init_logger();
@@ -96114,7 +96138,7 @@ ${tail}`;
       if (!baseCommit || !branchCommit) return "undeterminable";
       if (baseCommit === branchCommit) return "not_diverged";
       try {
-        if (!fs53.existsSync(submoduleRepoPath)) return "undeterminable";
+        if (!fs54.existsSync(submoduleRepoPath)) return "undeterminable";
         (0, import_node_child_process10.execFileSync)(GIT2, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
         (0, import_node_child_process10.execFileSync)(GIT2, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
       } catch {
@@ -96449,7 +96473,7 @@ ${tail}`;
       }
       return { ok: true, branchHead };
     }
-    var fs53;
+    var fs54;
     var import_path19;
     var import_node_child_process10;
     var SUBMODULE_PUBLISH_REQUIRED_RECOMMENDED_ACTION;
@@ -96457,7 +96481,7 @@ ${tail}`;
     var init_mesh_refine_submodule_converge = __esm2({
       "src/mesh/mesh-refine-submodule-converge.ts"() {
         "use strict";
-        fs53 = __toESM2(require("fs"));
+        fs54 = __toESM2(require("fs"));
         import_path19 = require("path");
         import_node_child_process10 = require("child_process");
         init_mesh_refine_gitlink_utils();
@@ -96473,12 +96497,12 @@ ${tail}`;
     function writeValidationFailureLog(workspace, index, candidate, streams, now = () => /* @__PURE__ */ new Date()) {
       try {
         const dir = (0, import_path20.join)(workspace, REFINE_VALIDATION_LOG_DIR);
-        fs54.mkdirSync(dir, { recursive: true });
+        fs55.mkdirSync(dir, { recursive: true });
         const stamp2 = now().toISOString().replace(/[:.]/g, "-");
         const file2 = (0, import_path20.join)(dir, `refine-${stamp2}-${index}.log`);
         const asText = (v) => typeof v === "string" ? v : v == null ? "" : String(v);
         const shown = candidate.displayCommand || [candidate.command, ...candidate.args || []].join(" ");
-        fs54.writeFileSync(
+        fs55.writeFileSync(
           file2,
           `# refine validation failure
 # command: ${shown}
@@ -97075,7 +97099,7 @@ ${mergeTreeErr?.stderr || ""}`;
           return newTree || void 0;
         } finally {
           try {
-            fs54.rmSync(tmpIndex, { force: true });
+            fs55.rmSync(tmpIndex, { force: true });
           } catch {
           }
         }
@@ -97150,7 +97174,7 @@ ${mergeTreeErr?.stderr || ""}`;
           return newTree || void 0;
         } finally {
           try {
-            fs54.rmSync(tmpIndex, { force: true });
+            fs55.rmSync(tmpIndex, { force: true });
           } catch {
           }
         }
@@ -97339,9 +97363,9 @@ ${mergeTreeErr?.stderr || ""}`;
         return ["npm", "pnpm", "yarn", "bun"].includes(command) && candidate.args.some((arg) => arg === "run" || arg === "test" || arg === "exec");
       };
       const dependenciesLikelyMissing = (cwd) => {
-        if (!fs54.existsSync((0, import_path20.join)(cwd, "package.json"))) return false;
-        if (fs54.existsSync((0, import_path20.join)(cwd, "node_modules"))) return false;
-        return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs54.existsSync((0, import_path20.join)(cwd, lock)));
+        if (!fs55.existsSync((0, import_path20.join)(cwd, "package.json"))) return false;
+        if (fs55.existsSync((0, import_path20.join)(cwd, "node_modules"))) return false;
+        return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs55.existsSync((0, import_path20.join)(cwd, lock)));
       };
       const needsNodeModules = (candidate, cwd) => isPackageManagerValidation(candidate) && dependenciesLikelyMissing(cwd);
       const isDaemonScopedCommand = (candidate) => {
@@ -97511,7 +97535,7 @@ ${mergeTreeErr?.stderr || ""}`;
       return summary;
     }
     var import_path20;
-    var fs54;
+    var fs55;
     var import_node_child_process11;
     var REFINE_VALIDATION_TIMEOUT_MS;
     var REFINE_VALIDATION_OUTPUT_LIMIT_BYTES;
@@ -97523,7 +97547,7 @@ ${mergeTreeErr?.stderr || ""}`;
         init_refine_config();
         init_worktree_bootstrap_config();
         import_path20 = require("path");
-        fs54 = __toESM2(require("fs"));
+        fs55 = __toESM2(require("fs"));
         import_node_child_process11 = require("child_process");
         init_resolve_executable();
         init_mesh_refine_worker_cap();
@@ -104791,7 +104815,7 @@ The pin is NOT cleared automatically: a pin often encodes required context conti
     var import_fs21 = require("fs");
     var import_os4 = require("os");
     var path28 = __toESM2(require("path"));
-    var fs19 = __toESM2(require("fs"));
+    var fs20 = __toESM2(require("fs"));
     var path27 = __toESM2(require("path"));
     function manifestCandidates(exeDir) {
       return [
@@ -104816,14 +104840,14 @@ The pin is NOT cleared automatically: a pin often encodes required context conti
       if (!exePath) return null;
       let exeDir;
       try {
-        exeDir = fs19.statSync(exePath).isDirectory() ? exePath : path27.dirname(exePath);
+        exeDir = fs20.statSync(exePath).isDirectory() ? exePath : path27.dirname(exePath);
       } catch {
         exeDir = path27.dirname(exePath);
       }
       for (const candidate of manifestCandidates(exeDir)) {
         try {
-          if (!fs19.existsSync(candidate)) continue;
-          const version2 = parseVersionFromManifest(fs19.readFileSync(candidate, "utf-8"));
+          if (!fs20.existsSync(candidate)) continue;
+          const version2 = parseVersionFromManifest(fs20.readFileSync(candidate, "utf-8"));
           if (version2) return version2;
         } catch {
         }
@@ -108263,13 +108287,13 @@ ${effect.notification.body || ""}`.trim();
       if (typeof instanceWorkspace === "string" && instanceWorkspace.trim()) return instanceWorkspace;
       return "";
     }
-    var fs21 = __toESM2(require("fs"));
+    var fs222 = __toESM2(require("fs"));
     var path30 = __toESM2(require("path"));
     var import_node_crypto5 = require("crypto");
     init_config();
     init_logger();
     init_debug_trace();
-    var fs20 = __toESM2(require("fs"));
+    var fs21 = __toESM2(require("fs"));
     var path29 = __toESM2(require("path"));
     init_contracts2();
     init_read_chat_contract();
@@ -109225,10 +109249,10 @@ ${effect.notification.body || ""}`.trim();
       if (!text) return "";
       const lexical = path29.resolve(text);
       try {
-        return fs20.realpathSync.native(lexical);
+        return fs21.realpathSync.native(lexical);
       } catch {
         try {
-          return fs20.realpathSync(lexical);
+          return fs21.realpathSync(lexical);
         } catch {
           return lexical;
         }
@@ -110455,11 +110479,11 @@ ${effect.notification.body || ""}`.trim();
     function storeChatDebugBundleOnDaemon(bundle, targetSessionId) {
       const bundleId = createChatDebugBundleId(targetSessionId);
       const dir = getChatDebugBundleDir();
-      fs21.mkdirSync(dir, { recursive: true });
+      fs222.mkdirSync(dir, { recursive: true });
       const savedPath = path30.join(dir, `${bundleId}.json`);
       const json3 = `${JSON.stringify(bundle, null, 2)}
 `;
-      fs21.writeFileSync(savedPath, json3, { encoding: "utf8", mode: 384 });
+      fs222.writeFileSync(savedPath, json3, { encoding: "utf8", mode: 384 });
       return { bundleId, savedPath, sizeBytes: Buffer.byteLength(json3, "utf8") };
     }
     function isDaemonFileDebugDelivery(args) {
@@ -111411,7 +111435,7 @@ ${effect.notification.body || ""}`.trim();
       }
       return { success: false, error: "resolveAction script not available for this provider" };
     }
-    var fs222 = __toESM2(require("fs"));
+    var fs23 = __toESM2(require("fs"));
     var path31 = __toESM2(require("path"));
     var os17 = __toESM2(require("os"));
     var KEY_TO_VK = {
@@ -111684,7 +111708,7 @@ ${effect.notification.body || ""}`.trim();
       return path31.resolve(inputPath);
     }
     function listDirectoryEntriesSafe(dirPath) {
-      const entries = fs222.readdirSync(dirPath, { withFileTypes: true });
+      const entries = fs23.readdirSync(dirPath, { withFileTypes: true });
       const files = [];
       for (const entry of entries) {
         const entryPath = path31.join(dirPath, entry.name);
@@ -111696,14 +111720,14 @@ ${effect.notification.body || ""}`.trim();
           if (entry.isFile()) {
             let size;
             try {
-              size = fs222.statSync(entryPath).size;
+              size = fs23.statSync(entryPath).size;
             } catch {
               size = void 0;
             }
             files.push({ name: entry.name, type: "file", size });
             continue;
           }
-          const stat2 = fs222.statSync(entryPath);
+          const stat2 = fs23.statSync(entryPath);
           files.push({
             name: entry.name,
             type: stat2.isDirectory() ? "directory" : "file",
@@ -111721,7 +111745,7 @@ ${effect.notification.body || ""}`.trim();
         const letter = String.fromCharCode(code);
         const root = `${letter}:\\`;
         try {
-          if (!fs222.existsSync(root)) continue;
+          if (!fs23.existsSync(root)) continue;
           if (excluded && root.toLowerCase() === excluded) continue;
           drives.push({ name: `${letter}:`, type: "directory", path: root });
         } catch {
@@ -111732,7 +111756,7 @@ ${effect.notification.body || ""}`.trim();
     async function handleFileRead(h, args) {
       try {
         const filePath = resolveSafePath(args?.path);
-        const content = fs222.readFileSync(filePath, "utf-8");
+        const content = fs23.readFileSync(filePath, "utf-8");
         return { success: true, content, path: filePath };
       } catch (e) {
         return { success: false, error: e.message };
@@ -111741,8 +111765,8 @@ ${effect.notification.body || ""}`.trim();
     async function handleFileWrite(h, args) {
       try {
         const filePath = resolveSafePath(args?.path);
-        fs222.mkdirSync(path31.dirname(filePath), { recursive: true });
-        fs222.writeFileSync(filePath, args?.content || "", "utf-8");
+        fs23.mkdirSync(path31.dirname(filePath), { recursive: true });
+        fs23.writeFileSync(filePath, args?.content || "", "utf-8");
         return { success: true, path: filePath };
       } catch (e) {
         return { success: false, error: e.message };
@@ -113020,7 +113044,7 @@ ${effect.notification.body || ""}`.trim();
         if (!["cli", "ide", "extension", "acp"].includes(category)) {
           return { success: false, error: `unknown category: ${category}` };
         }
-        const fs67 = require("fs");
+        const fs68 = require("fs");
         const path64 = require("path");
         try {
           const installRoot = this.getUpstreamInstallRoot();
@@ -113029,9 +113053,9 @@ ${effect.notification.body || ""}`.trim();
           if (!targetDir.startsWith(installRootResolved + path64.sep)) {
             return { success: false, error: "refusing to delete outside upstream root" };
           }
-          const hadUpstreamDir = fs67.existsSync(targetDir);
+          const hadUpstreamDir = fs68.existsSync(targetDir);
           if (hadUpstreamDir) {
-            fs67.rmSync(targetDir, { recursive: true, force: true });
+            fs68.rmSync(targetDir, { recursive: true, force: true });
           }
           let channelDeactivated = false;
           try {
@@ -113060,28 +113084,28 @@ ${effect.notification.body || ""}`.trim();
        * the UI and by the update checker.
        */
       handleListInstalledProviders(_args) {
-        const fs67 = require("fs");
+        const fs68 = require("fs");
         const path64 = require("path");
         const installRoot = this.getUpstreamInstallRoot();
-        if (!fs67.existsSync(installRoot)) return { success: true, providers: [] };
+        if (!fs68.existsSync(installRoot)) return { success: true, providers: [] };
         const CATEGORIES = ["cli", "ide", "extension", "acp"];
         const items = [];
         for (const category of CATEGORIES) {
           const categoryDir = path64.join(installRoot, category);
-          if (!fs67.existsSync(categoryDir)) continue;
+          if (!fs68.existsSync(categoryDir)) continue;
           let entries;
           try {
-            entries = fs67.readdirSync(categoryDir);
+            entries = fs68.readdirSync(categoryDir);
           } catch {
             continue;
           }
           for (const type2 of entries) {
             const v1Path = path64.join(categoryDir, type2, "provider.v1.json");
             const v0Path = path64.join(categoryDir, type2, "provider.json");
-            const manifestPath = fs67.existsSync(v1Path) ? v1Path : fs67.existsSync(v0Path) ? v0Path : null;
+            const manifestPath = fs68.existsSync(v1Path) ? v1Path : fs68.existsSync(v0Path) ? v0Path : null;
             if (!manifestPath) continue;
             try {
-              const m = JSON.parse(fs67.readFileSync(manifestPath, "utf-8"));
+              const m = JSON.parse(fs68.readFileSync(manifestPath, "utf-8"));
               const modelOptions = Array.isArray(m.modelOptions) ? m.modelOptions.filter((x) => typeof x === "string" && !!x.trim()) : [];
               const thinkingLevelOptions = Array.isArray(m.thinkingLevelOptions) ? m.thinkingLevelOptions.filter((x) => typeof x === "string" && !!x.trim()) : [];
               items.push({
@@ -113347,7 +113371,7 @@ ${effect.notification.body || ""}`.trim();
         if (!/^@[a-z0-9_-]+$/i.test(requestedName)) {
           return { success: false, error: "name must match @[a-z0-9_-]+" };
         }
-        const fs67 = require("fs");
+        const fs68 = require("fs");
         const path64 = require("path");
         const { spawnSync: spawnSync3 } = require("child_process");
         const file2 = ext.loadExternalSources();
@@ -113358,8 +113382,8 @@ ${effect.notification.body || ""}`.trim();
           return { success: false, error: `source url+ref already registered (use a different name to track another ref)` };
         }
         const sourceDir = path64.join(ext.externalRoot(), requestedName);
-        if (!fs67.existsSync(ext.externalRoot())) fs67.mkdirSync(ext.externalRoot(), { recursive: true });
-        if (fs67.existsSync(sourceDir)) {
+        if (!fs68.existsSync(ext.externalRoot())) fs68.mkdirSync(ext.externalRoot(), { recursive: true });
+        if (fs68.existsSync(sourceDir)) {
           return { success: false, error: `directory already exists: ${sourceDir} (rename or remove first)` };
         }
         const clone2 = spawnSync3("git", ["clone", "--depth=1", "--branch", ref, "--", url2, sourceDir], {
@@ -113369,7 +113393,7 @@ ${effect.notification.body || ""}`.trim();
         });
         if (clone2.status !== 0) {
           try {
-            fs67.rmSync(sourceDir, { recursive: true, force: true });
+            fs68.rmSync(sourceDir, { recursive: true, force: true });
           } catch {
           }
           return { success: false, error: `git clone failed: ${(clone2.stderr || clone2.stdout || "").trim() || "unknown error"}` };
@@ -113413,15 +113437,15 @@ ${effect.notification.body || ""}`.trim();
         const name = typeof args?.name === "string" ? args.name.trim() : "";
         if (!name) return { success: false, error: "name is required" };
         const ext = (init_external_sources(), __toCommonJS2(external_sources_exports));
-        const fs67 = require("fs");
+        const fs68 = require("fs");
         const path64 = require("path");
         const file2 = ext.loadExternalSources();
         const match = file2.sources.find((s2) => s2.name === name);
         if (!match) return { success: false, error: `source "${name}" not registered` };
         const sourceDir = path64.join(ext.externalRoot(), name);
-        if (fs67.existsSync(sourceDir)) {
+        if (fs68.existsSync(sourceDir)) {
           try {
-            fs67.rmSync(sourceDir, { recursive: true, force: true });
+            fs68.rmSync(sourceDir, { recursive: true, force: true });
           } catch (e) {
             return { success: false, error: `failed to delete ${sourceDir}: ${e?.message || e}` };
           }
@@ -114085,7 +114109,7 @@ ${effect.notification.body || ""}`.trim();
         };
       }
     };
-    var fs25 = __toESM2(require("fs"));
+    var fs26 = __toESM2(require("fs"));
     init_logger();
     init_debug_trace();
     var diagnosticsHandlers = {
@@ -114105,8 +114129,8 @@ ${effect.notification.body || ""}`.trim();
             return { success: true, logs: [], totalBuffered: 0 };
           }
           const logPath = getCurrentDaemonLogPath();
-          if (fs25.existsSync(logPath)) {
-            const content = fs25.readFileSync(logPath, "utf-8");
+          if (fs26.existsSync(logPath)) {
+            const content = fs26.readFileSync(logPath, "utf-8");
             const allLines = content.split("\n");
             const recent = allLines.slice(-count).join("\n");
             return { success: true, logs: recent, totalLines: allLines.length };
@@ -114128,11 +114152,11 @@ ${effect.notification.body || ""}`.trim();
     init_config();
     var import_child_process8 = require("child_process");
     var import_child_process9 = require("child_process");
-    var fs27 = __toESM2(require("fs"));
+    var fs28 = __toESM2(require("fs"));
     var os18 = __toESM2(require("os"));
     var path34 = __toESM2(require("path"));
     var import_child_process7 = require("child_process");
-    var fs26 = __toESM2(require("fs"));
+    var fs27 = __toESM2(require("fs"));
     var http2 = __toESM2(require("http"));
     var path33 = __toESM2(require("path"));
     init_track_identity();
@@ -114439,12 +114463,12 @@ ${effect.notification.body || ""}`.trim();
       const candidates = [currentNode];
       const portableRoot = path33.join(homeDir2, normalizeInstanceDir(instanceDir), "tools", "node22");
       try {
-        const dirs = fs26.readdirSync(portableRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path33.join(portableRoot, entry.name, "node.exe"));
+        const dirs = fs27.readdirSync(portableRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path33.join(portableRoot, entry.name, "node.exe"));
         candidates.push(...dirs);
       } catch {
       }
       for (const candidate of candidates) {
-        if (candidate && fs26.existsSync(candidate) && nodeMajor(candidate) === 22) return candidate;
+        if (candidate && fs27.existsSync(candidate) && nodeMajor(candidate) === 22) return candidate;
       }
       return null;
     }
@@ -114475,7 +114499,7 @@ ${effect.notification.body || ""}`.trim();
     }
     function verifyStagedConptyPrebuild(stagedPrefix, log) {
       const candidates = resolveConptyPrebuildCandidates(stagedPrefix);
-      const found = candidates.find((candidate) => fs26.existsSync(candidate));
+      const found = candidates.find((candidate) => fs27.existsSync(candidate));
       if (!found) {
         throw new Error(
           `Staged install is missing required native addon: node-pty's conpty.node prebuild (checked: ${candidates.join(", ")}). Aborting activation to prevent a daemon boot crash.`
@@ -114486,13 +114510,13 @@ ${effect.notification.body || ""}`.trim();
     function readPackageCliEntry(prefix, packageName, targetVersion) {
       const packageRoot = packageRootForPrefix(prefix, packageName);
       const packageJsonPath = path33.join(packageRoot, "package.json");
-      const pkg = JSON.parse(fs26.readFileSync(packageJsonPath, "utf8"));
+      const pkg = JSON.parse(fs27.readFileSync(packageJsonPath, "utf8"));
       if (pkg.name !== packageName) throw new Error(`staged package name mismatch: ${pkg.name || "missing"}`);
       if (pkg.version !== targetVersion) throw new Error(`staged package version mismatch: ${pkg.version || "missing"}`);
       const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.adhdev || (pkg.bin ? Object.values(pkg.bin)[0] : void 0);
       if (!bin) throw new Error("staged package has no CLI entry");
       const cliEntry = path33.resolve(packageRoot, bin);
-      if (!fs26.existsSync(cliEntry)) throw new Error(`staged CLI entry is missing: ${cliEntry}`);
+      if (!fs27.existsSync(cliEntry)) throw new Error(`staged CLI entry is missing: ${cliEntry}`);
       return cliEntry;
     }
     function quotePowerShellLiteral(value) {
@@ -114512,12 +114536,12 @@ exit $LASTEXITCODE\r
       const noExt = `#!/bin/sh
 exec "${portableNode}" "${cliEntry}" "$@"
 `;
-      fs26.writeFileSync(cmdPath, cmd, "ascii");
-      fs26.writeFileSync(ps1Path, ps1, "utf8");
-      fs26.writeFileSync(noExtPath, noExt, "ascii");
-      const cmdReadback = fs26.readFileSync(cmdPath, "utf8");
-      const ps1Readback = fs26.readFileSync(ps1Path, "utf8");
-      const noExtReadback = fs26.readFileSync(noExtPath, "utf8");
+      fs27.writeFileSync(cmdPath, cmd, "ascii");
+      fs27.writeFileSync(ps1Path, ps1, "utf8");
+      fs27.writeFileSync(noExtPath, noExt, "ascii");
+      const cmdReadback = fs27.readFileSync(cmdPath, "utf8");
+      const ps1Readback = fs27.readFileSync(ps1Path, "utf8");
+      const noExtReadback = fs27.readFileSync(noExtPath, "utf8");
       if (!cmdReadback.includes(portableNode) || !ps1Readback.includes(portableNode) || !noExtReadback.includes(portableNode) || /(^|\s)exec\s+node(\s|$)/m.test(noExtReadback)) {
         throw new Error("portable Node 22 pin validation failed");
       }
@@ -114534,7 +114558,7 @@ exec "${portableNode}" "${cliEntry}" "$@"
       }
     }
     function atomicWrite(destination, content, encoding) {
-      fs26.mkdirSync(path33.dirname(destination), { recursive: true });
+      fs27.mkdirSync(path33.dirname(destination), { recursive: true });
       if (process.platform === "win32") {
         const bytes = Buffer.from(content, encoding);
         const payload = Buffer.from(JSON.stringify({ destination, bytes: bytes.toString("base64") }), "utf8").toString("base64");
@@ -114567,12 +114591,12 @@ exec "${portableNode}" "${cliEntry}" "$@"
         return;
       }
       const temporary = `${destination}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-      fs26.writeFileSync(temporary, content, encoding);
+      fs27.writeFileSync(temporary, content, encoding);
       try {
-        fs26.renameSync(temporary, destination);
+        fs27.renameSync(temporary, destination);
       } catch (error48) {
         try {
-          fs26.unlinkSync(temporary);
+          fs27.unlinkSync(temporary);
         } catch {
         }
         throw error48;
@@ -114599,7 +114623,7 @@ exec "${portableNode}" "${cliEntry}" "$@"
       for (const name of STABLE_FILES) {
         const target = path33.join(stablePrefix, name);
         try {
-          snapshots.set(target, { exists: true, data: fs26.readFileSync(target) });
+          snapshots.set(target, { exists: true, data: fs27.readFileSync(target) });
         } catch {
           snapshots.set(target, { exists: false });
         }
@@ -114619,12 +114643,12 @@ exec "${portableNode}" "${cliEntry}" "$@"
         } else if (name === POINTER_NAME) {
           if (layout.activeVersionName) writePointerVerified(target, layout.activeVersionName);
           else try {
-            fs26.unlinkSync(target);
+            fs27.unlinkSync(target);
           } catch {
           }
         } else {
           try {
-            fs26.unlinkSync(target);
+            fs27.unlinkSync(target);
           } catch {
           }
         }
@@ -114638,7 +114662,7 @@ exec "${portableNode}" "${cliEntry}" "$@"
       if (REAL_PLATFORM !== "win32") return;
       let readback = "";
       try {
-        readback = fs26.readFileSync(pointerPath, "utf8").trim();
+        readback = fs27.readFileSync(pointerPath, "utf8").trim();
       } catch (error48) {
         throw new Error(`version pointer readback failed for ${pointerPath}: ${error48?.message || String(error48)}`);
       }
@@ -114667,9 +114691,9 @@ exec "${portableNode}" "${cliEntry}" "$@"
           log(`Refusing to clean up ${stagedPrefix}: not a version-* prefix under ${layout.installRoot}`);
           return;
         }
-        if (!fs26.existsSync(stagedPrefix)) return;
+        if (!fs27.existsSync(stagedPrefix)) return;
         removeInactivePrefix(stagedPrefix, log);
-        if (fs26.existsSync(stagedPrefix)) {
+        if (fs27.existsSync(stagedPrefix)) {
           log(`Failed staged prefix ${stagedPrefix} could not be fully removed; a future update will retry`);
         } else {
           log(`Cleaned up failed staged prefix ${stagedPrefix}`);
@@ -114685,7 +114709,7 @@ exec "${portableNode}" "${cliEntry}" "$@"
       const snapshots = snapshotStableFiles(layout.stablePrefix);
       let activated = false;
       let restarted = null;
-      fs26.mkdirSync(stagedPrefix, { recursive: false });
+      fs27.mkdirSync(stagedPrefix, { recursive: false });
       try {
         hooks.log(`Installing ${packageName}@${targetVersion} into inactive prefix ${stagedPrefix}`);
         await hooks.install(stagedPrefix, portableNode);
@@ -114854,7 +114878,7 @@ exec "${portableNode}" "${cliEntry}" "$@"
       const { layout, activePrefix, log } = options;
       let candidates = [];
       try {
-        candidates = fs26.readdirSync(layout.installRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("version-")).map((entry) => path33.join(layout.installRoot, entry.name)).filter((entry) => normalizeForCompare(entry) !== normalizeForCompare(activePrefix)).sort().slice(0, 8);
+        candidates = fs27.readdirSync(layout.installRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("version-")).map((entry) => path33.join(layout.installRoot, entry.name)).filter((entry) => normalizeForCompare(entry) !== normalizeForCompare(activePrefix)).sort().slice(0, 8);
       } catch {
         return;
       }
@@ -114882,7 +114906,7 @@ exec "${portableNode}" "${cliEntry}" "$@"
     }
     function removeInactivePrefix(target, log) {
       try {
-        fs26.rmSync(target, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 });
+        fs27.rmSync(target, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 });
       } catch (error48) {
         log?.(`Failed to remove inactive prefix ${target}: ${error48?.message || String(error48)}`);
       }
@@ -114896,14 +114920,14 @@ exec "${portableNode}" "${cliEntry}" "$@"
       return base || ".adhdev";
     }
     function getUpgradeLogPath(configDir = getConfigDir2()) {
-      fs27.mkdirSync(configDir, { recursive: true });
+      fs28.mkdirSync(configDir, { recursive: true });
       return path34.join(configDir, "daemon-upgrade.log");
     }
     function appendUpgradeLog(message, configDir = getConfigDir2()) {
       const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
 `;
       try {
-        fs27.appendFileSync(getUpgradeLogPath(configDir), line, "utf8");
+        fs28.appendFileSync(getUpgradeLogPath(configDir), line, "utf8");
       } catch {
       }
     }
@@ -114911,12 +114935,12 @@ exec "${portableNode}" "${cliEntry}" "$@"
       const binDir = path34.dirname(nodeExecutable);
       if (platform11 === "win32") {
         const npmCliPath = path34.join(binDir, "node_modules", "npm", "bin", "npm-cli.js");
-        if (fs27.existsSync(npmCliPath)) {
+        if (fs28.existsSync(npmCliPath)) {
           return { executable: nodeExecutable, argsPrefix: [npmCliPath], execOptions: getNpmExecOptions(platform11) };
         }
         for (const candidate of ["npm.exe", "npm"]) {
           const candidatePath = path34.join(binDir, candidate);
-          if (fs27.existsSync(candidatePath)) {
+          if (fs28.existsSync(candidatePath)) {
             return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform11) };
           }
         }
@@ -114924,7 +114948,7 @@ exec "${portableNode}" "${cliEntry}" "$@"
       }
       for (const candidate of ["npm"]) {
         const candidatePath = path34.join(binDir, candidate);
-        if (fs27.existsSync(candidatePath)) {
+        if (fs28.existsSync(candidatePath)) {
           return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform11) };
         }
       }
@@ -114934,12 +114958,12 @@ exec "${portableNode}" "${cliEntry}" "$@"
       if (!currentCliPath) return null;
       let resolvedPath = currentCliPath;
       try {
-        resolvedPath = fs27.realpathSync.native(currentCliPath);
+        resolvedPath = fs28.realpathSync.native(currentCliPath);
       } catch {
       }
       let currentDir2 = resolvedPath;
       try {
-        if (fs27.statSync(resolvedPath).isFile()) {
+        if (fs28.statSync(resolvedPath).isFile()) {
           currentDir2 = path34.dirname(resolvedPath);
         }
       } catch {
@@ -114948,8 +114972,8 @@ exec "${portableNode}" "${cliEntry}" "$@"
       while (true) {
         const packageJsonPath = path34.join(currentDir2, "package.json");
         try {
-          if (fs27.existsSync(packageJsonPath)) {
-            const parsed = JSON.parse(fs27.readFileSync(packageJsonPath, "utf8"));
+          if (fs28.existsSync(packageJsonPath)) {
+            const parsed = JSON.parse(fs28.readFileSync(packageJsonPath, "utf8"));
             if (parsed?.name === packageName) {
               const normalized = currentDir2.replace(/\\/g, "/");
               return normalized.includes("/node_modules/") ? currentDir2 : null;
@@ -114986,7 +115010,7 @@ exec "${portableNode}" "${cliEntry}" "$@"
       const installRoot = path34.join(homeDir2, instanceDir, "npm-installs");
       const pointerPath = path34.join(homeDir2, instanceDir, "npm-global", ".adhdev-current");
       try {
-        const activeVersion = fs27.readFileSync(pointerPath, "utf8").trim();
+        const activeVersion = fs28.readFileSync(pointerPath, "utf8").trim();
         if (activeVersion.startsWith("version-")) return path34.join(installRoot, activeVersion);
       } catch {
       }
@@ -115114,8 +115138,8 @@ exec "${portableNode}" "${cliEntry}" "$@"
       let killedPid = null;
       let keepPidFile = false;
       try {
-        if (fs27.existsSync(pidFile)) {
-          const pid = Number.parseInt(fs27.readFileSync(pidFile, "utf8").trim(), 10);
+        if (fs28.existsSync(pidFile)) {
+          const pid = Number.parseInt(fs28.readFileSync(pidFile, "utf8").trim(), 10);
           if (Number.isFinite(pid) && pid !== process.pid) {
             outcome.pid = pid;
             const identity = classifySessionHostPid(pid);
@@ -115153,7 +115177,7 @@ exec "${portableNode}" "${cliEntry}" "$@"
       keepPidFile = outcome.survived;
       if (!keepPidFile) {
         try {
-          fs27.unlinkSync(pidFile);
+          fs28.unlinkSync(pidFile);
         } catch {
         }
       } else {
@@ -115239,7 +115263,7 @@ exec "${portableNode}" "${cliEntry}" "$@"
     }
     function getUpgradeFailureNoticePath(configDir = getConfigDir2()) {
       try {
-        fs27.mkdirSync(configDir, { recursive: true });
+        fs28.mkdirSync(configDir, { recursive: true });
       } catch {
       }
       return path34.join(configDir, "daemon-upgrade-last-error.txt");
@@ -115256,7 +115280,7 @@ ${body}`, configDir);
       const marker = target ? `${UPGRADE_FAILURE_TARGET_MARKER} ${target}
 ` : "";
       try {
-        fs27.writeFileSync(
+        fs28.writeFileSync(
           getUpgradeFailureNoticePath(configDir),
           `[${(/* @__PURE__ */ new Date()).toISOString()}]
 ${body}
@@ -115269,7 +115293,7 @@ ${marker}`,
     function clearUpgradeFailureNotice(configDir = getConfigDir2()) {
       const noticePath = getUpgradeFailureNoticePath(configDir);
       try {
-        fs27.unlinkSync(noticePath);
+        fs28.unlinkSync(noticePath);
       } catch (error48) {
         if (error48?.code === "ENOENT") return;
         appendUpgradeLog(
@@ -115302,8 +115326,8 @@ ${marker}`,
     function readUpgradeFailureNotice(configDir = getConfigDir2()) {
       try {
         const noticePath = getUpgradeFailureNoticePath(configDir);
-        if (!fs27.existsSync(noticePath)) return null;
-        const notice = fs27.readFileSync(noticePath, "utf8").trim();
+        if (!fs28.existsSync(noticePath)) return null;
+        const notice = fs28.readFileSync(noticePath, "utf8").trim();
         if (!notice) return null;
         const recordedAt = parseUpgradeNoticeTimestamp(notice);
         const ageMs2 = recordedAt ? Date.now() - Date.parse(recordedAt) : null;
@@ -115329,13 +115353,13 @@ ${marker}`,
     function removeDaemonPidFile(configDir = getConfigDir2()) {
       const pidFile = path34.join(configDir, "daemon.pid");
       try {
-        fs27.unlinkSync(pidFile);
+        fs28.unlinkSync(pidFile);
       } catch {
       }
     }
     function safeRemoveStaleEntry(target, label) {
       try {
-        fs27.rmSync(target, { recursive: true, force: true });
+        fs28.rmSync(target, { recursive: true, force: true });
         appendUpgradeLog(`${label}: ${target}`);
       } catch (error48) {
         appendUpgradeLog(`Skipped locked stale entry (${error48?.code || "error"}): ${target} \u2014 ${error48?.message || String(error48)}`);
@@ -115356,19 +115380,19 @@ ${marker}`,
         if (pkgName.startsWith("@")) {
           const [scope, name] = pkgName.split("/");
           const scopeDir = path34.join(npmRoot, scope);
-          if (!fs27.existsSync(scopeDir)) return;
-          for (const entry of fs27.readdirSync(scopeDir)) {
+          if (!fs28.existsSync(scopeDir)) return;
+          for (const entry of fs28.readdirSync(scopeDir)) {
             if (!entry.startsWith(`.${name}-`)) continue;
             safeRemoveStaleEntry(path34.join(scopeDir, entry), "Removed stale scoped staging dir");
           }
         } else {
-          for (const entry of fs27.readdirSync(npmRoot)) {
+          for (const entry of fs28.readdirSync(npmRoot)) {
             if (!entry.startsWith(`.${pkgName}-`)) continue;
             safeRemoveStaleEntry(path34.join(npmRoot, entry), "Removed stale staging dir");
           }
         }
-        if (fs27.existsSync(binDir)) {
-          for (const entry of fs27.readdirSync(binDir)) {
+        if (fs28.existsSync(binDir)) {
+          for (const entry of fs28.readdirSync(binDir)) {
             if (!Array.from(binNames).some((name) => entry.startsWith(`.${name}-`))) continue;
             safeRemoveStaleEntry(path34.join(binDir, entry), "Removed stale bin staging entry");
           }
@@ -115389,12 +115413,12 @@ ${marker}`,
       const binDir = path34.join(prefix, "bin");
       const names = resolvePosixBinNames(packageName);
       const baseShim = path34.join(binDir, names[0]);
-      if (!fs27.existsSync(baseShim)) {
+      if (!fs28.existsSync(baseShim)) {
         throw new Error(`installed CLI shim is missing: ${baseShim}`);
       }
       for (const name of names) {
         const shimPath = path34.join(binDir, name);
-        if (!fs27.existsSync(shimPath)) continue;
+        if (!fs28.existsSync(shimPath)) continue;
         (0, import_child_process8.execFileSync)(shimPath, ["--version"], {
           encoding: "utf8",
           stdio: "pipe",
@@ -115405,15 +115429,15 @@ ${marker}`,
     }
     function backupPosixInstall(options) {
       try {
-        fs27.mkdirSync(options.configDir, { recursive: true });
-        const backupDir = fs27.mkdtempSync(path34.join(options.configDir, "upgrade-backup-"));
-        fs27.cpSync(options.packageRoot, path34.join(backupDir, "package"), { recursive: true });
+        fs28.mkdirSync(options.configDir, { recursive: true });
+        const backupDir = fs28.mkdtempSync(path34.join(options.configDir, "upgrade-backup-"));
+        fs28.cpSync(options.packageRoot, path34.join(backupDir, "package"), { recursive: true });
         const binShims = [];
         const binDir = path34.join(options.installPrefix, "bin");
         for (const name of resolvePosixBinNames(options.packageName)) {
           const shim = path34.join(binDir, name);
-          if (fs27.existsSync(shim)) {
-            fs27.cpSync(shim, path34.join(backupDir, `bin-${name}`), { recursive: true });
+          if (fs28.existsSync(shim)) {
+            fs28.cpSync(shim, path34.join(backupDir, `bin-${name}`), { recursive: true });
             binShims.push(shim);
           }
         }
@@ -115424,10 +115448,10 @@ ${marker}`,
       }
     }
     function restorePosixInstall(backup) {
-      fs27.rmSync(backup.packageRoot, { recursive: true, force: true });
-      fs27.cpSync(path34.join(backup.backupDir, "package"), backup.packageRoot, { recursive: true });
+      fs28.rmSync(backup.packageRoot, { recursive: true, force: true });
+      fs28.cpSync(path34.join(backup.backupDir, "package"), backup.packageRoot, { recursive: true });
       for (const shim of backup.binShims) {
-        fs27.cpSync(path34.join(backup.backupDir, `bin-${path34.basename(shim)}`), shim, { recursive: true });
+        fs28.cpSync(path34.join(backup.backupDir, `bin-${path34.basename(shim)}`), shim, { recursive: true });
       }
     }
     function runPosixInPlaceUpgrade(options) {
@@ -115436,7 +115460,7 @@ ${marker}`,
       const spec = `${payload.packageName}@${payload.targetVersion || "latest"}`;
       const { packageRoot, installPrefix } = installCommand.surface;
       try {
-        for (const entry of fs27.readdirSync(configDir)) {
+        for (const entry of fs28.readdirSync(configDir)) {
           if (entry.startsWith("upgrade-preflight-")) {
             safeRemoveStaleEntry(path34.join(configDir, entry), "Removed stale pre-flight staging prefix");
           }
@@ -115444,8 +115468,8 @@ ${marker}`,
       } catch {
       }
       const preflightPrefix = (() => {
-        fs27.mkdirSync(configDir, { recursive: true });
-        return fs27.mkdtempSync(path34.join(configDir, "upgrade-preflight-"));
+        fs28.mkdirSync(configDir, { recursive: true });
+        return fs28.mkdtempSync(path34.join(configDir, "upgrade-preflight-"));
       })();
       try {
         appendUpgradeLog(`Pre-flight: installing ${spec} into throwaway prefix ${preflightPrefix}`);
@@ -115610,7 +115634,7 @@ ${marker}`,
           throw new Error("installer-managed Windows update requires the portable Node.js 22 runtime");
         }
         const npmCliPath = path34.join(path34.dirname(portableNode), "node_modules", "npm", "bin", "npm-cli.js");
-        if (!fs27.existsSync(npmCliPath)) {
+        if (!fs28.existsSync(npmCliPath)) {
           throw new Error(`portable Node.js 22 npm CLI is missing: ${npmCliPath}`);
         }
         appendUpgradeLog(`Installer-managed pointer layout detected; active prefix will remain untouched: ${windowsInstallerLayout.activePrefix}`);
@@ -116066,14 +116090,14 @@ ${marker}`,
         }
       },
       list_coordinator_prompts: async (_ctx, _args) => {
-        const fs67 = await import("fs");
+        const fs68 = await import("fs");
         const path64 = await import("path");
         const { getConfigDir: getConfigDir22 } = await Promise.resolve().then(() => (init_config(), config_exports));
         const dir = path64.join(getConfigDir22(), "coordinator-prompts");
         const entries = {};
         try {
-          if (fs67.existsSync(dir)) {
-            for (const name of fs67.readdirSync(dir)) {
+          if (fs68.existsSync(dir)) {
+            for (const name of fs68.readdirSync(dir)) {
               const matchOverride = name.match(/^([a-zA-Z0-9_.-]+)\.md$/);
               const matchAppend = name.match(/^([a-zA-Z0-9_.-]+)\.append\.md$/);
               const m = matchAppend || matchOverride;
@@ -116083,7 +116107,7 @@ ${marker}`,
               const full = path64.join(dir, name);
               let content = "";
               try {
-                content = fs67.readFileSync(full, "utf8");
+                content = fs68.readFileSync(full, "utf8");
               } catch {
               }
               if (!entries[key2]) entries[key2] = { override: "", append: "" };
@@ -116097,7 +116121,7 @@ ${marker}`,
         return { success: true, dir, entries };
       },
       write_coordinator_prompt: async (_ctx, args) => {
-        const fs67 = await import("fs");
+        const fs68 = await import("fs");
         const path64 = await import("path");
         const { getConfigDir: getConfigDir22 } = await Promise.resolve().then(() => (init_config(), config_exports));
         const key2 = typeof args?.key === "string" ? args.key.trim() : "";
@@ -116110,11 +116134,11 @@ ${marker}`,
         const filename = kind === "append" ? `${key2}.append.md` : `${key2}.md`;
         const full = path64.join(dir, filename);
         try {
-          fs67.mkdirSync(dir, { recursive: true });
+          fs68.mkdirSync(dir, { recursive: true });
           if (content.trim()) {
-            fs67.writeFileSync(full, content, { encoding: "utf8", mode: 384 });
-          } else if (fs67.existsSync(full)) {
-            fs67.unlinkSync(full);
+            fs68.writeFileSync(full, content, { encoding: "utf8", mode: 384 });
+          } else if (fs68.existsSync(full)) {
+            fs68.unlinkSync(full);
           }
           return { success: true, path: full, kind, key: key2 };
         } catch (error48) {
@@ -116586,7 +116610,7 @@ ${marker}`,
       }
     };
     init_dist();
-    var fs28 = __toESM2(require("fs"));
+    var fs29 = __toESM2(require("fs"));
     init_logger();
     var DEFAULT_TAIL_BYTES = 64 * 1024;
     var MAX_TAIL_BYTES2 = 128 * 1024;
@@ -116610,9 +116634,9 @@ ${marker}`,
       return Math.min(Math.floor(tailBytes), MAX_TAIL_BYTES2);
     }
     function readByteBoundedTail(filePath, limitBytes) {
-      const fd = fs28.openSync(filePath, "r");
+      const fd = fs29.openSync(filePath, "r");
       try {
-        const stat2 = fs28.fstatSync(fd);
+        const stat2 = fs29.fstatSync(fd);
         const size = stat2.size;
         if (size === 0) return { text: "", truncated: false, bytesReturned: 0 };
         const want = Math.min(limitBytes, size);
@@ -116623,7 +116647,7 @@ ${marker}`,
         while (position < size) {
           const chunkSize = Math.min(READ_CHUNK_BYTES, size - position);
           const chunk = Buffer.alloc(chunkSize);
-          fs28.readSync(fd, chunk, 0, chunkSize, position);
+          fs29.readSync(fd, chunk, 0, chunkSize, position);
           buffers.push(chunk);
           position += chunkSize;
         }
@@ -116636,7 +116660,7 @@ ${marker}`,
         }
         return { text: buf.toString("utf-8"), truncated, bytesReturned: buf.length };
       } finally {
-        fs28.closeSync(fd);
+        fs29.closeSync(fd);
       }
     }
     function splitLogLines(text) {
@@ -116714,8 +116738,8 @@ ${marker}`,
       const limitBytes = clampTailBytes(args.tailBytes);
       const primaryPath = resolveLogPath(args.date);
       const backupPaths = sizeRotationPaths(primaryPath);
-      const primaryExists = fs28.existsSync(primaryPath);
-      const existingBackupPaths = backupPaths.filter((backupPath2) => fs28.existsSync(backupPath2));
+      const primaryExists = fs29.existsSync(primaryPath);
+      const existingBackupPaths = backupPaths.filter((backupPath2) => fs29.existsSync(backupPath2));
       if (!primaryExists && existingBackupPaths.length === 0) {
         return errorResult(
           `No daemon log file at ${primaryPath} (dir: ${getDaemonLogDir()})`,
@@ -116754,7 +116778,7 @@ ${marker}`,
       try {
         for (const p of [...existingBackupPaths].reverse().concat(primaryExists ? [primaryPath] : [])) {
           if (!p) continue;
-          const buf = fs28.readFileSync(p);
+          const buf = fs29.readFileSync(p);
           scannedBytes += buf.length;
           allLines = allLines.concat(splitLogLines(buf.toString("utf-8")));
         }
@@ -117161,9 +117185,9 @@ ${marker}`,
     var import_fs22 = require("fs");
     var import_child_process11 = require("child_process");
     var import_chalk = __toESM2((init_source(), __toCommonJS(source_exports)));
-    var fs422 = __toESM2(require("fs"));
+    var fs43 = __toESM2(require("fs"));
     var path46 = __toESM2(require("path"));
-    var fs31 = __toESM2(require("fs"));
+    var fs322 = __toESM2(require("fs"));
     var os23 = __toESM2(require("os"));
     var path38 = __toESM2(require("path"));
     init_terminal_screen();
@@ -117441,10 +117465,10 @@ ${marker}`,
     init_fsm_evaluator();
     init_fsm_types();
     init_fsm_loader();
-    var fs30 = __toESM2(require("fs"));
+    var fs31 = __toESM2(require("fs"));
     var os222 = __toESM2(require("os"));
     var path37 = __toESM2(require("path"));
-    var fs29 = __toESM2(require("fs"));
+    var fs30 = __toESM2(require("fs"));
     var os21 = __toESM2(require("os"));
     var path36 = __toESM2(require("path"));
     var crypto4 = __toESM2(require("crypto"));
@@ -117456,7 +117480,7 @@ ${marker}`,
     }
     function realWorkspacePath(workingDir) {
       try {
-        return fs29.realpathSync(workingDir);
+        return fs30.realpathSync(workingDir);
       } catch {
         return path36.resolve(workingDir);
       }
@@ -117479,12 +117503,12 @@ ${marker}`,
       const trustDir = path36.join(kimiHome2(env2), "workspace-trust");
       const trustFile = path36.join(trustDir, key2);
       try {
-        if (fs29.existsSync(trustFile)) {
+        if (fs30.existsSync(trustFile)) {
           LOG2.debug("kimi-workspace-trust", `${real} already trusted (${key2}) \u2014 no change`);
           return null;
         }
-        fs29.mkdirSync(trustDir, { recursive: true });
-        fs29.writeFileSync(trustFile, JSON.stringify({ root: real, trustedAt: Date.now() }), "utf8");
+        fs30.mkdirSync(trustDir, { recursive: true });
+        fs30.writeFileSync(trustFile, JSON.stringify({ root: real, trustedAt: Date.now() }), "utf8");
         LOG2.info("kimi-workspace-trust", `pre-trusted workspace ${real} (${key2})`);
         return real;
       } catch (err) {
@@ -117500,7 +117524,7 @@ ${marker}`,
     }
     function realWorkspacePath2(workingDir) {
       try {
-        return fs30.realpathSync(workingDir);
+        return fs31.realpathSync(workingDir);
       } catch {
         return path37.resolve(workingDir);
       }
@@ -117515,8 +117539,8 @@ ${marker}`,
       const real = realWorkspacePath2(workingDir);
       try {
         let parsed = {};
-        if (fs30.existsSync(settingsPath)) {
-          const text = fs30.readFileSync(settingsPath, "utf8");
+        if (fs31.existsSync(settingsPath)) {
+          const text = fs31.readFileSync(settingsPath, "utf8");
           if (text.trim().length > 0) {
             const json3 = JSON.parse(text);
             if (json3 && typeof json3 === "object" && !Array.isArray(json3)) {
@@ -117532,8 +117556,8 @@ ${marker}`,
         }
         list.push(real);
         parsed[key2] = list;
-        fs30.mkdirSync(path37.dirname(settingsPath), { recursive: true });
-        fs30.writeFileSync(settingsPath, `${JSON.stringify(parsed, null, 2)}
+        fs31.mkdirSync(path37.dirname(settingsPath), { recursive: true });
+        fs31.writeFileSync(settingsPath, `${JSON.stringify(parsed, null, 2)}
 `, "utf8");
         LOG2.info("pre-launch-trust", `pre-trusted workspace in ${trust.settings_path} (key="${key2}")`);
         return real;
@@ -118063,7 +118087,7 @@ ${marker}`,
         try {
           const dir = path38.dirname(this.opts.specPath);
           const base = path38.basename(this.opts.specPath);
-          this.specWatcher = fs31.watch(dir, { persistent: false }, (_event, filename) => {
+          this.specWatcher = fs322.watch(dir, { persistent: false }, (_event, filename) => {
             if (filename && filename !== base) return;
             const res = loadFsmSpec(this.opts.specPath);
             if (!res.ok) {
@@ -118879,7 +118903,7 @@ ${marker}`,
         const ext = guessExt(mime);
         const tmp = path38.join(os23.tmpdir(), `adhdev-attach-${Date.now()}${ext}`);
         try {
-          fs31.writeFileSync(tmp, Buffer.from(blob, "base64"));
+          fs322.writeFileSync(tmp, Buffer.from(blob, "base64"));
         } catch {
           return;
         }
@@ -119021,7 +119045,7 @@ ${marker}`,
       return { start, end };
     }
     init_evaluator();
-    var fs33 = __toESM2(require("fs"));
+    var fs34 = __toESM2(require("fs"));
     var os24 = __toESM2(require("os"));
     var path39 = __toESM2(require("path"));
     init_logger();
@@ -119087,7 +119111,7 @@ ${marker}`,
         }
       }
     }
-    var fs322 = __toESM2(require("fs"));
+    var fs33 = __toESM2(require("fs"));
     var PARSED_JSONL_CACHE_MAX_ENTRIES = 8;
     var PARSED_JSONL_CACHE_MAX_SOURCE_BYTES = 16 * 1024 * 1024;
     var parsedJsonlCache = /* @__PURE__ */ new Map();
@@ -119114,7 +119138,7 @@ ${marker}`,
     function readJsonlLines(p, forceRefresh = false) {
       let stat2;
       try {
-        stat2 = fs322.statSync(p);
+        stat2 = fs33.statSync(p);
       } catch {
         return [];
       }
@@ -119129,7 +119153,7 @@ ${marker}`,
       parsedJsonlCacheStats.misses++;
       let text;
       try {
-        text = fs322.readFileSync(p, "utf8");
+        text = fs33.readFileSync(p, "utf8");
         parsedJsonlCacheStats.fileReads++;
       } catch {
         return [];
@@ -119296,7 +119320,7 @@ ${marker}`,
         const wsRaw = typeof input.workspace === "string" ? input.workspace : "";
         let wsReal = wsRaw;
         try {
-          if (wsRaw) wsReal = fs33.realpathSync(wsRaw);
+          if (wsRaw) wsReal = fs34.realpathSync(wsRaw);
         } catch {
         }
         LOG2.debug("NativeHistory", `jsonl unresolved: tried=${JSON.stringify(resolved)} sessionId=${requestedSessionId || "(none)"} wsRaw=${JSON.stringify(wsRaw)} wsReal=${JSON.stringify(wsReal)} rawSlug=${JSON.stringify(claudeProjectDirName(wsRaw))} realSlug=${JSON.stringify(claudeProjectDirName(wsReal))} (concrete miss + raw-slug retry + projects scan all failed)`);
@@ -119439,7 +119463,7 @@ ${marker}`,
       } else {
         let stat2 = null;
         try {
-          stat2 = fs33.statSync(resolved);
+          stat2 = fs34.statSync(resolved);
         } catch {
         }
         if (stat2 && stat2.isFile()) {
@@ -119454,7 +119478,7 @@ ${marker}`,
           const resolvedRaw = expandPath2(src.path, input, { skipWorkspaceRealpath: true });
           if (resolvedRaw && resolvedRaw !== resolved) {
             try {
-              const rawStat = fs33.statSync(resolvedRaw);
+              const rawStat = fs34.statSync(resolvedRaw);
               if (rawStat.isFile()) sourcePath = resolvedRaw;
               else if (rawStat.isDirectory()) {
                 sourcePath = pickExactSessionFile(resolvedRaw, filePat, requestedSessionId) || (requestedSessionId ? null : newestRecentFile(resolvedRaw, filePat, windowMs, sessionFloor));
@@ -119471,7 +119495,7 @@ ${marker}`,
     }
     function claimKeyForPath(p) {
       try {
-        return fs33.realpathSync(p);
+        return fs34.realpathSync(p);
       } catch {
         return p;
       }
@@ -119533,7 +119557,7 @@ ${marker}`,
     function listSidecarWorkspaceCandidates(template, pattern, windowMs, sessionFloorMs, workspaceHint, sidecar) {
       let wsResolved = workspaceHint;
       try {
-        wsResolved = fs33.realpathSync(workspaceHint);
+        wsResolved = fs34.realpathSync(workspaceHint);
       } catch {
       }
       const dirs = expandDirGlob(template);
@@ -119547,7 +119571,7 @@ ${marker}`,
           if (!ws) continue;
           let wsReal = ws;
           try {
-            wsReal = fs33.realpathSync(ws);
+            wsReal = fs34.realpathSync(ws);
           } catch {
           }
           if (ws !== workspaceHint && wsReal !== wsResolved) continue;
@@ -119568,7 +119592,7 @@ ${marker}`,
     function readSidecarWorkspace(sourcePath, cfg) {
       try {
         const sidecar = path39.resolve(path39.dirname(sourcePath), cfg.rel_path);
-        const parsed = JSON.parse(fs33.readFileSync(sidecar, "utf8"));
+        const parsed = JSON.parse(fs34.readFileSync(sidecar, "utf8"));
         const v = jsonPathGet(parsed, cfg.workspace_path);
         return typeof v === "string" && v.trim() ? v.trim() : void 0;
       } catch {
@@ -119656,7 +119680,7 @@ ${marker}`,
       if (!wsRaw) return void 0;
       let wsReal = wsRaw;
       try {
-        wsReal = fs33.realpathSync(wsRaw);
+        wsReal = fs34.realpathSync(wsRaw);
       } catch {
       }
       const slugs = /* @__PURE__ */ new Set();
@@ -119686,7 +119710,7 @@ ${marker}`,
     }
     function executeSqlite(src, input) {
       const resolved = expandPath2(src.path, input);
-      if (!resolved || !fs33.existsSync(resolved)) return null;
+      if (!resolved || !fs34.existsSync(resolved)) return null;
       let Database;
       try {
         Database = loadBetterSqlite3();
@@ -119825,7 +119849,7 @@ ${marker}`,
       let workspaceResolved = workspaceRaw;
       if (workspaceRaw && !opts?.skipWorkspaceRealpath) {
         try {
-          workspaceResolved = fs33.realpathSync(workspaceRaw);
+          workspaceResolved = fs34.realpathSync(workspaceRaw);
         } catch {
         }
       }
@@ -119867,7 +119891,7 @@ ${marker}`,
       if (!base) return null;
       let baseStat = null;
       try {
-        baseStat = fs33.statSync(base);
+        baseStat = fs34.statSync(base);
       } catch {
         return null;
       }
@@ -119875,7 +119899,7 @@ ${marker}`,
       const needle = `${requestedSessionId.toLowerCase()}.jsonl`;
       const dirsToScan = [base];
       try {
-        for (const entry of fs33.readdirSync(base, { withFileTypes: true })) {
+        for (const entry of fs34.readdirSync(base, { withFileTypes: true })) {
           if (entry.isDirectory()) dirsToScan.push(path39.join(base, entry.name));
         }
       } catch {
@@ -119883,7 +119907,7 @@ ${marker}`,
       for (const dir of dirsToScan) {
         let entries;
         try {
-          entries = fs33.readdirSync(dir, { withFileTypes: true });
+          entries = fs34.readdirSync(dir, { withFileTypes: true });
         } catch {
           continue;
         }
@@ -119923,7 +119947,7 @@ ${marker}`,
           for (const d of dirs) {
             let entries;
             try {
-              entries = fs33.readdirSync(d, { withFileTypes: true });
+              entries = fs34.readdirSync(d, { withFileTypes: true });
             } catch {
               continue;
             }
@@ -119936,7 +119960,7 @@ ${marker}`,
             const candidate = path39.join(d, seg);
             let stat2 = null;
             try {
-              stat2 = fs33.statSync(candidate);
+              stat2 = fs34.statSync(candidate);
             } catch {
               continue;
             }
@@ -119980,7 +120004,7 @@ ${marker}`,
     function walkAllDirs(root, out) {
       let entries;
       try {
-        entries = fs33.readdirSync(root, { withFileTypes: true });
+        entries = fs34.readdirSync(root, { withFileTypes: true });
       } catch {
         return;
       }
@@ -119996,7 +120020,7 @@ ${marker}`,
       for (const d of dirs) {
         let entries;
         try {
-          entries = fs33.readdirSync(d, { withFileTypes: true });
+          entries = fs34.readdirSync(d, { withFileTypes: true });
         } catch {
           continue;
         }
@@ -120023,7 +120047,7 @@ ${marker}`,
         if (!resolved) continue;
         let entries;
         try {
-          entries = fs33.readdirSync(resolved, { withFileTypes: true });
+          entries = fs34.readdirSync(resolved, { withFileTypes: true });
         } catch {
           continue;
         }
@@ -120052,7 +120076,7 @@ ${marker}`,
       let workspaceResolved = workspaceRaw;
       if (workspaceRaw) {
         try {
-          workspaceResolved = fs33.realpathSync(workspaceRaw);
+          workspaceResolved = fs34.realpathSync(workspaceRaw);
         } catch {
         }
       }
@@ -120077,7 +120101,7 @@ ${marker}`,
     function newestRecentFile(dir, pattern, windowMs, sessionFloorMs = 0) {
       let entries;
       try {
-        entries = fs33.readdirSync(dir, { withFileTypes: true });
+        entries = fs34.readdirSync(dir, { withFileTypes: true });
       } catch {
         return null;
       }
@@ -120094,14 +120118,14 @@ ${marker}`,
     }
     function safeMtimeMs(p) {
       try {
-        return Math.floor(fs33.statSync(p).mtimeMs);
+        return Math.floor(fs34.statSync(p).mtimeMs);
       } catch {
         return 0;
       }
     }
     function safeBirthtimeMs(p) {
       try {
-        const st = fs33.statSync(p);
+        const st = fs34.statSync(p);
         const birth = Math.floor(st.birthtimeMs);
         return birth > 0 ? birth : Math.floor(st.mtimeMs);
       } catch {
@@ -120162,10 +120186,10 @@ ${marker}`,
     }
     function readCandidateSessionMeta(filePath) {
       try {
-        const fd = fs33.openSync(filePath, "r");
+        const fd = fs34.openSync(filePath, "r");
         try {
           const buf = Buffer.alloc(8192);
-          const bytes = fs33.readSync(fd, buf, 0, buf.length, 0);
+          const bytes = fs34.readSync(fd, buf, 0, buf.length, 0);
           if (bytes <= 0) return null;
           const text = buf.subarray(0, bytes).toString("utf8");
           const nl = text.indexOf("\n");
@@ -120183,7 +120207,7 @@ ${marker}`,
             sessionTimestampMs: Number.isFinite(tsMs) ? tsMs : void 0
           };
         } finally {
-          fs33.closeSync(fd);
+          fs34.closeSync(fd);
         }
       } catch {
         return null;
@@ -120193,7 +120217,7 @@ ${marker}`,
       if (!sessionFloorMs || !workspaceHint || candidatePaths.length === 0) return null;
       let workspaceResolved = workspaceHint;
       try {
-        workspaceResolved = fs33.realpathSync(workspaceHint);
+        workspaceResolved = fs34.realpathSync(workspaceHint);
       } catch {
       }
       let best = null;
@@ -120202,7 +120226,7 @@ ${marker}`,
         if (!meta3 || !meta3.cwd || meta3.sessionTimestampMs == null) continue;
         let candidateCwd = meta3.cwd;
         try {
-          candidateCwd = fs33.realpathSync(meta3.cwd);
+          candidateCwd = fs34.realpathSync(meta3.cwd);
         } catch {
         }
         if (candidateCwd !== workspaceResolved && meta3.cwd !== workspaceHint) continue;
@@ -120215,7 +120239,7 @@ ${marker}`,
     function listMatchingFiles(dir, pattern) {
       let entries;
       try {
-        entries = fs33.readdirSync(dir, { withFileTypes: true });
+        entries = fs34.readdirSync(dir, { withFileTypes: true });
       } catch {
         return [];
       }
@@ -120507,12 +120531,12 @@ ${marker}`,
       }
       return t.negate ? !result : result;
     }
-    var fs40 = __toESM2(require("fs"));
+    var fs41 = __toESM2(require("fs"));
     init_logger();
-    var fs39 = __toESM2(require("fs"));
+    var fs40 = __toESM2(require("fs"));
     var os28 = __toESM2(require("os"));
     var path45 = __toESM2(require("path"));
-    var fs34 = __toESM2(require("fs"));
+    var fs35 = __toESM2(require("fs"));
     var path40 = __toESM2(require("path"));
     function extractTimestampValue(value) {
       if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
@@ -120526,7 +120550,7 @@ ${marker}`,
     }
     function statMtimeMs(filePath) {
       try {
-        return fs34.statSync(filePath).mtimeMs;
+        return fs35.statSync(filePath).mtimeMs;
       } catch {
         return 0;
       }
@@ -120609,7 +120633,7 @@ ${marker}`,
     function parseTranscriptFile(filePath, sessionId, workspaceFallback) {
       let raw;
       try {
-        raw = fs34.readFileSync(filePath, "utf-8");
+        raw = fs35.readFileSync(filePath, "utf-8");
       } catch {
         return { messages: [], usageRecords: [] };
       }
@@ -120695,7 +120719,7 @@ ${marker}`,
       if (!sessionPath || !path40.isAbsolute(sessionPath)) return null;
       const basename22 = path40.basename(sessionPath, ".jsonl");
       if (!isSafeSessionId(basename22)) return null;
-      if (!fs34.existsSync(sessionPath)) return null;
+      if (!fs35.existsSync(sessionPath)) return null;
       const sourceMtimeMs = statMtimeMs(sessionPath);
       const { messages, usageRecords } = parseTranscriptFile(sessionPath, basename22);
       if (messages.length === 0) return null;
@@ -120718,7 +120742,7 @@ ${marker}`,
       }
       return session;
     }
-    var fs35 = __toESM2(require("fs"));
+    var fs36 = __toESM2(require("fs"));
     var path41 = __toESM2(require("path"));
     init_native_turn_signal();
     var CODEX_DEFAULT_COMPLETION_SIGNAL = {
@@ -120739,7 +120763,7 @@ ${marker}`,
     }
     function statMtimeMs2(filePath) {
       try {
-        return fs35.statSync(filePath).mtimeMs;
+        return fs36.statSync(filePath).mtimeMs;
       } catch {
         return 0;
       }
@@ -120855,7 +120879,7 @@ ${marker}`,
     }
     function readSessionMeta(filePath) {
       try {
-        const firstLine = fs35.readFileSync(filePath, "utf-8").split("\n").find(Boolean);
+        const firstLine = fs36.readFileSync(filePath, "utf-8").split("\n").find(Boolean);
         if (!firstLine) return null;
         const parsed = JSON.parse(firstLine);
         if (String(parsed.type ?? "") !== "session_meta") return null;
@@ -120867,7 +120891,7 @@ ${marker}`,
     function parseSessionFile(filePath, sessionId, workspaceFallback, completionSignal = CODEX_DEFAULT_COMPLETION_SIGNAL) {
       let raw;
       try {
-        raw = fs35.readFileSync(filePath, "utf-8");
+        raw = fs36.readFileSync(filePath, "utf-8");
       } catch {
         return { messages: [], usageRecords: [], turnTerminalMarkers: [] };
       }
@@ -121003,7 +121027,7 @@ ${marker}`,
     }
     function readSession2(sessionPath, nativeHistory) {
       if (!sessionPath || !path41.isAbsolute(sessionPath)) return null;
-      if (!fs35.existsSync(sessionPath)) return null;
+      if (!fs36.existsSync(sessionPath)) return null;
       const meta3 = readSessionMeta(sessionPath);
       const metaId = String(meta3?.id ?? "").trim();
       const basename22 = path41.basename(sessionPath, ".jsonl");
@@ -121042,7 +121066,7 @@ ${marker}`,
       if (turnTerminalMarkers.length > 0) session.turnTerminalMarkers = turnTerminalMarkers;
       return session;
     }
-    var fs36 = __toESM2(require("fs"));
+    var fs37 = __toESM2(require("fs"));
     var path422 = __toESM2(require("path"));
     var os25 = __toESM2(require("os"));
     init_load_better_sqlite3();
@@ -121059,7 +121083,7 @@ ${marker}`,
     }
     function statMtimeMs3(filePath) {
       try {
-        return fs36.statSync(filePath).mtimeMs;
+        return fs37.statSync(filePath).mtimeMs;
       } catch {
         return 0;
       }
@@ -121088,12 +121112,12 @@ ${marker}`,
     function findBrainTranscriptPath(sessionId) {
       if (!isUuidLike(sessionId)) return null;
       const logsRoot = resolvePathInside(brainRoot(), sessionId, ".system_generated", "logs");
-      if (!logsRoot || !fs36.existsSync(logsRoot)) return null;
-      const candidates = ["transcript_full.jsonl", "transcript.jsonl"].map((file2) => resolvePathInside(logsRoot, file2)).filter((p) => p !== null && fs36.existsSync(p));
+      if (!logsRoot || !fs37.existsSync(logsRoot)) return null;
+      const candidates = ["transcript_full.jsonl", "transcript.jsonl"].map((file2) => resolvePathInside(logsRoot, file2)).filter((p) => p !== null && fs37.existsSync(p));
       if (candidates.length === 0) {
         let entries = [];
         try {
-          entries = fs36.readdirSync(logsRoot, { withFileTypes: true });
+          entries = fs37.readdirSync(logsRoot, { withFileTypes: true });
         } catch {
           return null;
         }
@@ -121119,7 +121143,7 @@ ${marker}`,
     function parseBrainTranscript(filePath, sessionId, workspace) {
       let raw;
       try {
-        raw = fs36.readFileSync(filePath, "utf-8");
+        raw = fs37.readFileSync(filePath, "utf-8");
       } catch {
         return null;
       }
@@ -121179,7 +121203,7 @@ ${marker}`,
       const sourcePath = historyJsonlPath();
       let lines = [];
       try {
-        lines = fs36.readFileSync(sourcePath, "utf-8").split("\n").filter(Boolean);
+        lines = fs37.readFileSync(sourcePath, "utf-8").split("\n").filter(Boolean);
       } catch {
         return [];
       }
@@ -121227,7 +121251,7 @@ ${marker}`,
     function parsePbFile(filePath, sessionId) {
       let buf;
       try {
-        buf = fs36.readFileSync(filePath);
+        buf = fs37.readFileSync(filePath);
       } catch {
         return null;
       }
@@ -121692,7 +121716,7 @@ ${marker}`,
         }
       }
       const pbPath = resolvePathInside(conversationsRoot(), `${sessionId}.pb`);
-      if (pbPath && fs36.existsSync(pbPath)) {
+      if (pbPath && fs37.existsSync(pbPath)) {
         const pbMessages = parsePbFile(pbPath, sessionId);
         if (pbMessages && pbMessages.length > 0) {
           return {
@@ -121711,7 +121735,7 @@ ${marker}`,
     }
     function readSession3(sessionPath, sessionId, workspace) {
       if (!sessionPath || !path422.isAbsolute(sessionPath)) return null;
-      if (!fs36.existsSync(sessionPath)) return null;
+      if (!fs37.existsSync(sessionPath)) return null;
       const sourceMtimeMs = statMtimeMs3(sessionPath);
       const brainRootPath = brainRoot();
       if (sessionPath.startsWith(brainRootPath + path422.sep) && sessionPath.endsWith(".jsonl")) {
@@ -121770,7 +121794,7 @@ ${marker}`,
       }
       return null;
     }
-    var fs37 = __toESM2(require("fs"));
+    var fs38 = __toESM2(require("fs"));
     var path43 = __toESM2(require("path"));
     var os26 = __toESM2(require("os"));
     init_load_better_sqlite3();
@@ -121778,13 +121802,13 @@ ${marker}`,
     var HERMES_LEGACY_SESSIONS_DIR = path43.join(os26.homedir(), ".hermes", "sessions");
     function statMtimeMs4(p) {
       try {
-        return Math.floor(fs37.statSync(p).mtimeMs);
+        return Math.floor(fs38.statSync(p).mtimeMs);
       } catch {
         return 0;
       }
     }
     function openDb() {
-      if (!fs37.existsSync(HERMES_STATE_DB)) return null;
+      if (!fs38.existsSync(HERMES_STATE_DB)) return null;
       try {
         const Database = loadBetterSqlite3();
         return new Database(HERMES_STATE_DB, { readonly: true, fileMustExist: true });
@@ -121952,10 +121976,10 @@ ${marker}`,
           }
         }
       }
-      if (!path43.isAbsolute(sessionPath) || !fs37.existsSync(sessionPath)) return null;
+      if (!path43.isAbsolute(sessionPath) || !fs38.existsSync(sessionPath)) return null;
       let raw;
       try {
-        raw = JSON.parse(fs37.readFileSync(sessionPath, "utf8"));
+        raw = JSON.parse(fs38.readFileSync(sessionPath, "utf8"));
       } catch {
         return null;
       }
@@ -121995,7 +122019,7 @@ ${marker}`,
       if (s2 === "tool" || s2 === "tool_result" || s2 === "function") return "assistant";
       return "system";
     }
-    var fs38 = __toESM2(require("fs"));
+    var fs39 = __toESM2(require("fs"));
     var path44 = __toESM2(require("path"));
     var os27 = __toESM2(require("os"));
     function grokSessionsRoot() {
@@ -122007,7 +122031,7 @@ ${marker}`,
     }
     function statMtimeMs5(filePath) {
       try {
-        return fs38.statSync(filePath).mtimeMs;
+        return fs39.statSync(filePath).mtimeMs;
       } catch {
         return 0;
       }
@@ -122018,7 +122042,7 @@ ${marker}`,
     function workspaceCandidates(workspace) {
       const out = [workspace];
       try {
-        const real = fs38.realpathSync(workspace);
+        const real = fs39.realpathSync(workspace);
         if (real && real !== workspace) out.push(real);
       } catch {
       }
@@ -122027,22 +122051,22 @@ ${marker}`,
     function resolveGrokPath(workspace, sessionId) {
       if (!sessionId || !isUuidLike2(sessionId)) return null;
       const root = grokSessionsRoot();
-      if (!fs38.existsSync(root)) return null;
+      if (!fs39.existsSync(root)) return null;
       for (const candidate of workspaceCandidates(workspace || "")) {
         if (!candidate) continue;
         const file2 = path44.join(root, encodeWorkspaceDir(candidate), sessionId, "chat_history.jsonl");
-        if (fs38.existsSync(file2)) return file2;
+        if (fs39.existsSync(file2)) return file2;
       }
       let entries = [];
       try {
-        entries = fs38.readdirSync(root, { withFileTypes: true });
+        entries = fs39.readdirSync(root, { withFileTypes: true });
       } catch {
         return null;
       }
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const file2 = path44.join(root, entry.name, sessionId, "chat_history.jsonl");
-        if (fs38.existsSync(file2)) return file2;
+        if (fs39.existsSync(file2)) return file2;
       }
       return null;
     }
@@ -122096,7 +122120,7 @@ ${marker}`,
     }
     function readSessionCreatedAtMs(sessionDir) {
       try {
-        const summary = JSON.parse(fs38.readFileSync(path44.join(sessionDir, "summary.json"), "utf8"));
+        const summary = JSON.parse(fs39.readFileSync(path44.join(sessionDir, "summary.json"), "utf8"));
         const created = summary?.created_at;
         if (typeof created === "string") {
           const parsed = Date.parse(created);
@@ -122109,7 +122133,7 @@ ${marker}`,
     function readSession5(sourcePath, sessionId, workspace) {
       let text;
       try {
-        text = fs38.readFileSync(sourcePath, "utf8");
+        text = fs39.readFileSync(sourcePath, "utf8");
       } catch {
         return null;
       }
@@ -122159,26 +122183,26 @@ ${marker}`,
     }
     function listSessions(workspace, limit = 50) {
       const root = grokSessionsRoot();
-      if (!fs38.existsSync(root)) return [];
+      if (!fs39.existsSync(root)) return [];
       const dirs = [];
       for (const candidate of workspaceCandidates(workspace || "")) {
         if (!candidate) continue;
         const dir = path44.join(root, encodeWorkspaceDir(candidate));
-        if (fs38.existsSync(dir)) dirs.push(dir);
+        if (fs39.existsSync(dir)) dirs.push(dir);
       }
       if (dirs.length === 0) return [];
       const out = [];
       for (const dir of dirs) {
         let entries = [];
         try {
-          entries = fs38.readdirSync(dir, { withFileTypes: true });
+          entries = fs39.readdirSync(dir, { withFileTypes: true });
         } catch {
           continue;
         }
         for (const entry of entries) {
           if (!entry.isDirectory() || !isUuidLike2(entry.name)) continue;
           const sourcePath = path44.join(dir, entry.name, "chat_history.jsonl");
-          if (!fs38.existsSync(sourcePath)) continue;
+          if (!fs39.existsSync(sourcePath)) continue;
           const session = readSession5(sourcePath, entry.name, workspace);
           if (!session || session.messages.length === 0) continue;
           const first = session.messages[0];
@@ -122208,10 +122232,10 @@ ${marker}`,
     }
     function listSessionsAllWorkspaces(limit = 50) {
       const root = grokSessionsRoot();
-      if (!fs38.existsSync(root)) return [];
+      if (!fs39.existsSync(root)) return [];
       let dirs = [];
       try {
-        dirs = fs38.readdirSync(root, { withFileTypes: true });
+        dirs = fs39.readdirSync(root, { withFileTypes: true });
       } catch {
         return [];
       }
@@ -122259,7 +122283,7 @@ ${marker}`,
         const ownerConfirmed = reader === "antigravity-cli" ? resolved?.ownerConfirmed === true : void 0;
         if (input.forceRefresh === true || input.args?.forceRefresh === true) {
           try {
-            fs39.statSync(sourcePath);
+            fs40.statSync(sourcePath);
           } catch {
           }
         }
@@ -122324,10 +122348,10 @@ ${marker}`,
     }
     function resolveClaudePath(workspace, sessionId) {
       const dir = path45.join(os28.homedir(), ".claude", "projects", cwdAsDashes(workspace));
-      if (!fs39.existsSync(dir)) return null;
+      if (!fs40.existsSync(dir)) return null;
       if (sessionId) {
         const candidate = path45.join(dir, `${sessionId}.jsonl`);
-        if (fs39.existsSync(candidate)) return candidate;
+        if (fs40.existsSync(candidate)) return candidate;
       }
       return null;
     }
@@ -122345,7 +122369,7 @@ ${marker}`,
       if (key2) {
         const pinned = codexRuntimeBindings.get(key2);
         if (pinned) {
-          if (fs39.existsSync(pinned)) return pinned;
+          if (fs40.existsSync(pinned)) return pinned;
           codexRuntimeBindings.delete(key2);
         }
       }
@@ -122354,7 +122378,7 @@ ${marker}`,
       return resolved;
     }
     function findCodexPathBySessionId(root, sessionId) {
-      if (!fs39.existsSync(root)) return null;
+      if (!fs40.existsSync(root)) return null;
       const needle = sessionId.toLowerCase();
       const matches = [];
       const stack = [root];
@@ -122362,7 +122386,7 @@ ${marker}`,
         const current = stack.pop();
         let entries = [];
         try {
-          entries = fs39.readdirSync(current, { withFileTypes: true });
+          entries = fs40.readdirSync(current, { withFileTypes: true });
         } catch {
           continue;
         }
@@ -122382,7 +122406,7 @@ ${marker}`,
       return matches[0]?.p ?? null;
     }
     function findCodexPathByRuntime(root, workspace, sessionStartedAtMs) {
-      if (!fs39.existsSync(root) || !workspace) return null;
+      if (!fs40.existsSync(root) || !workspace) return null;
       const workspaceResolved = resolveRealPath(workspace);
       const cutoff = Date.now() - RECENT_WINDOW_MS;
       const matches = [];
@@ -122391,7 +122415,7 @@ ${marker}`,
         const current = stack.pop();
         let entries = [];
         try {
-          entries = fs39.readdirSync(current, { withFileTypes: true });
+          entries = fs40.readdirSync(current, { withFileTypes: true });
         } catch {
           continue;
         }
@@ -122416,10 +122440,10 @@ ${marker}`,
     }
     function readCodexSessionMeta(filePath) {
       try {
-        const fd = fs39.openSync(filePath, "r");
+        const fd = fs40.openSync(filePath, "r");
         try {
           const buffer = Buffer.alloc(8192);
-          const bytes = fs39.readSync(fd, buffer, 0, buffer.length, 0);
+          const bytes = fs40.readSync(fd, buffer, 0, buffer.length, 0);
           if (bytes <= 0) return null;
           const text = buffer.subarray(0, bytes).toString("utf8");
           const firstLine = text.slice(0, text.indexOf("\n") >= 0 ? text.indexOf("\n") : text.length).trim();
@@ -122434,7 +122458,7 @@ ${marker}`,
             timestampMs: Number.isFinite(timestampMs) ? timestampMs : void 0
           };
         } finally {
-          fs39.closeSync(fd);
+          fs40.closeSync(fd);
         }
       } catch {
         return null;
@@ -122442,7 +122466,7 @@ ${marker}`,
     }
     function resolveRealPath(value) {
       try {
-        return fs39.realpathSync(value);
+        return fs40.realpathSync(value);
       } catch {
         return value;
       }
@@ -122464,19 +122488,19 @@ ${marker}`,
       const owner = antigravityOwnerToken(workspace, sessionStartedAtMs, instanceId);
       if (sessionId && isUuidLikeSessionId2(sessionId)) {
         const dbPath = path45.join(agyRoot, "conversations", `${sessionId}.db`);
-        if (fs39.existsSync(dbPath)) {
+        if (fs40.existsSync(dbPath)) {
           if (owner) claimAntigravityConversation(sessionId, owner);
           return { path: dbPath, ownerConfirmed: true };
         }
       }
       const brainRoot2 = path45.join(agyRoot, "brain");
-      if (fs39.existsSync(brainRoot2)) {
+      if (fs40.existsSync(brainRoot2)) {
         const cutoff = spawnAwareCutoff(sessionStartedAtMs);
         const nonEmptyBrain = (uuid3, p) => {
           const t = path45.join(p, ".system_generated", "logs", "transcript.jsonl");
-          return fs39.existsSync(t) && safeSize(t) > 0 ? t : null;
+          return fs40.existsSync(t) && safeSize(t) > 0 ? t : null;
         };
-        const all = fs39.readdirSync(brainRoot2, { withFileTypes: true }).filter((e) => e.isDirectory() && isUuidLikeSessionId2(e.name)).filter((e) => !isAntigravityConversationClaimedByOther(e.name, owner)).map((e) => {
+        const all = fs40.readdirSync(brainRoot2, { withFileTypes: true }).filter((e) => e.isDirectory() && isUuidLikeSessionId2(e.name)).filter((e) => !isAntigravityConversationClaimedByOther(e.name, owner)).map((e) => {
           const p = path45.join(brainRoot2, e.name);
           return { uuid: e.name, p, mtime: safeMtime(p), birth: safeBirthtime(p) };
         }).filter((e) => e.mtime >= cutoff);
@@ -122507,7 +122531,7 @@ ${marker}`,
     function pickUnboundConversationDb(convRoot, sessionFloorMs, owner) {
       let entries = [];
       try {
-        entries = fs39.readdirSync(convRoot, { withFileTypes: true });
+        entries = fs40.readdirSync(convRoot, { withFileTypes: true });
       } catch {
         return null;
       }
@@ -122545,9 +122569,9 @@ ${marker}`,
       void workspace;
       void sessionId;
       const dbPath = path45.join(os28.homedir(), ".hermes", "state.db");
-      if (fs39.existsSync(dbPath)) return dbPath;
+      if (fs40.existsSync(dbPath)) return dbPath;
       const dir = path45.join(os28.homedir(), ".hermes", "sessions");
-      if (!fs39.existsSync(dir)) return null;
+      if (!fs40.existsSync(dir)) return null;
       return newestRecentFile2(dir, /^session_.*\.json$/);
     }
     function readByReader(reader, sourcePath, sessionId, workspace, requestedProviderSid) {
@@ -122586,7 +122610,7 @@ ${marker}`,
     function newestRecentFile2(dir, pattern) {
       try {
         const cutoff = Date.now() - RECENT_WINDOW_MS;
-        const entries = fs39.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && pattern.test(e.name)).map((e) => ({ p: path45.join(dir, e.name), mtime: safeMtime(path45.join(dir, e.name)) })).filter((e) => e.mtime >= cutoff).sort((a, b) => b.mtime - a.mtime);
+        const entries = fs40.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && pattern.test(e.name)).map((e) => ({ p: path45.join(dir, e.name), mtime: safeMtime(path45.join(dir, e.name)) })).filter((e) => e.mtime >= cutoff).sort((a, b) => b.mtime - a.mtime);
         return entries[0]?.p ?? null;
       } catch {
         return null;
@@ -122594,14 +122618,14 @@ ${marker}`,
     }
     function safeMtime(p) {
       try {
-        return Math.floor(fs39.statSync(p).mtimeMs);
+        return Math.floor(fs40.statSync(p).mtimeMs);
       } catch {
         return 0;
       }
     }
     function safeBirthtime(p) {
       try {
-        const st = fs39.statSync(p);
+        const st = fs40.statSync(p);
         const birth = Math.floor(st.birthtimeMs);
         return birth > 0 ? birth : Math.floor(st.mtimeMs);
       } catch {
@@ -122610,7 +122634,7 @@ ${marker}`,
     }
     function safeSize(p) {
       try {
-        return fs39.statSync(p).size;
+        return fs40.statSync(p).size;
       } catch {
         return 0;
       }
@@ -122906,19 +122930,19 @@ ${marker}`,
       return attrs;
     }
     function readTailJsonlLines(filePath, maxBytes) {
-      const stat2 = fs40.statSync(filePath);
+      const stat2 = fs41.statSync(filePath);
       const size = stat2.size;
       const start = size > maxBytes ? size - maxBytes : 0;
       const length = size - start;
       if (length <= 0) return [];
-      const fd = fs40.openSync(filePath, "r");
+      const fd = fs41.openSync(filePath, "r");
       let text;
       try {
         const buf = Buffer.alloc(length);
-        const bytes = fs40.readSync(fd, buf, 0, length, start);
+        const bytes = fs41.readSync(fd, buf, 0, length, start);
         text = buf.subarray(0, bytes).toString("utf8");
       } finally {
-        fs40.closeSync(fd);
+        fs41.closeSync(fd);
       }
       const rawLines = text.split("\n");
       if (start > 0 && rawLines.length > 0) rawLines.shift();
@@ -123027,7 +123051,7 @@ ${text}` : text;
       }
       return messages.filter((m) => typeof m.content === "string" && m.content.trim().length > 0);
     }
-    var fs41 = __toESM2(require("fs"));
+    var fs422 = __toESM2(require("fs"));
     var import_node_crypto6 = require("crypto");
     init_provider_cli_shared();
     init_logger();
@@ -123385,7 +123409,7 @@ ${text}` : text;
        *  (claude-cli specs/4.0.json), which previously stubbed the method to false. */
       lastApprovalResolvedAt = 0;
       constructor(specPath, workingDir, cliArgs, extraEnv, transportFactory, sessionId, manifestTuning) {
-        const raw = JSON.parse(fs41.readFileSync(specPath, "utf8"));
+        const raw = JSON.parse(fs422.readFileSync(specPath, "utf8"));
         this.spec = {
           id: raw.id,
           name: raw.name,
@@ -124750,10 +124774,10 @@ ${text}` : text;
     function createCliAdapter(provider, workingDir, cliArgs, extraEnv, transportFactory, sessionId, removeArgs) {
       const resolvedSpecPath = provider._resolvedSpecPath;
       const dir = provider._resolvedProviderDir;
-      let specPath = resolvedSpecPath && fs422.existsSync(resolvedSpecPath) ? resolvedSpecPath : void 0;
+      let specPath = resolvedSpecPath && fs43.existsSync(resolvedSpecPath) ? resolvedSpecPath : void 0;
       if (!specPath && dir) {
         const legacy = path46.join(dir, "spec.json");
-        if (fs422.existsSync(legacy)) specPath = legacy;
+        if (fs43.existsSync(legacy)) specPath = legacy;
       }
       if (!specPath) {
         throw new Error(formatNoResolvableSpecError(provider.type, dir));
@@ -124855,7 +124879,7 @@ ${text}` : text;
     init_summary_metadata();
     var os30 = __toESM2(require("os"));
     var crypto6 = __toESM2(require("crypto"));
-    var fs46 = __toESM2(require("fs"));
+    var fs47 = __toESM2(require("fs"));
     function shouldUseBracketedPasteForEnvelope(input) {
       return input.parts.some((part) => part.type === "image");
     }
@@ -125110,7 +125134,7 @@ ${text}` : text;
     var os29 = __toESM2(require("os"));
     var path47 = __toESM2(require("path"));
     var crypto5 = __toESM2(require("crypto"));
-    var fs43 = __toESM2(require("fs"));
+    var fs44 = __toESM2(require("fs"));
     var IMAGE_MIME_EXTENSIONS = {
       "image/png": ".png",
       "image/jpeg": ".jpg",
@@ -125145,9 +125169,9 @@ ${text}` : text;
       if (!part.data) return null;
       const rawData = part.data.includes(",") ? part.data.split(",").pop() || "" : part.data;
       if (!rawData) return null;
-      fs43.mkdirSync(dir, { recursive: true });
+      fs44.mkdirSync(dir, { recursive: true });
       const filePath = path47.join(dir, safeInputImageBasename(index, part.mimeType));
-      fs43.writeFileSync(filePath, Buffer.from(rawData, "base64"));
+      fs44.writeFileSync(filePath, Buffer.from(rawData, "base64"));
       cleanupStaleMaterializedImages(dir);
       return filePath;
     }
@@ -125159,14 +125183,14 @@ ${text}` : text;
       if (now - lastMaterializedImageCleanupAt < MATERIALIZED_IMAGE_CLEANUP_INTERVAL_MS) return;
       lastMaterializedImageCleanupAt = now;
       try {
-        const entries = fs43.readdirSync(dir);
+        const entries = fs44.readdirSync(dir);
         for (const entry of entries) {
           if (!entry.startsWith("adhdev-input-image-")) continue;
           const fullPath = path47.join(dir, entry);
           try {
-            const stat2 = fs43.statSync(fullPath);
+            const stat2 = fs44.statSync(fullPath);
             if (now - stat2.mtimeMs > MATERIALIZED_IMAGE_MAX_AGE_MS) {
-              fs43.unlinkSync(fullPath);
+              fs44.unlinkSync(fullPath);
             }
           } catch {
           }
@@ -125622,7 +125646,7 @@ ${text}` : text;
       if (missingEvidence) return { action: "suppress", missingEvidence };
       return { action: "inline_fire", missingEvidence: false };
     }
-    var fs44 = __toESM2(require("fs"));
+    var fs45 = __toESM2(require("fs"));
     function createSqliteProbeCache() {
       return { db: null, dbPath: null, missingUntil: 0 };
     }
@@ -125642,7 +125666,7 @@ ${text}` : text;
       };
       addDir(workingDir);
       try {
-        addDir(fs44.realpathSync.native(workingDir));
+        addDir(fs45.realpathSync.native(workingDir));
       } catch {
       }
       return Array.from(dirs);
@@ -126056,7 +126080,7 @@ ${buttons.join("\n")}`;
       }
       return adapterStatus;
     }
-    var fs45 = __toESM2(require("fs"));
+    var fs46 = __toESM2(require("fs"));
     init_contracts2();
     init_chat_message_normalization();
     init_chat_history();
@@ -126260,7 +126284,7 @@ ${buttons.join("\n")}`;
       }
       if (host.lastExternalCompletionProbe?.sourcePath) {
         try {
-          fs45.statSync(host.lastExternalCompletionProbe.sourcePath);
+          fs46.statSync(host.lastExternalCompletionProbe.sourcePath);
         } catch {
         }
       }
@@ -127576,7 +127600,7 @@ ${buttons.join("\n")}`;
         const resolvedDbPath = probe.dbPath.replace(/^~/, os30.homedir());
         const now = Date.now();
         if (this.sqliteProbeCache.missingUntil > now) return null;
-        if (!fs46.existsSync(resolvedDbPath)) {
+        if (!fs47.existsSync(resolvedDbPath)) {
           this.sqliteProbeCache.missingUntil = now + 1e4;
           return null;
         }
@@ -132980,7 +133004,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     var net3 = __toESM2(require("net"));
     var os322 = __toESM2(require("os"));
     var path56 = __toESM2(require("path"));
-    var fs51 = __toESM2(require("fs"));
+    var fs52 = __toESM2(require("fs"));
     var path55 = __toESM2(require("path"));
     var chokidar = __toESM2(require_chokidar());
     init_logger();
@@ -133481,7 +133505,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     init_contract();
     init_track_identity();
     init_config_dir();
-    var fs47 = __toESM2(require("fs"));
+    var fs48 = __toESM2(require("fs"));
     var path51 = __toESM2(require("path"));
     var crypto8 = __toESM2(require("crypto"));
     init_config();
@@ -133517,13 +133541,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
       /** Create a fresh staging directory. Caller must clean it up (or gc will). */
       createStagingDir(kind) {
         const dir = path51.join(this.stagingDir, `${kind}-${process.pid}-${crypto8.randomBytes(6).toString("hex")}`);
-        fs47.mkdirSync(dir, { recursive: true });
+        fs48.mkdirSync(dir, { recursive: true });
         return dir;
       }
       removeStagingDir(dir) {
         if (!dir.startsWith(this.stagingDir + path51.sep)) return;
         try {
-          fs47.rmSync(dir, { recursive: true, force: true });
+          fs48.rmSync(dir, { recursive: true, force: true });
         } catch {
         }
       }
@@ -133539,7 +133563,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       hasObject(digest) {
         try {
-          return fs47.statSync(this.getObjectDir(digest)).isDirectory();
+          return fs48.statSync(this.getObjectDir(digest)).isDirectory();
         } catch {
           return false;
         }
@@ -133557,8 +133581,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
           this.removeStagingDir(stagedObjectDir);
           return objectDir;
         }
-        fs47.mkdirSync(this.objectsDir, { recursive: true });
-        fs47.renameSync(stagedObjectDir, objectDir);
+        fs48.mkdirSync(this.objectsDir, { recursive: true });
+        fs48.renameSync(stagedObjectDir, objectDir);
         return objectDir;
       }
       // ─── Pointers ────────────────────────────────────────────
@@ -133570,10 +133594,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
        */
       getPointer(channel, providerType) {
         const file2 = this.pointerPath(channel, providerType);
-        if (!fs47.existsSync(file2)) return null;
+        if (!fs48.existsSync(file2)) return null;
         let parsed;
         try {
-          parsed = JSON.parse(fs47.readFileSync(file2, "utf-8"));
+          parsed = JSON.parse(fs48.readFileSync(file2, "utf-8"));
         } catch (e) {
           throw new ProviderChannelError(
             "STORE_CORRUPT",
@@ -133601,7 +133625,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         const dir = this.activeDir(channel);
         let files = [];
         try {
-          files = fs47.readdirSync(dir).filter((f) => f.endsWith(".json"));
+          files = fs48.readdirSync(dir).filter((f) => f.endsWith(".json"));
         } catch {
           return { pointers, errors };
         }
@@ -133622,7 +133646,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         const activations = [];
         for (const pointer of pointers.values()) {
           const objectDir = this.getObjectDir(pointer.active.digest);
-          if (!fs47.existsSync(objectDir)) {
+          if (!fs48.existsSync(objectDir)) {
             errors.push(new ProviderChannelError(
               "STORE_CORRUPT",
               `active object ${pointer.active.digest} for "${pointer.active.providerType}" is missing \u2014 skipping (fail closed)`,
@@ -133691,9 +133715,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
       /** Remove an activation pointer (e.g. provider uninstalled). */
       removePointer(channel, providerType) {
         const file2 = this.pointerPath(channel, providerType);
-        if (!fs47.existsSync(file2)) return false;
+        if (!fs48.existsSync(file2)) return false;
         try {
-          fs47.rmSync(file2, { force: true });
+          fs48.rmSync(file2, { force: true });
           return true;
         } catch {
           return false;
@@ -133701,11 +133725,11 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       writePointerAtomic(channel, providerType, pointer) {
         const dir = this.activeDir(channel);
-        fs47.mkdirSync(dir, { recursive: true });
+        fs48.mkdirSync(dir, { recursive: true });
         const file2 = this.pointerPath(channel, providerType);
         const tmp = path51.join(dir, `.${providerType}.${process.pid}.${crypto8.randomBytes(4).toString("hex")}.tmp`);
-        fs47.writeFileSync(tmp, JSON.stringify(pointer, null, 2), "utf-8");
-        fs47.renameSync(tmp, file2);
+        fs48.writeFileSync(tmp, JSON.stringify(pointer, null, 2), "utf-8");
+        fs48.renameSync(tmp, file2);
       }
       // ─── GC (N=2 retention) ──────────────────────────────────
       /**
@@ -133721,13 +133745,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
           const dir = this.activeDir(channel);
           let files = [];
           try {
-            files = fs47.readdirSync(dir).filter((f) => f.endsWith(".json"));
+            files = fs48.readdirSync(dir).filter((f) => f.endsWith(".json"));
           } catch {
             continue;
           }
           for (const file2 of files) {
             try {
-              const parsed = JSON.parse(fs47.readFileSync(path51.join(dir, file2), "utf-8"));
+              const parsed = JSON.parse(fs48.readFileSync(path51.join(dir, file2), "utf-8"));
               if (typeof parsed?.active?.digest === "string") referenced.add(parsed.active.digest);
               if (typeof parsed?.previous?.digest === "string") referenced.add(parsed.previous.digest);
             } catch {
@@ -133737,7 +133761,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         const removedObjects = [];
         let objectNames = [];
         try {
-          objectNames = fs47.readdirSync(this.objectsDir);
+          objectNames = fs48.readdirSync(this.objectsDir);
         } catch {
           objectNames = [];
         }
@@ -133745,7 +133769,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           const digest = `sha256:${name}`;
           if (referenced.has(digest)) continue;
           try {
-            fs47.rmSync(path51.join(this.objectsDir, name), { recursive: true, force: true });
+            fs48.rmSync(path51.join(this.objectsDir, name), { recursive: true, force: true });
             removedObjects.push(digest);
           } catch {
           }
@@ -133753,13 +133777,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
         let removedStaging = 0;
         let stagingEntries = [];
         try {
-          stagingEntries = fs47.readdirSync(this.stagingDir);
+          stagingEntries = fs48.readdirSync(this.stagingDir);
         } catch {
           stagingEntries = [];
         }
         for (const name of stagingEntries) {
           try {
-            fs47.rmSync(path51.join(this.stagingDir, name), { recursive: true, force: true });
+            fs48.rmSync(path51.join(this.stagingDir, name), { recursive: true, force: true });
             removedStaging++;
           } catch {
           }
@@ -133770,10 +133794,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
         return { removedObjects, removedStaging };
       }
     };
-    var fs50 = __toESM2(require("fs"));
+    var fs51 = __toESM2(require("fs"));
     var path53 = __toESM2(require("path"));
     init_contract();
-    var fs48 = __toESM2(require("fs"));
+    var fs49 = __toESM2(require("fs"));
     var path522 = __toESM2(require("path"));
     var import_crypto18 = require("crypto");
     init_contract();
@@ -133792,7 +133816,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       const hash2 = (0, import_crypto18.createHash)("sha256");
       for (const relPath of relPaths) {
         const absPath = path522.join(rootDir, ...relPath.split("/"));
-        const bytes = fs48.readFileSync(absPath);
+        const bytes = fs49.readFileSync(absPath);
         hash2.update(relPath, "utf8");
         hash2.update("\0");
         hash2.update(String(bytes.length), "utf8");
@@ -133804,7 +133828,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     function collectRegularFiles(rootDir, dir, out, providerType) {
       let entries;
       try {
-        entries = fs48.readdirSync(dir, { withFileTypes: true });
+        entries = fs49.readdirSync(dir, { withFileTypes: true });
       } catch (e) {
         throw new ProviderChannelError(
           "ENTRY_TREE_INVALID",
@@ -133829,12 +133853,12 @@ Run 'adhdev doctor' for detailed diagnostics.`
         out.push(rel);
       }
     }
-    var fs49 = __toESM2(require("fs"));
+    var fs50 = __toESM2(require("fs"));
     var zlib = __toESM2(require("zlib"));
     var import_promises6 = require("stream/promises");
     async function extractTarballGz(tarPath, destDir) {
       const tarFs = require_tar_fs();
-      await (0, import_promises6.pipeline)(fs49.createReadStream(tarPath), zlib.createGunzip(), tarFs.extract(destDir));
+      await (0, import_promises6.pipeline)(fs50.createReadStream(tarPath), zlib.createGunzip(), tarFs.extract(destDir));
     }
     var REGISTRY_LIST_LIMIT = 100;
     var ProviderChannelRuntime = class {
@@ -133957,7 +133981,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         try {
           const tarPath = path53.join(stagingRoot, "providers.tar.gz");
           const extractDir = path53.join(stagingRoot, "repo");
-          fs50.mkdirSync(extractDir, { recursive: true });
+          fs51.mkdirSync(extractDir, { recursive: true });
           try {
             await this.downloadFile(this.providerTarballUrl, tarPath);
             await this.extractTarball(tarPath, extractDir);
@@ -134015,8 +134039,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
         let relDir;
         try {
           relDir = path53.relative(repoRoot, artifactDir).split(path53.sep).join("/");
-          fs50.mkdirSync(path53.join(objStaging, entry.category), { recursive: true });
-          fs50.renameSync(artifactDir, path53.join(objStaging, entry.category, path53.basename(artifactDir)));
+          fs51.mkdirSync(path53.join(objStaging, entry.category), { recursive: true });
+          fs51.renameSync(artifactDir, path53.join(objStaging, entry.category, path53.basename(artifactDir)));
         } catch (e) {
           this.store.removeStagingDir(objStaging);
           return { code: "TRANSPORT_FAILED", message: `failed to stage artifact tree: ${e?.message || e}`, providerType: entry.providerType };
@@ -134055,7 +134079,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     function findTarballRepoRoot(extractDir) {
       let entries;
       try {
-        entries = fs50.readdirSync(extractDir, { withFileTypes: true });
+        entries = fs51.readdirSync(extractDir, { withFileTypes: true });
       } catch {
         return null;
       }
@@ -134067,7 +134091,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       const categoryDir = path53.join(repoRoot, entry.category);
       let candidates;
       try {
-        candidates = fs50.readdirSync(categoryDir, { withFileTypes: true });
+        candidates = fs51.readdirSync(categoryDir, { withFileTypes: true });
       } catch {
         return null;
       }
@@ -134078,8 +134102,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
         for (const manifestName of ["provider.v1.json", "provider.json"]) {
           const manifestPath = path53.join(dir, manifestName);
           try {
-            if (!fs50.existsSync(manifestPath)) continue;
-            const manifest = JSON.parse(fs50.readFileSync(manifestPath, "utf-8"));
+            if (!fs51.existsSync(manifestPath)) continue;
+            const manifest = JSON.parse(fs51.readFileSync(manifestPath, "utf-8"));
             if (manifest?.type === entry.providerType) return dir;
             break;
           } catch {
@@ -134096,14 +134120,14 @@ Run 'adhdev doctor' for detailed diagnostics.`
       const scan = (dir) => {
         let entries;
         try {
-          entries = fs50.readdirSync(dir, { withFileTypes: true });
+          entries = fs51.readdirSync(dir, { withFileTypes: true });
         } catch {
           return;
         }
         const manifest = entries.find((e) => e.isFile() && (e.name === "provider.v1.json" || e.name === "provider.json"));
         if (manifest) {
           try {
-            const parsed = JSON.parse(fs50.readFileSync(path53.join(dir, manifest.name), "utf-8"));
+            const parsed = JSON.parse(fs51.readFileSync(path53.join(dir, manifest.name), "utf-8"));
             if (typeof parsed?.type === "string" && parsed.type.trim()) targets.add(parsed.type);
           } catch {
           }
@@ -134168,7 +134192,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
               reject(new Error(`HTTP ${res.statusCode}`));
               return;
             }
-            const ws = fs50.createWriteStream(destPath);
+            const ws = fs51.createWriteStream(destPath);
             res.pipe(ws);
             ws.on("finish", () => {
               ws.close();
@@ -134329,9 +134353,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
       static siblingRefusalLogged = /* @__PURE__ */ new Set();
       static looksLikeProviderRoot(candidate) {
         try {
-          if (!fs51.existsSync(candidate) || !fs51.statSync(candidate).isDirectory()) return false;
+          if (!fs52.existsSync(candidate) || !fs52.statSync(candidate).isDirectory()) return false;
           return ["ide", "extension", "cli", "acp"].some(
-            (category) => fs51.existsSync(path55.join(candidate, category))
+            (category) => fs52.existsSync(path55.join(candidate, category))
           );
         } catch {
           return false;
@@ -134339,7 +134363,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       static hasProviderRootMarker(candidate) {
         try {
-          return fs51.existsSync(path55.join(candidate, _ProviderLoader.SIBLING_MARKER_FILE));
+          return fs52.existsSync(path55.join(candidate, _ProviderLoader.SIBLING_MARKER_FILE));
         } catch {
           return false;
         }
@@ -134426,12 +134450,12 @@ Run 'adhdev doctor' for detailed diagnostics.`
           const configDir = getConfigDir2();
           const oldDir = path55.join(configDir, "marketplace");
           const newDir = path55.join(configDir, "external");
-          if (!fs51.existsSync(oldDir)) return;
-          if (fs51.existsSync(newDir)) {
+          if (!fs52.existsSync(oldDir)) return;
+          if (fs52.existsSync(newDir)) {
             this.log(`Migration skipped: both ~/.adhdev/marketplace and ~/.adhdev/external exist (marketplace dir is now inert and can be removed manually).`);
             return;
           }
-          fs51.renameSync(oldDir, newDir);
+          fs52.renameSync(oldDir, newDir);
           this.log(`Migrated ~/.adhdev/marketplace \u2192 ~/.adhdev/external (one-time rename after provider source-layer cleanup).`);
         } catch (e) {
           this.log(`Marketplace\u2192external migration failed: ${e?.message || e}`);
@@ -134551,7 +134575,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         this.providers.clear();
         this.providerAvailability.clear();
         let upstreamCount = 0;
-        if (!this.disableUpstream && fs51.existsSync(this.upstreamDir)) {
+        if (!this.disableUpstream && fs52.existsSync(this.upstreamDir)) {
           upstreamCount = this.loadDir(this.upstreamDir);
           if (upstreamCount > 0) {
             this.log(`Loaded ${upstreamCount} upstream providers (auto-updated)`);
@@ -134561,10 +134585,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
         this.loadVerifiedChannelActivations();
         const externalDir = path55.join(getConfigDir2(), "external");
-        if (fs51.existsSync(externalDir)) {
+        if (fs52.existsSync(externalDir)) {
           const rootEntries = (() => {
             try {
-              return fs51.readdirSync(externalDir, { withFileTypes: true });
+              return fs52.readdirSync(externalDir, { withFileTypes: true });
             } catch {
               return [];
             }
@@ -134613,7 +134637,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
             }
           }
         }
-        if (fs51.existsSync(this.userDir)) {
+        if (fs52.existsSync(this.userDir)) {
           const userCount = this.loadDir(this.userDir, [".upstream"]);
           if (userCount > 0) {
             this.log(`Loaded ${userCount} user custom providers (never auto-updated)`);
@@ -134751,7 +134775,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         if (this.countVerifiedChannelPointers() > 0) return null;
         if (this.hasUpstream()) return this.syncVerifiedChannel();
         try {
-          fs51.mkdirSync(this.defaultProvidersDir, { recursive: true });
+          fs52.mkdirSync(this.defaultProvidersDir, { recursive: true });
         } catch {
         }
         return this.syncVerifiedChannel({ bootstrapAll: true });
@@ -134762,7 +134786,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       readChannelActivationStamp() {
         try {
-          return JSON.parse(fs51.readFileSync(this.channelActivationStampPath(), "utf-8"));
+          return JSON.parse(fs52.readFileSync(this.channelActivationStampPath(), "utf-8"));
         } catch {
           return null;
         }
@@ -134810,8 +134834,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
           }
         }
         try {
-          fs51.mkdirSync(this.defaultProvidersDir, { recursive: true });
-          fs51.writeFileSync(stampPath, JSON.stringify({
+          fs52.mkdirSync(this.defaultProvidersDir, { recursive: true });
+          fs52.writeFileSync(stampPath, JSON.stringify({
             daemonVersion: this.daemonVersion,
             channel: this.channel,
             syncedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -134955,10 +134979,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
        * Check if upstream directory exists and has providers.
        */
       hasUpstream() {
-        if (!fs51.existsSync(this.upstreamDir)) return false;
+        if (!fs52.existsSync(this.upstreamDir)) return false;
         try {
-          return fs51.readdirSync(this.upstreamDir).some(
-            (d) => fs51.statSync(path55.join(this.upstreamDir, d)).isDirectory()
+          return fs52.readdirSync(this.upstreamDir).some(
+            (d) => fs52.statSync(path55.join(this.upstreamDir, d)).isDirectory()
           );
         } catch {
           return false;
@@ -135507,7 +135531,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                     resolved._resolvedScriptsSource = `compatibility:${entry.ideVersion}`;
                     if (providerDir) {
                       const fullDir = path55.join(providerDir, entry.scriptDir);
-                      resolved._resolvedScriptsPath = fs51.existsSync(path55.join(fullDir, "scripts.js")) ? path55.join(fullDir, "scripts.js") : fullDir;
+                      resolved._resolvedScriptsPath = fs52.existsSync(path55.join(fullDir, "scripts.js")) ? path55.join(fullDir, "scripts.js") : fullDir;
                     }
                     matched = true;
                   }
@@ -135526,7 +135550,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 resolved._resolvedScriptsSource = "defaultScriptDir:version_miss";
                 if (providerDir) {
                   const fullDir = path55.join(providerDir, base.defaultScriptDir);
-                  resolved._resolvedScriptsPath = fs51.existsSync(path55.join(fullDir, "scripts.js")) ? path55.join(fullDir, "scripts.js") : fullDir;
+                  resolved._resolvedScriptsPath = fs52.existsSync(path55.join(fullDir, "scripts.js")) ? path55.join(fullDir, "scripts.js") : fullDir;
                 }
               }
               resolved._versionWarning = `Version ${currentVersion} not in compatibility matrix. Using default scripts.`;
@@ -135544,7 +135568,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                   resolved._resolvedScriptsSource = `versions:${range}`;
                   if (providerDir) {
                     const fullDir = path55.join(providerDir, dirOverride);
-                    resolved._resolvedScriptsPath = fs51.existsSync(path55.join(fullDir, "scripts.js")) ? path55.join(fullDir, "scripts.js") : fullDir;
+                    resolved._resolvedScriptsPath = fs52.existsSync(path55.join(fullDir, "scripts.js")) ? path55.join(fullDir, "scripts.js") : fullDir;
                   }
                 }
               } else if (override.scripts) {
@@ -135561,7 +135585,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
             resolved._resolvedScriptsSource = "defaultScriptDir:no_version";
             if (providerDir) {
               const fullDir = path55.join(providerDir, base.defaultScriptDir);
-              resolved._resolvedScriptsPath = fs51.existsSync(path55.join(fullDir, "scripts.js")) ? path55.join(fullDir, "scripts.js") : fullDir;
+              resolved._resolvedScriptsPath = fs52.existsSync(path55.join(fullDir, "scripts.js")) ? path55.join(fullDir, "scripts.js") : fullDir;
             }
           }
         }
@@ -135579,7 +135603,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
             for (const [scriptName, override] of Object.entries(base.overrides)) {
               if (!override || typeof override.path !== "string") continue;
               const fullPath = path55.join(providerDir2, override.path);
-              if (!fs51.existsSync(fullPath)) {
+              if (!fs52.existsSync(fullPath)) {
                 this.log(`  [overrides] ${base.type}: ${scriptName} path not found: ${fullPath}`);
                 continue;
               }
@@ -135609,7 +135633,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
         if (providerDir) {
           try {
-            const fs67 = require("fs");
+            const fs68 = require("fs");
             const path64 = require("path");
             const candidates = [];
             if (Array.isArray(base.compatibility)) {
@@ -135621,13 +135645,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
             }
             candidates.push(path64.join(providerDir, "specs", "default.json"));
             candidates.push(path64.join(providerDir, "spec.json"));
-            const specPath = candidates.find((p) => fs67.existsSync(p));
+            const specPath = candidates.find((p) => fs68.existsSync(p));
             let nh;
             if (specPath) {
               resolved._resolvedSpecPath = specPath;
               let specControls;
               try {
-                const rawSpec = JSON.parse(fs67.readFileSync(specPath, "utf8"));
+                const rawSpec = JSON.parse(fs68.readFileSync(specPath, "utf8"));
                 specControls = rawSpec.control_bar;
                 nh = rawSpec.native_history;
               } catch {
@@ -135670,7 +135694,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 }
               } else if (nh.override_path) {
                 const overrideFile = path64.resolve(providerDir, nh.override_path);
-                if (fs67.existsSync(overrideFile)) {
+                if (fs68.existsSync(overrideFile)) {
                   try {
                     registerProviderScriptRootSafely(path64.dirname(path64.dirname(providerDir)));
                     delete require.cache[require.resolve(overrideFile)];
@@ -135729,7 +135753,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           return null;
         }
         const dir = path55.join(providerDir, scriptDir);
-        if (!fs51.existsSync(dir)) {
+        if (!fs52.existsSync(dir)) {
           this.debugLog(`[loadScriptsFromDir] ${type2}: dir not found: ${dir}`);
           return null;
         }
@@ -135737,7 +135761,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         const cached5 = this.scriptsCache.get(dir);
         if (cached5) return cached5;
         const scriptsJs = path55.join(dir, "scripts.js");
-        if (fs51.existsSync(scriptsJs)) {
+        if (fs52.existsSync(scriptsJs)) {
           try {
             delete require.cache[require.resolve(scriptsJs)];
             const loaded = require(scriptsJs);
@@ -135758,9 +135782,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
       watch() {
         this.stopWatch();
         const watchDir = (dir) => {
-          if (!fs51.existsSync(dir)) {
+          if (!fs52.existsSync(dir)) {
             try {
-              fs51.mkdirSync(dir, { recursive: true });
+              fs52.mkdirSync(dir, { recursive: true });
             } catch {
               return;
             }
@@ -135823,11 +135847,11 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       /** Count provider files (provider.v1.json or provider.json — at most one per dir). */
       countProviders(dir) {
-        if (!fs51.existsSync(dir)) return 0;
+        if (!fs52.existsSync(dir)) return 0;
         let count = 0;
         const scan = (d) => {
           try {
-            const entries = fs51.readdirSync(d, { withFileTypes: true });
+            const entries = fs52.readdirSync(d, { withFileTypes: true });
             const hasManifest = entries.some((e) => e.name === "provider.v1.json" || e.name === "provider.json");
             if (hasManifest) count++;
             for (const entry of entries) {
@@ -136057,13 +136081,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
         if (!provider) return null;
         const cat = provider.category;
         const searchRoots = this.getProviderRoots();
-        const hasManifest = (dir) => fs51.existsSync(path55.join(dir, "provider.v1.json")) || fs51.existsSync(path55.join(dir, "provider.json"));
+        const hasManifest = (dir) => fs52.existsSync(path55.join(dir, "provider.v1.json")) || fs52.existsSync(path55.join(dir, "provider.json"));
         const readManifestType = (dir) => {
           for (const file2 of ["provider.v1.json", "provider.json"]) {
             const p = path55.join(dir, file2);
-            if (!fs51.existsSync(p)) continue;
+            if (!fs52.existsSync(p)) continue;
             try {
-              const data = JSON.parse(fs51.readFileSync(p, "utf-8"));
+              const data = JSON.parse(fs52.readFileSync(p, "utf-8"));
               if (typeof data?.type === "string") return data.type;
             } catch {
             }
@@ -136071,13 +136095,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
           return null;
         };
         for (const root of searchRoots) {
-          if (!fs51.existsSync(root)) continue;
+          if (!fs52.existsSync(root)) continue;
           const candidate = this.getProviderDir(root, cat, type2);
           if (hasManifest(candidate)) return candidate;
           const catDir = path55.join(root, cat);
-          if (fs51.existsSync(catDir)) {
+          if (fs52.existsSync(catDir)) {
             try {
-              for (const entry of fs51.readdirSync(catDir, { withFileTypes: true })) {
+              for (const entry of fs52.readdirSync(catDir, { withFileTypes: true })) {
                 if (!entry.isDirectory()) continue;
                 const entryDir = path55.join(catDir, entry.name);
                 const manifestType = readManifestType(entryDir);
@@ -136096,7 +136120,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
        */
       buildScriptWrappersFromDir(dir) {
         const scriptsJs = path55.join(dir, "scripts.js");
-        if (fs51.existsSync(scriptsJs)) {
+        if (fs52.existsSync(scriptsJs)) {
           try {
             delete require.cache[require.resolve(scriptsJs)];
             return require(scriptsJs);
@@ -136106,13 +136130,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
         const toCamel = (name) => name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
         const result = {};
         try {
-          for (const file2 of fs51.readdirSync(dir)) {
+          for (const file2 of fs52.readdirSync(dir)) {
             if (!file2.endsWith(".js")) continue;
             const scriptName = toCamel(file2.replace(".js", ""));
             const filePath = path55.join(dir, file2);
             result[scriptName] = (...args) => {
               try {
-                let content = fs51.readFileSync(filePath, "utf-8");
+                let content = fs52.readFileSync(filePath, "utf-8");
                 if (args[0] && typeof args[0] === "object") {
                   for (const [key2, val] of Object.entries(args[0])) {
                     let v = val;
@@ -136158,12 +136182,12 @@ Run 'adhdev doctor' for detailed diagnostics.`
        * Structure: dir/category/agent-name/provider.{json,js}
        */
       loadDir(dir, excludeDirs) {
-        if (!fs51.existsSync(dir)) return 0;
+        if (!fs52.existsSync(dir)) return 0;
         let count = 0;
         const scan = (d) => {
           let entries;
           try {
-            entries = fs51.readdirSync(d, { withFileTypes: true });
+            entries = fs52.readdirSync(d, { withFileTypes: true });
           } catch {
             return;
           }
@@ -136173,7 +136197,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
             const manifestFile = hasV1 ? "provider.v1.json" : "provider.json";
             const jsonPath = path55.join(d, manifestFile);
             try {
-              const raw = fs51.readFileSync(jsonPath, "utf-8");
+              const raw = fs52.readFileSync(jsonPath, "utf-8");
               const mod = JSON.parse(raw);
               if (hasV1 && (mod?.category === "cli" || mod?.category === "acp")) {
                 try {
@@ -136212,7 +136236,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
               } else {
                 const hasCompatibility = Array.isArray(normalizedProvider.compatibility);
                 const scriptsPath = path55.join(d, "scripts.js");
-                if (!hasCompatibility && fs51.existsSync(scriptsPath)) {
+                if (!hasCompatibility && fs52.existsSync(scriptsPath)) {
                   try {
                     registerProviderScriptRootSafely(path55.dirname(path55.dirname(d)));
                     delete require.cache[require.resolve(scriptsPath)];
@@ -136590,7 +136614,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         }
       } else if (plat === "win32") {
         try {
-          const fs67 = require("fs");
+          const fs68 = require("fs");
           const appNameMap = getMacAppIdentifiers();
           const appName = appNameMap[ideId];
           if (appName) {
@@ -136599,8 +136623,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
               appName,
               "storage.json"
             );
-            if (fs67.existsSync(storagePath)) {
-              const data = JSON.parse(fs67.readFileSync(storagePath, "utf-8"));
+            if (fs68.existsSync(storagePath)) {
+              const data = JSON.parse(fs68.readFileSync(storagePath, "utf-8"));
               const workspaces = data?.openedPathsList?.workspaces3 || data?.openedPathsList?.entries || [];
               if (workspaces.length > 0) {
                 const recent = workspaces[0];
@@ -139405,7 +139429,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       }
     };
     var import_path222 = require("path");
-    var fs55 = __toESM2(require("fs"));
+    var fs56 = __toESM2(require("fs"));
     init_logger();
     init_mesh_host_ownership();
     init_coordinator_registry();
@@ -139710,15 +139734,15 @@ ${ptyResult.output.slice(-2e3)}`);
             }
             if (cliType === "codex-cli") {
               const repoMcpConfigPath = (0, import_path222.join)(workspace, ".mcp.json");
-              if (fs55.existsSync(repoMcpConfigPath)) {
+              if (fs56.existsSync(repoMcpConfigPath)) {
                 try {
                   const repoMcpConfig = parseMeshCoordinatorMcpConfig(
-                    fs55.readFileSync(repoMcpConfigPath, "utf-8"),
+                    fs56.readFileSync(repoMcpConfigPath, "utf-8"),
                     "claude_mcp_json"
                   );
                   const existingServers2 = repoMcpConfig.mcpServers;
                   if (existingServers2 && typeof existingServers2 === "object" && !Array.isArray(existingServers2) && existingServers2[coordinatorSetup.serverName]) {
-                    fs55.writeFileSync(repoMcpConfigPath, serializeMeshCoordinatorMcpConfig({
+                    fs56.writeFileSync(repoMcpConfigPath, serializeMeshCoordinatorMcpConfig({
                       ...repoMcpConfig,
                       mcpServers: {
                         ...existingServers2,
@@ -140089,7 +140113,7 @@ ${ptyResult.output.slice(-2e3)}`);
         }
       }
     };
-    var fs56 = __toESM2(require("fs"));
+    var fs57 = __toESM2(require("fs"));
     var import_os5 = require("os");
     init_config();
     init_git_status();
@@ -140472,7 +140496,7 @@ ${ptyResult.output.slice(-2e3)}`);
               }
             }
             if (workspace) {
-              if (!fs56.existsSync(workspace)) {
+              if (!fs57.existsSync(workspace)) {
                 const inlineTransitGit = buildInlineMeshTransitGitStatus(node);
                 let remoteProbeApplied = false;
                 if (inlineTransitGit) {
@@ -140613,7 +140637,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const pendingRetentionCounters2 = { ...getPendingRetentionCounters() };
           const turnPresentationCounters = getTurnPresentationMetrics();
           const previewFreshness = (() => {
-            const localRepoRoot = nodeStatuses.map((node) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace)).find((candidate) => !!candidate && fs56.existsSync(candidate));
+            const localRepoRoot = nodeStatuses.map((node) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace)).find((candidate) => !!candidate && fs57.existsSync(candidate));
             return localRepoRoot ? buildPreviewFreshness(localRepoRoot) : void 0;
           })();
           const asyncRefineJobs = buildMeshAsyncRefineJobs({
@@ -140813,7 +140837,7 @@ ${ptyResult.output.slice(-2e3)}`);
     init_logger();
     init_mesh_dual_write();
     init_transcript_publisher();
-    var fs57 = __toESM2(require("fs"));
+    var fs58 = __toESM2(require("fs"));
     var path57 = __toESM2(require("path"));
     init_config_dir();
     var MAX_FILE_SIZE = 5 * 1024 * 1024;
@@ -140862,7 +140886,7 @@ ${ptyResult.output.slice(-2e3)}`);
       currentFile = path57.join(dir, `commands-${today}.jsonl`);
       if (dirChanged) {
         try {
-          fs57.mkdirSync(dir, { recursive: true });
+          fs58.mkdirSync(dir, { recursive: true });
         } catch {
         }
         cleanOldFiles();
@@ -140870,7 +140894,7 @@ ${ptyResult.output.slice(-2e3)}`);
     }
     function cleanOldFiles() {
       try {
-        const files = fs57.readdirSync(currentDir).filter((f) => f.startsWith("commands-") && f.endsWith(".jsonl"));
+        const files = fs58.readdirSync(currentDir).filter((f) => f.startsWith("commands-") && f.endsWith(".jsonl"));
         const cutoff = /* @__PURE__ */ new Date();
         cutoff.setDate(cutoff.getDate() - MAX_DAYS);
         const cutoffStr = cutoff.toISOString().slice(0, 10);
@@ -140878,7 +140902,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const dateMatch = file2.match(/commands-(\d{4}-\d{2}-\d{2})/);
           if (dateMatch && dateMatch[1] < cutoffStr) {
             try {
-              fs57.unlinkSync(path57.join(currentDir, file2));
+              fs58.unlinkSync(path57.join(currentDir, file2));
             } catch {
             }
           }
@@ -140888,14 +140912,14 @@ ${ptyResult.output.slice(-2e3)}`);
     }
     function checkSize() {
       try {
-        const stat2 = fs57.statSync(currentFile);
+        const stat2 = fs58.statSync(currentFile);
         if (stat2.size > MAX_FILE_SIZE) {
           const backup = currentFile.replace(".jsonl", ".1.jsonl");
           try {
-            fs57.unlinkSync(backup);
+            fs58.unlinkSync(backup);
           } catch {
           }
-          fs57.renameSync(currentFile, backup);
+          fs58.renameSync(currentFile, backup);
         }
       } catch {
       }
@@ -140928,15 +140952,15 @@ ${ptyResult.output.slice(-2e3)}`);
           ...entry.error ? { err: entry.error } : {},
           ...entry.durationMs !== void 0 ? { ms: entry.durationMs } : {}
         });
-        fs57.appendFileSync(currentFile, line + "\n");
+        fs58.appendFileSync(currentFile, line + "\n");
       } catch {
       }
     }
     function getRecentCommands(count = 50) {
       try {
         refreshCurrentFile();
-        if (!fs57.existsSync(currentFile)) return [];
-        const content = fs57.readFileSync(currentFile, "utf-8");
+        if (!fs58.existsSync(currentFile)) return [];
+        const content = fs58.readFileSync(currentFile, "utf-8");
         const lines = content.trim().split("\n").filter(Boolean);
         return lines.slice(-count).map((line) => {
           try {
@@ -140963,10 +140987,10 @@ ${ptyResult.output.slice(-2e3)}`);
     init_mesh_host_ownership();
     init_repo_mesh_types();
     init_mesh_config();
-    var fs59 = __toESM2(require("fs"));
+    var fs60 = __toESM2(require("fs"));
     init_mesh_node_identity();
     init_router_refine();
-    var fs58 = __toESM2(require("fs"));
+    var fs59 = __toESM2(require("fs"));
     var import_node_os22 = require("os");
     var import_path23 = require("path");
     init_logger();
@@ -140997,7 +141021,7 @@ ${ptyResult.output.slice(-2e3)}`);
       return out;
     }
     function repoRootUsable(repoRoot) {
-      return typeof repoRoot === "string" && repoRoot.trim().length > 0 && fs58.existsSync(repoRoot.trim());
+      return typeof repoRoot === "string" && repoRoot.trim().length > 0 && fs59.existsSync(repoRoot.trim());
     }
     function meshWorktreeBaseDir(mesh) {
       const v = mesh?.policy?.worktreeBaseDir;
@@ -141066,14 +141090,14 @@ ${ptyResult.output.slice(-2e3)}`);
       return false;
     }
     async function bestEffortRemoveWorktreeDir(self, dir) {
-      if (!dir || !fs58.existsSync(dir)) return { removed: true, residue: false };
+      if (!dir || !fs59.existsSync(dir)) return { removed: true, residue: false };
       const sleep3 = (ms) => new Promise((resolve32) => setTimeout(resolve32, ms));
       const ABSORB = /* @__PURE__ */ new Set(["EINVAL", "EPERM", "EBUSY", "ENOTEMPTY", "EACCES", "EMFILE", "ENFILE"]);
       let lastErr;
       for (let attempt = 0; attempt < 4; attempt++) {
         try {
-          fs58.rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-          if (!fs58.existsSync(dir)) return { removed: true, residue: false };
+          fs59.rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+          if (!fs59.existsSync(dir)) return { removed: true, residue: false };
           lastErr = new Error("directory still present after rmSync");
         } catch (e) {
           lastErr = e;
@@ -141084,7 +141108,7 @@ ${ptyResult.output.slice(-2e3)}`);
         }
         await sleep3(150 * (attempt + 1));
       }
-      return fs58.existsSync(dir) ? { removed: false, residue: true, error: String(lastErr?.message || lastErr || "unknown rm error") } : { removed: true, residue: false };
+      return fs59.existsSync(dir) ? { removed: false, residue: true, error: String(lastErr?.message || lastErr || "unknown rm error") } : { removed: true, residue: false };
     }
     async function precheckLocalWorktreeRemovable(self, args) {
       const sessionPreservedNote = " The delegated session was left running (not stopped) \u2014 resolve the issue and retry mesh_remove_node.";
@@ -141097,10 +141121,10 @@ ${ptyResult.output.slice(-2e3)}`);
           recoveryHint: "Inspect the mesh node record before removing it, or remove stale metadata manually only after confirming no managed worktree remains." + sessionPreservedNote
         };
       }
-      if (!fs58.existsSync(workspace)) return { ok: true };
+      if (!fs59.existsSync(workspace)) return { ok: true };
       const sourceNode = args.node?.clonedFromNodeId ? args.mesh?.nodes?.find((n) => meshNodeIdMatches(n, args.node.clonedFromNodeId)) : args.mesh?.nodes?.find((n) => !n.isLocalWorktree);
       const repoRoot = typeof sourceNode?.repoRoot === "string" && sourceNode.repoRoot.trim() ? sourceNode.repoRoot.trim() : typeof sourceNode?.workspace === "string" && sourceNode.workspace.trim() ? sourceNode.workspace.trim() : "";
-      if (!repoRoot || !fs58.existsSync(repoRoot)) {
+      if (!repoRoot || !fs59.existsSync(repoRoot)) {
         return {
           ok: false,
           code: "mesh_worktree_cleanup_missing_source_repo",
@@ -141120,7 +141144,7 @@ ${ptyResult.output.slice(-2e3)}`);
       const normalizePath2 = (value) => {
         const resolved = (0, import_path23.resolve)(value);
         try {
-          return fs58.realpathSync(resolved);
+          return fs59.realpathSync(resolved);
         } catch {
           return resolved;
         }
@@ -141221,13 +141245,13 @@ ${ptyResult.output.slice(-2e3)}`);
           recoveryHint: "Inspect the mesh node record before removing it, or remove stale metadata manually only after confirming no managed worktree remains."
         };
       }
-      const worktreeExists = fs58.existsSync(workspace);
+      const worktreeExists = fs59.existsSync(workspace);
       const sourceNode = args.node?.clonedFromNodeId ? args.mesh?.nodes?.find((n) => meshNodeIdMatches(n, args.node.clonedFromNodeId)) : args.mesh?.nodes?.find((n) => !n.isLocalWorktree);
       const repoRoot = typeof sourceNode?.repoRoot === "string" && sourceNode.repoRoot.trim() ? sourceNode.repoRoot.trim() : typeof sourceNode?.workspace === "string" && sourceNode.workspace.trim() ? sourceNode.workspace.trim() : "";
       if (!worktreeExists) {
         return { success: true, skipped: true, removedPath: workspace, repoRoot: repoRoot || void 0, reason: "worktree_path_missing" };
       }
-      if (!repoRoot || !fs58.existsSync(repoRoot)) {
+      if (!repoRoot || !fs59.existsSync(repoRoot)) {
         return {
           success: false,
           code: "mesh_worktree_cleanup_missing_source_repo",
@@ -141247,7 +141271,7 @@ ${ptyResult.output.slice(-2e3)}`);
       const normalizePath2 = (value) => {
         const resolved = (0, import_path23.resolve)(value);
         try {
-          return fs58.realpathSync(resolved);
+          return fs59.realpathSync(resolved);
         } catch {
           return resolved;
         }
@@ -141464,7 +141488,7 @@ ${ptyResult.output.slice(-2e3)}`);
         });
         return String(stdout || "").trim();
       };
-      const workspaceMissing = !args.workspace || !fs58.existsSync(args.workspace);
+      const workspaceMissing = !args.workspace || !fs59.existsSync(args.workspace);
       let head = "";
       const branch = typeof args.node?.worktreeBranch === "string" ? args.node.worktreeBranch.trim() : "";
       if (workspaceMissing) {
@@ -142514,7 +142538,7 @@ ${ptyResult.output.slice(-2e3)}`);
         const tombstones = this.removedInlineMeshNodeIds.get(meshId);
         if (!tombstones?.size || !tombstones.has(nodeId)) return false;
         const workspace = readStringValue(node?.workspace);
-        if (workspace && fs59.existsSync(workspace)) {
+        if (workspace && fs60.existsSync(workspace)) {
           tombstones.delete(nodeId);
           if (tombstones.size === 0) this.removedInlineMeshNodeIds.delete(meshId);
           return false;
@@ -142535,7 +142559,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const nodeId = readInlineMeshNodeId(node);
           if (!nodeId || !tombstones.has(nodeId)) return true;
           const workspace = readStringValue(node?.workspace);
-          if (workspace && fs59.existsSync(workspace)) {
+          if (workspace && fs60.existsSync(workspace)) {
             tombstones.delete(nodeId);
             return true;
           }
@@ -142980,7 +143004,6 @@ ${ptyResult.output.slice(-2e3)}`);
     }
     init_snapshot3();
     init_runtime_defaults();
-    init_transcript_publisher();
     var DEFAULT_GIT_REFRESH_CONCURRENCY = 2;
     var DEFAULT_CHAT_TAIL_FLUSH_DEBOUNCE_MS = 700;
     var PUSH_TOPICS = ["machine.runtime", "session_host.diagnostics", "session.modal", "daemon.metadata"];
@@ -143334,7 +143357,6 @@ ${ptyResult.output.slice(-2e3)}`);
       markChatOutputActivity(sessionId) {
         const cfg = this.opts.chatTail;
         if (!sessionId || !(cfg?.isCliSession?.(sessionId) ?? false)) return;
-        markTranscriptPtyOutputActivity(sessionId);
         this.chatOutputActiveAt.set(sessionId, this.now());
         if (this.chatOutputFlushTimer) return;
         if (cfg?.scheduleGate && !cfg.scheduleGate()) return;
@@ -145660,7 +145682,7 @@ ${ptyResult.output.slice(-2e3)}`);
     };
     init_io_contracts();
     init_chat_message_normalization();
-    var fs60 = __toESM2(require("fs"));
+    var fs61 = __toESM2(require("fs"));
     var path58 = __toESM2(require("path"));
     var os33 = __toESM2(require("os"));
     var import_os6 = require("os");
@@ -145677,8 +145699,8 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       load() {
         try {
-          if (fs60.existsSync(getArchivePath2())) {
-            this.history = JSON.parse(fs60.readFileSync(getArchivePath2(), "utf-8"));
+          if (fs61.existsSync(getArchivePath2())) {
+            this.history = JSON.parse(fs61.readFileSync(getArchivePath2(), "utf-8"));
           }
         } catch {
           this.history = {};
@@ -145715,8 +145737,8 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       save() {
         try {
-          fs60.mkdirSync(path58.dirname(getArchivePath2()), { recursive: true });
-          fs60.writeFileSync(getArchivePath2(), JSON.stringify(this.history, null, 2));
+          fs61.mkdirSync(path58.dirname(getArchivePath2()), { recursive: true });
+          fs61.writeFileSync(getArchivePath2(), JSON.stringify(this.history, null, 2));
         } catch {
         }
       }
@@ -145741,8 +145763,8 @@ ${ptyResult.output.slice(-2e3)}`);
         for (const ext of exes) {
           const fullPath = path58.join(p, name + ext);
           try {
-            if (fs60.existsSync(fullPath)) {
-              const stat2 = fs60.statSync(fullPath);
+            if (fs61.existsSync(fullPath)) {
+              const stat2 = fs61.statSync(fullPath);
               if (stat2.isFile() && (isWin || stat2.mode & 73)) {
                 return fullPath;
               }
@@ -145789,9 +145811,9 @@ ${ptyResult.output.slice(-2e3)}`);
         if (p.includes("*")) {
           const home = os33.homedir();
           const resolved = p.replace(/\*/g, home.split(path58.sep).pop() || "");
-          if (fs60.existsSync(resolved)) return resolved;
+          if (fs61.existsSync(resolved)) return resolved;
         } else {
-          if (fs60.existsSync(p)) return p;
+          if (fs61.existsSync(p)) return p;
         }
       }
       return null;
@@ -145799,7 +145821,7 @@ ${ptyResult.output.slice(-2e3)}`);
     async function getMacAppVersion(appPath) {
       if ((0, import_os6.platform)() !== "darwin" || !appPath.endsWith(".app")) return null;
       const plistPath = path58.join(appPath, "Contents", "Info.plist");
-      if (!fs60.existsSync(plistPath)) return null;
+      if (!fs61.existsSync(plistPath)) return null;
       const raw = await runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
       return raw || null;
     }
@@ -145826,7 +145848,7 @@ ${ptyResult.output.slice(-2e3)}`);
           let resolvedBin = cliBin;
           if (!resolvedBin && appPath && currentOs === "darwin") {
             const bundled = path58.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
-            if (provider.cli && fs60.existsSync(bundled)) resolvedBin = bundled;
+            if (provider.cli && fs61.existsSync(bundled)) resolvedBin = bundled;
           }
           info.installed = !!(appPath || resolvedBin);
           info.path = appPath || null;
@@ -145872,7 +145894,7 @@ ${ptyResult.output.slice(-2e3)}`);
       return results;
     }
     var http3 = __toESM2(require("http"));
-    var fs64 = __toESM2(require("fs"));
+    var fs65 = __toESM2(require("fs"));
     var path62 = __toESM2(require("path"));
     init_config();
     function generateFiles(type2, name, category, opts = {}) {
@@ -146218,7 +146240,7 @@ async (params) => {
     }
     init_logger();
     init_builders();
-    var fs61 = __toESM2(require("fs"));
+    var fs62 = __toESM2(require("fs"));
     var path59 = __toESM2(require("path"));
     init_logger();
     async function handleCdpEvaluate(ctx, req, res) {
@@ -146399,17 +146421,17 @@ async (params) => {
       }
       let scriptsPath = "";
       const directScripts = path59.join(dir, "scripts.js");
-      if (fs61.existsSync(directScripts)) {
+      if (fs62.existsSync(directScripts)) {
         scriptsPath = directScripts;
       } else {
         const scriptsDir = path59.join(dir, "scripts");
-        if (fs61.existsSync(scriptsDir)) {
-          const versions = fs61.readdirSync(scriptsDir).filter((d) => {
-            return fs61.statSync(path59.join(scriptsDir, d)).isDirectory();
+        if (fs62.existsSync(scriptsDir)) {
+          const versions = fs62.readdirSync(scriptsDir).filter((d) => {
+            return fs62.statSync(path59.join(scriptsDir, d)).isDirectory();
           }).sort().reverse();
           for (const ver of versions) {
             const p = path59.join(scriptsDir, ver, "scripts.js");
-            if (fs61.existsSync(p)) {
+            if (fs62.existsSync(p)) {
               scriptsPath = p;
               break;
             }
@@ -146421,7 +146443,7 @@ async (params) => {
         return;
       }
       try {
-        const source = fs61.readFileSync(scriptsPath, "utf-8");
+        const source = fs62.readFileSync(scriptsPath, "utf-8");
         const hints = {};
         const funcRegex = /module\.exports\.(\w+)\s*=\s*function\s+\w+\s*\(params\)/g;
         let match;
@@ -147234,7 +147256,7 @@ async (params) => {
         ctx.json(res, 500, { error: `DOM context collection failed: ${e.message}` });
       }
     }
-    var fs62 = __toESM2(require("fs"));
+    var fs63 = __toESM2(require("fs"));
     var path60 = __toESM2(require("path"));
     function slugifyFixtureName(value) {
       const normalized = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -147250,10 +147272,10 @@ async (params) => {
     function readCliFixture(ctx, type2, name) {
       const fixtureDir = getCliFixtureDir(ctx, type2);
       const filePath = path60.join(fixtureDir, `${name}.json`);
-      if (!fs62.existsSync(filePath)) {
+      if (!fs63.existsSync(filePath)) {
         throw new Error(`Fixture not found: ${filePath}`);
       }
-      return JSON.parse(fs62.readFileSync(filePath, "utf-8"));
+      return JSON.parse(fs63.readFileSync(filePath, "utf-8"));
     }
     function getExerciseTranscriptText(result) {
       const parts = [];
@@ -148003,7 +148025,7 @@ async (params) => {
           return;
         }
         const fixtureDir = getCliFixtureDir(ctx, type2);
-        fs62.mkdirSync(fixtureDir, { recursive: true });
+        fs63.mkdirSync(fixtureDir, { recursive: true });
         const name = slugifyFixtureName(String(body?.name || `${type2}-${Date.now()}`));
         const result = await runCliExerciseInternal(ctx, { ...request, type: type2 });
         const fixture = {
@@ -148031,7 +148053,7 @@ async (params) => {
           notes: typeof body?.notes === "string" ? body.notes : void 0
         };
         const filePath = path60.join(fixtureDir, `${name}.json`);
-        fs62.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
+        fs63.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
         ctx.json(res, 200, {
           saved: true,
           name,
@@ -148049,14 +148071,14 @@ async (params) => {
     async function handleCliFixtureList(ctx, type2, _req, res) {
       try {
         const fixtureDir = getCliFixtureDir(ctx, type2);
-        if (!fs62.existsSync(fixtureDir)) {
+        if (!fs63.existsSync(fixtureDir)) {
           ctx.json(res, 200, { fixtures: [], count: 0 });
           return;
         }
-        const fixtures = fs62.readdirSync(fixtureDir).filter((file2) => file2.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file2) => {
+        const fixtures = fs63.readdirSync(fixtureDir).filter((file2) => file2.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file2) => {
           const fullPath = path60.join(fixtureDir, file2);
           try {
-            const raw = JSON.parse(fs62.readFileSync(fullPath, "utf-8"));
+            const raw = JSON.parse(fs63.readFileSync(fullPath, "utf-8"));
             return {
               name: raw.name || file2.replace(/\.json$/i, ""),
               path: fullPath,
@@ -148187,7 +148209,7 @@ async (params) => {
         ctx.json(res, 500, { error: `Raw send failed: ${e.message}` });
       }
     }
-    var fs63 = __toESM2(require("fs"));
+    var fs64 = __toESM2(require("fs"));
     var path61 = __toESM2(require("path"));
     var os34 = __toESM2(require("os"));
     var import_session_host_core10 = require_dist();
@@ -148236,10 +148258,10 @@ async (params) => {
       return fallback?.type || null;
     }
     function getLatestScriptVersionDir(scriptsDir) {
-      if (!fs63.existsSync(scriptsDir)) return null;
-      const versions = fs63.readdirSync(scriptsDir).filter((d) => {
+      if (!fs64.existsSync(scriptsDir)) return null;
+      const versions = fs64.readdirSync(scriptsDir).filter((d) => {
         try {
-          return fs63.statSync(path61.join(scriptsDir, d)).isDirectory();
+          return fs64.statSync(path61.join(scriptsDir, d)).isDirectory();
         } catch {
           return false;
         }
@@ -148261,13 +148283,13 @@ async (params) => {
       if (!sourceDir) {
         return { dir: null, reason: `Provider source directory not found for '${type2}'` };
       }
-      if (!fs63.existsSync(desiredDir)) {
-        fs63.mkdirSync(path61.dirname(desiredDir), { recursive: true });
-        fs63.cpSync(sourceDir, desiredDir, { recursive: true });
+      if (!fs64.existsSync(desiredDir)) {
+        fs64.mkdirSync(path61.dirname(desiredDir), { recursive: true });
+        fs64.cpSync(sourceDir, desiredDir, { recursive: true });
         ctx.log(`Auto-implement writable copy created: ${desiredDir}`);
       }
       const providerJson = path61.join(desiredDir, "provider.json");
-      if (!fs63.existsSync(providerJson)) {
+      if (!fs64.existsSync(providerJson)) {
         return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
       }
       return { dir: desiredDir };
@@ -148275,15 +148297,15 @@ async (params) => {
     function loadAutoImplReferenceScripts(ctx, referenceType) {
       if (!referenceType) return {};
       const refDir = ctx.findProviderDir(referenceType);
-      if (!refDir || !fs63.existsSync(refDir)) return {};
+      if (!refDir || !fs64.existsSync(refDir)) return {};
       const referenceScripts = {};
       const scriptsDir = path61.join(refDir, "scripts");
       const latestDir = getLatestScriptVersionDir(scriptsDir);
       if (!latestDir) return referenceScripts;
-      for (const file2 of fs63.readdirSync(latestDir)) {
+      for (const file2 of fs64.readdirSync(latestDir)) {
         if (!file2.endsWith(".js")) continue;
         try {
-          referenceScripts[file2] = fs63.readFileSync(path61.join(latestDir, file2), "utf-8");
+          referenceScripts[file2] = fs64.readFileSync(path61.join(latestDir, file2), "utf-8");
         } catch {
         }
       }
@@ -148392,15 +148414,15 @@ async (params) => {
         const referenceScripts = loadAutoImplReferenceScripts(ctx, resolvedReference);
         const prompt = buildAutoImplPrompt(ctx, type2, provider, providerDir, functions, domContext, referenceScripts, comment, resolvedReference, verification);
         const tmpDir = path61.join(os34.tmpdir(), "adhdev-autoimpl");
-        if (!fs63.existsSync(tmpDir)) fs63.mkdirSync(tmpDir, { recursive: true });
+        if (!fs64.existsSync(tmpDir)) fs64.mkdirSync(tmpDir, { recursive: true });
         const promptFile = path61.join(tmpDir, `prompt-${type2}-${Date.now()}.md`);
-        fs63.writeFileSync(promptFile, prompt, "utf-8");
+        fs64.writeFileSync(promptFile, prompt, "utf-8");
         ctx.log(`Auto-implement prompt written to ${promptFile} (${prompt.length} chars)`);
         const agentProvider = ctx.providerLoader.resolve(agent) || ctx.providerLoader.getMeta(agent);
         const spawn7 = agentProvider?.spawn;
         if (!spawn7?.command) {
           try {
-            fs63.unlinkSync(promptFile);
+            fs64.unlinkSync(promptFile);
           } catch {
           }
           ctx.json(res, 400, { error: `Agent '${agent}' has no spawn config. Select a CLI provider with a spawn configuration.` });
@@ -148503,7 +148525,7 @@ async (params) => {
             } catch {
             }
             try {
-              fs63.unlinkSync(promptFile);
+              fs64.unlinkSync(promptFile);
             } catch {
             }
             ctx.log(`Auto-implement (ACP) ${success2 ? "completed" : "failed"}: ${type2} (exit: ${code})`);
@@ -148727,7 +148749,7 @@ async (params) => {
             }
           });
           try {
-            fs63.unlinkSync(promptFile);
+            fs64.unlinkSync(promptFile);
           } catch {
           }
           ctx.log(`Auto-implement ${success2 ? "completed" : "failed"}: ${type2} (exit: ${code})${verificationSummary ? ` verify=${verificationSummary.pass ? "pass" : "fail"}` : ""}`);
@@ -148832,10 +148854,10 @@ async (params) => {
         lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
         lines.push("These are the ONLY files you are allowed to modify. Replace the TODO stubs with working implementations.");
         lines.push("");
-        for (const file2 of fs63.readdirSync(latestScriptsDir)) {
+        for (const file2 of fs64.readdirSync(latestScriptsDir)) {
           if (file2.endsWith(".js") && targetFileNames.has(file2)) {
             try {
-              const content = fs63.readFileSync(path61.join(latestScriptsDir, file2), "utf-8");
+              const content = fs64.readFileSync(path61.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
               lines.push("```javascript");
               lines.push(content);
@@ -148845,14 +148867,14 @@ async (params) => {
             }
           }
         }
-        const refFiles = fs63.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+        const refFiles = fs64.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
         if (refFiles.length > 0) {
           lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
           lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
           lines.push("");
           for (const file2 of refFiles) {
             try {
-              const content = fs63.readFileSync(path61.join(latestScriptsDir, file2), "utf-8");
+              const content = fs64.readFileSync(path61.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u{1F512}`);
               lines.push("```javascript");
               lines.push(content);
@@ -148897,7 +148919,7 @@ async (params) => {
       const loadGuide = (name) => {
         try {
           const p = path61.join(docsDir, name);
-          if (fs63.existsSync(p)) return fs63.readFileSync(p, "utf-8");
+          if (fs64.existsSync(p)) return fs64.readFileSync(p, "utf-8");
         } catch {
         }
         return null;
@@ -149141,11 +149163,11 @@ async (params) => {
         lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
         lines.push("These are the ONLY files you are allowed to modify. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
         lines.push("");
-        for (const file2 of fs63.readdirSync(latestScriptsDir)) {
+        for (const file2 of fs64.readdirSync(latestScriptsDir)) {
           if (!file2.endsWith(".js")) continue;
           if (!targetFileNames.has(file2)) continue;
           try {
-            const content = fs63.readFileSync(path61.join(latestScriptsDir, file2), "utf-8");
+            const content = fs64.readFileSync(path61.join(latestScriptsDir, file2), "utf-8");
             lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
             lines.push("```javascript");
             lines.push(content);
@@ -149154,14 +149176,14 @@ async (params) => {
           } catch {
           }
         }
-        const refFiles = fs63.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+        const refFiles = fs64.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
         if (refFiles.length > 0) {
           lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
           lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
           lines.push("");
           for (const file2 of refFiles) {
             try {
-              const content = fs63.readFileSync(path61.join(latestScriptsDir, file2), "utf-8");
+              const content = fs64.readFileSync(path61.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u{1F512}`);
               lines.push("```javascript");
               lines.push(content);
@@ -149198,7 +149220,7 @@ async (params) => {
       const loadGuide = (name) => {
         try {
           const p = path61.join(docsDir, name);
-          if (fs63.existsSync(p)) return fs63.readFileSync(p, "utf-8");
+          if (fs64.existsSync(p)) return fs64.readFileSync(p, "utf-8");
         } catch {
         }
         return null;
@@ -149937,7 +149959,7 @@ data: ${JSON.stringify(msg.data)}
           path62.join(process.cwd(), "packages/web-devconsole/dist")
         ];
         for (const dir of candidates) {
-          if (fs64.existsSync(path62.join(dir, "index.html"))) return dir;
+          if (fs65.existsSync(path62.join(dir, "index.html"))) return dir;
         }
         return null;
       }
@@ -149949,7 +149971,7 @@ data: ${JSON.stringify(msg.data)}
         }
         const htmlPath = path62.join(distDir, "index.html");
         try {
-          const html = fs64.readFileSync(htmlPath, "utf-8");
+          const html = fs65.readFileSync(htmlPath, "utf-8");
           res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
           res.end(html);
         } catch (e) {
@@ -149979,7 +150001,7 @@ data: ${JSON.stringify(msg.data)}
           return;
         }
         try {
-          const content = fs64.readFileSync(filePath);
+          const content = fs65.readFileSync(filePath);
           const ext = path62.extname(filePath);
           const contentType = _DevServer.MIME_MAP[ext] || "application/octet-stream";
           res.writeHead(200, { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" });
@@ -150088,14 +150110,14 @@ data: ${JSON.stringify(msg.data)}
         const files = [];
         const scan = (d, prefix) => {
           try {
-            for (const entry of fs64.readdirSync(d, { withFileTypes: true })) {
+            for (const entry of fs65.readdirSync(d, { withFileTypes: true })) {
               if (entry.name.startsWith(".") || entry.name.endsWith(".bak")) continue;
               const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
               if (entry.isDirectory()) {
                 files.push({ path: rel, size: 0, type: "dir" });
                 scan(path62.join(d, entry.name), rel);
               } else {
-                const stat2 = fs64.statSync(path62.join(d, entry.name));
+                const stat2 = fs65.statSync(path62.join(d, entry.name));
                 files.push({ path: rel, size: stat2.size, type: "file" });
               }
             }
@@ -150123,11 +150145,11 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 403, { error: "Forbidden" });
           return;
         }
-        if (!fs64.existsSync(fullPath) || fs64.statSync(fullPath).isDirectory()) {
+        if (!fs65.existsSync(fullPath) || fs65.statSync(fullPath).isDirectory()) {
           this.json(res, 404, { error: `File not found: ${filePath}` });
           return;
         }
-        const content = fs64.readFileSync(fullPath, "utf-8");
+        const content = fs65.readFileSync(fullPath, "utf-8");
         this.json(res, 200, { type: type2, path: filePath, content, lines: content.split("\n").length });
       }
       /** POST /api/providers/:type/file — write a file { path, content } */
@@ -150149,9 +150171,9 @@ data: ${JSON.stringify(msg.data)}
           return;
         }
         try {
-          if (fs64.existsSync(fullPath)) fs64.copyFileSync(fullPath, fullPath + ".bak");
-          fs64.mkdirSync(path62.dirname(fullPath), { recursive: true });
-          fs64.writeFileSync(fullPath, content, "utf-8");
+          if (fs65.existsSync(fullPath)) fs65.copyFileSync(fullPath, fullPath + ".bak");
+          fs65.mkdirSync(path62.dirname(fullPath), { recursive: true });
+          fs65.writeFileSync(fullPath, content, "utf-8");
           this.log(`File saved: ${fullPath} (${content.length} chars)`);
           this.providerLoader.reload();
           this.json(res, 200, { saved: true, path: filePath, chars: content.length });
@@ -150168,8 +150190,8 @@ data: ${JSON.stringify(msg.data)}
         }
         for (const name of ["scripts.js", "provider.json"]) {
           const p = path62.join(dir, name);
-          if (fs64.existsSync(p)) {
-            const source = fs64.readFileSync(p, "utf-8");
+          if (fs65.existsSync(p)) {
+            const source = fs65.readFileSync(p, "utf-8");
             this.json(res, 200, { type: type2, path: p, source, lines: source.split("\n").length });
             return;
           }
@@ -150188,11 +150210,11 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 404, { error: `Provider not found: ${type2}` });
           return;
         }
-        const target = fs64.existsSync(path62.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
+        const target = fs65.existsSync(path62.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
         const targetPath = path62.join(dir, target);
         try {
-          if (fs64.existsSync(targetPath)) fs64.copyFileSync(targetPath, targetPath + ".bak");
-          fs64.writeFileSync(targetPath, source, "utf-8");
+          if (fs65.existsSync(targetPath)) fs65.copyFileSync(targetPath, targetPath + ".bak");
+          fs65.writeFileSync(targetPath, source, "utf-8");
           this.log(`Saved provider: ${targetPath} (${source.length} chars)`);
           this.providerLoader.reload();
           this.json(res, 200, { saved: true, path: targetPath, chars: source.length });
@@ -150338,20 +150360,20 @@ data: ${JSON.stringify(msg.data)}
         let targetDir;
         targetDir = this.providerLoader.getUserProviderDir(category, type2);
         const jsonPath = path62.join(targetDir, "provider.json");
-        if (fs64.existsSync(jsonPath)) {
+        if (fs65.existsSync(jsonPath)) {
           this.json(res, 409, { error: `Provider already exists at ${targetDir}`, path: targetDir });
           return;
         }
         try {
           const result = generateFiles(type2, name, category, { cdpPorts, cli, processName, installPath, binary: binary2, extensionId, version: version2, osPaths, processNames });
-          fs64.mkdirSync(targetDir, { recursive: true });
-          fs64.writeFileSync(jsonPath, result["provider.json"], "utf-8");
+          fs65.mkdirSync(targetDir, { recursive: true });
+          fs65.writeFileSync(jsonPath, result["provider.json"], "utf-8");
           const createdFiles = ["provider.json"];
           if (result.files) {
             for (const [relPath, content] of Object.entries(result.files)) {
               const fullPath = path62.join(targetDir, relPath);
-              fs64.mkdirSync(path62.dirname(fullPath), { recursive: true });
-              fs64.writeFileSync(fullPath, content, "utf-8");
+              fs65.mkdirSync(path62.dirname(fullPath), { recursive: true });
+              fs65.writeFileSync(fullPath, content, "utf-8");
               createdFiles.push(relPath);
             }
           }
@@ -150400,10 +150422,10 @@ data: ${JSON.stringify(msg.data)}
       }
       // ─── Phase 2: Auto-Implement Backend ───
       getLatestScriptVersionDir(scriptsDir) {
-        if (!fs64.existsSync(scriptsDir)) return null;
-        const versions = fs64.readdirSync(scriptsDir).filter((d) => {
+        if (!fs65.existsSync(scriptsDir)) return null;
+        const versions = fs65.readdirSync(scriptsDir).filter((d) => {
           try {
-            return fs64.statSync(path62.join(scriptsDir, d)).isDirectory();
+            return fs65.statSync(path62.join(scriptsDir, d)).isDirectory();
           } catch {
             return false;
           }
@@ -150425,13 +150447,13 @@ data: ${JSON.stringify(msg.data)}
         if (!sourceDir) {
           return { dir: null, reason: `Provider source directory not found for '${type2}'` };
         }
-        if (!fs64.existsSync(desiredDir)) {
-          fs64.mkdirSync(path62.dirname(desiredDir), { recursive: true });
-          fs64.cpSync(sourceDir, desiredDir, { recursive: true });
+        if (!fs65.existsSync(desiredDir)) {
+          fs65.mkdirSync(path62.dirname(desiredDir), { recursive: true });
+          fs65.cpSync(sourceDir, desiredDir, { recursive: true });
           this.log(`Auto-implement writable copy created: ${desiredDir}`);
         }
         const providerJson = path62.join(desiredDir, "provider.json");
-        if (!fs64.existsSync(providerJson)) {
+        if (!fs65.existsSync(providerJson)) {
           return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
         }
         return { dir: desiredDir };
@@ -151240,7 +151262,7 @@ data: ${JSON.stringify(msg.data)}
       }
     }
     var import_child_process14 = require("child_process");
-    var fs65 = __toESM2(require("fs"));
+    var fs66 = __toESM2(require("fs"));
     var os35 = __toESM2(require("os"));
     var path63 = __toESM2(require("path"));
     var import_session_host_core14 = require_dist();
@@ -151267,7 +151289,7 @@ data: ${JSON.stringify(msg.data)}
           path63.resolve(__dirname, "../../vendor/session-host-daemon/index.js")
         ];
         for (const candidate of packagedCandidates) {
-          if (fs65.existsSync(candidate)) {
+          if (fs66.existsSync(candidate)) {
             return candidate;
           }
         }
@@ -151287,8 +151309,8 @@ data: ${JSON.stringify(msg.data)}
       function getPid() {
         try {
           const pidFile = getPidFile();
-          if (!fs65.existsSync(pidFile)) return null;
-          const pid = Number.parseInt(fs65.readFileSync(pidFile, "utf8").trim(), 10);
+          if (!fs66.existsSync(pidFile)) return null;
+          const pid = Number.parseInt(fs66.readFileSync(pidFile, "utf8").trim(), 10);
           return Number.isFinite(pid) ? pid : null;
         } catch {
           return null;
@@ -151338,7 +151360,7 @@ data: ${JSON.stringify(msg.data)}
         if (markerIndex === -1) return;
         const activePrefix = entry.slice(0, markerIndex);
         const candidates = resolveConptyPrebuildCandidates(activePrefix);
-        const found = candidates.find((candidate) => fs65.existsSync(candidate));
+        const found = candidates.find((candidate) => fs66.existsSync(candidate));
         if (!found) {
           throw new Error(
             `conpty.node missing at boot despite passing the install-time gate \u2014 likely deleted post-install (checked: ${candidates.join(", ")}). Every session-host spawn would crash requiring node-pty; refusing to spawn.`
@@ -151355,8 +151377,8 @@ data: ${JSON.stringify(msg.data)}
         let logFd = null;
         if (options.spawnStdio === "logfile") {
           const logDir = path63.join(instance().configDir, "logs");
-          fs65.mkdirSync(logDir, { recursive: true });
-          logFd = fs65.openSync(path63.join(logDir, "session-host.log"), "a");
+          fs66.mkdirSync(logDir, { recursive: true });
+          logFd = fs66.openSync(path63.join(logDir, "session-host.log"), "a");
           stdio = ["ignore", logFd, logFd];
         }
         const child = (0, import_child_process14.spawn)(nodeExecutable, [entry], {
@@ -151381,7 +151403,7 @@ data: ${JSON.stringify(msg.data)}
         if (typeof child?.unref === "function") child.unref();
         if (logFd !== null) {
           try {
-            fs65.closeSync(logFd);
+            fs66.closeSync(logFd);
           } catch {
           }
         }
@@ -151399,8 +151421,8 @@ data: ${JSON.stringify(msg.data)}
         const pidFile = getPidFile();
         let keepPidFile = false;
         try {
-          if (fs65.existsSync(pidFile)) {
-            const pid = Number.parseInt(fs65.readFileSync(pidFile, "utf8").trim(), 10);
+          if (fs66.existsSync(pidFile)) {
+            const pid = Number.parseInt(fs66.readFileSync(pidFile, "utf8").trim(), 10);
             if (Number.isFinite(pid) && pid !== process.pid) {
               const managed = isManagedPid(pid);
               if (managed) {
@@ -151420,7 +151442,7 @@ data: ${JSON.stringify(msg.data)}
         } finally {
           if (!keepPidFile) {
             try {
-              fs65.unlinkSync(pidFile);
+              fs66.unlinkSync(pidFile);
             } catch {
             }
           }
@@ -151456,7 +151478,7 @@ data: ${JSON.stringify(msg.data)}
         }
         if (!reported) return;
         if (pathsEquivalent(reported, currentEntry)) return;
-        const reportedExists = fs65.existsSync(reported);
+        const reportedExists = fs66.existsSync(reported);
         LOG2.warn(
           "SessionHost",
           `Reachable session-host reports it is running from ${reported}${reportedExists ? "" : " (which no longer exists)"}, but this install runs from ${currentEntry}. That host would fail every create_session loading node-pty from its own prefix; stopping it so a current one is spawned in its place.`
@@ -151684,8 +151706,8 @@ data: ${JSON.stringify(msg.data)}
           const res = await fetch(extension.vsixUrl);
           if (res.ok) {
             const buffer = Buffer.from(await res.arrayBuffer());
-            const fs67 = await import("fs");
-            fs67.writeFileSync(vsixPath, buffer);
+            const fs68 = await import("fs");
+            fs68.writeFileSync(vsixPath, buffer);
             return new Promise((resolve32) => {
               const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
               (0, import_child_process15.exec)(cmd, { timeout: 6e4 }, (error48, _stdout, stderr) => {
@@ -151749,6 +151771,7 @@ data: ${JSON.stringify(msg.data)}
     }
     init_cli_detector();
     init_build_info();
+    init_transcript_publisher();
     var SessionRegistry = class {
       bySessionId = /* @__PURE__ */ new Map();
       byManagerKey = /* @__PURE__ */ new Map();
@@ -151761,6 +151784,7 @@ data: ${JSON.stringify(msg.data)}
           target = { ...target, providerSessionId: priorProviderSessionId };
         }
         this.bySessionId.set(target.sessionId, target);
+        startTranscriptStatPolling(target.sessionId);
         if (target.cdpManagerKey) this.addIndex(this.byManagerKey, target.cdpManagerKey, target.sessionId);
         if (target.instanceKey) this.addIndex(this.byInstanceKey, target.instanceKey, target.sessionId);
         if (target.parentSessionId) this.addIndex(this.byParentSessionId, target.parentSessionId, target.sessionId);
@@ -151790,6 +151814,7 @@ data: ${JSON.stringify(msg.data)}
         const target = this.bySessionId.get(sessionId);
         if (!target) return;
         this.bySessionId.delete(sessionId);
+        stopTranscriptStatPolling(sessionId);
         if (target.cdpManagerKey) this.removeIndex(this.byManagerKey, target.cdpManagerKey, sessionId);
         if (target.instanceKey) this.removeIndex(this.byInstanceKey, target.instanceKey, sessionId);
         if (target.parentSessionId) this.removeIndex(this.byParentSessionId, target.parentSessionId, sessionId);
@@ -154034,6 +154059,18 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
             // `settle()` publishes it right after this pull returns.
             // Returning null here is therefore correct, not "nothing to
             // do" — see transcript-publisher.ts's `settle()`.
+            resolveSourcePath: (sessionId) => {
+              const session = sessionRegistry.get(sessionId);
+              if (!session) return null;
+              const provider = providerLoader.getMeta(session.providerType);
+              const nh = provider?.nativeHistory;
+              if (!nh?.source) return null;
+              return resolveJsonlSourcePath(nh.source, {
+                workspace: session.workspace,
+                providerSessionId: session.providerSessionId,
+                sessionStartedAtMs: session.spawnedAtMs
+              });
+            },
             collectObservation: async (sessionId) => {
               try {
                 await commandHandler.handle("read_chat", { targetSessionId: sessionId });
@@ -154494,7 +154531,7 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
       Object.values(V1_PRIMITIVE_CATALOG).flat()
     );
     var V1_CONTRACT_VERSION = "1.0.0";
-    var fs66 = __toESM2(require("fs"));
+    var fs67 = __toESM2(require("fs"));
     var import_chalk2 = __toESM2((init_source(), __toCommonJS(source_exports)));
     init_dist();
     var CLAUDE_NO_API_LINE = "Claude has no quota API \u2014 adhdev borrows your statusLine to read it.";
@@ -154649,7 +154686,7 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         console.log(import_chalk2.default.gray(`  Backup: ${status.paths.backupFile}`));
         let snapshotMtimeMs = null;
         try {
-          snapshotMtimeMs = fs66.statSync(status.paths.snapshotFile).mtimeMs;
+          snapshotMtimeMs = fs67.statSync(status.paths.snapshotFile).mtimeMs;
         } catch {
         }
         console.log(import_chalk2.default.gray(