@adhdev/daemon-standalone 1.0.56-rc.7 → 1.0.56-rc.8

package/dist/index.js

@@ -36620,10 +36620,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "13ea4fe8748ca3d97f0e4f9cc10a4c5969855fff" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "13ea4fe8" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.56-rc.7" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-19T14:43:40.002Z" : void 0);
+      const commit = readInjected(true ? "f45b1ccbf70f856ec2232e2dc5a87acaf875243e" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "f45b1ccb" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.56-rc.8" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-19T16:04:19.674Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -40952,11 +40952,11 @@ child.on('exit', () => process.exit(0));
     }
     function windowsExtraBinDirs() {
       const dirs = [];
-      const fs59 = require("fs");
+      const fs61 = require("fs");
       const push = (dir) => {
         if (!dir) return;
         try {
-          if (fs59.existsSync(dir)) dirs.push(dir);
+          if (fs61.existsSync(dir)) dirs.push(dir);
         } catch {
         }
       };
@@ -40972,12 +40972,12 @@ child.on('exit', () => process.exit(0));
     }
     function unixExtraBinDirs() {
       const dirs = [];
-      const fs59 = require("fs");
+      const fs61 = require("fs");
       const home = os52.homedir();
       const push = (dir) => {
         if (!dir) return;
         try {
-          if (fs59.existsSync(dir)) dirs.push(dir);
+          if (fs61.existsSync(dir)) dirs.push(dir);
         } catch {
         }
       };
@@ -41016,9 +41016,9 @@ child.on('exit', () => process.exit(0));
         for (const ext of exes) {
           const fullPath = path9.join(p, trimmed + ext);
           try {
-            const fs59 = require("fs");
-            if (fs59.existsSync(fullPath)) {
-              const stat2 = fs59.statSync(fullPath);
+            const fs61 = require("fs");
+            if (fs61.existsSync(fullPath)) {
+              const stat2 = fs61.statSync(fullPath);
               if (stat2.isFile() && (isWin || stat2.mode & 73)) {
                 return fullPath;
               }
@@ -41032,12 +41032,12 @@ child.on('exit', () => process.exit(0));
     function isScriptBinary(binaryPath) {
       if (!path9.isAbsolute(binaryPath)) return false;
       try {
-        const fs59 = require("fs");
-        const resolved = fs59.realpathSync(binaryPath);
+        const fs61 = require("fs");
+        const resolved = fs61.realpathSync(binaryPath);
         const head = Buffer.alloc(8);
-        const fd = fs59.openSync(resolved, "r");
-        fs59.readSync(fd, head, 0, 8, 0);
-        fs59.closeSync(fd);
+        const fd = fs61.openSync(resolved, "r");
+        fs61.readSync(fd, head, 0, 8, 0);
+        fs61.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;
@@ -41048,12 +41048,12 @@ child.on('exit', () => process.exit(0));
     function looksLikeMachOOrElf(filePath) {
       if (!path9.isAbsolute(filePath)) return false;
       try {
-        const fs59 = require("fs");
-        const resolved = fs59.realpathSync(filePath);
+        const fs61 = require("fs");
+        const resolved = fs61.realpathSync(filePath);
         const buf = Buffer.alloc(8);
-        const fd = fs59.openSync(resolved, "r");
-        fs59.readSync(fd, buf, 0, 8, 0);
-        fs59.closeSync(fd);
+        const fd = fs61.openSync(resolved, "r");
+        fs61.readSync(fd, buf, 0, 8, 0);
+        fs61.closeSync(fd);
         let i = 0;
         if (buf[0] === 239 && buf[1] === 187 && buf[2] === 191) i = 3;
         const b = buf.subarray(i);
@@ -47896,11 +47896,31 @@ ${blocks.join("\n\n")}`;
         ...alertReason ? [alertReason] : []
       ].join("::");
     }
+    function isDurablyDedupedEvent(event) {
+      if (!TERMINAL_COMPLETION_EVENTS.has(event.event)) return false;
+      const metadata = readRecord2(event.metadataEvent) || {};
+      const taskId = readNonEmptyString(metadata.taskId) || readNonEmptyString(readRecord2(metadata.payload)?.taskId);
+      return !!taskId;
+    }
+    function recordDurableTerminalDedup(event, fingerprint) {
+      if (!isDurablyDedupedEvent(event)) return;
+      try {
+        const store = MeshRuntimeStore.getInstance();
+        store.recordCompletionFingerprint(event.meshId, `pending::${fingerprint}`, TERMINAL_COMPLETION_DEDUP_TTL_MS);
+        store.sweepExpiredFingerprints();
+      } catch {
+      }
+    }
     function hasPendingCoordinatorEventDuplicate(event) {
       const fingerprint = buildPendingEventFingerprint(event);
       if (!fingerprint.trim()) return false;
       try {
-        return MeshRuntimeStore.getInstance().hasPendingEventFingerprint(event.meshId, fingerprint);
+        const store = MeshRuntimeStore.getInstance();
+        if (store.hasPendingEventFingerprint(event.meshId, fingerprint)) return true;
+        if (isDurablyDedupedEvent(event) && store.hasCompletionFingerprint(event.meshId, `pending::${fingerprint}`)) {
+          return true;
+        }
+        return false;
       } catch {
         return false;
       }
@@ -48123,6 +48143,7 @@ ${blocks.join("\n\n")}`;
           dispatchedBy: event.dispatchedBy ? JSON.stringify(event.dispatchedBy) : null,
           intendedFor: event.intendedFor ? JSON.stringify(event.intendedFor) : null
         });
+        recordDurableTerminalDedup(event, fingerprint);
         return true;
       } catch (e) {
         LOG2.error(
@@ -48343,6 +48364,7 @@ ${blocks.join("\n\n")}`;
     var loggedSqlitePendingDrainFailure;
     var TERMINAL_COMPLETION_EVENTS;
     var COORDINATOR_ALERT_EVENTS_WITH_REASON_FINGERPRINT;
+    var TERMINAL_COMPLETION_DEDUP_TTL_MS;
     var PENDING_EVENTS_DRAINED_RETENTION_MS;
     var PENDING_EVENTS_UNDRAINED_RETENTION_MS;
     var PENDING_RETENTION_EXPIRED_HOLD_REASON;
@@ -48396,6 +48418,7 @@ ${blocks.join("\n\n")}`;
         COORDINATOR_ALERT_EVENTS_WITH_REASON_FINGERPRINT = /* @__PURE__ */ new Set([
           "mesh:dispatch_blocked"
         ]);
+        TERMINAL_COMPLETION_DEDUP_TTL_MS = 60 * 60 * 1e3;
         PENDING_EVENTS_DRAINED_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
         PENDING_EVENTS_UNDRAINED_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
         PENDING_RETENTION_EXPIRED_HOLD_REASON = "pending_retention_expired";
@@ -54861,7 +54884,11 @@ The instruction it carried was never delivered to anyone. If it still matters, r
           }
           /** Remove all pending-event rows (drained included) for a mesh — mesh deletion / test cleanup. */
           clearPendingEventsForMesh(meshId) {
-            return this.db.prepare("DELETE FROM mesh_pending_events WHERE mesh_id = ?").run(meshId).changes;
+            const changes = this.db.prepare("DELETE FROM mesh_pending_events WHERE mesh_id = ?").run(meshId).changes;
+            this.db.prepare(
+              `DELETE FROM mesh_completion_fingerprints WHERE mesh_id = ? AND fingerprint LIKE 'pending::%'`
+            ).run(meshId);
+            return changes;
           }
           pendingEventCount(meshId) {
             const row = this.db.prepare(
@@ -58803,8 +58830,8 @@ ${rendered}`, "utf-8");
         if (!(0, import_node_fs3.existsSync)(filePath)) return;
         if (owned) {
           try {
-            const fs59 = require("fs");
-            fs59.unlinkSync(filePath);
+            const fs61 = require("fs");
+            fs61.unlinkSync(filePath);
           } catch {
           }
           return;
@@ -58817,8 +58844,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 fs59 = require("fs");
-            fs59.unlinkSync(filePath);
+            const fs61 = require("fs");
+            fs61.unlinkSync(filePath);
           } catch {
           }
         } else {
@@ -62648,6 +62675,13 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       }
       return false;
     }
+    function isReplayOfRecordedSynthSummary(recorded, incoming) {
+      if (recorded === incoming) return true;
+      if (!recorded || !incoming) return false;
+      const [shorter, longer] = recorded.length <= incoming.length ? [recorded, incoming] : [incoming, recorded];
+      if (!longer.startsWith(shorter)) return false;
+      return longer.length <= shorter.length + 32;
+    }
     function hasIdenticalSynthesizedTerminal(args) {
       const entries = readLedgerEntriesByKind(args.meshId, ["task_dispatched", ...TERMINAL_LEDGER_KINDS2]);
       let afterDispatch = !args.dispatchEntryId && !args.dispatchTimestamp;
@@ -62667,7 +62701,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         if (entry.kind !== "task_completed" && entry.kind !== "task_failed") continue;
         const diagnostic = readRecord2(entry.payload?.completionDiagnostic);
         if (readNonEmptyString(diagnostic?.reason) !== "direct_task_transcript_reconciliation") continue;
-        if (readNonEmptyString(entry.payload?.finalSummary) !== args.finalSummary) continue;
+        if (!isReplayOfRecordedSynthSummary(readNonEmptyString(entry.payload?.finalSummary), args.finalSummary)) continue;
         const terminalTaskId = readNonEmptyString(entry.payload?.taskId);
         if (terminalTaskId && terminalTaskId !== args.taskId) continue;
         if (terminalTaskId && terminalTaskId === args.taskId) return true;
@@ -77621,8 +77655,8 @@ ${cleanBody}`;
             let cwd = options.cwd;
             if (cwd) {
               try {
-                const fs59 = require("fs");
-                const stat2 = fs59.statSync(cwd);
+                const fs61 = require("fs");
+                const stat2 = fs61.statSync(cwd);
                 if (!stat2.isDirectory()) cwd = os14.homedir();
               } catch {
                 cwd = os14.homedir();
@@ -79019,6 +79053,360 @@ ${cleanBody}`;
         DEFAULT_REFINE_VITEST_MAX_WORKERS = 2;
       }
     });
+    function readChangedGitlinkPaths(repoRoot, fromRef, toRef) {
+      try {
+        const output = (0, import_node_child_process11.execFileSync)(GIT4, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
+          cwd: repoRoot,
+          encoding: "utf8",
+          maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
+        });
+        const paths = /* @__PURE__ */ new Set();
+        for (const line of output.split("\n")) {
+          if (!line.trim()) continue;
+          const metaAndPath = line.split("	");
+          const meta3 = metaAndPath[0] || "";
+          const path58 = metaAndPath[metaAndPath.length - 1]?.trim();
+          if (!path58) continue;
+          const parts = meta3.split(/\s+/);
+          if (parts[0]?.includes("160000") || parts[1]?.includes("160000")) {
+            paths.add(path58);
+          }
+        }
+        return [...paths].sort();
+      } catch {
+        return [];
+      }
+    }
+    function readTreeObject(repoRoot, ref, path58) {
+      try {
+        const output = (0, import_node_child_process11.execFileSync)(GIT4, ["ls-tree", ref, "--", path58], {
+          cwd: repoRoot,
+          encoding: "utf8",
+          maxBuffer: 1024 * 1024
+        }).trim();
+        const match = output.match(/\bcommit\s+([0-9a-f]{40})\b/i);
+        return match?.[1];
+      } catch {
+        return void 0;
+      }
+    }
+    function submoduleCommitPresent(submoduleRepoPath, commit) {
+      if (!commit) return false;
+      try {
+        (0, import_node_child_process11.execFileSync)(GIT4, ["cat-file", "-e", `${commit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    function ensureSubmoduleCommitLocal(submoduleRepoPath, baseSubmoduleRepoPath, commit) {
+      if (!commit) return false;
+      const present = () => {
+        try {
+          (0, import_node_child_process11.execFileSync)(GIT4, ["cat-file", "-e", `${commit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+          return true;
+        } catch {
+          return false;
+        }
+      };
+      if (present()) return true;
+      try {
+        if (!fs48.existsSync(submoduleRepoPath) || !fs48.existsSync(baseSubmoduleRepoPath)) return false;
+      } catch {
+        return false;
+      }
+      const strategies = [
+        // 1. All local branches (historical behaviour).
+        ["fetch", "-q", baseSubmoduleRepoPath, "+refs/heads/*:refs/adhdev-refine-base/*"],
+        // 2. The base checkout's detached HEAD plus every ref it has.
+        ["fetch", "-q", baseSubmoduleRepoPath, "HEAD", "+refs/*:refs/adhdev-refine-base-all/*"],
+        // 3. The exact object, allowing a bare-sha want on the source side.
+        ["fetch", "-q", "--upload-pack", "git -c uploadpack.allowAnySHA1InWant=true upload-pack", baseSubmoduleRepoPath, commit]
+      ];
+      for (const args of strategies) {
+        try {
+          (0, import_node_child_process11.execFileSync)(GIT4, ["-c", "protocol.file.allow=always", ...args], {
+            cwd: submoduleRepoPath,
+            stdio: ["ignore", "ignore", "pipe"]
+          });
+        } catch {
+        }
+        if (present()) return true;
+      }
+      return false;
+    }
+    var fs48;
+    var import_node_child_process11;
+    var GIT4;
+    var REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES;
+    var init_mesh_refine_gitlink_utils = __esm2({
+      "src/mesh/mesh-refine-gitlink-utils.ts"() {
+        "use strict";
+        fs48 = __toESM2(require("fs"));
+        import_node_child_process11 = require("child_process");
+        init_resolve_executable();
+        GIT4 = process.platform === "win32" ? resolveWin32Executable("git") : "git";
+        REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES = 4 * 1024 * 1024;
+      }
+    });
+    function classifySubmoduleDivergence(submoduleRepoPath, baseCommit, branchCommit) {
+      if (!baseCommit || !branchCommit) return "undeterminable";
+      if (baseCommit === branchCommit) return "not_diverged";
+      try {
+        if (!fs49.existsSync(submoduleRepoPath)) return "undeterminable";
+        (0, import_node_child_process12.execFileSync)(GIT4, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+        (0, import_node_child_process12.execFileSync)(GIT4, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+      } catch {
+        return "undeterminable";
+      }
+      try {
+        (0, import_node_child_process12.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+        return "not_diverged";
+      } catch {
+      }
+      try {
+        (0, import_node_child_process12.execFileSync)(GIT4, ["merge-base", "--is-ancestor", branchCommit, baseCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+        return "not_diverged";
+      } catch {
+      }
+      try {
+        const mb = (0, import_node_child_process12.execFileSync)(GIT4, ["merge-base", baseCommit, branchCommit], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+        return mb ? "diverged" : "not_diverged";
+      } catch {
+        return "not_diverged";
+      }
+    }
+    function resolveSubmoduleRemoteMainRef(submoduleRepoPath) {
+      try {
+        const sym = (0, import_node_child_process12.execFileSync)(GIT4, ["symbolic-ref", "-q", "refs/remotes/origin/HEAD"], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+        if (sym) return sym;
+      } catch {
+      }
+      for (const branch of ["main", "master"]) {
+        try {
+          (0, import_node_child_process12.execFileSync)(GIT4, ["rev-parse", "--verify", "-q", `refs/remotes/origin/${branch}`], { cwd: submoduleRepoPath, stdio: ["ignore", "pipe", "pipe"] });
+          return `refs/remotes/origin/${branch}`;
+        } catch {
+        }
+      }
+      return void 0;
+    }
+    function findEquivalentPublishedSubmoduleCommit(submoduleRepoPath, baseCommit, branchCommit, remoteRef) {
+      try {
+        const mergeTreeOut = (0, import_node_child_process12.execFileSync)(GIT4, ["merge-tree", "--write-tree", baseCommit, branchCommit], {
+          cwd: submoduleRepoPath,
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        const mergedTree = mergeTreeOut.trim().split(/\s+/)[0] || "";
+        if (!mergedTree) return void 0;
+        const candidates = (0, import_node_child_process12.execFileSync)(GIT4, ["rev-list", "--max-count=100", remoteRef, "--not", baseCommit], {
+          cwd: submoduleRepoPath,
+          encoding: "utf8"
+        }).split("\n").map((s2) => s2.trim()).filter(Boolean);
+        for (const candidate of candidates) {
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, candidate], { cwd: submoduleRepoPath, stdio: "ignore" });
+          } catch {
+            continue;
+          }
+          const tree = (0, import_node_child_process12.execFileSync)(GIT4, ["rev-parse", `${candidate}^{tree}`], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+          if (tree === mergedTree) return candidate;
+        }
+      } catch {
+      }
+      return void 0;
+    }
+    function convergeDivergedSubmoduleGitlinks(worktreeRoot, baseRepoRoot, baseHead, branchHead) {
+      const changed = readChangedGitlinkPaths(worktreeRoot, baseHead, branchHead);
+      if (changed.length === 0) {
+        return { converged: false, reason: "no_changed_gitlinks", resolutions: [], gitlinks: [] };
+      }
+      const gitlinks = [];
+      const resolutions = [];
+      let sawDiverged = false;
+      let sawUndeterminable = false;
+      for (const path58 of changed) {
+        const baseCommit = readTreeObject(baseRepoRoot, baseHead, path58);
+        const branchCommit = readTreeObject(worktreeRoot, branchHead, path58);
+        const submoduleRepoPath = (0, import_path17.resolve)(worktreeRoot, path58);
+        if (baseCommit) {
+          ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path17.resolve)(baseRepoRoot, path58), baseCommit);
+        }
+        const markUndeterminable = () => {
+          const unavailable = [];
+          if (!baseCommit || !submoduleCommitPresent(submoduleRepoPath, baseCommit)) unavailable.push("base");
+          if (!branchCommit || !submoduleCommitPresent(submoduleRepoPath, branchCommit)) unavailable.push("branch");
+          sawUndeterminable = true;
+          gitlinks.push({ path: path58, baseCommit, branchCommit, action: "skipped_commit_unavailable", unavailable });
+        };
+        if (!baseCommit || !branchCommit) {
+          markUndeterminable();
+          continue;
+        }
+        const divergence = classifySubmoduleDivergence(submoduleRepoPath, baseCommit, branchCommit);
+        if (divergence === "undeterminable") {
+          markUndeterminable();
+          continue;
+        }
+        if (divergence !== "diverged") {
+          gitlinks.push({ path: path58, baseCommit, branchCommit, action: "skipped_not_diverged" });
+          continue;
+        }
+        sawDiverged = true;
+        try {
+          (0, import_node_child_process12.execFileSync)(GIT4, ["-c", "protocol.file.allow=always", "fetch", "-q", "origin"], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
+        } catch {
+        }
+        const remoteMainRef = resolveSubmoduleRemoteMainRef(submoduleRepoPath);
+        const publishedEquivalent = remoteMainRef ? findEquivalentPublishedSubmoduleCommit(submoduleRepoPath, baseCommit, branchCommit, remoteMainRef) : void 0;
+        if (publishedEquivalent) {
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["checkout", "-q", "--detach", publishedEquivalent], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
+          } catch {
+          }
+          gitlinks.push({ path: path58, baseCommit, branchCommit, rebasedCommit: publishedEquivalent, action: "converged_to_published" });
+          resolutions.push({ path: path58, baseCommit, branchCommit, rebasedCommit: publishedEquivalent });
+          continue;
+        }
+        let rebasedCommit;
+        try {
+          (0, import_node_child_process12.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
+          (0, import_node_child_process12.execFileSync)(GIT4, ["rebase", baseCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "pipe", "pipe"] });
+          rebasedCommit = (0, import_node_child_process12.execFileSync)(GIT4, ["rev-parse", "HEAD"], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+        } catch {
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["rebase", "--abort"], { cwd: submoduleRepoPath, stdio: "ignore" });
+          } catch {
+          }
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+          } catch {
+          }
+          gitlinks.push({ path: path58, baseCommit, branchCommit, action: "rebase_conflict" });
+          return { converged: false, reason: "rebase_conflict", resolutions: [], gitlinks };
+        }
+        const branchWorkSurvived = (() => {
+          if (!rebasedCommit) return false;
+          if (rebasedCommit === branchCommit) return true;
+          if (rebasedCommit === baseCommit) return false;
+          try {
+            const replayed = (0, import_node_child_process12.execFileSync)(GIT4, ["rev-list", "--count", `${baseCommit}..${rebasedCommit}`], {
+              cwd: submoduleRepoPath,
+              encoding: "utf8"
+            }).trim();
+            return Number.parseInt(replayed, 10) > 0;
+          } catch {
+            return false;
+          }
+        })();
+        if (!branchWorkSurvived) {
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+          } catch {
+          }
+          gitlinks.push({ path: path58, baseCommit, branchCommit, rebasedCommit, action: "rebase_dropped_branch_commits" });
+          return { converged: false, reason: "rebase_dropped_branch_commits", resolutions: [], gitlinks };
+        }
+        gitlinks.push({ path: path58, baseCommit, branchCommit, rebasedCommit, action: "rebased" });
+        resolutions.push({ path: path58, baseCommit, branchCommit, rebasedCommit });
+      }
+      if (!sawDiverged) {
+        const reason = sawUndeterminable ? "submodule_commit_unavailable" : "not_diverged";
+        return { converged: false, reason, resolutions: [], gitlinks };
+      }
+      return { converged: resolutions.length > 0, resolutions, gitlinks };
+    }
+    function rootRebaseResolvingGitlinks(worktreeRoot, baseHead, resolutions) {
+      const resolveByPath = new Map(resolutions.map((r) => [r.path, r.rebasedCommit]));
+      const runRebase = (args) => {
+        try {
+          (0, import_node_child_process12.execFileSync)(GIT4, args, {
+            cwd: worktreeRoot,
+            stdio: ["ignore", "pipe", "pipe"],
+            // A rebase editor prompt would hang; keep it non-interactive.
+            env: { ...process.env, GIT_EDITOR: "true", GIT_SEQUENCE_EDITOR: "true" }
+          });
+          return { ok: true };
+        } catch {
+          return { ok: false };
+        }
+      };
+      const unmergedPaths = () => {
+        try {
+          return (0, import_node_child_process12.execFileSync)(GIT4, ["diff", "--name-only", "--diff-filter=U"], { cwd: worktreeRoot, encoding: "utf8" }).split("\n").map((s2) => s2.trim()).filter(Boolean);
+        } catch {
+          return [];
+        }
+      };
+      const abort = (reason, conflictPaths) => {
+        try {
+          (0, import_node_child_process12.execFileSync)(GIT4, ["rebase", "--abort"], { cwd: worktreeRoot, stdio: "ignore" });
+        } catch {
+        }
+        return { ok: false, reason, conflictPaths };
+      };
+      let progress = runRebase(["rebase", baseHead]);
+      let guard = 0;
+      while (!progress.ok) {
+        if (guard++ > 100) return abort("rebase_error");
+        const conflicts = unmergedPaths();
+        if (conflicts.length === 0) {
+          return abort("rebase_error");
+        }
+        const unresolvable = conflicts.filter((p) => !resolveByPath.has(p));
+        if (unresolvable.length > 0) {
+          const unresolvableGitlink = unresolvable.some((p) => {
+            try {
+              const staged = (0, import_node_child_process12.execFileSync)(GIT4, ["ls-files", "--stage", "--", p], { cwd: worktreeRoot, encoding: "utf8" });
+              return /^160000\s/m.test(staged);
+            } catch {
+              return false;
+            }
+          });
+          const allGitlink = unresolvable.every((p) => {
+            try {
+              const staged = (0, import_node_child_process12.execFileSync)(GIT4, ["ls-files", "--stage", "--", p], { cwd: worktreeRoot, encoding: "utf8" });
+              return /^160000\s/m.test(staged);
+            } catch {
+              return false;
+            }
+          });
+          return abort(allGitlink && unresolvableGitlink ? "unexpected_gitlink" : "non_gitlink_conflict", conflicts);
+        }
+        for (const p of conflicts) {
+          const commit = resolveByPath.get(p);
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["checkout", "-q", "--detach", commit], { cwd: (0, import_path17.resolve)(worktreeRoot, p), stdio: "ignore" });
+          } catch {
+          }
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["add", p], { cwd: worktreeRoot, stdio: "ignore" });
+          } catch {
+            return abort("rebase_error", conflicts);
+          }
+        }
+        progress = runRebase(["rebase", "--continue"]);
+      }
+      let branchHead;
+      try {
+        branchHead = (0, import_node_child_process12.execFileSync)(GIT4, ["rev-parse", "HEAD"], { cwd: worktreeRoot, encoding: "utf8" }).trim();
+      } catch {
+      }
+      return { ok: true, branchHead };
+    }
+    var fs49;
+    var import_path17;
+    var import_node_child_process12;
+    var init_mesh_refine_submodule_converge = __esm2({
+      "src/mesh/mesh-refine-submodule-converge.ts"() {
+        "use strict";
+        fs49 = __toESM2(require("fs"));
+        import_path17 = require("path");
+        import_node_child_process12 = require("child_process");
+        init_mesh_refine_gitlink_utils();
+      }
+    });
     function truncateValidationOutput(value) {
       const text = typeof value === "string" ? value : value == null ? "" : String(value);
       if (text.length <= REFINE_VALIDATION_SUMMARY_CHARS) return text;
@@ -79036,13 +79424,13 @@ ${tail}`;
     }
     function writeValidationFailureLog(workspace, index, candidate, streams, now = () => /* @__PURE__ */ new Date()) {
       try {
-        const dir = (0, import_path17.join)(workspace, REFINE_VALIDATION_LOG_DIR);
-        fs48.mkdirSync(dir, { recursive: true });
+        const dir = (0, import_path18.join)(workspace, REFINE_VALIDATION_LOG_DIR);
+        fs50.mkdirSync(dir, { recursive: true });
         const stamp = now().toISOString().replace(/[:.]/g, "-");
-        const file2 = (0, import_path17.join)(dir, `refine-${stamp}-${index}.log`);
+        const file2 = (0, import_path18.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(" ");
-        fs48.writeFileSync(
+        fs50.writeFileSync(
           file2,
           `# refine validation failure
 # command: ${shown}
@@ -79116,18 +79504,18 @@ ${asText(streams.stderr)}
       return { enabled: false };
     }
     async function computeGitPatchId(cwd, fromRef, toRef, excludePaths = []) {
-      const { execFileSync: execFileSync13 } = await import("child_process");
+      const { execFileSync: execFileSync15 } = await import("child_process");
       const diffArgs = ["diff", "--patch", "--full-index", fromRef, toRef];
       if (excludePaths.length > 0) {
         diffArgs.push("--", ".", ...excludePaths.map((path58) => `:(exclude)${path58}`));
       }
-      const diff = execFileSync13(GIT4, diffArgs, {
+      const diff = execFileSync15(GIT4, diffArgs, {
         cwd,
         encoding: "utf8",
         maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
       });
       if (!diff.trim()) return "";
-      const patchId = execFileSync13(GIT4, ["patch-id", "--stable"], {
+      const patchId = execFileSync15(GIT4, ["patch-id", "--stable"], {
         cwd,
         input: diff,
         encoding: "utf8",
@@ -79138,8 +79526,8 @@ ${asText(streams.stderr)}
     async function runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead) {
       const startedAt = Date.now();
       try {
-        const { execFileSync: execFileSync13 } = await import("child_process");
-        const git3 = (args) => execFileSync13(GIT4, args, {
+        const { execFileSync: execFileSync15 } = await import("child_process");
+        const git3 = (args) => execFileSync15(GIT4, args, {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -79240,7 +79628,7 @@ ${e?.stderr || ""}`
         ...autoPublish !== void 0 ? { autoPublishSubmoduleMainCommits: autoPublish } : {}
       };
       try {
-        const git3 = (args) => (0, import_node_child_process11.execFileSync)(GIT4, args, {
+        const git3 = (args) => (0, import_node_child_process13.execFileSync)(GIT4, args, {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
@@ -79294,7 +79682,7 @@ ${e?.stderr || ""}`
             } catch {
               continue;
             }
-            const submoduleRepo = (0, import_path17.join)(repoRoot, p);
+            const submoduleRepo = (0, import_path18.join)(repoRoot, p);
             let fastForward;
             let reachableFromOriginMain;
             if (branchCommit) {
@@ -79365,7 +79753,7 @@ ${e?.stderr || ""}`
     }
     function execGitOk(cwd, args) {
       try {
-        (0, import_node_child_process11.execFileSync)(GIT4, args, { cwd, encoding: "utf8", maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES, windowsHide: true });
+        (0, import_node_child_process13.execFileSync)(GIT4, args, { cwd, encoding: "utf8", maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES, windowsHide: true });
         return true;
       } catch {
         return false;
@@ -79374,8 +79762,8 @@ ${e?.stderr || ""}`
     async function checkWorktreeChangesPatchEquivalentInRef(repoRoot, ref, worktreeHead) {
       const startedAt = Date.now();
       try {
-        const { execFileSync: execFileSync13 } = await import("child_process");
-        const git3 = (gitArgs) => execFileSync13(GIT4, gitArgs, {
+        const { execFileSync: execFileSync15 } = await import("child_process");
+        const git3 = (gitArgs) => execFileSync15(GIT4, gitArgs, {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -79438,8 +79826,8 @@ ${mergeTreeErr?.stderr || ""}`;
     async function runMeshRefineEffectiveDiffGate(repoRoot, baseHead, branchHead) {
       const startedAt = Date.now();
       try {
-        const { execFileSync: execFileSync13 } = await import("child_process");
-        const git3 = (args, opts) => execFileSync13(GIT4, args, {
+        const { execFileSync: execFileSync15 } = await import("child_process");
+        const git3 = (args, opts) => execFileSync15(GIT4, args, {
           cwd: opts?.cwd || repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -79513,45 +79901,8 @@ ${mergeTreeErr?.stderr || ""}`;
         ]
       };
     }
-    function readChangedGitlinkPaths(repoRoot, fromRef, toRef) {
-      try {
-        const output = (0, import_node_child_process11.execFileSync)(GIT4, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
-          cwd: repoRoot,
-          encoding: "utf8",
-          maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
-        });
-        const paths = /* @__PURE__ */ new Set();
-        for (const line of output.split("\n")) {
-          if (!line.trim()) continue;
-          const metaAndPath = line.split("	");
-          const meta3 = metaAndPath[0] || "";
-          const path58 = metaAndPath[metaAndPath.length - 1]?.trim();
-          if (!path58) continue;
-          const parts = meta3.split(/\s+/);
-          if (parts[0]?.includes("160000") || parts[1]?.includes("160000")) {
-            paths.add(path58);
-          }
-        }
-        return [...paths].sort();
-      } catch {
-        return [];
-      }
-    }
-    function readTreeObject(repoRoot, ref, path58) {
-      try {
-        const output = (0, import_node_child_process11.execFileSync)(GIT4, ["ls-tree", ref, "--", path58], {
-          cwd: repoRoot,
-          encoding: "utf8",
-          maxBuffer: 1024 * 1024
-        }).trim();
-        const match = output.match(/\bcommit\s+([0-9a-f]{40})\b/i);
-        return match?.[1];
-      } catch {
-        return void 0;
-      }
-    }
     function resolveGitDir(repoRoot) {
-      const out = (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", "--absolute-git-dir"], {
+      const out = (0, import_node_child_process13.execFileSync)(GIT4, ["rev-parse", "--absolute-git-dir"], {
         cwd: repoRoot,
         encoding: "utf8",
         maxBuffer: 1024 * 1024
@@ -79562,10 +79913,10 @@ ${mergeTreeErr?.stderr || ""}`;
       if (!baseCommit || !branchCommit) return false;
       if (baseCommit === branchCommit) return true;
       try {
-        if (!fs48.existsSync(submoduleRepoPath)) return false;
-        (0, import_node_child_process11.execFileSync)(GIT4, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
-        (0, import_node_child_process11.execFileSync)(GIT4, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
-        (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+        if (!fs50.existsSync(submoduleRepoPath)) return false;
+        (0, import_node_child_process13.execFileSync)(GIT4, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+        (0, import_node_child_process13.execFileSync)(GIT4, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+        (0, import_node_child_process13.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
         return true;
       } catch {
         return false;
@@ -79573,7 +79924,7 @@ ${mergeTreeErr?.stderr || ""}`;
     }
     function readChangedPathKinds(repoRoot, fromRef, toRef) {
       try {
-        const output = (0, import_node_child_process11.execFileSync)(GIT4, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
+        const output = (0, import_node_child_process13.execFileSync)(GIT4, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -79601,7 +79952,7 @@ ${mergeTreeErr?.stderr || ""}`;
         const baseCommit = readTreeObject(repoRoot, baseHead, path58);
         const branchCommit = readTreeObject(repoRoot, branchHead, path58);
         if (!baseCommit || !branchCommit) return false;
-        return isSubmoduleFastForward((0, import_path17.resolve)(repoRoot, path58), baseCommit, branchCommit);
+        return isSubmoduleFastForward((0, import_path18.resolve)(repoRoot, path58), baseCommit, branchCommit);
       });
     }
     function collectTrivialFastForwardGitlinkResolutions(worktreeRoot, baseRepoRoot, baseHead, branchHead) {
@@ -79610,8 +79961,8 @@ ${mergeTreeErr?.stderr || ""}`;
         const baseCommit = readTreeObject(baseRepoRoot, baseHead, path58);
         const branchCommit = readTreeObject(worktreeRoot, branchHead, path58);
         if (!baseCommit || !branchCommit) continue;
-        const submoduleRepoPath = (0, import_path17.resolve)(worktreeRoot, path58);
-        ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path17.resolve)(baseRepoRoot, path58), baseCommit);
+        const submoduleRepoPath = (0, import_path18.resolve)(worktreeRoot, path58);
+        ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path18.resolve)(baseRepoRoot, path58), baseCommit);
         if (baseCommit === branchCommit) {
           continue;
         }
@@ -79623,254 +79974,11 @@ ${mergeTreeErr?.stderr || ""}`;
       }
       return resolutions;
     }
-    function isSubmoduleDivergedSibling(submoduleRepoPath, baseCommit, branchCommit) {
-      if (!baseCommit || !branchCommit || baseCommit === branchCommit) return false;
-      try {
-        if (!fs48.existsSync(submoduleRepoPath)) return false;
-        (0, import_node_child_process11.execFileSync)(GIT4, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
-        (0, import_node_child_process11.execFileSync)(GIT4, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
-      } catch {
-        return false;
-      }
-      try {
-        (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
-        return false;
-      } catch {
-      }
-      try {
-        (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", "--is-ancestor", branchCommit, baseCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
-        return false;
-      } catch {
-      }
-      try {
-        const mb = (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", baseCommit, branchCommit], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
-        return !!mb;
-      } catch {
-        return false;
-      }
-    }
-    function resolveSubmoduleRemoteMainRef(submoduleRepoPath) {
-      try {
-        const sym = (0, import_node_child_process11.execFileSync)(GIT4, ["symbolic-ref", "-q", "refs/remotes/origin/HEAD"], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
-        if (sym) return sym;
-      } catch {
-      }
-      for (const branch of ["main", "master"]) {
-        try {
-          (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", "--verify", "-q", `refs/remotes/origin/${branch}`], { cwd: submoduleRepoPath, stdio: ["ignore", "pipe", "pipe"] });
-          return `refs/remotes/origin/${branch}`;
-        } catch {
-        }
-      }
-      return void 0;
-    }
-    function findEquivalentPublishedSubmoduleCommit(submoduleRepoPath, baseCommit, branchCommit, remoteRef) {
-      try {
-        const mergeTreeOut = (0, import_node_child_process11.execFileSync)(GIT4, ["merge-tree", "--write-tree", baseCommit, branchCommit], {
-          cwd: submoduleRepoPath,
-          encoding: "utf8",
-          stdio: ["ignore", "pipe", "pipe"]
-        });
-        const mergedTree = mergeTreeOut.trim().split(/\s+/)[0] || "";
-        if (!mergedTree) return void 0;
-        const candidates = (0, import_node_child_process11.execFileSync)(GIT4, ["rev-list", "--max-count=100", remoteRef, "--not", baseCommit], {
-          cwd: submoduleRepoPath,
-          encoding: "utf8"
-        }).split("\n").map((s2) => s2.trim()).filter(Boolean);
-        for (const candidate of candidates) {
-          try {
-            (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, candidate], { cwd: submoduleRepoPath, stdio: "ignore" });
-          } catch {
-            continue;
-          }
-          const tree = (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", `${candidate}^{tree}`], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
-          if (tree === mergedTree) return candidate;
-        }
-      } catch {
-      }
-      return void 0;
-    }
-    function ensureSubmoduleCommitLocal(submoduleRepoPath, baseSubmoduleRepoPath, commit) {
-      if (!commit) return;
-      try {
-        (0, import_node_child_process11.execFileSync)(GIT4, ["cat-file", "-e", `${commit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
-        return;
-      } catch {
-      }
-      try {
-        if (!fs48.existsSync(submoduleRepoPath) || !fs48.existsSync(baseSubmoduleRepoPath)) return;
-        (0, import_node_child_process11.execFileSync)(GIT4, ["-c", "protocol.file.allow=always", "fetch", "-q", baseSubmoduleRepoPath, "+refs/heads/*:refs/adhdev-refine-base/*"], {
-          cwd: submoduleRepoPath,
-          stdio: ["ignore", "ignore", "pipe"]
-        });
-      } catch {
-      }
-    }
-    function convergeDivergedSubmoduleGitlinks(worktreeRoot, baseRepoRoot, baseHead, branchHead) {
-      const changed = readChangedGitlinkPaths(worktreeRoot, baseHead, branchHead);
-      if (changed.length === 0) {
-        return { converged: false, reason: "no_changed_gitlinks", resolutions: [], gitlinks: [] };
-      }
-      const gitlinks = [];
-      const resolutions = [];
-      let sawDiverged = false;
-      for (const path58 of changed) {
-        const baseCommit = readTreeObject(baseRepoRoot, baseHead, path58);
-        const branchCommit = readTreeObject(worktreeRoot, branchHead, path58);
-        const submoduleRepoPath = (0, import_path17.resolve)(worktreeRoot, path58);
-        if (baseCommit) {
-          ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path17.resolve)(baseRepoRoot, path58), baseCommit);
-        }
-        if (!baseCommit || !branchCommit || !isSubmoduleDivergedSibling(submoduleRepoPath, baseCommit, branchCommit)) {
-          gitlinks.push({ path: path58, baseCommit, branchCommit, action: "skipped_not_diverged" });
-          continue;
-        }
-        sawDiverged = true;
-        try {
-          (0, import_node_child_process11.execFileSync)(GIT4, ["-c", "protocol.file.allow=always", "fetch", "-q", "origin"], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
-        } catch {
-        }
-        const remoteMainRef = resolveSubmoduleRemoteMainRef(submoduleRepoPath);
-        const publishedEquivalent = remoteMainRef ? findEquivalentPublishedSubmoduleCommit(submoduleRepoPath, baseCommit, branchCommit, remoteMainRef) : void 0;
-        if (publishedEquivalent) {
-          try {
-            (0, import_node_child_process11.execFileSync)(GIT4, ["checkout", "-q", "--detach", publishedEquivalent], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
-          } catch {
-          }
-          gitlinks.push({ path: path58, baseCommit, branchCommit, rebasedCommit: publishedEquivalent, action: "converged_to_published" });
-          resolutions.push({ path: path58, baseCommit, branchCommit, rebasedCommit: publishedEquivalent });
-          continue;
-        }
-        let rebasedCommit;
-        try {
-          (0, import_node_child_process11.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
-          (0, import_node_child_process11.execFileSync)(GIT4, ["rebase", baseCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "pipe", "pipe"] });
-          rebasedCommit = (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", "HEAD"], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
-        } catch {
-          try {
-            (0, import_node_child_process11.execFileSync)(GIT4, ["rebase", "--abort"], { cwd: submoduleRepoPath, stdio: "ignore" });
-          } catch {
-          }
-          try {
-            (0, import_node_child_process11.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
-          } catch {
-          }
-          gitlinks.push({ path: path58, baseCommit, branchCommit, action: "rebase_conflict" });
-          return { converged: false, reason: "rebase_conflict", resolutions: [], gitlinks };
-        }
-        const branchWorkSurvived = (() => {
-          if (!rebasedCommit) return false;
-          if (rebasedCommit === branchCommit) return true;
-          if (rebasedCommit === baseCommit) return false;
-          try {
-            const replayed = (0, import_node_child_process11.execFileSync)(GIT4, ["rev-list", "--count", `${baseCommit}..${rebasedCommit}`], {
-              cwd: submoduleRepoPath,
-              encoding: "utf8"
-            }).trim();
-            return Number.parseInt(replayed, 10) > 0;
-          } catch {
-            return false;
-          }
-        })();
-        if (!branchWorkSurvived) {
-          try {
-            (0, import_node_child_process11.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
-          } catch {
-          }
-          gitlinks.push({ path: path58, baseCommit, branchCommit, rebasedCommit, action: "rebase_dropped_branch_commits" });
-          return { converged: false, reason: "rebase_dropped_branch_commits", resolutions: [], gitlinks };
-        }
-        gitlinks.push({ path: path58, baseCommit, branchCommit, rebasedCommit, action: "rebased" });
-        resolutions.push({ path: path58, baseCommit, branchCommit, rebasedCommit });
-      }
-      if (!sawDiverged) {
-        return { converged: false, reason: "not_diverged", resolutions: [], gitlinks };
-      }
-      return { converged: resolutions.length > 0, resolutions, gitlinks };
-    }
-    function rootRebaseResolvingGitlinks(worktreeRoot, baseHead, resolutions) {
-      const resolveByPath = new Map(resolutions.map((r) => [r.path, r.rebasedCommit]));
-      const runRebase = (args) => {
-        try {
-          (0, import_node_child_process11.execFileSync)(GIT4, args, {
-            cwd: worktreeRoot,
-            stdio: ["ignore", "pipe", "pipe"],
-            // A rebase editor prompt would hang; keep it non-interactive.
-            env: { ...process.env, GIT_EDITOR: "true", GIT_SEQUENCE_EDITOR: "true" }
-          });
-          return { ok: true };
-        } catch {
-          return { ok: false };
-        }
-      };
-      const unmergedPaths = () => {
-        try {
-          return (0, import_node_child_process11.execFileSync)(GIT4, ["diff", "--name-only", "--diff-filter=U"], { cwd: worktreeRoot, encoding: "utf8" }).split("\n").map((s2) => s2.trim()).filter(Boolean);
-        } catch {
-          return [];
-        }
-      };
-      const abort = (reason, conflictPaths) => {
-        try {
-          (0, import_node_child_process11.execFileSync)(GIT4, ["rebase", "--abort"], { cwd: worktreeRoot, stdio: "ignore" });
-        } catch {
-        }
-        return { ok: false, reason, conflictPaths };
-      };
-      let progress = runRebase(["rebase", baseHead]);
-      let guard = 0;
-      while (!progress.ok) {
-        if (guard++ > 100) return abort("rebase_error");
-        const conflicts = unmergedPaths();
-        if (conflicts.length === 0) {
-          return abort("rebase_error");
-        }
-        const unresolvable = conflicts.filter((p) => !resolveByPath.has(p));
-        if (unresolvable.length > 0) {
-          const unresolvableGitlink = unresolvable.some((p) => {
-            try {
-              const staged = (0, import_node_child_process11.execFileSync)(GIT4, ["ls-files", "--stage", "--", p], { cwd: worktreeRoot, encoding: "utf8" });
-              return /^160000\s/m.test(staged);
-            } catch {
-              return false;
-            }
-          });
-          const allGitlink = unresolvable.every((p) => {
-            try {
-              const staged = (0, import_node_child_process11.execFileSync)(GIT4, ["ls-files", "--stage", "--", p], { cwd: worktreeRoot, encoding: "utf8" });
-              return /^160000\s/m.test(staged);
-            } catch {
-              return false;
-            }
-          });
-          return abort(allGitlink && unresolvableGitlink ? "unexpected_gitlink" : "non_gitlink_conflict", conflicts);
-        }
-        for (const p of conflicts) {
-          const commit = resolveByPath.get(p);
-          try {
-            (0, import_node_child_process11.execFileSync)(GIT4, ["checkout", "-q", "--detach", commit], { cwd: (0, import_path17.resolve)(worktreeRoot, p), stdio: "ignore" });
-          } catch {
-          }
-          try {
-            (0, import_node_child_process11.execFileSync)(GIT4, ["add", p], { cwd: worktreeRoot, stdio: "ignore" });
-          } catch {
-            return abort("rebase_error", conflicts);
-          }
-        }
-        progress = runRebase(["rebase", "--continue"]);
-      }
-      let branchHead;
-      try {
-        branchHead = (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", "HEAD"], { cwd: worktreeRoot, encoding: "utf8" }).trim();
-      } catch {
-      }
-      return { ok: true, branchHead };
-    }
     function evaluateGitlinkTrivialFastForward(repoRoot, baseHead, branchHead) {
       const changedGitlinks = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path58) => {
         const baseCommit = readTreeObject(repoRoot, baseHead, path58);
         const branchCommit = readTreeObject(repoRoot, branchHead, path58);
-        const submoduleRepoPath = (0, import_path17.resolve)(repoRoot, path58);
+        const submoduleRepoPath = (0, import_path18.resolve)(repoRoot, path58);
         const fastForward = !!baseCommit && !!branchCommit && isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit);
         return { path: path58, baseCommit, branchCommit, fastForward };
       });
@@ -79887,7 +79995,7 @@ ${mergeTreeErr?.stderr || ""}`;
       }
       let mergeBase = "";
       try {
-        mergeBase = (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", baseHead, branchHead], {
+        mergeBase = (0, import_node_child_process13.execFileSync)(GIT4, ["merge-base", baseHead, branchHead], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: 1024 * 1024
@@ -79917,7 +80025,7 @@ ${mergeTreeErr?.stderr || ""}`;
     }
     function buildTreeWithGitlinksEqualized(repoRoot, commitish, paths, placeholderCommit) {
       try {
-        const tree = (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", `${commitish}^{tree}`], {
+        const tree = (0, import_node_child_process13.execFileSync)(GIT4, ["rev-parse", `${commitish}^{tree}`], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: 1024 * 1024
@@ -79925,11 +80033,11 @@ ${mergeTreeErr?.stderr || ""}`;
         if (!tree) return void 0;
         const updates = paths.map((path58) => `160000 commit ${placeholderCommit}	${path58}`).join("\n");
         if (!updates) return tree;
-        const tmpIndex = (0, import_path17.join)(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
+        const tmpIndex = (0, import_path18.join)(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
         const env2 = { ...process.env, GIT_INDEX_FILE: tmpIndex };
         try {
-          (0, import_node_child_process11.execFileSync)(GIT4, ["read-tree", tree], { cwd: repoRoot, env: env2, stdio: "ignore" });
-          (0, import_node_child_process11.execFileSync)(GIT4, ["update-index", "--index-info"], {
+          (0, import_node_child_process13.execFileSync)(GIT4, ["read-tree", tree], { cwd: repoRoot, env: env2, stdio: "ignore" });
+          (0, import_node_child_process13.execFileSync)(GIT4, ["update-index", "--index-info"], {
             cwd: repoRoot,
             env: env2,
             input: `${updates}
@@ -79937,11 +80045,11 @@ ${mergeTreeErr?.stderr || ""}`;
             encoding: "utf8",
             stdio: ["pipe", "ignore", "ignore"]
           });
-          const newTree = (0, import_node_child_process11.execFileSync)(GIT4, ["write-tree"], { cwd: repoRoot, env: env2, encoding: "utf8" }).trim();
+          const newTree = (0, import_node_child_process13.execFileSync)(GIT4, ["write-tree"], { cwd: repoRoot, env: env2, encoding: "utf8" }).trim();
           return newTree || void 0;
         } finally {
           try {
-            fs48.rmSync(tmpIndex, { force: true });
+            fs50.rmSync(tmpIndex, { force: true });
           } catch {
           }
         }
@@ -79953,7 +80061,7 @@ ${mergeTreeErr?.stderr || ""}`;
       try {
         const branchGitlinks = gitlinks.filter((entry) => entry.branchCommit);
         const gitlinkPaths = branchGitlinks.map((entry) => entry.path);
-        const mergeBase = (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", baseHead, branchHead], {
+        const mergeBase = (0, import_node_child_process13.execFileSync)(GIT4, ["merge-base", baseHead, branchHead], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: 1024 * 1024
@@ -79966,22 +80074,22 @@ ${mergeTreeErr?.stderr || ""}`;
           const theirsEqTree = buildTreeWithGitlinksEqualized(repoRoot, branchHead, gitlinkPaths, placeholder);
           if (baseEqTree && oursEqTree && theirsEqTree) {
             try {
-              const baseEqCommit = (0, import_node_child_process11.execFileSync)(GIT4, ["commit-tree", baseEqTree, "-m", "refine-ff-base"], {
+              const baseEqCommit = (0, import_node_child_process13.execFileSync)(GIT4, ["commit-tree", baseEqTree, "-m", "refine-ff-base"], {
                 cwd: repoRoot,
                 encoding: "utf8",
                 maxBuffer: 1024 * 1024
               }).trim();
-              const oursEqCommit = (0, import_node_child_process11.execFileSync)(GIT4, ["commit-tree", oursEqTree, "-p", baseEqCommit, "-m", "refine-ff-ours"], {
+              const oursEqCommit = (0, import_node_child_process13.execFileSync)(GIT4, ["commit-tree", oursEqTree, "-p", baseEqCommit, "-m", "refine-ff-ours"], {
                 cwd: repoRoot,
                 encoding: "utf8",
                 maxBuffer: 1024 * 1024
               }).trim();
-              const theirsEqCommit = (0, import_node_child_process11.execFileSync)(GIT4, ["commit-tree", theirsEqTree, "-p", baseEqCommit, "-m", "refine-ff-theirs"], {
+              const theirsEqCommit = (0, import_node_child_process13.execFileSync)(GIT4, ["commit-tree", theirsEqTree, "-p", baseEqCommit, "-m", "refine-ff-theirs"], {
                 cwd: repoRoot,
                 encoding: "utf8",
                 maxBuffer: 1024 * 1024
               }).trim();
-              const mergeOut = (0, import_node_child_process11.execFileSync)(GIT4, ["merge-tree", "--write-tree", oursEqCommit, theirsEqCommit], {
+              const mergeOut = (0, import_node_child_process13.execFileSync)(GIT4, ["merge-tree", "--write-tree", oursEqCommit, theirsEqCommit], {
                 cwd: repoRoot,
                 encoding: "utf8",
                 maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -79992,7 +80100,7 @@ ${mergeTreeErr?.stderr || ""}`;
             }
           }
         }
-        const contentTree = mergedContentTree || (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", `${baseHead}^{tree}`], {
+        const contentTree = mergedContentTree || (0, import_node_child_process13.execFileSync)(GIT4, ["rev-parse", `${baseHead}^{tree}`], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: 1024 * 1024
@@ -80000,11 +80108,11 @@ ${mergeTreeErr?.stderr || ""}`;
         if (!contentTree) return void 0;
         const updates = branchGitlinks.map((entry) => `160000 commit ${entry.branchCommit}	${entry.path}`).join("\n");
         if (!updates) return contentTree;
-        const tmpIndex = (0, import_path17.join)(resolveGitDir(repoRoot), `adhdev-refine-ff-${baseHead.slice(0, 12)}-${branchHead.slice(0, 12)}.index`);
+        const tmpIndex = (0, import_path18.join)(resolveGitDir(repoRoot), `adhdev-refine-ff-${baseHead.slice(0, 12)}-${branchHead.slice(0, 12)}.index`);
         const env2 = { ...process.env, GIT_INDEX_FILE: tmpIndex };
         try {
-          (0, import_node_child_process11.execFileSync)(GIT4, ["read-tree", contentTree], { cwd: repoRoot, env: env2, stdio: "ignore" });
-          (0, import_node_child_process11.execFileSync)(GIT4, ["update-index", "--index-info"], {
+          (0, import_node_child_process13.execFileSync)(GIT4, ["read-tree", contentTree], { cwd: repoRoot, env: env2, stdio: "ignore" });
+          (0, import_node_child_process13.execFileSync)(GIT4, ["update-index", "--index-info"], {
             cwd: repoRoot,
             env: env2,
             input: `${updates}
@@ -80012,11 +80120,11 @@ ${mergeTreeErr?.stderr || ""}`;
             encoding: "utf8",
             stdio: ["pipe", "ignore", "ignore"]
           });
-          const newTree = (0, import_node_child_process11.execFileSync)(GIT4, ["write-tree"], { cwd: repoRoot, env: env2, encoding: "utf8" }).trim();
+          const newTree = (0, import_node_child_process13.execFileSync)(GIT4, ["write-tree"], { cwd: repoRoot, env: env2, encoding: "utf8" }).trim();
           return newTree || void 0;
         } finally {
           try {
-            fs48.rmSync(tmpIndex, { force: true });
+            fs50.rmSync(tmpIndex, { force: true });
           } catch {
           }
         }
@@ -80128,7 +80236,7 @@ ${mergeTreeErr?.stderr || ""}`;
           return { stdout: String(stdout || ""), stderr: String(stderr || ""), refspec };
         };
         const importCommitFromWorktreeSubmodule = async (submodulePath, worktreeSubmodulePath, commit) => {
-          if (!fs48.existsSync(worktreeSubmodulePath)) return false;
+          if (!fs50.existsSync(worktreeSubmodulePath)) return false;
           try {
             await runGit3(worktreeSubmodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
           } catch {
@@ -80157,7 +80265,7 @@ ${mergeTreeErr?.stderr || ""}`;
           return match ? { commit: match[1], path: match[2] } : null;
         }).filter((entry) => !!entry);
         for (const gitlink of gitlinks) {
-          const submodulePath = (0, import_path17.resolve)(repoRoot, gitlink.path);
+          const submodulePath = (0, import_path18.resolve)(repoRoot, gitlink.path);
           const entry = {
             path: gitlink.path,
             commit: gitlink.commit,
@@ -80165,7 +80273,7 @@ ${mergeTreeErr?.stderr || ""}`;
           };
           let submoduleDefaultBranch = "main";
           try {
-            if (!fs48.existsSync(submodulePath)) {
+            if (!fs50.existsSync(submodulePath)) {
               entry.error = `Submodule checkout missing at ${gitlink.path}`;
               entry.publishRequired = true;
               if (options.allowAutoPublishSubmoduleMainCommits === true) {
@@ -80184,7 +80292,7 @@ ${mergeTreeErr?.stderr || ""}`;
               entry.localReachable = false;
               if (options.allowAutoPublishSubmoduleMainCommits === true && options.worktreeRoot) {
                 try {
-                  const imported = await importCommitFromWorktreeSubmodule(submodulePath, (0, import_path17.resolve)(options.worktreeRoot, gitlink.path), gitlink.commit);
+                  const imported = await importCommitFromWorktreeSubmodule(submodulePath, (0, import_path18.resolve)(options.worktreeRoot, gitlink.path), gitlink.commit);
                   if (imported) {
                     entry.localReachable = true;
                     entry.importedFromWorktree = true;
@@ -80414,13 +80522,13 @@ ${mergeTreeErr?.stderr || ""}`;
         ...extras
       });
       const isPackageManagerValidation = (candidate) => {
-        const command = (0, import_path17.basename)(candidate.command).replace(/\.(?:cmd|exe)$/i, "");
+        const command = (0, import_path18.basename)(candidate.command).replace(/\.(?:cmd|exe)$/i, "");
         return ["npm", "pnpm", "yarn", "bun"].includes(command) && candidate.args.some((arg) => arg === "run" || arg === "test" || arg === "exec");
       };
       const dependenciesLikelyMissing = (cwd) => {
-        if (!fs48.existsSync((0, import_path17.join)(cwd, "package.json"))) return false;
-        if (fs48.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) => fs48.existsSync((0, import_path17.join)(cwd, lock)));
+        if (!fs50.existsSync((0, import_path18.join)(cwd, "package.json"))) return false;
+        if (fs50.existsSync((0, import_path18.join)(cwd, "node_modules"))) return false;
+        return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs50.existsSync((0, import_path18.join)(cwd, lock)));
       };
       const needsNodeModules = (candidate, cwd) => isPackageManagerValidation(candidate) && dependenciesLikelyMissing(cwd);
       const isDaemonScopedCommand = (candidate) => {
@@ -80487,7 +80595,7 @@ ${mergeTreeErr?.stderr || ""}`;
         summary.bootstrap = { stage: "legacy" };
         for (const candidate of selection.bootstrapCommands) {
           const startedAt = Date.now();
-          const cwd = candidate.cwd ? (0, import_path17.resolve)(workspace, candidate.cwd) : workspace;
+          const cwd = candidate.cwd ? (0, import_path18.resolve)(workspace, candidate.cwd) : workspace;
           const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
           const resolvedCommand = resolveWin32Executable(candidate.command);
           const spawn7 = buildWin32ExecFileSpawn(resolvedCommand, candidate.args);
@@ -80520,7 +80628,7 @@ ${mergeTreeErr?.stderr || ""}`;
       let missingDepsBlocked = false;
       for (const candidate of commandsToRun) {
         const startedAt = Date.now();
-        const cwd = candidate.cwd ? (0, import_path17.resolve)(workspace, candidate.cwd) : workspace;
+        const cwd = candidate.cwd ? (0, import_path18.resolve)(workspace, candidate.cwd) : workspace;
         const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
         const bootstrapProvidedDependencies = summary.bootstrap?.stage === "cached" || summary.bootstrap?.stage === "ran" || summary.bootstrap?.stage === "legacy";
         if (!bootstrapProvidedDependencies && needsNodeModules(candidate, cwd)) {
@@ -80587,16 +80695,14 @@ ${mergeTreeErr?.stderr || ""}`;
       summary.status = "passed";
       return summary;
     }
-    var import_path17;
-    var fs48;
-    var import_node_child_process11;
-    var GIT4;
+    var import_path18;
+    var fs50;
+    var import_node_child_process13;
     var REFINE_VALIDATION_TIMEOUT_MS;
     var REFINE_VALIDATION_OUTPUT_LIMIT_BYTES;
     var REFINE_VALIDATION_SUMMARY_HEAD_CHARS;
     var REFINE_VALIDATION_SUMMARY_TAIL_CHARS;
     var REFINE_VALIDATION_SUMMARY_CHARS;
-    var REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES;
     var REFINE_VALIDATION_LOG_DIR;
     var init_mesh_refine_gates = __esm2({
       "src/mesh/mesh-refine-gates.ts"() {
@@ -80604,19 +80710,19 @@ ${mergeTreeErr?.stderr || ""}`;
         init_git_status();
         init_refine_config();
         init_worktree_bootstrap_config();
-        import_path17 = require("path");
-        fs48 = __toESM2(require("fs"));
-        import_node_child_process11 = require("child_process");
+        import_path18 = require("path");
+        fs50 = __toESM2(require("fs"));
+        import_node_child_process13 = require("child_process");
         init_resolve_executable();
         init_mesh_refine_worker_cap();
-        GIT4 = process.platform === "win32" ? resolveWin32Executable("git") : "git";
+        init_mesh_refine_gitlink_utils();
+        init_mesh_refine_submodule_converge();
         REFINE_VALIDATION_TIMEOUT_MS = 12e4;
         REFINE_VALIDATION_OUTPUT_LIMIT_BYTES = 128 * 1024;
         REFINE_VALIDATION_SUMMARY_HEAD_CHARS = 2e3;
         REFINE_VALIDATION_SUMMARY_TAIL_CHARS = 6e3;
         REFINE_VALIDATION_SUMMARY_CHARS = REFINE_VALIDATION_SUMMARY_HEAD_CHARS + REFINE_VALIDATION_SUMMARY_TAIL_CHARS;
-        REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES = 4 * 1024 * 1024;
-        REFINE_VALIDATION_LOG_DIR = (0, import_path17.join)(".adhdev", "logs");
+        REFINE_VALIDATION_LOG_DIR = (0, import_path18.join)(".adhdev", "logs");
       }
     });
     function findOpenRefineDispatchForNode(args) {
@@ -81303,6 +81409,9 @@ ${mergeTreeErr?.stderr || ""}`;
               convergeReason: converge.reason,
               gitlinks: converge.gitlinks
             });
+            if (converge.reason === "submodule_commit_unavailable") {
+              LOG2.warn("Mesh", `[Refinery] Could NOT determine submodule gitlink divergence for node ${node.id} \u2014 a gitlink commit is missing from the local submodule object store (auto-converge could not run): ` + converge.gitlinks.filter((g) => g.action === "skipped_commit_unavailable").map((g) => `${g.path} (missing: ${(g.unavailable || []).join("+") || "unknown"}; base=${(g.baseCommit || "?").slice(0, 12)} branch=${(g.branchCommit || "?").slice(0, 12)})`).join(", "));
+            }
             recordMeshRefineStage(refineStages, "sync_base", "passed", syncStarted, {
               ahead: divergence.ahead,
               behind: divergence.behind,
@@ -81345,12 +81454,12 @@ ${mergeTreeErr?.stderr || ""}`;
             throw err;
           }
         } else {
-          (0, import_node_child_process12.execFileSync)("git", ["rebase", baseHead], { cwd: node.workspace, stdio: ["ignore", "pipe", "pipe"] });
+          (0, import_node_child_process14.execFileSync)("git", ["rebase", baseHead], { cwd: node.workspace, stdio: ["ignore", "pipe", "pipe"] });
         }
       } catch (rebaseErr) {
         if (!rebaseErr?.alreadyAborted) {
           try {
-            (0, import_node_child_process12.execFileSync)("git", ["rebase", "--abort"], { cwd: node.workspace, stdio: "ignore" });
+            (0, import_node_child_process14.execFileSync)("git", ["rebase", "--abort"], { cwd: node.workspace, stdio: "ignore" });
           } catch {
           }
         }
@@ -82804,7 +82913,7 @@ ${e?.stderr || ""}`;
         if (!repoRoot || !workspace) return;
         const branch = typeof node?.worktreeBranch === "string" && node.worktreeBranch.trim() ? node.worktreeBranch.trim() : (() => {
           try {
-            return (0, import_node_child_process12.execFileSync)("git", ["branch", "--show-current"], { cwd: workspace, encoding: "utf8" }).trim();
+            return (0, import_node_child_process14.execFileSync)("git", ["branch", "--show-current"], { cwd: workspace, encoding: "utf8" }).trim();
           } catch {
             return "";
           }
@@ -82812,7 +82921,7 @@ ${e?.stderr || ""}`;
         if (!branch) return;
         const baseBranch = (() => {
           try {
-            return (0, import_node_child_process12.execFileSync)("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" }).trim() || "main";
+            return (0, import_node_child_process14.execFileSync)("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" }).trim() || "main";
           } catch {
             return "main";
           }
@@ -82880,13 +82989,13 @@ ${e?.stderr || ""}`;
       });
       return handle;
     }
-    var import_node_child_process12;
+    var import_node_child_process14;
     var import_node_fs9;
     var RETRYABLE_BASE_MOVEMENT_CODES;
     var init_router_refine = __esm2({
       "src/commands/router-refine.ts"() {
         "use strict";
-        import_node_child_process12 = require("child_process");
+        import_node_child_process14 = require("child_process");
         import_node_fs9 = require("fs");
         init_logger();
         init_debug_trace();
@@ -95210,7 +95319,7 @@ ${effect.notification.body || ""}`.trim();
         if (!["cli", "ide", "extension", "acp"].includes(category)) {
           return { success: false, error: `unknown category: ${category}` };
         }
-        const fs59 = require("fs");
+        const fs61 = require("fs");
         const path58 = require("path");
         try {
           const installRoot = this.getUpstreamInstallRoot();
@@ -95219,10 +95328,10 @@ ${effect.notification.body || ""}`.trim();
           if (!targetDir.startsWith(installRootResolved + path58.sep)) {
             return { success: false, error: "refusing to delete outside upstream root" };
           }
-          if (!fs59.existsSync(targetDir)) {
+          if (!fs61.existsSync(targetDir)) {
             return { success: false, error: "not installed" };
           }
-          fs59.rmSync(targetDir, { recursive: true, force: true });
+          fs61.rmSync(targetDir, { recursive: true, force: true });
           try {
             this._ctx.providerLoader?.deactivateVerifiedChannel?.(type2);
           } catch {
@@ -95242,28 +95351,28 @@ ${effect.notification.body || ""}`.trim();
        * the UI and by the update checker.
        */
       handleListInstalledProviders(_args) {
-        const fs59 = require("fs");
+        const fs61 = require("fs");
         const path58 = require("path");
         const installRoot = this.getUpstreamInstallRoot();
-        if (!fs59.existsSync(installRoot)) return { success: true, providers: [] };
+        if (!fs61.existsSync(installRoot)) return { success: true, providers: [] };
         const CATEGORIES = ["cli", "ide", "extension", "acp"];
         const items = [];
         for (const category of CATEGORIES) {
           const categoryDir = path58.join(installRoot, category);
-          if (!fs59.existsSync(categoryDir)) continue;
+          if (!fs61.existsSync(categoryDir)) continue;
           let entries;
           try {
-            entries = fs59.readdirSync(categoryDir);
+            entries = fs61.readdirSync(categoryDir);
           } catch {
             continue;
           }
           for (const type2 of entries) {
             const v1Path = path58.join(categoryDir, type2, "provider.v1.json");
             const v0Path = path58.join(categoryDir, type2, "provider.json");
-            const manifestPath = fs59.existsSync(v1Path) ? v1Path : fs59.existsSync(v0Path) ? v0Path : null;
+            const manifestPath = fs61.existsSync(v1Path) ? v1Path : fs61.existsSync(v0Path) ? v0Path : null;
             if (!manifestPath) continue;
             try {
-              const m = JSON.parse(fs59.readFileSync(manifestPath, "utf-8"));
+              const m = JSON.parse(fs61.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({
@@ -95484,7 +95593,7 @@ ${effect.notification.body || ""}`.trim();
         if (!/^@[a-z0-9_-]+$/i.test(requestedName)) {
           return { success: false, error: "name must match @[a-z0-9_-]+" };
         }
-        const fs59 = require("fs");
+        const fs61 = require("fs");
         const path58 = require("path");
         const { spawnSync: spawnSync3 } = require("child_process");
         const file2 = ext.loadExternalSources();
@@ -95495,8 +95604,8 @@ ${effect.notification.body || ""}`.trim();
           return { success: false, error: `source url+ref already registered (use a different name to track another ref)` };
         }
         const sourceDir = path58.join(ext.externalRoot(), requestedName);
-        if (!fs59.existsSync(ext.externalRoot())) fs59.mkdirSync(ext.externalRoot(), { recursive: true });
-        if (fs59.existsSync(sourceDir)) {
+        if (!fs61.existsSync(ext.externalRoot())) fs61.mkdirSync(ext.externalRoot(), { recursive: true });
+        if (fs61.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], {
@@ -95506,7 +95615,7 @@ ${effect.notification.body || ""}`.trim();
         });
         if (clone2.status !== 0) {
           try {
-            fs59.rmSync(sourceDir, { recursive: true, force: true });
+            fs61.rmSync(sourceDir, { recursive: true, force: true });
           } catch {
           }
           return { success: false, error: `git clone failed: ${(clone2.stderr || clone2.stdout || "").trim() || "unknown error"}` };
@@ -95550,15 +95659,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 fs59 = require("fs");
+        const fs61 = require("fs");
         const path58 = 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 = path58.join(ext.externalRoot(), name);
-        if (fs59.existsSync(sourceDir)) {
+        if (fs61.existsSync(sourceDir)) {
           try {
-            fs59.rmSync(sourceDir, { recursive: true, force: true });
+            fs61.rmSync(sourceDir, { recursive: true, force: true });
           } catch (e) {
             return { success: false, error: `failed to delete ${sourceDir}: ${e?.message || e}` };
           }
@@ -97885,14 +97994,14 @@ ${marker}`,
         }
       },
       list_coordinator_prompts: async (_ctx, _args) => {
-        const fs59 = await import("fs");
+        const fs61 = await import("fs");
         const path58 = await import("path");
         const { getConfigDir: getConfigDir22 } = await Promise.resolve().then(() => (init_config(), config_exports));
         const dir = path58.join(getConfigDir22(), "coordinator-prompts");
         const entries = {};
         try {
-          if (fs59.existsSync(dir)) {
-            for (const name of fs59.readdirSync(dir)) {
+          if (fs61.existsSync(dir)) {
+            for (const name of fs61.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;
@@ -97902,7 +98011,7 @@ ${marker}`,
               const full = path58.join(dir, name);
               let content = "";
               try {
-                content = fs59.readFileSync(full, "utf8");
+                content = fs61.readFileSync(full, "utf8");
               } catch {
               }
               if (!entries[key2]) entries[key2] = { override: "", append: "" };
@@ -97916,7 +98025,7 @@ ${marker}`,
         return { success: true, dir, entries };
       },
       write_coordinator_prompt: async (_ctx, args) => {
-        const fs59 = await import("fs");
+        const fs61 = await import("fs");
         const path58 = await import("path");
         const { getConfigDir: getConfigDir22 } = await Promise.resolve().then(() => (init_config(), config_exports));
         const key2 = typeof args?.key === "string" ? args.key.trim() : "";
@@ -97929,11 +98038,11 @@ ${marker}`,
         const filename = kind === "append" ? `${key2}.append.md` : `${key2}.md`;
         const full = path58.join(dir, filename);
         try {
-          fs59.mkdirSync(dir, { recursive: true });
+          fs61.mkdirSync(dir, { recursive: true });
           if (content.trim()) {
-            fs59.writeFileSync(full, content, { encoding: "utf8", mode: 384 });
-          } else if (fs59.existsSync(full)) {
-            fs59.unlinkSync(full);
+            fs61.writeFileSync(full, content, { encoding: "utf8", mode: 384 });
+          } else if (fs61.existsSync(full)) {
+            fs61.unlinkSync(full);
           }
           return { success: true, path: full, kind, key: key2 };
         } catch (error48) {
@@ -116161,7 +116270,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
         if (providerDir) {
           try {
-            const fs59 = require("fs");
+            const fs61 = require("fs");
             const path58 = require("path");
             const candidates = [];
             if (Array.isArray(base.compatibility)) {
@@ -116173,13 +116282,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
             }
             candidates.push(path58.join(providerDir, "specs", "default.json"));
             candidates.push(path58.join(providerDir, "spec.json"));
-            const specPath = candidates.find((p) => fs59.existsSync(p));
+            const specPath = candidates.find((p) => fs61.existsSync(p));
             let nh;
             if (specPath) {
               resolved._resolvedSpecPath = specPath;
               let specControls;
               try {
-                const rawSpec = JSON.parse(fs59.readFileSync(specPath, "utf8"));
+                const rawSpec = JSON.parse(fs61.readFileSync(specPath, "utf8"));
                 specControls = rawSpec.control_bar;
                 nh = rawSpec.native_history;
               } catch {
@@ -116222,7 +116331,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 }
               } else if (nh.override_path) {
                 const overrideFile = path58.resolve(providerDir, nh.override_path);
-                if (fs59.existsSync(overrideFile)) {
+                if (fs61.existsSync(overrideFile)) {
                   try {
                     registerProviderScriptRootSafely(path58.dirname(path58.dirname(providerDir)));
                     delete require.cache[require.resolve(overrideFile)];
@@ -117139,7 +117248,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         }
       } else if (plat === "win32") {
         try {
-          const fs59 = require("fs");
+          const fs61 = require("fs");
           const appNameMap = getMacAppIdentifiers();
           const appName = appNameMap[ideId];
           if (appName) {
@@ -117148,8 +117257,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
               appName,
               "storage.json"
             );
-            if (fs59.existsSync(storagePath)) {
-              const data = JSON.parse(fs59.readFileSync(storagePath, "utf-8"));
+            if (fs61.existsSync(storagePath)) {
+              const data = JSON.parse(fs61.readFileSync(storagePath, "utf-8"));
               const workspaces = data?.openedPathsList?.workspaces3 || data?.openedPathsList?.entries || [];
               if (workspaces.length > 0) {
                 const recent = workspaces[0];
@@ -117839,7 +117948,7 @@ ${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: existsSync67, readFileSync: readFileSync55, mkdirSync: mkdirSync31, writeFileSync: writeFileSync31 } = await import("fs");
+          const { existsSync: existsSync69, readFileSync: readFileSync55, mkdirSync: mkdirSync31, writeFileSync: writeFileSync31 } = await import("fs");
           const { dirname: dirname24, join: join67 } = await import("path");
           const yaml6 = await Promise.resolve().then(() => (init_js_yaml(), js_yaml_exports));
           const relativePath = MESH_JSON_CONFIG_LOCATIONS2[0];
@@ -117848,7 +117957,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           let existedAsYaml = false;
           for (const relative8 of MESH_JSON_CONFIG_LOCATIONS2) {
             const candidate = join67(workspace, relative8);
-            if (!existsSync67(candidate)) continue;
+            if (!existsSync69(candidate)) continue;
             try {
               const text = readFileSync55(candidate, "utf-8");
               const parsed = /\.json$/i.test(candidate) ? JSON.parse(text) : yaml6.load(text);
@@ -120162,7 +120271,7 @@ ${ptyResult.output.slice(-2e3)}`);
               workspace
             };
           }
-          const { existsSync: existsSync67, readFileSync: readFileSync55, writeFileSync: writeFileSync31, copyFileSync: copyFileSync3, mkdirSync: mkdirSync31 } = await import("fs");
+          const { existsSync: existsSync69, readFileSync: readFileSync55, 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;
@@ -120207,7 +120316,7 @@ ${ptyResult.output.slice(-2e3)}`);
             if (hermesManualFallback) return returnManualFallback(message);
             return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
           }
-          const hadExistingMcpConfig = existsSync67(mcpConfigPath);
+          const hadExistingMcpConfig = existsSync69(mcpConfigPath);
           let existingMcpConfig = hermesBaseConfig?.config || {};
           if (hermesBaseConfig) {
             copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname24(mcpConfigPath));
@@ -121008,7 +121117,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: existsSync67 } = await import("fs");
+          const { existsSync: existsSync69 } = 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" };
@@ -121027,7 +121136,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const derivation = deriveMeshReviewInboxItems2({ nodes: nodeStatuses, ledgerEntries });
           for (const item of derivation.items) {
             const workspace = item.workspace;
-            if (!workspace || !existsSync67(workspace)) continue;
+            if (!workspace || !existsSync69(workspace)) continue;
             const baseRef = item.defaultBranch ? `origin/${item.defaultBranch}` : "origin/main";
             try {
               const diffResult = await getGitDiffSummary2(workspace, { baseRef, maxFiles: 100 });
@@ -121222,12 +121331,12 @@ ${ptyResult.output.slice(-2e3)}`);
     }
     init_debug_trace();
     init_mesh_host_ownership();
-    var fs51 = __toESM2(require("fs"));
+    var fs53 = __toESM2(require("fs"));
     init_mesh_node_identity();
     init_router_refine();
-    var fs49 = __toESM2(require("fs"));
+    var fs51 = __toESM2(require("fs"));
     var import_node_os2 = require("os");
-    var import_path18 = require("path");
+    var import_path19 = require("path");
     init_logger();
     init_git_locale();
     init_dist();
@@ -121239,7 +121348,7 @@ ${ptyResult.output.slice(-2e3)}`);
     function acceptableManagedWorktreePaths(resolveWorktreePath2, normalizePath2, repoRoot, meshName, branch, worktreeBaseDir) {
       const safeBranch = branch.replace(/[/\\:*?"<>|]/g, "-").replace(/^\.+|\.+$/g, "");
       const safeMeshName = meshName.replace(/[/\\:*?"<>|]/g, "-").replace(/^\.+|\.+$/g, "");
-      const legacyPath = (0, import_path18.join)((0, import_path18.dirname)(repoRoot), LEGACY_WORKTREE_DIR_NAME, safeMeshName, safeBranch);
+      const legacyPath = (0, import_path19.join)((0, import_path19.dirname)(repoRoot), LEGACY_WORKTREE_DIR_NAME, safeMeshName, safeBranch);
       const candidates = [
         resolveWorktreePath2(repoRoot, meshName, branch, worktreeBaseDir),
         legacyPath
@@ -121263,8 +121372,8 @@ ${ptyResult.output.slice(-2e3)}`);
     function looksLikeCrossTrackWorktreePath(actualPath, normalizePath2) {
       const home = normalizePath2((0, import_node_os2.homedir)());
       return TRACK_CONFIG_DIR_NAMES.some((trackDirName) => {
-        const trackWorktreesDir = (0, import_path18.join)(home, trackDirName, "worktrees");
-        return actualPath === normalizePath2(trackWorktreesDir) || actualPath.startsWith(normalizePath2(trackWorktreesDir) + import_path18.sep);
+        const trackWorktreesDir = (0, import_path19.join)(home, trackDirName, "worktrees");
+        return actualPath === normalizePath2(trackWorktreesDir) || actualPath.startsWith(normalizePath2(trackWorktreesDir) + import_path19.sep);
       });
     }
     function unexpectedPathRecoveryHint(actualPath, normalizePath2, suffix) {
@@ -121322,14 +121431,14 @@ ${ptyResult.output.slice(-2e3)}`);
       return false;
     }
     async function bestEffortRemoveWorktreeDir(self, dir) {
-      if (!dir || !fs49.existsSync(dir)) return { removed: true, residue: false };
+      if (!dir || !fs51.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 {
-          fs49.rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-          if (!fs49.existsSync(dir)) return { removed: true, residue: false };
+          fs51.rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+          if (!fs51.existsSync(dir)) return { removed: true, residue: false };
           lastErr = new Error("directory still present after rmSync");
         } catch (e) {
           lastErr = e;
@@ -121340,7 +121449,7 @@ ${ptyResult.output.slice(-2e3)}`);
         }
         await sleep3(150 * (attempt + 1));
       }
-      return fs49.existsSync(dir) ? { removed: false, residue: true, error: String(lastErr?.message || lastErr || "unknown rm error") } : { removed: true, residue: false };
+      return fs51.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.";
@@ -121353,10 +121462,10 @@ ${ptyResult.output.slice(-2e3)}`);
           recoveryHint: "Inspect the mesh node record before removing it, or remove stale metadata manually only after confirming no managed worktree remains." + sessionPreservedNote
         };
       }
-      if (!fs49.existsSync(workspace)) return { ok: true };
+      if (!fs51.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 || !fs49.existsSync(repoRoot)) {
+      if (!repoRoot || !fs51.existsSync(repoRoot)) {
         return {
           ok: false,
           code: "mesh_worktree_cleanup_missing_source_repo",
@@ -121374,9 +121483,9 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
       const normalizePath2 = (value) => {
-        const resolved = (0, import_path18.resolve)(value);
+        const resolved = (0, import_path19.resolve)(value);
         try {
-          return fs49.realpathSync(resolved);
+          return fs51.realpathSync(resolved);
         } catch {
           return resolved;
         }
@@ -121477,13 +121586,13 @@ ${ptyResult.output.slice(-2e3)}`);
           recoveryHint: "Inspect the mesh node record before removing it, or remove stale metadata manually only after confirming no managed worktree remains."
         };
       }
-      const worktreeExists = fs49.existsSync(workspace);
+      const worktreeExists = fs51.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 || !fs49.existsSync(repoRoot)) {
+      if (!repoRoot || !fs51.existsSync(repoRoot)) {
         return {
           success: false,
           code: "mesh_worktree_cleanup_missing_source_repo",
@@ -121501,9 +121610,9 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2, removeWorktree: removeWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
       const normalizePath2 = (value) => {
-        const resolved = (0, import_path18.resolve)(value);
+        const resolved = (0, import_path19.resolve)(value);
         try {
-          return fs49.realpathSync(resolved);
+          return fs51.realpathSync(resolved);
         } catch {
           return resolved;
         }
@@ -122150,8 +122259,8 @@ ${ptyResult.output.slice(-2e3)}`);
     init_logger();
     var yaml5 = __toESM2(require_js_yaml());
     var import_os5 = require("os");
-    var import_path19 = require("path");
-    var fs50 = __toESM2(require("fs"));
+    var import_path20 = require("path");
+    var fs52 = __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);
@@ -122191,14 +122300,14 @@ ${ptyResult.output.slice(-2e3)}`);
     }
     function resolveHermesUserHome() {
       const explicitHome = process.env.HERMES_HOME?.trim();
-      return explicitHome || (0, import_path19.join)((0, import_os5.homedir)(), ".hermes");
+      return explicitHome || (0, import_path20.join)((0, import_os5.homedir)(), ".hermes");
     }
     function loadHermesCoordinatorBaseConfig(targetConfigPath) {
       const sourceHome = resolveHermesUserHome();
-      const sourceConfigPath = (0, import_path19.join)(sourceHome, "config.yaml");
-      if (!fs50.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-      if ((0, import_path19.resolve)(sourceConfigPath) === (0, import_path19.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-      const parsed = parseMeshCoordinatorMcpConfig(fs50.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
+      const sourceConfigPath = (0, import_path20.join)(sourceHome, "config.yaml");
+      if (!fs52.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+      if ((0, import_path20.resolve)(sourceConfigPath) === (0, import_path20.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+      const parsed = parseMeshCoordinatorMcpConfig(fs52.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
       const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
       return { config: baseConfig, sourceHome, sourceConfigPath };
     }
@@ -122231,13 +122340,13 @@ ${ptyResult.output.slice(-2e3)}`);
       return sanitized;
     }
     function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
-      if ((0, import_path19.resolve)(sourceHome) === (0, import_path19.resolve)(targetHome)) return;
+      if ((0, import_path20.resolve)(sourceHome) === (0, import_path20.resolve)(targetHome)) return;
       for (const fileName of [".env", "auth.json"]) {
-        const sourcePath = (0, import_path19.join)(sourceHome, fileName);
-        const targetPath = (0, import_path19.join)(targetHome, fileName);
-        if (!fs50.existsSync(sourcePath)) continue;
+        const sourcePath = (0, import_path20.join)(sourceHome, fileName);
+        const targetPath = (0, import_path20.join)(targetHome, fileName);
+        if (!fs52.existsSync(sourcePath)) continue;
         try {
-          fs50.copyFileSync(sourcePath, targetPath);
+          fs52.copyFileSync(sourcePath, targetPath);
         } catch (error48) {
           LOG2.warn("MeshCoordinator", `Could not copy Hermes ${fileName} into isolated coordinator home: ${error48?.message || error48}`);
         }
@@ -122752,7 +122861,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const nodeId = readInlineMeshNodeId(node);
           if (!nodeId || !tombstones.has(nodeId)) return true;
           const workspace = readStringValue(node?.workspace);
-          if (workspace && fs51.existsSync(workspace)) {
+          if (workspace && fs53.existsSync(workspace)) {
             tombstones.delete(nodeId);
             return true;
           }
@@ -124812,7 +124921,7 @@ ${ptyResult.output.slice(-2e3)}`);
     };
     init_io_contracts();
     init_chat_message_normalization();
-    var fs52 = __toESM2(require("fs"));
+    var fs54 = __toESM2(require("fs"));
     var path522 = __toESM2(require("path"));
     var os28 = __toESM2(require("os"));
     var import_os6 = require("os");
@@ -124829,8 +124938,8 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       load() {
         try {
-          if (fs52.existsSync(getArchivePath2())) {
-            this.history = JSON.parse(fs52.readFileSync(getArchivePath2(), "utf-8"));
+          if (fs54.existsSync(getArchivePath2())) {
+            this.history = JSON.parse(fs54.readFileSync(getArchivePath2(), "utf-8"));
           }
         } catch {
           this.history = {};
@@ -124867,8 +124976,8 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       save() {
         try {
-          fs52.mkdirSync(path522.dirname(getArchivePath2()), { recursive: true });
-          fs52.writeFileSync(getArchivePath2(), JSON.stringify(this.history, null, 2));
+          fs54.mkdirSync(path522.dirname(getArchivePath2()), { recursive: true });
+          fs54.writeFileSync(getArchivePath2(), JSON.stringify(this.history, null, 2));
         } catch {
         }
       }
@@ -124893,8 +125002,8 @@ ${ptyResult.output.slice(-2e3)}`);
         for (const ext of exes) {
           const fullPath = path522.join(p, name + ext);
           try {
-            if (fs52.existsSync(fullPath)) {
-              const stat2 = fs52.statSync(fullPath);
+            if (fs54.existsSync(fullPath)) {
+              const stat2 = fs54.statSync(fullPath);
               if (stat2.isFile() && (isWin || stat2.mode & 73)) {
                 return fullPath;
               }
@@ -124941,9 +125050,9 @@ ${ptyResult.output.slice(-2e3)}`);
         if (p.includes("*")) {
           const home = os28.homedir();
           const resolved = p.replace(/\*/g, home.split(path522.sep).pop() || "");
-          if (fs52.existsSync(resolved)) return resolved;
+          if (fs54.existsSync(resolved)) return resolved;
         } else {
-          if (fs52.existsSync(p)) return p;
+          if (fs54.existsSync(p)) return p;
         }
       }
       return null;
@@ -124951,7 +125060,7 @@ ${ptyResult.output.slice(-2e3)}`);
     async function getMacAppVersion(appPath) {
       if ((0, import_os6.platform)() !== "darwin" || !appPath.endsWith(".app")) return null;
       const plistPath = path522.join(appPath, "Contents", "Info.plist");
-      if (!fs52.existsSync(plistPath)) return null;
+      if (!fs54.existsSync(plistPath)) return null;
       const raw = await runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
       return raw || null;
     }
@@ -124978,7 +125087,7 @@ ${ptyResult.output.slice(-2e3)}`);
           let resolvedBin = cliBin;
           if (!resolvedBin && appPath && currentOs === "darwin") {
             const bundled = path522.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
-            if (provider.cli && fs52.existsSync(bundled)) resolvedBin = bundled;
+            if (provider.cli && fs54.existsSync(bundled)) resolvedBin = bundled;
           }
           info.installed = !!(appPath || resolvedBin);
           info.path = appPath || null;
@@ -125024,7 +125133,7 @@ ${ptyResult.output.slice(-2e3)}`);
       return results;
     }
     var http3 = __toESM2(require("http"));
-    var fs56 = __toESM2(require("fs"));
+    var fs58 = __toESM2(require("fs"));
     var path56 = __toESM2(require("path"));
     init_config();
     function generateFiles(type2, name, category, opts = {}) {
@@ -125370,7 +125479,7 @@ async (params) => {
     }
     init_logger();
     init_builders();
-    var fs53 = __toESM2(require("fs"));
+    var fs55 = __toESM2(require("fs"));
     var path53 = __toESM2(require("path"));
     init_logger();
     async function handleCdpEvaluate(ctx, req, res) {
@@ -125551,17 +125660,17 @@ async (params) => {
       }
       let scriptsPath = "";
       const directScripts = path53.join(dir, "scripts.js");
-      if (fs53.existsSync(directScripts)) {
+      if (fs55.existsSync(directScripts)) {
         scriptsPath = directScripts;
       } else {
         const scriptsDir = path53.join(dir, "scripts");
-        if (fs53.existsSync(scriptsDir)) {
-          const versions = fs53.readdirSync(scriptsDir).filter((d) => {
-            return fs53.statSync(path53.join(scriptsDir, d)).isDirectory();
+        if (fs55.existsSync(scriptsDir)) {
+          const versions = fs55.readdirSync(scriptsDir).filter((d) => {
+            return fs55.statSync(path53.join(scriptsDir, d)).isDirectory();
           }).sort().reverse();
           for (const ver of versions) {
             const p = path53.join(scriptsDir, ver, "scripts.js");
-            if (fs53.existsSync(p)) {
+            if (fs55.existsSync(p)) {
               scriptsPath = p;
               break;
             }
@@ -125573,7 +125682,7 @@ async (params) => {
         return;
       }
       try {
-        const source = fs53.readFileSync(scriptsPath, "utf-8");
+        const source = fs55.readFileSync(scriptsPath, "utf-8");
         const hints = {};
         const funcRegex = /module\.exports\.(\w+)\s*=\s*function\s+\w+\s*\(params\)/g;
         let match;
@@ -126386,7 +126495,7 @@ async (params) => {
         ctx.json(res, 500, { error: `DOM context collection failed: ${e.message}` });
       }
     }
-    var fs54 = __toESM2(require("fs"));
+    var fs56 = __toESM2(require("fs"));
     var path54 = __toESM2(require("path"));
     function slugifyFixtureName(value) {
       const normalized = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -126402,10 +126511,10 @@ async (params) => {
     function readCliFixture(ctx, type2, name) {
       const fixtureDir = getCliFixtureDir(ctx, type2);
       const filePath = path54.join(fixtureDir, `${name}.json`);
-      if (!fs54.existsSync(filePath)) {
+      if (!fs56.existsSync(filePath)) {
         throw new Error(`Fixture not found: ${filePath}`);
       }
-      return JSON.parse(fs54.readFileSync(filePath, "utf-8"));
+      return JSON.parse(fs56.readFileSync(filePath, "utf-8"));
     }
     function getExerciseTranscriptText(result) {
       const parts = [];
@@ -127155,7 +127264,7 @@ async (params) => {
           return;
         }
         const fixtureDir = getCliFixtureDir(ctx, type2);
-        fs54.mkdirSync(fixtureDir, { recursive: true });
+        fs56.mkdirSync(fixtureDir, { recursive: true });
         const name = slugifyFixtureName(String(body?.name || `${type2}-${Date.now()}`));
         const result = await runCliExerciseInternal(ctx, { ...request, type: type2 });
         const fixture = {
@@ -127183,7 +127292,7 @@ async (params) => {
           notes: typeof body?.notes === "string" ? body.notes : void 0
         };
         const filePath = path54.join(fixtureDir, `${name}.json`);
-        fs54.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
+        fs56.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
         ctx.json(res, 200, {
           saved: true,
           name,
@@ -127201,14 +127310,14 @@ async (params) => {
     async function handleCliFixtureList(ctx, type2, _req, res) {
       try {
         const fixtureDir = getCliFixtureDir(ctx, type2);
-        if (!fs54.existsSync(fixtureDir)) {
+        if (!fs56.existsSync(fixtureDir)) {
           ctx.json(res, 200, { fixtures: [], count: 0 });
           return;
         }
-        const fixtures = fs54.readdirSync(fixtureDir).filter((file2) => file2.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file2) => {
+        const fixtures = fs56.readdirSync(fixtureDir).filter((file2) => file2.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file2) => {
           const fullPath = path54.join(fixtureDir, file2);
           try {
-            const raw = JSON.parse(fs54.readFileSync(fullPath, "utf-8"));
+            const raw = JSON.parse(fs56.readFileSync(fullPath, "utf-8"));
             return {
               name: raw.name || file2.replace(/\.json$/i, ""),
               path: fullPath,
@@ -127339,7 +127448,7 @@ async (params) => {
         ctx.json(res, 500, { error: `Raw send failed: ${e.message}` });
       }
     }
-    var fs55 = __toESM2(require("fs"));
+    var fs57 = __toESM2(require("fs"));
     var path55 = __toESM2(require("path"));
     var os29 = __toESM2(require("os"));
     var import_session_host_core10 = require_dist();
@@ -127388,10 +127497,10 @@ async (params) => {
       return fallback?.type || null;
     }
     function getLatestScriptVersionDir(scriptsDir) {
-      if (!fs55.existsSync(scriptsDir)) return null;
-      const versions = fs55.readdirSync(scriptsDir).filter((d) => {
+      if (!fs57.existsSync(scriptsDir)) return null;
+      const versions = fs57.readdirSync(scriptsDir).filter((d) => {
         try {
-          return fs55.statSync(path55.join(scriptsDir, d)).isDirectory();
+          return fs57.statSync(path55.join(scriptsDir, d)).isDirectory();
         } catch {
           return false;
         }
@@ -127413,13 +127522,13 @@ async (params) => {
       if (!sourceDir) {
         return { dir: null, reason: `Provider source directory not found for '${type2}'` };
       }
-      if (!fs55.existsSync(desiredDir)) {
-        fs55.mkdirSync(path55.dirname(desiredDir), { recursive: true });
-        fs55.cpSync(sourceDir, desiredDir, { recursive: true });
+      if (!fs57.existsSync(desiredDir)) {
+        fs57.mkdirSync(path55.dirname(desiredDir), { recursive: true });
+        fs57.cpSync(sourceDir, desiredDir, { recursive: true });
         ctx.log(`Auto-implement writable copy created: ${desiredDir}`);
       }
       const providerJson = path55.join(desiredDir, "provider.json");
-      if (!fs55.existsSync(providerJson)) {
+      if (!fs57.existsSync(providerJson)) {
         return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
       }
       return { dir: desiredDir };
@@ -127427,15 +127536,15 @@ async (params) => {
     function loadAutoImplReferenceScripts(ctx, referenceType) {
       if (!referenceType) return {};
       const refDir = ctx.findProviderDir(referenceType);
-      if (!refDir || !fs55.existsSync(refDir)) return {};
+      if (!refDir || !fs57.existsSync(refDir)) return {};
       const referenceScripts = {};
       const scriptsDir = path55.join(refDir, "scripts");
       const latestDir = getLatestScriptVersionDir(scriptsDir);
       if (!latestDir) return referenceScripts;
-      for (const file2 of fs55.readdirSync(latestDir)) {
+      for (const file2 of fs57.readdirSync(latestDir)) {
         if (!file2.endsWith(".js")) continue;
         try {
-          referenceScripts[file2] = fs55.readFileSync(path55.join(latestDir, file2), "utf-8");
+          referenceScripts[file2] = fs57.readFileSync(path55.join(latestDir, file2), "utf-8");
         } catch {
         }
       }
@@ -127544,15 +127653,15 @@ async (params) => {
         const referenceScripts = loadAutoImplReferenceScripts(ctx, resolvedReference);
         const prompt = buildAutoImplPrompt(ctx, type2, provider, providerDir, functions, domContext, referenceScripts, comment, resolvedReference, verification);
         const tmpDir = path55.join(os29.tmpdir(), "adhdev-autoimpl");
-        if (!fs55.existsSync(tmpDir)) fs55.mkdirSync(tmpDir, { recursive: true });
+        if (!fs57.existsSync(tmpDir)) fs57.mkdirSync(tmpDir, { recursive: true });
         const promptFile = path55.join(tmpDir, `prompt-${type2}-${Date.now()}.md`);
-        fs55.writeFileSync(promptFile, prompt, "utf-8");
+        fs57.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 {
-            fs55.unlinkSync(promptFile);
+            fs57.unlinkSync(promptFile);
           } catch {
           }
           ctx.json(res, 400, { error: `Agent '${agent}' has no spawn config. Select a CLI provider with a spawn configuration.` });
@@ -127654,7 +127763,7 @@ async (params) => {
             } catch {
             }
             try {
-              fs55.unlinkSync(promptFile);
+              fs57.unlinkSync(promptFile);
             } catch {
             }
             ctx.log(`Auto-implement (ACP) ${success2 ? "completed" : "failed"}: ${type2} (exit: ${code})`);
@@ -127877,7 +127986,7 @@ async (params) => {
             }
           });
           try {
-            fs55.unlinkSync(promptFile);
+            fs57.unlinkSync(promptFile);
           } catch {
           }
           ctx.log(`Auto-implement ${success2 ? "completed" : "failed"}: ${type2} (exit: ${code})${verificationSummary ? ` verify=${verificationSummary.pass ? "pass" : "fail"}` : ""}`);
@@ -127982,10 +128091,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 fs55.readdirSync(latestScriptsDir)) {
+        for (const file2 of fs57.readdirSync(latestScriptsDir)) {
           if (file2.endsWith(".js") && targetFileNames.has(file2)) {
             try {
-              const content = fs55.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
+              const content = fs57.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
               lines.push("```javascript");
               lines.push(content);
@@ -127995,14 +128104,14 @@ async (params) => {
             }
           }
         }
-        const refFiles = fs55.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+        const refFiles = fs57.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 = fs55.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
+              const content = fs57.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u{1F512}`);
               lines.push("```javascript");
               lines.push(content);
@@ -128047,7 +128156,7 @@ async (params) => {
       const loadGuide = (name) => {
         try {
           const p = path55.join(docsDir, name);
-          if (fs55.existsSync(p)) return fs55.readFileSync(p, "utf-8");
+          if (fs57.existsSync(p)) return fs57.readFileSync(p, "utf-8");
         } catch {
         }
         return null;
@@ -128291,11 +128400,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 fs55.readdirSync(latestScriptsDir)) {
+        for (const file2 of fs57.readdirSync(latestScriptsDir)) {
           if (!file2.endsWith(".js")) continue;
           if (!targetFileNames.has(file2)) continue;
           try {
-            const content = fs55.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
+            const content = fs57.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
             lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
             lines.push("```javascript");
             lines.push(content);
@@ -128304,14 +128413,14 @@ async (params) => {
           } catch {
           }
         }
-        const refFiles = fs55.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+        const refFiles = fs57.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 = fs55.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
+              const content = fs57.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u{1F512}`);
               lines.push("```javascript");
               lines.push(content);
@@ -128348,7 +128457,7 @@ async (params) => {
       const loadGuide = (name) => {
         try {
           const p = path55.join(docsDir, name);
-          if (fs55.existsSync(p)) return fs55.readFileSync(p, "utf-8");
+          if (fs57.existsSync(p)) return fs57.readFileSync(p, "utf-8");
         } catch {
         }
         return null;
@@ -129086,7 +129195,7 @@ data: ${JSON.stringify(msg.data)}
           path56.join(process.cwd(), "packages/web-devconsole/dist")
         ];
         for (const dir of candidates) {
-          if (fs56.existsSync(path56.join(dir, "index.html"))) return dir;
+          if (fs58.existsSync(path56.join(dir, "index.html"))) return dir;
         }
         return null;
       }
@@ -129098,7 +129207,7 @@ data: ${JSON.stringify(msg.data)}
         }
         const htmlPath = path56.join(distDir, "index.html");
         try {
-          const html = fs56.readFileSync(htmlPath, "utf-8");
+          const html = fs58.readFileSync(htmlPath, "utf-8");
           res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
           res.end(html);
         } catch (e) {
@@ -129128,7 +129237,7 @@ data: ${JSON.stringify(msg.data)}
           return;
         }
         try {
-          const content = fs56.readFileSync(filePath);
+          const content = fs58.readFileSync(filePath);
           const ext = path56.extname(filePath);
           const contentType = _DevServer.MIME_MAP[ext] || "application/octet-stream";
           res.writeHead(200, { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" });
@@ -129237,14 +129346,14 @@ data: ${JSON.stringify(msg.data)}
         const files = [];
         const scan = (d, prefix) => {
           try {
-            for (const entry of fs56.readdirSync(d, { withFileTypes: true })) {
+            for (const entry of fs58.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(path56.join(d, entry.name), rel);
               } else {
-                const stat2 = fs56.statSync(path56.join(d, entry.name));
+                const stat2 = fs58.statSync(path56.join(d, entry.name));
                 files.push({ path: rel, size: stat2.size, type: "file" });
               }
             }
@@ -129272,11 +129381,11 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 403, { error: "Forbidden" });
           return;
         }
-        if (!fs56.existsSync(fullPath) || fs56.statSync(fullPath).isDirectory()) {
+        if (!fs58.existsSync(fullPath) || fs58.statSync(fullPath).isDirectory()) {
           this.json(res, 404, { error: `File not found: ${filePath}` });
           return;
         }
-        const content = fs56.readFileSync(fullPath, "utf-8");
+        const content = fs58.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 } */
@@ -129298,9 +129407,9 @@ data: ${JSON.stringify(msg.data)}
           return;
         }
         try {
-          if (fs56.existsSync(fullPath)) fs56.copyFileSync(fullPath, fullPath + ".bak");
-          fs56.mkdirSync(path56.dirname(fullPath), { recursive: true });
-          fs56.writeFileSync(fullPath, content, "utf-8");
+          if (fs58.existsSync(fullPath)) fs58.copyFileSync(fullPath, fullPath + ".bak");
+          fs58.mkdirSync(path56.dirname(fullPath), { recursive: true });
+          fs58.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 });
@@ -129317,8 +129426,8 @@ data: ${JSON.stringify(msg.data)}
         }
         for (const name of ["scripts.js", "provider.json"]) {
           const p = path56.join(dir, name);
-          if (fs56.existsSync(p)) {
-            const source = fs56.readFileSync(p, "utf-8");
+          if (fs58.existsSync(p)) {
+            const source = fs58.readFileSync(p, "utf-8");
             this.json(res, 200, { type: type2, path: p, source, lines: source.split("\n").length });
             return;
           }
@@ -129337,11 +129446,11 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 404, { error: `Provider not found: ${type2}` });
           return;
         }
-        const target = fs56.existsSync(path56.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
+        const target = fs58.existsSync(path56.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
         const targetPath = path56.join(dir, target);
         try {
-          if (fs56.existsSync(targetPath)) fs56.copyFileSync(targetPath, targetPath + ".bak");
-          fs56.writeFileSync(targetPath, source, "utf-8");
+          if (fs58.existsSync(targetPath)) fs58.copyFileSync(targetPath, targetPath + ".bak");
+          fs58.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 });
@@ -129486,20 +129595,20 @@ data: ${JSON.stringify(msg.data)}
         let targetDir;
         targetDir = this.providerLoader.getUserProviderDir(category, type2);
         const jsonPath = path56.join(targetDir, "provider.json");
-        if (fs56.existsSync(jsonPath)) {
+        if (fs58.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 });
-          fs56.mkdirSync(targetDir, { recursive: true });
-          fs56.writeFileSync(jsonPath, result["provider.json"], "utf-8");
+          fs58.mkdirSync(targetDir, { recursive: true });
+          fs58.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 = path56.join(targetDir, relPath);
-              fs56.mkdirSync(path56.dirname(fullPath), { recursive: true });
-              fs56.writeFileSync(fullPath, content, "utf-8");
+              fs58.mkdirSync(path56.dirname(fullPath), { recursive: true });
+              fs58.writeFileSync(fullPath, content, "utf-8");
               createdFiles.push(relPath);
             }
           }
@@ -129548,10 +129657,10 @@ data: ${JSON.stringify(msg.data)}
       }
       // ─── Phase 2: Auto-Implement Backend ───
       getLatestScriptVersionDir(scriptsDir) {
-        if (!fs56.existsSync(scriptsDir)) return null;
-        const versions = fs56.readdirSync(scriptsDir).filter((d) => {
+        if (!fs58.existsSync(scriptsDir)) return null;
+        const versions = fs58.readdirSync(scriptsDir).filter((d) => {
           try {
-            return fs56.statSync(path56.join(scriptsDir, d)).isDirectory();
+            return fs58.statSync(path56.join(scriptsDir, d)).isDirectory();
           } catch {
             return false;
           }
@@ -129573,13 +129682,13 @@ data: ${JSON.stringify(msg.data)}
         if (!sourceDir) {
           return { dir: null, reason: `Provider source directory not found for '${type2}'` };
         }
-        if (!fs56.existsSync(desiredDir)) {
-          fs56.mkdirSync(path56.dirname(desiredDir), { recursive: true });
-          fs56.cpSync(sourceDir, desiredDir, { recursive: true });
+        if (!fs58.existsSync(desiredDir)) {
+          fs58.mkdirSync(path56.dirname(desiredDir), { recursive: true });
+          fs58.cpSync(sourceDir, desiredDir, { recursive: true });
           this.log(`Auto-implement writable copy created: ${desiredDir}`);
         }
         const providerJson = path56.join(desiredDir, "provider.json");
-        if (!fs56.existsSync(providerJson)) {
+        if (!fs58.existsSync(providerJson)) {
           return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
         }
         return { dir: desiredDir };
@@ -130388,7 +130497,7 @@ data: ${JSON.stringify(msg.data)}
       }
     }
     var import_child_process14 = require("child_process");
-    var fs57 = __toESM2(require("fs"));
+    var fs59 = __toESM2(require("fs"));
     var os30 = __toESM2(require("os"));
     var path57 = __toESM2(require("path"));
     var import_session_host_core14 = require_dist();
@@ -130414,7 +130523,7 @@ data: ${JSON.stringify(msg.data)}
           path57.resolve(__dirname, "../../vendor/session-host-daemon/index.js")
         ];
         for (const candidate of packagedCandidates) {
-          if (fs57.existsSync(candidate)) {
+          if (fs59.existsSync(candidate)) {
             return candidate;
           }
         }
@@ -130434,8 +130543,8 @@ data: ${JSON.stringify(msg.data)}
       function getPid() {
         try {
           const pidFile = getPidFile();
-          if (!fs57.existsSync(pidFile)) return null;
-          const pid = Number.parseInt(fs57.readFileSync(pidFile, "utf8").trim(), 10);
+          if (!fs59.existsSync(pidFile)) return null;
+          const pid = Number.parseInt(fs59.readFileSync(pidFile, "utf8").trim(), 10);
           return Number.isFinite(pid) ? pid : null;
         } catch {
           return null;
@@ -130485,7 +130594,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) => fs57.existsSync(candidate));
+        const found = candidates.find((candidate) => fs59.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.`
@@ -130501,8 +130610,8 @@ data: ${JSON.stringify(msg.data)}
         let logFd = null;
         if (options.spawnStdio === "logfile") {
           const logDir = path57.join(instance().configDir, "logs");
-          fs57.mkdirSync(logDir, { recursive: true });
-          logFd = fs57.openSync(path57.join(logDir, "session-host.log"), "a");
+          fs59.mkdirSync(logDir, { recursive: true });
+          logFd = fs59.openSync(path57.join(logDir, "session-host.log"), "a");
           stdio = ["ignore", logFd, logFd];
         }
         const child = (0, import_child_process14.spawn)(nodeExecutable, [entry], {
@@ -130514,7 +130623,7 @@ data: ${JSON.stringify(msg.data)}
         child.unref();
         if (logFd !== null) {
           try {
-            fs57.closeSync(logFd);
+            fs59.closeSync(logFd);
           } catch {
           }
         }
@@ -130532,8 +130641,8 @@ data: ${JSON.stringify(msg.data)}
         const pidFile = getPidFile();
         let keepPidFile = false;
         try {
-          if (fs57.existsSync(pidFile)) {
-            const pid = Number.parseInt(fs57.readFileSync(pidFile, "utf8").trim(), 10);
+          if (fs59.existsSync(pidFile)) {
+            const pid = Number.parseInt(fs59.readFileSync(pidFile, "utf8").trim(), 10);
             if (Number.isFinite(pid) && pid !== process.pid) {
               const managed = isManagedPid(pid);
               if (managed) {
@@ -130553,7 +130662,7 @@ data: ${JSON.stringify(msg.data)}
         } finally {
           if (!keepPidFile) {
             try {
-              fs57.unlinkSync(pidFile);
+              fs59.unlinkSync(pidFile);
             } catch {
             }
           }
@@ -130589,7 +130698,7 @@ data: ${JSON.stringify(msg.data)}
         }
         if (!reported) return;
         if (pathsEquivalent(reported, currentEntry)) return;
-        const reportedExists = fs57.existsSync(reported);
+        const reportedExists = fs59.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.`
@@ -130816,8 +130925,8 @@ data: ${JSON.stringify(msg.data)}
           const res = await fetch(extension.vsixUrl);
           if (res.ok) {
             const buffer = Buffer.from(await res.arrayBuffer());
-            const fs59 = await import("fs");
-            fs59.writeFileSync(vsixPath, buffer);
+            const fs61 = await import("fs");
+            fs61.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) => {
@@ -130963,7 +131072,7 @@ data: ${JSON.stringify(msg.data)}
     init_mesh_events();
     init_mesh_reconcile_loop();
     var import_fs19 = require("fs");
-    var import_path20 = require("path");
+    var import_path21 = require("path");
     var import_crypto18 = require("crypto");
     init_logger();
     init_mesh_ledger();
@@ -131041,7 +131150,7 @@ data: ${JSON.stringify(msg.data)}
       }
       for (const name of names) {
         if (!isPendingEventsFile(name)) continue;
-        const path58 = (0, import_path20.join)(dir, name);
+        const path58 = (0, import_path21.join)(dir, name);
         result.filesScanned++;
         const claimed = `${path58}.migrating`;
         try {
@@ -131820,7 +131929,7 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
       Object.values(V1_PRIMITIVE_CATALOG).flat()
     );
     var V1_CONTRACT_VERSION = "1.0.0";
-    var fs58 = __toESM2(require("fs"));
+    var fs60 = __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.";
@@ -131931,7 +132040,7 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         console.log(import_chalk2.default.gray(`  Backup: ${status.paths.backupFile}`));
         let snapshotMtimeMs = null;
         try {
-          snapshotMtimeMs = fs58.statSync(status.paths.snapshotFile).mtimeMs;
+          snapshotMtimeMs = fs60.statSync(status.paths.snapshotFile).mtimeMs;
         } catch {
         }
         console.log(import_chalk2.default.gray(