@adhdev/daemon-standalone 1.0.49-rc.10 → 1.0.49-rc.12

package/dist/index.js

@@ -36552,8 +36552,8 @@ var require_dist3 = __commonJS({
     function isRecord(value) {
       return !!value && typeof value === "object" && !Array.isArray(value);
     }
-    function parseConfigText(path55, text) {
-      if (/\.json$/i.test(path55)) return JSON.parse(text);
+    function parseConfigText(path56, text) {
+      if (/\.json$/i.test(path56)) return JSON.parse(text);
       return yaml.load(text);
     }
     function normalizeOperatingNote(value) {
@@ -37056,10 +37056,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "85491e20f327dc51eb20e6b0674af0041e0c5f5e" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "85491e20" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.49-rc.10" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-14T23:22:28.218Z" : void 0);
+      const commit = readInjected(true ? "d20b4ad708551ef7198efd44a123bcb981b62fb1" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "d20b4ad7" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.49-rc.12" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-15T07:08:42.502Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -37131,8 +37131,8 @@ var require_dist3 = __commonJS({
       }
       return { valid: errors.length === 0, errors, config: errors.length === 0 ? config2 : void 0 };
     }
-    function parseConfigText2(path55, text) {
-      if (/\.json$/i.test(path55)) return JSON.parse(text);
+    function parseConfigText2(path56, text) {
+      if (/\.json$/i.test(path56)) return JSON.parse(text);
       return yaml2.load(text);
     }
     function loadChangeImpactConfig(repoRoot) {
@@ -37833,20 +37833,20 @@ var require_dist3 = __commonJS({
       try {
         const paths = await readSubmodulePaths(repo, options);
         const ignoreSet = new Set(options.submoduleIgnorePaths || []);
-        const visiblePaths = paths.filter((path55) => !ignoreSet.has(path55));
+        const visiblePaths = paths.filter((path56) => !ignoreSet.has(path56));
         const expectedByPath = await readGitlinkExpectedShas(repo, visiblePaths, options);
         const lastCheckedAt = Date.now();
         const headOidByPath = /* @__PURE__ */ new Map();
         const submodules = await Promise.all(
-          visiblePaths.map(async (path55) => {
-            const repoPath = repo.repoRoot + "/" + path55;
-            const expected = expectedByPath.get(path55) ?? null;
+          visiblePaths.map(async (path56) => {
+            const repoPath = repo.repoRoot + "/" + path56;
+            const expected = expectedByPath.get(path56) ?? null;
             const worktree = await readSubmoduleWorktreeStatus(repo, repoPath, options);
             const actual = worktree.headOid;
-            if (actual) headOidByPath.set(path55, actual);
+            if (actual) headOidByPath.set(path56, actual);
             const outOfSync = actual === null ? true : expected !== null && expected !== actual;
             return {
-              path: path55,
+              path: path56,
               // Prefer the recorded gitlink SHA (matches the legacy column); fall back
               // to the checked-out SHA so the field is never empty when both are known.
               commit: expected ?? actual ?? "",
@@ -40501,6 +40501,13 @@ child.on('exit', () => process.exit(0));
       if (typeof retryAtMs !== "number" || retryAtMs > now) return false;
       return (failureRetries.get(provider)?.failures ?? 0) <= QUOTA_FAILURE_MAX_RETRIES;
     }
+    function isSnapshotStaleForRouting(provider, now = Date.now()) {
+      const entry = cache.get(provider);
+      if (!entry) return false;
+      const updatedAt = Number(entry.updatedAt);
+      if (!Number.isFinite(updatedAt) || updatedAt <= 0) return true;
+      return now - updatedAt >= QUOTA_ROUTABLE_MAX_AGE_MS;
+    }
     function updateFailureRetry(provider, fetch2, isEnabled) {
       const entry = cache.get(provider);
       const retryAtMs = entry && entry.status !== "ok" ? entry.metadata?.retryAtMs : void 0;
@@ -40551,7 +40558,7 @@ child.on('exit', () => process.exit(0));
         } catch {
           active = false;
         }
-        const needsBackfill = options.isEnabled ? fetchers.some(({ provider }) => options.isEnabled(provider) && (!cache.has(provider) || isFailureRetryDue(provider))) : false;
+        const needsBackfill = options.isEnabled ? fetchers.some(({ provider }) => options.isEnabled(provider) && (!cache.has(provider) || isFailureRetryDue(provider) || isSnapshotStaleForRouting(provider))) : false;
         if (!active && !needsBackfill) return;
         running = true;
         void refreshQuotaCacheOnce(fetchers, options.isEnabled).catch((e) => LOG2.warn("Quota", `Quota refresh tick error: ${e?.message || e}`)).finally(() => {
@@ -40613,6 +40620,7 @@ child.on('exit', () => process.exit(0));
     var hydrated;
     var QUOTA_FAILURE_MAX_RETRIES;
     var failureRetries;
+    var QUOTA_ROUTABLE_MAX_AGE_MS;
     var WORKING_STATUSES;
     var bootRefreshInFlight;
     var QUOTA_EVENT_REFRESH_DEBOUNCE_MS;
@@ -40639,6 +40647,7 @@ child.on('exit', () => process.exit(0));
         hydrated = false;
         QUOTA_FAILURE_MAX_RETRIES = 4;
         failureRetries = /* @__PURE__ */ new Map();
+        QUOTA_ROUTABLE_MAX_AGE_MS = 30 * 60 * 1e3;
         WORKING_STATUSES = /* @__PURE__ */ new Set([
           "generating",
           "waiting_approval",
@@ -40839,11 +40848,11 @@ child.on('exit', () => process.exit(0));
     }
     function windowsExtraBinDirs() {
       const dirs = [];
-      const fs57 = require("fs");
+      const fs58 = require("fs");
       const push = (dir) => {
         if (!dir) return;
         try {
-          if (fs57.existsSync(dir)) dirs.push(dir);
+          if (fs58.existsSync(dir)) dirs.push(dir);
         } catch {
         }
       };
@@ -40859,12 +40868,12 @@ child.on('exit', () => process.exit(0));
     }
     function unixExtraBinDirs() {
       const dirs = [];
-      const fs57 = require("fs");
+      const fs58 = require("fs");
       const home = os42.homedir();
       const push = (dir) => {
         if (!dir) return;
         try {
-          if (fs57.existsSync(dir)) dirs.push(dir);
+          if (fs58.existsSync(dir)) dirs.push(dir);
         } catch {
         }
       };
@@ -40903,9 +40912,9 @@ child.on('exit', () => process.exit(0));
         for (const ext of exes) {
           const fullPath = path8.join(p, trimmed + ext);
           try {
-            const fs57 = require("fs");
-            if (fs57.existsSync(fullPath)) {
-              const stat2 = fs57.statSync(fullPath);
+            const fs58 = require("fs");
+            if (fs58.existsSync(fullPath)) {
+              const stat2 = fs58.statSync(fullPath);
               if (stat2.isFile() && (isWin || stat2.mode & 73)) {
                 return fullPath;
               }
@@ -40919,12 +40928,12 @@ child.on('exit', () => process.exit(0));
     function isScriptBinary(binaryPath) {
       if (!path8.isAbsolute(binaryPath)) return false;
       try {
-        const fs57 = require("fs");
-        const resolved = fs57.realpathSync(binaryPath);
+        const fs58 = require("fs");
+        const resolved = fs58.realpathSync(binaryPath);
         const head = Buffer.alloc(8);
-        const fd = fs57.openSync(resolved, "r");
-        fs57.readSync(fd, head, 0, 8, 0);
-        fs57.closeSync(fd);
+        const fd = fs58.openSync(resolved, "r");
+        fs58.readSync(fd, head, 0, 8, 0);
+        fs58.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;
@@ -40935,12 +40944,12 @@ child.on('exit', () => process.exit(0));
     function looksLikeMachOOrElf(filePath) {
       if (!path8.isAbsolute(filePath)) return false;
       try {
-        const fs57 = require("fs");
-        const resolved = fs57.realpathSync(filePath);
+        const fs58 = require("fs");
+        const resolved = fs58.realpathSync(filePath);
         const buf = Buffer.alloc(8);
-        const fd = fs57.openSync(resolved, "r");
-        fs57.readSync(fd, buf, 0, 8, 0);
-        fs57.closeSync(fd);
+        const fd = fs58.openSync(resolved, "r");
+        fs58.readSync(fd, buf, 0, 8, 0);
+        fs58.closeSync(fd);
         let i = 0;
         if (buf[0] === 239 && buf[1] === 187 && buf[2] === 191) i = 3;
         const b = buf.subarray(i);
@@ -42369,12 +42378,12 @@ ${error48.message || ""}`;
       if (!Array.isArray(value)) return void 0;
       const submodules = value.map((entry) => {
         const submodule = readRecord(entry);
-        const path55 = readString2(submodule.path);
+        const path56 = readString2(submodule.path);
         const commit = readString2(submodule.commit);
-        const repoPath = readString2(submodule.repoPath, submodule.repo_root) ?? joinRepoPath(parentRepoRoot, path55);
-        if (!path55 || !commit) return null;
+        const repoPath = readString2(submodule.repoPath, submodule.repo_root) ?? joinRepoPath(parentRepoRoot, path56);
+        if (!path56 || !commit) return null;
         const result = {
-          path: path55,
+          path: path56,
           commit,
           dirty: readBoolean(submodule.dirty) ?? false,
           outOfSync: readBoolean(submodule.outOfSync, submodule.out_of_sync) ?? false,
@@ -42956,6 +42965,7 @@ ${error48.message || ""}`;
           "mesh_status",
           "mesh_list_nodes",
           "mesh_enqueue_task",
+          "mesh_enqueue_batch",
           "mesh_view_queue",
           "mesh_queue_cancel",
           "mesh_queue_requeue",
@@ -43149,10 +43159,10 @@ ${error48.message || ""}`;
       return (0, import_path5.join)(getConfigDir2(), "meshes.json");
     }
     function loadMeshConfig(options = {}) {
-      const path55 = getMeshConfigPath();
-      if (!(0, import_fs5.existsSync)(path55)) return { meshes: [] };
+      const path56 = getMeshConfigPath();
+      if (!(0, import_fs5.existsSync)(path56)) return { meshes: [] };
       try {
-        const raw = JSON.parse((0, import_fs5.readFileSync)(path55, "utf-8"));
+        const raw = JSON.parse((0, import_fs5.readFileSync)(path56, "utf-8"));
         if (!raw || !Array.isArray(raw.meshes)) return { meshes: [] };
         const config2 = raw;
         const migrated = migrateLoadedMeshConfig(config2);
@@ -43250,8 +43260,8 @@ ${error48.message || ""}`;
       return tags.length ? tags : void 0;
     }
     function saveMeshConfig(config2) {
-      const path55 = getMeshConfigPath();
-      (0, import_fs5.writeFileSync)(path55, JSON.stringify(config2, null, 2), { encoding: "utf-8", mode: 384 });
+      const path56 = getMeshConfigPath();
+      (0, import_fs5.writeFileSync)(path56, JSON.stringify(config2, null, 2), { encoding: "utf-8", mode: 384 });
     }
     function normalizeRepoIdentity(remoteUrl) {
       let identity = remoteUrl.trim().replace(/[?#].*$/, "").replace(/\/+$/, "");
@@ -43259,8 +43269,8 @@ ${error48.message || ""}`;
       if (/^[a-z][a-z0-9+.-]*:\/\//i.test(identity)) {
         try {
           const url2 = new URL(identity);
-          const path55 = decodeURIComponent(url2.pathname).replace(/^\/+|\/+$/g, "").replace(/\.git$/i, "");
-          if (url2.hostname && path55) return `${url2.hostname.toLowerCase()}/${path55}`;
+          const path56 = decodeURIComponent(url2.pathname).replace(/^\/+|\/+$/g, "").replace(/\.git$/i, "");
+          if (url2.hostname && path56) return `${url2.hostname.toLowerCase()}/${path56}`;
         } catch {
         }
       }
@@ -45918,59 +45928,59 @@ Next step: ${nextStep}`;
     function isNonEmptyString(value) {
       return typeof value === "string" && value.length > 0;
     }
-    function assertCoordinatorIdentity(raw, path55) {
+    function assertCoordinatorIdentity(raw, path56) {
       if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, path55, "must be an object");
+        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, path56, "must be an object");
       }
       const obj = raw;
       if (!isNonEmptyString(obj.daemonId)) {
-        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path55}.daemonId`, "must be a non-empty string");
+        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path56}.daemonId`, "must be a non-empty string");
       }
       if (!isNonEmptyString(obj.coordinatorRunId)) {
-        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path55}.coordinatorRunId`, "must be a non-empty string");
+        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path56}.coordinatorRunId`, "must be a non-empty string");
       }
       const sessionId = obj.sessionId;
       if (sessionId !== void 0 && !isNonEmptyString(sessionId)) {
-        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path55}.sessionId`, "must be a non-empty string when provided");
+        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path56}.sessionId`, "must be a non-empty string when provided");
       }
       return sessionId !== void 0 ? { daemonId: obj.daemonId, coordinatorRunId: obj.coordinatorRunId, sessionId } : { daemonId: obj.daemonId, coordinatorRunId: obj.coordinatorRunId };
     }
-    function assertPendingMeshCoordinatorEventV2(raw, path55 = "$") {
+    function assertPendingMeshCoordinatorEventV2(raw, path56 = "$") {
       if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, path55, "must be an object");
+        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, path56, "must be an object");
       }
       const obj = raw;
       if (!isSupportedMeshProtocolVersion(obj.protocolVersion)) {
-        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path55}.protocolVersion`, `must be one of ${SUPPORTED_MESH_PROTOCOL_VERSIONS.join(", ")}`);
+        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path56}.protocolVersion`, `must be one of ${SUPPORTED_MESH_PROTOCOL_VERSIONS.join(", ")}`);
       }
       if (!isNonEmptyString(obj.eventId)) {
-        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path55}.eventId`, "must be a non-empty string");
+        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path56}.eventId`, "must be a non-empty string");
       }
       if (!isMeshEventScope(obj.scope)) {
-        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path55}.scope`, `must be one of ${MESH_EVENT_SCOPES.join(", ")}`);
+        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path56}.scope`, `must be one of ${MESH_EVENT_SCOPES.join(", ")}`);
       }
       if (!isNonEmptyString(obj.event)) {
-        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path55}.event`, "must be a non-empty string");
+        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path56}.event`, "must be a non-empty string");
       }
       if (!isNonEmptyString(obj.meshId)) {
-        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path55}.meshId`, "must be a non-empty string");
+        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path56}.meshId`, "must be a non-empty string");
       }
-      const dispatchedBy = assertCoordinatorIdentity(obj.dispatchedBy, `${path55}.dispatchedBy`);
+      const dispatchedBy = assertCoordinatorIdentity(obj.dispatchedBy, `${path56}.dispatchedBy`);
       if (obj.scope === "unicast") {
         if (!obj.intendedFor) {
-          throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path55}.intendedFor`, "unicast scope requires intendedFor");
+          throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path56}.intendedFor`, "unicast scope requires intendedFor");
         }
       } else if (obj.intendedFor !== void 0) {
-        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path55}.intendedFor`, "only unicast scope may set intendedFor");
+        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path56}.intendedFor`, "only unicast scope may set intendedFor");
       }
-      const intendedFor = obj.intendedFor ? assertCoordinatorIdentity(obj.intendedFor, `${path55}.intendedFor`) : void 0;
+      const intendedFor = obj.intendedFor ? assertCoordinatorIdentity(obj.intendedFor, `${path56}.intendedFor`) : void 0;
       const metadata = obj.metadataEvent && typeof obj.metadataEvent === "object" && !Array.isArray(obj.metadataEvent) ? obj.metadataEvent : null;
       if (!metadata) {
-        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path55}.metadataEvent`, "must be an object");
+        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path56}.metadataEvent`, "must be an object");
       }
       const queuedAt = typeof obj.queuedAt === "number" && Number.isFinite(obj.queuedAt) ? obj.queuedAt : null;
       if (queuedAt === null) {
-        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path55}.queuedAt`, "must be a finite number");
+        throw new MeshContractViolationError(MESH_PROTOCOL_VERSION_V2, `${path56}.queuedAt`, "must be a finite number");
       }
       return {
         event: obj.event,
@@ -47159,6 +47169,7 @@ Next step: ${nextStep}`;
     __export2(mesh_work_queue_exports, {
       ACTIVE_MESH_QUEUE_STATUSES: () => ACTIVE_MESH_QUEUE_STATUSES,
       HISTORICAL_MESH_QUEUE_STATUSES: () => HISTORICAL_MESH_QUEUE_STATUSES,
+      MESH_TASK_GRAPH_MAX_TASKS: () => MESH_TASK_GRAPH_MAX_TASKS,
       MESH_TASK_MODES: () => MESH_TASK_MODES,
       MESH_TASK_PRIORITIES: () => MESH_TASK_PRIORITIES,
       NOT_BEFORE_RELATIVE_THRESHOLD_MS: () => NOT_BEFORE_RELATIVE_THRESHOLD_MS,
@@ -47177,6 +47188,7 @@ Next step: ${nextStep}`;
       deleteDirectDispatchesByTaskId: () => deleteDirectDispatchesByTaskId,
       describeTaskDependencyState: () => describeTaskDependencyState,
       enqueueTask: () => enqueueTask,
+      enqueueTaskGraph: () => enqueueTaskGraph,
       expireTaskTargetPin: () => expireTaskTargetPin,
       formatMeshTaskModeViolations: () => formatMeshTaskModeViolations,
       getActiveDirectDispatches: () => getActiveDirectDispatches,
@@ -47564,11 +47576,11 @@ Next step: ${nextStep}`;
       const pinnedProvider = typeof providerType === "string" && providerType.trim() ? providerType.trim() : void 0;
       const providerTags = pinnedProvider ? [pinnedProvider] : readNodeProviderTypes(node?.policy);
       const worktreeBranch = typeof node?.worktreeBranch === "string" && node.worktreeBranch.trim() ? node.worktreeBranch.trim() : null;
-      const os30 = readNodeOverride(node, "platform") ?? readNodeReporter(node, "platform") ?? process.platform;
+      const os31 = readNodeOverride(node, "platform") ?? readNodeReporter(node, "platform") ?? process.platform;
       const arch2 = readNodeOverride(node, "arch") ?? readNodeReporter(node, "arch") ?? process.arch;
       return normalizeMeshCapabilityTags([
         ...Array.isArray(node?.capabilities) ? node.capabilities : [],
-        `os=${os30}`,
+        `os=${os31}`,
         `arch=${arch2}`,
         ...providerTags.map((p) => `provider=${p}`),
         // Worktree nodes automatically expose a "worktree=<branch>" tag so that
@@ -47735,6 +47747,48 @@ Next step: ${nextStep}`;
       scheduleMissionCloseCandidateCheck(meshId, [result]);
       return result;
     }
+    function enqueueTaskGraph(meshId, specs, opts) {
+      requireMeshHostQueueOwner(opts);
+      if (!Array.isArray(specs) || specs.length === 0) {
+        throw new Error("empty_task_graph: enqueueTaskGraph requires at least one task spec");
+      }
+      if (specs.length > MESH_TASK_GRAPH_MAX_TASKS) {
+        throw new Error(`task_graph_too_large: ${specs.length} tasks exceeds the ${MESH_TASK_GRAPH_MAX_TASKS}-task cap for one atomic enqueue`);
+      }
+      const ids = specs.map(() => (0, import_crypto8.randomUUID)());
+      const idByRef = /* @__PURE__ */ new Map();
+      specs.forEach((spec, i) => {
+        const ref = typeof spec.ref === "string" ? spec.ref.trim() : "";
+        if (!ref) return;
+        if (idByRef.has(ref)) {
+          throw new Error(`duplicate_task_ref: ref '${ref}' is used by more than one task in this batch`);
+        }
+        idByRef.set(ref, ids[i]);
+      });
+      const store = MeshRuntimeStore.getInstance();
+      return withQueueLock(meshId, () => {
+        const inserted = [];
+        specs.forEach((spec, i) => {
+          const { ref, message, ...taskOpts } = spec;
+          const label = ref ? `'${ref}'` : `#${i}`;
+          const dependsOn = normalizeDependsOn(spec.dependsOn).map((dep) => {
+            const mapped = idByRef.get(dep);
+            if (mapped) return mapped;
+            if (store.findQueueEntryById(meshId, dep)) return dep;
+            throw new Error(
+              `unknown_dependency: task ${label} depends on '${dep}', which is neither a ref in this batch nor an existing task id` + (idByRef.size ? ` (batch refs: ${[...idByRef.keys()].join(", ")})` : "")
+            );
+          });
+          inserted.push(enqueueTask(meshId, message, {
+            ...taskOpts,
+            dependsOn,
+            id: ids[i],
+            ...opts?.ownerRole ? { ownerRole: opts.ownerRole } : {}
+          }));
+        });
+        return inserted;
+      });
+    }
     function recordDirectDispatchTask(meshId, message, opts) {
       const missionId = typeof opts.missionId === "string" ? opts.missionId.trim() : "";
       const taskId = typeof opts.id === "string" ? opts.id.trim() : "";
@@ -48186,6 +48240,7 @@ Next step: ${nextStep}`;
     var EVIDENCE_ONLY_WRAPPERS;
     var GIT_MUTATION_SUBCOMMANDS;
     var GIT_STASH_READONLY_SUBCOMMANDS;
+    var MESH_TASK_GRAPH_MAX_TASKS;
     var DEPENDENCY_FAILURE_TERMINALS;
     var TERMINAL_TASK_STATUSES;
     var lastCancelledTaskAssignment;
@@ -48262,6 +48317,7 @@ Next step: ${nextStep}`;
           "prune"
         ]);
         GIT_STASH_READONLY_SUBCOMMANDS = /* @__PURE__ */ new Set(["list", "show"]);
+        MESH_TASK_GRAPH_MAX_TASKS = 50;
         DEPENDENCY_FAILURE_TERMINALS = /* @__PURE__ */ new Set(["failed", "cancelled"]);
         TERMINAL_TASK_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
         lastCancelledTaskAssignment = /* @__PURE__ */ new Map();
@@ -49041,10 +49097,10 @@ Next step: ${nextStep}`;
             this.migratedMeshIds.add(meshId);
             const count = this.db.prepare("SELECT COUNT(*) AS count FROM mesh_queue WHERE mesh_id = ?").get(meshId);
             if (count.count > 0) return;
-            const path55 = legacyQueuePath(meshId);
-            if (!(0, import_fs6.existsSync)(path55)) return;
+            const path56 = legacyQueuePath(meshId);
+            if (!(0, import_fs6.existsSync)(path56)) return;
             try {
-              const entries = JSON.parse((0, import_fs6.readFileSync)(path55, "utf-8"));
+              const entries = JSON.parse((0, import_fs6.readFileSync)(path56, "utf-8"));
               if (!Array.isArray(entries)) return;
               const insert = this.db.prepare(`
                 INSERT OR REPLACE INTO mesh_queue (
@@ -51176,10 +51232,10 @@ Next step: ${nextStep}`;
       }
     }
     function readArchivedCounts(meshId) {
-      const path55 = getArchivedCountsPath(meshId);
-      if (!(0, import_fs7.existsSync)(path55)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
+      const path56 = getArchivedCountsPath(meshId);
+      if (!(0, import_fs7.existsSync)(path56)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
       try {
-        return JSON.parse((0, import_fs7.readFileSync)(path55, "utf-8"));
+        return JSON.parse((0, import_fs7.readFileSync)(path56, "utf-8"));
       } catch {
         return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
       }
@@ -52629,7 +52685,7 @@ ${rules.join("\n")}`;
 - **Match concurrency to task kind.** Read-only investigation (\`live_debug_readonly\`) carries no isolation or merge cost and is exempt from the one-write-per-node limit: dispatch every independent read-only task at once, up to the read-only cap shown in Policy \u2014 they need neither a free node nor a worktree. Write tasks (\`code_change\`) are limited to ONE active task per node and each needs its OWN branch workspace, so clone a worktree per write task rather than queueing them onto one node \u2014 **or spreading them across base nodes, which is NOT a substitute**: a mesh with four base nodes still has zero branch isolation, because each base node is one shared checkout of the same branch. Ramp up cautiously only when tasks share a base branch or a submodule pointer, where landing order actually matters. Never launch a second session onto work already in flight for the same issue, and never duplicate a session because \`mesh_read_chat\` shows no final message while tool/terminal activity is ongoing. All of this is about *unrelated* work running side by side; it does not mean splitting one line of work across sessions \u2014 successive stages of the same investigation belong in the session that already has the context (see Workflow 3f).
 - **Check history first.** Call \`mesh_task_history\` at session start to avoid duplicate work and inform recovery. On failure, read task history before retrying.
 - **Don't reopen already-done work after a resume.** Before reopening a reported issue after context compaction or session resume, check current git state and recent session context. If another session has already completed the work, continue from the existing diff/commit instead of starting a duplicate investigation.
-- **Sequence shared-base-moving merges.** Parallel dispatch is encouraged, but merging one worktree can advance another in-flight worktree's base \u2014 especially a shared submodule pointer \u2014 turning a clean fast-forward into a diverged rebase (patch-equivalence correctly blocks this). Before merging an in-flight worktree while siblings are also in flight, land in an intentional order, re-clone long-running worktrees from the advanced base, or expect to manually rebase + ff-only the laggards; merging an independent fix mid-flight can strand siblings into a rebase.
+- **Sequence shared-base-moving merges \u2014 use \`mesh_refine_batch\` for two or more.** Merging one worktree advances another in-flight worktree's base \u2014 especially a shared submodule pointer \u2014 turning a clean fast-forward into a diverged rebase. When you have 2+ sibling worktrees to land, pass them to \`mesh_refine_batch\` (dry-run first) instead of calling \`mesh_refine_node\` once per node: it picks a conflict-aware order (non-submodule first, submodule-touching serialized last), and because each node re-resolves the base and auto-rebases before its own gates, siblings that fall behind are rebased for you rather than by hand. It also avoids the \`base_locked\` contention that concurrent single-node refines cause. It is not a conflict solver \u2014 a real content or submodule conflict still lands that node in \`blocked_review\` for manual resolution while the rest of the batch proceeds. Only drop to per-node \`mesh_refine_node\` for a single branch, or to hand-resolve a node the batch reported blocked.
 - **Converge branches.** After worktree tasks: refine/fast-forward, or classify as \`pushed_feature_branch_needs_merge\` / \`blocked_review\` / \`cleanup_candidate\` / \`not_mergeable\`. Clean up with \`mesh_remove_node\`.
 - **Refinery is config-driven.** \`mesh_refine_node\` must run validation from \`.adhdev/refine.{json,yaml,yml}\` or \`repo-mesh.refine.*\`. Heuristics are scaffolding only.
 - **Submodule reachability = publish-needed.** \`submodule_reachability_failed\` \u2192 classify as \`blocked_review\`, request user approval to push to submodule main, then rerun \`mesh_refine_node\`.
@@ -52679,6 +52735,7 @@ When you compose the task message you dispatch to a node, include this requireme
 | \`mesh_status\` | Check all nodes' health, git state, active sessions, and branch convergence |
 | \`mesh_list_nodes\` | List nodes with workspace paths |
 | \`mesh_enqueue_task\` | Add a task to the pull-based work queue; idle nodes auto-claim |
+| \`mesh_enqueue_batch\` | Atomically enqueue a dependency-wired SET of tasks (all-or-nothing \u2014 a mid-batch error rolls the whole batch back); \`depends_on\` may name batch-local \`ref\` labels, forward references allowed |
 | \`mesh_view_queue\` | View queue status \u2014 pending, assigned, completed, failed, cancelled tasks |
 | \`mesh_queue_cancel\` | Cancel a queue task without deleting audit history |
 | \`mesh_queue_requeue\` | Return a task to pending for retry; clears stale session targets |
@@ -52736,7 +52793,7 @@ Before doing any coordinator work, confirm that the actual callable tool list in
         WORKFLOW_SECTION = `## Orchestration Workflow
 
 1. **Assess** \u2014 Call \`mesh_status\` to see which nodes are healthy and available. Check \`mesh_task_history\` to understand what has already been done in this mesh \u2014 previous delegations, completions, and failures.
-2. **Plan** \u2014 Decompose the user's request into independent tasks for parallel execution, or sequential tasks when dependencies exist. If \`mesh_task_history\` shows a recent failure for a task, decide whether to retry or reassign. **For multi-task work, create a mission first**: call \`mesh_mission_upsert\` with a title and goal, then attach every enqueued task with \`mission_id\`. Express "B after A" ordering with \`depends_on\` on the queue task instead of waiting and polling \u2014 the system claims dependents automatically when their dependencies complete. When the mission's outcome is decided, update its status (\`completed\`/\`abandoned\`) via \`mesh_mission_upsert\`. If the prompt already shows an **Active Mission**, continue it from its current task state \u2014 do not re-enqueue tasks that already exist.
+2. **Plan** \u2014 Decompose the user's request into independent tasks for parallel execution, or sequential tasks when dependencies exist. If \`mesh_task_history\` shows a recent failure for a task, decide whether to retry or reassign. **For multi-task work, create a mission first**: call \`mesh_mission_upsert\` with a title and goal, then attach every enqueued task with \`mission_id\`. Express "B after A" ordering with \`depends_on\` on the queue task instead of waiting and polling \u2014 the system claims dependents automatically when their dependencies complete. When the plan is a multi-task graph, submit it with ONE \`mesh_enqueue_batch\` call instead of N sequential enqueues: the batch inserts atomically (a mid-batch error such as a cycle or bad difficulty rolls the whole set back, so no half-registered chain), and each task's \`depends_on\` may name sibling tasks by their batch-local \`ref\` label, forward references included. When the mission's outcome is decided, update its status (\`completed\`/\`abandoned\`) via \`mesh_mission_upsert\`. If the prompt already shows an **Active Mission**, continue it from its current task state \u2014 do not re-enqueue tasks that already exist.
 3. **Queue / Delegate** \u2014 The Mesh uses an autonomous pull-based Work Queue:
    a. **General Tasks**: Enqueue tasks using \`mesh_enqueue_task\`. Idle node agents will automatically pull tasks from the queue and begin working.
    b. **Node Preparation**: Reuse an existing idle session on the correct node/provider before launching a new chat/session. Call \`mesh_launch_session\` only when no suitable session exists, when the user explicitly asks for a fresh provider/session, or when branch/worktree isolation requires it. **A node is not limited to one live session for read-only work** \u2014 \`readonly\`/\`live_debug_readonly\` tasks are exempt from the one-active-per-node invariant, so the SAME node can auto-launch multiple concurrent read-only sessions with no worktree needed. Cloning a worktree costs roughly 10 seconds, so it is cheap enough to create one whenever write work needs a free node; use it for branch isolation, for parallel write tasks (one active write per node), or when a node's read-only queue is deep enough that a second node would clearly finish faster \u2014 call \`mesh_clone_node\` to create the worktree node first.
@@ -52753,7 +52810,7 @@ Before doing any coordinator work, confirm that the actual callable tool list in
 4. **Monitor** \u2014 Prefer event-driven completion/status notifications. Do **not** poll \`mesh_read_chat\` repeatedly. Do **not** repeatedly call \`mesh_status\` or \`mesh_view_queue\` just to wait for assigned/generating work. After dispatching a direct or queued task, send one progress update with the task/session handle, then stop. Wait for \`pendingCoordinatorEvents\` or another completion/approval/status signal, an explicit user status request, or a real timeout/stall signal before reading status/chat/queue again. Use at most one compact \`mesh_read_chat\` check after a terminal signal. Handle approvals via \`mesh_approve\`. **Proactively parallelize new work.** When the user reports a new bug or asks for new work, start it immediately if it is independent of in-flight tasks and there is headroom under \`maxParallelTasks\` \u2014 do not wait for a current task to finish or for the user to prompt you to parallelize. Read-only diagnosis (\`live_debug_readonly\`) has no isolation or merge cost, so dispatch it in parallel right away. The no-polling / concurrency-limit rules constrain *re-checking or duplicating already-dispatched work*; they are **not** a reason to defer starting a new, independent task.
 5. **Verify** \u2014 When a task reports completion or git work is visible, call \`mesh_git_status\` to verify changes were made.
 6. **Checkpoint** \u2014 Call \`mesh_checkpoint\` to save the work.
-7. **Converge branches** \u2014 Before marking any task complete, classify every touched node/branch into exactly one final state: \`merged_to_main\`, \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\`. Use \`mesh_status\` branchConvergenceSummary. For obvious clean branch catch-up (ahead 0, behind > 0, upstream fresh, no dirty/stash/submodule issues), use \`mesh_fast_forward_node\` dry-run first and execute only when explicitly safe/approved; this avoids consuming an agent session. Use \`mesh_refine_node\` for clean worktree branches when safe. Before/refine merging root commits that contain submodule gitlink changes, require each submodule commit to be reachable from the configured submodule remote main branch, not merely present on a feature ref or local checkout. If \`mesh_refine_node\` returns \`submodule_reachability_failed\` or publish-required evidence, keep the public convergence bucket as \`blocked_review\`; unless \`allowAutoPublishSubmoduleMainCommits\` is explicitly enabled and Refinery reports successful non-force publish plus post-publish verification, ask the user for explicit approval to push/publish the unreachable submodule commit(s) to submodule main, then rerun \`mesh_refine_node\`. Do not merge the root branch until the submodule commit(s) are reachable from submodule origin/main. A task that remains on a non-main branch is not fully complete unless the final report names the follow-up state and next step.
+7. **Converge branches** \u2014 Before marking any task complete, classify every touched node/branch into exactly one final state: \`merged_to_main\`, \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\`. Use \`mesh_status\` branchConvergenceSummary. For obvious clean branch catch-up (ahead 0, behind > 0, upstream fresh, no dirty/stash/submodule issues), use \`mesh_fast_forward_node\` dry-run first and execute only when explicitly safe/approved; this avoids consuming an agent session. Use \`mesh_refine_node\` for clean worktree branches when safe \u2014 but when 2+ sibling worktrees share a base, converge them with \`mesh_refine_batch\` rather than repeated single-node calls (see the sequencing rule in Rules). Before/refine merging root commits that contain submodule gitlink changes, require each submodule commit to be reachable from the configured submodule remote main branch, not merely present on a feature ref or local checkout. If \`mesh_refine_node\` returns \`submodule_reachability_failed\` or publish-required evidence, keep the public convergence bucket as \`blocked_review\`; unless \`allowAutoPublishSubmoduleMainCommits\` is explicitly enabled and Refinery reports successful non-force publish plus post-publish verification, ask the user for explicit approval to push/publish the unreachable submodule commit(s) to submodule main, then rerun \`mesh_refine_node\`. Do not merge the root branch until the submodule commit(s) are reachable from submodule origin/main. A task that remains on a non-main branch is not fully complete unless the final report names the follow-up state and next step.
 8. **Clean up** \u2014 Remove worktree nodes via \`mesh_remove_node\` after their work is merged or no longer needed.
 9. **Report** \u2014 Summarize what was done, what changed, any issues, and the branch convergence state.
 
@@ -53238,8 +53295,8 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
       if (rejectedCommands.length) errors.push("one or more validation commands are invalid");
       return { valid: errors.length === 0, errors, bootstrapCommands, commands, rejectedCommands, bootstrapMode, deprecationWarnings };
     }
-    function parseConfigText3(path55, text) {
-      if (/\.json$/i.test(path55)) return JSON.parse(text);
+    function parseConfigText3(path56, text) {
+      if (/\.json$/i.test(path56)) return JSON.parse(text);
       return yaml3.load(text);
     }
     function loadMeshRefineConfig(mesh, workspace) {
@@ -53665,8 +53722,8 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
       const lines = porcelain.split(/\r?\n/).filter((line) => line.length > 0);
       for (const line of lines) {
         const status = line.slice(0, 2);
-        const path55 = line.slice(3).trim().replace(/\\/g, "/").replace(/\/+$/, "");
-        const isGitlinkPointerMove = (status === " M" || status === "M ") && submodulePaths.has(path55);
+        const path56 = line.slice(3).trim().replace(/\\/g, "/").replace(/\/+$/, "");
+        const isGitlinkPointerMove = (status === " M" || status === "M ") && submodulePaths.has(path56);
         if (!isGitlinkPointerMove) return false;
       }
       return true;
@@ -53701,8 +53758,8 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
       if (node?.worktreeBootstrap?.status !== "running") return false;
       return !isWorktreeBootstrapStaleRunning(node, nowMs);
     }
-    function parseConfigText4(path55, text) {
-      if (/\.json$/i.test(path55)) return JSON.parse(text);
+    function parseConfigText4(path56, text) {
+      if (/\.json$/i.test(path56)) return JSON.parse(text);
       return yaml4.load(text);
     }
     function truncateOutput(value) {
@@ -54056,8 +54113,8 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
       }
       const serverName = mcpConfig.serverName?.trim() || DEFAULT_SERVER_NAME;
       if (mcpConfig.mode === "auto_import") {
-        const path55 = mcpConfig.path?.trim();
-        if (!path55) {
+        const path56 = mcpConfig.path?.trim();
+        if (!path56) {
           return { kind: "unsupported", reason: "Provider auto-import MCP config is missing a config path" };
         }
         const mcpServer = resolveAdhdevMcpServerLaunch({
@@ -54077,7 +54134,7 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
         return {
           kind: "auto_import",
           serverName,
-          configPath: resolveMcpConfigPath(path55, workspace),
+          configPath: resolveMcpConfigPath(path56, workspace),
           configFormat: mcpConfig.format,
           mcpServer
         };
@@ -54291,8 +54348,8 @@ ${rendered}`, "utf-8");
         if (!(0, import_node_fs3.existsSync)(filePath)) return;
         if (owned) {
           try {
-            const fs57 = require("fs");
-            fs57.unlinkSync(filePath);
+            const fs58 = require("fs");
+            fs58.unlinkSync(filePath);
           } catch {
           }
           return;
@@ -54305,8 +54362,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 fs57 = require("fs");
-            fs57.unlinkSync(filePath);
+            const fs58 = require("fs");
+            fs58.unlinkSync(filePath);
           } catch {
           }
         } else {
@@ -54421,10 +54478,10 @@ ${rendered}`, "utf-8");
       return (0, import_path11.join)(getDaemonDataDir(), "mesh-coordinators.json");
     }
     function loadMeshCoordinatorRegistry() {
-      const path55 = getRegistryPath();
-      if (!(0, import_fs12.existsSync)(path55)) return;
+      const path56 = getRegistryPath();
+      if (!(0, import_fs12.existsSync)(path56)) return;
       try {
-        const raw = JSON.parse((0, import_fs12.readFileSync)(path55, "utf-8"));
+        const raw = JSON.parse((0, import_fs12.readFileSync)(path56, "utf-8"));
         if (!Array.isArray(raw)) return;
         _registry.clear();
         for (const entry of raw) {
@@ -61264,6 +61321,102 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         MAX_TRACKED_CLONED_NODES = 512;
       }
     });
+    function quotaClaimBlockKey(meshId, observation) {
+      return `${meshId}:${observation.nodeId}:${observation.sessionId}:${observation.providerType}`;
+    }
+    function quotaClaimBlockDescription(providerType, block2) {
+      if (block2.reason === PROVIDER_QUOTA_EXHAUSTED_SKIP_REASON) {
+        return `provider '${providerType}' reported quota exhausted`;
+      }
+      return `provider '${providerType}' had ${block2.remainingPercent.toFixed(1)}% ${block2.window} quota remaining (< ${block2.thresholdPercent}% threshold)`;
+    }
+    function rememberBounded(map3, key2, value) {
+      map3.set(key2, value);
+      if (map3.size > AUTO_LAUNCH_LEDGER_DEDUP_MAX) {
+        const oldest = map3.keys().next().value;
+        if (oldest !== void 0) map3.delete(oldest);
+      }
+    }
+    function logQuotaClaimBlockTransition(meshId, observation) {
+      const key2 = quotaClaimBlockKey(meshId, observation);
+      const fingerprint = `${observation.block.reason}:${observation.block.window}:${observation.block.remainingPercent}:${observation.block.thresholdPercent}`;
+      if (lastQuotaClaimBlockLog.get(key2) === fingerprint) return;
+      rememberBounded(lastQuotaClaimBlockLog, key2, fingerprint);
+      LOG2.info("MeshQueue", `QUOTA GATE: deferring queue claim for node ${observation.nodeId} (${observation.sessionId}): ${quotaClaimBlockDescription(observation.providerType, observation.block)} \u2014 trying remaining provider candidates; the task stays pending only if none can claim`);
+    }
+    function clearQuotaClaimBlockState(meshId, nodeId, sessionId, providerType) {
+      lastQuotaClaimBlockLog.delete(quotaClaimBlockKey(meshId, { nodeId, sessionId, providerType }));
+    }
+    function logQuotaClaimFallbackSuccess(blocked, taskId, winner) {
+      if (!blocked.length) return;
+      const detail = blocked.map((item) => quotaClaimBlockDescription(item.providerType, item.block)).join("; ");
+      LOG2.info("MeshQueue", `QUOTA GATE: queue claim fallback succeeded for task ${taskId}: ${detail} \u2192 provider '${winner.providerType}' claimed on node ${winner.nodeId} (${winner.sessionId})`);
+    }
+    function logAllQuotaClaimCandidatesBlocked(meshId, trace, pendingTaskIds) {
+      if (!trace.blocked.length || trace.clear > 0 || trace.blocked.length !== trace.evaluated) return;
+      const detail = trace.blocked.map((item) => `${item.nodeId}/${quotaClaimBlockDescription(item.providerType, item.block)}`).join("; ");
+      const fingerprint = `${pendingTaskIds.slice().sort().join(",")}|${detail}`;
+      if (lastAllQuotaClaimBlockedLog.get(meshId) === fingerprint) return;
+      rememberBounded(lastAllQuotaClaimBlockedLog, meshId, fingerprint);
+      LOG2.info("MeshQueue", `QUOTA GATE: every idle provider candidate was quota-gated for mesh ${meshId} (${detail}); task(s) ${pendingTaskIds.join(", ") || "pending"} remain queued until a quota window resets`);
+    }
+    function clearAllQuotaClaimCandidatesBlockedState(meshId) {
+      lastAllQuotaClaimBlockedLog.delete(meshId);
+    }
+    function logAutoLaunchQuotaFallbackSuccess(resolved, taskId, nodeId, sessionId) {
+      if (!resolved.providerType || !resolved.quotaGated?.length) return;
+      const detail = resolved.quotaGated.map((item) => quotaClaimBlockDescription(item.providerType, item.block)).join("; ");
+      LOG2.info("MeshQueue", `QUOTA GATE: auto-launch fallback succeeded for task ${taskId} on node ${nodeId}: ${detail} \u2192 spawned provider '${resolved.providerType}'${sessionId ? ` (${sessionId})` : ""}`);
+    }
+    function recordAutoLaunchEvent(meshId, args) {
+      const dedupKey = `${meshId}:${args.taskId}`;
+      const currentSig = `${args.phase}|${args.reason || ""}`;
+      if (args.phase === "skipped" && lastAutoLaunchLedgerKey.get(dedupKey) === currentSig) {
+        return;
+      }
+      lastAutoLaunchLedgerKey.set(dedupKey, currentSig);
+      if (lastAutoLaunchLedgerKey.size > AUTO_LAUNCH_LEDGER_DEDUP_MAX) {
+        const oldest = lastAutoLaunchLedgerKey.keys().next().value;
+        if (oldest !== void 0) lastAutoLaunchLedgerKey.delete(oldest);
+      }
+      try {
+        appendLedgerEntry(meshId, {
+          kind: "session_auto_launch",
+          nodeId: args.nodeId,
+          sessionId: args.sessionId,
+          providerType: args.providerType,
+          // (B) promote taskId so this entry joins the task lifecycle timeline.
+          ...args.taskId ? { taskId: args.taskId } : {},
+          payload: {
+            phase: args.phase,
+            taskId: args.taskId,
+            reason: args.reason,
+            error: args.error,
+            // (D) resolved execution profile for the spawned worker.
+            ...args.model ? { resolvedModel: args.model } : {},
+            ...args.thinkingLevel ? { resolvedThinkingLevel: args.thinkingLevel } : {}
+          }
+        });
+      } catch (e) {
+        LOG2.warn("MeshQueue", `Failed to record auto-launch ledger event: ${e?.message || e}`);
+      }
+    }
+    var lastQuotaClaimBlockLog;
+    var lastAllQuotaClaimBlockedLog;
+    var lastAutoLaunchLedgerKey;
+    var AUTO_LAUNCH_LEDGER_DEDUP_MAX;
+    var init_mesh_queue_observability = __esm2({
+      "src/mesh/mesh-queue-observability.ts"() {
+        "use strict";
+        init_logger();
+        init_mesh_ledger();
+        init_mesh_quota_routing();
+        lastQuotaClaimBlockLog = /* @__PURE__ */ new Map();
+        lastAllQuotaClaimBlockedLog = /* @__PURE__ */ new Map();
+        lastAutoLaunchLedgerKey = /* @__PURE__ */ new Map();
+        AUTO_LAUNCH_LEDGER_DEDUP_MAX = 2e3;
+      }
+    });
     function isActionableSkipReason(reason) {
       if (!reason) return false;
       return ACTIONABLE_SKIP_REASON_PREFIXES.some((prefix) => reason === prefix || reason.startsWith(prefix));
@@ -61349,8 +61502,8 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         nextAction: "Launch a session on that node yourself with mesh_launch_session, or ensure the remote daemon is connected over P2P."
       };
       if (reason.startsWith("provider") || reason === "missing_provider_priority") return {
-        summary: "the node has no usable provider for this task (provider priority missing/unusable, or the provider loader is unavailable)",
-        nextAction: "Check the node's providerPriority policy and that the required CLI/ACP provider is installed and enabled on that machine."
+        summary: `the current provider scan found no usable provider for this task (provider priority missing/unusable, or the provider loader is unavailable; ${reason})`,
+        nextAction: "Check the node's providerPriority policy and that the required CLI/ACP provider is installed and enabled on that machine. Quota-gated candidates use a separate, self-resolving reason and are not proof of this configuration blocker."
       };
       if (reason === "dirty_workspace") return {
         summary: "the node's workspace is dirty, so auto-launch is blocked to avoid clobbering uncommitted changes",
@@ -61399,7 +61552,8 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       const nodeLabel = readNonEmptyString(nodeId) || readNonEmptyString(task?.targetNodeId);
       const evidence = reason === "target_session_pin_expired" ? resolveTaskDeliveryEvidence(meshId, taskId) : void 0;
       const { summary, nextAction } = actionableSkipGuidance(reason, evidence);
-      const closing = reason === "target_session_pin_expired" ? "The stale pin has already been cleared, so the task is now claimable by any compatible session \u2014 the action above is about the session it was originally addressed to." : "This is an actionable blocker \u2014 it will NOT clear on its own; the task stays pending until you resolve it.";
+      const providerAvailabilityResult = reason.startsWith("provider") || reason === "missing_provider_priority";
+      const closing = reason === "target_session_pin_expired" ? "The stale pin has already been cleared, so the task is now claimable by any compatible session \u2014 the action above is about the session it was originally addressed to." : providerAvailabilityResult ? "This result needs action if it persists: a later provider-status refresh or an already-starting usable session can clear it, but a genuinely missing, disabled, or misconfigured provider will keep the task pending until you fix that configuration." : "This is an actionable blocker \u2014 it will NOT clear on its own; the task stays pending until you resolve it.";
       const coordinatorMessage = `[System] A queued mesh task${nodeLabel ? ` for node ${nodeLabel}` : ""} is not being dispatched because ${summary}. ${nextAction} ${closing}`;
       try {
         queuePendingMeshCoordinatorEvent({
@@ -61442,6 +61596,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         init_config();
         init_slot_model_enforcement();
         init_mesh_queue_assignment();
+        init_mesh_queue_observability();
         ACTIONABLE_SKIP_REASON_PREFIXES = [
           "target_node_id_unmatched",
           "no_node_satisfies_required_tags",
@@ -61972,7 +62127,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         return void 0;
       }
     }
-    function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType, routingDecision) {
+    function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType, routingDecision, quotaClaimTrace) {
       const mesh = getMeshWithCache(components, meshId);
       const node = mesh?.nodes.find((n) => meshNodeIdMatches(n, nodeId));
       if (routingDecision?.source !== "autoLaunch") {
@@ -61983,14 +62138,15 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         return false;
       }
       const quotaClaimBlock = evaluateProviderQuotaGate(node, providerType, mesh?.policy?.quotaRouting ?? null, Date.now(), mesh);
+      if (quotaClaimTrace) quotaClaimTrace.evaluated += 1;
       if (quotaClaimBlock) {
-        if (quotaClaimBlock.reason === PROVIDER_QUOTA_EXHAUSTED_SKIP_REASON) {
-          LOG2.info("MeshQueue", `QUOTA GATE: deferring queue claim for node ${nodeId} (${sessionId}): provider '${providerType}' reported its quota EXHAUSTED \u2014 task left pending until the quota resets`);
-        } else {
-          LOG2.info("MeshQueue", `QUOTA GATE: deferring queue claim for node ${nodeId} (${sessionId}): provider '${providerType}' has ${quotaClaimBlock.remainingPercent.toFixed(1)}% ${quotaClaimBlock.window} quota remaining (< ${quotaClaimBlock.thresholdPercent}% threshold) \u2014 task left pending until the window resets`);
-        }
+        const observation = { nodeId, sessionId, providerType, block: quotaClaimBlock };
+        logQuotaClaimBlockTransition(meshId, observation);
+        quotaClaimTrace?.blocked.push(observation);
         return false;
       }
+      clearQuotaClaimBlockState(meshId, nodeId, sessionId, providerType);
+      if (quotaClaimTrace) quotaClaimTrace.clear += 1;
       const inlineBootstrapNode = (() => {
         try {
           const inlineMesh = components.router?.getCachedInlineMesh?.(meshId);
@@ -62049,6 +62205,12 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       if (!task) {
         return false;
       }
+      if (quotaClaimTrace?.blocked.length) {
+        logQuotaClaimFallbackSuccess(quotaClaimTrace.blocked, task.id, { nodeId, sessionId, providerType });
+        quotaClaimTrace.blocked = [];
+        quotaClaimTrace.evaluated = 0;
+        quotaClaimTrace.clear = 0;
+      }
       const terminal = findTerminalLedgerEvidenceForTask({
         meshId,
         taskId: task.id
@@ -62397,39 +62559,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         return true;
       });
     }
-    function recordAutoLaunchEvent(meshId, args) {
-      const dedupKey = `${meshId}:${args.taskId}`;
-      const currentSig = `${args.phase}|${args.reason || ""}`;
-      if (args.phase === "skipped" && lastAutoLaunchLedgerKey.get(dedupKey) === currentSig) {
-        return;
-      }
-      lastAutoLaunchLedgerKey.set(dedupKey, currentSig);
-      if (lastAutoLaunchLedgerKey.size > AUTO_LAUNCH_LEDGER_DEDUP_MAX) {
-        const oldest = lastAutoLaunchLedgerKey.keys().next().value;
-        if (oldest !== void 0) lastAutoLaunchLedgerKey.delete(oldest);
-      }
-      try {
-        appendLedgerEntry(meshId, {
-          kind: "session_auto_launch",
-          nodeId: args.nodeId,
-          sessionId: args.sessionId,
-          providerType: args.providerType,
-          // (B) promote taskId so this entry joins the task lifecycle timeline.
-          ...args.taskId ? { taskId: args.taskId } : {},
-          payload: {
-            phase: args.phase,
-            taskId: args.taskId,
-            reason: args.reason,
-            error: args.error,
-            // (D) resolved execution profile for the spawned worker.
-            ...args.model ? { resolvedModel: args.model } : {},
-            ...args.thinkingLevel ? { resolvedThinkingLevel: args.thinkingLevel } : {}
-          }
-        });
-      } catch (e) {
-        LOG2.warn("MeshQueue", `Failed to record auto-launch ledger event: ${e?.message || e}`);
-      }
-    }
     function markAutoLaunch(meshId, taskId, args) {
       recordTaskAutoLaunch(meshId, taskId, {
         status: args.status,
@@ -62529,6 +62658,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       });
       return {
         providerType: winner.providerType,
+        ...ranked.gated.length ? { quotaGated: ranked.gated } : {},
         ...winner.slot.model ? { model: winner.slot.model } : {},
         ...winner.slot.thinkingLevel ? { thinkingLevel: winner.slot.thinkingLevel } : {},
         // The slot that won selection. Returned so the caller can enforce
@@ -62848,6 +62978,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
               }
               const remoteSessionId = readNonEmptyString(payload.sessionId) || readNonEmptyString(payload.id) || readNonEmptyString(payload.runtimeSessionId);
               markAutoLaunch(meshId, task.id, { status: "completed", nodeId, providerType: resolved.providerType, sessionId: remoteSessionId || void 0, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
+              logAutoLaunchQuotaFallbackSuccess(resolved, task.id, nodeId, remoteSessionId || void 0);
               autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
               sweepExpiredCooldowns();
               return true;
@@ -62878,6 +63009,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
               return false;
             }
             markAutoLaunch(meshId, task.id, { status: "completed", nodeId, providerType: resolved.providerType, sessionId, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
+            logAutoLaunchQuotaFallbackSuccess(resolved, task.id, nodeId, sessionId);
             await waitForLocalSessionReady(components, sessionId);
             const requiredTags = Array.isArray(task.requiredTags) ? task.requiredTags.filter((t) => !!t) : [];
             const routingDecision = {
@@ -62986,8 +63118,9 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           remoteCandidates.push({ nodeId: idle.nodeId, sessionId: idle.sessionId, providerType: idle.providerType, origin: "remote", node });
         }
       }
+      const quotaClaimTrace = { blocked: [], evaluated: 0, clear: 0 };
       const assignIdleCandidate = (candidate) => {
-        const assigned = tryAssignQueueTask(components, meshId, candidate.nodeId, candidate.sessionId, candidate.providerType);
+        const assigned = tryAssignQueueTask(components, meshId, candidate.nodeId, candidate.sessionId, candidate.providerType, void 0, quotaClaimTrace);
         if (assigned && candidate.origin === "remote") {
           try {
             MeshRuntimeStore.getInstance().deleteRemoteIdleSession(meshId, candidate.nodeId, candidate.sessionId);
@@ -63030,6 +63163,11 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         nodeId: task.assignedNodeId,
         sessionId: task.assignedSessionId
       }));
+      if (newlyAssignedTasks.length === 0 && !autoLaunchStarted) {
+        logAllQuotaClaimCandidatesBlocked(meshId, quotaClaimTrace, afterQueue.filter((task) => task.status === "pending").map((task) => task.id));
+      } else {
+        clearAllQuotaClaimCandidatesBlockedState(meshId);
+      }
       const autoLaunchPending = autoLaunchStarted || afterQueue.some((task) => {
         if (task.status !== "pending") return false;
         const al = task.autoLaunch;
@@ -63081,8 +63219,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     var AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES;
     var AUTO_LAUNCH_REMOTE_IDLE_TTL_MS;
     var autoLaunchAwaitClaimBackoff;
-    var lastAutoLaunchLedgerKey;
-    var AUTO_LAUNCH_LEDGER_DEDUP_MAX;
     var init_mesh_queue_assignment = __esm2({
       "src/mesh/mesh-queue-assignment.ts"() {
         "use strict";
@@ -63115,6 +63251,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         init_mesh_auto_fast_forward();
         init_mesh_skip_notify();
         init_mesh_scheduling_fitness();
+        init_mesh_queue_observability();
         init_mesh_auto_fast_forward();
         init_mesh_skip_notify();
         init_mesh_scheduling_fitness();
@@ -63131,8 +63268,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES = 2;
         AUTO_LAUNCH_REMOTE_IDLE_TTL_MS = 5 * 60 * 1e3;
         autoLaunchAwaitClaimBackoff = /* @__PURE__ */ new Map();
-        lastAutoLaunchLedgerKey = /* @__PURE__ */ new Map();
-        AUTO_LAUNCH_LEDGER_DEDUP_MAX = 2e3;
       }
     });
     function readSettings(state) {
@@ -67351,12 +67486,12 @@ ${cleanBody}`;
         return !liveePaths.has(norm);
       });
     }
-    function safeUnlink(path55) {
+    function safeUnlink(path56) {
       try {
-        (0, import_fs16.unlinkSync)(path55);
+        (0, import_fs16.unlinkSync)(path56);
         return true;
       } catch (e) {
-        LOG2.warn("DiskRetention", `Failed to delete ${path55}: ${e?.message || e}`);
+        LOG2.warn("DiskRetention", `Failed to delete ${path56}: ${e?.message || e}`);
         return false;
       }
     }
@@ -67370,10 +67505,10 @@ ${cleanBody}`;
         return [];
       }
       for (const name of names) {
-        const path55 = (0, import_path14.join)(dir, name);
+        const path56 = (0, import_path14.join)(dir, name);
         try {
-          const st = (0, import_fs16.statSync)(path55);
-          if (st.isFile()) out.push({ path: path55, mtimeMs: st.mtimeMs });
+          const st = (0, import_fs16.statSync)(path56);
+          if (st.isFile()) out.push({ path: path56, mtimeMs: st.mtimeMs });
         } catch {
         }
       }
@@ -70559,54 +70694,54 @@ ${cleanBody}`;
       }
       return errs;
     }
-    function validateCondition(c, sectionIds, path55) {
+    function validateCondition(c, sectionIds, path56) {
       const errs = [];
       const w = c;
       if ("all" in w) {
-        w.all.forEach((x, i) => errs.push(...validateCondition(x, sectionIds, `${path55}.all[${i}]`)));
+        w.all.forEach((x, i) => errs.push(...validateCondition(x, sectionIds, `${path56}.all[${i}]`)));
         return errs;
       }
       if ("any" in w) {
-        w.any.forEach((x, i) => errs.push(...validateCondition(x, sectionIds, `${path55}.any[${i}]`)));
+        w.any.forEach((x, i) => errs.push(...validateCondition(x, sectionIds, `${path56}.any[${i}]`)));
         return errs;
       }
       if ("not" in w) {
-        errs.push(...validateCondition(w.not, sectionIds, `${path55}.not`));
+        errs.push(...validateCondition(w.not, sectionIds, `${path56}.not`));
         return errs;
       }
       if ("matches" in w) {
-        if (w.section && !sectionIds.has(w.section)) errs.push(`${path55}.section "${w.section}" unknown`);
+        if (w.section && !sectionIds.has(w.section)) errs.push(`${path56}.section "${w.section}" unknown`);
         try {
           new RegExp(w.matches, w.flags ?? "i");
         } catch (e) {
-          errs.push(`${path55}.matches invalid regex: ${e.message}`);
+          errs.push(`${path56}.matches invalid regex: ${e.message}`);
         }
         return errs;
       }
       if ("cursor_above" in w && "changed" in w) return errs;
       if ("signal" in w) {
-        if (typeof w.signal !== "string" || !w.signal.trim()) errs.push(`${path55}.signal must be a non-empty string`);
-        if (w.equals !== void 0 && typeof w.equals !== "boolean") errs.push(`${path55}.equals must be a boolean`);
+        if (typeof w.signal !== "string" || !w.signal.trim()) errs.push(`${path56}.signal must be a non-empty string`);
+        if (w.equals !== void 0 && typeof w.equals !== "boolean") errs.push(`${path56}.equals must be a boolean`);
         return errs;
       }
       if ("elapsed_ms" in w) {
-        if (typeof w.elapsed_ms !== "number") errs.push(`${path55}.elapsed_ms must be a number`);
+        if (typeof w.elapsed_ms !== "number") errs.push(`${path56}.elapsed_ms must be a number`);
         return errs;
       }
       if ("stable_ms" in w) {
-        if (typeof w.stable_ms !== "number") errs.push(`${path55}.stable_ms must be a number`);
-        if (w.section && !sectionIds.has(w.section)) errs.push(`${path55}.section "${w.section}" unknown`);
+        if (typeof w.stable_ms !== "number") errs.push(`${path56}.stable_ms must be a number`);
+        if (w.section && !sectionIds.has(w.section)) errs.push(`${path56}.section "${w.section}" unknown`);
         if (w.ignore_lines !== void 0) {
-          if (typeof w.ignore_lines !== "string") errs.push(`${path55}.ignore_lines must be a string`);
+          if (typeof w.ignore_lines !== "string") errs.push(`${path56}.ignore_lines must be a string`);
           else try {
             new RegExp(w.ignore_lines, "m");
           } catch (e) {
-            errs.push(`${path55}.ignore_lines invalid regex: ${e.message}`);
+            errs.push(`${path56}.ignore_lines invalid regex: ${e.message}`);
           }
         }
         return errs;
       }
-      errs.push(`${path55} is not a recognized condition`);
+      errs.push(`${path56} is not a recognized condition`);
       return errs;
     }
     var fs17;
@@ -73168,8 +73303,8 @@ ${cleanBody}`;
             let cwd = options.cwd;
             if (cwd) {
               try {
-                const fs57 = require("fs");
-                const stat2 = fs57.statSync(cwd);
+                const fs58 = require("fs");
+                const stat2 = fs58.statSync(cwd);
                 if (!stat2.isDirectory()) cwd = os15.homedir();
               } catch {
                 cwd = os15.homedir();
@@ -78497,7 +78632,7 @@ ${lastSnapshot}`;
     }
     function canonicalize(p) {
       try {
-        const resolved = path45.resolve(p);
+        const resolved = path46.resolve(p);
         try {
           return nodeFs.realpathSync.native ? nodeFs.realpathSync.native(resolved) : nodeFs.realpathSync(resolved);
         } catch {
@@ -78517,7 +78652,7 @@ ${lastSnapshot}`;
       }
       for (const root of _gatedRoots) {
         if (normalized === root.rootPath) return root;
-        if (normalized.startsWith(root.rootPath + path45.sep)) return root;
+        if (normalized.startsWith(root.rootPath + path46.sep)) return root;
       }
       return null;
     }
@@ -78536,16 +78671,16 @@ ${lastSnapshot}`;
       };
     }
     function gatedRequire(request, parent, isMain, gated, originalLoad) {
-      if (request.startsWith("./") || request.startsWith("../") || path45.isAbsolute(request)) {
+      if (request.startsWith("./") || request.startsWith("../") || path46.isAbsolute(request)) {
         let resolved;
         try {
-          const callerRequire = parent?.filename ? (0, import_node_module2.createRequire)(parent.filename) : (0, import_node_module2.createRequire)(path45.join(gated.rootPath, "__entry__.js"));
+          const callerRequire = parent?.filename ? (0, import_node_module2.createRequire)(parent.filename) : (0, import_node_module2.createRequire)(path46.join(gated.rootPath, "__entry__.js"));
           resolved = callerRequire.resolve(request);
         } catch {
           return originalLoad.call(this, request, parent, isMain);
         }
         const resolvedCanon = canonicalize(resolved) || resolved;
-        if (!(resolvedCanon === gated.rootPath || resolvedCanon.startsWith(gated.rootPath + path45.sep))) {
+        if (!(resolvedCanon === gated.rootPath || resolvedCanon.startsWith(gated.rootPath + path46.sep))) {
           denyRequire(request, parent, `relative path escapes provider root (resolved to ${resolvedCanon})`);
         }
         return originalLoad.call(this, request, parent, isMain);
@@ -78569,7 +78704,7 @@ ${lastSnapshot}`;
       err.callerFilename = caller;
       throw err;
     }
-    var path45;
+    var path46;
     var import_node_module2;
     var nodeFs;
     var nodeChildProcess;
@@ -78590,7 +78725,7 @@ ${lastSnapshot}`;
     var init_require_whitelist = __esm2({
       "src/providers/sdk/v1/sandbox/require-whitelist.ts"() {
         "use strict";
-        path45 = __toESM2(require("path"));
+        path46 = __toESM2(require("path"));
         import_node_module2 = require("module");
         nodeFs = __toESM2(require("fs"));
         nodeChildProcess = __toESM2(require("child_process"));
@@ -79316,7 +79451,7 @@ ${lastSnapshot}`;
       return _cliValidator;
     }
     function formatIssue(err) {
-      const path55 = err.instancePath || "";
+      const path56 = err.instancePath || "";
       const params = err.params;
       let message = err.message || "validation failed";
       let allowed;
@@ -79334,7 +79469,7 @@ ${lastSnapshot}`;
       } else if (err.keyword === "type") {
         message = `must be ${params.type}`;
       }
-      return { path: path55, keyword: err.keyword, message, ...allowed !== void 0 ? { allowed } : {} };
+      return { path: path56, keyword: err.keyword, message, ...allowed !== void 0 ? { allowed } : {} };
     }
     function validateCliProviderManifest(manifest) {
       const validator = getCliValidator();
@@ -79445,6 +79580,7 @@ ${lastSnapshot}`;
       MESH_REFINE_CONFIG_LOCATIONS: () => MESH_REFINE_CONFIG_LOCATIONS,
       MESH_REFINE_CONFIG_SCHEMA: () => MESH_REFINE_CONFIG_SCHEMA,
       MESH_SCHEDULING_STRATEGIES: () => MESH_SCHEDULING_STRATEGIES,
+      MESH_TASK_GRAPH_MAX_TASKS: () => MESH_TASK_GRAPH_MAX_TASKS,
       MESH_TASK_PRIORITIES: () => MESH_TASK_PRIORITIES,
       MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS: () => MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS,
       MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA: () => MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA,
@@ -79579,6 +79715,7 @@ ${lastSnapshot}`;
       drainPendingMeshCoordinatorEvents: () => drainPendingMeshCoordinatorEvents,
       encodeDuplicateMeshDispatchCode: () => encodeDuplicateMeshDispatchCode,
       enqueueTask: () => enqueueTask,
+      enqueueTaskGraph: () => enqueueTaskGraph,
       ensureSessionHostReady: () => ensureSessionHostReady2,
       evaluateFsm: () => evaluateFsm,
       evaluateProviderQuotaGate: () => evaluateProviderQuotaGate,
@@ -81062,8 +81199,8 @@ ${lastSnapshot}`;
         throw new Error(stderr || error48?.message || `git ${args[0]} failed`);
       }
     }
-    async function canonicalPath(path55) {
-      const absolute = (0, import_node_path2.resolve)(path55);
+    async function canonicalPath(path56) {
+      const absolute = (0, import_node_path2.resolve)(path56);
       try {
         return await (0, import_promises4.realpath)(absolute);
       } catch {
@@ -81586,51 +81723,51 @@ ${lastSnapshot}`;
     }
     var usageFileCache = /* @__PURE__ */ new Map();
     function readUsageFile(meshId) {
-      const path55 = getUsagePath(meshId);
+      const path56 = getUsagePath(meshId);
       let stat2;
       try {
-        const s2 = (0, import_fs13.statSync)(path55);
+        const s2 = (0, import_fs13.statSync)(path56);
         stat2 = { mtimeMs: s2.mtimeMs, size: s2.size };
       } catch {
-        usageFileCache.delete(path55);
+        usageFileCache.delete(path56);
         return emptyFile(meshId);
       }
-      const cached5 = usageFileCache.get(path55);
+      const cached5 = usageFileCache.get(path56);
       if (cached5 && cached5.mtimeMs === stat2.mtimeMs && cached5.size === stat2.size) {
         return cached5.file;
       }
       try {
-        const parsed = JSON.parse((0, import_fs13.readFileSync)(path55, "utf-8"));
+        const parsed = JSON.parse((0, import_fs13.readFileSync)(path56, "utf-8"));
         if (!parsed || typeof parsed !== "object" || !parsed.sessions) {
-          usageFileCache.delete(path55);
+          usageFileCache.delete(path56);
           return emptyFile(meshId);
         }
-        usageFileCache.set(path55, { file: parsed, mtimeMs: stat2.mtimeMs, size: stat2.size });
+        usageFileCache.set(path56, { file: parsed, mtimeMs: stat2.mtimeMs, size: stat2.size });
         return parsed;
       } catch {
-        usageFileCache.delete(path55);
+        usageFileCache.delete(path56);
         return emptyFile(meshId);
       }
     }
     function writeUsageFile(meshId, file2) {
-      const path55 = getUsagePath(meshId);
-      const tmp = `${path55}.tmp`;
+      const path56 = getUsagePath(meshId);
+      const tmp = `${path56}.tmp`;
       (0, import_fs13.writeFileSync)(tmp, JSON.stringify(file2), { encoding: "utf-8", mode: 384 });
       try {
-        (0, import_fs13.renameSync)(tmp, path55);
+        (0, import_fs13.renameSync)(tmp, path56);
       } catch (e) {
         try {
           (0, import_fs13.unlinkSync)(tmp);
         } catch {
         }
-        usageFileCache.delete(path55);
+        usageFileCache.delete(path56);
         throw e;
       }
       try {
-        const s2 = (0, import_fs13.statSync)(path55);
-        usageFileCache.set(path55, { file: file2, mtimeMs: s2.mtimeMs, size: s2.size });
+        const s2 = (0, import_fs13.statSync)(path56);
+        usageFileCache.set(path56, { file: file2, mtimeMs: s2.mtimeMs, size: s2.size });
       } catch {
-        usageFileCache.delete(path55);
+        usageFileCache.delete(path56);
       }
     }
     function foldIntoRollup(rollup, entry) {
@@ -82124,19 +82261,19 @@ ${lastSnapshot}`;
       return null;
     }
     async function detectIDEs(providerLoader) {
-      const os30 = (0, import_os3.platform)();
+      const os31 = (0, import_os3.platform)();
       const results = [];
       for (const def of getMergedDefinitions()) {
         const cliPath = findCliCommand(providerLoader?.getIdeCliCommand(def.id, def.cli) || def.cli);
-        const appPath = checkPathExists(providerLoader?.getIdePathCandidates(def.id, def.paths[os30] || []) || []);
+        const appPath = checkPathExists(providerLoader?.getIdePathCandidates(def.id, def.paths[os31] || []) || []);
         let resolvedCli = cliPath;
-        if (!resolvedCli && appPath && os30 === "darwin") {
+        if (!resolvedCli && appPath && os31 === "darwin") {
           const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
           if ((0, import_fs17.existsSync)(bundledCli)) resolvedCli = bundledCli;
         }
-        if (!resolvedCli && appPath && os30 === "win32") {
-          const { dirname: dirname23 } = await import("path");
-          const appDir = dirname23(appPath);
+        if (!resolvedCli && appPath && os31 === "win32") {
+          const { dirname: dirname24 } = await import("path");
+          const appDir = dirname24(appPath);
           const candidates = [
             `${appDir}\\\\bin\\\\${def.cli}.cmd`,
             `${appDir}\\\\bin\\\\${def.cli}`,
@@ -82151,7 +82288,7 @@ ${lastSnapshot}`;
             }
           }
         }
-        const installed = os30 === "darwin" ? !!(resolvedCli || appPath) : !!resolvedCli;
+        const installed = os31 === "darwin" ? !!(resolvedCli || appPath) : !!resolvedCli;
         const version2 = null;
         results.push({
           id: def.id,
@@ -90374,8 +90511,8 @@ ${effect.notification.body || ""}`.trim();
        * own upstream cache and never writes into another instance's store.
        */
       getUpstreamInstallRoot() {
-        const path55 = require("path");
-        return path55.join(getConfigDir2(), "providers", ".upstream");
+        const path56 = require("path");
+        return path56.join(getConfigDir2(), "providers", ".upstream");
       }
       /**
        * Install (activate) a provider from the VERIFIED CHANNEL.
@@ -90458,19 +90595,19 @@ ${effect.notification.body || ""}`.trim();
         if (!["cli", "ide", "extension", "acp"].includes(category)) {
           return { success: false, error: `unknown category: ${category}` };
         }
-        const fs57 = require("fs");
-        const path55 = require("path");
+        const fs58 = require("fs");
+        const path56 = require("path");
         try {
           const installRoot = this.getUpstreamInstallRoot();
-          const installRootResolved = path55.resolve(installRoot);
-          const targetDir = path55.resolve(path55.join(installRoot, category, type2));
-          if (!targetDir.startsWith(installRootResolved + path55.sep)) {
+          const installRootResolved = path56.resolve(installRoot);
+          const targetDir = path56.resolve(path56.join(installRoot, category, type2));
+          if (!targetDir.startsWith(installRootResolved + path56.sep)) {
             return { success: false, error: "refusing to delete outside upstream root" };
           }
-          if (!fs57.existsSync(targetDir)) {
+          if (!fs58.existsSync(targetDir)) {
             return { success: false, error: "not installed" };
           }
-          fs57.rmSync(targetDir, { recursive: true, force: true });
+          fs58.rmSync(targetDir, { recursive: true, force: true });
           try {
             this._ctx.providerLoader?.deactivateVerifiedChannel?.(type2);
           } catch {
@@ -90490,28 +90627,28 @@ ${effect.notification.body || ""}`.trim();
        * the UI and by the update checker.
        */
       handleListInstalledProviders(_args) {
-        const fs57 = require("fs");
-        const path55 = require("path");
+        const fs58 = require("fs");
+        const path56 = require("path");
         const installRoot = this.getUpstreamInstallRoot();
-        if (!fs57.existsSync(installRoot)) return { success: true, providers: [] };
+        if (!fs58.existsSync(installRoot)) return { success: true, providers: [] };
         const CATEGORIES = ["cli", "ide", "extension", "acp"];
         const items = [];
         for (const category of CATEGORIES) {
-          const categoryDir = path55.join(installRoot, category);
-          if (!fs57.existsSync(categoryDir)) continue;
+          const categoryDir = path56.join(installRoot, category);
+          if (!fs58.existsSync(categoryDir)) continue;
           let entries;
           try {
-            entries = fs57.readdirSync(categoryDir);
+            entries = fs58.readdirSync(categoryDir);
           } catch {
             continue;
           }
           for (const type2 of entries) {
-            const v1Path = path55.join(categoryDir, type2, "provider.v1.json");
-            const v0Path = path55.join(categoryDir, type2, "provider.json");
-            const manifestPath = fs57.existsSync(v1Path) ? v1Path : fs57.existsSync(v0Path) ? v0Path : null;
+            const v1Path = path56.join(categoryDir, type2, "provider.v1.json");
+            const v0Path = path56.join(categoryDir, type2, "provider.json");
+            const manifestPath = fs58.existsSync(v1Path) ? v1Path : fs58.existsSync(v0Path) ? v0Path : null;
             if (!manifestPath) continue;
             try {
-              const m = JSON.parse(fs57.readFileSync(manifestPath, "utf-8"));
+              const m = JSON.parse(fs58.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({
@@ -90732,8 +90869,8 @@ ${effect.notification.body || ""}`.trim();
         if (!/^@[a-z0-9_-]+$/i.test(requestedName)) {
           return { success: false, error: "name must match @[a-z0-9_-]+" };
         }
-        const fs57 = require("fs");
-        const path55 = require("path");
+        const fs58 = require("fs");
+        const path56 = require("path");
         const { spawnSync: spawnSync3 } = require("child_process");
         const file2 = ext.loadExternalSources();
         if (file2.sources.some((s2) => s2.name === requestedName)) {
@@ -90742,9 +90879,9 @@ ${effect.notification.body || ""}`.trim();
         if (file2.sources.some((s2) => s2.url === url2 && s2.ref === ref)) {
           return { success: false, error: `source url+ref already registered (use a different name to track another ref)` };
         }
-        const sourceDir = path55.join(ext.externalRoot(), requestedName);
-        if (!fs57.existsSync(ext.externalRoot())) fs57.mkdirSync(ext.externalRoot(), { recursive: true });
-        if (fs57.existsSync(sourceDir)) {
+        const sourceDir = path56.join(ext.externalRoot(), requestedName);
+        if (!fs58.existsSync(ext.externalRoot())) fs58.mkdirSync(ext.externalRoot(), { recursive: true });
+        if (fs58.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], {
@@ -90754,7 +90891,7 @@ ${effect.notification.body || ""}`.trim();
         });
         if (clone2.status !== 0) {
           try {
-            fs57.rmSync(sourceDir, { recursive: true, force: true });
+            fs58.rmSync(sourceDir, { recursive: true, force: true });
           } catch {
           }
           return { success: false, error: `git clone failed: ${(clone2.stderr || clone2.stdout || "").trim() || "unknown error"}` };
@@ -90798,15 +90935,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 fs57 = require("fs");
-        const path55 = require("path");
+        const fs58 = require("fs");
+        const path56 = 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 = path55.join(ext.externalRoot(), name);
-        if (fs57.existsSync(sourceDir)) {
+        const sourceDir = path56.join(ext.externalRoot(), name);
+        if (fs58.existsSync(sourceDir)) {
           try {
-            fs57.rmSync(sourceDir, { recursive: true, force: true });
+            fs58.rmSync(sourceDir, { recursive: true, force: true });
           } catch (e) {
             return { success: false, error: `failed to delete ${sourceDir}: ${e?.message || e}` };
           }
@@ -92973,6 +93110,7 @@ ${marker}`,
     }
     init_snapshot2();
     init_build_info();
+    init_track_identity();
     init_coordinator_registry();
     init_types();
     init_deps();
@@ -93002,7 +93140,11 @@ ${marker}`,
         return {
           success: true,
           status: snapshot,
-          daemonBuild: getDaemonBuildInfo(),
+          // `track` is reported by the daemon that answered this command. It
+          // must travel explicitly: version strings do not identify a release
+          // track (stable can legitimately publish an rc), and an older daemon
+          // that omits this field must remain "unknown" to remote consumers.
+          daemonBuild: { ...getDaemonBuildInfo(), track: TRACK },
           upgradeFailure: readUpgradeFailureNotice(),
           providerChannelStaleness: ctx.deps.providerLoader?.getChannelStalenessSnapshot?.() ?? null
         };
@@ -93126,24 +93268,24 @@ ${marker}`,
         }
       },
       list_coordinator_prompts: async (_ctx, _args) => {
-        const fs57 = await import("fs");
-        const path55 = await import("path");
+        const fs58 = await import("fs");
+        const path56 = await import("path");
         const { getConfigDir: getConfigDir22 } = await Promise.resolve().then(() => (init_config(), config_exports));
-        const dir = path55.join(getConfigDir22(), "coordinator-prompts");
+        const dir = path56.join(getConfigDir22(), "coordinator-prompts");
         const entries = {};
         try {
-          if (fs57.existsSync(dir)) {
-            for (const name of fs57.readdirSync(dir)) {
+          if (fs58.existsSync(dir)) {
+            for (const name of fs58.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;
               if (!m) continue;
               const isAppend = !!matchAppend;
               const key2 = m[1];
-              const full = path55.join(dir, name);
+              const full = path56.join(dir, name);
               let content = "";
               try {
-                content = fs57.readFileSync(full, "utf8");
+                content = fs58.readFileSync(full, "utf8");
               } catch {
               }
               if (!entries[key2]) entries[key2] = { override: "", append: "" };
@@ -93157,8 +93299,8 @@ ${marker}`,
         return { success: true, dir, entries };
       },
       write_coordinator_prompt: async (_ctx, args) => {
-        const fs57 = await import("fs");
-        const path55 = await import("path");
+        const fs58 = await import("fs");
+        const path56 = await import("path");
         const { getConfigDir: getConfigDir22 } = await Promise.resolve().then(() => (init_config(), config_exports));
         const key2 = typeof args?.key === "string" ? args.key.trim() : "";
         const kind = args?.kind === "append" ? "append" : "override";
@@ -93166,15 +93308,15 @@ ${marker}`,
         if (!key2 || !/^[a-zA-Z0-9_.-]+$/.test(key2)) {
           return { success: false, error: "key must match [a-zA-Z0-9_.-]+" };
         }
-        const dir = path55.join(getConfigDir22(), "coordinator-prompts");
+        const dir = path56.join(getConfigDir22(), "coordinator-prompts");
         const filename = kind === "append" ? `${key2}.append.md` : `${key2}.md`;
-        const full = path55.join(dir, filename);
+        const full = path56.join(dir, filename);
         try {
-          fs57.mkdirSync(dir, { recursive: true });
+          fs58.mkdirSync(dir, { recursive: true });
           if (content.trim()) {
-            fs57.writeFileSync(full, content, { encoding: "utf8", mode: 384 });
-          } else if (fs57.existsSync(full)) {
-            fs57.unlinkSync(full);
+            fs58.writeFileSync(full, content, { encoding: "utf8", mode: 384 });
+          } else if (fs58.existsSync(full)) {
+            fs58.unlinkSync(full);
           }
           return { success: true, path: full, kind, key: key2 };
         } catch (error48) {
@@ -104520,10 +104662,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
     };
     var import_child_process12 = require("child_process");
     var net3 = __toESM2(require("net"));
-    var os26 = __toESM2(require("os"));
+    var os27 = __toESM2(require("os"));
+    var path48 = __toESM2(require("path"));
+    var fs43 = __toESM2(require("fs"));
     var path47 = __toESM2(require("path"));
-    var fs422 = __toESM2(require("fs"));
-    var path46 = __toESM2(require("path"));
     var chokidar = __toESM2(require_chokidar());
     init_logger();
     init_auto_approve_modes();
@@ -104989,9 +105131,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
     init_external_sources();
     init_config();
     init_native_history_executor();
-    var fs37 = __toESM2(require("fs"));
-    var os25 = __toESM2(require("os"));
-    var path41 = __toESM2(require("path"));
+    var fs38 = __toESM2(require("fs"));
+    var os26 = __toESM2(require("os"));
+    var path422 = __toESM2(require("path"));
     var fs33 = __toESM2(require("fs"));
     var path37 = __toESM2(require("path"));
     init_usage_normalize();
@@ -105174,17 +105316,17 @@ Run 'adhdev doctor' for detailed diagnostics.`
     }
     function readSession(sessionPath) {
       if (!sessionPath || !path37.isAbsolute(sessionPath)) return null;
-      const basename19 = path37.basename(sessionPath, ".jsonl");
-      if (!isSafeSessionId(basename19)) return null;
+      const basename20 = path37.basename(sessionPath, ".jsonl");
+      if (!isSafeSessionId(basename20)) return null;
       if (!fs33.existsSync(sessionPath)) return null;
       const sourceMtimeMs = statMtimeMs(sessionPath);
-      const { messages, usageRecords } = parseTranscriptFile(sessionPath, basename19);
+      const { messages, usageRecords } = parseTranscriptFile(sessionPath, basename20);
       if (messages.length === 0) return null;
       const firstSystem = messages.find((m) => m.kind === "session_start");
       const workspace = firstSystem?.workspace || firstSystem?.content || void 0;
       const session = {
         messages,
-        providerSessionId: basename19,
+        providerSessionId: basename20,
         source: "provider-native",
         sourcePath: sessionPath,
         sourceMtimeMs,
@@ -105193,7 +105335,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       };
       if (usageRecords.length > 0) {
         session.usage = foldUsageRecords(usageRecords, {
-          providerSessionId: basename19,
+          providerSessionId: basename20,
           agent: "claude-cli"
         });
       }
@@ -105488,8 +105630,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
       if (!fs34.existsSync(sessionPath)) return null;
       const meta3 = readSessionMeta(sessionPath);
       const metaId = String(meta3?.id ?? "").trim();
-      const basename19 = path38.basename(sessionPath, ".jsonl");
-      const uuidMatch = basename19.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i);
+      const basename20 = path38.basename(sessionPath, ".jsonl");
+      const uuidMatch = basename20.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i);
       const filenameUuid2 = uuidMatch ? uuidMatch[1] : "";
       if (metaId && filenameUuid2 && metaId !== filenameUuid2) return null;
       const sessionId = metaId || filenameUuid2;
@@ -106389,6 +106531,240 @@ Run 'adhdev doctor' for detailed diagnostics.`
       if (s2 === "tool" || s2 === "tool_result" || s2 === "function") return "assistant";
       return "system";
     }
+    var fs37 = __toESM2(require("fs"));
+    var path41 = __toESM2(require("path"));
+    var os25 = __toESM2(require("os"));
+    function grokSessionsRoot() {
+      const home = process.env.GROK_HOME && process.env.GROK_HOME.trim() ? process.env.GROK_HOME.trim() : path41.join(os25.homedir(), ".grok");
+      return path41.join(home, "sessions");
+    }
+    function encodeWorkspaceDir(workspace) {
+      return encodeURIComponent(workspace);
+    }
+    function statMtimeMs5(filePath) {
+      try {
+        return fs37.statSync(filePath).mtimeMs;
+      } catch {
+        return 0;
+      }
+    }
+    function isUuidLike2(value) {
+      return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(value);
+    }
+    function workspaceCandidates(workspace) {
+      const out = [workspace];
+      try {
+        const real = fs37.realpathSync(workspace);
+        if (real && real !== workspace) out.push(real);
+      } catch {
+      }
+      return out;
+    }
+    function resolveGrokPath(workspace, sessionId) {
+      if (!sessionId || !isUuidLike2(sessionId)) return null;
+      const root = grokSessionsRoot();
+      if (!fs37.existsSync(root)) return null;
+      for (const candidate of workspaceCandidates(workspace || "")) {
+        if (!candidate) continue;
+        const file2 = path41.join(root, encodeWorkspaceDir(candidate), sessionId, "chat_history.jsonl");
+        if (fs37.existsSync(file2)) return file2;
+      }
+      let entries = [];
+      try {
+        entries = fs37.readdirSync(root, { withFileTypes: true });
+      } catch {
+        return null;
+      }
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const file2 = path41.join(root, entry.name, sessionId, "chat_history.jsonl");
+        if (fs37.existsSync(file2)) return file2;
+      }
+      return null;
+    }
+    var USER_QUERY_RE = /<user_query>\s*([\s\S]*?)\s*<\/user_query>/;
+    function unwrapUserQuery(text) {
+      const match = USER_QUERY_RE.exec(text);
+      if (match) return match[1].trim();
+      return text.trim();
+    }
+    function blocksToText(content) {
+      if (typeof content === "string") return content;
+      if (!Array.isArray(content)) return "";
+      const parts = [];
+      for (const block2 of content) {
+        if (!block2 || typeof block2 !== "object") continue;
+        const record2 = block2;
+        if (typeof record2.text === "string") parts.push(record2.text);
+        else if (record2.type === "image") parts.push("[image]");
+      }
+      return parts.join("\n");
+    }
+    function parseGrokRecord(raw) {
+      if (!raw || typeof raw !== "object") return null;
+      const record2 = raw;
+      const type2 = typeof record2.type === "string" ? record2.type : "";
+      if (type2 === "system") return null;
+      if (type2 === "reasoning") return null;
+      if (type2 === "user") {
+        if (typeof record2.synthetic_reason === "string" && record2.synthetic_reason) return null;
+        const text = unwrapUserQuery(blocksToText(record2.content));
+        if (!text) return null;
+        return { role: "user", content: text, kind: "standard" };
+      }
+      if (type2 === "assistant") {
+        const text = blocksToText(record2.content).trim();
+        const toolCalls = Array.isArray(record2.tool_calls) ? record2.tool_calls : [];
+        if (!text) {
+          if (toolCalls.length === 0) return null;
+          const names = toolCalls.map((call) => call && typeof call === "object" ? call.name : null).filter((name) => typeof name === "string" && name.length > 0);
+          const label = names.length > 0 ? names.join(", ") : "tool";
+          return { role: "assistant", content: `[tool: ${label}]`, kind: "tool" };
+        }
+        return { role: "assistant", content: text, kind: "standard" };
+      }
+      if (type2 === "tool_result") {
+        const text = blocksToText(record2.content).trim();
+        if (!text) return null;
+        return { role: "assistant", content: text, kind: "tool" };
+      }
+      return null;
+    }
+    function readSessionCreatedAtMs(sessionDir) {
+      try {
+        const summary = JSON.parse(fs37.readFileSync(path41.join(sessionDir, "summary.json"), "utf8"));
+        const created = summary?.created_at;
+        if (typeof created === "string") {
+          const parsed = Date.parse(created);
+          if (Number.isFinite(parsed) && parsed > 0) return parsed;
+        }
+      } catch {
+      }
+      return 0;
+    }
+    function readSession5(sourcePath, sessionId, workspace) {
+      let text;
+      try {
+        text = fs37.readFileSync(sourcePath, "utf8");
+      } catch {
+        return null;
+      }
+      const sessionDir = path41.dirname(sourcePath);
+      const providerSessionId = path41.basename(sessionDir);
+      const sourceMtimeMs = statMtimeMs5(sourcePath);
+      const parsed = [];
+      for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        let record2;
+        try {
+          record2 = JSON.parse(trimmed);
+        } catch {
+          continue;
+        }
+        const message = parseGrokRecord(record2);
+        if (message) parsed.push(message);
+      }
+      const startMs = readSessionCreatedAtMs(sessionDir) || sourceMtimeMs;
+      const endMs = Math.max(sourceMtimeMs, startMs);
+      const span = endMs - startMs;
+      const step = parsed.length > 1 ? Math.floor(span / (parsed.length - 1)) : 0;
+      const messages = parsed.map((message, index) => {
+        const receivedAt = parsed.length > 1 ? startMs + step * index : endMs;
+        return {
+          ts: new Date(receivedAt).toISOString(),
+          receivedAt,
+          role: message.role,
+          content: message.content,
+          kind: message.kind,
+          agent: "grok-cli",
+          historySessionId: sessionId || providerSessionId,
+          ...workspace ? { workspace } : {},
+          providerUnitKey: `${providerSessionId}:${index}`
+        };
+      });
+      return {
+        messages,
+        providerSessionId,
+        source: "provider-native",
+        sourcePath,
+        sourceMtimeMs,
+        nativeHistoryCoverage: "full",
+        ...workspace ? { workspace } : {}
+      };
+    }
+    function listSessions(workspace, limit = 50) {
+      const root = grokSessionsRoot();
+      if (!fs37.existsSync(root)) return [];
+      const dirs = [];
+      for (const candidate of workspaceCandidates(workspace || "")) {
+        if (!candidate) continue;
+        const dir = path41.join(root, encodeWorkspaceDir(candidate));
+        if (fs37.existsSync(dir)) dirs.push(dir);
+      }
+      if (dirs.length === 0) return [];
+      const out = [];
+      for (const dir of dirs) {
+        let entries = [];
+        try {
+          entries = fs37.readdirSync(dir, { withFileTypes: true });
+        } catch {
+          continue;
+        }
+        for (const entry of entries) {
+          if (!entry.isDirectory() || !isUuidLike2(entry.name)) continue;
+          const sourcePath = path41.join(dir, entry.name, "chat_history.jsonl");
+          if (!fs37.existsSync(sourcePath)) continue;
+          const session = readSession5(sourcePath, entry.name, workspace);
+          if (!session || session.messages.length === 0) continue;
+          const first = session.messages[0];
+          const last = session.messages[session.messages.length - 1];
+          const firstUser = session.messages.find(
+            (m) => m.role === "user" && !m.content.startsWith("<user_info>")
+          ) ?? session.messages.find((m) => m.role === "user");
+          out.push({
+            historySessionId: entry.name,
+            sessionId: entry.name,
+            sourcePath,
+            sourceMtimeMs: session.sourceMtimeMs,
+            messageCount: session.messages.length,
+            firstMessageAt: first.receivedAt,
+            lastMessageAt: last.receivedAt,
+            ...firstUser ? { sessionTitle: firstUser.content.slice(0, 80) } : {},
+            ...firstUser ? { preview: firstUser.content.slice(0, 200) } : {},
+            ...workspace ? { workspace } : {},
+            agent: "grok-cli",
+            source: "provider-native",
+            nativeHistoryCoverage: "full"
+          });
+        }
+      }
+      out.sort((a, b) => b.sourceMtimeMs - a.sourceMtimeMs);
+      return out.slice(0, limit);
+    }
+    function listSessionsAllWorkspaces(limit = 50) {
+      const root = grokSessionsRoot();
+      if (!fs37.existsSync(root)) return [];
+      let dirs = [];
+      try {
+        dirs = fs37.readdirSync(root, { withFileTypes: true });
+      } catch {
+        return [];
+      }
+      const out = [];
+      for (const dir of dirs) {
+        if (!dir.isDirectory()) continue;
+        let workspace = "";
+        try {
+          workspace = decodeURIComponent(dir.name);
+        } catch {
+          continue;
+        }
+        out.push(...listSessions(workspace, limit));
+      }
+      out.sort((a, b) => b.sourceMtimeMs - a.sourceMtimeMs);
+      return out.slice(0, limit);
+    }
     init_constants();
     function createNativeHistoryDispatcher(reader) {
       return (input) => {
@@ -106403,7 +106779,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         const ownerConfirmed = reader === "antigravity-cli" ? resolved?.ownerConfirmed === true : void 0;
         if (input.forceRefresh === true || input.args?.forceRefresh === true) {
           try {
-            fs37.statSync(sourcePath);
+            fs38.statSync(sourcePath);
           } catch {
           }
         }
@@ -106454,14 +106830,21 @@ Run 'adhdev doctor' for detailed diagnostics.`
           const p = resolveHermesPath(workspace, sessionId);
           return p ? { path: p } : null;
         }
+        // grok stores per-cwd like claude, but keyed by the url-encoded cwd and
+        // with the uuid as a DIRECTORY (…/<uuid>/chat_history.jsonl) rather than
+        // the filename, so resolution lives in the reader module.
+        case "grok-cli": {
+          const p = resolveGrokPath(workspace, sessionId);
+          return p ? { path: p } : null;
+        }
       }
     }
     function resolveClaudePath(workspace, sessionId) {
-      const dir = path41.join(os25.homedir(), ".claude", "projects", cwdAsDashes(workspace));
-      if (!fs37.existsSync(dir)) return null;
+      const dir = path422.join(os26.homedir(), ".claude", "projects", cwdAsDashes(workspace));
+      if (!fs38.existsSync(dir)) return null;
       if (sessionId) {
-        const candidate = path41.join(dir, `${sessionId}.jsonl`);
-        if (fs37.existsSync(candidate)) return candidate;
+        const candidate = path422.join(dir, `${sessionId}.jsonl`);
+        if (fs38.existsSync(candidate)) return candidate;
       }
       return null;
     }
@@ -106473,7 +106856,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       return findCodexPathByRuntime(root, workspace, sessionStartedAtMs);
     }
     function findCodexPathBySessionId(root, sessionId) {
-      if (!fs37.existsSync(root)) return null;
+      if (!fs38.existsSync(root)) return null;
       const needle = sessionId.toLowerCase();
       const matches = [];
       const stack = [root];
@@ -106481,12 +106864,12 @@ Run 'adhdev doctor' for detailed diagnostics.`
         const current = stack.pop();
         let entries = [];
         try {
-          entries = fs37.readdirSync(current, { withFileTypes: true });
+          entries = fs38.readdirSync(current, { withFileTypes: true });
         } catch {
           continue;
         }
         for (const entry of entries) {
-          const entryPath = path41.join(current, entry.name);
+          const entryPath = path422.join(current, entry.name);
           if (entry.isDirectory()) {
             stack.push(entryPath);
             continue;
@@ -106501,7 +106884,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       return matches[0]?.p ?? null;
     }
     function findCodexPathByRuntime(root, workspace, sessionStartedAtMs) {
-      if (!fs37.existsSync(root) || !workspace) return null;
+      if (!fs38.existsSync(root) || !workspace) return null;
       const workspaceResolved = resolveRealPath(workspace);
       const cutoff = Date.now() - RECENT_WINDOW_MS;
       const matches = [];
@@ -106510,12 +106893,12 @@ Run 'adhdev doctor' for detailed diagnostics.`
         const current = stack.pop();
         let entries = [];
         try {
-          entries = fs37.readdirSync(current, { withFileTypes: true });
+          entries = fs38.readdirSync(current, { withFileTypes: true });
         } catch {
           continue;
         }
         for (const entry of entries) {
-          const entryPath = path41.join(current, entry.name);
+          const entryPath = path422.join(current, entry.name);
           if (entry.isDirectory()) {
             stack.push(entryPath);
             continue;
@@ -106535,10 +106918,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
     }
     function readCodexSessionMeta(filePath) {
       try {
-        const fd = fs37.openSync(filePath, "r");
+        const fd = fs38.openSync(filePath, "r");
         try {
           const buffer = Buffer.alloc(8192);
-          const bytes = fs37.readSync(fd, buffer, 0, buffer.length, 0);
+          const bytes = fs38.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();
@@ -106553,7 +106936,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
             timestampMs: Number.isFinite(timestampMs) ? timestampMs : void 0
           };
         } finally {
-          fs37.closeSync(fd);
+          fs38.closeSync(fd);
         }
       } catch {
         return null;
@@ -106561,7 +106944,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     }
     function resolveRealPath(value) {
       try {
-        return fs37.realpathSync(value);
+        return fs38.realpathSync(value);
       } catch {
         return value;
       }
@@ -106579,24 +106962,24 @@ Run 'adhdev doctor' for detailed diagnostics.`
     }
     var AGY_SPAWN_CLAIM_GRACE_MS = 2e3;
     function resolveAntigravityPath(workspace, sessionId, sessionStartedAtMs, instanceId) {
-      const agyRoot = path41.join(os25.homedir(), ".gemini", "antigravity-cli");
+      const agyRoot = path422.join(os26.homedir(), ".gemini", "antigravity-cli");
       const owner = antigravityOwnerToken(workspace, sessionStartedAtMs, instanceId);
       if (sessionId && isUuidLikeSessionId2(sessionId)) {
-        const dbPath = path41.join(agyRoot, "conversations", `${sessionId}.db`);
-        if (fs37.existsSync(dbPath)) {
+        const dbPath = path422.join(agyRoot, "conversations", `${sessionId}.db`);
+        if (fs38.existsSync(dbPath)) {
           if (owner) claimAntigravityConversation(sessionId, owner);
           return { path: dbPath, ownerConfirmed: true };
         }
       }
-      const brainRoot2 = path41.join(agyRoot, "brain");
-      if (fs37.existsSync(brainRoot2)) {
+      const brainRoot2 = path422.join(agyRoot, "brain");
+      if (fs38.existsSync(brainRoot2)) {
         const cutoff = spawnAwareCutoff(sessionStartedAtMs);
         const nonEmptyBrain = (uuid3, p) => {
-          const t = path41.join(p, ".system_generated", "logs", "transcript.jsonl");
-          return fs37.existsSync(t) && safeSize(t) > 0 ? t : null;
+          const t = path422.join(p, ".system_generated", "logs", "transcript.jsonl");
+          return fs38.existsSync(t) && safeSize(t) > 0 ? t : null;
         };
-        const all = fs37.readdirSync(brainRoot2, { withFileTypes: true }).filter((e) => e.isDirectory() && isUuidLikeSessionId2(e.name)).filter((e) => !isAntigravityConversationClaimedByOther(e.name, owner)).map((e) => {
-          const p = path41.join(brainRoot2, e.name);
+        const all = fs38.readdirSync(brainRoot2, { withFileTypes: true }).filter((e) => e.isDirectory() && isUuidLikeSessionId2(e.name)).filter((e) => !isAntigravityConversationClaimedByOther(e.name, owner)).map((e) => {
+          const p = path422.join(brainRoot2, e.name);
           return { uuid: e.name, p, mtime: safeMtime(p), birth: safeBirthtime(p) };
         }).filter((e) => e.mtime >= cutoff);
         let ordered = [];
@@ -106615,7 +106998,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           }
         }
       }
-      const convRoot = path41.join(agyRoot, "conversations");
+      const convRoot = path422.join(agyRoot, "conversations");
       const picked = pickUnboundConversationDb(convRoot, sessionStartedAtMs, owner);
       if (picked) {
         if (owner) claimAntigravityConversation(picked.uuid, owner);
@@ -106626,7 +107009,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     function pickUnboundConversationDb(convRoot, sessionFloorMs, owner) {
       let entries = [];
       try {
-        entries = fs37.readdirSync(convRoot, { withFileTypes: true });
+        entries = fs38.readdirSync(convRoot, { withFileTypes: true });
       } catch {
         return null;
       }
@@ -106639,7 +107022,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         if (!match || !isUuidLikeSessionId2(match[1])) continue;
         const uuid3 = match[1];
         if (isAntigravityConversationClaimedByOther(uuid3, owner)) continue;
-        const p = path41.join(convRoot, entry.name);
+        const p = path422.join(convRoot, entry.name);
         const mtime = safeMtime(p);
         if (applyRecencyCutoff && mtime < recencyCutoff) continue;
         candidates.push({ path: p, uuid: uuid3, mtime, birth: safeBirthtime(p) });
@@ -106663,10 +107046,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
     function resolveHermesPath(workspace, sessionId) {
       void workspace;
       void sessionId;
-      const dbPath = path41.join(os25.homedir(), ".hermes", "state.db");
-      if (fs37.existsSync(dbPath)) return dbPath;
-      const dir = path41.join(os25.homedir(), ".hermes", "sessions");
-      if (!fs37.existsSync(dir)) return null;
+      const dbPath = path422.join(os26.homedir(), ".hermes", "state.db");
+      if (fs38.existsSync(dbPath)) return dbPath;
+      const dir = path422.join(os26.homedir(), ".hermes", "sessions");
+      if (!fs38.existsSync(dir)) return null;
       return newestRecentFile2(dir, /^session_.*\.json$/);
     }
     function readByReader(reader, sourcePath, sessionId, workspace, requestedProviderSid) {
@@ -106684,6 +107067,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
         // per-session file upstream, so they need no equivalent pin here.
         case "hermes-cli":
           return readSession4(sourcePath, requestedProviderSid || void 0);
+        case "grok-cli":
+          return readSession5(sourcePath, sessionId, workspace || void 0);
       }
     }
     function cwdAsDashes(cwd) {
@@ -106691,7 +107076,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       return cwd.replace(/\//g, "-");
     }
     function codexSessionsRoot() {
-      return path41.join(os25.homedir(), ".codex", "sessions");
+      return path422.join(os26.homedir(), ".codex", "sessions");
     }
     function isUuidLikeSessionId2(sessionId) {
       return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(sessionId);
@@ -106703,7 +107088,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     function newestRecentFile2(dir, pattern) {
       try {
         const cutoff = Date.now() - RECENT_WINDOW_MS;
-        const entries = fs37.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && pattern.test(e.name)).map((e) => ({ p: path41.join(dir, e.name), mtime: safeMtime(path41.join(dir, e.name)) })).filter((e) => e.mtime >= cutoff).sort((a, b) => b.mtime - a.mtime);
+        const entries = fs38.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && pattern.test(e.name)).map((e) => ({ p: path422.join(dir, e.name), mtime: safeMtime(path422.join(dir, e.name)) })).filter((e) => e.mtime >= cutoff).sort((a, b) => b.mtime - a.mtime);
         return entries[0]?.p ?? null;
       } catch {
         return null;
@@ -106711,14 +107096,14 @@ Run 'adhdev doctor' for detailed diagnostics.`
     }
     function safeMtime(p) {
       try {
-        return Math.floor(fs37.statSync(p).mtimeMs);
+        return Math.floor(fs38.statSync(p).mtimeMs);
       } catch {
         return 0;
       }
     }
     function safeBirthtime(p) {
       try {
-        const st = fs37.statSync(p);
+        const st = fs38.statSync(p);
         const birth = Math.floor(st.birthtimeMs);
         return birth > 0 ? birth : Math.floor(st.mtimeMs);
       } catch {
@@ -106727,11 +107112,20 @@ Run 'adhdev doctor' for detailed diagnostics.`
     }
     function safeSize(p) {
       try {
-        return fs37.statSync(p).size;
+        return fs38.statSync(p).size;
       } catch {
         return 0;
       }
     }
+    function createNativeHistoryListDispatcher(reader) {
+      if (reader !== "grok-cli") return null;
+      return (input) => {
+        const limitRaw = input.args?.limit;
+        const limit = typeof limitRaw === "number" && limitRaw > 0 ? Math.floor(limitRaw) : 50;
+        const sessions = input.workspace ? listSessions(input.workspace, limit) : listSessionsAllWorkspaces(limit);
+        return { sessions };
+      };
+    }
     function normalizeRole2(r) {
       const s2 = String(r ?? "").toLowerCase();
       if (s2 === "user" || s2 === "human") return "user";
@@ -106801,8 +107195,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       return { activatable, skipped };
     }
-    var fs38 = __toESM2(require("fs"));
-    var path422 = __toESM2(require("path"));
+    var fs39 = __toESM2(require("fs"));
+    var path43 = __toESM2(require("path"));
     var crypto8 = __toESM2(require("crypto"));
     init_config();
     var ProviderChannelStore = class _ProviderChannelStore {
@@ -106815,19 +107209,19 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       /** Default store root, resolved through the config-dir abstraction. */
       static defaultRoot() {
-        return path422.join(getConfigDir2(), "providers", ".store");
+        return path43.join(getConfigDir2(), "providers", ".store");
       }
       get objectsDir() {
-        return path422.join(this.rootDir, "objects");
+        return path43.join(this.rootDir, "objects");
       }
       get stagingDir() {
-        return path422.join(this.rootDir, "staging");
+        return path43.join(this.rootDir, "staging");
       }
       activeDir(channel) {
-        return path422.join(this.rootDir, "active", channel);
+        return path43.join(this.rootDir, "active", channel);
       }
       pointerPath(channel, providerType) {
-        return path422.join(this.activeDir(channel), `${providerType}.json`);
+        return path43.join(this.activeDir(channel), `${providerType}.json`);
       }
       log(msg) {
         this.logFn(`[ProviderChannelStore] ${msg}`);
@@ -106835,14 +107229,14 @@ Run 'adhdev doctor' for detailed diagnostics.`
       // ─── Staging ─────────────────────────────────────────────
       /** Create a fresh staging directory. Caller must clean it up (or gc will). */
       createStagingDir(kind) {
-        const dir = path422.join(this.stagingDir, `${kind}-${process.pid}-${crypto8.randomBytes(6).toString("hex")}`);
-        fs38.mkdirSync(dir, { recursive: true });
+        const dir = path43.join(this.stagingDir, `${kind}-${process.pid}-${crypto8.randomBytes(6).toString("hex")}`);
+        fs39.mkdirSync(dir, { recursive: true });
         return dir;
       }
       removeStagingDir(dir) {
-        if (!dir.startsWith(this.stagingDir + path422.sep)) return;
+        if (!dir.startsWith(this.stagingDir + path43.sep)) return;
         try {
-          fs38.rmSync(dir, { recursive: true, force: true });
+          fs39.rmSync(dir, { recursive: true, force: true });
         } catch {
         }
       }
@@ -106854,11 +107248,11 @@ Run 'adhdev doctor' for detailed diagnostics.`
         return digest.slice("sha256:".length);
       }
       getObjectDir(digest) {
-        return path422.join(this.objectsDir, _ProviderChannelStore.objectName(digest));
+        return path43.join(this.objectsDir, _ProviderChannelStore.objectName(digest));
       }
       hasObject(digest) {
         try {
-          return fs38.statSync(this.getObjectDir(digest)).isDirectory();
+          return fs39.statSync(this.getObjectDir(digest)).isDirectory();
         } catch {
           return false;
         }
@@ -106876,8 +107270,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
           this.removeStagingDir(stagedObjectDir);
           return objectDir;
         }
-        fs38.mkdirSync(this.objectsDir, { recursive: true });
-        fs38.renameSync(stagedObjectDir, objectDir);
+        fs39.mkdirSync(this.objectsDir, { recursive: true });
+        fs39.renameSync(stagedObjectDir, objectDir);
         return objectDir;
       }
       // ─── Pointers ────────────────────────────────────────────
@@ -106889,10 +107283,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
        */
       getPointer(channel, providerType) {
         const file2 = this.pointerPath(channel, providerType);
-        if (!fs38.existsSync(file2)) return null;
+        if (!fs39.existsSync(file2)) return null;
         let parsed;
         try {
-          parsed = JSON.parse(fs38.readFileSync(file2, "utf-8"));
+          parsed = JSON.parse(fs39.readFileSync(file2, "utf-8"));
         } catch (e) {
           throw new ProviderChannelError(
             "STORE_CORRUPT",
@@ -106920,7 +107314,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         const dir = this.activeDir(channel);
         let files = [];
         try {
-          files = fs38.readdirSync(dir).filter((f) => f.endsWith(".json"));
+          files = fs39.readdirSync(dir).filter((f) => f.endsWith(".json"));
         } catch {
           return { pointers, errors };
         }
@@ -106941,7 +107335,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         const activations = [];
         for (const pointer of pointers.values()) {
           const objectDir = this.getObjectDir(pointer.active.digest);
-          if (!fs38.existsSync(objectDir)) {
+          if (!fs39.existsSync(objectDir)) {
             errors.push(new ProviderChannelError(
               "STORE_CORRUPT",
               `active object ${pointer.active.digest} for "${pointer.active.providerType}" is missing \u2014 skipping (fail closed)`,
@@ -107010,9 +107404,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 (!fs38.existsSync(file2)) return false;
+        if (!fs39.existsSync(file2)) return false;
         try {
-          fs38.rmSync(file2, { force: true });
+          fs39.rmSync(file2, { force: true });
           return true;
         } catch {
           return false;
@@ -107020,11 +107414,11 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       writePointerAtomic(channel, providerType, pointer) {
         const dir = this.activeDir(channel);
-        fs38.mkdirSync(dir, { recursive: true });
+        fs39.mkdirSync(dir, { recursive: true });
         const file2 = this.pointerPath(channel, providerType);
-        const tmp = path422.join(dir, `.${providerType}.${process.pid}.${crypto8.randomBytes(4).toString("hex")}.tmp`);
-        fs38.writeFileSync(tmp, JSON.stringify(pointer, null, 2), "utf-8");
-        fs38.renameSync(tmp, file2);
+        const tmp = path43.join(dir, `.${providerType}.${process.pid}.${crypto8.randomBytes(4).toString("hex")}.tmp`);
+        fs39.writeFileSync(tmp, JSON.stringify(pointer, null, 2), "utf-8");
+        fs39.renameSync(tmp, file2);
       }
       // ─── GC (N=2 retention) ──────────────────────────────────
       /**
@@ -107040,13 +107434,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
           const dir = this.activeDir(channel);
           let files = [];
           try {
-            files = fs38.readdirSync(dir).filter((f) => f.endsWith(".json"));
+            files = fs39.readdirSync(dir).filter((f) => f.endsWith(".json"));
           } catch {
             continue;
           }
           for (const file2 of files) {
             try {
-              const parsed = JSON.parse(fs38.readFileSync(path422.join(dir, file2), "utf-8"));
+              const parsed = JSON.parse(fs39.readFileSync(path43.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 {
@@ -107056,7 +107450,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         const removedObjects = [];
         let objectNames = [];
         try {
-          objectNames = fs38.readdirSync(this.objectsDir);
+          objectNames = fs39.readdirSync(this.objectsDir);
         } catch {
           objectNames = [];
         }
@@ -107064,7 +107458,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           const digest = `sha256:${name}`;
           if (referenced.has(digest)) continue;
           try {
-            fs38.rmSync(path422.join(this.objectsDir, name), { recursive: true, force: true });
+            fs39.rmSync(path43.join(this.objectsDir, name), { recursive: true, force: true });
             removedObjects.push(digest);
           } catch {
           }
@@ -107072,13 +107466,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
         let removedStaging = 0;
         let stagingEntries = [];
         try {
-          stagingEntries = fs38.readdirSync(this.stagingDir);
+          stagingEntries = fs39.readdirSync(this.stagingDir);
         } catch {
           stagingEntries = [];
         }
         for (const name of stagingEntries) {
           try {
-            fs38.rmSync(path422.join(this.stagingDir, name), { recursive: true, force: true });
+            fs39.rmSync(path43.join(this.stagingDir, name), { recursive: true, force: true });
             removedStaging++;
           } catch {
           }
@@ -107089,10 +107483,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
         return { removedObjects, removedStaging };
       }
     };
-    var fs41 = __toESM2(require("fs"));
+    var fs422 = __toESM2(require("fs"));
+    var path45 = __toESM2(require("path"));
+    var fs40 = __toESM2(require("fs"));
     var path44 = __toESM2(require("path"));
-    var fs39 = __toESM2(require("fs"));
-    var path43 = __toESM2(require("path"));
     var import_crypto12 = require("crypto");
     var TREE_DIGEST_ALGORITHM = "adhdev-provider-tree-sha256-v1";
     function computeProviderTreeDigest(rootDir, providerType) {
@@ -107108,8 +107502,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
       relPaths.sort();
       const hash2 = (0, import_crypto12.createHash)("sha256");
       for (const relPath of relPaths) {
-        const absPath = path43.join(rootDir, ...relPath.split("/"));
-        const bytes = fs39.readFileSync(absPath);
+        const absPath = path44.join(rootDir, ...relPath.split("/"));
+        const bytes = fs40.readFileSync(absPath);
         hash2.update(relPath, "utf8");
         hash2.update("\0");
         hash2.update(String(bytes.length), "utf8");
@@ -107121,7 +107515,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     function collectRegularFiles(rootDir, dir, out, providerType) {
       let entries;
       try {
-        entries = fs39.readdirSync(dir, { withFileTypes: true });
+        entries = fs40.readdirSync(dir, { withFileTypes: true });
       } catch (e) {
         throw new ProviderChannelError(
           "ENTRY_TREE_INVALID",
@@ -107130,7 +107524,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         );
       }
       for (const entry of entries) {
-        const abs = path43.join(dir, entry.name);
+        const abs = path44.join(dir, entry.name);
         if (entry.isDirectory()) {
           collectRegularFiles(rootDir, abs, out, providerType);
           continue;
@@ -107142,16 +107536,16 @@ Run 'adhdev doctor' for detailed diagnostics.`
             providerType
           );
         }
-        const rel = path43.relative(rootDir, abs).split(path43.sep).join("/");
+        const rel = path44.relative(rootDir, abs).split(path44.sep).join("/");
         out.push(rel);
       }
     }
-    var fs40 = __toESM2(require("fs"));
+    var fs41 = __toESM2(require("fs"));
     var zlib = __toESM2(require("zlib"));
     var import_promises5 = require("stream/promises");
     async function extractTarballGz(tarPath, destDir) {
       const tarFs = require_tar_fs();
-      await (0, import_promises5.pipeline)(fs40.createReadStream(tarPath), zlib.createGunzip(), tarFs.extract(destDir));
+      await (0, import_promises5.pipeline)(fs41.createReadStream(tarPath), zlib.createGunzip(), tarFs.extract(destDir));
     }
     var REGISTRY_LIST_LIMIT = 100;
     var ProviderChannelRuntime = class {
@@ -107272,9 +107666,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
         const stagingRoot = this.store.createStagingDir("sync");
         try {
-          const tarPath = path44.join(stagingRoot, "providers.tar.gz");
-          const extractDir = path44.join(stagingRoot, "repo");
-          fs41.mkdirSync(extractDir, { recursive: true });
+          const tarPath = path45.join(stagingRoot, "providers.tar.gz");
+          const extractDir = path45.join(stagingRoot, "repo");
+          fs422.mkdirSync(extractDir, { recursive: true });
           try {
             await this.downloadFile(this.providerTarballUrl, tarPath);
             await this.extractTarball(tarPath, extractDir);
@@ -107331,9 +107725,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
         const objStaging = this.store.createStagingDir(`obj-${entry.providerType}`);
         let relDir;
         try {
-          relDir = path44.relative(repoRoot, artifactDir).split(path44.sep).join("/");
-          fs41.mkdirSync(path44.join(objStaging, entry.category), { recursive: true });
-          fs41.renameSync(artifactDir, path44.join(objStaging, entry.category, path44.basename(artifactDir)));
+          relDir = path45.relative(repoRoot, artifactDir).split(path45.sep).join("/");
+          fs422.mkdirSync(path45.join(objStaging, entry.category), { recursive: true });
+          fs422.renameSync(artifactDir, path45.join(objStaging, entry.category, path45.basename(artifactDir)));
         } catch (e) {
           this.store.removeStagingDir(objStaging);
           return { code: "TRANSPORT_FAILED", message: `failed to stage artifact tree: ${e?.message || e}`, providerType: entry.providerType };
@@ -107372,31 +107766,31 @@ Run 'adhdev doctor' for detailed diagnostics.`
     function findTarballRepoRoot(extractDir) {
       let entries;
       try {
-        entries = fs41.readdirSync(extractDir, { withFileTypes: true });
+        entries = fs422.readdirSync(extractDir, { withFileTypes: true });
       } catch {
         return null;
       }
       const dirs = entries.filter((e) => e.isDirectory());
       if (dirs.length !== 1) return null;
-      return path44.join(extractDir, dirs[0].name);
+      return path45.join(extractDir, dirs[0].name);
     }
     function locateArtifactDir(repoRoot, entry) {
-      const categoryDir = path44.join(repoRoot, entry.category);
+      const categoryDir = path45.join(repoRoot, entry.category);
       let candidates;
       try {
-        candidates = fs41.readdirSync(categoryDir, { withFileTypes: true });
+        candidates = fs422.readdirSync(categoryDir, { withFileTypes: true });
       } catch {
         return null;
       }
       for (const candidate of candidates) {
         if (!candidate.isDirectory()) continue;
         if (candidate.name.startsWith("_") || candidate.name.startsWith(".")) continue;
-        const dir = path44.join(categoryDir, candidate.name);
+        const dir = path45.join(categoryDir, candidate.name);
         for (const manifestName of ["provider.v1.json", "provider.json"]) {
-          const manifestPath = path44.join(dir, manifestName);
+          const manifestPath = path45.join(dir, manifestName);
           try {
-            if (!fs41.existsSync(manifestPath)) continue;
-            const manifest = JSON.parse(fs41.readFileSync(manifestPath, "utf-8"));
+            if (!fs422.existsSync(manifestPath)) continue;
+            const manifest = JSON.parse(fs422.readFileSync(manifestPath, "utf-8"));
             if (manifest?.type === entry.providerType) return dir;
             break;
           } catch {
@@ -107413,14 +107807,14 @@ Run 'adhdev doctor' for detailed diagnostics.`
       const scan = (dir) => {
         let entries;
         try {
-          entries = fs41.readdirSync(dir, { withFileTypes: true });
+          entries = fs422.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(fs41.readFileSync(path44.join(dir, manifest.name), "utf-8"));
+            const parsed = JSON.parse(fs422.readFileSync(path45.join(dir, manifest.name), "utf-8"));
             if (typeof parsed?.type === "string" && parsed.type.trim()) targets.add(parsed.type);
           } catch {
           }
@@ -107429,7 +107823,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         for (const entry of entries) {
           if (!entry.isDirectory()) continue;
           if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
-          scan(path44.join(dir, entry.name));
+          scan(path45.join(dir, entry.name));
         }
       };
       scan(upstreamDir);
@@ -107437,7 +107831,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     }
     function pathEnvDiagnostic() {
       const raw = process.env.PATH ?? "";
-      const entries = raw.split(path44.delimiter).filter((e) => e.length > 0);
+      const entries = raw.split(path45.delimiter).filter((e) => e.length > 0);
       const hasSystem32 = entries.some((e) => /system32$/i.test(e.replace(/[\\/]+$/, "")));
       return `platform=${process.platform} pathEntries=${entries.length} system32InPath=${hasSystem32}`;
     }
@@ -107485,7 +107879,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
               reject(new Error(`HTTP ${res.statusCode}`));
               return;
             }
-            const ws = fs41.createWriteStream(destPath);
+            const ws = fs422.createWriteStream(destPath);
             res.pipe(ws);
             ws.on("finish", () => {
               ws.close();
@@ -107628,9 +108022,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
       static siblingRefusalLogged = /* @__PURE__ */ new Set();
       static looksLikeProviderRoot(candidate) {
         try {
-          if (!fs422.existsSync(candidate) || !fs422.statSync(candidate).isDirectory()) return false;
+          if (!fs43.existsSync(candidate) || !fs43.statSync(candidate).isDirectory()) return false;
           return ["ide", "extension", "cli", "acp"].some(
-            (category) => fs422.existsSync(path46.join(candidate, category))
+            (category) => fs43.existsSync(path47.join(candidate, category))
           );
         } catch {
           return false;
@@ -107638,20 +108032,20 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       static hasProviderRootMarker(candidate) {
         try {
-          return fs422.existsSync(path46.join(candidate, _ProviderLoader.SIBLING_MARKER_FILE));
+          return fs43.existsSync(path47.join(candidate, _ProviderLoader.SIBLING_MARKER_FILE));
         } catch {
           return false;
         }
       }
       detectDefaultUserDir() {
-        const fallback = path46.join(getConfigDir2(), "providers");
+        const fallback = path47.join(getConfigDir2(), "providers");
         const envOptIn = process.env[_ProviderLoader.SIBLING_ENV_VAR] === "1";
         const visited = /* @__PURE__ */ new Set();
         for (const start of this.probeStarts) {
-          let current = path46.resolve(start);
+          let current = path47.resolve(start);
           while (!visited.has(current)) {
             visited.add(current);
-            const siblingCandidate = path46.join(path46.dirname(current), _ProviderLoader.REPO_PROVIDER_DIRNAME);
+            const siblingCandidate = path47.join(path47.dirname(current), _ProviderLoader.REPO_PROVIDER_DIRNAME);
             if (_ProviderLoader.looksLikeProviderRoot(siblingCandidate)) {
               const hasMarker = _ProviderLoader.hasProviderRootMarker(siblingCandidate);
               if (envOptIn || hasMarker) {
@@ -107688,7 +108082,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 }
               }
             }
-            const parent = path46.dirname(current);
+            const parent = path47.dirname(current);
             if (parent === current) break;
             current = parent;
           }
@@ -107704,11 +108098,11 @@ Run 'adhdev doctor' for detailed diagnostics.`
         this.channelStore = options?.channelStore === null ? null : options?.channelStore ?? new ProviderChannelStore(ProviderChannelStore.defaultRoot(), this.logFn);
         this.channelSyncIO = options?.channelSyncIO;
         this.daemonVersion = (options?.daemonVersion || "").trim().replace(/^v/, "");
-        this.defaultProvidersDir = path46.join(getConfigDir2(), "providers");
+        this.defaultProvidersDir = path47.join(getConfigDir2(), "providers");
         const detected = this.detectDefaultUserDir();
         this.userDir = detected.path;
         this.userDirSource = detected.source;
-        this.upstreamDir = path46.join(this.defaultProvidersDir, ".upstream");
+        this.upstreamDir = path47.join(this.defaultProvidersDir, ".upstream");
         this.disableUpstream = false;
         this.applySourceConfig({
           userDir: options?.userDir,
@@ -107720,14 +108114,14 @@ Run 'adhdev doctor' for detailed diagnostics.`
       migrateMarketplaceDirToExternal() {
         try {
           const configDir = getConfigDir2();
-          const oldDir = path46.join(configDir, "marketplace");
-          const newDir = path46.join(configDir, "external");
-          if (!fs422.existsSync(oldDir)) return;
-          if (fs422.existsSync(newDir)) {
+          const oldDir = path47.join(configDir, "marketplace");
+          const newDir = path47.join(configDir, "external");
+          if (!fs43.existsSync(oldDir)) return;
+          if (fs43.existsSync(newDir)) {
             this.log(`Migration skipped: both ~/.adhdev/marketplace and ~/.adhdev/external exist (marketplace dir is now inert and can be removed manually).`);
             return;
           }
-          fs422.renameSync(oldDir, newDir);
+          fs43.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}`);
@@ -107757,7 +108151,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
        * Highest-priority editable overrides come first.
        */
       getProviderRoots() {
-        const externalDir = path46.join(getConfigDir2(), "external");
+        const externalDir = path47.join(getConfigDir2(), "external");
         return [this.userDir, externalDir, ...this.channelObjectRoots, this.upstreamDir];
       }
       getSourceConfig() {
@@ -107785,7 +108179,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           this.userDir = detected.path;
           this.userDirSource = detected.source;
         }
-        this.upstreamDir = path46.join(this.defaultProvidersDir, ".upstream");
+        this.upstreamDir = path47.join(this.defaultProvidersDir, ".upstream");
         this.disableUpstream = this.sourceMode === "no-upstream";
         if (this.explicitProviderDir) {
           this.log(`Config 'providerDir' applied: ${this.userDir}`);
@@ -107799,7 +108193,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       * Canonical provider directory shape for a given root.
       */
       getProviderDir(root, category, type2) {
-        return path46.join(root, category, type2);
+        return path47.join(root, category, type2);
       }
       /**
       * Canonical user override directory for a provider.
@@ -107826,7 +108220,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       resolveProviderFile(type2, ...segments) {
         const dir = this.findProviderDirInternal(type2);
         if (!dir) return null;
-        return path46.join(dir, ...segments);
+        return path47.join(dir, ...segments);
       }
       /**
       * Load all providers (3-tier priority)
@@ -107847,7 +108241,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         this.providers.clear();
         this.providerAvailability.clear();
         let upstreamCount = 0;
-        if (!this.disableUpstream && fs422.existsSync(this.upstreamDir)) {
+        if (!this.disableUpstream && fs43.existsSync(this.upstreamDir)) {
           upstreamCount = this.loadDir(this.upstreamDir);
           if (upstreamCount > 0) {
             this.log(`Loaded ${upstreamCount} upstream providers (auto-updated)`);
@@ -107856,11 +108250,11 @@ Run 'adhdev doctor' for detailed diagnostics.`
           this.log("Upstream loading disabled (sourceMode=no-upstream)");
         }
         this.loadVerifiedChannelActivations();
-        const externalDir = path46.join(getConfigDir2(), "external");
-        if (fs422.existsSync(externalDir)) {
+        const externalDir = path47.join(getConfigDir2(), "external");
+        if (fs43.existsSync(externalDir)) {
           const rootEntries = (() => {
             try {
-              return fs422.readdirSync(externalDir, { withFileTypes: true });
+              return fs43.readdirSync(externalDir, { withFileTypes: true });
             } catch {
               return [];
             }
@@ -107878,7 +108272,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
             const ambiguousTypes = [];
             for (const sourceEntry of rootEntries) {
               if (!sourceEntry.isDirectory()) continue;
-              const sourceDir = path46.join(externalDir, sourceEntry.name);
+              const sourceDir = path47.join(externalDir, sourceEntry.name);
               const sourceLoaded = this.loadDir(sourceDir);
               if (sourceLoaded > 0) {
                 totalLoaded += sourceLoaded;
@@ -107894,7 +108288,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 ambiguousTypes.push({ type: type2, chosen: resolved.source ?? "?", candidates: resolved.candidates });
               }
               if (resolved.source && resolved.source !== "?") {
-                const sourceDir = path46.join(externalDir, resolved.source);
+                const sourceDir = path47.join(externalDir, resolved.source);
                 const reloadCount = this.loadDir(sourceDir);
                 if (reloadCount === 0) {
                   this.log(`Active source "${resolved.source}" no longer provides ${type2}`);
@@ -107909,7 +108303,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
             }
           }
         }
-        if (fs422.existsSync(this.userDir)) {
+        if (fs43.existsSync(this.userDir)) {
           const userCount = this.loadDir(this.userDir, [".upstream"]);
           if (userCount > 0) {
             this.log(`Loaded ${userCount} user custom providers (never auto-updated)`);
@@ -108047,18 +108441,18 @@ Run 'adhdev doctor' for detailed diagnostics.`
         if (this.countVerifiedChannelPointers() > 0) return null;
         if (this.hasUpstream()) return this.syncVerifiedChannel();
         try {
-          fs422.mkdirSync(this.defaultProvidersDir, { recursive: true });
+          fs43.mkdirSync(this.defaultProvidersDir, { recursive: true });
         } catch {
         }
         return this.syncVerifiedChannel({ bootstrapAll: true });
       }
       /** Stamp path recording which daemon version last ran a successful verified sync. */
       channelActivationStampPath() {
-        return path46.join(this.defaultProvidersDir, ".channel-activation-stamp.json");
+        return path47.join(this.defaultProvidersDir, ".channel-activation-stamp.json");
       }
       readChannelActivationStamp() {
         try {
-          return JSON.parse(fs422.readFileSync(this.channelActivationStampPath(), "utf-8"));
+          return JSON.parse(fs43.readFileSync(this.channelActivationStampPath(), "utf-8"));
         } catch {
           return null;
         }
@@ -108066,8 +108460,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
       writeChannelActivationStamp() {
         if (!this.daemonVersion) return;
         try {
-          fs422.mkdirSync(this.defaultProvidersDir, { recursive: true });
-          fs422.writeFileSync(this.channelActivationStampPath(), JSON.stringify({
+          fs43.mkdirSync(this.defaultProvidersDir, { recursive: true });
+          fs43.writeFileSync(this.channelActivationStampPath(), JSON.stringify({
             daemonVersion: this.daemonVersion,
             channel: this.channel,
             syncedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -108211,10 +108605,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
        * Check if upstream directory exists and has providers.
        */
       hasUpstream() {
-        if (!fs422.existsSync(this.upstreamDir)) return false;
+        if (!fs43.existsSync(this.upstreamDir)) return false;
         try {
-          return fs422.readdirSync(this.upstreamDir).some(
-            (d) => fs422.statSync(path46.join(this.upstreamDir, d)).isDirectory()
+          return fs43.readdirSync(this.upstreamDir).some(
+            (d) => fs43.statSync(path47.join(this.upstreamDir, d)).isDirectory()
           );
         } catch {
           return false;
@@ -108762,8 +109156,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
                     resolved._resolvedScriptDir = entry.scriptDir;
                     resolved._resolvedScriptsSource = `compatibility:${entry.ideVersion}`;
                     if (providerDir) {
-                      const fullDir = path46.join(providerDir, entry.scriptDir);
-                      resolved._resolvedScriptsPath = fs422.existsSync(path46.join(fullDir, "scripts.js")) ? path46.join(fullDir, "scripts.js") : fullDir;
+                      const fullDir = path47.join(providerDir, entry.scriptDir);
+                      resolved._resolvedScriptsPath = fs43.existsSync(path47.join(fullDir, "scripts.js")) ? path47.join(fullDir, "scripts.js") : fullDir;
                     }
                     matched = true;
                   }
@@ -108781,8 +109175,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 resolved._resolvedScriptDir = base.defaultScriptDir;
                 resolved._resolvedScriptsSource = "defaultScriptDir:version_miss";
                 if (providerDir) {
-                  const fullDir = path46.join(providerDir, base.defaultScriptDir);
-                  resolved._resolvedScriptsPath = fs422.existsSync(path46.join(fullDir, "scripts.js")) ? path46.join(fullDir, "scripts.js") : fullDir;
+                  const fullDir = path47.join(providerDir, base.defaultScriptDir);
+                  resolved._resolvedScriptsPath = fs43.existsSync(path47.join(fullDir, "scripts.js")) ? path47.join(fullDir, "scripts.js") : fullDir;
                 }
               }
               resolved._versionWarning = `Version ${currentVersion} not in compatibility matrix. Using default scripts.`;
@@ -108799,8 +109193,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
                   resolved._resolvedScriptDir = dirOverride;
                   resolved._resolvedScriptsSource = `versions:${range}`;
                   if (providerDir) {
-                    const fullDir = path46.join(providerDir, dirOverride);
-                    resolved._resolvedScriptsPath = fs422.existsSync(path46.join(fullDir, "scripts.js")) ? path46.join(fullDir, "scripts.js") : fullDir;
+                    const fullDir = path47.join(providerDir, dirOverride);
+                    resolved._resolvedScriptsPath = fs43.existsSync(path47.join(fullDir, "scripts.js")) ? path47.join(fullDir, "scripts.js") : fullDir;
                   }
                 }
               } else if (override.scripts) {
@@ -108816,8 +109210,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
             resolved._resolvedScriptDir = base.defaultScriptDir;
             resolved._resolvedScriptsSource = "defaultScriptDir:no_version";
             if (providerDir) {
-              const fullDir = path46.join(providerDir, base.defaultScriptDir);
-              resolved._resolvedScriptsPath = fs422.existsSync(path46.join(fullDir, "scripts.js")) ? path46.join(fullDir, "scripts.js") : fullDir;
+              const fullDir = path47.join(providerDir, base.defaultScriptDir);
+              resolved._resolvedScriptsPath = fs43.existsSync(path47.join(fullDir, "scripts.js")) ? path47.join(fullDir, "scripts.js") : fullDir;
             }
           }
         }
@@ -108834,13 +109228,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
           if (providerDir2) {
             for (const [scriptName, override] of Object.entries(base.overrides)) {
               if (!override || typeof override.path !== "string") continue;
-              const fullPath = path46.join(providerDir2, override.path);
-              if (!fs422.existsSync(fullPath)) {
+              const fullPath = path47.join(providerDir2, override.path);
+              if (!fs43.existsSync(fullPath)) {
                 this.log(`  [overrides] ${base.type}: ${scriptName} path not found: ${fullPath}`);
                 continue;
               }
               try {
-                registerProviderScriptRootSafely(path46.dirname(path46.dirname(providerDir2)));
+                registerProviderScriptRootSafely(path47.dirname(path47.dirname(providerDir2)));
                 delete require.cache[require.resolve(fullPath)];
                 const fn = require(fullPath);
                 const target = typeof fn === "function" ? fn : fn && fn[scriptName];
@@ -108865,25 +109259,25 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
         if (providerDir) {
           try {
-            const fs57 = require("fs");
-            const path55 = require("path");
+            const fs58 = require("fs");
+            const path56 = require("path");
             const candidates = [];
             if (Array.isArray(base.compatibility)) {
               for (const entry of base.compatibility) {
                 if (typeof entry?.spec !== "string") continue;
                 const matches = !entry.ideVersion || currentVersion && this.matchesVersion(currentVersion, entry.ideVersion) || !currentVersion;
-                if (matches) candidates.push(path55.join(providerDir, entry.spec));
+                if (matches) candidates.push(path56.join(providerDir, entry.spec));
               }
             }
-            candidates.push(path55.join(providerDir, "specs", "default.json"));
-            candidates.push(path55.join(providerDir, "spec.json"));
-            const specPath = candidates.find((p) => fs57.existsSync(p));
+            candidates.push(path56.join(providerDir, "specs", "default.json"));
+            candidates.push(path56.join(providerDir, "spec.json"));
+            const specPath = candidates.find((p) => fs58.existsSync(p));
             let nh;
             if (specPath) {
               resolved._resolvedSpecPath = specPath;
               let specControls;
               try {
-                const rawSpec = JSON.parse(fs57.readFileSync(specPath, "utf8"));
+                const rawSpec = JSON.parse(fs58.readFileSync(specPath, "utf8"));
                 specControls = rawSpec.control_bar;
                 nh = rawSpec.native_history;
               } catch {
@@ -108925,10 +109319,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
                   lister = (input) => executeNativeHistoryList(nh, input);
                 }
               } else if (nh.override_path) {
-                const overrideFile = path55.resolve(providerDir, nh.override_path);
-                if (fs57.existsSync(overrideFile)) {
+                const overrideFile = path56.resolve(providerDir, nh.override_path);
+                if (fs58.existsSync(overrideFile)) {
                   try {
-                    registerProviderScriptRootSafely(path55.dirname(path55.dirname(providerDir)));
+                    registerProviderScriptRootSafely(path56.dirname(path56.dirname(providerDir)));
                     delete require.cache[require.resolve(overrideFile)];
                     const mod = require(overrideFile);
                     const fn = typeof mod === "function" ? mod : mod && typeof mod.default === "function" ? mod.default : null;
@@ -108943,6 +109337,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 const dispatch = createNativeHistoryDispatcher(nh.reader);
                 format = nh.reader;
                 reader = (input) => dispatch(input);
+                const listDispatch = createNativeHistoryListDispatcher(nh.reader);
+                if (listDispatch) lister = (input) => listDispatch(input);
               }
               if (reader) {
                 resolved.scripts = { ...resolved.scripts || {} };
@@ -108976,16 +109372,16 @@ Run 'adhdev doctor' for detailed diagnostics.`
           this.debugLog(`[loadScriptsFromDir] ${type2}: providerDir not found`);
           return null;
         }
-        const dir = path46.join(providerDir, scriptDir);
-        if (!fs422.existsSync(dir)) {
+        const dir = path47.join(providerDir, scriptDir);
+        if (!fs43.existsSync(dir)) {
           this.debugLog(`[loadScriptsFromDir] ${type2}: dir not found: ${dir}`);
           return null;
         }
-        registerProviderScriptRootSafely(path46.dirname(path46.dirname(providerDir)));
+        registerProviderScriptRootSafely(path47.dirname(path47.dirname(providerDir)));
         const cached5 = this.scriptsCache.get(dir);
         if (cached5) return cached5;
-        const scriptsJs = path46.join(dir, "scripts.js");
-        if (fs422.existsSync(scriptsJs)) {
+        const scriptsJs = path47.join(dir, "scripts.js");
+        if (fs43.existsSync(scriptsJs)) {
           try {
             delete require.cache[require.resolve(scriptsJs)];
             const loaded = require(scriptsJs);
@@ -109006,9 +109402,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
       watch() {
         this.stopWatch();
         const watchDir = (dir) => {
-          if (!fs422.existsSync(dir)) {
+          if (!fs43.existsSync(dir)) {
             try {
-              fs422.mkdirSync(dir, { recursive: true });
+              fs43.mkdirSync(dir, { recursive: true });
             } catch {
               return;
             }
@@ -109029,7 +109425,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
               if (filePath.endsWith(".js") || filePath.endsWith(".json")) {
                 if (reloadTimer) clearTimeout(reloadTimer);
                 reloadTimer = setTimeout(() => {
-                  this.log(`File changed: ${path46.basename(filePath)}, reloading...`);
+                  this.log(`File changed: ${path47.basename(filePath)}, reloading...`);
                   this.reload();
                 }, 300);
               }
@@ -109071,15 +109467,15 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       /** Count provider files (provider.v1.json or provider.json — at most one per dir). */
       countProviders(dir) {
-        if (!fs422.existsSync(dir)) return 0;
+        if (!fs43.existsSync(dir)) return 0;
         let count = 0;
         const scan = (d) => {
           try {
-            const entries = fs422.readdirSync(d, { withFileTypes: true });
+            const entries = fs43.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) {
-              if (entry.isDirectory()) scan(path46.join(d, entry.name));
+              if (entry.isDirectory()) scan(path47.join(d, entry.name));
             }
           } catch {
           }
@@ -109305,13 +109701,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
         if (!provider) return null;
         const cat = provider.category;
         const searchRoots = this.getProviderRoots();
-        const hasManifest = (dir) => fs422.existsSync(path46.join(dir, "provider.v1.json")) || fs422.existsSync(path46.join(dir, "provider.json"));
+        const hasManifest = (dir) => fs43.existsSync(path47.join(dir, "provider.v1.json")) || fs43.existsSync(path47.join(dir, "provider.json"));
         const readManifestType = (dir) => {
           for (const file2 of ["provider.v1.json", "provider.json"]) {
-            const p = path46.join(dir, file2);
-            if (!fs422.existsSync(p)) continue;
+            const p = path47.join(dir, file2);
+            if (!fs43.existsSync(p)) continue;
             try {
-              const data = JSON.parse(fs422.readFileSync(p, "utf-8"));
+              const data = JSON.parse(fs43.readFileSync(p, "utf-8"));
               if (typeof data?.type === "string") return data.type;
             } catch {
             }
@@ -109319,15 +109715,15 @@ Run 'adhdev doctor' for detailed diagnostics.`
           return null;
         };
         for (const root of searchRoots) {
-          if (!fs422.existsSync(root)) continue;
+          if (!fs43.existsSync(root)) continue;
           const candidate = this.getProviderDir(root, cat, type2);
           if (hasManifest(candidate)) return candidate;
-          const catDir = path46.join(root, cat);
-          if (fs422.existsSync(catDir)) {
+          const catDir = path47.join(root, cat);
+          if (fs43.existsSync(catDir)) {
             try {
-              for (const entry of fs422.readdirSync(catDir, { withFileTypes: true })) {
+              for (const entry of fs43.readdirSync(catDir, { withFileTypes: true })) {
                 if (!entry.isDirectory()) continue;
-                const entryDir = path46.join(catDir, entry.name);
+                const entryDir = path47.join(catDir, entry.name);
                 const manifestType = readManifestType(entryDir);
                 if (manifestType === type2) return entryDir;
               }
@@ -109343,8 +109739,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
        * (template substitution is NOT applied here — scripts.js handles that)
        */
       buildScriptWrappersFromDir(dir) {
-        const scriptsJs = path46.join(dir, "scripts.js");
-        if (fs422.existsSync(scriptsJs)) {
+        const scriptsJs = path47.join(dir, "scripts.js");
+        if (fs43.existsSync(scriptsJs)) {
           try {
             delete require.cache[require.resolve(scriptsJs)];
             return require(scriptsJs);
@@ -109354,13 +109750,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 fs422.readdirSync(dir)) {
+          for (const file2 of fs43.readdirSync(dir)) {
             if (!file2.endsWith(".js")) continue;
             const scriptName = toCamel(file2.replace(".js", ""));
-            const filePath = path46.join(dir, file2);
+            const filePath = path47.join(dir, file2);
             result[scriptName] = (...args) => {
               try {
-                let content = fs422.readFileSync(filePath, "utf-8");
+                let content = fs43.readFileSync(filePath, "utf-8");
                 if (args[0] && typeof args[0] === "object") {
                   for (const [key2, val] of Object.entries(args[0])) {
                     let v = val;
@@ -109406,12 +109802,12 @@ Run 'adhdev doctor' for detailed diagnostics.`
        * Structure: dir/category/agent-name/provider.{json,js}
        */
       loadDir(dir, excludeDirs) {
-        if (!fs422.existsSync(dir)) return 0;
+        if (!fs43.existsSync(dir)) return 0;
         let count = 0;
         const scan = (d) => {
           let entries;
           try {
-            entries = fs422.readdirSync(d, { withFileTypes: true });
+            entries = fs43.readdirSync(d, { withFileTypes: true });
           } catch {
             return;
           }
@@ -109419,9 +109815,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
           const hasJson = entries.some((e) => e.name === "provider.json");
           if (hasV1 || hasJson) {
             const manifestFile = hasV1 ? "provider.v1.json" : "provider.json";
-            const jsonPath = path46.join(d, manifestFile);
+            const jsonPath = path47.join(d, manifestFile);
             try {
-              const raw = fs422.readFileSync(jsonPath, "utf-8");
+              const raw = fs43.readFileSync(jsonPath, "utf-8");
               const mod = JSON.parse(raw);
               if (hasV1 && mod?.category === "cli") {
                 try {
@@ -109459,10 +109855,10 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
                 this.log(`\u26A0 Invalid provider at ${jsonPath}: ${validation.errors.join("; ")}`);
               } else {
                 const hasCompatibility = Array.isArray(normalizedProvider.compatibility);
-                const scriptsPath = path46.join(d, "scripts.js");
-                if (!hasCompatibility && fs422.existsSync(scriptsPath)) {
+                const scriptsPath = path47.join(d, "scripts.js");
+                if (!hasCompatibility && fs43.existsSync(scriptsPath)) {
                   try {
-                    registerProviderScriptRootSafely(path46.dirname(path46.dirname(d)));
+                    registerProviderScriptRootSafely(path47.dirname(path47.dirname(d)));
                     delete require.cache[require.resolve(scriptsPath)];
                     const scripts = require(scriptsPath);
                     normalizedProvider.scripts = scripts;
@@ -109470,8 +109866,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
                     this.log(`\u26A0 Failed to load scripts: ${scriptsPath}: ${e.message}`);
                   }
                 }
-                const externalDirAbs = path46.join(getConfigDir2(), "external");
-                const isChannelStoreObject = d.includes(`${path46.sep}.store${path46.sep}`);
+                const externalDirAbs = path47.join(getConfigDir2(), "external");
+                const isChannelStoreObject = d.includes(`${path47.sep}.store${path47.sep}`);
                 const layer = d.startsWith(externalDirAbs) ? "external" : d.startsWith(this.userDir) && !d.includes(".upstream") && !isChannelStoreObject ? "user" : "upstream";
                 try {
                   const { inspectManifestShape: inspectManifestShape2, classifyTrust: classifyTrust2 } = (init_provider_trust(), __toCommonJS2(provider_trust_exports));
@@ -109481,8 +109877,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
                   normalizedProvider._sourceTrust = trust;
                   normalizedProvider._manifestShape = shape;
                   if (layer === "external") {
-                    const rel = path46.relative(externalDirAbs, d);
-                    const firstSeg = rel.split(path46.sep)[0];
+                    const rel = path47.relative(externalDirAbs, d);
+                    const firstSeg = rel.split(path47.sep)[0];
                     if (firstSeg && firstSeg !== "..") normalizedProvider._sourceName = firstSeg;
                   }
                 } catch {
@@ -109507,7 +109903,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
               if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
               if (d === dir && entry.name === "examples") continue;
               if (excludeDirs && d === dir && excludeDirs.includes(entry.name)) continue;
-              scan(path46.join(d, entry.name));
+              scan(path47.join(d, entry.name));
             }
           }
         };
@@ -109710,7 +110106,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       });
     }
     async function killIdeProcess(ideId) {
-      const plat = os26.platform();
+      const plat = os27.platform();
       const appName = getMacAppIdentifiers()[ideId];
       const winProcesses = getWinProcessNames()[ideId];
       try {
@@ -109771,7 +110167,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       }
     }
     async function isIdeRunning(ideId) {
-      const plat = os26.platform();
+      const plat = os27.platform();
       try {
         if (plat === "darwin") {
           const appName = getMacAppIdentifiers()[ideId];
@@ -109826,7 +110222,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       }
     }
     async function detectCurrentWorkspace(ideId) {
-      const plat = os26.platform();
+      const plat = os27.platform();
       if (plat === "darwin") {
         try {
           const appName = getMacAppIdentifiers()[ideId];
@@ -109841,17 +110237,17 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         }
       } else if (plat === "win32") {
         try {
-          const fs57 = require("fs");
+          const fs58 = require("fs");
           const appNameMap = getMacAppIdentifiers();
           const appName = appNameMap[ideId];
           if (appName) {
-            const storagePath = path47.join(
-              process.env.APPDATA || path47.join(os26.homedir(), "AppData", "Roaming"),
+            const storagePath = path48.join(
+              process.env.APPDATA || path48.join(os27.homedir(), "AppData", "Roaming"),
               appName,
               "storage.json"
             );
-            if (fs57.existsSync(storagePath)) {
-              const data = JSON.parse(fs57.readFileSync(storagePath, "utf-8"));
+            if (fs58.existsSync(storagePath)) {
+              const data = JSON.parse(fs58.readFileSync(storagePath, "utf-8"));
               const workspaces = data?.openedPathsList?.workspaces3 || data?.openedPathsList?.entries || [];
               if (workspaces.length > 0) {
                 const recent = workspaces[0];
@@ -109868,7 +110264,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       return void 0;
     }
     async function launchWithCdp(options = {}) {
-      const platform10 = os26.platform();
+      const platform10 = os27.platform();
       let targetIde;
       const ides = await detectIDEs(getProviderLoader());
       if (options.ideId) {
@@ -110431,11 +110827,11 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             MESH_JSON_CONFIG_LOCATIONS: MESH_JSON_CONFIG_LOCATIONS2
           } = await Promise.resolve().then(() => (init_mesh_json_config(), mesh_json_config_exports));
           const { mkdirSync: mkdirSync31, writeFileSync: writeFileSync31 } = await import("fs");
-          const { dirname: dirname23, join: join64 } = await import("path");
+          const { dirname: dirname24, join: join65 } = await import("path");
           const scaffold = buildMeshJsonConfigScaffold2(mesh);
           const scaffoldJson = serializeMeshJsonConfigScaffold2(scaffold);
           const relativePath = MESH_JSON_CONFIG_LOCATIONS2[0];
-          const absolutePath = join64(workspace, relativePath);
+          const absolutePath = join65(workspace, relativePath);
           const validation = normalizeRepoMeshDeclarativeConfig2(scaffold);
           if (!validation.valid) {
             return { success: false, meshId, error: `invalid mesh.json scaffold: ${validation.errors.join("; ")}` };
@@ -110471,7 +110867,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
               note: "Dry-run: nothing written. Re-run with write=true to persist to the repo (commit target). meshes.json is untouched."
             };
           }
-          mkdirSync31(dirname23(absolutePath), { recursive: true });
+          mkdirSync31(dirname24(absolutePath), { recursive: true });
           writeFileSync31(absolutePath, `${scaffoldJson}
 `, "utf-8");
           return {
@@ -110541,18 +110937,18 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             normalizeRepoMeshDeclarativeConfig: normalizeRepoMeshDeclarativeConfig2,
             MESH_JSON_CONFIG_LOCATIONS: MESH_JSON_CONFIG_LOCATIONS2
           } = await Promise.resolve().then(() => (init_mesh_json_config(), mesh_json_config_exports));
-          const { existsSync: existsSync63, readFileSync: readFileSync53, mkdirSync: mkdirSync31, writeFileSync: writeFileSync31 } = await import("fs");
-          const { dirname: dirname23, join: join64 } = await import("path");
+          const { existsSync: existsSync65, readFileSync: readFileSync54, mkdirSync: mkdirSync31, writeFileSync: writeFileSync31 } = await import("fs");
+          const { dirname: dirname24, join: join65 } = await import("path");
           const yaml6 = await Promise.resolve().then(() => (init_js_yaml(), js_yaml_exports));
           const relativePath = MESH_JSON_CONFIG_LOCATIONS2[0];
           let baseDoc = { version: 1 };
-          let existingPath = join64(workspace, relativePath);
+          let existingPath = join65(workspace, relativePath);
           let existedAsYaml = false;
           for (const relative8 of MESH_JSON_CONFIG_LOCATIONS2) {
-            const candidate = join64(workspace, relative8);
-            if (!existsSync63(candidate)) continue;
+            const candidate = join65(workspace, relative8);
+            if (!existsSync65(candidate)) continue;
             try {
-              const text = readFileSync53(candidate, "utf-8");
+              const text = readFileSync54(candidate, "utf-8");
               const parsed = /\.json$/i.test(candidate) ? JSON.parse(text) : yaml6.load(text);
               if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
                 baseDoc = parsed;
@@ -110606,7 +111002,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
               note: "Dry-run: nothing written. Re-run with write=true to persist. Only the providerDefaults zone is merged; other repo zones are preserved."
             };
           }
-          mkdirSync31(dirname23(absolutePath), { recursive: true });
+          mkdirSync31(dirname24(absolutePath), { recursive: true });
           writeFileSync31(absolutePath, serialized, "utf-8");
           return {
             success: true,
@@ -111968,6 +112364,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     };
     init_dist();
     init_logger();
+    init_track_identity();
     init_mesh_turn_presentation();
     init_state_store();
     var RESTART_BLOCKING_STATES = /* @__PURE__ */ new Set(["generating", "waiting_approval", "waiting_choice", "finalizing", "starting"]);
@@ -112031,6 +112428,16 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     function normalizeRestartMode(value) {
       return value === "restart" ? "restart" : "upgrade";
     }
+    function withRestartTargetDaemon(result, selfDaemonId) {
+      return {
+        ...result,
+        restartTargetDaemon: {
+          daemonId: selfDaemonId || "unknown",
+          track: TRACK,
+          npmTag: IDENTITY.npmTag
+        }
+      };
+    }
     function restartWarnings(args) {
       const warnings = [];
       if (args.forced) {
@@ -112172,6 +112579,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           nodeDaemonId = typeof node?.daemonId === "string" ? node.daemonId.trim() : void 0;
         }
         const selfDaemonId = ctx.deps.statusInstanceId;
+        const finishHere = (result) => withRestartTargetDaemon(result, selfDaemonId);
         const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
         if (isRemote && ctx.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
           const forwarded = await ctx.deps.dispatchMeshCommand(nodeDaemonId, "restart_daemon_node", {
@@ -112184,26 +112592,26 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         if (args?.cancelWhenIdle === true) {
           const had = pendingDeferredRestarts.has(scheduleKey);
           clearPendingDeferredRestart(scheduleKey);
-          return { success: true, restarted: false, cancelled: had, deferredRestart: null };
+          return finishHere({ success: true, restarted: false, cancelled: had, deferredRestart: null });
         }
         if (args?.whenIdleStatus === true) {
-          return { success: true, restarted: false, deferredRestart: deferredRestartInfo(scheduleKey) };
+          return finishHere({ success: true, restarted: false, deferredRestart: deferredRestartInfo(scheduleKey) });
         }
         const blocking = collectBlockingSessions(ctx.deps, meshId);
         if (blocking.length > 0) {
           if (args?.force === true) {
             LOG2.warn("MeshRestart", `force restart over ${blocking.length} blocking session(s): ${blocking.map((b) => `${b.instanceId || "?"}(${b.status})`).join(", ")} \u2014 pendingOutboundQueue will be lost`);
-            return executeRestart(ctx.deps, args, { forced: true });
+            return finishHere(await executeRestart(ctx.deps, args, { forced: true }));
           }
           const foreignBlocking = blocking.filter((b) => !b.selfCoordinator || b.pendingOutbound);
           if (args?.selfOnly === true && foreignBlocking.length === 0) {
             LOG2.info("MeshRestart", `selfOnly restart: waiving ${blocking.length} self-coordinator session(s) for mesh ${meshId}`);
-            return executeRestart(ctx.deps, args, { forced: false });
+            return finishHere(await executeRestart(ctx.deps, args, { forced: false }));
           }
           if (args?.whenIdle === true) {
-            return scheduleDeferredRestart(ctx.deps, args, meshId, nodeId);
+            return finishHere(scheduleDeferredRestart(ctx.deps, args, meshId, nodeId));
           }
-          return {
+          return finishHere({
             success: false,
             restarted: false,
             code: "blocking_sessions",
@@ -112215,9 +112623,9 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
               whenIdle: "schedule the restart to run automatically once the daemon goes idle (safest)"
             },
             deferredRestart: deferredRestartInfo(scheduleKey)
-          };
+          });
         }
-        return executeRestart(ctx.deps, args, { forced: false });
+        return finishHere(await executeRestart(ctx.deps, args, { forced: false }));
       }
     };
     init_cli_detector();
@@ -112370,7 +112778,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       }
     };
     var import_path16 = require("path");
-    var fs43 = __toESM2(require("fs"));
+    var fs44 = __toESM2(require("fs"));
     init_logger();
     init_mesh_host_ownership();
     init_coordinator_registry();
@@ -112651,15 +113059,15 @@ ${ptyResult.output.slice(-2e3)}`);
             }
             if (cliType === "codex-cli") {
               const repoMcpConfigPath = (0, import_path16.join)(workspace, ".mcp.json");
-              if (fs43.existsSync(repoMcpConfigPath)) {
+              if (fs44.existsSync(repoMcpConfigPath)) {
                 try {
                   const repoMcpConfig = parseMeshCoordinatorMcpConfig(
-                    fs43.readFileSync(repoMcpConfigPath, "utf-8"),
+                    fs44.readFileSync(repoMcpConfigPath, "utf-8"),
                     "claude_mcp_json"
                   );
                   const existingServers2 = repoMcpConfig.mcpServers;
                   if (existingServers2 && typeof existingServers2 === "object" && !Array.isArray(existingServers2) && existingServers2[coordinatorSetup.serverName]) {
-                    fs43.writeFileSync(repoMcpConfigPath, serializeMeshCoordinatorMcpConfig({
+                    fs44.writeFileSync(repoMcpConfigPath, serializeMeshCoordinatorMcpConfig({
                       ...repoMcpConfig,
                       mcpServers: {
                         ...existingServers2,
@@ -112822,8 +113230,8 @@ ${ptyResult.output.slice(-2e3)}`);
               workspace
             };
           }
-          const { existsSync: existsSync63, readFileSync: readFileSync53, writeFileSync: writeFileSync31, copyFileSync: copyFileSync3, mkdirSync: mkdirSync31 } = await import("fs");
-          const { dirname: dirname23 } = await import("path");
+          const { existsSync: existsSync65, readFileSync: readFileSync54, writeFileSync: writeFileSync31, copyFileSync: copyFileSync3, mkdirSync: mkdirSync31 } = await import("fs");
+          const { dirname: dirname24 } = await import("path");
           const mcpConfigPath = coordinatorSetup.configPath;
           const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
           let hermesBaseConfig = null;
@@ -112860,21 +113268,21 @@ ${ptyResult.output.slice(-2e3)}`);
             ...mcpServerEnv ? { env: mcpServerEnv } : {}
           });
           try {
-            mkdirSync31(dirname23(mcpConfigPath), { recursive: true });
+            mkdirSync31(dirname24(mcpConfigPath), { recursive: true });
           } catch (error48) {
             const message = `Could not prepare MCP config path for automatic setup: ${error48?.message || error48}`;
             LOG2.error("MeshCoordinator", message);
             if (hermesManualFallback) return returnManualFallback(message);
             return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
           }
-          const hadExistingMcpConfig = existsSync63(mcpConfigPath);
+          const hadExistingMcpConfig = existsSync65(mcpConfigPath);
           let existingMcpConfig = hermesBaseConfig?.config || {};
           if (hermesBaseConfig) {
-            copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname23(mcpConfigPath));
+            copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname24(mcpConfigPath));
           }
           if (hadExistingMcpConfig) {
             try {
-              const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync53(mcpConfigPath, "utf-8"), configFormat);
+              const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync54(mcpConfigPath, "utf-8"), configFormat);
               const existingCoordinatorConfig = hermesManualFallback ? stripHermesCoordinatorTempModelProviderOverrides(parsedExistingMcpConfig) : parsedExistingMcpConfig;
               existingMcpConfig = { ...existingMcpConfig, ...existingCoordinatorConfig };
               copyFileSync3(mcpConfigPath, mcpConfigPath + ".backup");
@@ -112908,7 +113316,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const cliArgs = [];
           const launchEnv = {};
           if (configFormat === "hermes_config_yaml") {
-            launchEnv.HERMES_HOME = dirname23(mcpConfigPath);
+            launchEnv.HERMES_HOME = dirname24(mcpConfigPath);
             launchEnv.HERMES_IGNORE_USER_CONFIG = "";
           }
           let autoImportContextFilePath;
@@ -113028,7 +113436,7 @@ ${ptyResult.output.slice(-2e3)}`);
         }
       }
     };
-    var fs44 = __toESM2(require("fs"));
+    var fs45 = __toESM2(require("fs"));
     var import_os4 = require("os");
     init_config();
     init_git_status();
@@ -113076,10 +113484,10 @@ ${ptyResult.output.slice(-2e3)}`);
       }
     }
     function readRecord7(repoRoot) {
-      const path55 = (0, import_node_path4.resolve)(repoRoot, PREVIEW_DEPLOY_RECORD);
-      if (!(0, import_node_fs4.existsSync)(path55)) return null;
+      const path56 = (0, import_node_path4.resolve)(repoRoot, PREVIEW_DEPLOY_RECORD);
+      if (!(0, import_node_fs4.existsSync)(path56)) return null;
       try {
-        const parsed = JSON.parse((0, import_node_fs4.readFileSync)(path55, "utf8"));
+        const parsed = JSON.parse((0, import_node_fs4.readFileSync)(path56, "utf8"));
         return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
       } catch {
         return null;
@@ -113397,7 +113805,7 @@ ${ptyResult.output.slice(-2e3)}`);
               }
             }
             if (workspace) {
-              if (!fs44.existsSync(workspace)) {
+              if (!fs45.existsSync(workspace)) {
                 const inlineTransitGit = buildInlineMeshTransitGitStatus(node);
                 let remoteProbeApplied = false;
                 if (inlineTransitGit) {
@@ -113536,7 +113944,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 && fs44.existsSync(candidate));
+            const localRepoRoot = nodeStatuses.map((node) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace)).find((candidate) => !!candidate && fs45.existsSync(candidate));
             return localRepoRoot ? buildPreviewFreshness(localRepoRoot) : void 0;
           })();
           const asyncRefineJobs = buildMeshAsyncRefineJobs({
@@ -113668,7 +114076,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const { deriveMeshReviewInboxItems: deriveMeshReviewInboxItems2 } = await Promise.resolve().then(() => (init_mesh_review_inbox(), mesh_review_inbox_exports));
           const { readLedgerEntries: readLedgerEntries2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
           const { getGitDiffSummary: getGitDiffSummary2 } = await Promise.resolve().then(() => (init_git_diff(), git_diff_exports));
-          const { existsSync: existsSync63 } = await import("fs");
+          const { existsSync: existsSync65 } = await import("fs");
           const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
           const mesh = meshRecord?.mesh;
           if (!mesh) return { success: false, error: "Mesh not found" };
@@ -113687,7 +114095,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const derivation = deriveMeshReviewInboxItems2({ nodes: nodeStatuses, ledgerEntries });
           for (const item of derivation.items) {
             const workspace = item.workspace;
-            if (!workspace || !existsSync63(workspace)) continue;
+            if (!workspace || !existsSync65(workspace)) continue;
             const baseRef = item.defaultBranch ? `origin/${item.defaultBranch}` : "origin/main";
             try {
               const diffResult = await getGitDiffSummary2(workspace, { baseRef, maxFiles: 100 });
@@ -113734,8 +114142,8 @@ ${ptyResult.output.slice(-2e3)}`);
     );
     init_dist();
     init_logger();
-    var fs45 = __toESM2(require("fs"));
-    var path48 = __toESM2(require("path"));
+    var fs46 = __toESM2(require("fs"));
+    var path49 = __toESM2(require("path"));
     init_config_dir();
     var MAX_FILE_SIZE = 5 * 1024 * 1024;
     var MAX_DAYS = 7;
@@ -113780,10 +114188,10 @@ ${ptyResult.output.slice(-2e3)}`);
       const dirChanged = dir !== currentDir;
       currentDate2 = today;
       currentDir = dir;
-      currentFile = path48.join(dir, `commands-${today}.jsonl`);
+      currentFile = path49.join(dir, `commands-${today}.jsonl`);
       if (dirChanged) {
         try {
-          fs45.mkdirSync(dir, { recursive: true });
+          fs46.mkdirSync(dir, { recursive: true });
         } catch {
         }
         cleanOldFiles();
@@ -113791,7 +114199,7 @@ ${ptyResult.output.slice(-2e3)}`);
     }
     function cleanOldFiles() {
       try {
-        const files = fs45.readdirSync(currentDir).filter((f) => f.startsWith("commands-") && f.endsWith(".jsonl"));
+        const files = fs46.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);
@@ -113799,7 +114207,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const dateMatch = file2.match(/commands-(\d{4}-\d{2}-\d{2})/);
           if (dateMatch && dateMatch[1] < cutoffStr) {
             try {
-              fs45.unlinkSync(path48.join(currentDir, file2));
+              fs46.unlinkSync(path49.join(currentDir, file2));
             } catch {
             }
           }
@@ -113809,14 +114217,14 @@ ${ptyResult.output.slice(-2e3)}`);
     }
     function checkSize() {
       try {
-        const stat2 = fs45.statSync(currentFile);
+        const stat2 = fs46.statSync(currentFile);
         if (stat2.size > MAX_FILE_SIZE) {
           const backup = currentFile.replace(".jsonl", ".1.jsonl");
           try {
-            fs45.unlinkSync(backup);
+            fs46.unlinkSync(backup);
           } catch {
           }
-          fs45.renameSync(currentFile, backup);
+          fs46.renameSync(currentFile, backup);
         }
       } catch {
       }
@@ -113849,15 +114257,15 @@ ${ptyResult.output.slice(-2e3)}`);
           ...entry.error ? { err: entry.error } : {},
           ...entry.durationMs !== void 0 ? { ms: entry.durationMs } : {}
         });
-        fs45.appendFileSync(currentFile, line + "\n");
+        fs46.appendFileSync(currentFile, line + "\n");
       } catch {
       }
     }
     function getRecentCommands(count = 50) {
       try {
         refreshCurrentFile();
-        if (!fs45.existsSync(currentFile)) return [];
-        const content = fs45.readFileSync(currentFile, "utf-8");
+        if (!fs46.existsSync(currentFile)) return [];
+        const content = fs46.readFileSync(currentFile, "utf-8");
         const lines = content.trim().split("\n").filter(Boolean);
         return lines.slice(-count).map((line) => {
           try {
@@ -113882,9 +114290,10 @@ ${ptyResult.output.slice(-2e3)}`);
     }
     init_debug_trace();
     init_mesh_host_ownership();
-    var fs49 = __toESM2(require("fs"));
+    var fs50 = __toESM2(require("fs"));
     init_mesh_node_identity();
     var import_node_child_process10 = require("child_process");
+    var import_node_fs6 = require("fs");
     init_logger();
     init_debug_trace();
     init_dist();
@@ -113898,9 +114307,9 @@ ${ptyResult.output.slice(-2e3)}`);
     var execFileAsync4 = (0, import_node_util5.promisify)(import_node_child_process7.execFile);
     var GIT = process.platform === "win32" ? resolveWin32Executable("git") : "git";
     var MAX_CHANGED_FILES2 = 500;
-    function topLevel(path55) {
-      const slash = path55.indexOf("/");
-      return slash === -1 ? path55 : path55.slice(0, slash);
+    function topLevel(path56) {
+      const slash = path56.indexOf("/");
+      return slash === -1 ? path56 : path56.slice(0, slash);
     }
     async function analyzeMeshRefineNodeChangeArea(args) {
       const { nodeId, workspace, branch, baseRef, branchRef, diffCwd, submodulePaths } = args;
@@ -114003,27 +114412,27 @@ ${ptyResult.output.slice(-2e3)}`);
         return false;
       }
     }
-    async function assessScope(cwd, path55, baseRef, branchRef) {
+    async function assessScope(cwd, path56, baseRef, branchRef) {
       try {
-        if (!(0, import_node_fs5.existsSync)(cwd)) return { path: path55, verdict: "unknown", error: `path does not exist: ${cwd}` };
+        if (!(0, import_node_fs5.existsSync)(cwd)) return { path: path56, verdict: "unknown", error: `path does not exist: ${cwd}` };
         const liveBaseHead = await git2(cwd, ["rev-parse", baseRef]);
         const branchHead = await git2(cwd, ["rev-parse", branchRef]);
         if (!liveBaseHead || !branchHead) {
-          return { path: path55, verdict: "unknown", error: "could not resolve base or branch head" };
+          return { path: path56, verdict: "unknown", error: "could not resolve base or branch head" };
         }
         if (await isAncestor(cwd, liveBaseHead, branchHead)) {
-          return { path: path55, verdict: "clear", liveBaseHead };
+          return { path: path56, verdict: "clear", liveBaseHead };
         }
         let mergeBase;
         try {
           mergeBase = await git2(cwd, ["merge-base", liveBaseHead, branchHead]);
         } catch {
-          return { path: path55, verdict: "unknown", liveBaseHead, error: "no common merge base" };
+          return { path: path56, verdict: "unknown", liveBaseHead, error: "no common merge base" };
         }
-        if (!mergeBase) return { path: path55, verdict: "unknown", liveBaseHead, error: "empty merge base" };
-        return { path: path55, verdict: "diverged", liveBaseHead, mergeBase };
+        if (!mergeBase) return { path: path56, verdict: "unknown", liveBaseHead, error: "empty merge base" };
+        return { path: path56, verdict: "diverged", liveBaseHead, mergeBase };
       } catch (e) {
-        return { path: path55, verdict: "unknown", error: e?.message || String(e) };
+        return { path: path56, verdict: "unknown", error: e?.message || String(e) };
       }
     }
     async function resolveSubmodulePaths(repoRoot) {
@@ -114095,6 +114504,58 @@ ${ptyResult.output.slice(-2e3)}`);
       const verdict = scopes.some((s2) => s2.verdict === "diverged") ? "diverged" : scopes.some((s2) => s2.verdict === "unknown") ? "unknown" : "clear";
       return { verdict, scopes, touchedSubmodulePaths, durationMs: Date.now() - started };
     }
+    function classifyRefineTerminal(result) {
+      const refineCode = typeof result.code === "string" ? result.code : "";
+      const landing = extractRefineMergeLanding(result);
+      const isPostMergeWarning = result.success !== true && landing.merged && landing.pushed;
+      const kind = result.success === true ? "completed" : isPostMergeWarning ? "completed_with_warnings" : refineCode === "blocked_review" || refineCode === "worktree_missing" ? "blocked_review" : refineCode === "validation_failed" || refineCode === "validation_dependencies_missing" || refineCode === "missing_dependencies" || refineCode === "dependency_bootstrap_failed" || refineCode === "spawn_resolution_failed" || refineCode === "validation_unavailable" || refineCode === "output_limit_exceeded" ? "validation_failed" : refineCode === "submodule_reachability_failed" ? "submodule_reachability_failed" : refineCode === "merge_failed" || refineCode === "patch_equivalence_failed" || refineCode === "needs_rebase" || refineCode === "needs_rebase_with_conflicts" ? "merge_failed" : refineCode === "cleanup_failed" ? "cleanup_failed" : "merge_failed";
+      const clean = kind === "completed";
+      return { kind, landing, isPostMergeWarning, converged: clean || isPostMergeWarning, clean };
+    }
+    function refineTerminalNextStep(kind) {
+      switch (kind) {
+        case "blocked_review":
+          return "Request user review/approval before attempting to merge again.";
+        case "validation_failed":
+          return "Fix failing tests or configure validation.bootstrapCommands and retry mesh_refine_node.";
+        case "submodule_reachability_failed":
+          return "Push unreachable submodule commits to origin/main, then retry mesh_refine_node.";
+        case "merge_failed":
+          return "Resolve merge conflicts or patch equivalence issues, then retry mesh_refine_node.";
+        case "cleanup_failed":
+          return "Manually remove the worktree and retry or use mesh_remove_node.";
+        case "completed_with_warnings":
+          return "The merge IS on origin \u2014 do NOT re-run mesh_refine_node. Only the post-merge step below needs attention (worktree cleanup / submodule alignment); treat the branch as merged_to_main.";
+        default:
+          return "Inspect refineStages for the failing stage and retry.";
+      }
+    }
+    function buildRefineWorktreeMissingResult(nodeId, workspace, refineStages) {
+      return {
+        success: false,
+        code: "worktree_missing",
+        convergenceStatus: "blocked_review",
+        // Never auto-retried: re-running cannot recreate the worktree, and the node has
+        // most likely already converged.
+        retryable: false,
+        workspaceMissing: true,
+        error: `The worktree directory for node '${nodeId}' no longer exists (${workspace}); nothing was merged by this run. Worktree removal is the final step of a SUCCESSFUL refine, so this node was most likely already merged and cleaned up by an earlier job \u2014 verify with 'git -C <repoRoot> log --oneline' before acting. Do NOT re-run refine to "fix" this.`,
+        nextStep: "Verify whether the branch already merged into the base (it most likely did). If so, treat the node as merged_to_main and remove it from the mesh; only re-clone if the work is genuinely missing.",
+        refineStages,
+        finalBranchConvergenceState: {
+          baseBranch: void 0,
+          merged: false,
+          removed: true,
+          status: "blocked_review"
+        }
+      };
+    }
+    function extractRefineMergeLanding(result) {
+      const fbcs = result.finalBranchConvergenceState && typeof result.finalBranchConvergenceState === "object" ? result.finalBranchConvergenceState : void 0;
+      const merged = result.merged === true || result.mergedLocal === true || fbcs?.merged === true;
+      const pushed = result.pushed === true || fbcs?.pushed === true;
+      return { merged: !!merged, pushed: !!pushed && !!merged };
+    }
     init_repo_mesh_types();
     init_git_status();
     init_git_locale();
@@ -114103,7 +114564,7 @@ ${ptyResult.output.slice(-2e3)}`);
     init_refine_config();
     init_worktree_bootstrap_config();
     var import_path17 = require("path");
-    var fs46 = __toESM2(require("fs"));
+    var fs47 = __toESM2(require("fs"));
     var import_node_child_process9 = require("child_process");
     init_resolve_executable();
     var GIT3 = process.platform === "win32" ? resolveWin32Executable("git") : "git";
@@ -114132,12 +114593,12 @@ ${tail}`;
     function writeValidationFailureLog(workspace, index, candidate, streams, now = () => /* @__PURE__ */ new Date()) {
       try {
         const dir = (0, import_path17.join)(workspace, REFINE_VALIDATION_LOG_DIR);
-        fs46.mkdirSync(dir, { recursive: true });
+        fs47.mkdirSync(dir, { recursive: true });
         const stamp = now().toISOString().replace(/[:.]/g, "-");
         const file2 = (0, import_path17.join)(dir, `refine-${stamp}-${index}.log`);
         const asText = (v) => typeof v === "string" ? v : v == null ? "" : String(v);
         const shown = candidate.displayCommand || [candidate.command, ...candidate.args || []].join(" ");
-        fs46.writeFileSync(
+        fs47.writeFileSync(
           file2,
           `# refine validation failure
 # command: ${shown}
@@ -114214,7 +114675,7 @@ ${asText(streams.stderr)}
       const { execFileSync: execFileSync12 } = await import("child_process");
       const diffArgs = ["diff", "--patch", "--full-index", fromRef, toRef];
       if (excludePaths.length > 0) {
-        diffArgs.push("--", ".", ...excludePaths.map((path55) => `:(exclude)${path55}`));
+        diffArgs.push("--", ".", ...excludePaths.map((path56) => `:(exclude)${path56}`));
       }
       const diff = execFileSync12(GIT3, diffArgs, {
         cwd,
@@ -114559,9 +115020,9 @@ ${mergeTreeErr?.stderr || ""}`;
             if (!trimmed) continue;
             if (trimmed.startsWith("+")) {
               const parts = trimmed.slice(1).trim().split(/\s+/);
-              const path55 = parts[1] || parts[0] || "(unknown)";
+              const path56 = parts[1] || parts[0] || "(unknown)";
               submoduleHints.push({
-                path: path55,
+                path: path56,
                 reason: "submodule checked-out commit differs from the committed gitlink (pointer bump not committed on the root branch)"
               });
             }
@@ -114591,10 +115052,10 @@ ${mergeTreeErr?.stderr || ""}`;
     }
     function buildPatchEquivalenceSubmoduleConflictHint(repoRoot, baseHead, branchHead, output) {
       if (!/(submodule|160000)/i.test(output) || !/(conflict|failed to merge)/i.test(output)) return void 0;
-      const conflicts = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path55) => ({
-        path: path55,
-        baseCommit: readTreeObject(repoRoot, baseHead, path55),
-        branchCommit: readTreeObject(repoRoot, branchHead, path55)
+      const conflicts = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path56) => ({
+        path: path56,
+        baseCommit: readTreeObject(repoRoot, baseHead, path56),
+        branchCommit: readTreeObject(repoRoot, branchHead, path56)
       }));
       if (conflicts.length === 0) return void 0;
       return {
@@ -114620,11 +115081,11 @@ ${mergeTreeErr?.stderr || ""}`;
           if (!line.trim()) continue;
           const metaAndPath = line.split("	");
           const meta3 = metaAndPath[0] || "";
-          const path55 = metaAndPath[metaAndPath.length - 1]?.trim();
-          if (!path55) continue;
+          const path56 = metaAndPath[metaAndPath.length - 1]?.trim();
+          if (!path56) continue;
           const parts = meta3.split(/\s+/);
           if (parts[0]?.includes("160000") || parts[1]?.includes("160000")) {
-            paths.add(path55);
+            paths.add(path56);
           }
         }
         return [...paths].sort();
@@ -114632,9 +115093,9 @@ ${mergeTreeErr?.stderr || ""}`;
         return [];
       }
     }
-    function readTreeObject(repoRoot, ref, path55) {
+    function readTreeObject(repoRoot, ref, path56) {
       try {
-        const output = (0, import_node_child_process9.execFileSync)(GIT3, ["ls-tree", ref, "--", path55], {
+        const output = (0, import_node_child_process9.execFileSync)(GIT3, ["ls-tree", ref, "--", path56], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: 1024 * 1024
@@ -114657,7 +115118,7 @@ ${mergeTreeErr?.stderr || ""}`;
       if (!baseCommit || !branchCommit) return false;
       if (baseCommit === branchCommit) return true;
       try {
-        if (!fs46.existsSync(submoduleRepoPath)) return false;
+        if (!fs47.existsSync(submoduleRepoPath)) return false;
         (0, import_node_child_process9.execFileSync)(GIT3, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
         (0, import_node_child_process9.execFileSync)(GIT3, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
         (0, import_node_child_process9.execFileSync)(GIT3, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
@@ -114679,12 +115140,12 @@ ${mergeTreeErr?.stderr || ""}`;
           if (!line.trim()) continue;
           const metaAndPath = line.split("	");
           const meta3 = metaAndPath[0] || "";
-          const path55 = metaAndPath[metaAndPath.length - 1]?.trim();
-          if (!path55 || seen.has(path55)) continue;
-          seen.add(path55);
+          const path56 = metaAndPath[metaAndPath.length - 1]?.trim();
+          if (!path56 || seen.has(path56)) continue;
+          seen.add(path56);
           const parts = meta3.split(/\s+/);
           const isGitlink = !!(parts[0]?.includes("160000") || parts[1]?.includes("160000"));
-          result.push({ path: path55, isGitlink });
+          result.push({ path: path56, isGitlink });
         }
         return result;
       } catch {
@@ -114692,28 +115153,28 @@ ${mergeTreeErr?.stderr || ""}`;
       }
     }
     function collectFastForwardGitlinkPaths(repoRoot, baseHead, branchHead) {
-      return readChangedGitlinkPaths(repoRoot, baseHead, branchHead).filter((path55) => {
-        const baseCommit = readTreeObject(repoRoot, baseHead, path55);
-        const branchCommit = readTreeObject(repoRoot, branchHead, path55);
+      return readChangedGitlinkPaths(repoRoot, baseHead, branchHead).filter((path56) => {
+        const baseCommit = readTreeObject(repoRoot, baseHead, path56);
+        const branchCommit = readTreeObject(repoRoot, branchHead, path56);
         if (!baseCommit || !branchCommit) return false;
-        return isSubmoduleFastForward((0, import_path17.resolve)(repoRoot, path55), baseCommit, branchCommit);
+        return isSubmoduleFastForward((0, import_path17.resolve)(repoRoot, path56), baseCommit, branchCommit);
       });
     }
     function collectTrivialFastForwardGitlinkResolutions(worktreeRoot, baseRepoRoot, baseHead, branchHead) {
       const resolutions = [];
-      for (const path55 of readChangedGitlinkPaths(worktreeRoot, baseHead, branchHead)) {
-        const baseCommit = readTreeObject(baseRepoRoot, baseHead, path55);
-        const branchCommit = readTreeObject(worktreeRoot, branchHead, path55);
+      for (const path56 of readChangedGitlinkPaths(worktreeRoot, baseHead, branchHead)) {
+        const baseCommit = readTreeObject(baseRepoRoot, baseHead, path56);
+        const branchCommit = readTreeObject(worktreeRoot, branchHead, path56);
         if (!baseCommit || !branchCommit) continue;
-        const submoduleRepoPath = (0, import_path17.resolve)(worktreeRoot, path55);
-        ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path17.resolve)(baseRepoRoot, path55), baseCommit);
+        const submoduleRepoPath = (0, import_path17.resolve)(worktreeRoot, path56);
+        ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path17.resolve)(baseRepoRoot, path56), baseCommit);
         if (baseCommit === branchCommit) {
           continue;
         }
         if (isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit)) {
-          resolutions.push({ path: path55, rebasedCommit: branchCommit });
+          resolutions.push({ path: path56, rebasedCommit: branchCommit });
         } else if (isSubmoduleFastForward(submoduleRepoPath, branchCommit, baseCommit)) {
-          resolutions.push({ path: path55, rebasedCommit: baseCommit });
+          resolutions.push({ path: path56, rebasedCommit: baseCommit });
         }
       }
       return resolutions;
@@ -114721,7 +115182,7 @@ ${mergeTreeErr?.stderr || ""}`;
     function isSubmoduleDivergedSibling(submoduleRepoPath, baseCommit, branchCommit) {
       if (!baseCommit || !branchCommit || baseCommit === branchCommit) return false;
       try {
-        if (!fs46.existsSync(submoduleRepoPath)) return false;
+        if (!fs47.existsSync(submoduleRepoPath)) return false;
         (0, import_node_child_process9.execFileSync)(GIT3, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
         (0, import_node_child_process9.execFileSync)(GIT3, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
       } catch {
@@ -114793,7 +115254,7 @@ ${mergeTreeErr?.stderr || ""}`;
       } catch {
       }
       try {
-        if (!fs46.existsSync(submoduleRepoPath) || !fs46.existsSync(baseSubmoduleRepoPath)) return;
+        if (!fs47.existsSync(submoduleRepoPath) || !fs47.existsSync(baseSubmoduleRepoPath)) return;
         (0, import_node_child_process9.execFileSync)(GIT3, ["-c", "protocol.file.allow=always", "fetch", "-q", baseSubmoduleRepoPath, "+refs/heads/*:refs/adhdev-refine-base/*"], {
           cwd: submoduleRepoPath,
           stdio: ["ignore", "ignore", "pipe"]
@@ -114809,15 +115270,15 @@ ${mergeTreeErr?.stderr || ""}`;
       const gitlinks = [];
       const resolutions = [];
       let sawDiverged = false;
-      for (const path55 of changed) {
-        const baseCommit = readTreeObject(baseRepoRoot, baseHead, path55);
-        const branchCommit = readTreeObject(worktreeRoot, branchHead, path55);
-        const submoduleRepoPath = (0, import_path17.resolve)(worktreeRoot, path55);
+      for (const path56 of changed) {
+        const baseCommit = readTreeObject(baseRepoRoot, baseHead, path56);
+        const branchCommit = readTreeObject(worktreeRoot, branchHead, path56);
+        const submoduleRepoPath = (0, import_path17.resolve)(worktreeRoot, path56);
         if (baseCommit) {
-          ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path17.resolve)(baseRepoRoot, path55), baseCommit);
+          ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path17.resolve)(baseRepoRoot, path56), baseCommit);
         }
         if (!baseCommit || !branchCommit || !isSubmoduleDivergedSibling(submoduleRepoPath, baseCommit, branchCommit)) {
-          gitlinks.push({ path: path55, baseCommit, branchCommit, action: "skipped_not_diverged" });
+          gitlinks.push({ path: path56, baseCommit, branchCommit, action: "skipped_not_diverged" });
           continue;
         }
         sawDiverged = true;
@@ -114832,8 +115293,8 @@ ${mergeTreeErr?.stderr || ""}`;
             (0, import_node_child_process9.execFileSync)(GIT3, ["checkout", "-q", "--detach", publishedEquivalent], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
           } catch {
           }
-          gitlinks.push({ path: path55, baseCommit, branchCommit, rebasedCommit: publishedEquivalent, action: "converged_to_published" });
-          resolutions.push({ path: path55, baseCommit, branchCommit, rebasedCommit: publishedEquivalent });
+          gitlinks.push({ path: path56, baseCommit, branchCommit, rebasedCommit: publishedEquivalent, action: "converged_to_published" });
+          resolutions.push({ path: path56, baseCommit, branchCommit, rebasedCommit: publishedEquivalent });
           continue;
         }
         let rebasedCommit;
@@ -114850,7 +115311,7 @@ ${mergeTreeErr?.stderr || ""}`;
             (0, import_node_child_process9.execFileSync)(GIT3, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
           } catch {
           }
-          gitlinks.push({ path: path55, baseCommit, branchCommit, action: "rebase_conflict" });
+          gitlinks.push({ path: path56, baseCommit, branchCommit, action: "rebase_conflict" });
           return { converged: false, reason: "rebase_conflict", resolutions: [], gitlinks };
         }
         const branchWorkSurvived = (() => {
@@ -114872,11 +115333,11 @@ ${mergeTreeErr?.stderr || ""}`;
             (0, import_node_child_process9.execFileSync)(GIT3, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
           } catch {
           }
-          gitlinks.push({ path: path55, baseCommit, branchCommit, rebasedCommit, action: "rebase_dropped_branch_commits" });
+          gitlinks.push({ path: path56, baseCommit, branchCommit, rebasedCommit, action: "rebase_dropped_branch_commits" });
           return { converged: false, reason: "rebase_dropped_branch_commits", resolutions: [], gitlinks };
         }
-        gitlinks.push({ path: path55, baseCommit, branchCommit, rebasedCommit, action: "rebased" });
-        resolutions.push({ path: path55, baseCommit, branchCommit, rebasedCommit });
+        gitlinks.push({ path: path56, baseCommit, branchCommit, rebasedCommit, action: "rebased" });
+        resolutions.push({ path: path56, baseCommit, branchCommit, rebasedCommit });
       }
       if (!sawDiverged) {
         return { converged: false, reason: "not_diverged", resolutions: [], gitlinks };
@@ -114962,12 +115423,12 @@ ${mergeTreeErr?.stderr || ""}`;
       return { ok: true, branchHead };
     }
     function evaluateGitlinkTrivialFastForward(repoRoot, baseHead, branchHead) {
-      const changedGitlinks = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path55) => {
-        const baseCommit = readTreeObject(repoRoot, baseHead, path55);
-        const branchCommit = readTreeObject(repoRoot, branchHead, path55);
-        const submoduleRepoPath = (0, import_path17.resolve)(repoRoot, path55);
+      const changedGitlinks = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path56) => {
+        const baseCommit = readTreeObject(repoRoot, baseHead, path56);
+        const branchCommit = readTreeObject(repoRoot, branchHead, path56);
+        const submoduleRepoPath = (0, import_path17.resolve)(repoRoot, path56);
         const fastForward = !!baseCommit && !!branchCommit && isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit);
-        return { path: path55, baseCommit, branchCommit, fastForward };
+        return { path: path56, baseCommit, branchCommit, fastForward };
       });
       if (changedGitlinks.length === 0) {
         return { trivial: false, reason: "no_changed_gitlinks", gitlinks: changedGitlinks };
@@ -115018,7 +115479,7 @@ ${mergeTreeErr?.stderr || ""}`;
           maxBuffer: 1024 * 1024
         }).trim();
         if (!tree) return void 0;
-        const updates = paths.map((path55) => `160000 commit ${placeholderCommit}	${path55}`).join("\n");
+        const updates = paths.map((path56) => `160000 commit ${placeholderCommit}	${path56}`).join("\n");
         if (!updates) return tree;
         const tmpIndex = (0, import_path17.join)(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
         const env2 = { ...process.env, GIT_INDEX_FILE: tmpIndex };
@@ -115036,7 +115497,7 @@ ${mergeTreeErr?.stderr || ""}`;
           return newTree || void 0;
         } finally {
           try {
-            fs46.rmSync(tmpIndex, { force: true });
+            fs47.rmSync(tmpIndex, { force: true });
           } catch {
           }
         }
@@ -115111,7 +115572,7 @@ ${mergeTreeErr?.stderr || ""}`;
           return newTree || void 0;
         } finally {
           try {
-            fs46.rmSync(tmpIndex, { force: true });
+            fs47.rmSync(tmpIndex, { force: true });
           } catch {
           }
         }
@@ -115121,7 +115582,7 @@ ${mergeTreeErr?.stderr || ""}`;
     }
     async function alignRefinerySubmodulesAfterMerge(repoRoot, previousBaseHead, currentHead, options = {}) {
       const startedAt = Date.now();
-      const changedGitlinkPaths = readChangedGitlinkPaths(repoRoot, previousBaseHead, currentHead).filter((path55) => !(options.submoduleIgnorePaths || []).includes(path55));
+      const changedGitlinkPaths = readChangedGitlinkPaths(repoRoot, previousBaseHead, currentHead).filter((path56) => !(options.submoduleIgnorePaths || []).includes(path56));
       const preStatus = await getGitRepoStatus(repoRoot, {
         includeSubmodules: true,
         submoduleIgnorePaths: options.submoduleIgnorePaths,
@@ -115168,7 +115629,7 @@ ${mergeTreeErr?.stderr || ""}`;
           changedGitlinkPaths,
           outOfSyncPaths,
           updatedPaths: updatePaths,
-          verifiedPaths: updatePaths.filter((path55) => !remaining.some((submodule) => submodule.path === path55)),
+          verifiedPaths: updatePaths.filter((path56) => !remaining.some((submodule) => submodule.path === path56)),
           durationMs: Date.now() - startedAt,
           command: `git ${commandArgs.join(" ")}`,
           stdout: truncateValidationOutput(result.stdout),
@@ -115223,7 +115684,7 @@ ${mergeTreeErr?.stderr || ""}`;
           return { stdout: String(stdout || ""), stderr: String(stderr || ""), refspec };
         };
         const importCommitFromWorktreeSubmodule = async (submodulePath, worktreeSubmodulePath, commit) => {
-          if (!fs46.existsSync(worktreeSubmodulePath)) return false;
+          if (!fs47.existsSync(worktreeSubmodulePath)) return false;
           try {
             await runGit3(worktreeSubmodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
           } catch {
@@ -115260,7 +115721,7 @@ ${mergeTreeErr?.stderr || ""}`;
           };
           let submoduleDefaultBranch = "main";
           try {
-            if (!fs46.existsSync(submodulePath)) {
+            if (!fs47.existsSync(submodulePath)) {
               entry.error = `Submodule checkout missing at ${gitlink.path}`;
               entry.publishRequired = true;
               if (options.allowAutoPublishSubmoduleMainCommits === true) {
@@ -115513,9 +115974,9 @@ ${mergeTreeErr?.stderr || ""}`;
         return ["npm", "pnpm", "yarn", "bun"].includes(command) && candidate.args.some((arg) => arg === "run" || arg === "test" || arg === "exec");
       };
       const dependenciesLikelyMissing = (cwd) => {
-        if (!fs46.existsSync((0, import_path17.join)(cwd, "package.json"))) return false;
-        if (fs46.existsSync((0, import_path17.join)(cwd, "node_modules"))) return false;
-        return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs46.existsSync((0, import_path17.join)(cwd, lock)));
+        if (!fs47.existsSync((0, import_path17.join)(cwd, "package.json"))) return false;
+        if (fs47.existsSync((0, import_path17.join)(cwd, "node_modules"))) return false;
+        return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs47.existsSync((0, import_path17.join)(cwd, lock)));
       };
       const needsNodeModules = (candidate, cwd) => isPackageManagerValidation(candidate) && dependenciesLikelyMissing(cwd);
       const isDaemonScopedCommand = (candidate) => {
@@ -115745,7 +116206,16 @@ ${mergeTreeErr?.stderr || ""}`;
         "conflictPaths",
         "branchRefWarning",
         "residueWarning",
-        "branchRefDeleted"
+        "branchRefDeleted",
+        // GHOST-FAILURE: merge-landing facts. The coordinator sees ONLY this slim
+        // result; without these it cannot tell a pre-merge failure (nothing landed)
+        // from a post-merge one (the change IS on origin) without a manual git check.
+        "merged",
+        "mergedLocal",
+        "pushed",
+        "mergedSha",
+        "postMergeWarning",
+        "refineLanding"
       ]) {
         if (result[key2] !== void 0) slim[key2] = result[key2];
       }
@@ -116030,6 +116500,13 @@ ${mergeTreeErr?.stderr || ""}`;
       if (!node.isLocalWorktree || !node.workspace) {
         return { kind: "terminal", result: { success: false, error: `Refinery requires a local worktree node`, refineStages } };
       }
+      if (!(0, import_node_fs6.existsSync)(node.workspace)) {
+        recordMeshRefineStage(refineStages, "resolve_refs", "failed", Date.now(), {
+          workspace: node.workspace,
+          workspaceMissing: true
+        });
+        return { kind: "terminal", result: buildRefineWorktreeMissingResult(nodeId, node.workspace, refineStages) };
+      }
       const sourceNode = node.clonedFromNodeId ? mesh?.nodes.find((n) => meshNodeIdMatches(n, node.clonedFromNodeId)) : mesh?.nodes.find((n) => !n.isLocalWorktree);
       const repoRoot = sourceNode?.repoRoot || sourceNode?.workspace;
       if (!repoRoot) return { kind: "terminal", result: { success: false, error: "Source node repoRoot not found", refineStages } };
@@ -117567,11 +118044,10 @@ ${e?.stderr || ""}`;
       }
       const completedAt = (/* @__PURE__ */ new Date()).toISOString();
       const refineCode = typeof result.code === "string" ? result.code : "";
-      const refineTerminalKind = result.success === true ? "completed" : refineCode === "blocked_review" ? "blocked_review" : refineCode === "validation_failed" || refineCode === "validation_dependencies_missing" || refineCode === "missing_dependencies" || refineCode === "dependency_bootstrap_failed" || refineCode === "spawn_resolution_failed" || refineCode === "validation_unavailable" || refineCode === "output_limit_exceeded" ? "validation_failed" : refineCode === "submodule_reachability_failed" ? "submodule_reachability_failed" : refineCode === "merge_failed" || refineCode === "patch_equivalence_failed" || refineCode === "needs_rebase" || refineCode === "needs_rebase_with_conflicts" ? "merge_failed" : refineCode === "cleanup_failed" ? "cleanup_failed" : "merge_failed";
-      const isTerminalSuccess = refineTerminalKind === "completed";
-      const blockerContext = isTerminalSuccess ? void 0 : (() => {
+      const { kind: refineTerminalKind, landing, isPostMergeWarning, converged: isTerminalConverged, clean: isTerminalClean } = classifyRefineTerminal(result);
+      const blockerContext = isTerminalClean ? void 0 : (() => {
         const code = typeof result.code === "string" ? result.code : refineTerminalKind;
-        const stage = refineTerminalKind === "validation_failed" ? "validation" : refineTerminalKind === "submodule_reachability_failed" ? "submodule_reachability" : refineCode === "patch_equivalence_failed" ? "patch_equivalence" : refineCode === "needs_rebase" || refineCode === "needs_rebase_with_conflicts" ? "patch_equivalence" : refineTerminalKind === "merge_failed" ? "merge" : refineTerminalKind === "cleanup_failed" ? "cleanup" : "unknown";
+        const stage = refineTerminalKind === "validation_failed" ? "validation" : refineTerminalKind === "submodule_reachability_failed" ? "submodule_reachability" : refineCode === "patch_equivalence_failed" ? "patch_equivalence" : refineCode === "needs_rebase" || refineCode === "needs_rebase_with_conflicts" ? "patch_equivalence" : refineTerminalKind === "merge_failed" ? "merge" : refineTerminalKind === "cleanup_failed" ? "cleanup" : refineTerminalKind === "completed_with_warnings" ? refineCode === "post_merge_submodule_alignment_failed" ? "submodule_alignment" : "cleanup" : "unknown";
         const ctx = {
           stage,
           reason: code,
@@ -117619,14 +118095,23 @@ ${e?.stderr || ""}`;
         ...result,
         terminalKind: refineTerminalKind,
         ...blockerContext ? { blockerContext } : {},
-        ...result.nextStep === void 0 && !isTerminalSuccess ? {
-          nextStep: refineTerminalKind === "blocked_review" ? "Request user review/approval before attempting to merge again." : refineTerminalKind === "validation_failed" ? "Fix failing tests or configure validation.bootstrapCommands and retry mesh_refine_node." : refineTerminalKind === "submodule_reachability_failed" ? "Push unreachable submodule commits to origin/main, then retry mesh_refine_node." : refineTerminalKind === "merge_failed" ? "Resolve merge conflicts or patch equivalence issues, then retry mesh_refine_node." : refineTerminalKind === "cleanup_failed" ? "Manually remove the worktree and retry or use mesh_remove_node." : "Inspect refineStages for the failing stage and retry."
+        ...result.nextStep === void 0 && !isTerminalClean ? { nextStep: refineTerminalNextStep(refineTerminalKind) } : {},
+        // GHOST-FAILURE: explicit machine-readable landing verdict, present on EVERY
+        // terminal result (plain failures read merged:false) so a coordinator never
+        // has to run `git log` to tell whether the work landed.
+        refineLanding: {
+          merged: landing.merged,
+          pushed: landing.pushed,
+          converged: isTerminalConverged
+        },
+        ...isPostMergeWarning ? {
+          postMergeWarning: `Merge landed and was pushed to origin/${typeof result.into === "string" ? result.into : "base"}, but a post-merge step failed (${refineCode || "unknown"}). This node is CONVERGED \u2014 do not re-refine it.`
         } : {}
       };
       const terminalHandle = buildRefineJobHandle(self, {
         meshId: handle.meshId,
         nodeId: handle.targetNodeId,
-        status: isTerminalSuccess ? "completed" : "failed",
+        status: isTerminalConverged ? "completed" : "failed",
         startedAt: handle.startedAt,
         completedAt,
         jobId: handle.jobId,
@@ -117644,8 +118129,8 @@ ${e?.stderr || ""}`;
       self.terminalRefineJobs.set(key2, terminal);
       self.runningRefineJobs.delete(key2);
       self.invalidateAggregateMeshStatus(handle.meshId);
-      await appendRefineJobLedger(self, isTerminalSuccess ? "task_completed" : "task_failed", terminalHandle, normalizedResult);
-      queueRefineJobEvent(self, isTerminalSuccess ? "refine:completed" : "refine:failed", terminalHandle, normalizedResult);
+      await appendRefineJobLedger(self, isTerminalConverged ? "task_completed" : "task_failed", terminalHandle, normalizedResult);
+      queueRefineJobEvent(self, isTerminalConverged ? "refine:completed" : "refine:failed", terminalHandle, normalizedResult);
     }
     async function recordRefineAcceptBaseDivergence(self, handle, node) {
       try {
@@ -117712,7 +118197,7 @@ ${e?.stderr || ""}`;
       });
       return handle;
     }
-    var fs47 = __toESM2(require("fs"));
+    var fs48 = __toESM2(require("fs"));
     var import_node_os2 = require("os");
     var import_path18 = require("path");
     init_logger();
@@ -117768,14 +118253,14 @@ ${e?.stderr || ""}`;
       return false;
     }
     async function bestEffortRemoveWorktreeDir(self, dir) {
-      if (!dir || !fs47.existsSync(dir)) return { removed: true, residue: false };
+      if (!dir || !fs48.existsSync(dir)) return { removed: true, residue: false };
       const sleep3 = (ms) => new Promise((resolve30) => setTimeout(resolve30, ms));
       const ABSORB = /* @__PURE__ */ new Set(["EINVAL", "EPERM", "EBUSY", "ENOTEMPTY", "EACCES", "EMFILE", "ENFILE"]);
       let lastErr;
       for (let attempt = 0; attempt < 4; attempt++) {
         try {
-          fs47.rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-          if (!fs47.existsSync(dir)) return { removed: true, residue: false };
+          fs48.rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+          if (!fs48.existsSync(dir)) return { removed: true, residue: false };
           lastErr = new Error("directory still present after rmSync");
         } catch (e) {
           lastErr = e;
@@ -117786,7 +118271,7 @@ ${e?.stderr || ""}`;
         }
         await sleep3(150 * (attempt + 1));
       }
-      return fs47.existsSync(dir) ? { removed: false, residue: true, error: String(lastErr?.message || lastErr || "unknown rm error") } : { removed: true, residue: false };
+      return fs48.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.";
@@ -117799,10 +118284,10 @@ ${e?.stderr || ""}`;
           recoveryHint: "Inspect the mesh node record before removing it, or remove stale metadata manually only after confirming no managed worktree remains." + sessionPreservedNote
         };
       }
-      if (!fs47.existsSync(workspace)) return { ok: true };
+      if (!fs48.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 || !fs47.existsSync(repoRoot)) {
+      if (!repoRoot || !fs48.existsSync(repoRoot)) {
         return {
           ok: false,
           code: "mesh_worktree_cleanup_missing_source_repo",
@@ -117822,7 +118307,7 @@ ${e?.stderr || ""}`;
       const normalizePath2 = (value) => {
         const resolved = (0, import_path18.resolve)(value);
         try {
-          return fs47.realpathSync(resolved);
+          return fs48.realpathSync(resolved);
         } catch {
           return resolved;
         }
@@ -117893,13 +118378,13 @@ ${e?.stderr || ""}`;
           recoveryHint: "Inspect the mesh node record before removing it, or remove stale metadata manually only after confirming no managed worktree remains."
         };
       }
-      const worktreeExists = fs47.existsSync(workspace);
+      const worktreeExists = fs48.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 || !fs47.existsSync(repoRoot)) {
+      if (!repoRoot || !fs48.existsSync(repoRoot)) {
         return {
           success: false,
           code: "mesh_worktree_cleanup_missing_source_repo",
@@ -117919,7 +118404,7 @@ ${e?.stderr || ""}`;
       const normalizePath2 = (value) => {
         const resolved = (0, import_path18.resolve)(value);
         try {
-          return fs47.realpathSync(resolved);
+          return fs48.realpathSync(resolved);
         } catch {
           return resolved;
         }
@@ -118566,7 +119051,7 @@ ${e?.stderr || ""}`;
     var yaml5 = __toESM2(require_js_yaml());
     var import_os5 = require("os");
     var import_path19 = require("path");
-    var fs48 = __toESM2(require("fs"));
+    var fs49 = __toESM2(require("fs"));
     var MESH_COORDINATOR_AUTO_IMPORT_FORMATS = ["claude_mcp_json", "hermes_config_yaml", "opencode_json"];
     function isSupportedMeshCoordinatorConfigFormat(format) {
       return MESH_COORDINATOR_AUTO_IMPORT_FORMATS.includes(format);
@@ -118611,9 +119096,9 @@ ${e?.stderr || ""}`;
     function loadHermesCoordinatorBaseConfig(targetConfigPath) {
       const sourceHome = resolveHermesUserHome();
       const sourceConfigPath = (0, import_path19.join)(sourceHome, "config.yaml");
-      if (!fs48.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+      if (!fs49.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
       if ((0, import_path19.resolve)(sourceConfigPath) === (0, import_path19.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-      const parsed = parseMeshCoordinatorMcpConfig(fs48.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
+      const parsed = parseMeshCoordinatorMcpConfig(fs49.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
       const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
       return { config: baseConfig, sourceHome, sourceConfigPath };
     }
@@ -118650,9 +119135,9 @@ ${e?.stderr || ""}`;
       for (const fileName of [".env", "auth.json"]) {
         const sourcePath = (0, import_path19.join)(sourceHome, fileName);
         const targetPath = (0, import_path19.join)(targetHome, fileName);
-        if (!fs48.existsSync(sourcePath)) continue;
+        if (!fs49.existsSync(sourcePath)) continue;
         try {
-          fs48.copyFileSync(sourcePath, targetPath);
+          fs49.copyFileSync(sourcePath, targetPath);
         } catch (error48) {
           LOG2.warn("MeshCoordinator", `Could not copy Hermes ${fileName} into isolated coordinator home: ${error48?.message || error48}`);
         }
@@ -119167,7 +119652,7 @@ ${e?.stderr || ""}`;
           const nodeId = readInlineMeshNodeId(node);
           if (!nodeId || !tombstones.has(nodeId)) return true;
           const workspace = readStringValue(node?.workspace);
-          if (workspace && fs49.existsSync(workspace)) {
+          if (workspace && fs50.existsSync(workspace)) {
             tombstones.delete(nodeId);
             return true;
           }
@@ -121187,14 +121672,14 @@ ${e?.stderr || ""}`;
     };
     init_io_contracts();
     init_chat_message_normalization();
-    var fs50 = __toESM2(require("fs"));
-    var path49 = __toESM2(require("path"));
-    var os27 = __toESM2(require("os"));
+    var fs51 = __toESM2(require("fs"));
+    var path50 = __toESM2(require("path"));
+    var os28 = __toESM2(require("os"));
     var import_os6 = require("os");
     init_config();
     var import_child_process13 = require("child_process");
     function getArchivePath2() {
-      return path49.join(getConfigDir2(), "version-history.json");
+      return path50.join(getConfigDir2(), "version-history.json");
     }
     var MAX_ENTRIES_PER_PROVIDER = 20;
     var VersionArchive = class {
@@ -121204,8 +121689,8 @@ ${e?.stderr || ""}`;
       }
       load() {
         try {
-          if (fs50.existsSync(getArchivePath2())) {
-            this.history = JSON.parse(fs50.readFileSync(getArchivePath2(), "utf-8"));
+          if (fs51.existsSync(getArchivePath2())) {
+            this.history = JSON.parse(fs51.readFileSync(getArchivePath2(), "utf-8"));
           }
         } catch {
           this.history = {};
@@ -121242,8 +121727,8 @@ ${e?.stderr || ""}`;
       }
       save() {
         try {
-          fs50.mkdirSync(path49.dirname(getArchivePath2()), { recursive: true });
-          fs50.writeFileSync(getArchivePath2(), JSON.stringify(this.history, null, 2));
+          fs51.mkdirSync(path50.dirname(getArchivePath2()), { recursive: true });
+          fs51.writeFileSync(getArchivePath2(), JSON.stringify(this.history, null, 2));
         } catch {
         }
       }
@@ -121266,10 +121751,10 @@ ${e?.stderr || ""}`;
       for (const p of paths) {
         if (!p) continue;
         for (const ext of exes) {
-          const fullPath = path49.join(p, name + ext);
+          const fullPath = path50.join(p, name + ext);
           try {
-            if (fs50.existsSync(fullPath)) {
-              const stat2 = fs50.statSync(fullPath);
+            if (fs51.existsSync(fullPath)) {
+              const stat2 = fs51.statSync(fullPath);
               if (stat2.isFile() && (isWin || stat2.mode & 73)) {
                 return fullPath;
               }
@@ -121314,19 +121799,19 @@ ${e?.stderr || ""}`;
     function checkPathExists2(paths) {
       for (const p of paths) {
         if (p.includes("*")) {
-          const home = os27.homedir();
-          const resolved = p.replace(/\*/g, home.split(path49.sep).pop() || "");
-          if (fs50.existsSync(resolved)) return resolved;
+          const home = os28.homedir();
+          const resolved = p.replace(/\*/g, home.split(path50.sep).pop() || "");
+          if (fs51.existsSync(resolved)) return resolved;
         } else {
-          if (fs50.existsSync(p)) return p;
+          if (fs51.existsSync(p)) return p;
         }
       }
       return null;
     }
     async function getMacAppVersion(appPath) {
       if ((0, import_os6.platform)() !== "darwin" || !appPath.endsWith(".app")) return null;
-      const plistPath = path49.join(appPath, "Contents", "Info.plist");
-      if (!fs50.existsSync(plistPath)) return null;
+      const plistPath = path50.join(appPath, "Contents", "Info.plist");
+      if (!fs51.existsSync(plistPath)) return null;
       const raw = await runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
       return raw || null;
     }
@@ -121352,8 +121837,8 @@ ${e?.stderr || ""}`;
           const cliBin = provider.cli ? findBinary2(provider.cli) : null;
           let resolvedBin = cliBin;
           if (!resolvedBin && appPath && currentOs === "darwin") {
-            const bundled = path49.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
-            if (provider.cli && fs50.existsSync(bundled)) resolvedBin = bundled;
+            const bundled = path50.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
+            if (provider.cli && fs51.existsSync(bundled)) resolvedBin = bundled;
           }
           info.installed = !!(appPath || resolvedBin);
           info.path = appPath || null;
@@ -121399,8 +121884,8 @@ ${e?.stderr || ""}`;
       return results;
     }
     var http3 = __toESM2(require("http"));
-    var fs54 = __toESM2(require("fs"));
-    var path53 = __toESM2(require("path"));
+    var fs55 = __toESM2(require("fs"));
+    var path54 = __toESM2(require("path"));
     init_config();
     function generateFiles(type2, name, category, opts = {}) {
       const { cdpPorts, cli, processName, installPath, binary: binary2, extensionId, version: version2 = "0.1" } = opts;
@@ -121745,8 +122230,8 @@ async (params) => {
     }
     init_logger();
     init_builders();
-    var fs51 = __toESM2(require("fs"));
-    var path50 = __toESM2(require("path"));
+    var fs52 = __toESM2(require("fs"));
+    var path51 = __toESM2(require("path"));
     init_logger();
     async function handleCdpEvaluate(ctx, req, res) {
       const body = await ctx.readBody(req);
@@ -121925,18 +122410,18 @@ async (params) => {
         return;
       }
       let scriptsPath = "";
-      const directScripts = path50.join(dir, "scripts.js");
-      if (fs51.existsSync(directScripts)) {
+      const directScripts = path51.join(dir, "scripts.js");
+      if (fs52.existsSync(directScripts)) {
         scriptsPath = directScripts;
       } else {
-        const scriptsDir = path50.join(dir, "scripts");
-        if (fs51.existsSync(scriptsDir)) {
-          const versions = fs51.readdirSync(scriptsDir).filter((d) => {
-            return fs51.statSync(path50.join(scriptsDir, d)).isDirectory();
+        const scriptsDir = path51.join(dir, "scripts");
+        if (fs52.existsSync(scriptsDir)) {
+          const versions = fs52.readdirSync(scriptsDir).filter((d) => {
+            return fs52.statSync(path51.join(scriptsDir, d)).isDirectory();
           }).sort().reverse();
           for (const ver of versions) {
-            const p = path50.join(scriptsDir, ver, "scripts.js");
-            if (fs51.existsSync(p)) {
+            const p = path51.join(scriptsDir, ver, "scripts.js");
+            if (fs52.existsSync(p)) {
               scriptsPath = p;
               break;
             }
@@ -121948,7 +122433,7 @@ async (params) => {
         return;
       }
       try {
-        const source = fs51.readFileSync(scriptsPath, "utf-8");
+        const source = fs52.readFileSync(scriptsPath, "utf-8");
         const hints = {};
         const funcRegex = /module\.exports\.(\w+)\s*=\s*function\s+\w+\s*\(params\)/g;
         let match;
@@ -122761,8 +123246,8 @@ async (params) => {
         ctx.json(res, 500, { error: `DOM context collection failed: ${e.message}` });
       }
     }
-    var fs52 = __toESM2(require("fs"));
-    var path51 = __toESM2(require("path"));
+    var fs53 = __toESM2(require("fs"));
+    var path522 = __toESM2(require("path"));
     function slugifyFixtureName(value) {
       const normalized = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
       return normalized || `fixture-${Date.now()}`;
@@ -122772,15 +123257,15 @@ async (params) => {
       if (!providerDir) {
         throw new Error(`Provider directory not found for '${type2}'`);
       }
-      return path51.join(providerDir, "fixtures");
+      return path522.join(providerDir, "fixtures");
     }
     function readCliFixture(ctx, type2, name) {
       const fixtureDir = getCliFixtureDir(ctx, type2);
-      const filePath = path51.join(fixtureDir, `${name}.json`);
-      if (!fs52.existsSync(filePath)) {
+      const filePath = path522.join(fixtureDir, `${name}.json`);
+      if (!fs53.existsSync(filePath)) {
         throw new Error(`Fixture not found: ${filePath}`);
       }
-      return JSON.parse(fs52.readFileSync(filePath, "utf-8"));
+      return JSON.parse(fs53.readFileSync(filePath, "utf-8"));
     }
     function getExerciseTranscriptText(result) {
       const parts = [];
@@ -123525,7 +124010,7 @@ async (params) => {
           return;
         }
         const fixtureDir = getCliFixtureDir(ctx, type2);
-        fs52.mkdirSync(fixtureDir, { recursive: true });
+        fs53.mkdirSync(fixtureDir, { recursive: true });
         const name = slugifyFixtureName(String(body?.name || `${type2}-${Date.now()}`));
         const result = await runCliExerciseInternal(ctx, { ...request, type: type2 });
         const fixture = {
@@ -123552,8 +124037,8 @@ async (params) => {
           },
           notes: typeof body?.notes === "string" ? body.notes : void 0
         };
-        const filePath = path51.join(fixtureDir, `${name}.json`);
-        fs52.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
+        const filePath = path522.join(fixtureDir, `${name}.json`);
+        fs53.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
         ctx.json(res, 200, {
           saved: true,
           name,
@@ -123571,14 +124056,14 @@ async (params) => {
     async function handleCliFixtureList(ctx, type2, _req, res) {
       try {
         const fixtureDir = getCliFixtureDir(ctx, type2);
-        if (!fs52.existsSync(fixtureDir)) {
+        if (!fs53.existsSync(fixtureDir)) {
           ctx.json(res, 200, { fixtures: [], count: 0 });
           return;
         }
-        const fixtures = fs52.readdirSync(fixtureDir).filter((file2) => file2.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file2) => {
-          const fullPath = path51.join(fixtureDir, file2);
+        const fixtures = fs53.readdirSync(fixtureDir).filter((file2) => file2.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file2) => {
+          const fullPath = path522.join(fixtureDir, file2);
           try {
-            const raw = JSON.parse(fs52.readFileSync(fullPath, "utf-8"));
+            const raw = JSON.parse(fs53.readFileSync(fullPath, "utf-8"));
             return {
               name: raw.name || file2.replace(/\.json$/i, ""),
               path: fullPath,
@@ -123709,9 +124194,9 @@ async (params) => {
         ctx.json(res, 500, { error: `Raw send failed: ${e.message}` });
       }
     }
-    var fs53 = __toESM2(require("fs"));
-    var path522 = __toESM2(require("path"));
-    var os28 = __toESM2(require("os"));
+    var fs54 = __toESM2(require("fs"));
+    var path53 = __toESM2(require("path"));
+    var os29 = __toESM2(require("os"));
     var import_session_host_core11 = require_dist();
     function getAutoImplPid(ctx) {
       const pid = ctx.autoImplProcess?.pid;
@@ -123758,38 +124243,38 @@ async (params) => {
       return fallback?.type || null;
     }
     function getLatestScriptVersionDir(scriptsDir) {
-      if (!fs53.existsSync(scriptsDir)) return null;
-      const versions = fs53.readdirSync(scriptsDir).filter((d) => {
+      if (!fs54.existsSync(scriptsDir)) return null;
+      const versions = fs54.readdirSync(scriptsDir).filter((d) => {
         try {
-          return fs53.statSync(path522.join(scriptsDir, d)).isDirectory();
+          return fs54.statSync(path53.join(scriptsDir, d)).isDirectory();
         } catch {
           return false;
         }
       }).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" }));
       if (versions.length === 0) return null;
-      return path522.join(scriptsDir, versions[0]);
+      return path53.join(scriptsDir, versions[0]);
     }
     function resolveAutoImplWritableProviderDir(ctx, category, type2, requestedDir) {
-      const canonicalUserDir = path522.resolve(ctx.providerLoader.getUserProviderDir(category, type2));
-      const desiredDir = requestedDir ? path522.resolve(requestedDir) : canonicalUserDir;
-      const upstreamRoot = path522.resolve(ctx.providerLoader.getUpstreamDir());
-      if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path522.sep}`)) {
+      const canonicalUserDir = path53.resolve(ctx.providerLoader.getUserProviderDir(category, type2));
+      const desiredDir = requestedDir ? path53.resolve(requestedDir) : canonicalUserDir;
+      const upstreamRoot = path53.resolve(ctx.providerLoader.getUpstreamDir());
+      if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path53.sep}`)) {
         return { dir: null, reason: `Refusing to write into upstream provider directory: ${desiredDir}` };
       }
-      if (path522.basename(desiredDir) !== type2) {
+      if (path53.basename(desiredDir) !== type2) {
         return { dir: null, reason: `Requested writable provider directory must end with '${type2}': ${desiredDir}` };
       }
       const sourceDir = ctx.findProviderDir(type2);
       if (!sourceDir) {
         return { dir: null, reason: `Provider source directory not found for '${type2}'` };
       }
-      if (!fs53.existsSync(desiredDir)) {
-        fs53.mkdirSync(path522.dirname(desiredDir), { recursive: true });
-        fs53.cpSync(sourceDir, desiredDir, { recursive: true });
+      if (!fs54.existsSync(desiredDir)) {
+        fs54.mkdirSync(path53.dirname(desiredDir), { recursive: true });
+        fs54.cpSync(sourceDir, desiredDir, { recursive: true });
         ctx.log(`Auto-implement writable copy created: ${desiredDir}`);
       }
-      const providerJson = path522.join(desiredDir, "provider.json");
-      if (!fs53.existsSync(providerJson)) {
+      const providerJson = path53.join(desiredDir, "provider.json");
+      if (!fs54.existsSync(providerJson)) {
         return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
       }
       return { dir: desiredDir };
@@ -123797,15 +124282,15 @@ async (params) => {
     function loadAutoImplReferenceScripts(ctx, referenceType) {
       if (!referenceType) return {};
       const refDir = ctx.findProviderDir(referenceType);
-      if (!refDir || !fs53.existsSync(refDir)) return {};
+      if (!refDir || !fs54.existsSync(refDir)) return {};
       const referenceScripts = {};
-      const scriptsDir = path522.join(refDir, "scripts");
+      const scriptsDir = path53.join(refDir, "scripts");
       const latestDir = getLatestScriptVersionDir(scriptsDir);
       if (!latestDir) return referenceScripts;
-      for (const file2 of fs53.readdirSync(latestDir)) {
+      for (const file2 of fs54.readdirSync(latestDir)) {
         if (!file2.endsWith(".js")) continue;
         try {
-          referenceScripts[file2] = fs53.readFileSync(path522.join(latestDir, file2), "utf-8");
+          referenceScripts[file2] = fs54.readFileSync(path53.join(latestDir, file2), "utf-8");
         } catch {
         }
       }
@@ -123913,16 +124398,16 @@ async (params) => {
         });
         const referenceScripts = loadAutoImplReferenceScripts(ctx, resolvedReference);
         const prompt = buildAutoImplPrompt(ctx, type2, provider, providerDir, functions, domContext, referenceScripts, comment, resolvedReference, verification);
-        const tmpDir = path522.join(os28.tmpdir(), "adhdev-autoimpl");
-        if (!fs53.existsSync(tmpDir)) fs53.mkdirSync(tmpDir, { recursive: true });
-        const promptFile = path522.join(tmpDir, `prompt-${type2}-${Date.now()}.md`);
-        fs53.writeFileSync(promptFile, prompt, "utf-8");
+        const tmpDir = path53.join(os29.tmpdir(), "adhdev-autoimpl");
+        if (!fs54.existsSync(tmpDir)) fs54.mkdirSync(tmpDir, { recursive: true });
+        const promptFile = path53.join(tmpDir, `prompt-${type2}-${Date.now()}.md`);
+        fs54.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 {
-            fs53.unlinkSync(promptFile);
+            fs54.unlinkSync(promptFile);
           } catch {
           }
           ctx.json(res, 400, { error: `Agent '${agent}' has no spawn config. Select a CLI provider with a spawn configuration.` });
@@ -124024,7 +124509,7 @@ async (params) => {
             } catch {
             }
             try {
-              fs53.unlinkSync(promptFile);
+              fs54.unlinkSync(promptFile);
             } catch {
             }
             ctx.log(`Auto-implement (ACP) ${success2 ? "completed" : "failed"}: ${type2} (exit: ${code})`);
@@ -124068,7 +124553,7 @@ async (params) => {
         const interactiveFlags = ["--yolo", "--interactive", "-i"];
         const baseArgs = [...spawn7.args || []].filter((a) => !interactiveFlags.includes(a));
         let shellCmd;
-        const isWin = os28.platform() === "win32";
+        const isWin = os29.platform() === "win32";
         const escapeArg = (a) => isWin ? `"${a.replace(/"/g, '""')}"` : `'${a.replace(/'/g, "'\\''")}'`;
         const promptMode = autoImpl?.promptMode ?? "stdin";
         const extraArgs = autoImpl?.extraArgs ?? [];
@@ -124107,7 +124592,7 @@ async (params) => {
         try {
           const pty = require("node-pty");
           ctx.log(`Auto-implement spawn (PTY): ${shellCmd}`);
-          const isWin2 = os28.platform() === "win32";
+          const isWin2 = os29.platform() === "win32";
           child = pty.spawn(isWin2 ? "cmd.exe" : process.env.SHELL || "/bin/zsh", [isWin2 ? "/c" : "-c", shellCmd], {
             name: "xterm-256color",
             cols: import_session_host_core11.DEFAULT_SESSION_HOST_COLS,
@@ -124250,7 +124735,7 @@ async (params) => {
             }
           });
           try {
-            fs53.unlinkSync(promptFile);
+            fs54.unlinkSync(promptFile);
           } catch {
           }
           ctx.log(`Auto-implement ${success2 ? "completed" : "failed"}: ${type2} (exit: ${code})${verificationSummary ? ` verify=${verificationSummary.pass ? "pass" : "fail"}` : ""}`);
@@ -124347,7 +124832,7 @@ async (params) => {
         setMode: "set_mode.js"
       };
       const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-      const scriptsDir = path522.join(providerDir, "scripts");
+      const scriptsDir = path53.join(providerDir, "scripts");
       const latestScriptsDir = getLatestScriptVersionDir(scriptsDir);
       if (latestScriptsDir) {
         lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -124355,10 +124840,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 fs53.readdirSync(latestScriptsDir)) {
+        for (const file2 of fs54.readdirSync(latestScriptsDir)) {
           if (file2.endsWith(".js") && targetFileNames.has(file2)) {
             try {
-              const content = fs53.readFileSync(path522.join(latestScriptsDir, file2), "utf-8");
+              const content = fs54.readFileSync(path53.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
               lines.push("```javascript");
               lines.push(content);
@@ -124368,14 +124853,14 @@ async (params) => {
             }
           }
         }
-        const refFiles = fs53.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+        const refFiles = fs54.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 = fs53.readFileSync(path522.join(latestScriptsDir, file2), "utf-8");
+              const content = fs54.readFileSync(path53.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u{1F512}`);
               lines.push("```javascript");
               lines.push(content);
@@ -124416,11 +124901,11 @@ async (params) => {
           lines.push("");
         }
       }
-      const docsDir = path522.join(providerDir, "../../docs");
+      const docsDir = path53.join(providerDir, "../../docs");
       const loadGuide = (name) => {
         try {
-          const p = path522.join(docsDir, name);
-          if (fs53.existsSync(p)) return fs53.readFileSync(p, "utf-8");
+          const p = path53.join(docsDir, name);
+          if (fs54.existsSync(p)) return fs54.readFileSync(p, "utf-8");
         } catch {
         }
         return null;
@@ -124656,7 +125141,7 @@ async (params) => {
         parseApproval: "parse_approval.js"
       };
       const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-      const scriptsDir = path522.join(providerDir, "scripts");
+      const scriptsDir = path53.join(providerDir, "scripts");
       const latestScriptsDir = getLatestScriptVersionDir(scriptsDir);
       if (latestScriptsDir) {
         lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -124664,11 +125149,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 fs53.readdirSync(latestScriptsDir)) {
+        for (const file2 of fs54.readdirSync(latestScriptsDir)) {
           if (!file2.endsWith(".js")) continue;
           if (!targetFileNames.has(file2)) continue;
           try {
-            const content = fs53.readFileSync(path522.join(latestScriptsDir, file2), "utf-8");
+            const content = fs54.readFileSync(path53.join(latestScriptsDir, file2), "utf-8");
             lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
             lines.push("```javascript");
             lines.push(content);
@@ -124677,14 +125162,14 @@ async (params) => {
           } catch {
           }
         }
-        const refFiles = fs53.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+        const refFiles = fs54.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 = fs53.readFileSync(path522.join(latestScriptsDir, file2), "utf-8");
+              const content = fs54.readFileSync(path53.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u{1F512}`);
               lines.push("```javascript");
               lines.push(content);
@@ -124717,11 +125202,11 @@ async (params) => {
           lines.push("");
         }
       }
-      const docsDir = path522.join(providerDir, "../../docs");
+      const docsDir = path53.join(providerDir, "../../docs");
       const loadGuide = (name) => {
         try {
-          const p = path522.join(docsDir, name);
-          if (fs53.existsSync(p)) return fs53.readFileSync(p, "utf-8");
+          const p = path53.join(docsDir, name);
+          if (fs54.existsSync(p)) return fs54.readFileSync(p, "utf-8");
         } catch {
         }
         return null;
@@ -125165,8 +125650,8 @@ data: ${JSON.stringify(msg.data)}
       }
       getEndpointList() {
         return this.routes.map((r) => {
-          const path55 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
-          return `${r.method.padEnd(5)} ${path55}`;
+          const path56 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
+          return `${r.method.padEnd(5)} ${path56}`;
         });
       }
       async start(port = DEV_SERVER_PORT) {
@@ -125454,12 +125939,12 @@ data: ${JSON.stringify(msg.data)}
       // ─── DevConsole SPA ───
       getConsoleDistDir() {
         const candidates = [
-          path53.resolve(__dirname, "../../web-devconsole/dist"),
-          path53.resolve(__dirname, "../../../web-devconsole/dist"),
-          path53.join(process.cwd(), "packages/web-devconsole/dist")
+          path54.resolve(__dirname, "../../web-devconsole/dist"),
+          path54.resolve(__dirname, "../../../web-devconsole/dist"),
+          path54.join(process.cwd(), "packages/web-devconsole/dist")
         ];
         for (const dir of candidates) {
-          if (fs54.existsSync(path53.join(dir, "index.html"))) return dir;
+          if (fs55.existsSync(path54.join(dir, "index.html"))) return dir;
         }
         return null;
       }
@@ -125469,9 +125954,9 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 500, { error: "DevConsole not found. Run: npm run build -w packages/web-devconsole" });
           return;
         }
-        const htmlPath = path53.join(distDir, "index.html");
+        const htmlPath = path54.join(distDir, "index.html");
         try {
-          const html = fs54.readFileSync(htmlPath, "utf-8");
+          const html = fs55.readFileSync(htmlPath, "utf-8");
           res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
           res.end(html);
         } catch (e) {
@@ -125494,15 +125979,15 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 404, { error: "Not found" });
           return;
         }
-        const safePath = path53.normalize(pathname).replace(/^\.\.\//, "");
-        const filePath = path53.join(distDir, safePath);
+        const safePath = path54.normalize(pathname).replace(/^\.\.\//, "");
+        const filePath = path54.join(distDir, safePath);
         if (!filePath.startsWith(distDir)) {
           this.json(res, 403, { error: "Forbidden" });
           return;
         }
         try {
-          const content = fs54.readFileSync(filePath);
-          const ext = path53.extname(filePath);
+          const content = fs55.readFileSync(filePath);
+          const ext = path54.extname(filePath);
           const contentType = _DevServer.MIME_MAP[ext] || "application/octet-stream";
           res.writeHead(200, { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" });
           res.end(content);
@@ -125610,14 +126095,14 @@ data: ${JSON.stringify(msg.data)}
         const files = [];
         const scan = (d, prefix) => {
           try {
-            for (const entry of fs54.readdirSync(d, { withFileTypes: true })) {
+            for (const entry of fs55.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(path53.join(d, entry.name), rel);
+                scan(path54.join(d, entry.name), rel);
               } else {
-                const stat2 = fs54.statSync(path53.join(d, entry.name));
+                const stat2 = fs55.statSync(path54.join(d, entry.name));
                 files.push({ path: rel, size: stat2.size, type: "file" });
               }
             }
@@ -125640,16 +126125,16 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 404, { error: `Provider directory not found: ${type2}` });
           return;
         }
-        const fullPath = path53.resolve(dir, path53.normalize(filePath));
+        const fullPath = path54.resolve(dir, path54.normalize(filePath));
         if (!fullPath.startsWith(dir)) {
           this.json(res, 403, { error: "Forbidden" });
           return;
         }
-        if (!fs54.existsSync(fullPath) || fs54.statSync(fullPath).isDirectory()) {
+        if (!fs55.existsSync(fullPath) || fs55.statSync(fullPath).isDirectory()) {
           this.json(res, 404, { error: `File not found: ${filePath}` });
           return;
         }
-        const content = fs54.readFileSync(fullPath, "utf-8");
+        const content = fs55.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 } */
@@ -125665,15 +126150,15 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 404, { error: `Provider directory not found: ${type2}` });
           return;
         }
-        const fullPath = path53.resolve(dir, path53.normalize(filePath));
+        const fullPath = path54.resolve(dir, path54.normalize(filePath));
         if (!fullPath.startsWith(dir)) {
           this.json(res, 403, { error: "Forbidden" });
           return;
         }
         try {
-          if (fs54.existsSync(fullPath)) fs54.copyFileSync(fullPath, fullPath + ".bak");
-          fs54.mkdirSync(path53.dirname(fullPath), { recursive: true });
-          fs54.writeFileSync(fullPath, content, "utf-8");
+          if (fs55.existsSync(fullPath)) fs55.copyFileSync(fullPath, fullPath + ".bak");
+          fs55.mkdirSync(path54.dirname(fullPath), { recursive: true });
+          fs55.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 });
@@ -125689,9 +126174,9 @@ data: ${JSON.stringify(msg.data)}
           return;
         }
         for (const name of ["scripts.js", "provider.json"]) {
-          const p = path53.join(dir, name);
-          if (fs54.existsSync(p)) {
-            const source = fs54.readFileSync(p, "utf-8");
+          const p = path54.join(dir, name);
+          if (fs55.existsSync(p)) {
+            const source = fs55.readFileSync(p, "utf-8");
             this.json(res, 200, { type: type2, path: p, source, lines: source.split("\n").length });
             return;
           }
@@ -125710,11 +126195,11 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 404, { error: `Provider not found: ${type2}` });
           return;
         }
-        const target = fs54.existsSync(path53.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
-        const targetPath = path53.join(dir, target);
+        const target = fs55.existsSync(path54.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
+        const targetPath = path54.join(dir, target);
         try {
-          if (fs54.existsSync(targetPath)) fs54.copyFileSync(targetPath, targetPath + ".bak");
-          fs54.writeFileSync(targetPath, source, "utf-8");
+          if (fs55.existsSync(targetPath)) fs55.copyFileSync(targetPath, targetPath + ".bak");
+          fs55.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 });
@@ -125858,21 +126343,21 @@ data: ${JSON.stringify(msg.data)}
         }
         let targetDir;
         targetDir = this.providerLoader.getUserProviderDir(category, type2);
-        const jsonPath = path53.join(targetDir, "provider.json");
-        if (fs54.existsSync(jsonPath)) {
+        const jsonPath = path54.join(targetDir, "provider.json");
+        if (fs55.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 });
-          fs54.mkdirSync(targetDir, { recursive: true });
-          fs54.writeFileSync(jsonPath, result["provider.json"], "utf-8");
+          fs55.mkdirSync(targetDir, { recursive: true });
+          fs55.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 = path53.join(targetDir, relPath);
-              fs54.mkdirSync(path53.dirname(fullPath), { recursive: true });
-              fs54.writeFileSync(fullPath, content, "utf-8");
+              const fullPath = path54.join(targetDir, relPath);
+              fs55.mkdirSync(path54.dirname(fullPath), { recursive: true });
+              fs55.writeFileSync(fullPath, content, "utf-8");
               createdFiles.push(relPath);
             }
           }
@@ -125921,38 +126406,38 @@ data: ${JSON.stringify(msg.data)}
       }
       // ─── Phase 2: Auto-Implement Backend ───
       getLatestScriptVersionDir(scriptsDir) {
-        if (!fs54.existsSync(scriptsDir)) return null;
-        const versions = fs54.readdirSync(scriptsDir).filter((d) => {
+        if (!fs55.existsSync(scriptsDir)) return null;
+        const versions = fs55.readdirSync(scriptsDir).filter((d) => {
           try {
-            return fs54.statSync(path53.join(scriptsDir, d)).isDirectory();
+            return fs55.statSync(path54.join(scriptsDir, d)).isDirectory();
           } catch {
             return false;
           }
         }).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" }));
         if (versions.length === 0) return null;
-        return path53.join(scriptsDir, versions[0]);
+        return path54.join(scriptsDir, versions[0]);
       }
       resolveAutoImplWritableProviderDir(category, type2, requestedDir) {
-        const canonicalUserDir = path53.resolve(this.providerLoader.getUserProviderDir(category, type2));
-        const desiredDir = requestedDir ? path53.resolve(requestedDir) : canonicalUserDir;
-        const upstreamRoot = path53.resolve(this.providerLoader.getUpstreamDir());
-        if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path53.sep}`)) {
+        const canonicalUserDir = path54.resolve(this.providerLoader.getUserProviderDir(category, type2));
+        const desiredDir = requestedDir ? path54.resolve(requestedDir) : canonicalUserDir;
+        const upstreamRoot = path54.resolve(this.providerLoader.getUpstreamDir());
+        if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path54.sep}`)) {
           return { dir: null, reason: `Refusing to write into upstream provider directory: ${desiredDir}` };
         }
-        if (path53.basename(desiredDir) !== type2) {
+        if (path54.basename(desiredDir) !== type2) {
           return { dir: null, reason: `Requested writable provider directory must end with '${type2}': ${desiredDir}` };
         }
         const sourceDir = this.findProviderDir(type2);
         if (!sourceDir) {
           return { dir: null, reason: `Provider source directory not found for '${type2}'` };
         }
-        if (!fs54.existsSync(desiredDir)) {
-          fs54.mkdirSync(path53.dirname(desiredDir), { recursive: true });
-          fs54.cpSync(sourceDir, desiredDir, { recursive: true });
+        if (!fs55.existsSync(desiredDir)) {
+          fs55.mkdirSync(path54.dirname(desiredDir), { recursive: true });
+          fs55.cpSync(sourceDir, desiredDir, { recursive: true });
           this.log(`Auto-implement writable copy created: ${desiredDir}`);
         }
-        const providerJson = path53.join(desiredDir, "provider.json");
-        if (!fs54.existsSync(providerJson)) {
+        const providerJson = path54.join(desiredDir, "provider.json");
+        if (!fs55.existsSync(providerJson)) {
           return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
         }
         return { dir: desiredDir };
@@ -126762,9 +127247,9 @@ data: ${JSON.stringify(msg.data)}
       }
     }
     var import_child_process14 = require("child_process");
-    var fs55 = __toESM2(require("fs"));
-    var os29 = __toESM2(require("os"));
-    var path54 = __toESM2(require("path"));
+    var fs56 = __toESM2(require("fs"));
+    var os30 = __toESM2(require("os"));
+    var path55 = __toESM2(require("path"));
     var import_session_host_core15 = require_dist();
     init_logger();
     init_runtime_defaults();
@@ -126784,18 +127269,18 @@ data: ${JSON.stringify(msg.data)}
       function resolveEntry() {
         if (options.resolveEntryOverride) return options.resolveEntryOverride();
         const packagedCandidates = [
-          path54.resolve(__dirname, "../vendor/session-host-daemon/index.js"),
-          path54.resolve(__dirname, "../../vendor/session-host-daemon/index.js")
+          path55.resolve(__dirname, "../vendor/session-host-daemon/index.js"),
+          path55.resolve(__dirname, "../../vendor/session-host-daemon/index.js")
         ];
         for (const candidate of packagedCandidates) {
-          if (fs55.existsSync(candidate)) {
+          if (fs56.existsSync(candidate)) {
             return candidate;
           }
         }
         return require.resolve("@adhdev/session-host-daemon");
       }
       function pathsEquivalent(left, right) {
-        return path54.resolve(left).toLowerCase() === path54.resolve(right).toLowerCase();
+        return path55.resolve(left).toLowerCase() === path55.resolve(right).toLowerCase();
       }
       function getRunningSessionHostScriptPath(pid) {
         const commandLine = getProcessCommandLine(pid);
@@ -126803,13 +127288,13 @@ data: ${JSON.stringify(msg.data)}
         return parseNodeScriptPath(commandLine);
       }
       function getPidFile() {
-        return path54.join(instance().configDir, `${appName}-session-host.pid`);
+        return path55.join(instance().configDir, `${appName}-session-host.pid`);
       }
       function getPid() {
         try {
           const pidFile = getPidFile();
-          if (!fs55.existsSync(pidFile)) return null;
-          const pid = Number.parseInt(fs55.readFileSync(pidFile, "utf8").trim(), 10);
+          if (!fs56.existsSync(pidFile)) return null;
+          const pid = Number.parseInt(fs56.readFileSync(pidFile, "utf8").trim(), 10);
           return Number.isFinite(pid) ? pid : null;
         } catch {
           return null;
@@ -126835,7 +127320,7 @@ data: ${JSON.stringify(msg.data)}
         }
         let portableNode = null;
         try {
-          portableNode = findPortableNode22(os29.homedir(), process.execPath, resolveInstanceDir());
+          portableNode = findPortableNode22(os30.homedir(), process.execPath, resolveInstanceDir());
         } catch (error48) {
           LOG2.warn(
             "SessionHost",
@@ -126859,7 +127344,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) => fs55.existsSync(candidate));
+        const found = candidates.find((candidate) => fs56.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.`
@@ -126874,9 +127359,9 @@ data: ${JSON.stringify(msg.data)}
         let stdio = "ignore";
         let logFd = null;
         if (options.spawnStdio === "logfile") {
-          const logDir = path54.join(instance().configDir, "logs");
-          fs55.mkdirSync(logDir, { recursive: true });
-          logFd = fs55.openSync(path54.join(logDir, "session-host.log"), "a");
+          const logDir = path55.join(instance().configDir, "logs");
+          fs56.mkdirSync(logDir, { recursive: true });
+          logFd = fs56.openSync(path55.join(logDir, "session-host.log"), "a");
           stdio = ["ignore", logFd, logFd];
         }
         const child = (0, import_child_process14.spawn)(nodeExecutable, [entry], {
@@ -126888,7 +127373,7 @@ data: ${JSON.stringify(msg.data)}
         child.unref();
         if (logFd !== null) {
           try {
-            fs55.closeSync(logFd);
+            fs56.closeSync(logFd);
           } catch {
           }
         }
@@ -126906,8 +127391,8 @@ data: ${JSON.stringify(msg.data)}
         const pidFile = getPidFile();
         let keepPidFile = false;
         try {
-          if (fs55.existsSync(pidFile)) {
-            const pid = Number.parseInt(fs55.readFileSync(pidFile, "utf8").trim(), 10);
+          if (fs56.existsSync(pidFile)) {
+            const pid = Number.parseInt(fs56.readFileSync(pidFile, "utf8").trim(), 10);
             if (Number.isFinite(pid) && pid !== process.pid) {
               const managed = isManagedPid(pid);
               if (managed) {
@@ -126927,7 +127412,7 @@ data: ${JSON.stringify(msg.data)}
         } finally {
           if (!keepPidFile) {
             try {
-              fs55.unlinkSync(pidFile);
+              fs56.unlinkSync(pidFile);
             } catch {
             }
           }
@@ -126963,7 +127448,7 @@ data: ${JSON.stringify(msg.data)}
         }
         if (!reported) return;
         if (pathsEquivalent(reported, currentEntry)) return;
-        const reportedExists = fs55.existsSync(reported);
+        const reportedExists = fs56.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.`
@@ -127190,8 +127675,8 @@ data: ${JSON.stringify(msg.data)}
           const res = await fetch(extension.vsixUrl);
           if (res.ok) {
             const buffer = Buffer.from(await res.arrayBuffer());
-            const fs57 = await import("fs");
-            fs57.writeFileSync(vsixPath, buffer);
+            const fs58 = await import("fs");
+            fs58.writeFileSync(vsixPath, buffer);
             return new Promise((resolve30) => {
               const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
               (0, import_child_process15.exec)(cmd, { timeout: 6e4 }, (error48, _stdout, stderr) => {
@@ -127415,11 +127900,11 @@ data: ${JSON.stringify(msg.data)}
       }
       for (const name of names) {
         if (!isPendingEventsFile(name)) continue;
-        const path55 = (0, import_path20.join)(dir, name);
+        const path56 = (0, import_path20.join)(dir, name);
         result.filesScanned++;
-        const claimed = `${path55}.migrating`;
+        const claimed = `${path56}.migrating`;
         try {
-          (0, import_fs19.renameSync)(path55, claimed);
+          (0, import_fs19.renameSync)(path56, claimed);
         } catch {
           continue;
         }
@@ -127429,7 +127914,7 @@ data: ${JSON.stringify(msg.data)}
         } catch (e) {
           LOG2.warn("MeshEvents", `Pending-events migration: cannot read ${name}; leaving it for the next boot: ${e?.message || e}`);
           try {
-            (0, import_fs19.renameSync)(claimed, path55);
+            (0, import_fs19.renameSync)(claimed, path56);
           } catch {
           }
           result.filesRetained++;
@@ -127444,7 +127929,7 @@ data: ${JSON.stringify(msg.data)}
         }
         if (!allImported) {
           try {
-            (0, import_fs19.renameSync)(claimed, path55);
+            (0, import_fs19.renameSync)(claimed, path56);
           } catch {
           }
           result.filesRetained++;
@@ -128040,10 +128525,10 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
     init_parse_approval();
     init_visible_region();
     init_parse_session();
-    var import_node_fs6 = require("fs");
+    var import_node_fs7 = require("fs");
     var import_node_path6 = require("path");
     init_provider_cli_shared();
-    var import_node_fs7 = require("fs");
+    var import_node_fs8 = require("fs");
     var import_node_path7 = require("path");
     init_manifest();
     var V1_PRIMITIVE_CATALOG = Object.freeze({
@@ -128116,7 +128601,7 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
       Object.values(V1_PRIMITIVE_CATALOG).flat()
     );
     var V1_CONTRACT_VERSION = "1.0.0";
-    var fs56 = __toESM2(require("fs"));
+    var fs57 = __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.";
@@ -128227,7 +128712,7 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         console.log(import_chalk2.default.gray(`  Backup: ${status.paths.backupFile}`));
         let snapshotMtimeMs = null;
         try {
-          snapshotMtimeMs = fs56.statSync(status.paths.snapshotFile).mtimeMs;
+          snapshotMtimeMs = fs57.statSync(status.paths.snapshotFile).mtimeMs;
         } catch {
         }
         console.log(import_chalk2.default.gray(