@adhdev/daemon-standalone 1.0.58-rc.14 → 1.0.58-rc.15

package/dist/index.js

@@ -36882,10 +36882,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "3f1bf15bd8ba7a0e9c7e1ff028dfc00efd1115f4" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "3f1bf15b" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.58-rc.14" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-25T17:44:27.365Z" : void 0);
+      const commit = readInjected(true ? "0b39364ac334ce9649b42e58d5bda606abe274ec" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "0b39364a" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.58-rc.15" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-26T02:38:01.516Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -46233,6 +46233,20 @@ Next step: ${nextStep}`;
           `[System] Refinery async job for ${args.nodeLabel} failed${details ? ` (${details})` : ""}${error48 ? `: ${error48}` : "."}`,
           nextStep ? `Next step: ${nextStep}` : "Review the terminal refine event/ledger before retrying."
         ];
+        const batchResults = result?.batch === true && Array.isArray(result?.results) ? result.results : [];
+        const failedNodes = batchResults.filter((entry) => entry && entry.convergence !== "merged_to_main" && entry.convergence !== "skipped_patch_equivalent");
+        if (failedNodes.length > 0) {
+          parts.push("Per-node failures:");
+          for (const entry of failedNodes) {
+            const nodeId = readNonEmptyString(entry.nodeId) || "(unknown node)";
+            const nodeConvergence = readNonEmptyString(entry.convergence);
+            const nodeCode = readNonEmptyString(entry.code);
+            const nodeStage = readNonEmptyString(entry.stage);
+            const nodeError = readNonEmptyString(entry.error);
+            const codeStage = [nodeCode ? `code=${nodeCode}` : "", nodeStage ? `stage=${nodeStage}` : ""].filter(Boolean).join(", ");
+            parts.push(`- ${nodeId}${nodeConvergence ? `: ${nodeConvergence}` : ""}${codeStage ? ` (${codeStage})` : ""}${nodeError ? ` \u2014 ${nodeError.length > 200 ? `${nodeError.slice(0, 200)}\u2026` : nodeError}` : ""}`);
+          }
+        }
         return parts.join("\n");
       }
       return "";
@@ -60646,7 +60660,7 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
       const remote = opts.remote?.trim() || "origin";
       const localTimeout = opts.timeoutMs ?? 1e4;
       const git3 = resolveWin32Executable("git");
-      const execFileAsync7 = (0, import_node_util3.promisify)(import_node_child_process4.execFile);
+      const execFileAsync8 = (0, import_node_util3.promisify)(import_node_child_process4.execFile);
       if (opts.superprojectWorkspace && opts.submodulePath) {
         try {
           const normalized = opts.submodulePath.replace(/\\/g, "/").replace(/\/+$/, "");
@@ -60656,7 +60670,7 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
         }
       }
       try {
-        const { stdout } = await execFileAsync7(
+        const { stdout } = await execFileAsync8(
           git3,
           ["symbolic-ref", "--short", `refs/remotes/${remote}/HEAD`],
           { cwd: opts.submoduleRepoPath, encoding: "utf8", timeout: localTimeout, windowsHide: true }
@@ -60668,7 +60682,7 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
       } catch {
       }
       try {
-        const { stdout } = await execFileAsync7(
+        const { stdout } = await execFileAsync8(
           git3,
           ["ls-remote", "--symref", remote, "HEAD"],
           { cwd: opts.submoduleRepoPath, encoding: "utf8", timeout: Math.max(localTimeout, 3e4), windowsHide: true }
@@ -60839,7 +60853,7 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
       if (!validation.valid) {
         return { status: "failed", required: required2, configSource: loaded.path || loaded.source, configSourceType: "invalid", error: String(validation.rejectedCommands[0]?.reason || validation.errors.join("; ")), commandsRun: [] };
       }
-      const execFileAsync7 = (0, import_node_util3.promisify)(import_node_child_process4.execFile);
+      const execFileAsync8 = (0, import_node_util3.promisify)(import_node_child_process4.execFile);
       const state = {
         status: "running",
         required: required2,
@@ -60867,7 +60881,7 @@ When the user asks to **set up / configure / onboard** this repo for Repo Mesh (
         const resolvedCommand = resolveWin32Executable(command.command);
         const spawn7 = buildWin32ExecFileSpawn(resolvedCommand, command.args);
         try {
-          const result = await execFileAsync7(spawn7.file, spawn7.args, {
+          const result = await execFileAsync8(spawn7.file, spawn7.args, {
             cwd,
             encoding: "utf8",
             timeout: command.timeoutMs || DEFAULT_TIMEOUT_MS2,
@@ -76631,9 +76645,9 @@ ${cleanBody}`;
       }
     }
     async function defaultRunGit(args, cwd) {
-      const { execFile: execFile8 } = await import("child_process");
-      const { promisify: promisify11 } = await import("util");
-      const { stdout } = await promisify11(execFile8)("git", args, {
+      const { execFile: execFile9 } = await import("child_process");
+      const { promisify: promisify12 } = await import("util");
+      const { stdout } = await promisify12(execFile9)("git", args, {
         cwd,
         encoding: "utf8",
         timeout: 3e4,
@@ -83316,435 +83330,9 @@ ${cleanBody}`;
         _acpValidator = null;
       }
     });
-    function topLevel(path63) {
-      const slash = path63.indexOf("/");
-      return slash === -1 ? path63 : path63.slice(0, slash);
-    }
-    async function analyzeMeshRefineNodeChangeArea(args) {
-      const { nodeId, workspace, branch, baseRef, branchRef, diffCwd, submodulePaths } = args;
-      const base = {
-        nodeId,
-        workspace,
-        branch,
-        changedTopLevelPaths: [],
-        changedFiles: [],
-        touchedSubmodulePaths: [],
-        touchesSubmodule: false,
-        aheadCount: 0
-      };
-      try {
-        let mergeBase = baseRef;
-        try {
-          const { stdout } = await execFileAsync5(GIT2, ["merge-base", baseRef, branchRef], { cwd: diffCwd, encoding: "utf8" });
-          const resolved = stdout.trim();
-          if (resolved) mergeBase = resolved;
-        } catch {
-        }
-        const { stdout: countStdout } = await execFileAsync5(
-          GIT2,
-          ["rev-list", "--count", `${mergeBase}..${branchRef}`],
-          { cwd: diffCwd, encoding: "utf8" }
-        );
-        base.aheadCount = Number.parseInt(countStdout.trim(), 10) || 0;
-        const { stdout: nameStdout } = await execFileAsync5(
-          GIT2,
-          ["diff", "--name-only", `${mergeBase}..${branchRef}`],
-          { cwd: diffCwd, encoding: "utf8" }
-        );
-        const files = nameStdout.split("\n").map((line) => line.trim()).filter(Boolean).slice(0, MAX_CHANGED_FILES2);
-        base.changedFiles = files;
-        const topSet = /* @__PURE__ */ new Set();
-        const submoduleSet = /* @__PURE__ */ new Set();
-        for (const file2 of files) {
-          const top = topLevel(file2);
-          topSet.add(top);
-          if (submodulePaths.has(file2) || submodulePaths.has(top)) {
-            submoduleSet.add(submodulePaths.has(file2) ? file2 : top);
-          }
-        }
-        base.changedTopLevelPaths = [...topSet].sort();
-        base.touchedSubmodulePaths = [...submoduleSet].sort();
-        base.touchesSubmodule = submoduleSet.size > 0;
-        return base;
-      } catch (e) {
-        base.error = e?.message || String(e);
-        return base;
-      }
-    }
-    function orderMeshRefineBatchNodes(changeAreas) {
-      const areaById = {};
-      for (const area of changeAreas) areaById[area.nodeId] = area;
-      const ranked = [...changeAreas].sort((a, b) => {
-        const aSub = a.touchesSubmodule ? 1 : 0;
-        const bSub = b.touchesSubmodule ? 1 : 0;
-        if (aSub !== bSub) return aSub - bSub;
-        const aBreadth = a.changedTopLevelPaths.length;
-        const bBreadth = b.changedTopLevelPaths.length;
-        if (aBreadth !== bBreadth) return aBreadth - bBreadth;
-        return a.nodeId.localeCompare(b.nodeId);
-      });
-      const rationale = [];
-      const nonSub = ranked.filter((a) => !a.touchesSubmodule).map((a) => a.nodeId);
-      const sub = ranked.filter((a) => a.touchesSubmodule).map((a) => a.nodeId);
-      if (nonSub.length) {
-        rationale.push(`Non-submodule nodes first (no submodule-main advance, conflict-free ordering): ${nonSub.join(", ")}`);
-      }
-      if (sub.length) {
-        rationale.push(`Submodule-touching nodes last, serialized (each merge advances submodule main, forcing rebase of the next): ${sub.join(", ")}`);
-      }
-      for (const area of ranked) {
-        if (area.error) rationale.push(`Node ${area.nodeId}: change-area analysis degraded (${area.error}); placed with neutral priority.`);
-      }
-      return { order: ranked.map((a) => a.nodeId), changeAreas: areaById, rationale };
-    }
-    var import_node_child_process10;
-    var import_node_util6;
-    var execFileAsync5;
-    var GIT2;
-    var MAX_CHANGED_FILES2;
-    var init_mesh_refine_batch = __esm2({
-      "src/mesh/mesh-refine-batch.ts"() {
-        "use strict";
-        import_node_child_process10 = require("child_process");
-        import_node_util6 = require("util");
-        init_resolve_executable();
-        execFileAsync5 = (0, import_node_util6.promisify)(import_node_child_process10.execFile);
-        GIT2 = process.platform === "win32" ? resolveWin32Executable("git") : "git";
-        MAX_CHANGED_FILES2 = 500;
-      }
-    });
-    async function git2(cwd, args) {
-      const { stdout } = await execFileAsync6(GIT3, args, {
-        cwd,
-        encoding: "utf8",
-        timeout: 15e3,
-        windowsHide: true
-      });
-      return String(stdout || "").trim();
-    }
-    async function isAncestor(cwd, ancestor, descendant) {
-      try {
-        await git2(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]);
-        return true;
-      } catch {
-        return false;
-      }
-    }
-    async function assessScope(cwd, path63, baseRef, branchRef) {
-      try {
-        if (!(0, import_node_fs7.existsSync)(cwd)) return { path: path63, verdict: "unknown", error: `path does not exist: ${cwd}` };
-        const liveBaseHead = await git2(cwd, ["rev-parse", baseRef]);
-        const branchHead = await git2(cwd, ["rev-parse", branchRef]);
-        if (!liveBaseHead || !branchHead) {
-          return { path: path63, verdict: "unknown", error: "could not resolve base or branch head" };
-        }
-        if (await isAncestor(cwd, liveBaseHead, branchHead)) {
-          return { path: path63, verdict: "clear", liveBaseHead };
-        }
-        let mergeBase;
-        try {
-          mergeBase = await git2(cwd, ["merge-base", liveBaseHead, branchHead]);
-        } catch {
-          return { path: path63, verdict: "unknown", liveBaseHead, error: "no common merge base" };
-        }
-        if (!mergeBase) return { path: path63, verdict: "unknown", liveBaseHead, error: "empty merge base" };
-        return { path: path63, verdict: "diverged", liveBaseHead, mergeBase };
-      } catch (e) {
-        return { path: path63, verdict: "unknown", error: e?.message || String(e) };
-      }
-    }
-    async function resolveSubmodulePaths(repoRoot) {
-      try {
-        const stdout = await git2(repoRoot, ["config", "--file", ".gitmodules", "--get-regexp", "path"]);
-        const paths = /* @__PURE__ */ new Set();
-        for (const line of stdout.split("\n")) {
-          const trimmed = line.trim();
-          const spaceIdx = trimmed.indexOf(" ");
-          if (spaceIdx === -1) continue;
-          const value = trimmed.slice(spaceIdx + 1).trim();
-          if (value) paths.add(value);
-        }
-        return paths;
-      } catch {
-        return /* @__PURE__ */ new Set();
-      }
-    }
-    async function assessRefineBaseDivergence(args) {
-      const started = Date.now();
-      const { repoRoot, workspace, baseBranch, branch } = args;
-      const scopes = [];
-      let touchedSubmodulePaths = [];
-      const rootBaseRef = await (async () => {
-        for (const ref of [`origin/${baseBranch}`, baseBranch, "HEAD"]) {
-          try {
-            await git2(repoRoot, ["rev-parse", "--verify", `${ref}^{commit}`]);
-            return ref;
-          } catch {
-          }
-        }
-        return `origin/${baseBranch}`;
-      })();
-      scopes.push(await assessScope(workspace, ".", rootBaseRef, branch));
-      try {
-        const submodulePaths = await resolveSubmodulePaths(repoRoot);
-        if (submodulePaths.size > 0) {
-          const baseRefSha = await git2(repoRoot, ["rev-parse", rootBaseRef]).catch(() => "");
-          const branchRefSha = await git2(workspace, ["rev-parse", branch]).catch(() => "");
-          if (baseRefSha && branchRefSha) {
-            const area = await analyzeMeshRefineNodeChangeArea({
-              nodeId: "(accept-precheck)",
-              workspace,
-              branch,
-              baseRef: baseRefSha,
-              branchRef: branchRefSha,
-              diffCwd: workspace,
-              submodulePaths
-            });
-            touchedSubmodulePaths = area.touchedSubmodulePaths;
-            for (const subPath of touchedSubmodulePaths) {
-              const subCwd = (0, import_node_path5.resolve)(workspace, subPath);
-              const subBaseRef = await (async () => {
-                for (const ref of ["origin/main", "origin/master", "main", "master"]) {
-                  try {
-                    await git2(subCwd, ["rev-parse", "--verify", `${ref}^{commit}`]);
-                    return ref;
-                  } catch {
-                  }
-                }
-                return "origin/main";
-              })();
-              scopes.push(await assessScope(subCwd, subPath, subBaseRef, "HEAD"));
-            }
-          }
-        }
-      } catch {
-      }
-      const verdict = scopes.some((s2) => s2.verdict === "diverged") ? "diverged" : scopes.some((s2) => s2.verdict === "unknown") ? "unknown" : "clear";
-      return { verdict, scopes, touchedSubmodulePaths, durationMs: Date.now() - started };
-    }
-    var import_node_child_process11;
-    var import_node_util7;
-    var import_node_path5;
-    var import_node_fs7;
-    var execFileAsync6;
-    var GIT3;
-    var init_mesh_refine_base_divergence = __esm2({
-      "src/mesh/mesh-refine-base-divergence.ts"() {
-        "use strict";
-        import_node_child_process11 = require("child_process");
-        import_node_util7 = require("util");
-        import_node_path5 = require("path");
-        import_node_fs7 = require("fs");
-        init_resolve_executable();
-        init_mesh_refine_batch();
-        execFileAsync6 = (0, import_node_util7.promisify)(import_node_child_process11.execFile);
-        GIT3 = process.platform === "win32" ? resolveWin32Executable("git") : "git";
-      }
-    });
-    var mesh_refine_zombie_sweep_exports = {};
-    __export2(mesh_refine_zombie_sweep_exports, {
-      classifyRefineDispatch: () => classifyRefineDispatch,
-      refineArchivePairKey: () => refineArchivePairKey,
-      selectOpenRefineDispatches: () => selectOpenRefineDispatches,
-      shouldNotifyRefineCloseOut: () => shouldNotifyRefineCloseOut
-    });
-    function classifyRefineDispatch(record2, opts) {
-      if (opts.isRunning(record2.nodeId)) return void 0;
-      const dispatchedAtMs = new Date(record2.timestamp).getTime();
-      const ageMs2 = Number.isFinite(dispatchedAtMs) ? opts.nowMs - dispatchedAtMs : void 0;
-      const base = { nodeId: record2.nodeId, jobId: record2.jobId, ...ageMs2 !== void 0 ? { ageMs: ageMs2 } : {} };
-      if (!opts.nodeExists(record2.nodeId)) {
-        return { ...base, disposition: "close_removed_node" };
-      }
-      if (opts.executorLiveness) {
-        let liveness;
-        try {
-          liveness = opts.executorLiveness(record2);
-        } catch {
-          liveness = "unknown";
-        }
-        if (liveness === "alive") {
-          return { ...base, disposition: "defer_executor_alive" };
-        }
-      }
-      if (ageMs2 !== void 0 && ageMs2 >= 0 && ageMs2 < opts.graceMs) {
-        return { ...base, disposition: "defer_grace" };
-      }
-      if (ageMs2 !== void 0 && ageMs2 >= opts.zombieCutoffMs) {
-        return { ...base, disposition: "close_stale" };
-      }
-      return { ...base, disposition: "resume" };
-    }
-    function selectOpenRefineDispatches(entries, archivedTerminalKeys) {
-      const terminalKeys = /* @__PURE__ */ new Set();
-      for (const e of entries) {
-        if (e.kind !== "task_completed" && e.kind !== "task_failed") continue;
-        if (!e.nodeId) continue;
-        const jobId = e.payload?.refineJob?.jobId;
-        if (jobId) terminalKeys.add(`${e.nodeId}:${jobId}`);
-      }
-      const open = [];
-      const seen = /* @__PURE__ */ new Set();
-      for (const e of entries) {
-        if (e.kind !== "task_dispatched" || !e.nodeId) continue;
-        const payload = e.payload;
-        if (payload?.source !== "refine_mesh_node_async_job") continue;
-        const jobId = payload?.refineJob?.jobId;
-        if (!jobId) continue;
-        const key2 = `${e.nodeId}:${jobId}`;
-        if (terminalKeys.has(key2) || seen.has(key2)) continue;
-        if (archivedTerminalKeys?.has(refineArchivePairKey(e.nodeId, jobId))) continue;
-        seen.add(key2);
-        const executor = payload?.refineJob?.executor;
-        open.push({ nodeId: e.nodeId, jobId, timestamp: e.timestamp, ...executor ? { executor } : {} });
-      }
-      return open;
-    }
-    function refineArchivePairKey(nodeId, jobId) {
-      return `refine:${nodeId}:${jobId}`;
-    }
-    function shouldNotifyRefineCloseOut(decision, notifyHorizonMs) {
-      if (decision.disposition === "close_removed_node") return false;
-      if (decision.disposition !== "close_stale") return false;
-      if (decision.ageMs === void 0) return true;
-      return decision.ageMs < notifyHorizonMs;
-    }
-    var init_mesh_refine_zombie_sweep = __esm2({
-      "src/mesh/mesh-refine-zombie-sweep.ts"() {
-        "use strict";
-      }
-    });
-    function classifyRefineTerminal(result) {
-      const refineCode = typeof result.code === "string" ? result.code : "";
-      const landing = extractRefineMergeLanding(result);
-      const isPostMergeWarning = result.success !== true && landing.merged && landing.pushed;
-      const kind = result.success === true ? "completed" : isPostMergeWarning ? "completed_with_warnings" : refineCode === "blocked_review" || refineCode === "worktree_missing" || refineCode === "worktree_dirty" || refineCode === "rebase_precondition_failed" || refineCode === "rebase_failed" ? "blocked_review" : refineCode === "validation_failed" || refineCode === "validation_dependencies_missing" || refineCode === "missing_dependencies" || refineCode === "dependency_bootstrap_failed" || refineCode === "spawn_resolution_failed" || refineCode === "validation_unavailable" || refineCode === "output_limit_exceeded" ? "validation_failed" : refineCode === "submodule_reachability_failed" ? "submodule_reachability_failed" : refineCode === "merge_failed" || refineCode === "patch_equivalence_failed" || refineCode === "needs_rebase" || refineCode === "needs_rebase_with_conflicts" ? "merge_failed" : refineCode === "cleanup_failed" ? "cleanup_failed" : "merge_failed";
-      const clean = kind === "completed";
-      return { kind, landing, isPostMergeWarning, converged: clean || isPostMergeWarning, clean };
-    }
-    function refineTerminalNextStep(kind) {
-      switch (kind) {
-        case "blocked_review":
-          return "Request user review/approval before attempting to merge again.";
-        case "validation_failed":
-          return "Fix failing tests or configure validation.bootstrapCommands and retry mesh_refine_node.";
-        case "submodule_reachability_failed":
-          return "Push unreachable submodule commits to origin/main, then retry mesh_refine_node.";
-        case "merge_failed":
-          return "Resolve merge conflicts or patch equivalence issues, then retry mesh_refine_node.";
-        case "cleanup_failed":
-          return "Manually remove the worktree and retry or use mesh_remove_node.";
-        case "completed_with_warnings":
-          return "The merge IS on origin \u2014 do NOT re-run mesh_refine_node. Only the post-merge step below needs attention (worktree cleanup / submodule alignment); treat the branch as merged_to_main.";
-        default:
-          return "Inspect refineStages for the failing stage and retry.";
-      }
-    }
-    function buildRefineWorktreeMissingResult(nodeId, workspace, refineStages) {
-      return {
-        success: false,
-        code: "worktree_missing",
-        convergenceStatus: "blocked_review",
-        // Never auto-retried: re-running cannot recreate the worktree, and the node has
-        // most likely already converged.
-        retryable: false,
-        workspaceMissing: true,
-        error: `The worktree directory for node '${nodeId}' no longer exists (${workspace}); nothing was merged by this run. Worktree removal is the final step of a SUCCESSFUL refine, so this node was most likely already merged and cleaned up by an earlier job \u2014 verify with 'git -C <repoRoot> log --oneline' before acting. Do NOT re-run refine to "fix" this.`,
-        nextStep: "Verify whether the branch already merged into the base (it most likely did). If so, treat the node as merged_to_main and remove it from the mesh; only re-clone if the work is genuinely missing.",
-        refineStages,
-        finalBranchConvergenceState: {
-          baseBranch: void 0,
-          merged: false,
-          removed: true,
-          status: "blocked_review"
-        }
-      };
-    }
-    function extractRefineMergeLanding(result) {
-      const fbcs = result.finalBranchConvergenceState && typeof result.finalBranchConvergenceState === "object" ? result.finalBranchConvergenceState : void 0;
-      const merged = result.merged === true || result.mergedLocal === true || fbcs?.merged === true;
-      const pushed = result.pushed === true || fbcs?.pushed === true;
-      return { merged: !!merged, pushed: !!pushed && !!merged };
-    }
-    function buildRefineBlockerContext(result, opts) {
-      if (opts.isTerminalClean) return void 0;
-      const refineTerminalKind = opts.terminalKind;
-      const refineCode = typeof result.code === "string" ? result.code : "";
-      const code = typeof result.code === "string" ? result.code : refineTerminalKind;
-      const stage = refineTerminalKind === "validation_failed" ? "validation" : refineTerminalKind === "submodule_reachability_failed" ? "submodule_reachability" : refineCode === "patch_equivalence_failed" ? "patch_equivalence" : refineCode === "needs_rebase" || refineCode === "needs_rebase_with_conflicts" ? "patch_equivalence" : refineCode === "worktree_dirty" || refineCode === "rebase_precondition_failed" || refineCode === "rebase_failed" ? "patch_equivalence" : refineTerminalKind === "merge_failed" ? "merge" : refineTerminalKind === "cleanup_failed" ? "cleanup" : refineTerminalKind === "completed_with_warnings" ? refineCode === "post_merge_submodule_alignment_failed" ? "submodule_alignment" : "cleanup" : "unknown";
-      const ctx = { stage, reason: code, terminalKind: refineTerminalKind };
-      if (typeof result.error === "string") ctx.error = result.error;
-      if (typeof result.blockedReason === "string") ctx.blockedReason = result.blockedReason;
-      if (typeof result.detailedReason === "string") ctx.detailedReason = result.detailedReason;
-      if (typeof result.detailedReasonDescription === "string") ctx.detailedReasonDescription = result.detailedReasonDescription;
-      if (typeof result.recommendedAction === "string") ctx.recommendedAction = result.recommendedAction;
-      if (result.evidence && typeof result.evidence === "object") ctx.evidence = result.evidence;
-      if (typeof result.rebaseStderr === "string") ctx.rebaseStderr = result.rebaseStderr;
-      if (typeof result.rebaseFailureDetail === "string") ctx.rebaseFailureDetail = result.rebaseFailureDetail;
-      if (typeof result.rebaseConflict === "boolean") ctx.rebaseConflict = result.rebaseConflict;
-      if (stage === "patch_equivalence" && result.patchEquivalence) {
-        const pe = result.patchEquivalence;
-        ctx.details = {
-          expectedPatchId: pe.expectedPatchId,
-          actualPatchId: pe.actualPatchId,
-          status: pe.status,
-          actionableHint: pe.actionableHint,
-          error: pe.error,
-          ...typeof result.detailedReason === "string" ? { detailedReason: result.detailedReason } : {},
-          ...typeof result.recommendedAction === "string" ? { recommendedAction: result.recommendedAction } : {},
-          ...result.evidence && typeof result.evidence === "object" ? { evidence: result.evidence } : {}
-        };
-      }
-      if (stage === "submodule_reachability" && Array.isArray(result.unreachableSubmoduleCommits)) {
-        ctx.details = {
-          unreachableCount: result.unreachableSubmoduleCommits.length,
-          paths: result.unreachableSubmoduleCommits.map((e) => e.path),
-          autoPublishAllowed: result.unreachableSubmoduleCommits[0]?.autoPublishAllowed
-        };
-      }
-      if (stage === "validation" && result.validationSummary) {
-        const vs = result.validationSummary;
-        const diagnostics = opts.extractValidationDiagnostics?.(vs);
-        ctx.details = {
-          failureCode: vs.failureCode,
-          failureKind: vs.failureKind,
-          commandsRun: Array.isArray(vs.commandsRun) ? vs.commandsRun.length : void 0,
-          ...diagnostics ? { failure: diagnostics } : {}
-        };
-      }
-      return ctx;
-    }
-    var init_mesh_refine_landing = __esm2({
-      "src/mesh/mesh-refine-landing.ts"() {
-        "use strict";
-      }
-    });
-    function resolveRefineVitestMaxWorkers(env2 = process.env) {
-      const raw = env2[REFINE_VITEST_MAX_WORKERS_ENV];
-      if (raw === void 0 || raw.trim() === "") return DEFAULT_REFINE_VITEST_MAX_WORKERS;
-      const parsed = Number.parseInt(raw, 10);
-      if (!Number.isFinite(parsed)) return DEFAULT_REFINE_VITEST_MAX_WORKERS;
-      if (parsed === 0) return null;
-      return Math.max(1, parsed);
-    }
-    function refineGateChildEnv(env2 = process.env) {
-      if (env2.VITEST_MAX_WORKERS) return {};
-      const cap = resolveRefineVitestMaxWorkers(env2);
-      if (cap === null) return {};
-      return { VITEST_MAX_WORKERS: String(cap) };
-    }
-    var REFINE_VITEST_MAX_WORKERS_ENV;
-    var DEFAULT_REFINE_VITEST_MAX_WORKERS;
-    var init_mesh_refine_worker_cap = __esm2({
-      "src/mesh/mesh-refine-worker-cap.ts"() {
-        "use strict";
-        REFINE_VITEST_MAX_WORKERS_ENV = "ADHDEV_REFINE_VITEST_MAX_WORKERS";
-        DEFAULT_REFINE_VITEST_MAX_WORKERS = 2;
-      }
-    });
     function readChangedGitlinkPaths(repoRoot, fromRef, toRef) {
       try {
-        const output = (0, import_node_child_process12.execFileSync)(GIT4, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
+        const output = (0, import_node_child_process9.execFileSync)(GIT2, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -83768,7 +83356,7 @@ ${cleanBody}`;
     }
     function readTreeObject(repoRoot, ref, path63) {
       try {
-        const output = (0, import_node_child_process12.execFileSync)(GIT4, ["ls-tree", ref, "--", path63], {
+        const output = (0, import_node_child_process9.execFileSync)(GIT2, ["ls-tree", ref, "--", path63], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: 1024 * 1024
@@ -83783,7 +83371,7 @@ ${cleanBody}`;
       for (const ref of refs) {
         if (!ref) return false;
         try {
-          (0, import_node_child_process12.execFileSync)(GIT4, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], { cwd, stdio: "ignore", windowsHide: true });
+          (0, import_node_child_process9.execFileSync)(GIT2, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], { cwd, stdio: "ignore", windowsHide: true });
         } catch {
           return false;
         }
@@ -83792,13 +83380,13 @@ ${cleanBody}`;
     }
     function probeGitAncestry(cwd, ancestor, descendant) {
       try {
-        if (!fs53.existsSync(cwd)) return "undeterminable";
+        if (!fs50.existsSync(cwd)) return "undeterminable";
       } catch {
         return "undeterminable";
       }
       if (!gitRefsResolvable(cwd, [ancestor, descendant])) return "undeterminable";
       try {
-        (0, import_node_child_process12.execFileSync)(GIT4, ["merge-base", "--is-ancestor", ancestor, descendant], { cwd, stdio: "ignore", windowsHide: true });
+        (0, import_node_child_process9.execFileSync)(GIT2, ["merge-base", "--is-ancestor", ancestor, descendant], { cwd, stdio: "ignore", windowsHide: true });
         return true;
       } catch (e) {
         return e?.status === 1 ? false : "undeterminable";
@@ -83806,8 +83394,8 @@ ${cleanBody}`;
     }
     function probeSubmoduleGitlinkReachability(input) {
       const { path: path63, baseCommit, branchCommit, probeRoot, baseRepoRoot } = input;
-      const submoduleRepo = (0, import_path17.resolve)(probeRoot, path63);
-      const baseSubmoduleRepo = (0, import_path17.resolve)(baseRepoRoot, path63);
+      const submoduleRepo = (0, import_path16.resolve)(probeRoot, path63);
+      const baseSubmoduleRepo = (0, import_path16.resolve)(baseRepoRoot, path63);
       if (baseCommit) ensureSubmoduleCommitLocal(submoduleRepo, baseSubmoduleRepo, baseCommit);
       if (branchCommit) ensureSubmoduleCommitLocal(submoduleRepo, baseSubmoduleRepo, branchCommit);
       let fastForward;
@@ -83845,7 +83433,7 @@ ${cleanBody}`;
     function submoduleCommitPresent(submoduleRepoPath, commit) {
       if (!commit) return false;
       try {
-        (0, import_node_child_process12.execFileSync)(GIT4, ["cat-file", "-e", `${commit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+        (0, import_node_child_process9.execFileSync)(GIT2, ["cat-file", "-e", `${commit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
         return true;
       } catch {
         return false;
@@ -83855,7 +83443,7 @@ ${cleanBody}`;
       if (!commit) return false;
       const present = () => {
         try {
-          (0, import_node_child_process12.execFileSync)(GIT4, ["cat-file", "-e", `${commit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+          (0, import_node_child_process9.execFileSync)(GIT2, ["cat-file", "-e", `${commit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
           return true;
         } catch {
           return false;
@@ -83863,7 +83451,7 @@ ${cleanBody}`;
       };
       if (present()) return true;
       try {
-        if (!fs53.existsSync(submoduleRepoPath) || !fs53.existsSync(baseSubmoduleRepoPath)) return false;
+        if (!fs50.existsSync(submoduleRepoPath) || !fs50.existsSync(baseSubmoduleRepoPath)) return false;
       } catch {
         return false;
       }
@@ -83877,7 +83465,7 @@ ${cleanBody}`;
       ];
       for (const args of strategies) {
         try {
-          (0, import_node_child_process12.execFileSync)(GIT4, ["-c", "protocol.file.allow=always", ...args], {
+          (0, import_node_child_process9.execFileSync)(GIT2, ["-c", "protocol.file.allow=always", ...args], {
             cwd: submoduleRepoPath,
             stdio: ["ignore", "ignore", "pipe"]
           });
@@ -83907,7 +83495,7 @@ ${cleanBody}`;
     }
     function readChangedPathKinds(repoRoot, fromRef, toRef) {
       try {
-        const output = (0, import_node_child_process12.execFileSync)(GIT4, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
+        const output = (0, import_node_child_process9.execFileSync)(GIT2, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -83930,25 +83518,25 @@ ${cleanBody}`;
         return [];
       }
     }
-    async function verifyRemoteBranchContainsCommit(runGit3, submodulePath, commit, branch = "main") {
+    async function verifyRemoteBranchContainsCommit(runGit4, submodulePath, commit, branch = "main") {
       try {
-        await runGit3(submodulePath, ["-c", "protocol.file.allow=always", "fetch", "origin", `refs/heads/${branch}:refs/remotes/origin/${branch}`]);
+        await runGit4(submodulePath, ["-c", "protocol.file.allow=always", "fetch", "origin", `refs/heads/${branch}:refs/remotes/origin/${branch}`]);
       } catch (fetchError) {
         return { state: "undeterminable", error: fetchError };
       }
       const remoteRef = `refs/remotes/origin/${branch}`;
       try {
-        await runGit3(submodulePath, ["rev-parse", "--verify", "--quiet", `${remoteRef}^{commit}`]);
+        await runGit4(submodulePath, ["rev-parse", "--verify", "--quiet", `${remoteRef}^{commit}`]);
       } catch (resolveError) {
         return { state: "undeterminable", error: resolveError };
       }
       try {
-        await runGit3(submodulePath, ["rev-parse", "--verify", "--quiet", `${commit}^{commit}`]);
+        await runGit4(submodulePath, ["rev-parse", "--verify", "--quiet", `${commit}^{commit}`]);
       } catch (missingCandidate) {
         return { state: "absent", error: missingCandidate };
       }
       try {
-        await runGit3(submodulePath, ["merge-base", "--is-ancestor", commit, remoteRef]);
+        await runGit4(submodulePath, ["merge-base", "--is-ancestor", commit, remoteRef]);
         return { state: "contained" };
       } catch (ancestryError) {
         return ancestryError?.code === 1 ? { state: "absent", error: ancestryError } : { state: "undeterminable", error: ancestryError };
@@ -83975,45 +83563,68 @@ ${cleanBody}`;
       parts.push("Do not merge the root branch until every submodule gitlink commit is reachable from submodule origin/main.");
       return parts.join(" ");
     }
-    var fs53;
-    var import_node_child_process12;
-    var import_path17;
-    var GIT4;
+    var fs50;
+    var import_node_child_process9;
+    var import_path16;
+    var GIT2;
     var REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES;
     var init_mesh_refine_gitlink_utils = __esm2({
       "src/mesh/mesh-refine-gitlink-utils.ts"() {
         "use strict";
-        fs53 = __toESM2(require("fs"));
-        import_node_child_process12 = require("child_process");
-        import_path17 = require("path");
+        fs50 = __toESM2(require("fs"));
+        import_node_child_process9 = require("child_process");
+        import_path16 = require("path");
         init_logger();
         init_resolve_executable();
-        GIT4 = process.platform === "win32" ? resolveWin32Executable("git") : "git";
+        GIT2 = process.platform === "win32" ? resolveWin32Executable("git") : "git";
         REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES = 4 * 1024 * 1024;
       }
     });
+    function resolveRefineVitestMaxWorkers(env2 = process.env) {
+      const raw = env2[REFINE_VITEST_MAX_WORKERS_ENV];
+      if (raw === void 0 || raw.trim() === "") return DEFAULT_REFINE_VITEST_MAX_WORKERS;
+      const parsed = Number.parseInt(raw, 10);
+      if (!Number.isFinite(parsed)) return DEFAULT_REFINE_VITEST_MAX_WORKERS;
+      if (parsed === 0) return null;
+      return Math.max(1, parsed);
+    }
+    function refineGateChildEnv(env2 = process.env) {
+      if (env2.VITEST_MAX_WORKERS) return {};
+      const cap = resolveRefineVitestMaxWorkers(env2);
+      if (cap === null) return {};
+      return { VITEST_MAX_WORKERS: String(cap) };
+    }
+    var REFINE_VITEST_MAX_WORKERS_ENV;
+    var DEFAULT_REFINE_VITEST_MAX_WORKERS;
+    var init_mesh_refine_worker_cap = __esm2({
+      "src/mesh/mesh-refine-worker-cap.ts"() {
+        "use strict";
+        REFINE_VITEST_MAX_WORKERS_ENV = "ADHDEV_REFINE_VITEST_MAX_WORKERS";
+        DEFAULT_REFINE_VITEST_MAX_WORKERS = 2;
+      }
+    });
     function classifySubmoduleDivergence(submoduleRepoPath, baseCommit, branchCommit) {
       if (!baseCommit || !branchCommit) return "undeterminable";
       if (baseCommit === branchCommit) return "not_diverged";
       try {
-        if (!fs54.existsSync(submoduleRepoPath)) return "undeterminable";
-        (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" });
+        if (!fs51.existsSync(submoduleRepoPath)) return "undeterminable";
+        (0, import_node_child_process10.execFileSync)(GIT2, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+        (0, import_node_child_process10.execFileSync)(GIT2, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
       } catch {
         return "undeterminable";
       }
       try {
-        (0, import_node_child_process13.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+        (0, import_node_child_process10.execFileSync)(GIT2, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
         return "not_diverged";
       } catch {
       }
       try {
-        (0, import_node_child_process13.execFileSync)(GIT4, ["merge-base", "--is-ancestor", branchCommit, baseCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+        (0, import_node_child_process10.execFileSync)(GIT2, ["merge-base", "--is-ancestor", branchCommit, baseCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
         return "not_diverged";
       } catch {
       }
       try {
-        const mb = (0, import_node_child_process13.execFileSync)(GIT4, ["merge-base", baseCommit, branchCommit], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+        const mb = (0, import_node_child_process10.execFileSync)(GIT2, ["merge-base", baseCommit, branchCommit], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
         return mb ? "diverged" : "not_diverged";
       } catch {
         return "not_diverged";
@@ -84021,13 +83632,13 @@ ${cleanBody}`;
     }
     function resolveSubmoduleRemoteMainRef(submoduleRepoPath) {
       try {
-        const sym = (0, import_node_child_process13.execFileSync)(GIT4, ["symbolic-ref", "-q", "refs/remotes/origin/HEAD"], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+        const sym = (0, import_node_child_process10.execFileSync)(GIT2, ["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_process13.execFileSync)(GIT4, ["rev-parse", "--verify", "-q", `refs/remotes/origin/${branch}`], { cwd: submoduleRepoPath, stdio: ["ignore", "pipe", "pipe"] });
+          (0, import_node_child_process10.execFileSync)(GIT2, ["rev-parse", "--verify", "-q", `refs/remotes/origin/${branch}`], { cwd: submoduleRepoPath, stdio: ["ignore", "pipe", "pipe"] });
           return `refs/remotes/origin/${branch}`;
         } catch {
         }
@@ -84036,24 +83647,24 @@ ${cleanBody}`;
     }
     function findEquivalentPublishedSubmoduleCommit(submoduleRepoPath, baseCommit, branchCommit, remoteRef) {
       try {
-        const mergeTreeOut = (0, import_node_child_process13.execFileSync)(GIT4, ["merge-tree", "--write-tree", baseCommit, branchCommit], {
+        const mergeTreeOut = (0, import_node_child_process10.execFileSync)(GIT2, ["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_process13.execFileSync)(GIT4, ["rev-list", "--max-count=100", remoteRef, "--not", baseCommit], {
+        const candidates = (0, import_node_child_process10.execFileSync)(GIT2, ["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_process13.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, candidate], { cwd: submoduleRepoPath, stdio: "ignore" });
+            (0, import_node_child_process10.execFileSync)(GIT2, ["merge-base", "--is-ancestor", baseCommit, candidate], { cwd: submoduleRepoPath, stdio: "ignore" });
           } catch {
             continue;
           }
-          const tree = (0, import_node_child_process13.execFileSync)(GIT4, ["rev-parse", `${candidate}^{tree}`], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+          const tree = (0, import_node_child_process10.execFileSync)(GIT2, ["rev-parse", `${candidate}^{tree}`], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
           if (tree === mergedTree) return candidate;
         }
       } catch {
@@ -84062,7 +83673,7 @@ ${cleanBody}`;
     }
     function submoduleHasOriginRemote(submoduleRepoPath) {
       try {
-        const url2 = (0, import_node_child_process13.execFileSync)(GIT4, ["remote", "get-url", "origin"], {
+        const url2 = (0, import_node_child_process10.execFileSync)(GIT2, ["remote", "get-url", "origin"], {
           cwd: submoduleRepoPath,
           encoding: "utf8",
           stdio: ["ignore", "pipe", "ignore"]
@@ -84088,9 +83699,9 @@ ${cleanBody}`;
       for (const path63 of changed) {
         const baseCommit = readTreeObject(baseRepoRoot, baseHead, path63);
         const branchCommit = readTreeObject(worktreeRoot, branchHead, path63);
-        const submoduleRepoPath = (0, import_path18.resolve)(worktreeRoot, path63);
+        const submoduleRepoPath = (0, import_path17.resolve)(worktreeRoot, path63);
         if (baseCommit) {
-          ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path18.resolve)(baseRepoRoot, path63), baseCommit);
+          ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path17.resolve)(baseRepoRoot, path63), baseCommit);
         }
         const markUndeterminable = () => {
           const unavailable = [];
@@ -84116,7 +83727,7 @@ ${cleanBody}`;
         const originConfigured = submoduleHasOriginRemote(submoduleRepoPath);
         let remoteFetched = true;
         try {
-          (0, import_node_child_process13.execFileSync)(GIT4, ["-c", "protocol.file.allow=always", "fetch", "-q", "origin"], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
+          (0, import_node_child_process10.execFileSync)(GIT2, ["-c", "protocol.file.allow=always", "fetch", "-q", "origin"], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
         } catch {
           remoteFetched = false;
         }
@@ -84124,7 +83735,7 @@ ${cleanBody}`;
         const publishedEquivalent = remoteMainRef ? findEquivalentPublishedSubmoduleCommit(submoduleRepoPath, baseCommit, branchCommit, remoteMainRef) : void 0;
         if (publishedEquivalent) {
           try {
-            (0, import_node_child_process13.execFileSync)(GIT4, ["checkout", "-q", "--detach", publishedEquivalent], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
+            (0, import_node_child_process10.execFileSync)(GIT2, ["checkout", "-q", "--detach", publishedEquivalent], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
           } catch {
           }
           gitlinks.push({ path: path63, baseCommit, branchCommit, rebasedCommit: publishedEquivalent, action: "converged_to_published" });
@@ -84136,7 +83747,7 @@ ${cleanBody}`;
         const willMintUnpublishedCommit = branchPublished !== true;
         const wouldConflict = (() => {
           try {
-            (0, import_node_child_process13.execFileSync)(GIT4, ["merge-tree", "--write-tree", baseCommit, branchCommit], {
+            (0, import_node_child_process10.execFileSync)(GIT2, ["merge-tree", "--write-tree", baseCommit, branchCommit], {
               cwd: submoduleRepoPath,
               encoding: "utf8",
               stdio: ["ignore", "pipe", "pipe"]
@@ -84169,16 +83780,16 @@ ${cleanBody}`;
         }
         let rebasedCommit;
         try {
-          (0, import_node_child_process13.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
-          (0, import_node_child_process13.execFileSync)(GIT4, ["rebase", baseCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "pipe", "pipe"] });
-          rebasedCommit = (0, import_node_child_process13.execFileSync)(GIT4, ["rev-parse", "HEAD"], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+          (0, import_node_child_process10.execFileSync)(GIT2, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
+          (0, import_node_child_process10.execFileSync)(GIT2, ["rebase", baseCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "pipe", "pipe"] });
+          rebasedCommit = (0, import_node_child_process10.execFileSync)(GIT2, ["rev-parse", "HEAD"], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
         } catch {
           try {
-            (0, import_node_child_process13.execFileSync)(GIT4, ["rebase", "--abort"], { cwd: submoduleRepoPath, stdio: "ignore" });
+            (0, import_node_child_process10.execFileSync)(GIT2, ["rebase", "--abort"], { cwd: submoduleRepoPath, stdio: "ignore" });
           } catch {
           }
           try {
-            (0, import_node_child_process13.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+            (0, import_node_child_process10.execFileSync)(GIT2, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
           } catch {
           }
           gitlinks.push({ path: path63, baseCommit, branchCommit, action: "rebase_conflict" });
@@ -84189,7 +83800,7 @@ ${cleanBody}`;
           if (rebasedCommit === branchCommit) return true;
           if (rebasedCommit === baseCommit) return false;
           try {
-            const replayed = (0, import_node_child_process13.execFileSync)(GIT4, ["rev-list", "--count", `${baseCommit}..${rebasedCommit}`], {
+            const replayed = (0, import_node_child_process10.execFileSync)(GIT2, ["rev-list", "--count", `${baseCommit}..${rebasedCommit}`], {
               cwd: submoduleRepoPath,
               encoding: "utf8"
             }).trim();
@@ -84200,7 +83811,7 @@ ${cleanBody}`;
         })();
         if (!branchWorkSurvived) {
           try {
-            (0, import_node_child_process13.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+            (0, import_node_child_process10.execFileSync)(GIT2, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
           } catch {
           }
           gitlinks.push({ path: path63, baseCommit, branchCommit, rebasedCommit, action: "rebase_dropped_branch_commits" });
@@ -84257,7 +83868,7 @@ ${cleanBody}`;
       const resolveByPath = new Map(resolutions.map((r) => [r.path, r.rebasedCommit]));
       const runRebase = (args) => {
         try {
-          (0, import_node_child_process13.execFileSync)(GIT4, args, {
+          (0, import_node_child_process10.execFileSync)(GIT2, args, {
             cwd: worktreeRoot,
             stdio: ["ignore", "pipe", "pipe"],
             // A rebase editor prompt would hang; keep it non-interactive.
@@ -84270,14 +83881,14 @@ ${cleanBody}`;
       };
       const unmergedPaths = () => {
         try {
-          return (0, import_node_child_process13.execFileSync)(GIT4, ["diff", "--name-only", "--diff-filter=U"], { cwd: worktreeRoot, encoding: "utf8" }).split("\n").map((s2) => s2.trim()).filter(Boolean);
+          return (0, import_node_child_process10.execFileSync)(GIT2, ["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_process13.execFileSync)(GIT4, ["rebase", "--abort"], { cwd: worktreeRoot, stdio: "ignore" });
+          (0, import_node_child_process10.execFileSync)(GIT2, ["rebase", "--abort"], { cwd: worktreeRoot, stdio: "ignore" });
         } catch {
         }
         return { ok: false, reason, conflictPaths };
@@ -84294,7 +83905,7 @@ ${cleanBody}`;
         if (unresolvable.length > 0) {
           const unresolvableGitlink = unresolvable.some((p) => {
             try {
-              const staged = (0, import_node_child_process13.execFileSync)(GIT4, ["ls-files", "--stage", "--", p], { cwd: worktreeRoot, encoding: "utf8" });
+              const staged = (0, import_node_child_process10.execFileSync)(GIT2, ["ls-files", "--stage", "--", p], { cwd: worktreeRoot, encoding: "utf8" });
               return /^160000\s/m.test(staged);
             } catch {
               return false;
@@ -84302,7 +83913,7 @@ ${cleanBody}`;
           });
           const allGitlink = unresolvable.every((p) => {
             try {
-              const staged = (0, import_node_child_process13.execFileSync)(GIT4, ["ls-files", "--stage", "--", p], { cwd: worktreeRoot, encoding: "utf8" });
+              const staged = (0, import_node_child_process10.execFileSync)(GIT2, ["ls-files", "--stage", "--", p], { cwd: worktreeRoot, encoding: "utf8" });
               return /^160000\s/m.test(staged);
             } catch {
               return false;
@@ -84313,11 +83924,11 @@ ${cleanBody}`;
         for (const p of conflicts) {
           const commit = resolveByPath.get(p);
           try {
-            (0, import_node_child_process13.execFileSync)(GIT4, ["checkout", "-q", "--detach", commit], { cwd: (0, import_path18.resolve)(worktreeRoot, p), stdio: "ignore" });
+            (0, import_node_child_process10.execFileSync)(GIT2, ["checkout", "-q", "--detach", commit], { cwd: (0, import_path17.resolve)(worktreeRoot, p), stdio: "ignore" });
           } catch {
           }
           try {
-            (0, import_node_child_process13.execFileSync)(GIT4, ["add", p], { cwd: worktreeRoot, stdio: "ignore" });
+            (0, import_node_child_process10.execFileSync)(GIT2, ["add", p], { cwd: worktreeRoot, stdio: "ignore" });
           } catch {
             return abort("rebase_error", conflicts);
           }
@@ -84326,22 +83937,22 @@ ${cleanBody}`;
       }
       let branchHead;
       try {
-        branchHead = (0, import_node_child_process13.execFileSync)(GIT4, ["rev-parse", "HEAD"], { cwd: worktreeRoot, encoding: "utf8" }).trim();
+        branchHead = (0, import_node_child_process10.execFileSync)(GIT2, ["rev-parse", "HEAD"], { cwd: worktreeRoot, encoding: "utf8" }).trim();
       } catch {
       }
       return { ok: true, branchHead };
     }
-    var fs54;
-    var import_path18;
-    var import_node_child_process13;
+    var fs51;
+    var import_path17;
+    var import_node_child_process10;
     var SUBMODULE_PUBLISH_REQUIRED_RECOMMENDED_ACTION;
     var SUBMODULE_PUBLICATION_UNDETERMINABLE_RECOMMENDED_ACTION;
     var init_mesh_refine_submodule_converge = __esm2({
       "src/mesh/mesh-refine-submodule-converge.ts"() {
         "use strict";
-        fs54 = __toESM2(require("fs"));
-        import_path18 = require("path");
-        import_node_child_process13 = require("child_process");
+        fs51 = __toESM2(require("fs"));
+        import_path17 = require("path");
+        import_node_child_process10 = require("child_process");
         init_mesh_refine_gitlink_utils();
         SUBMODULE_PUBLISH_REQUIRED_RECOMMENDED_ACTION = "Publish the branch-side submodule commit(s) to submodule origin main, then rerun mesh_refine_node. Do NOT retry the rebase: the branch was intentionally left unrewritten because a rebase here would mint a submodule commit the reachability gate must reject.";
         SUBMODULE_PUBLICATION_UNDETERMINABLE_RECOMMENDED_ACTION = "Restore access to the submodule remote (the publication check could not be run), then rerun mesh_refine_node. Do NOT publish and do NOT retry the rebase on this evidence: it is unknown whether the branch-side commit is already on origin, so minting or pushing here can synthesize a redundant twin of a published commit.";
@@ -84364,13 +83975,13 @@ ${tail}`;
     }
     function writeValidationFailureLog(workspace, index, candidate, streams, now = () => /* @__PURE__ */ new Date()) {
       try {
-        const dir = (0, import_path19.join)(workspace, REFINE_VALIDATION_LOG_DIR);
-        fs55.mkdirSync(dir, { recursive: true });
+        const dir = (0, import_path18.join)(workspace, REFINE_VALIDATION_LOG_DIR);
+        fs52.mkdirSync(dir, { recursive: true });
         const stamp = now().toISOString().replace(/[:.]/g, "-");
-        const file2 = (0, import_path19.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(" ");
-        fs55.writeFileSync(
+        fs52.writeFileSync(
           file2,
           `# refine validation failure
 # command: ${shown}
@@ -84434,13 +84045,13 @@ ${asText(streams.stderr)}
       if (excludePaths.length > 0) {
         diffArgs.push("--", ".", ...excludePaths.map((path63) => `:(exclude)${path63}`));
       }
-      const diff = execFileSync16(GIT4, diffArgs, {
+      const diff = execFileSync16(GIT2, diffArgs, {
         cwd,
         encoding: "utf8",
         maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
       });
       if (!diff.trim()) return "";
-      const patchId = execFileSync16(GIT4, ["patch-id", "--stable"], {
+      const patchId = execFileSync16(GIT2, ["patch-id", "--stable"], {
         cwd,
         input: diff,
         encoding: "utf8",
@@ -84452,7 +84063,7 @@ ${asText(streams.stderr)}
       const startedAt = Date.now();
       try {
         const { execFileSync: execFileSync16 } = await import("child_process");
-        const git3 = (args) => execFileSync16(GIT4, args, {
+        const git3 = (args) => execFileSync16(GIT2, args, {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -84560,7 +84171,7 @@ ${e?.stderr || ""}`
         ...autoPublish !== void 0 ? { autoPublishSubmoduleMainCommits: autoPublish } : {}
       };
       try {
-        const git3 = (args) => (0, import_node_child_process14.execFileSync)(GIT4, args, {
+        const git3 = (args) => (0, import_node_child_process11.execFileSync)(GIT2, args, {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
@@ -84700,7 +84311,7 @@ ${e?.stderr || ""}`
       const startedAt = Date.now();
       try {
         const { execFileSync: execFileSync16 } = await import("child_process");
-        const git3 = (gitArgs) => execFileSync16(GIT4, gitArgs, {
+        const git3 = (gitArgs) => execFileSync16(GIT2, gitArgs, {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -84765,7 +84376,7 @@ ${mergeTreeErr?.stderr || ""}`;
       const startedAt = Date.now();
       try {
         const { execFileSync: execFileSync16 } = await import("child_process");
-        const git3 = (args, opts) => execFileSync16(GIT4, args, {
+        const git3 = (args, opts) => execFileSync16(GIT2, args, {
           cwd: opts?.cwd || repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -84840,7 +84451,7 @@ ${mergeTreeErr?.stderr || ""}`;
       };
     }
     function resolveGitDir(repoRoot) {
-      const out = (0, import_node_child_process14.execFileSync)(GIT4, ["rev-parse", "--absolute-git-dir"], {
+      const out = (0, import_node_child_process11.execFileSync)(GIT2, ["rev-parse", "--absolute-git-dir"], {
         cwd: repoRoot,
         encoding: "utf8",
         maxBuffer: 1024 * 1024
@@ -84852,7 +84463,7 @@ ${mergeTreeErr?.stderr || ""}`;
         const baseCommit = readTreeObject(repoRoot, baseHead, path63);
         const branchCommit = readTreeObject(repoRoot, branchHead, path63);
         if (!baseCommit || !branchCommit) return false;
-        return isSubmoduleFastForward((0, import_path19.resolve)(repoRoot, path63), baseCommit, branchCommit);
+        return isSubmoduleFastForward((0, import_path18.resolve)(repoRoot, path63), baseCommit, branchCommit);
       });
     }
     function collectTrivialFastForwardGitlinkResolutions(worktreeRoot, baseRepoRoot, baseHead, branchHead) {
@@ -84861,8 +84472,8 @@ ${mergeTreeErr?.stderr || ""}`;
         const baseCommit = readTreeObject(baseRepoRoot, baseHead, path63);
         const branchCommit = readTreeObject(worktreeRoot, branchHead, path63);
         if (!baseCommit || !branchCommit) continue;
-        const submoduleRepoPath = (0, import_path19.resolve)(worktreeRoot, path63);
-        ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path19.resolve)(baseRepoRoot, path63), baseCommit);
+        const submoduleRepoPath = (0, import_path18.resolve)(worktreeRoot, path63);
+        ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path18.resolve)(baseRepoRoot, path63), baseCommit);
         if (baseCommit === branchCommit) {
           continue;
         }
@@ -84878,7 +84489,7 @@ ${mergeTreeErr?.stderr || ""}`;
       const changedGitlinks = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path63) => {
         const baseCommit = readTreeObject(repoRoot, baseHead, path63);
         const branchCommit = readTreeObject(repoRoot, branchHead, path63);
-        const submoduleRepoPath = (0, import_path19.resolve)(repoRoot, path63);
+        const submoduleRepoPath = (0, import_path18.resolve)(repoRoot, path63);
         const probe = !!baseCommit && !!branchCommit ? probeSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit) : "undeterminable";
         return {
           path: path63,
@@ -84903,7 +84514,7 @@ ${mergeTreeErr?.stderr || ""}`;
       }
       let mergeBase = "";
       try {
-        mergeBase = (0, import_node_child_process14.execFileSync)(GIT4, ["merge-base", baseHead, branchHead], {
+        mergeBase = (0, import_node_child_process11.execFileSync)(GIT2, ["merge-base", baseHead, branchHead], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: 1024 * 1024
@@ -84933,7 +84544,7 @@ ${mergeTreeErr?.stderr || ""}`;
     }
     function buildTreeWithGitlinksEqualized(repoRoot, commitish, paths, placeholderCommit) {
       try {
-        const tree = (0, import_node_child_process14.execFileSync)(GIT4, ["rev-parse", `${commitish}^{tree}`], {
+        const tree = (0, import_node_child_process11.execFileSync)(GIT2, ["rev-parse", `${commitish}^{tree}`], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: 1024 * 1024
@@ -84941,11 +84552,11 @@ ${mergeTreeErr?.stderr || ""}`;
         if (!tree) return void 0;
         const updates = paths.map((path63) => `160000 commit ${placeholderCommit}	${path63}`).join("\n");
         if (!updates) return tree;
-        const tmpIndex = (0, import_path19.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_process14.execFileSync)(GIT4, ["read-tree", tree], { cwd: repoRoot, env: env2, stdio: "ignore" });
-          (0, import_node_child_process14.execFileSync)(GIT4, ["update-index", "--index-info"], {
+          (0, import_node_child_process11.execFileSync)(GIT2, ["read-tree", tree], { cwd: repoRoot, env: env2, stdio: "ignore" });
+          (0, import_node_child_process11.execFileSync)(GIT2, ["update-index", "--index-info"], {
             cwd: repoRoot,
             env: env2,
             input: `${updates}
@@ -84953,11 +84564,11 @@ ${mergeTreeErr?.stderr || ""}`;
             encoding: "utf8",
             stdio: ["pipe", "ignore", "ignore"]
           });
-          const newTree = (0, import_node_child_process14.execFileSync)(GIT4, ["write-tree"], { cwd: repoRoot, env: env2, encoding: "utf8" }).trim();
+          const newTree = (0, import_node_child_process11.execFileSync)(GIT2, ["write-tree"], { cwd: repoRoot, env: env2, encoding: "utf8" }).trim();
           return newTree || void 0;
         } finally {
           try {
-            fs55.rmSync(tmpIndex, { force: true });
+            fs52.rmSync(tmpIndex, { force: true });
           } catch {
           }
         }
@@ -84969,7 +84580,7 @@ ${mergeTreeErr?.stderr || ""}`;
       try {
         const branchGitlinks = gitlinks.filter((entry) => entry.branchCommit);
         const gitlinkPaths = branchGitlinks.map((entry) => entry.path);
-        const mergeBase = (0, import_node_child_process14.execFileSync)(GIT4, ["merge-base", baseHead, branchHead], {
+        const mergeBase = (0, import_node_child_process11.execFileSync)(GIT2, ["merge-base", baseHead, branchHead], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: 1024 * 1024
@@ -84982,22 +84593,22 @@ ${mergeTreeErr?.stderr || ""}`;
           const theirsEqTree = buildTreeWithGitlinksEqualized(repoRoot, branchHead, gitlinkPaths, placeholder);
           if (baseEqTree && oursEqTree && theirsEqTree) {
             try {
-              const baseEqCommit = (0, import_node_child_process14.execFileSync)(GIT4, ["commit-tree", baseEqTree, "-m", "refine-ff-base"], {
+              const baseEqCommit = (0, import_node_child_process11.execFileSync)(GIT2, ["commit-tree", baseEqTree, "-m", "refine-ff-base"], {
                 cwd: repoRoot,
                 encoding: "utf8",
                 maxBuffer: 1024 * 1024
               }).trim();
-              const oursEqCommit = (0, import_node_child_process14.execFileSync)(GIT4, ["commit-tree", oursEqTree, "-p", baseEqCommit, "-m", "refine-ff-ours"], {
+              const oursEqCommit = (0, import_node_child_process11.execFileSync)(GIT2, ["commit-tree", oursEqTree, "-p", baseEqCommit, "-m", "refine-ff-ours"], {
                 cwd: repoRoot,
                 encoding: "utf8",
                 maxBuffer: 1024 * 1024
               }).trim();
-              const theirsEqCommit = (0, import_node_child_process14.execFileSync)(GIT4, ["commit-tree", theirsEqTree, "-p", baseEqCommit, "-m", "refine-ff-theirs"], {
+              const theirsEqCommit = (0, import_node_child_process11.execFileSync)(GIT2, ["commit-tree", theirsEqTree, "-p", baseEqCommit, "-m", "refine-ff-theirs"], {
                 cwd: repoRoot,
                 encoding: "utf8",
                 maxBuffer: 1024 * 1024
               }).trim();
-              const mergeOut = (0, import_node_child_process14.execFileSync)(GIT4, ["merge-tree", "--write-tree", oursEqCommit, theirsEqCommit], {
+              const mergeOut = (0, import_node_child_process11.execFileSync)(GIT2, ["merge-tree", "--write-tree", oursEqCommit, theirsEqCommit], {
                 cwd: repoRoot,
                 encoding: "utf8",
                 maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -85008,7 +84619,7 @@ ${mergeTreeErr?.stderr || ""}`;
             }
           }
         }
-        const contentTree = mergedContentTree || (0, import_node_child_process14.execFileSync)(GIT4, ["rev-parse", `${baseHead}^{tree}`], {
+        const contentTree = mergedContentTree || (0, import_node_child_process11.execFileSync)(GIT2, ["rev-parse", `${baseHead}^{tree}`], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: 1024 * 1024
@@ -85016,11 +84627,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_path19.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_process14.execFileSync)(GIT4, ["read-tree", contentTree], { cwd: repoRoot, env: env2, stdio: "ignore" });
-          (0, import_node_child_process14.execFileSync)(GIT4, ["update-index", "--index-info"], {
+          (0, import_node_child_process11.execFileSync)(GIT2, ["read-tree", contentTree], { cwd: repoRoot, env: env2, stdio: "ignore" });
+          (0, import_node_child_process11.execFileSync)(GIT2, ["update-index", "--index-info"], {
             cwd: repoRoot,
             env: env2,
             input: `${updates}
@@ -85028,11 +84639,11 @@ ${mergeTreeErr?.stderr || ""}`;
             encoding: "utf8",
             stdio: ["pipe", "ignore", "ignore"]
           });
-          const newTree = (0, import_node_child_process14.execFileSync)(GIT4, ["write-tree"], { cwd: repoRoot, env: env2, encoding: "utf8" }).trim();
+          const newTree = (0, import_node_child_process11.execFileSync)(GIT2, ["write-tree"], { cwd: repoRoot, env: env2, encoding: "utf8" }).trim();
           return newTree || void 0;
         } finally {
           try {
-            fs55.rmSync(tmpIndex, { force: true });
+            fs52.rmSync(tmpIndex, { force: true });
           } catch {
           }
         }
@@ -85066,10 +84677,10 @@ ${mergeTreeErr?.stderr || ""}`;
       }
       const commandArgs = ["submodule", "update", "--init", "--recursive", "--", ...updatePaths];
       try {
-        const { execFile: execFile8 } = await import("child_process");
-        const { promisify: promisify11 } = await import("util");
-        const execFileAsync7 = promisify11(execFile8);
-        const result = await execFileAsync7(GIT4, commandArgs, {
+        const { execFile: execFile9 } = await import("child_process");
+        const { promisify: promisify12 } = await import("util");
+        const execFileAsync8 = promisify12(execFile9);
+        const result = await execFileAsync8(GIT2, commandArgs, {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
@@ -85115,11 +84726,11 @@ ${mergeTreeErr?.stderr || ""}`;
       const startedAt = Date.now();
       const entries = [];
       try {
-        const { execFile: execFile8 } = await import("child_process");
-        const { promisify: promisify11 } = await import("util");
-        const execFileAsync7 = promisify11(execFile8);
-        const runGit3 = async (cwd, args) => {
-          const { stdout } = await execFileAsync7(GIT4, args, {
+        const { execFile: execFile9 } = await import("child_process");
+        const { promisify: promisify12 } = await import("util");
+        const execFileAsync8 = promisify12(execFile9);
+        const runGit4 = async (cwd, args) => {
+          const { stdout } = await execFileAsync8(GIT2, args, {
             cwd,
             encoding: "utf8",
             timeout: 3e4,
@@ -85128,10 +84739,10 @@ ${mergeTreeErr?.stderr || ""}`;
           });
           return String(stdout || "");
         };
-        const verifyRemoteMainContainsCommit = (submodulePath, commit, branch = "main") => verifyRemoteBranchContainsCommit(runGit3, submodulePath, commit, branch);
+        const verifyRemoteMainContainsCommit = (submodulePath, commit, branch = "main") => verifyRemoteBranchContainsCommit(runGit4, submodulePath, commit, branch);
         const publishCommitToRemoteMain = async (submodulePath, commit, branch = "main") => {
           const refspec = `${commit}:refs/heads/${branch}`;
-          const { stdout, stderr } = await execFileAsync7(GIT4, ["push", "origin", refspec], {
+          const { stdout, stderr } = await execFileAsync8(GIT2, ["push", "origin", refspec], {
             cwd: submodulePath,
             encoding: "utf8",
             timeout: 3e4,
@@ -85141,25 +84752,25 @@ ${mergeTreeErr?.stderr || ""}`;
           return { stdout: String(stdout || ""), stderr: String(stderr || ""), refspec };
         };
         const importCommitFromWorktreeSubmodule = async (submodulePath, worktreeSubmodulePath, commit) => {
-          if (!fs55.existsSync(worktreeSubmodulePath)) return false;
+          if (!fs52.existsSync(worktreeSubmodulePath)) return false;
           try {
-            await runGit3(worktreeSubmodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
+            await runGit4(worktreeSubmodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
           } catch {
             return false;
           }
-          await runGit3(submodulePath, ["-c", "protocol.file.allow=always", "fetch", worktreeSubmodulePath, commit]);
-          await runGit3(submodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
+          await runGit4(submodulePath, ["-c", "protocol.file.allow=always", "fetch", worktreeSubmodulePath, commit]);
+          await runGit4(submodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
           return true;
         };
         const findEquivalentPublishedCommit = async (submodulePath, commit, remoteRef) => {
           try {
-            const targetTree = (await runGit3(submodulePath, ["rev-parse", `${commit}^{tree}`])).trim();
+            const targetTree = (await runGit4(submodulePath, ["rev-parse", `${commit}^{tree}`])).trim();
             if (!targetTree) return void 0;
-            const candidates = (await runGit3(submodulePath, ["rev-list", "--max-count=100", remoteRef])).split("\n").map((s2) => s2.trim()).filter(Boolean);
+            const candidates = (await runGit4(submodulePath, ["rev-list", "--max-count=100", remoteRef])).split("\n").map((s2) => s2.trim()).filter(Boolean);
             for (const candidate of candidates) {
               let tree = "";
               try {
-                tree = (await runGit3(submodulePath, ["rev-parse", `${candidate}^{tree}`])).trim();
+                tree = (await runGit4(submodulePath, ["rev-parse", `${candidate}^{tree}`])).trim();
               } catch {
                 continue;
               }
@@ -85169,13 +84780,13 @@ ${mergeTreeErr?.stderr || ""}`;
           }
           return void 0;
         };
-        const treeOutput = await runGit3(repoRoot, ["ls-tree", "-r", "-z", mergedTree]);
+        const treeOutput = await runGit4(repoRoot, ["ls-tree", "-r", "-z", mergedTree]);
         const gitlinks = treeOutput.split("\0").filter(Boolean).map((record2) => {
           const match = /^160000\s+commit\s+([0-9a-f]{40})\t(.+)$/.exec(record2);
           return match ? { commit: match[1], path: match[2] } : null;
         }).filter((entry) => !!entry);
         for (const gitlink of gitlinks) {
-          const submodulePath = (0, import_path19.resolve)(repoRoot, gitlink.path);
+          const submodulePath = (0, import_path18.resolve)(repoRoot, gitlink.path);
           const entry = {
             path: gitlink.path,
             commit: gitlink.commit,
@@ -85183,7 +84794,7 @@ ${mergeTreeErr?.stderr || ""}`;
           };
           let submoduleDefaultBranch = "main";
           try {
-            if (!fs55.existsSync(submodulePath)) {
+            if (!fs52.existsSync(submodulePath)) {
               entry.error = `Submodule checkout missing at ${gitlink.path}`;
               entry.publishRequired = true;
               if (options.allowAutoPublishSubmoduleMainCommits === true) {
@@ -85196,13 +84807,13 @@ ${mergeTreeErr?.stderr || ""}`;
             }
             entry.checkedLocal = true;
             try {
-              await runGit3(submodulePath, ["cat-file", "-e", `${gitlink.commit}^{commit}`]);
+              await runGit4(submodulePath, ["cat-file", "-e", `${gitlink.commit}^{commit}`]);
               entry.localReachable = true;
             } catch {
               entry.localReachable = false;
               if (options.allowAutoPublishSubmoduleMainCommits === true && options.worktreeRoot) {
                 try {
-                  const imported = await importCommitFromWorktreeSubmodule(submodulePath, (0, import_path19.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;
@@ -85216,7 +84827,7 @@ ${mergeTreeErr?.stderr || ""}`;
               entry.remote = "origin";
               let remoteUrl = "";
               try {
-                remoteUrl = (await runGit3(submodulePath, ["remote", "get-url", "origin"])).trim();
+                remoteUrl = (await runGit4(submodulePath, ["remote", "get-url", "origin"])).trim();
                 if (!remoteUrl) throw new Error("origin remote has no URL");
                 entry.remoteUrl = remoteUrl;
               } catch {
@@ -85373,9 +84984,9 @@ ${mergeTreeErr?.stderr || ""}`;
       };
     }
     async function runMeshRefineValidationGate(mesh, workspace, opts) {
-      const { execFile: execFile8 } = await import("child_process");
-      const { promisify: promisify11 } = await import("util");
-      const execFileAsync7 = promisify11(execFile8);
+      const { execFile: execFile9 } = await import("child_process");
+      const { promisify: promisify12 } = await import("util");
+      const execFileAsync8 = promisify12(execFile9);
       const selection = resolveMeshRefineValidationPlan(mesh, workspace);
       const summary = {
         status: "skipped",
@@ -85454,13 +85065,13 @@ ${mergeTreeErr?.stderr || ""}`;
         ...extras
       });
       const isPackageManagerValidation = (candidate) => {
-        const command = (0, import_path19.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 (!fs55.existsSync((0, import_path19.join)(cwd, "package.json"))) return false;
-        if (fs55.existsSync((0, import_path19.join)(cwd, "node_modules"))) return false;
-        return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs55.existsSync((0, import_path19.join)(cwd, lock)));
+        if (!fs52.existsSync((0, import_path18.join)(cwd, "package.json"))) return false;
+        if (fs52.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) => fs52.existsSync((0, import_path18.join)(cwd, lock)));
       };
       const needsNodeModules = (candidate, cwd) => isPackageManagerValidation(candidate) && dependenciesLikelyMissing(cwd);
       const isDaemonScopedCommand = (candidate) => {
@@ -85527,12 +85138,12 @@ ${mergeTreeErr?.stderr || ""}`;
         summary.bootstrap = { stage: "legacy" };
         for (const candidate of selection.bootstrapCommands) {
           const startedAt = Date.now();
-          const cwd = candidate.cwd ? (0, import_path19.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);
           try {
-            const result = await execFileAsync7(spawn7.file, spawn7.args, {
+            const result = await execFileAsync8(spawn7.file, spawn7.args, {
               cwd,
               encoding: "utf8",
               timeout,
@@ -85560,7 +85171,7 @@ ${mergeTreeErr?.stderr || ""}`;
       let missingDepsBlocked = false;
       for (const candidate of commandsToRun) {
         const startedAt = Date.now();
-        const cwd = candidate.cwd ? (0, import_path19.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)) {
@@ -85577,7 +85188,7 @@ ${mergeTreeErr?.stderr || ""}`;
         const resolvedCommand = resolveWin32Executable(candidate.command);
         const spawn7 = buildWin32ExecFileSpawn(resolvedCommand, candidate.args);
         try {
-          const result = await execFileAsync7(spawn7.file, spawn7.args, {
+          const result = await execFileAsync8(spawn7.file, spawn7.args, {
             cwd,
             encoding: "utf8",
             timeout,
@@ -85627,9 +85238,9 @@ ${mergeTreeErr?.stderr || ""}`;
       summary.status = "passed";
       return summary;
     }
-    var import_path19;
-    var fs55;
-    var import_node_child_process14;
+    var import_path18;
+    var fs52;
+    var import_node_child_process11;
     var REFINE_VALIDATION_TIMEOUT_MS;
     var REFINE_VALIDATION_OUTPUT_LIMIT_BYTES;
     var REFINE_VALIDATION_SUMMARY_HEAD_CHARS;
@@ -85642,9 +85253,9 @@ ${mergeTreeErr?.stderr || ""}`;
         init_git_status();
         init_refine_config();
         init_worktree_bootstrap_config();
-        import_path19 = require("path");
-        fs55 = __toESM2(require("fs"));
-        import_node_child_process14 = require("child_process");
+        import_path18 = require("path");
+        fs52 = __toESM2(require("fs"));
+        import_node_child_process11 = require("child_process");
         init_resolve_executable();
         init_mesh_refine_worker_cap();
         init_mesh_refine_gitlink_utils();
@@ -85655,7 +85266,597 @@ ${mergeTreeErr?.stderr || ""}`;
         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_VALIDATION_LOG_DIR = (0, import_path19.join)(".adhdev", "logs");
+        REFINE_VALIDATION_LOG_DIR = (0, import_path18.join)(".adhdev", "logs");
+      }
+    });
+    async function runMeshRefineSubmoduleReachabilityPreflight(args) {
+      const startedAt = Date.now();
+      const touched = args.touchedSubmodulePaths ?? readChangedGitlinkPaths(args.worktreeRoot, args.baseRef, args.branchRef);
+      if (touched.length === 0) return void 0;
+      const entries = [];
+      for (const path63 of touched) {
+        const probedRepo = (0, import_path19.resolve)(args.worktreeRoot, path63);
+        const commit = readTreeObject(args.worktreeRoot, args.branchRef, path63);
+        if (!commit) {
+          entries.push({
+            path: path63,
+            verdict: "undeterminable",
+            probedRepo,
+            error: `No gitlink commit recorded at '${path63}' on ${args.branchRef}`
+          });
+          continue;
+        }
+        let remoteMainBranch = "main";
+        try {
+          remoteMainBranch = await resolveSubmoduleDefaultBranch({
+            submoduleRepoPath: probedRepo,
+            superprojectWorkspace: args.worktreeRoot,
+            submodulePath: path63
+          });
+        } catch {
+        }
+        const verdict = await verifyRemoteBranchContainsCommit(runGit2, probedRepo, commit, remoteMainBranch);
+        if (verdict.state === "contained") {
+          entries.push({ path: path63, commit, verdict: "reachable", remoteMainBranch, probedRepo });
+        } else if (verdict.state === "absent") {
+          entries.push({
+            path: path63,
+            commit,
+            verdict: "unreachable",
+            remoteMainBranch,
+            probedRepo,
+            error: `Submodule gitlink commit is not reachable from origin/${remoteMainBranch} (publish required before the root branch can merge).`
+          });
+        } else {
+          entries.push({
+            path: path63,
+            commit,
+            verdict: "undeterminable",
+            remoteMainBranch,
+            probedRepo,
+            error: `Reachability against origin/${remoteMainBranch} could not be determined (the submodule remote was not successfully consulted). This is NOT evidence the commit is unpublished.`
+          });
+        }
+      }
+      const blocked = entries.filter((entry) => entry.verdict !== "reachable");
+      const summary = {
+        status: blocked.length ? "warning" : "passed",
+        checked: entries.length,
+        entries,
+        durationMs: Date.now() - startedAt
+      };
+      if (blocked.length) {
+        const gateEntries = blocked.map((entry) => ({
+          path: entry.path,
+          commit: entry.commit || "",
+          reachable: false,
+          publishRequired: entry.verdict === "unreachable",
+          ...entry.verdict === "undeterminable" ? { remoteMainUndeterminable: true } : {}
+        }));
+        summary.nextStep = buildSubmodulePublishRequiredNextStep(gateEntries);
+      }
+      return summary;
+    }
+    async function resolveRefinePlanBaseRef(repoRoot) {
+      let baseBranch = "main";
+      try {
+        const { stdout } = await execFileAsync5(GIT2, ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" });
+        if (stdout.trim()) baseBranch = stdout.trim();
+      } catch {
+      }
+      try {
+        await execFileAsync5(GIT2, ["fetch", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8" });
+      } catch {
+      }
+      try {
+        const { stdout } = await execFileAsync5(GIT2, ["rev-parse", `origin/${baseBranch}`], { cwd: repoRoot, encoding: "utf8" });
+        if (stdout.trim()) return stdout.trim();
+      } catch {
+      }
+      try {
+        const { stdout } = await execFileAsync5(GIT2, ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf8" });
+        if (stdout.trim()) return stdout.trim();
+      } catch {
+      }
+      return "HEAD";
+    }
+    async function planMeshRefineNodeSubmodulePreflight(args) {
+      const { mesh, node } = args;
+      const workspace = typeof node?.workspace === "string" ? node.workspace : "";
+      if (!workspace) return void 0;
+      const allNodes = Array.isArray(mesh?.nodes) ? mesh.nodes : [];
+      const sourceNode = node.clonedFromNodeId ? allNodes.find((n) => meshNodeIdMatches(n, node.clonedFromNodeId)) : allNodes.find((n) => !n.isLocalWorktree);
+      const repoRoot = sourceNode?.repoRoot || sourceNode?.workspace;
+      if (!repoRoot) return void 0;
+      let branch = typeof node.worktreeBranch === "string" ? node.worktreeBranch : "";
+      try {
+        const { stdout } = await execFileAsync5(GIT2, ["branch", "--show-current"], { cwd: workspace, encoding: "utf8" });
+        if (stdout.trim()) branch = stdout.trim();
+      } catch {
+      }
+      if (!branch) return void 0;
+      let branchRef = branch;
+      try {
+        const { stdout } = await execFileAsync5(GIT2, ["rev-parse", branch], { cwd: workspace, encoding: "utf8" });
+        branchRef = stdout.trim() || branch;
+      } catch {
+      }
+      const baseRef = await resolveRefinePlanBaseRef(repoRoot);
+      return runMeshRefineSubmoduleReachabilityPreflight({
+        worktreeRoot: workspace,
+        baseRef,
+        branchRef,
+        ...args.touchedSubmodulePaths ? { touchedSubmodulePaths: args.touchedSubmodulePaths } : {}
+      });
+    }
+    async function buildMeshRefineBatchDryRunResult(args) {
+      const { mesh, orderedNodes, ordering } = args;
+      const warnings = [];
+      for (const node of orderedNodes) {
+        const area = ordering.changeAreas[node.id];
+        if (!area?.touchesSubmodule || area.error) continue;
+        let preflight;
+        try {
+          preflight = await planMeshRefineNodeSubmodulePreflight({
+            mesh,
+            node,
+            touchedSubmodulePaths: area.touchedSubmodulePaths
+          });
+        } catch {
+        }
+        if (!preflight) continue;
+        area.submoduleReachabilityPreflight = preflight;
+        if (preflight.status === "warning") {
+          warnings.push(`Node ${area.nodeId}: submodule reachability preflight warns \u2014 ${preflight.nextStep || "see changeAreas for details."}`);
+        }
+      }
+      return {
+        success: true,
+        batch: true,
+        dryRun: true,
+        nodeCount: orderedNodes.length,
+        order: ordering.order,
+        orderingRationale: ordering.rationale,
+        changeAreas: ordering.changeAreas,
+        plan: orderedNodes.map((node) => ({
+          nodeId: node.id,
+          workspace: node.workspace,
+          validationPlan: buildMeshRefineValidationPlan(mesh, node.workspace),
+          mergeWillRun: false
+        })),
+        ...warnings.length ? { submodulePreflightWarnings: warnings } : {},
+        note: "Dry-run: no validation, rebase, or merge was executed. Re-run with execute=true to converge nodes in this order."
+      };
+    }
+    var import_node_child_process12;
+    var import_node_util6;
+    var import_path19;
+    var execFileAsync5;
+    var runGit2;
+    var init_mesh_refine_submodule_preflight = __esm2({
+      "src/mesh/mesh-refine-submodule-preflight.ts"() {
+        "use strict";
+        import_node_child_process12 = require("child_process");
+        import_node_util6 = require("util");
+        import_path19 = require("path");
+        init_dist();
+        init_mesh_refine_gitlink_utils();
+        init_mesh_refine_gates();
+        init_worktree_bootstrap_config();
+        execFileAsync5 = (0, import_node_util6.promisify)(import_node_child_process12.execFile);
+        runGit2 = async (cwd, args) => {
+          const { stdout } = await execFileAsync5(GIT2, args, {
+            cwd,
+            encoding: "utf8",
+            timeout: 3e4,
+            maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
+            windowsHide: true
+          });
+          return String(stdout || "");
+        };
+      }
+    });
+    function topLevel(path63) {
+      const slash = path63.indexOf("/");
+      return slash === -1 ? path63 : path63.slice(0, slash);
+    }
+    async function analyzeMeshRefineNodeChangeArea(args) {
+      const { nodeId, workspace, branch, baseRef, branchRef, diffCwd, submodulePaths } = args;
+      const base = {
+        nodeId,
+        workspace,
+        branch,
+        changedTopLevelPaths: [],
+        changedFiles: [],
+        touchedSubmodulePaths: [],
+        touchesSubmodule: false,
+        aheadCount: 0
+      };
+      try {
+        let mergeBase = baseRef;
+        try {
+          const { stdout } = await execFileAsync6(GIT3, ["merge-base", baseRef, branchRef], { cwd: diffCwd, encoding: "utf8" });
+          const resolved = stdout.trim();
+          if (resolved) mergeBase = resolved;
+        } catch {
+        }
+        const { stdout: countStdout } = await execFileAsync6(
+          GIT3,
+          ["rev-list", "--count", `${mergeBase}..${branchRef}`],
+          { cwd: diffCwd, encoding: "utf8" }
+        );
+        base.aheadCount = Number.parseInt(countStdout.trim(), 10) || 0;
+        const { stdout: nameStdout } = await execFileAsync6(
+          GIT3,
+          ["diff", "--name-only", `${mergeBase}..${branchRef}`],
+          { cwd: diffCwd, encoding: "utf8" }
+        );
+        const files = nameStdout.split("\n").map((line) => line.trim()).filter(Boolean).slice(0, MAX_CHANGED_FILES2);
+        base.changedFiles = files;
+        const topSet = /* @__PURE__ */ new Set();
+        const submoduleSet = /* @__PURE__ */ new Set();
+        for (const file2 of files) {
+          const top = topLevel(file2);
+          topSet.add(top);
+          if (submodulePaths.has(file2) || submodulePaths.has(top)) {
+            submoduleSet.add(submodulePaths.has(file2) ? file2 : top);
+          }
+        }
+        base.changedTopLevelPaths = [...topSet].sort();
+        base.touchedSubmodulePaths = [...submoduleSet].sort();
+        base.touchesSubmodule = submoduleSet.size > 0;
+        return base;
+      } catch (e) {
+        base.error = e?.message || String(e);
+        return base;
+      }
+    }
+    function orderMeshRefineBatchNodes(changeAreas) {
+      const areaById = {};
+      for (const area of changeAreas) areaById[area.nodeId] = area;
+      const ranked = [...changeAreas].sort((a, b) => {
+        const aSub = a.touchesSubmodule ? 1 : 0;
+        const bSub = b.touchesSubmodule ? 1 : 0;
+        if (aSub !== bSub) return aSub - bSub;
+        const aBreadth = a.changedTopLevelPaths.length;
+        const bBreadth = b.changedTopLevelPaths.length;
+        if (aBreadth !== bBreadth) return aBreadth - bBreadth;
+        return a.nodeId.localeCompare(b.nodeId);
+      });
+      const rationale = [];
+      const nonSub = ranked.filter((a) => !a.touchesSubmodule).map((a) => a.nodeId);
+      const sub = ranked.filter((a) => a.touchesSubmodule).map((a) => a.nodeId);
+      if (nonSub.length) {
+        rationale.push(`Non-submodule nodes first (no submodule-main advance, conflict-free ordering): ${nonSub.join(", ")}`);
+      }
+      if (sub.length) {
+        rationale.push(`Submodule-touching nodes last, serialized (each merge advances submodule main, forcing rebase of the next): ${sub.join(", ")}`);
+      }
+      for (const area of ranked) {
+        if (area.error) rationale.push(`Node ${area.nodeId}: change-area analysis degraded (${area.error}); placed with neutral priority.`);
+      }
+      return { order: ranked.map((a) => a.nodeId), changeAreas: areaById, rationale };
+    }
+    var import_node_child_process14;
+    var import_node_util7;
+    var execFileAsync6;
+    var GIT3;
+    var MAX_CHANGED_FILES2;
+    var init_mesh_refine_batch = __esm2({
+      "src/mesh/mesh-refine-batch.ts"() {
+        "use strict";
+        import_node_child_process14 = require("child_process");
+        import_node_util7 = require("util");
+        init_resolve_executable();
+        execFileAsync6 = (0, import_node_util7.promisify)(import_node_child_process14.execFile);
+        GIT3 = process.platform === "win32" ? resolveWin32Executable("git") : "git";
+        MAX_CHANGED_FILES2 = 500;
+      }
+    });
+    async function git2(cwd, args) {
+      const { stdout } = await execFileAsync7(GIT4, args, {
+        cwd,
+        encoding: "utf8",
+        timeout: 15e3,
+        windowsHide: true
+      });
+      return String(stdout || "").trim();
+    }
+    async function isAncestor(cwd, ancestor, descendant) {
+      try {
+        await git2(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    async function assessScope(cwd, path63, baseRef, branchRef) {
+      try {
+        if (!(0, import_node_fs7.existsSync)(cwd)) return { path: path63, verdict: "unknown", error: `path does not exist: ${cwd}` };
+        const liveBaseHead = await git2(cwd, ["rev-parse", baseRef]);
+        const branchHead = await git2(cwd, ["rev-parse", branchRef]);
+        if (!liveBaseHead || !branchHead) {
+          return { path: path63, verdict: "unknown", error: "could not resolve base or branch head" };
+        }
+        if (await isAncestor(cwd, liveBaseHead, branchHead)) {
+          return { path: path63, verdict: "clear", liveBaseHead };
+        }
+        let mergeBase;
+        try {
+          mergeBase = await git2(cwd, ["merge-base", liveBaseHead, branchHead]);
+        } catch {
+          return { path: path63, verdict: "unknown", liveBaseHead, error: "no common merge base" };
+        }
+        if (!mergeBase) return { path: path63, verdict: "unknown", liveBaseHead, error: "empty merge base" };
+        return { path: path63, verdict: "diverged", liveBaseHead, mergeBase };
+      } catch (e) {
+        return { path: path63, verdict: "unknown", error: e?.message || String(e) };
+      }
+    }
+    async function resolveSubmodulePaths(repoRoot) {
+      try {
+        const stdout = await git2(repoRoot, ["config", "--file", ".gitmodules", "--get-regexp", "path"]);
+        const paths = /* @__PURE__ */ new Set();
+        for (const line of stdout.split("\n")) {
+          const trimmed = line.trim();
+          const spaceIdx = trimmed.indexOf(" ");
+          if (spaceIdx === -1) continue;
+          const value = trimmed.slice(spaceIdx + 1).trim();
+          if (value) paths.add(value);
+        }
+        return paths;
+      } catch {
+        return /* @__PURE__ */ new Set();
+      }
+    }
+    async function assessRefineBaseDivergence(args) {
+      const started = Date.now();
+      const { repoRoot, workspace, baseBranch, branch } = args;
+      const scopes = [];
+      let touchedSubmodulePaths = [];
+      const rootBaseRef = await (async () => {
+        for (const ref of [`origin/${baseBranch}`, baseBranch, "HEAD"]) {
+          try {
+            await git2(repoRoot, ["rev-parse", "--verify", `${ref}^{commit}`]);
+            return ref;
+          } catch {
+          }
+        }
+        return `origin/${baseBranch}`;
+      })();
+      scopes.push(await assessScope(workspace, ".", rootBaseRef, branch));
+      try {
+        const submodulePaths = await resolveSubmodulePaths(repoRoot);
+        if (submodulePaths.size > 0) {
+          const baseRefSha = await git2(repoRoot, ["rev-parse", rootBaseRef]).catch(() => "");
+          const branchRefSha = await git2(workspace, ["rev-parse", branch]).catch(() => "");
+          if (baseRefSha && branchRefSha) {
+            const area = await analyzeMeshRefineNodeChangeArea({
+              nodeId: "(accept-precheck)",
+              workspace,
+              branch,
+              baseRef: baseRefSha,
+              branchRef: branchRefSha,
+              diffCwd: workspace,
+              submodulePaths
+            });
+            touchedSubmodulePaths = area.touchedSubmodulePaths;
+            for (const subPath of touchedSubmodulePaths) {
+              const subCwd = (0, import_node_path5.resolve)(workspace, subPath);
+              const subBaseRef = await (async () => {
+                for (const ref of ["origin/main", "origin/master", "main", "master"]) {
+                  try {
+                    await git2(subCwd, ["rev-parse", "--verify", `${ref}^{commit}`]);
+                    return ref;
+                  } catch {
+                  }
+                }
+                return "origin/main";
+              })();
+              scopes.push(await assessScope(subCwd, subPath, subBaseRef, "HEAD"));
+            }
+          }
+        }
+      } catch {
+      }
+      const verdict = scopes.some((s2) => s2.verdict === "diverged") ? "diverged" : scopes.some((s2) => s2.verdict === "unknown") ? "unknown" : "clear";
+      return { verdict, scopes, touchedSubmodulePaths, durationMs: Date.now() - started };
+    }
+    var import_node_child_process15;
+    var import_node_util8;
+    var import_node_path5;
+    var import_node_fs7;
+    var execFileAsync7;
+    var GIT4;
+    var init_mesh_refine_base_divergence = __esm2({
+      "src/mesh/mesh-refine-base-divergence.ts"() {
+        "use strict";
+        import_node_child_process15 = require("child_process");
+        import_node_util8 = require("util");
+        import_node_path5 = require("path");
+        import_node_fs7 = require("fs");
+        init_resolve_executable();
+        init_mesh_refine_batch();
+        execFileAsync7 = (0, import_node_util8.promisify)(import_node_child_process15.execFile);
+        GIT4 = process.platform === "win32" ? resolveWin32Executable("git") : "git";
+      }
+    });
+    var mesh_refine_zombie_sweep_exports = {};
+    __export2(mesh_refine_zombie_sweep_exports, {
+      classifyRefineDispatch: () => classifyRefineDispatch,
+      refineArchivePairKey: () => refineArchivePairKey,
+      selectOpenRefineDispatches: () => selectOpenRefineDispatches,
+      shouldNotifyRefineCloseOut: () => shouldNotifyRefineCloseOut
+    });
+    function classifyRefineDispatch(record2, opts) {
+      if (opts.isRunning(record2.nodeId)) return void 0;
+      const dispatchedAtMs = new Date(record2.timestamp).getTime();
+      const ageMs2 = Number.isFinite(dispatchedAtMs) ? opts.nowMs - dispatchedAtMs : void 0;
+      const base = { nodeId: record2.nodeId, jobId: record2.jobId, ...ageMs2 !== void 0 ? { ageMs: ageMs2 } : {} };
+      if (!opts.nodeExists(record2.nodeId)) {
+        return { ...base, disposition: "close_removed_node" };
+      }
+      if (opts.executorLiveness) {
+        let liveness;
+        try {
+          liveness = opts.executorLiveness(record2);
+        } catch {
+          liveness = "unknown";
+        }
+        if (liveness === "alive") {
+          return { ...base, disposition: "defer_executor_alive" };
+        }
+      }
+      if (ageMs2 !== void 0 && ageMs2 >= 0 && ageMs2 < opts.graceMs) {
+        return { ...base, disposition: "defer_grace" };
+      }
+      if (ageMs2 !== void 0 && ageMs2 >= opts.zombieCutoffMs) {
+        return { ...base, disposition: "close_stale" };
+      }
+      return { ...base, disposition: "resume" };
+    }
+    function selectOpenRefineDispatches(entries, archivedTerminalKeys) {
+      const terminalKeys = /* @__PURE__ */ new Set();
+      for (const e of entries) {
+        if (e.kind !== "task_completed" && e.kind !== "task_failed") continue;
+        if (!e.nodeId) continue;
+        const jobId = e.payload?.refineJob?.jobId;
+        if (jobId) terminalKeys.add(`${e.nodeId}:${jobId}`);
+      }
+      const open = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const e of entries) {
+        if (e.kind !== "task_dispatched" || !e.nodeId) continue;
+        const payload = e.payload;
+        if (payload?.source !== "refine_mesh_node_async_job") continue;
+        const jobId = payload?.refineJob?.jobId;
+        if (!jobId) continue;
+        const key2 = `${e.nodeId}:${jobId}`;
+        if (terminalKeys.has(key2) || seen.has(key2)) continue;
+        if (archivedTerminalKeys?.has(refineArchivePairKey(e.nodeId, jobId))) continue;
+        seen.add(key2);
+        const executor = payload?.refineJob?.executor;
+        open.push({ nodeId: e.nodeId, jobId, timestamp: e.timestamp, ...executor ? { executor } : {} });
+      }
+      return open;
+    }
+    function refineArchivePairKey(nodeId, jobId) {
+      return `refine:${nodeId}:${jobId}`;
+    }
+    function shouldNotifyRefineCloseOut(decision, notifyHorizonMs) {
+      if (decision.disposition === "close_removed_node") return false;
+      if (decision.disposition !== "close_stale") return false;
+      if (decision.ageMs === void 0) return true;
+      return decision.ageMs < notifyHorizonMs;
+    }
+    var init_mesh_refine_zombie_sweep = __esm2({
+      "src/mesh/mesh-refine-zombie-sweep.ts"() {
+        "use strict";
+      }
+    });
+    function classifyRefineTerminal(result) {
+      const refineCode = typeof result.code === "string" ? result.code : "";
+      const landing = extractRefineMergeLanding(result);
+      const isPostMergeWarning = result.success !== true && landing.merged && landing.pushed;
+      const kind = result.success === true ? "completed" : isPostMergeWarning ? "completed_with_warnings" : refineCode === "blocked_review" || refineCode === "worktree_missing" || refineCode === "worktree_dirty" || refineCode === "rebase_precondition_failed" || refineCode === "rebase_failed" ? "blocked_review" : refineCode === "validation_failed" || refineCode === "validation_dependencies_missing" || refineCode === "missing_dependencies" || refineCode === "dependency_bootstrap_failed" || refineCode === "spawn_resolution_failed" || refineCode === "validation_unavailable" || refineCode === "output_limit_exceeded" ? "validation_failed" : refineCode === "submodule_reachability_failed" ? "submodule_reachability_failed" : refineCode === "merge_failed" || refineCode === "patch_equivalence_failed" || refineCode === "needs_rebase" || refineCode === "needs_rebase_with_conflicts" ? "merge_failed" : refineCode === "cleanup_failed" ? "cleanup_failed" : "merge_failed";
+      const clean = kind === "completed";
+      return { kind, landing, isPostMergeWarning, converged: clean || isPostMergeWarning, clean };
+    }
+    function refineTerminalNextStep(kind) {
+      switch (kind) {
+        case "blocked_review":
+          return "Request user review/approval before attempting to merge again.";
+        case "validation_failed":
+          return "Fix failing tests or configure validation.bootstrapCommands and retry mesh_refine_node.";
+        case "submodule_reachability_failed":
+          return "Push unreachable submodule commits to origin/main, then retry mesh_refine_node.";
+        case "merge_failed":
+          return "Resolve merge conflicts or patch equivalence issues, then retry mesh_refine_node.";
+        case "cleanup_failed":
+          return "Manually remove the worktree and retry or use mesh_remove_node.";
+        case "completed_with_warnings":
+          return "The merge IS on origin \u2014 do NOT re-run mesh_refine_node. Only the post-merge step below needs attention (worktree cleanup / submodule alignment); treat the branch as merged_to_main.";
+        default:
+          return "Inspect refineStages for the failing stage and retry.";
+      }
+    }
+    function buildRefineWorktreeMissingResult(nodeId, workspace, refineStages) {
+      return {
+        success: false,
+        code: "worktree_missing",
+        convergenceStatus: "blocked_review",
+        // Never auto-retried: re-running cannot recreate the worktree, and the node has
+        // most likely already converged.
+        retryable: false,
+        workspaceMissing: true,
+        error: `The worktree directory for node '${nodeId}' no longer exists (${workspace}); nothing was merged by this run. Worktree removal is the final step of a SUCCESSFUL refine, so this node was most likely already merged and cleaned up by an earlier job \u2014 verify with 'git -C <repoRoot> log --oneline' before acting. Do NOT re-run refine to "fix" this.`,
+        nextStep: "Verify whether the branch already merged into the base (it most likely did). If so, treat the node as merged_to_main and remove it from the mesh; only re-clone if the work is genuinely missing.",
+        refineStages,
+        finalBranchConvergenceState: {
+          baseBranch: void 0,
+          merged: false,
+          removed: true,
+          status: "blocked_review"
+        }
+      };
+    }
+    function extractRefineMergeLanding(result) {
+      const fbcs = result.finalBranchConvergenceState && typeof result.finalBranchConvergenceState === "object" ? result.finalBranchConvergenceState : void 0;
+      const merged = result.merged === true || result.mergedLocal === true || fbcs?.merged === true;
+      const pushed = result.pushed === true || fbcs?.pushed === true;
+      return { merged: !!merged, pushed: !!pushed && !!merged };
+    }
+    function buildRefineBlockerContext(result, opts) {
+      if (opts.isTerminalClean) return void 0;
+      const refineTerminalKind = opts.terminalKind;
+      const refineCode = typeof result.code === "string" ? result.code : "";
+      const code = typeof result.code === "string" ? result.code : refineTerminalKind;
+      const stage = refineTerminalKind === "validation_failed" ? "validation" : refineTerminalKind === "submodule_reachability_failed" ? "submodule_reachability" : refineCode === "patch_equivalence_failed" ? "patch_equivalence" : refineCode === "needs_rebase" || refineCode === "needs_rebase_with_conflicts" ? "patch_equivalence" : refineCode === "worktree_dirty" || refineCode === "rebase_precondition_failed" || refineCode === "rebase_failed" ? "patch_equivalence" : refineTerminalKind === "merge_failed" ? "merge" : refineTerminalKind === "cleanup_failed" ? "cleanup" : refineTerminalKind === "completed_with_warnings" ? refineCode === "post_merge_submodule_alignment_failed" ? "submodule_alignment" : "cleanup" : "unknown";
+      const ctx = { stage, reason: code, terminalKind: refineTerminalKind };
+      if (typeof result.error === "string") ctx.error = result.error;
+      if (typeof result.blockedReason === "string") ctx.blockedReason = result.blockedReason;
+      if (typeof result.detailedReason === "string") ctx.detailedReason = result.detailedReason;
+      if (typeof result.detailedReasonDescription === "string") ctx.detailedReasonDescription = result.detailedReasonDescription;
+      if (typeof result.recommendedAction === "string") ctx.recommendedAction = result.recommendedAction;
+      if (result.evidence && typeof result.evidence === "object") ctx.evidence = result.evidence;
+      if (typeof result.rebaseStderr === "string") ctx.rebaseStderr = result.rebaseStderr;
+      if (typeof result.rebaseFailureDetail === "string") ctx.rebaseFailureDetail = result.rebaseFailureDetail;
+      if (typeof result.rebaseConflict === "boolean") ctx.rebaseConflict = result.rebaseConflict;
+      if (stage === "patch_equivalence" && result.patchEquivalence) {
+        const pe = result.patchEquivalence;
+        ctx.details = {
+          expectedPatchId: pe.expectedPatchId,
+          actualPatchId: pe.actualPatchId,
+          status: pe.status,
+          actionableHint: pe.actionableHint,
+          error: pe.error,
+          ...typeof result.detailedReason === "string" ? { detailedReason: result.detailedReason } : {},
+          ...typeof result.recommendedAction === "string" ? { recommendedAction: result.recommendedAction } : {},
+          ...result.evidence && typeof result.evidence === "object" ? { evidence: result.evidence } : {}
+        };
+      }
+      if (stage === "submodule_reachability" && Array.isArray(result.unreachableSubmoduleCommits)) {
+        ctx.details = {
+          unreachableCount: result.unreachableSubmoduleCommits.length,
+          paths: result.unreachableSubmoduleCommits.map((e) => e.path),
+          autoPublishAllowed: result.unreachableSubmoduleCommits[0]?.autoPublishAllowed
+        };
+      }
+      if (stage === "validation" && result.validationSummary) {
+        const vs = result.validationSummary;
+        const diagnostics = opts.extractValidationDiagnostics?.(vs);
+        ctx.details = {
+          failureCode: vs.failureCode,
+          failureKind: vs.failureKind,
+          commandsRun: Array.isArray(vs.commandsRun) ? vs.commandsRun.length : void 0,
+          ...diagnostics ? { failure: diagnostics } : {}
+        };
+      }
+      return ctx;
+    }
+    var init_mesh_refine_landing = __esm2({
+      "src/mesh/mesh-refine-landing.ts"() {
+        "use strict";
       }
     });
     function findOpenRefineDispatchForNode(args) {
@@ -85946,28 +86147,28 @@ ${excerpt}` : "\n--- git output ---\n(none captured)");
         "use strict";
       }
     });
-    async function hasOriginRemote(execFileAsync7, repoRoot, env2) {
+    async function hasOriginRemote(execFileAsync8, repoRoot, env2) {
       try {
-        const { stdout } = await execFileAsync7("git", ["remote", "get-url", "origin"], { cwd: repoRoot, encoding: "utf8", env: env2 });
+        const { stdout } = await execFileAsync8("git", ["remote", "get-url", "origin"], { cwd: repoRoot, encoding: "utf8", env: env2 });
         return !!stdout.trim();
       } catch {
         return false;
       }
     }
     async function probeRefineBaseCas(params) {
-      const { execFileAsync: execFileAsync7, repoRoot, baseBranch, pinnedBaseHead, branchHead, env: env2 } = params;
-      if (!await hasOriginRemote(execFileAsync7, repoRoot, env2)) {
+      const { execFileAsync: execFileAsync8, repoRoot, baseBranch, pinnedBaseHead, branchHead, env: env2 } = params;
+      if (!await hasOriginRemote(execFileAsync8, repoRoot, env2)) {
         return { state: "no_origin" };
       }
       try {
-        await execFileAsync7("git", ["fetch", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8", env: env2 });
+        await execFileAsync8("git", ["fetch", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8", env: env2 });
       } catch (e) {
         const fetchError = e?.message || String(e);
         return { state: "undeterminable", reason: `git fetch origin ${baseBranch} failed: ${fetchError}`, fetchError };
       }
       let liveBaseHead;
       try {
-        const { stdout } = await execFileAsync7("git", ["rev-parse", `origin/${baseBranch}`], { cwd: repoRoot, encoding: "utf8", env: env2 });
+        const { stdout } = await execFileAsync8("git", ["rev-parse", `origin/${baseBranch}`], { cwd: repoRoot, encoding: "utf8", env: env2 });
         liveBaseHead = stdout.trim();
       } catch (e) {
         return { state: "undeterminable", reason: `git rev-parse origin/${baseBranch} failed: ${e?.message || String(e)}` };
@@ -85978,23 +86179,23 @@ ${excerpt}` : "\n--- git output ---\n(none captured)");
       if (liveBaseHead !== pinnedBaseHead) {
         return { state: "moved", liveBaseHead };
       }
-      const localBaseHead = branchHead ? await resolveLocalBaseHead(execFileAsync7, repoRoot, env2) : void 0;
-      if (localBaseHead && branchHead && localBaseHead !== pinnedBaseHead && await isAncestor2(execFileAsync7, repoRoot, pinnedBaseHead, localBaseHead, env2) && !await isAncestor2(execFileAsync7, repoRoot, localBaseHead, branchHead, env2) && !await isAncestor2(execFileAsync7, repoRoot, branchHead, localBaseHead, env2)) {
+      const localBaseHead = branchHead ? await resolveLocalBaseHead(execFileAsync8, repoRoot, env2) : void 0;
+      if (localBaseHead && branchHead && localBaseHead !== pinnedBaseHead && await isAncestor2(execFileAsync8, repoRoot, pinnedBaseHead, localBaseHead, env2) && !await isAncestor2(execFileAsync8, repoRoot, localBaseHead, branchHead, env2) && !await isAncestor2(execFileAsync8, repoRoot, branchHead, localBaseHead, env2)) {
         return { state: "moved", liveBaseHead, localBaseHead };
       }
       return { state: "unmoved", liveBaseHead };
     }
-    async function resolveLocalBaseHead(execFileAsync7, repoRoot, env2) {
+    async function resolveLocalBaseHead(execFileAsync8, repoRoot, env2) {
       try {
-        const { stdout } = await execFileAsync7("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf8", env: env2 });
+        const { stdout } = await execFileAsync8("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf8", env: env2 });
         return stdout.trim() || void 0;
       } catch {
         return void 0;
       }
     }
-    async function isAncestor2(execFileAsync7, repoRoot, maybeAncestor, descendant, env2) {
+    async function isAncestor2(execFileAsync8, repoRoot, maybeAncestor, descendant, env2) {
       try {
-        await execFileAsync7("git", ["merge-base", "--is-ancestor", maybeAncestor, descendant], { cwd: repoRoot, encoding: "utf8", env: env2 });
+        await execFileAsync8("git", ["merge-base", "--is-ancestor", maybeAncestor, descendant], { cwd: repoRoot, encoding: "utf8", env: env2 });
         return true;
       } catch {
         return false;
@@ -86632,30 +86833,30 @@ ${excerpt}` : "\n--- git output ---\n(none captured)");
       const sourceNode = node.clonedFromNodeId ? mesh?.nodes.find((n) => meshNodeIdMatches(n, node.clonedFromNodeId)) : mesh?.nodes.find((n) => !n.isLocalWorktree);
       const repoRoot = sourceNode?.repoRoot || sourceNode?.workspace;
       if (!repoRoot) return { kind: "terminal", result: { success: false, error: "Source node repoRoot not found", refineStages } };
-      const { execFile: execFile8 } = await import("child_process");
-      const { promisify: promisify11 } = await import("util");
-      const execFileAsync7 = promisify11(execFile8);
+      const { execFile: execFile9 } = await import("child_process");
+      const { promisify: promisify12 } = await import("util");
+      const execFileAsync8 = promisify12(execFile9);
       const resolveStarted = Date.now();
-      const { stdout: branchStdout } = await execFileAsync7("git", ["branch", "--show-current"], { cwd: node.workspace, encoding: "utf8", env: gitChildEnv() });
+      const { stdout: branchStdout } = await execFileAsync8("git", ["branch", "--show-current"], { cwd: node.workspace, encoding: "utf8", env: gitChildEnv() });
       const branch = branchStdout.trim();
       if (!branch) return { kind: "terminal", result: { success: false, error: "Could not determine branch of the worktree node", refineStages } };
-      const { stdout: baseBranchStdout } = await execFileAsync7("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
+      const { stdout: baseBranchStdout } = await execFileAsync8("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
       const baseBranch = baseBranchStdout.trim();
       let fetchWarning;
       try {
-        await execFileAsync7("git", ["fetch", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
+        await execFileAsync8("git", ["fetch", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
       } catch (e) {
         fetchWarning = `git fetch origin ${baseBranch} failed (proceeding with local HEAD): ${e?.message}`;
       }
       let baseHeadRaw;
       try {
-        const { stdout } = await execFileAsync7("git", ["rev-parse", `origin/${baseBranch}`], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
+        const { stdout } = await execFileAsync8("git", ["rev-parse", `origin/${baseBranch}`], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
         baseHeadRaw = stdout.trim();
       } catch {
-        const { stdout: localHead } = await execFileAsync7("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
+        const { stdout: localHead } = await execFileAsync8("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
         baseHeadRaw = localHead.trim();
       }
-      const { stdout: branchHeadStdout } = await execFileAsync7("git", ["rev-parse", branch], { cwd: node.workspace, encoding: "utf8", env: gitChildEnv() });
+      const { stdout: branchHeadStdout } = await execFileAsync8("git", ["rev-parse", branch], { cwd: node.workspace, encoding: "utf8", env: gitChildEnv() });
       const baseHead = baseHeadRaw;
       const branchHead = branchHeadStdout.trim();
       let changeImpact;
@@ -86679,7 +86880,7 @@ ${excerpt}` : "\n--- git output ---\n(none captured)");
           nodeId,
           args,
           refineStages,
-          execFileAsync: execFileAsync7,
+          execFileAsync: execFileAsync8,
           mesh,
           node,
           sourceNode,
@@ -86695,17 +86896,17 @@ ${excerpt}` : "\n--- git output ---\n(none captured)");
         }
       };
     }
-    async function computeBranchBaseDivergence(execFileAsync7, cwd, baseHead, branchHead) {
+    async function computeBranchBaseDivergence(execFileAsync8, cwd, baseHead, branchHead) {
       let mergeBase;
       try {
-        const { stdout } = await execFileAsync7("git", ["merge-base", baseHead, branchHead], { cwd, encoding: "utf8", env: gitChildEnv() });
+        const { stdout } = await execFileAsync8("git", ["merge-base", baseHead, branchHead], { cwd, encoding: "utf8", env: gitChildEnv() });
         mergeBase = stdout.trim() || void 0;
       } catch {
       }
       let ahead = 0;
       let behind = 0;
       try {
-        const { stdout } = await execFileAsync7("git", ["rev-list", "--left-right", "--count", `${baseHead}...${branchHead}`], { cwd, encoding: "utf8", env: gitChildEnv() });
+        const { stdout } = await execFileAsync8("git", ["rev-list", "--left-right", "--count", `${baseHead}...${branchHead}`], { cwd, encoding: "utf8", env: gitChildEnv() });
         const [left, right] = stdout.trim().split(/\s+/).map((n) => Number.parseInt(n, 10));
         behind = Number.isFinite(left) ? left : 0;
         ahead = Number.isFinite(right) ? right : 0;
@@ -86722,11 +86923,11 @@ ${excerpt}` : "\n--- git output ---\n(none captured)");
       };
     }
     async function refineSyncBaseStage(self, ctx) {
-      const { repoRoot, baseHead, node, branch, baseBranch, refineStages, execFileAsync: execFileAsync7 } = ctx;
+      const { repoRoot, baseHead, node, branch, baseBranch, refineStages, execFileAsync: execFileAsync8 } = ctx;
       let branchHead = ctx.branchHead;
       let gitlinkResolutions = [];
       const syncStarted = Date.now();
-      const divergence = await computeBranchBaseDivergence(execFileAsync7, node.workspace, baseHead, branchHead);
+      const divergence = await computeBranchBaseDivergence(execFileAsync8, node.workspace, baseHead, branchHead);
       if (divergence.behind === 0) {
         recordMeshRefineStage(refineStages, "sync_base", "passed", syncStarted, {
           ahead: divergence.ahead,
@@ -86820,12 +87021,12 @@ ${excerpt}` : "\n--- git output ---\n(none captured)");
             throw err;
           }
         } else {
-          (0, import_node_child_process15.execFileSync)("git", ["rebase", baseHead], { cwd: node.workspace, stdio: ["ignore", "pipe", "pipe"] });
+          (0, import_node_child_process16.execFileSync)("git", ["rebase", baseHead], { cwd: node.workspace, stdio: ["ignore", "pipe", "pipe"] });
         }
       } catch (rebaseErr) {
         if (!rebaseErr?.alreadyAborted) {
           try {
-            (0, import_node_child_process15.execFileSync)("git", ["rebase", "--abort"], { cwd: node.workspace, stdio: "ignore" });
+            (0, import_node_child_process16.execFileSync)("git", ["rebase", "--abort"], { cwd: node.workspace, stdio: "ignore" });
           } catch {
           }
         }
@@ -86930,7 +87131,7 @@ ${excerpt}` : "\n--- git output ---\n(none captured)");
           }
         } };
       }
-      const { stdout: rebasedHeadStdout } = await execFileAsync7("git", ["rev-parse", "HEAD"], { cwd: node.workspace, encoding: "utf8", env: gitChildEnv() });
+      const { stdout: rebasedHeadStdout } = await execFileAsync8("git", ["rev-parse", "HEAD"], { cwd: node.workspace, encoding: "utf8", env: gitChildEnv() });
       branchHead = rebasedHeadStdout.trim();
       ctx.branchHead = branchHead;
       let changeImpact = ctx.changeImpact;
@@ -87360,7 +87561,7 @@ ${hintLines.join("\n")}` : "",
       }
     }
     async function refineMergeAndFinalizeStage(self, ctx) {
-      const { meshId, nodeId, args, repoRoot, baseHead, node, branch, baseBranch, sourceNode, validationSummary, patchEquivalence, submoduleReachability, mesh, refineStages, execFileAsync: execFileAsync7 } = ctx;
+      const { meshId, nodeId, args, repoRoot, baseHead, node, branch, baseBranch, sourceNode, validationSummary, patchEquivalence, submoduleReachability, mesh, refineStages, execFileAsync: execFileAsync8 } = ctx;
       const leaseKey = `${repoRoot}::${baseBranch}`;
       const leaseHolder = buildRefineJobKey(self, meshId, nodeId);
       const alreadyHeld = self.refineBaseLeases.get(leaseKey) === leaseHolder;
@@ -87399,10 +87600,10 @@ ${hintLines.join("\n")}` : "",
       }
     }
     async function runRefineMergeAndFinalizeLocked(self, ctx) {
-      const { meshId, nodeId, args, repoRoot, baseHead, node, branch, baseBranch, sourceNode, validationSummary, patchEquivalence, submoduleReachability, mesh, refineStages, execFileAsync: execFileAsync7 } = ctx;
+      const { meshId, nodeId, args, repoRoot, baseHead, node, branch, baseBranch, sourceNode, validationSummary, patchEquivalence, submoduleReachability, mesh, refineStages, execFileAsync: execFileAsync8 } = ctx;
       const casStarted = Date.now();
       const cas = await probeRefineBaseCas({
-        execFileAsync: execFileAsync7,
+        execFileAsync: execFileAsync8,
         repoRoot,
         baseBranch,
         pinnedBaseHead: baseHead,
@@ -87426,7 +87627,7 @@ ${hintLines.join("\n")}` : "",
       let mergeResult;
       const mergeStarted = Date.now();
       try {
-        const result = await execFileAsync7("git", ["merge", "--no-ff", branch, "-m", `Auto-merge branch '${branch}' via Refinery`], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
+        const result = await execFileAsync8("git", ["merge", "--no-ff", branch, "-m", `Auto-merge branch '${branch}' via Refinery`], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
         mergeResult = {
           stdout: truncateValidationOutput(result.stdout),
           stderr: truncateValidationOutput(result.stderr),
@@ -87438,7 +87639,7 @@ ${hintLines.join("\n")}` : "",
 ${e?.stderr || ""}`;
         const conflictPaths = [...mergeOutput.matchAll(/Merge conflict in (.+)/g)].map((m) => m[1].trim()).filter(Boolean);
         try {
-          await execFileAsync7("git", ["merge", "--abort"], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
+          await execFileAsync8("git", ["merge", "--abort"], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
         } catch {
         }
         recordMeshRefineStage(refineStages, "merge", "failed", mergeStarted, {
@@ -87521,7 +87722,7 @@ ${e?.stderr || ""}`;
       if (!requireApprovalForPush) {
         const pushStarted = Date.now();
         try {
-          await execFileAsync7("git", ["push", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
+          await execFileAsync8("git", ["push", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
           pushResult = { pushed: true, remote: "origin", branch: baseBranch, durationMs: Date.now() - pushStarted };
           recordMeshRefineStage(refineStages, "push", "passed", pushStarted, pushResult);
         } catch (e) {
@@ -87765,9 +87966,9 @@ ${e?.stderr || ""}`;
       if (targetNodes.length === 0) {
         return { success: true, batch: true, dryRun: args?.dryRun !== false, nodeCount: 0, order: [], results: [], note: "No convergeable local worktree nodes found." };
       }
-      const { execFile: execFile8 } = await import("child_process");
-      const { promisify: promisify11 } = await import("util");
-      const execFileAsync7 = promisify11(execFile8);
+      const { execFile: execFile9 } = await import("child_process");
+      const { promisify: promisify12 } = await import("util");
+      const execFileAsync8 = promisify12(execFile9);
       const resolveRepoRootFor = (node) => {
         const sourceNode = node.clonedFromNodeId ? allNodes.find((n) => meshNodeIdMatches(n, node.clonedFromNodeId)) : allNodes.find((n) => !n.isLocalWorktree);
         return sourceNode?.repoRoot || sourceNode?.workspace;
@@ -87779,21 +87980,21 @@ ${e?.stderr || ""}`;
         if (cached5) return cached5;
         let baseBranch = "main";
         try {
-          const { stdout } = await execFileAsync7("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
+          const { stdout } = await execFileAsync8("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
           if (stdout.trim()) baseBranch = stdout.trim();
         } catch {
         }
         let baseRef = "HEAD";
         try {
-          await execFileAsync7("git", ["fetch", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
+          await execFileAsync8("git", ["fetch", "origin", baseBranch], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
         } catch {
         }
         try {
-          const { stdout } = await execFileAsync7("git", ["rev-parse", `origin/${baseBranch}`], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
+          const { stdout } = await execFileAsync8("git", ["rev-parse", `origin/${baseBranch}`], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
           baseRef = stdout.trim();
         } catch {
           try {
-            const { stdout } = await execFileAsync7("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
+            const { stdout } = await execFileAsync8("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
             baseRef = stdout.trim();
           } catch {
           }
@@ -87806,7 +88007,7 @@ ${e?.stderr || ""}`;
         const repoRoot = resolveRepoRootFor(node);
         let branch = typeof node.worktreeBranch === "string" ? node.worktreeBranch : "";
         try {
-          const { stdout } = await execFileAsync7("git", ["branch", "--show-current"], { cwd: node.workspace, encoding: "utf8", env: gitChildEnv() });
+          const { stdout } = await execFileAsync8("git", ["branch", "--show-current"], { cwd: node.workspace, encoding: "utf8", env: gitChildEnv() });
           if (stdout.trim()) branch = stdout.trim();
         } catch {
         }
@@ -87827,7 +88028,7 @@ ${e?.stderr || ""}`;
         if (!submodulePathsByRepoRoot.has(repoRoot)) {
           let subPaths = /* @__PURE__ */ new Set();
           try {
-            const { stdout } = await execFileAsync7("git", ["config", "--file", ".gitmodules", "--get-regexp", "path"], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
+            const { stdout } = await execFileAsync8("git", ["config", "--file", ".gitmodules", "--get-regexp", "path"], { cwd: repoRoot, encoding: "utf8", env: gitChildEnv() });
             for (const line of stdout.split("\n")) {
               const trimmed = line.trim();
               const spaceIdx = trimmed.indexOf(" ");
@@ -87843,7 +88044,7 @@ ${e?.stderr || ""}`;
         const baseRef = await resolveBaseRef(repoRoot);
         let branchRef = branch;
         try {
-          const { stdout } = await execFileAsync7("git", ["rev-parse", branch], { cwd: node.workspace, encoding: "utf8", env: gitChildEnv() });
+          const { stdout } = await execFileAsync8("git", ["rev-parse", branch], { cwd: node.workspace, encoding: "utf8", env: gitChildEnv() });
           branchRef = stdout.trim() || branch;
         } catch {
         }
@@ -87861,22 +88062,7 @@ ${e?.stderr || ""}`;
       const orderedNodes = ordering.order.map((nodeId) => targetNodes.find((n) => meshNodeIdMatches(n, nodeId))).filter((n) => !!n);
       const dryRun = args?.dryRun !== false && args?.execute !== true;
       if (dryRun) {
-        return {
-          success: true,
-          batch: true,
-          dryRun: true,
-          nodeCount: orderedNodes.length,
-          order: ordering.order,
-          orderingRationale: ordering.rationale,
-          changeAreas: ordering.changeAreas,
-          plan: orderedNodes.map((node) => ({
-            nodeId: node.id,
-            workspace: node.workspace,
-            validationPlan: buildMeshRefineValidationPlan(mesh, node.workspace),
-            mergeWillRun: false
-          })),
-          note: "Dry-run: no validation, rebase, or merge was executed. Re-run with execute=true to converge nodes in this order."
-        };
+        return buildMeshRefineBatchDryRunResult({ mesh, orderedNodes, ordering });
       }
       return runMeshRefineBatchConvergence(self, meshId, orderedNodes, ordering, args);
     }
@@ -87951,7 +88137,9 @@ ${e?.stderr || ""}`;
         allConverged,
         results,
         ...allConverged ? {} : {
-          nextStep: "Resolve blocked_review / not_mergeable nodes manually (see per-node code/stage/error), then re-run mesh_refine_batch for the remaining nodes."
+          // Name the failed nodes inline — the aggregate nextStep used to hide
+          // WHICH nodes blocked, forcing a manual git-log cross-check.
+          nextStep: `Resolve blocked_review / not_mergeable nodes manually \u2014 failed: ${results.filter((r) => r.convergence === "blocked_review" || r.convergence === "not_mergeable").map((r) => `${r.nodeId}${r.code ? ` [${r.code}]` : ""}`).join(", ")} (see per-node code/stage/error), then re-run mesh_refine_batch for the remaining nodes.`
         }
       };
     }
@@ -88263,7 +88451,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_process15.execFileSync)("git", ["branch", "--show-current"], { cwd: workspace, encoding: "utf8" }).trim();
+            return (0, import_node_child_process16.execFileSync)("git", ["branch", "--show-current"], { cwd: workspace, encoding: "utf8" }).trim();
           } catch {
             return "";
           }
@@ -88271,7 +88459,7 @@ ${e?.stderr || ""}`;
         if (!branch) return;
         const baseBranch = (() => {
           try {
-            return (0, import_node_child_process15.execFileSync)("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" }).trim() || "main";
+            return (0, import_node_child_process16.execFileSync)("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" }).trim() || "main";
           } catch {
             return "main";
           }
@@ -88339,13 +88527,13 @@ ${e?.stderr || ""}`;
       });
       return handle;
     }
-    var import_node_child_process15;
+    var import_node_child_process16;
     var import_node_fs9;
     var RETRYABLE_BASE_MOVEMENT_CODES;
     var init_router_refine = __esm2({
       "src/commands/router-refine.ts"() {
         "use strict";
-        import_node_child_process15 = require("child_process");
+        import_node_child_process16 = require("child_process");
         import_node_fs9 = require("fs");
         init_logger();
         init_debug_trace();
@@ -88354,6 +88542,7 @@ ${e?.stderr || ""}`;
         init_mesh_reconcile_identity();
         init_mesh_fast_forward();
         init_mesh_refine_batch();
+        init_mesh_refine_submodule_preflight();
         init_mesh_refine_base_divergence();
         init_mesh_refine_inflight();
         init_mesh_refine_inflight();
@@ -125027,8 +125216,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             let submodulesInitialized2 = false;
             if (initSubmodules) {
               try {
-                const { runGit: runGit3 } = await Promise.resolve().then(() => (init_git_executor(), git_executor_exports));
-                await runGit3(
+                const { runGit: runGit4 } = await Promise.resolve().then(() => (init_git_executor(), git_executor_exports));
+                await runGit4(
                   { workspace: result.worktreePath, repoRoot: result.worktreePath, isGitRepo: true },
                   ["submodule", "update", "--init", "--recursive"],
                   { timeoutMs: 12e4 }
@@ -125591,6 +125780,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     init_dist();
     init_mesh_fast_forward();
     init_cli_detector();
+    init_mesh_refine_submodule_preflight();
     var fastForwardHandlers = {
       mesh_init: async (ctx, args) => {
         const workspace = typeof args?.workspace === "string" && args.workspace.trim() ? args.workspace.trim() : process.cwd();
@@ -125613,6 +125803,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         const mesh = meshRecord?.mesh;
         const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
         if (!node?.workspace) return { success: false, error: `Node '${nodeId}' workspace not found` };
+        const submoduleReachabilityPreflight = await planMeshRefineNodeSubmodulePreflight({ mesh, node }).catch(() => void 0);
         return {
           success: true,
           dryRun: true,
@@ -125620,7 +125811,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           workspace: node.workspace,
           validationPlan: buildMeshRefineValidationPlan(mesh, node.workspace),
           mergeWillRun: false,
-          cleanupWillRun: false
+          cleanupWillRun: false,
+          ...submoduleReachabilityPreflight ? { submoduleReachabilityPreflight } : {}
         };
       },
       fast_forward_mesh_node: async (ctx, args) => {
@@ -125717,6 +125909,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           const mesh = meshRecord?.mesh;
           const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
           if (!node?.workspace) return { success: false, error: `Node '${nodeId}' workspace not found` };
+          const submoduleReachabilityPreflight = await planMeshRefineNodeSubmodulePreflight({ mesh, node }).catch(() => void 0);
           return {
             success: true,
             dryRun: true,
@@ -125725,6 +125918,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             validationPlan: buildMeshRefineValidationPlan(mesh, node.workspace),
             mergeWillRun: false,
             cleanupWillRun: false,
+            ...submoduleReachabilityPreflight ? { submoduleReachabilityPreflight } : {},
             hint: "Dry-run only \u2014 no merge/push/cleanup performed. Re-invoke with execute:true to converge this node."
           };
         }
@@ -126324,8 +126518,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         }
       }
     };
-    var import_path16 = require("path");
-    var fs50 = __toESM2(require("fs"));
+    var import_path20 = require("path");
+    var fs53 = __toESM2(require("fs"));
     init_logger();
     init_mesh_host_ownership();
     init_coordinator_registry();
@@ -126365,9 +126559,9 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       }
     }
     function isWorkspaceLocalPath(configPath, workspace) {
-      const resolvedConfig = (0, import_path16.resolve)(configPath);
-      const resolvedWorkspace = (0, import_path16.resolve)(workspace);
-      return resolvedConfig === resolvedWorkspace || resolvedConfig.startsWith(resolvedWorkspace + import_path16.sep);
+      const resolvedConfig = (0, import_path20.resolve)(configPath);
+      const resolvedWorkspace = (0, import_path20.resolve)(workspace);
+      return resolvedConfig === resolvedWorkspace || resolvedConfig.startsWith(resolvedWorkspace + import_path20.sep);
     }
     var meshCoordinatorLaunchHandlers = {
       launch_mesh_coordinator: async (ctx, args) => {
@@ -126629,16 +126823,16 @@ ${ptyResult.output.slice(-2e3)}`);
               };
             }
             if (cliType === "codex-cli") {
-              const repoMcpConfigPath = (0, import_path16.join)(workspace, ".mcp.json");
-              if (fs50.existsSync(repoMcpConfigPath)) {
+              const repoMcpConfigPath = (0, import_path20.join)(workspace, ".mcp.json");
+              if (fs53.existsSync(repoMcpConfigPath)) {
                 try {
                   const repoMcpConfig = parseMeshCoordinatorMcpConfig(
-                    fs50.readFileSync(repoMcpConfigPath, "utf-8"),
+                    fs53.readFileSync(repoMcpConfigPath, "utf-8"),
                     "claude_mcp_json"
                   );
                   const existingServers2 = repoMcpConfig.mcpServers;
                   if (existingServers2 && typeof existingServers2 === "object" && !Array.isArray(existingServers2) && existingServers2[coordinatorSetup.serverName]) {
-                    fs50.writeFileSync(repoMcpConfigPath, serializeMeshCoordinatorMcpConfig({
+                    fs53.writeFileSync(repoMcpConfigPath, serializeMeshCoordinatorMcpConfig({
                       ...repoMcpConfig,
                       mcpServers: {
                         ...existingServers2,
@@ -127009,7 +127203,7 @@ ${ptyResult.output.slice(-2e3)}`);
         }
       }
     };
-    var fs51 = __toESM2(require("fs"));
+    var fs54 = __toESM2(require("fs"));
     var import_os4 = require("os");
     init_config();
     init_git_status();
@@ -127018,7 +127212,7 @@ ${ptyResult.output.slice(-2e3)}`);
     init_mesh_turn_presentation();
     init_mesh_routing();
     init_mesh_host_ownership();
-    var import_node_child_process9 = require("child_process");
+    var import_node_child_process13 = require("child_process");
     var import_node_fs6 = require("fs");
     init_git_locale();
     var import_node_path4 = require("path");
@@ -127043,9 +127237,9 @@ ${ptyResult.output.slice(-2e3)}`);
       if (PREVIEW_PIPELINE_SCRIPTS.some((rel) => (0, import_node_fs6.existsSync)((0, import_node_path4.resolve)(repoRoot, rel)))) return true;
       return hasDeployPreviewNpmScript(repoRoot);
     }
-    function runGit2(repoRoot, args) {
+    function runGit3(repoRoot, args) {
       try {
-        return (0, import_node_child_process9.execFileSync)("git", args, {
+        return (0, import_node_child_process13.execFileSync)("git", args, {
           cwd: repoRoot,
           encoding: "utf8",
           stdio: ["ignore", "pipe", "ignore"],
@@ -127084,11 +127278,11 @@ ${ptyResult.output.slice(-2e3)}`);
       return result;
     }
     function readCurrentMainCommit(repoRoot) {
-      const originMain = runGit2(repoRoot, ["rev-parse", "--verify", "origin/main^{commit}"]);
+      const originMain = runGit3(repoRoot, ["rev-parse", "--verify", "origin/main^{commit}"]);
       if (originMain) {
         return { currentMainCommit: originMain, currentMainCommitSource: "origin/main" };
       }
-      const head = runGit2(repoRoot, ["rev-parse", "--verify", "HEAD"]);
+      const head = runGit3(repoRoot, ["rev-parse", "--verify", "HEAD"]);
       if (head) {
         return { currentMainCommit: head, currentMainCommitSource: "HEAD" };
       }
@@ -127392,7 +127586,7 @@ ${ptyResult.output.slice(-2e3)}`);
               }
             }
             if (workspace) {
-              if (!fs51.existsSync(workspace)) {
+              if (!fs54.existsSync(workspace)) {
                 const inlineTransitGit = buildInlineMeshTransitGitStatus(node);
                 let remoteProbeApplied = false;
                 if (inlineTransitGit) {
@@ -127533,7 +127727,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const pendingRetentionCounters2 = { ...getPendingRetentionCounters() };
           const turnPresentationCounters = getTurnPresentationMetrics();
           const previewFreshness = (() => {
-            const localRepoRoot = nodeStatuses.map((node) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace)).find((candidate) => !!candidate && fs51.existsSync(candidate));
+            const localRepoRoot = nodeStatuses.map((node) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace)).find((candidate) => !!candidate && fs54.existsSync(candidate));
             return localRepoRoot ? buildPreviewFreshness(localRepoRoot) : void 0;
           })();
           const asyncRefineJobs = buildMeshAsyncRefineJobs({
@@ -127731,7 +127925,7 @@ ${ptyResult.output.slice(-2e3)}`);
     );
     init_dist();
     init_logger();
-    var fs52 = __toESM2(require("fs"));
+    var fs55 = __toESM2(require("fs"));
     var path56 = __toESM2(require("path"));
     init_config_dir();
     var MAX_FILE_SIZE = 5 * 1024 * 1024;
@@ -127780,7 +127974,7 @@ ${ptyResult.output.slice(-2e3)}`);
       currentFile = path56.join(dir, `commands-${today}.jsonl`);
       if (dirChanged) {
         try {
-          fs52.mkdirSync(dir, { recursive: true });
+          fs55.mkdirSync(dir, { recursive: true });
         } catch {
         }
         cleanOldFiles();
@@ -127788,7 +127982,7 @@ ${ptyResult.output.slice(-2e3)}`);
     }
     function cleanOldFiles() {
       try {
-        const files = fs52.readdirSync(currentDir).filter((f) => f.startsWith("commands-") && f.endsWith(".jsonl"));
+        const files = fs55.readdirSync(currentDir).filter((f) => f.startsWith("commands-") && f.endsWith(".jsonl"));
         const cutoff = /* @__PURE__ */ new Date();
         cutoff.setDate(cutoff.getDate() - MAX_DAYS);
         const cutoffStr = cutoff.toISOString().slice(0, 10);
@@ -127796,7 +127990,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const dateMatch = file2.match(/commands-(\d{4}-\d{2}-\d{2})/);
           if (dateMatch && dateMatch[1] < cutoffStr) {
             try {
-              fs52.unlinkSync(path56.join(currentDir, file2));
+              fs55.unlinkSync(path56.join(currentDir, file2));
             } catch {
             }
           }
@@ -127806,14 +128000,14 @@ ${ptyResult.output.slice(-2e3)}`);
     }
     function checkSize() {
       try {
-        const stat2 = fs52.statSync(currentFile);
+        const stat2 = fs55.statSync(currentFile);
         if (stat2.size > MAX_FILE_SIZE) {
           const backup = currentFile.replace(".jsonl", ".1.jsonl");
           try {
-            fs52.unlinkSync(backup);
+            fs55.unlinkSync(backup);
           } catch {
           }
-          fs52.renameSync(currentFile, backup);
+          fs55.renameSync(currentFile, backup);
         }
       } catch {
       }
@@ -127846,15 +128040,15 @@ ${ptyResult.output.slice(-2e3)}`);
           ...entry.error ? { err: entry.error } : {},
           ...entry.durationMs !== void 0 ? { ms: entry.durationMs } : {}
         });
-        fs52.appendFileSync(currentFile, line + "\n");
+        fs55.appendFileSync(currentFile, line + "\n");
       } catch {
       }
     }
     function getRecentCommands(count = 50) {
       try {
         refreshCurrentFile();
-        if (!fs52.existsSync(currentFile)) return [];
-        const content = fs52.readFileSync(currentFile, "utf-8");
+        if (!fs55.existsSync(currentFile)) return [];
+        const content = fs55.readFileSync(currentFile, "utf-8");
         const lines = content.trim().split("\n").filter(Boolean);
         return lines.slice(-count).map((line) => {
           try {
@@ -127886,7 +128080,7 @@ ${ptyResult.output.slice(-2e3)}`);
     init_router_refine();
     var fs56 = __toESM2(require("fs"));
     var import_node_os22 = require("os");
-    var import_path20 = require("path");
+    var import_path21 = require("path");
     init_logger();
     init_git_locale();
     init_dist();
@@ -127898,7 +128092,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_path20.join)((0, import_path20.dirname)(repoRoot), LEGACY_WORKTREE_DIR_NAME, safeMeshName, safeBranch);
+      const legacyPath = (0, import_path21.join)((0, import_path21.dirname)(repoRoot), LEGACY_WORKTREE_DIR_NAME, safeMeshName, safeBranch);
       const candidates = [
         resolveWorktreePath2(repoRoot, meshName, branch, worktreeBaseDir),
         legacyPath
@@ -127925,8 +128119,8 @@ ${ptyResult.output.slice(-2e3)}`);
     function looksLikeCrossTrackWorktreePath(actualPath, normalizePath2) {
       const home = normalizePath2((0, import_node_os22.homedir)());
       return TRACK_CONFIG_DIR_NAMES.some((trackDirName) => {
-        const trackWorktreesDir = (0, import_path20.join)(home, trackDirName, "worktrees");
-        return actualPath === normalizePath2(trackWorktreesDir) || actualPath.startsWith(normalizePath2(trackWorktreesDir) + import_path20.sep);
+        const trackWorktreesDir = (0, import_path21.join)(home, trackDirName, "worktrees");
+        return actualPath === normalizePath2(trackWorktreesDir) || actualPath.startsWith(normalizePath2(trackWorktreesDir) + import_path21.sep);
       });
     }
     function unexpectedPathRecoveryHint(actualPath, normalizePath2, suffix) {
@@ -127953,11 +128147,11 @@ ${ptyResult.output.slice(-2e3)}`);
     }
     async function hasUnpushedWorktreeCommits(workspace) {
       try {
-        const { execFile: execFile8 } = await import("child_process");
-        const { promisify: promisify11 } = await import("util");
-        const execFileAsync7 = promisify11(execFile8);
+        const { execFile: execFile9 } = await import("child_process");
+        const { promisify: promisify12 } = await import("util");
+        const execFileAsync8 = promisify12(execFile9);
         const git3 = async (gitArgs) => {
-          const { stdout } = await execFileAsync7("git", gitArgs, {
+          const { stdout } = await execFileAsync8("git", gitArgs, {
             cwd: workspace,
             encoding: "utf8",
             timeout: 3e4,
@@ -128036,7 +128230,7 @@ ${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_path20.resolve)(value);
+        const resolved = (0, import_path21.resolve)(value);
         try {
           return fs56.realpathSync(resolved);
         } catch {
@@ -128092,11 +128286,11 @@ ${ptyResult.output.slice(-2e3)}`);
         }
       }
       if (args.force !== true) {
-        const { execFile: execFile8 } = await import("child_process");
-        const { promisify: promisify11 } = await import("util");
-        const execFileAsync7 = promisify11(execFile8);
+        const { execFile: execFile9 } = await import("child_process");
+        const { promisify: promisify12 } = await import("util");
+        const execFileAsync8 = promisify12(execFile9);
         try {
-          const { stdout } = await execFileAsync7("git", ["status", "--porcelain"], {
+          const { stdout } = await execFileAsync8("git", ["status", "--porcelain"], {
             cwd: workspace,
             encoding: "utf8",
             timeout: 3e4,
@@ -128163,7 +128357,7 @@ ${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_path20.resolve)(value);
+        const resolved = (0, import_path21.resolve)(value);
         try {
           return fs56.realpathSync(resolved);
         } catch {
@@ -128192,10 +128386,10 @@ ${ptyResult.output.slice(-2e3)}`);
       const managedEntry = entries.find((entry) => normalizePath2(entry.path) === actualPath);
       if (!managedEntry) {
         try {
-          const { execFile: execFile8 } = await import("child_process");
-          const { promisify: promisify11 } = await import("util");
-          const execFileAsync7 = promisify11(execFile8);
-          await execFileAsync7("git", ["worktree", "prune"], {
+          const { execFile: execFile9 } = await import("child_process");
+          const { promisify: promisify12 } = await import("util");
+          const execFileAsync8 = promisify12(execFile9);
+          await execFileAsync8("git", ["worktree", "prune"], {
             cwd: repoRoot,
             encoding: "utf8",
             timeout: 3e4,
@@ -128284,15 +128478,15 @@ ${ptyResult.output.slice(-2e3)}`);
         const isSubmoduleGuard = /working trees containing submodules cannot be moved or removed/i.test(message);
         const submoduleForceBlocked = isSubmoduleGuard && !forceFallbackConvergence.allow;
         if (forceFallbackConvergence.allow && !dirty) {
-          const { execFile: execFile8 } = await import("child_process");
-          const { promisify: promisify11 } = await import("util");
-          const execFileAsync7 = promisify11(execFile8);
+          const { execFile: execFile9 } = await import("child_process");
+          const { promisify: promisify12 } = await import("util");
+          const execFileAsync8 = promisify12(execFile9);
           const GIT_TIMEOUT_CLEANUP = 3e4;
           const GIT_MAX_BUFFER_CLEANUP = 4 * 1024 * 1024;
           const fallbackReason = isSubmoduleGuard ? "working_trees_containing_submodules" : "worktree_remove_failed";
           try {
             if (isSubmoduleGuard) {
-              await execFileAsync7("git", ["-C", workspace, "submodule", "deinit", "--all", "-f"], {
+              await execFileAsync8("git", ["-C", workspace, "submodule", "deinit", "--all", "-f"], {
                 encoding: "utf8",
                 timeout: GIT_TIMEOUT_CLEANUP,
                 maxBuffer: GIT_MAX_BUFFER_CLEANUP,
@@ -128300,7 +128494,7 @@ ${ptyResult.output.slice(-2e3)}`);
                 env: gitChildEnv()
               });
             }
-            await execFileAsync7("git", ["worktree", "remove", "--force", workspace], {
+            await execFileAsync8("git", ["worktree", "remove", "--force", workspace], {
               cwd: repoRoot,
               encoding: "utf8",
               timeout: GIT_TIMEOUT_CLEANUP,
@@ -128322,7 +128516,7 @@ ${ptyResult.output.slice(-2e3)}`);
           } catch (deinitError) {
             const rm = await self.bestEffortRemoveWorktreeDir(workspace);
             try {
-              await execFileAsync7("git", ["worktree", "prune"], {
+              await execFileAsync8("git", ["worktree", "prune"], {
                 cwd: repoRoot,
                 encoding: "utf8",
                 timeout: GIT_TIMEOUT_CLEANUP,
@@ -128368,11 +128562,11 @@ ${ptyResult.output.slice(-2e3)}`);
       if (refinedConvergence === "merged_pushed" || refinedConvergence === "merged_to_main") {
         return { allow: true, status: refinedConvergence, source: "node_refine_state" };
       }
-      const { execFile: execFile8 } = await import("child_process");
-      const { promisify: promisify11 } = await import("util");
-      const execFileAsync7 = promisify11(execFile8);
-      const runGit3 = async (gitArgs, cwd) => {
-        const { stdout } = await execFileAsync7("git", gitArgs, {
+      const { execFile: execFile9 } = await import("child_process");
+      const { promisify: promisify12 } = await import("util");
+      const execFileAsync8 = promisify12(execFile9);
+      const runGit4 = async (gitArgs, cwd) => {
+        const { stdout } = await execFileAsync8("git", gitArgs, {
           cwd,
           encoding: "utf8",
           timeout: 3e4,
@@ -128393,7 +128587,7 @@ ${ptyResult.output.slice(-2e3)}`);
           return { allow: false, error: "worktree path is missing and worktreeBranch metadata is absent, so the branch tip cannot be resolved" };
         }
         try {
-          head = await runGit3(["rev-parse", "--verify", `${branch}^{commit}`], args.repoRoot);
+          head = await runGit4(["rev-parse", "--verify", `${branch}^{commit}`], args.repoRoot);
         } catch {
           return { allow: true, status: "worktree_and_branch_absent", source: "git_branch_absent" };
         }
@@ -128402,7 +128596,7 @@ ${ptyResult.output.slice(-2e3)}`);
         }
       } else {
         try {
-          head = await runGit3(["rev-parse", "HEAD"], args.workspace);
+          head = await runGit4(["rev-parse", "HEAD"], args.workspace);
         } catch (e) {
           return { allow: false, error: `could not resolve worktree HEAD: ${e?.message || e}` };
         }
@@ -128410,7 +128604,7 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       const candidateRefs = [];
       try {
-        const defaultBranch = await runGit3(["branch", "--show-current"], args.repoRoot);
+        const defaultBranch = await runGit4(["branch", "--show-current"], args.repoRoot);
         if (defaultBranch) {
           candidateRefs.push(defaultBranch, `origin/${defaultBranch}`);
         }
@@ -128425,14 +128619,14 @@ ${ptyResult.output.slice(-2e3)}`);
         seen.add(ref);
         let commit = "";
         try {
-          commit = await runGit3(["rev-parse", "--verify", `${ref}^{commit}`], args.repoRoot);
+          commit = await runGit4(["rev-parse", "--verify", `${ref}^{commit}`], args.repoRoot);
         } catch {
           continue;
         }
         checkedRefs.push(ref);
         resolvedRefCommits.push({ ref, commit });
         try {
-          await runGit3(["merge-base", "--is-ancestor", head, commit], args.repoRoot);
+          await runGit4(["merge-base", "--is-ancestor", head, commit], args.repoRoot);
           return { allow: true, status: "merged_to_default_ref", source: "git_merge_base", ref };
         } catch {
         }
@@ -128831,7 +129025,7 @@ ${ptyResult.output.slice(-2e3)}`);
     init_logger();
     var yaml5 = __toESM2(require_js_yaml());
     var import_os5 = require("os");
-    var import_path21 = require("path");
+    var import_path222 = require("path");
     var fs57 = __toESM2(require("fs"));
     var MESH_COORDINATOR_AUTO_IMPORT_FORMATS = ["claude_mcp_json", "hermes_config_yaml", "opencode_json"];
     function isSupportedMeshCoordinatorConfigFormat(format) {
@@ -128872,13 +129066,13 @@ ${ptyResult.output.slice(-2e3)}`);
     }
     function resolveHermesUserHome() {
       const explicitHome = process.env.HERMES_HOME?.trim();
-      return explicitHome || (0, import_path21.join)((0, import_os5.homedir)(), ".hermes");
+      return explicitHome || (0, import_path222.join)((0, import_os5.homedir)(), ".hermes");
     }
     function loadHermesCoordinatorBaseConfig(targetConfigPath) {
       const sourceHome = resolveHermesUserHome();
-      const sourceConfigPath = (0, import_path21.join)(sourceHome, "config.yaml");
+      const sourceConfigPath = (0, import_path222.join)(sourceHome, "config.yaml");
       if (!fs57.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-      if ((0, import_path21.resolve)(sourceConfigPath) === (0, import_path21.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+      if ((0, import_path222.resolve)(sourceConfigPath) === (0, import_path222.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
       const parsed = parseMeshCoordinatorMcpConfig(fs57.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
       const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
       return { config: baseConfig, sourceHome, sourceConfigPath };
@@ -128912,10 +129106,10 @@ ${ptyResult.output.slice(-2e3)}`);
       return sanitized;
     }
     function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
-      if ((0, import_path21.resolve)(sourceHome) === (0, import_path21.resolve)(targetHome)) return;
+      if ((0, import_path222.resolve)(sourceHome) === (0, import_path222.resolve)(targetHome)) return;
       for (const fileName of [".env", "auth.json"]) {
-        const sourcePath = (0, import_path21.join)(sourceHome, fileName);
-        const targetPath = (0, import_path21.join)(targetHome, fileName);
+        const sourcePath = (0, import_path222.join)(sourceHome, fileName);
+        const targetPath = (0, import_path222.join)(targetHome, fileName);
         if (!fs57.existsSync(sourcePath)) continue;
         try {
           fs57.copyFileSync(sourcePath, targetPath);
@@ -138296,7 +138490,7 @@ data: ${JSON.stringify(msg.data)}
     init_mesh_events();
     init_mesh_reconcile_loop();
     var import_fs20 = require("fs");
-    var import_path222 = require("path");
+    var import_path23 = require("path");
     var import_crypto18 = require("crypto");
     init_logger();
     init_mesh_ledger();
@@ -138374,7 +138568,7 @@ data: ${JSON.stringify(msg.data)}
       }
       for (const name of names) {
         if (!isPendingEventsFile(name)) continue;
-        const path63 = (0, import_path222.join)(dir, name);
+        const path63 = (0, import_path23.join)(dir, name);
         result.filesScanned++;
         const claimed = `${path63}.migrating`;
         try {