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

package/dist/index.js

@@ -36620,10 +36620,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "13ea4fe8748ca3d97f0e4f9cc10a4c5969855fff" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "13ea4fe8" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.56-rc.7" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-19T14:43:40.002Z" : void 0);
+      const commit = readInjected(true ? "346a82b2748c5a3d6ab32d126bbe7399d24d9a82" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "346a82b2" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.56-rc.9" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-19T22:46:34.487Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -40952,11 +40952,11 @@ child.on('exit', () => process.exit(0));
     }
     function windowsExtraBinDirs() {
       const dirs = [];
-      const fs59 = require("fs");
+      const fs61 = require("fs");
       const push = (dir) => {
         if (!dir) return;
         try {
-          if (fs59.existsSync(dir)) dirs.push(dir);
+          if (fs61.existsSync(dir)) dirs.push(dir);
         } catch {
         }
       };
@@ -40972,12 +40972,12 @@ child.on('exit', () => process.exit(0));
     }
     function unixExtraBinDirs() {
       const dirs = [];
-      const fs59 = require("fs");
+      const fs61 = require("fs");
       const home = os52.homedir();
       const push = (dir) => {
         if (!dir) return;
         try {
-          if (fs59.existsSync(dir)) dirs.push(dir);
+          if (fs61.existsSync(dir)) dirs.push(dir);
         } catch {
         }
       };
@@ -41016,9 +41016,9 @@ child.on('exit', () => process.exit(0));
         for (const ext of exes) {
           const fullPath = path9.join(p, trimmed + ext);
           try {
-            const fs59 = require("fs");
-            if (fs59.existsSync(fullPath)) {
-              const stat2 = fs59.statSync(fullPath);
+            const fs61 = require("fs");
+            if (fs61.existsSync(fullPath)) {
+              const stat2 = fs61.statSync(fullPath);
               if (stat2.isFile() && (isWin || stat2.mode & 73)) {
                 return fullPath;
               }
@@ -41032,12 +41032,12 @@ child.on('exit', () => process.exit(0));
     function isScriptBinary(binaryPath) {
       if (!path9.isAbsolute(binaryPath)) return false;
       try {
-        const fs59 = require("fs");
-        const resolved = fs59.realpathSync(binaryPath);
+        const fs61 = require("fs");
+        const resolved = fs61.realpathSync(binaryPath);
         const head = Buffer.alloc(8);
-        const fd = fs59.openSync(resolved, "r");
-        fs59.readSync(fd, head, 0, 8, 0);
-        fs59.closeSync(fd);
+        const fd = fs61.openSync(resolved, "r");
+        fs61.readSync(fd, head, 0, 8, 0);
+        fs61.closeSync(fd);
         let i = 0;
         if (head[0] === 239 && head[1] === 187 && head[2] === 191) i = 3;
         return head[i] === 35 && head[i + 1] === 33;
@@ -41048,12 +41048,12 @@ child.on('exit', () => process.exit(0));
     function looksLikeMachOOrElf(filePath) {
       if (!path9.isAbsolute(filePath)) return false;
       try {
-        const fs59 = require("fs");
-        const resolved = fs59.realpathSync(filePath);
+        const fs61 = require("fs");
+        const resolved = fs61.realpathSync(filePath);
         const buf = Buffer.alloc(8);
-        const fd = fs59.openSync(resolved, "r");
-        fs59.readSync(fd, buf, 0, 8, 0);
-        fs59.closeSync(fd);
+        const fd = fs61.openSync(resolved, "r");
+        fs61.readSync(fd, buf, 0, 8, 0);
+        fs61.closeSync(fd);
         let i = 0;
         if (buf[0] === 239 && buf[1] === 187 && buf[2] === 191) i = 3;
         const b = buf.subarray(i);
@@ -42860,6 +42860,7 @@ ${error48.message || ""}`;
           "mesh_graph_view",
           "mesh_graph_gate_claim",
           "mesh_graph_gate_release",
+          "mesh_graph_gate_abandon",
           "mesh_queue_cancel",
           "mesh_queue_requeue",
           "mesh_send_task",
@@ -47896,11 +47897,31 @@ ${blocks.join("\n\n")}`;
         ...alertReason ? [alertReason] : []
       ].join("::");
     }
+    function isDurablyDedupedEvent(event) {
+      if (!TERMINAL_COMPLETION_EVENTS.has(event.event)) return false;
+      const metadata = readRecord2(event.metadataEvent) || {};
+      const taskId = readNonEmptyString(metadata.taskId) || readNonEmptyString(readRecord2(metadata.payload)?.taskId);
+      return !!taskId;
+    }
+    function recordDurableTerminalDedup(event, fingerprint) {
+      if (!isDurablyDedupedEvent(event)) return;
+      try {
+        const store = MeshRuntimeStore.getInstance();
+        store.recordCompletionFingerprint(event.meshId, `pending::${fingerprint}`, TERMINAL_COMPLETION_DEDUP_TTL_MS);
+        store.sweepExpiredFingerprints();
+      } catch {
+      }
+    }
     function hasPendingCoordinatorEventDuplicate(event) {
       const fingerprint = buildPendingEventFingerprint(event);
       if (!fingerprint.trim()) return false;
       try {
-        return MeshRuntimeStore.getInstance().hasPendingEventFingerprint(event.meshId, fingerprint);
+        const store = MeshRuntimeStore.getInstance();
+        if (store.hasPendingEventFingerprint(event.meshId, fingerprint)) return true;
+        if (isDurablyDedupedEvent(event) && store.hasCompletionFingerprint(event.meshId, `pending::${fingerprint}`)) {
+          return true;
+        }
+        return false;
       } catch {
         return false;
       }
@@ -48123,6 +48144,7 @@ ${blocks.join("\n\n")}`;
           dispatchedBy: event.dispatchedBy ? JSON.stringify(event.dispatchedBy) : null,
           intendedFor: event.intendedFor ? JSON.stringify(event.intendedFor) : null
         });
+        recordDurableTerminalDedup(event, fingerprint);
         return true;
       } catch (e) {
         LOG2.error(
@@ -48343,6 +48365,7 @@ ${blocks.join("\n\n")}`;
     var loggedSqlitePendingDrainFailure;
     var TERMINAL_COMPLETION_EVENTS;
     var COORDINATOR_ALERT_EVENTS_WITH_REASON_FINGERPRINT;
+    var TERMINAL_COMPLETION_DEDUP_TTL_MS;
     var PENDING_EVENTS_DRAINED_RETENTION_MS;
     var PENDING_EVENTS_UNDRAINED_RETENTION_MS;
     var PENDING_RETENTION_EXPIRED_HOLD_REASON;
@@ -48396,6 +48419,7 @@ ${blocks.join("\n\n")}`;
         COORDINATOR_ALERT_EVENTS_WITH_REASON_FINGERPRINT = /* @__PURE__ */ new Set([
           "mesh:dispatch_blocked"
         ]);
+        TERMINAL_COMPLETION_DEDUP_TTL_MS = 60 * 60 * 1e3;
         PENDING_EVENTS_DRAINED_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
         PENDING_EVENTS_UNDRAINED_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
         PENDING_RETENTION_EXPIRED_HOLD_REASON = "pending_retention_expired";
@@ -54861,7 +54885,11 @@ The instruction it carried was never delivered to anyone. If it still matters, r
           }
           /** Remove all pending-event rows (drained included) for a mesh — mesh deletion / test cleanup. */
           clearPendingEventsForMesh(meshId) {
-            return this.db.prepare("DELETE FROM mesh_pending_events WHERE mesh_id = ?").run(meshId).changes;
+            const changes = this.db.prepare("DELETE FROM mesh_pending_events WHERE mesh_id = ?").run(meshId).changes;
+            this.db.prepare(
+              `DELETE FROM mesh_completion_fingerprints WHERE mesh_id = ? AND fingerprint LIKE 'pending::%'`
+            ).run(meshId);
+            return changes;
           }
           pendingEventCount(meshId) {
             const row = this.db.prepare(
@@ -57169,6 +57197,7 @@ When you compose the task message you dispatch to a node, include this requireme
 | \`mesh_graph_view\` | Inspect orchestration graphs \u2014 node states, gates awaiting you, workspace sagas, why something is blocked |
 | \`mesh_graph_gate_claim\` | Take the lease on a gate awaiting a coordinator; returns the fencing token + generation a release needs |
 | \`mesh_graph_gate_release\` | Pass a gate you hold \u2014 the ONLY way through one (no timeout ever passes a gate). **A gate and its dependents are one unit**: a gate earns its keep only when some task names it in \`gated_by\`, because releasing it is what dispatches that task. A gate nothing depends on opens nothing and is pure claim/release overhead \u2014 declare the follower in the same batch, or skip the gate |
+| \`mesh_graph_gate_abandon\` | Give up on a gate that can never be opened, so its graph can go terminal. **Not a pass**: it CANCELS everything the gate was holding and produces no gate outcome. Use it when you cancelled the work behind a gate \u2014 otherwise that gate stays awaiting forever and the graph reaches no terminal state, not even cancelled |
 | \`mesh_queue_cancel\` | Cancel a queue task (audit history kept) |
 | \`mesh_queue_requeue\` | Return a task to pending for retry |
 | \`mesh_send_task\` | Push a task straight to a specific node/session |
@@ -57243,6 +57272,7 @@ Before doing any coordinator work, confirm that the actual callable tool list in
        - **"The only thing I am sure of right now is this one task" is not evidence of a single.** That feeling is about your confidence, not about how many steps are settled; two steps are routinely settled at once while it still feels that way. Count the steps you would actually dispatch. If that count is two or more, it is a batch no matter how the plan feels.
        - **"I cannot choose the next step until I see this result" states that the next step EXISTS.** What the result decides is *which branch you take*, not *whether* there is a follow-up \u2014 and a branch that turns on a predecessor's output is what \`run_if\` selects, what \`inputs_from\` feeds, and what a coordinator gate holds until you decide. Needing to look at evidence before choosing is the ordinary case for a graph edge, not an exception to it.
        - **A gate or a batch is not overhead when something follows it.** The extra call buys the dispatch of everything behind it, so it costs one call and saves a whole round-trip through you. The only genuinely wasteful gate is one nothing depends on \u2014 a gate no task names in \`gated_by\` opens nothing when released, which the release response tells you about; that case is answered by declaring the follower, not by abandoning the batch.
+       - **If you cancel the tasks behind a gate, close the gate too.** Cancelling a task never touches the gate that was holding it \u2014 gates are a separate control plane on purpose. A gate left over a cancelled branch stays \`awaiting_coordinator\` forever, and while ANY gate is unsettled its graph can reach no terminal state at all, not even \`cancelled\`. Close it with \`mesh_graph_gate_abandon\` and a reason. \`mesh_graph_view\` flags this case for you as a \`gate_abandon\` action. Abandon is not a shortcut through a gate: it cancels whatever the gate was holding and yields no gate outcome, so use \`mesh_graph_gate_release\` whenever you actually want the downstream work to run.
 
    When you do use \`mesh_enqueue_task\`, pass \`orchestration_decision\` recording why a single was right (\`single_reason\`: \`only_one_step_known\` / \`future_step_not_specifiable\` / \`same_session_continuation\` / \`legacy_client\` / \`operator_override\`). Omitting it is recorded as \`decision_missing\`.
 
@@ -58803,8 +58833,8 @@ ${rendered}`, "utf-8");
         if (!(0, import_node_fs3.existsSync)(filePath)) return;
         if (owned) {
           try {
-            const fs59 = require("fs");
-            fs59.unlinkSync(filePath);
+            const fs61 = require("fs");
+            fs61.unlinkSync(filePath);
           } catch {
           }
           return;
@@ -58817,8 +58847,8 @@ ${rendered}`, "utf-8");
         const remaining = (existing.slice(0, openIdx) + existing.slice(closeIdx + CLOSE.length)).replace(/^\s*\n+/, "").replace(/\n+\s*$/, "");
         if (!remaining.trim()) {
           try {
-            const fs59 = require("fs");
-            fs59.unlinkSync(filePath);
+            const fs61 = require("fs");
+            fs61.unlinkSync(filePath);
           } catch {
           }
         } else {
@@ -60945,6 +60975,98 @@ ${rendered}`, "utf-8");
         store.updateQueueEntry(entry);
       }
     }
+    function coordinatorGateAbandonedReason(gateId) {
+      return `coordinator_gate_abandoned:${gateId}`;
+    }
+    function abandonMeshGraphGate(input) {
+      const store = MeshRuntimeStore.getInstance();
+      const nowMs = input.nowMs ?? Date.now();
+      const nowIso = new Date(nowMs).toISOString();
+      const result = store.transaction(() => {
+        const graphStore = store.graphStore();
+        const gate = graphStore.getGate(input.gateId);
+        if (!gate || gate.meshId !== input.meshId) {
+          return { abandoned: false, reason: "gate_not_found", cancelledNodeIds: [], cancelledTaskIds: [] };
+        }
+        if (gate.state === "cancelled") {
+          return { abandoned: true, reason: "gate_already_abandoned", gate, cancelledNodeIds: [], cancelledTaskIds: [] };
+        }
+        if (gate.state === "released") {
+          return { abandoned: false, reason: `gate_terminal:${gate.state}`, gate, cancelledNodeIds: [], cancelledTaskIds: [] };
+        }
+        if (!input.force && gate.state === "claimed" && gate.leaseExpiresAt && gate.leaseExpiresAt > nowIso) {
+          return { abandoned: false, reason: "gate_lease_held", gate, cancelledNodeIds: [], cancelledTaskIds: [] };
+        }
+        const abandonReason = `${coordinatorGateAbandonedReason(gate.gateId)}:${input.reason}`;
+        const won = graphStore.patchGate(gate.gateId, {
+          state: "cancelled",
+          // Drop the lease: an abandoned gate has no owner and no live fence.
+          leaseOwnerSessionId: null,
+          fencingToken: null,
+          leaseExpiresAt: null
+        }, nowIso, { leaseGeneration: gate.leaseGeneration });
+        if (!won) {
+          return { abandoned: false, reason: "gate_abandon_race", gate, cancelledNodeIds: [], cancelledTaskIds: [] };
+        }
+        const node = graphStore.getNode(gate.graphId, gate.nodeId);
+        if (node && node.state !== "cancelled") {
+          graphStore.updateNodeState(gate.graphId, gate.nodeId, "cancelled", nowIso, { failureReason: abandonReason });
+        }
+        const cancelledNodeIds = node ? cancelGateDownstreamSubtree(store, node, nowIso, abandonReason) : [];
+        const cancelledTaskIds = [];
+        for (const nodeId of cancelledNodeIds) {
+          const target = graphStore.getNode(gate.graphId, nodeId);
+          if (target?.queueTaskId) cancelledTaskIds.push(target.queueTaskId);
+        }
+        const graph = graphStore.getGraph(gate.graphId);
+        let graphStatus;
+        const rolled = classifyGraphRollup(graphStore.listNodes(gate.graphId));
+        if (graph && rolled && graph.status !== rolled) {
+          graphStore.updateGraphStatus(gate.graphId, rolled, nowIso, true);
+          graphStatus = rolled;
+          insertGateOutbox(
+            graphStore,
+            gate.meshId,
+            gate.graphId,
+            rolled === "completed" ? "graph_completed" : rolled === "failed" ? "graph_failed" : "graph_cancelled",
+            { graphId: gate.graphId, status: rolled },
+            nowIso
+          );
+        } else if (graph?.status === "waiting_gate") {
+          const stillWaiting = graphStore.listGatesByGraph(gate.graphId).some((g) => g.gateId !== gate.gateId && (g.state === "awaiting_coordinator" || g.state === "claimed"));
+          if (!stillWaiting) {
+            graphStore.updateGraphStatus(gate.graphId, "active", nowIso);
+            graphStatus = "active";
+          }
+        }
+        insertGateOutbox(graphStore, gate.meshId, gate.graphId, "graph_gate_abandoned", {
+          graphId: gate.graphId,
+          gateId: gate.gateId,
+          nodeId: gate.nodeId,
+          ref: gate.ref,
+          action: gate.action,
+          priorState: gate.state,
+          reason: input.reason,
+          ...input.coordinatorSessionId ? { coordinatorSessionId: input.coordinatorSessionId } : {},
+          ...input.force ? { force: true } : {},
+          ...cancelledNodeIds.length > 0 ? { cancelledNodeIds } : {}
+        }, nowIso);
+        return {
+          abandoned: true,
+          gate: graphStore.getGate(gate.gateId),
+          cancelledNodeIds,
+          cancelledTaskIds,
+          ...graphStatus ? { graphStatus } : {}
+        };
+      });
+      if (result.abandoned) {
+        try {
+          drainMeshGraphOutbox(input.meshId);
+        } catch {
+        }
+      }
+      return result;
+    }
     function sweepMeshGraphGateTimeouts(meshId, nowMs) {
       const store = MeshRuntimeStore.getInstance();
       const now = nowMs ?? Date.now();
@@ -60997,7 +61119,7 @@ ${rendered}`, "utf-8");
     function isCancelExempt(state) {
       return state === "completed" || state === "released" || state === "skipped" || state === "cancelled" || state === "failed" || state === "expired";
     }
-    function cancelGateDownstreamSubtree(store, gateNode, nowIso) {
+    function cancelGateDownstreamSubtree(store, gateNode, nowIso, reason = `coordinator_gate_timeout:${gateNode.nodeId}`) {
       const graphStore = store.graphStore();
       const nodes = graphStore.listNodes(gateNode.graphId);
       const edges = graphStore.listEdges(gateNode.graphId);
@@ -61014,13 +61136,13 @@ ${rendered}`, "utf-8");
             const target = byId.get(edge.toNodeId);
             if (!target || isCancelExempt(target.state)) continue;
             graphStore.updateNodeState(target.graphId, target.nodeId, "cancelled", nowIso, {
-              failureReason: `coordinator_gate_timeout:${gateNode.nodeId}`
+              failureReason: reason
             });
             if (target.queueTaskId) {
               const entry = store.findQueueEntryById(target.meshId, target.queueTaskId);
               if (entry && entry.status === "pending") {
                 entry.status = "cancelled";
-                entry.blockedReason = `coordinator_gate_timeout:${gateNode.nodeId}`;
+                entry.blockedReason = reason;
                 store.updateQueueEntry(entry);
               }
             }
@@ -61057,6 +61179,7 @@ ${rendered}`, "utf-8");
         init_logger();
         init_mesh_graph_input_binding();
         init_mesh_graph_types();
+        init_mesh_graph_derived_failure();
         init_mesh_graph_transition_runner();
         init_mesh_graph_transition_runner();
         MESH_GATE_DEFAULT_LEASE_SECONDS = 900;
@@ -61189,6 +61312,20 @@ ${rendered}`, "utf-8");
         ...p.cancelledNodeIds?.length ? { cancelledNodeIds: p.cancelledNodeIds } : {}
       });
     }
+    function recordGraphGateAbandoned(meshId, p) {
+      safeAppend(meshId, "graph_gate_abandoned", {
+        graphId: p.graphId,
+        gateId: p.gateId,
+        ...p.ref ? { ref: p.ref } : {},
+        action: p.action,
+        priorState: p.priorState,
+        reason: p.reason.slice(0, 500),
+        ...p.coordinatorSessionId ? { coordinatorSessionId: p.coordinatorSessionId } : {},
+        ...p.force ? { force: true } : {},
+        ...p.cancelledNodeIds?.length ? { cancelledNodeIds: p.cancelledNodeIds } : {},
+        ...p.graphStatus ? { graphStatus: p.graphStatus } : {}
+      });
+    }
     var MESH_VALID_SINGLE_REASONS;
     var MESH_SUPERSEDED_SINGLE_REASONS;
     var MESH_DECLARED_ELIGIBLE_SINGLE_HINT;
@@ -62648,6 +62785,13 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       }
       return false;
     }
+    function isReplayOfRecordedSynthSummary(recorded, incoming) {
+      if (recorded === incoming) return true;
+      if (!recorded || !incoming) return false;
+      const [shorter, longer] = recorded.length <= incoming.length ? [recorded, incoming] : [incoming, recorded];
+      if (!longer.startsWith(shorter)) return false;
+      return longer.length <= shorter.length + 32;
+    }
     function hasIdenticalSynthesizedTerminal(args) {
       const entries = readLedgerEntriesByKind(args.meshId, ["task_dispatched", ...TERMINAL_LEDGER_KINDS2]);
       let afterDispatch = !args.dispatchEntryId && !args.dispatchTimestamp;
@@ -62667,7 +62811,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         if (entry.kind !== "task_completed" && entry.kind !== "task_failed") continue;
         const diagnostic = readRecord2(entry.payload?.completionDiagnostic);
         if (readNonEmptyString(diagnostic?.reason) !== "direct_task_transcript_reconciliation") continue;
-        if (readNonEmptyString(entry.payload?.finalSummary) !== args.finalSummary) continue;
+        if (!isReplayOfRecordedSynthSummary(readNonEmptyString(entry.payload?.finalSummary), args.finalSummary)) continue;
         const terminalTaskId = readNonEmptyString(entry.payload?.taskId);
         if (terminalTaskId && terminalTaskId !== args.taskId) continue;
         if (terminalTaskId && terminalTaskId === args.taskId) return true;
@@ -70810,81 +70954,6 @@ ${cleanBody}`;
         init_mesh_events_utils();
       }
     });
-    function bootstrapQueueTaskCountsAsHandled(task, bootstrapNodeId, nowMs) {
-      if (!meshNodeIdMatches({ id: task.targetNodeId }, bootstrapNodeId)) return false;
-      if (task.status === "assigned") return true;
-      const al = task.autoLaunch;
-      if (!al) return true;
-      if (al.status === "started" || al.status === "completed") {
-        const launchedAtMs = Date.parse(al.updatedAt);
-        return Number.isFinite(launchedAtMs) && nowMs - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS;
-      }
-      return true;
-    }
-    function resolveCoordinatorDrainDaemonIds(components) {
-      const statusInstanceId = readNonEmptyString(components.statusInstanceId);
-      const machineId = readNonEmptyString(loadConfig2().machineId);
-      return expandDaemonIdForms([statusInstanceId, machineId]);
-    }
-    function getCachedMeshByWorkspace(workspace) {
-      const now = Date.now();
-      const cached5 = meshByWorkspaceCache.get(workspace);
-      if (cached5 && now - cached5.cachedAt < MESH_WORKSPACE_CACHE_TTL_MS) return cached5.mesh;
-      const mesh = getMeshByRepo(workspace);
-      meshByWorkspaceCache.set(workspace, { mesh, cachedAt: now });
-      return mesh;
-    }
-    function recoverMeshIdByNodeId(nodeId) {
-      if (!nodeId) return "";
-      for (const mesh of listMeshes()) {
-        if (Array.isArray(mesh.nodes) && mesh.nodes.some((n) => meshNodeIdMatches(n, nodeId))) {
-          return readNonEmptyString(mesh.id);
-        }
-      }
-      return "";
-    }
-    function recoverMeshIdByCoordinatorAndNode(coordinatorDaemonId, nodeId) {
-      if (!coordinatorDaemonId) return "";
-      const hosted = listMeshes().filter((mesh) => {
-        const host = resolveMeshHostStatus(mesh);
-        return host.role === "host" && (!host.hostDaemonId || daemonIdsEquivalent(host.hostDaemonId, coordinatorDaemonId));
-      });
-      if (hosted.length === 0) return "";
-      if (nodeId) {
-        const byNode = hosted.find((mesh) => Array.isArray(mesh.nodes) && mesh.nodes.some((n) => meshNodeIdMatches(n, nodeId)));
-        if (byNode) return readNonEmptyString(byNode.id);
-        return "";
-      }
-      return hosted.length === 1 ? readNonEmptyString(hosted[0].id) : "";
-    }
-    function resolveForwardEventMeshId(components, payload) {
-      const direct = readNonEmptyString(payload.meshId);
-      if (direct) return direct;
-      const workspace = readNonEmptyString(payload.workspace);
-      const byWorkspace = workspace ? readNonEmptyString(getCachedMeshByWorkspace(workspace)?.id) : "";
-      if (byWorkspace) return byWorkspace;
-      const byNode = recoverMeshIdByNodeId(readNonEmptyString(payload.nodeId));
-      if (byNode) return byNode;
-      const sessionId = readNonEmptyString(payload.targetSessionId) || readNonEmptyString(payload.sessionId) || readNonEmptyString(payload.instanceId);
-      if (sessionId) {
-        try {
-          const state = components.instanceManager?.getInstance?.(sessionId)?.getState?.();
-          const settings = state?.settings || {};
-          const meshNodeFor = readNonEmptyString(settings.meshNodeFor);
-          if (meshNodeFor) return meshNodeFor;
-          const byStamp = recoverMeshIdByNodeId(readNonEmptyString(settings.meshNodeId));
-          if (byStamp) return byStamp;
-          const sessionWorkspace = readNonEmptyString(state?.workspace);
-          const bySessionWorkspace = sessionWorkspace ? readNonEmptyString(getCachedMeshByWorkspace(sessionWorkspace)?.id) : "";
-          if (bySessionWorkspace) return bySessionWorkspace;
-        } catch {
-        }
-      }
-      return "";
-    }
-    function __resetMeshWorkspaceCacheForTests() {
-      meshByWorkspaceCache.clear();
-    }
     function sweepExpiredRemoteIdleSessions() {
       try {
         MeshRuntimeStore.getInstance().pruneExpiredRemoteIdleSessions();
@@ -71012,6 +71081,10 @@ ${cleanBody}`;
       if (explicit) return explicit;
       return extractJsonObjectFromSummary(readNonEmptyString(metadataEvent.finalSummary) || void 0);
     }
+    function resolveUnifiedCompletionEvidenceLevel(args) {
+      if (args.computedLevel === "insufficient" || args.priorLevel === "insufficient") return "insufficient";
+      return args.computedLevel || args.priorLevel;
+    }
     function supersedesTruncatedTerminalSummary(args) {
       if (!args.terminalTaskId || !args.eventTaskId || args.terminalTaskId !== args.eventTaskId) return false;
       if (!isGenuineCompletionEvidence(args.metadataEvent)) return false;
@@ -71052,7 +71125,7 @@ ${cleanBody}`;
       return false;
     }
     function evaluateMeshEventSuppression(args, ctx) {
-      const { traceCtx, eventSessionId, eventNodeId, eventTimestamp, workerCoordinatorDaemonId, components } = ctx;
+      const { traceCtx, eventSessionId, eventNodeId, eventTimestamp, workerCoordinatorDaemonId, components, injectMeshSystemMessage: injectMeshSystemMessage2 } = ctx;
       const intentionalCleanupStop = shouldSuppressIntentionalCleanupStop({
         event: args.event,
         meshId: args.meshId,
@@ -71138,7 +71211,7 @@ ${cleanBody}`;
                 eventSessionId,
                 attempt
               });
-              const heldForRetry = retryEligible && holdCompletionForLiveStateRetry(components, args, eventSessionId, Date.now(), injectMeshSystemMessage);
+              const heldForRetry = retryEligible && holdCompletionForLiveStateRetry(components, args, eventSessionId, Date.now(), injectMeshSystemMessage2);
               const authorityDetail = !authority.authoritative && authority.detail ? ` [authorityClass=${authority.detail.authorityClass ?? "none"} evidenceSource=${authority.detail.evidenceSource ?? "none"} timing=${authority.detail.timing ?? "none"}]` : "";
               LOG2.info("MeshEvents", `Suppressed agent:generating_completed for session ${eventSessionId} (mesh ${args.meshId}): current live evidence remains pending (${live.kind ?? "unknown"}); transcript authority=${authority.authoritative ? "fresh_but_not_newer" : authority.reason}${authorityDetail}${heldForRetry ? " \u2014 bounded content-free retry armed" : ""}`);
               traceMeshEventDrop(
@@ -71184,7 +71257,7 @@ ${cleanBody}`;
               args,
               eventSessionId,
               Date.now(),
-              injectMeshSystemMessage
+              injectMeshSystemMessage2
             );
             LOG2.info("MeshEvents", `Suppressed agent:generating_completed for session ${eventSessionId} (mesh ${args.meshId}): terminal admission declined (${admission.reason}) \u2014 ${admission.detail}${heldForRetry ? " \u2014 bounded content-free retry armed" : ""}`);
             traceMeshEventDrop(
@@ -71451,6 +71524,119 @@ ${cleanBody}`;
       }
       return false;
     }
+    var lastPendingEventsPruneAt;
+    var PENDING_EVENTS_PRUNE_INTERVAL_MS;
+    var INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS;
+    var RECENT_COMPLETION_FINGERPRINT_TTL_MS;
+    var RECONCILED_COMPLETION_SOURCES;
+    var turnOutboxDrainScheduled;
+    var init_mesh_event_suppression = __esm2({
+      "src/mesh/mesh-event-suppression.ts"() {
+        "use strict";
+        init_logger();
+        init_mesh_ledger();
+        init_mesh_work_queue();
+        init_mesh_runtime_store();
+        init_mesh_events_pending();
+        init_mesh_event_trace();
+        init_dist();
+        init_mesh_events_stale();
+        init_mesh_task_inflight();
+        init_mesh_node_identity();
+        init_mesh_events_utils();
+        init_mesh_turn_ledger();
+        init_mesh_turn_presentation();
+        init_mesh_queue_assignment();
+        init_mesh_completion_live_gate();
+        init_mesh_provider_event_admission();
+        lastPendingEventsPruneAt = 0;
+        PENDING_EVENTS_PRUNE_INTERVAL_MS = 60 * 60 * 1e3;
+        INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS = 30 * 60 * 1e3;
+        RECENT_COMPLETION_FINGERPRINT_TTL_MS = 10 * 60 * 1e3;
+        RECONCILED_COMPLETION_SOURCES = /* @__PURE__ */ new Set([
+          "direct_task_transcript_reconciliation",
+          "daemon_reconcile_transcript_completion",
+          "mcp_mesh_status_transcript_reconciliation",
+          "no_progress_reconciliation"
+        ]);
+        turnOutboxDrainScheduled = false;
+      }
+    });
+    function bootstrapQueueTaskCountsAsHandled(task, bootstrapNodeId, nowMs) {
+      if (!meshNodeIdMatches({ id: task.targetNodeId }, bootstrapNodeId)) return false;
+      if (task.status === "assigned") return true;
+      const al = task.autoLaunch;
+      if (!al) return true;
+      if (al.status === "started" || al.status === "completed") {
+        const launchedAtMs = Date.parse(al.updatedAt);
+        return Number.isFinite(launchedAtMs) && nowMs - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS;
+      }
+      return true;
+    }
+    function resolveCoordinatorDrainDaemonIds(components) {
+      const statusInstanceId = readNonEmptyString(components.statusInstanceId);
+      const machineId = readNonEmptyString(loadConfig2().machineId);
+      return expandDaemonIdForms([statusInstanceId, machineId]);
+    }
+    function getCachedMeshByWorkspace(workspace) {
+      const now = Date.now();
+      const cached5 = meshByWorkspaceCache.get(workspace);
+      if (cached5 && now - cached5.cachedAt < MESH_WORKSPACE_CACHE_TTL_MS) return cached5.mesh;
+      const mesh = getMeshByRepo(workspace);
+      meshByWorkspaceCache.set(workspace, { mesh, cachedAt: now });
+      return mesh;
+    }
+    function recoverMeshIdByNodeId(nodeId) {
+      if (!nodeId) return "";
+      for (const mesh of listMeshes()) {
+        if (Array.isArray(mesh.nodes) && mesh.nodes.some((n) => meshNodeIdMatches(n, nodeId))) {
+          return readNonEmptyString(mesh.id);
+        }
+      }
+      return "";
+    }
+    function recoverMeshIdByCoordinatorAndNode(coordinatorDaemonId, nodeId) {
+      if (!coordinatorDaemonId) return "";
+      const hosted = listMeshes().filter((mesh) => {
+        const host = resolveMeshHostStatus(mesh);
+        return host.role === "host" && (!host.hostDaemonId || daemonIdsEquivalent(host.hostDaemonId, coordinatorDaemonId));
+      });
+      if (hosted.length === 0) return "";
+      if (nodeId) {
+        const byNode = hosted.find((mesh) => Array.isArray(mesh.nodes) && mesh.nodes.some((n) => meshNodeIdMatches(n, nodeId)));
+        if (byNode) return readNonEmptyString(byNode.id);
+        return "";
+      }
+      return hosted.length === 1 ? readNonEmptyString(hosted[0].id) : "";
+    }
+    function resolveForwardEventMeshId(components, payload) {
+      const direct = readNonEmptyString(payload.meshId);
+      if (direct) return direct;
+      const workspace = readNonEmptyString(payload.workspace);
+      const byWorkspace = workspace ? readNonEmptyString(getCachedMeshByWorkspace(workspace)?.id) : "";
+      if (byWorkspace) return byWorkspace;
+      const byNode = recoverMeshIdByNodeId(readNonEmptyString(payload.nodeId));
+      if (byNode) return byNode;
+      const sessionId = readNonEmptyString(payload.targetSessionId) || readNonEmptyString(payload.sessionId) || readNonEmptyString(payload.instanceId);
+      if (sessionId) {
+        try {
+          const state = components.instanceManager?.getInstance?.(sessionId)?.getState?.();
+          const settings = state?.settings || {};
+          const meshNodeFor = readNonEmptyString(settings.meshNodeFor);
+          if (meshNodeFor) return meshNodeFor;
+          const byStamp = recoverMeshIdByNodeId(readNonEmptyString(settings.meshNodeId));
+          if (byStamp) return byStamp;
+          const sessionWorkspace = readNonEmptyString(state?.workspace);
+          const bySessionWorkspace = sessionWorkspace ? readNonEmptyString(getCachedMeshByWorkspace(sessionWorkspace)?.id) : "";
+          if (bySessionWorkspace) return bySessionWorkspace;
+        } catch {
+        }
+      }
+      return "";
+    }
+    function __resetMeshWorkspaceCacheForTests() {
+      meshByWorkspaceCache.clear();
+    }
     function injectMeshSystemMessage(components, args) {
       const eventSessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
       const eventNodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
@@ -71528,7 +71714,8 @@ ${cleanBody}`;
         eventNodeId,
         eventTimestamp,
         workerCoordinatorDaemonId,
-        components
+        components,
+        injectMeshSystemMessage
       });
       if (suppression) {
         if (suppression.kind === "reconcile") {
@@ -72005,7 +72192,36 @@ ${cleanBody}`;
               // worker-result-shaped, e.g. a MAGI envelope) is concrete evidence and must
               // resolve to 'sufficient' — resolveWorkerResult now upgrades that case so a
               // complete, valid answer is no longer mislabelled insufficient/reviewRecommended.
-              ...completionEvidence ? completionEvidence.workerResult.source === "default" ? { evidenceLevel: "insufficient", reviewRecommended: true } : { evidenceLevel: "sufficient" } : {},
+              //
+              // EVIDENCE-LEVEL-UNIFY: the LEDGER value is merged with whatever
+              // applyTaskModeCompletionEvidence already stamped onto
+              // args.metadataEvent.evidenceLevel earlier in markSessionTerminal, so a
+              // 'reported' stamp can never make the ledger forget a locally-computed
+              // 'insufficient' (and vice versa). See resolveUnifiedCompletionEvidenceLevel.
+              //
+              // ONE-WAY ON PURPOSE — do NOT write the resolved level back onto
+              // args.metadataEvent. That mutation looks like the natural way to make the
+              // later buildMeshSystemMessage read agree with the ledger, but
+              // metadataEvent.evidenceLevel is load-bearing for DEDUP, not just wording:
+              // buildPendingEventFingerprint (mesh-events-pending.ts) keys terminal
+              // completions `…::weak` / `…::genuine` off isWeakCompletionMetadata, which
+              // reads this very field. Stamping 'insufficient' back onto an ordinary
+              // completion (workerResult.source === 'default' is the COMMON plain-text
+              // finalSummary case, not an anomaly) moves it into the `::weak` slot, where
+              // it collides with an earlier weak synth for the same taskId and the
+              // genuine completion is dropped as a duplicate — the exact swallow that
+              // EARLYNOTIFY-GATEBYPASS guards against. The ledger records the stricter
+              // verdict; the coordinator-facing weakness signal stays owned by the
+              // producers that set it deliberately.
+              ...(() => {
+                const computedLevel = completionEvidence ? completionEvidence.workerResult.source === "default" ? "insufficient" : "sufficient" : void 0;
+                const resolvedLevel = resolveUnifiedCompletionEvidenceLevel({
+                  computedLevel,
+                  priorLevel: readNonEmptyString(args.metadataEvent.evidenceLevel)
+                });
+                if (!resolvedLevel) return {};
+                return resolvedLevel === "insufficient" ? { evidenceLevel: resolvedLevel, reviewRecommended: true } : { evidenceLevel: resolvedLevel };
+              })(),
               // FALSE-COMPLETION-GIT-EVIDENCE: markSessionTerminal's synchronous git-clean
               // gate stamps this onto metadataEvent BEFORE this ledger append runs — OR it
               // into reviewRecommended (never downgrade the NOTIF Defect-2b verdict above)
@@ -72503,12 +72719,6 @@ ${cleanBody}`;
     var REMOTE_IDLE_SESSION_TTL_MS;
     var meshByWorkspaceCache;
     var MESH_WORKSPACE_CACHE_TTL_MS;
-    var lastPendingEventsPruneAt;
-    var PENDING_EVENTS_PRUNE_INTERVAL_MS;
-    var INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS;
-    var RECENT_COMPLETION_FINGERPRINT_TTL_MS;
-    var RECONCILED_COMPLETION_SOURCES;
-    var turnOutboxDrainScheduled;
     var init_mesh_event_forwarding = __esm2({
       "src/mesh/mesh-event-forwarding.ts"() {
         "use strict";
@@ -72535,28 +72745,15 @@ ${cleanBody}`;
         init_mesh_events_stale();
         init_mesh_task_inflight();
         init_mesh_graph_transition_runner();
-        init_mesh_node_identity();
         init_mesh_events_utils();
         init_mesh_event_classify();
         init_mesh_turn_ledger();
-        init_mesh_turn_presentation();
         init_mesh_queue_assignment();
-        init_mesh_completion_live_gate();
-        init_mesh_provider_event_admission();
+        init_mesh_event_suppression();
+        init_mesh_event_suppression();
         REMOTE_IDLE_SESSION_TTL_MS = 5 * 60 * 1e3;
         meshByWorkspaceCache = /* @__PURE__ */ new Map();
         MESH_WORKSPACE_CACHE_TTL_MS = 5e3;
-        lastPendingEventsPruneAt = 0;
-        PENDING_EVENTS_PRUNE_INTERVAL_MS = 60 * 60 * 1e3;
-        INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS = 30 * 60 * 1e3;
-        RECENT_COMPLETION_FINGERPRINT_TTL_MS = 10 * 60 * 1e3;
-        RECONCILED_COMPLETION_SOURCES = /* @__PURE__ */ new Set([
-          "direct_task_transcript_reconciliation",
-          "daemon_reconcile_transcript_completion",
-          "mcp_mesh_status_transcript_reconciliation",
-          "no_progress_reconciliation"
-        ]);
-        turnOutboxDrainScheduled = false;
       }
     });
     var init_mesh_events_coordinator = __esm2({
@@ -77621,8 +77818,8 @@ ${cleanBody}`;
             let cwd = options.cwd;
             if (cwd) {
               try {
-                const fs59 = require("fs");
-                const stat2 = fs59.statSync(cwd);
+                const fs61 = require("fs");
+                const stat2 = fs61.statSync(cwd);
                 if (!stat2.isDirectory()) cwd = os14.homedir();
               } catch {
                 cwd = os14.homedir();
@@ -79019,6 +79216,360 @@ ${cleanBody}`;
         DEFAULT_REFINE_VITEST_MAX_WORKERS = 2;
       }
     });
+    function readChangedGitlinkPaths(repoRoot, fromRef, toRef) {
+      try {
+        const output = (0, import_node_child_process11.execFileSync)(GIT4, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
+          cwd: repoRoot,
+          encoding: "utf8",
+          maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
+        });
+        const paths = /* @__PURE__ */ new Set();
+        for (const line of output.split("\n")) {
+          if (!line.trim()) continue;
+          const metaAndPath = line.split("	");
+          const meta3 = metaAndPath[0] || "";
+          const path58 = metaAndPath[metaAndPath.length - 1]?.trim();
+          if (!path58) continue;
+          const parts = meta3.split(/\s+/);
+          if (parts[0]?.includes("160000") || parts[1]?.includes("160000")) {
+            paths.add(path58);
+          }
+        }
+        return [...paths].sort();
+      } catch {
+        return [];
+      }
+    }
+    function readTreeObject(repoRoot, ref, path58) {
+      try {
+        const output = (0, import_node_child_process11.execFileSync)(GIT4, ["ls-tree", ref, "--", path58], {
+          cwd: repoRoot,
+          encoding: "utf8",
+          maxBuffer: 1024 * 1024
+        }).trim();
+        const match = output.match(/\bcommit\s+([0-9a-f]{40})\b/i);
+        return match?.[1];
+      } catch {
+        return void 0;
+      }
+    }
+    function submoduleCommitPresent(submoduleRepoPath, commit) {
+      if (!commit) return false;
+      try {
+        (0, import_node_child_process11.execFileSync)(GIT4, ["cat-file", "-e", `${commit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    function ensureSubmoduleCommitLocal(submoduleRepoPath, baseSubmoduleRepoPath, commit) {
+      if (!commit) return false;
+      const present = () => {
+        try {
+          (0, import_node_child_process11.execFileSync)(GIT4, ["cat-file", "-e", `${commit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+          return true;
+        } catch {
+          return false;
+        }
+      };
+      if (present()) return true;
+      try {
+        if (!fs48.existsSync(submoduleRepoPath) || !fs48.existsSync(baseSubmoduleRepoPath)) return false;
+      } catch {
+        return false;
+      }
+      const strategies = [
+        // 1. All local branches (historical behaviour).
+        ["fetch", "-q", baseSubmoduleRepoPath, "+refs/heads/*:refs/adhdev-refine-base/*"],
+        // 2. The base checkout's detached HEAD plus every ref it has.
+        ["fetch", "-q", baseSubmoduleRepoPath, "HEAD", "+refs/*:refs/adhdev-refine-base-all/*"],
+        // 3. The exact object, allowing a bare-sha want on the source side.
+        ["fetch", "-q", "--upload-pack", "git -c uploadpack.allowAnySHA1InWant=true upload-pack", baseSubmoduleRepoPath, commit]
+      ];
+      for (const args of strategies) {
+        try {
+          (0, import_node_child_process11.execFileSync)(GIT4, ["-c", "protocol.file.allow=always", ...args], {
+            cwd: submoduleRepoPath,
+            stdio: ["ignore", "ignore", "pipe"]
+          });
+        } catch {
+        }
+        if (present()) return true;
+      }
+      return false;
+    }
+    var fs48;
+    var import_node_child_process11;
+    var GIT4;
+    var REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES;
+    var init_mesh_refine_gitlink_utils = __esm2({
+      "src/mesh/mesh-refine-gitlink-utils.ts"() {
+        "use strict";
+        fs48 = __toESM2(require("fs"));
+        import_node_child_process11 = require("child_process");
+        init_resolve_executable();
+        GIT4 = process.platform === "win32" ? resolveWin32Executable("git") : "git";
+        REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES = 4 * 1024 * 1024;
+      }
+    });
+    function classifySubmoduleDivergence(submoduleRepoPath, baseCommit, branchCommit) {
+      if (!baseCommit || !branchCommit) return "undeterminable";
+      if (baseCommit === branchCommit) return "not_diverged";
+      try {
+        if (!fs49.existsSync(submoduleRepoPath)) return "undeterminable";
+        (0, import_node_child_process12.execFileSync)(GIT4, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+        (0, import_node_child_process12.execFileSync)(GIT4, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+      } catch {
+        return "undeterminable";
+      }
+      try {
+        (0, import_node_child_process12.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+        return "not_diverged";
+      } catch {
+      }
+      try {
+        (0, import_node_child_process12.execFileSync)(GIT4, ["merge-base", "--is-ancestor", branchCommit, baseCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+        return "not_diverged";
+      } catch {
+      }
+      try {
+        const mb = (0, import_node_child_process12.execFileSync)(GIT4, ["merge-base", baseCommit, branchCommit], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+        return mb ? "diverged" : "not_diverged";
+      } catch {
+        return "not_diverged";
+      }
+    }
+    function resolveSubmoduleRemoteMainRef(submoduleRepoPath) {
+      try {
+        const sym = (0, import_node_child_process12.execFileSync)(GIT4, ["symbolic-ref", "-q", "refs/remotes/origin/HEAD"], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+        if (sym) return sym;
+      } catch {
+      }
+      for (const branch of ["main", "master"]) {
+        try {
+          (0, import_node_child_process12.execFileSync)(GIT4, ["rev-parse", "--verify", "-q", `refs/remotes/origin/${branch}`], { cwd: submoduleRepoPath, stdio: ["ignore", "pipe", "pipe"] });
+          return `refs/remotes/origin/${branch}`;
+        } catch {
+        }
+      }
+      return void 0;
+    }
+    function findEquivalentPublishedSubmoduleCommit(submoduleRepoPath, baseCommit, branchCommit, remoteRef) {
+      try {
+        const mergeTreeOut = (0, import_node_child_process12.execFileSync)(GIT4, ["merge-tree", "--write-tree", baseCommit, branchCommit], {
+          cwd: submoduleRepoPath,
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        const mergedTree = mergeTreeOut.trim().split(/\s+/)[0] || "";
+        if (!mergedTree) return void 0;
+        const candidates = (0, import_node_child_process12.execFileSync)(GIT4, ["rev-list", "--max-count=100", remoteRef, "--not", baseCommit], {
+          cwd: submoduleRepoPath,
+          encoding: "utf8"
+        }).split("\n").map((s2) => s2.trim()).filter(Boolean);
+        for (const candidate of candidates) {
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, candidate], { cwd: submoduleRepoPath, stdio: "ignore" });
+          } catch {
+            continue;
+          }
+          const tree = (0, import_node_child_process12.execFileSync)(GIT4, ["rev-parse", `${candidate}^{tree}`], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+          if (tree === mergedTree) return candidate;
+        }
+      } catch {
+      }
+      return void 0;
+    }
+    function convergeDivergedSubmoduleGitlinks(worktreeRoot, baseRepoRoot, baseHead, branchHead) {
+      const changed = readChangedGitlinkPaths(worktreeRoot, baseHead, branchHead);
+      if (changed.length === 0) {
+        return { converged: false, reason: "no_changed_gitlinks", resolutions: [], gitlinks: [] };
+      }
+      const gitlinks = [];
+      const resolutions = [];
+      let sawDiverged = false;
+      let sawUndeterminable = false;
+      for (const path58 of changed) {
+        const baseCommit = readTreeObject(baseRepoRoot, baseHead, path58);
+        const branchCommit = readTreeObject(worktreeRoot, branchHead, path58);
+        const submoduleRepoPath = (0, import_path17.resolve)(worktreeRoot, path58);
+        if (baseCommit) {
+          ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path17.resolve)(baseRepoRoot, path58), baseCommit);
+        }
+        const markUndeterminable = () => {
+          const unavailable = [];
+          if (!baseCommit || !submoduleCommitPresent(submoduleRepoPath, baseCommit)) unavailable.push("base");
+          if (!branchCommit || !submoduleCommitPresent(submoduleRepoPath, branchCommit)) unavailable.push("branch");
+          sawUndeterminable = true;
+          gitlinks.push({ path: path58, baseCommit, branchCommit, action: "skipped_commit_unavailable", unavailable });
+        };
+        if (!baseCommit || !branchCommit) {
+          markUndeterminable();
+          continue;
+        }
+        const divergence = classifySubmoduleDivergence(submoduleRepoPath, baseCommit, branchCommit);
+        if (divergence === "undeterminable") {
+          markUndeterminable();
+          continue;
+        }
+        if (divergence !== "diverged") {
+          gitlinks.push({ path: path58, baseCommit, branchCommit, action: "skipped_not_diverged" });
+          continue;
+        }
+        sawDiverged = true;
+        try {
+          (0, import_node_child_process12.execFileSync)(GIT4, ["-c", "protocol.file.allow=always", "fetch", "-q", "origin"], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
+        } catch {
+        }
+        const remoteMainRef = resolveSubmoduleRemoteMainRef(submoduleRepoPath);
+        const publishedEquivalent = remoteMainRef ? findEquivalentPublishedSubmoduleCommit(submoduleRepoPath, baseCommit, branchCommit, remoteMainRef) : void 0;
+        if (publishedEquivalent) {
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["checkout", "-q", "--detach", publishedEquivalent], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
+          } catch {
+          }
+          gitlinks.push({ path: path58, baseCommit, branchCommit, rebasedCommit: publishedEquivalent, action: "converged_to_published" });
+          resolutions.push({ path: path58, baseCommit, branchCommit, rebasedCommit: publishedEquivalent });
+          continue;
+        }
+        let rebasedCommit;
+        try {
+          (0, import_node_child_process12.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
+          (0, import_node_child_process12.execFileSync)(GIT4, ["rebase", baseCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "pipe", "pipe"] });
+          rebasedCommit = (0, import_node_child_process12.execFileSync)(GIT4, ["rev-parse", "HEAD"], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+        } catch {
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["rebase", "--abort"], { cwd: submoduleRepoPath, stdio: "ignore" });
+          } catch {
+          }
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+          } catch {
+          }
+          gitlinks.push({ path: path58, baseCommit, branchCommit, action: "rebase_conflict" });
+          return { converged: false, reason: "rebase_conflict", resolutions: [], gitlinks };
+        }
+        const branchWorkSurvived = (() => {
+          if (!rebasedCommit) return false;
+          if (rebasedCommit === branchCommit) return true;
+          if (rebasedCommit === baseCommit) return false;
+          try {
+            const replayed = (0, import_node_child_process12.execFileSync)(GIT4, ["rev-list", "--count", `${baseCommit}..${rebasedCommit}`], {
+              cwd: submoduleRepoPath,
+              encoding: "utf8"
+            }).trim();
+            return Number.parseInt(replayed, 10) > 0;
+          } catch {
+            return false;
+          }
+        })();
+        if (!branchWorkSurvived) {
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+          } catch {
+          }
+          gitlinks.push({ path: path58, baseCommit, branchCommit, rebasedCommit, action: "rebase_dropped_branch_commits" });
+          return { converged: false, reason: "rebase_dropped_branch_commits", resolutions: [], gitlinks };
+        }
+        gitlinks.push({ path: path58, baseCommit, branchCommit, rebasedCommit, action: "rebased" });
+        resolutions.push({ path: path58, baseCommit, branchCommit, rebasedCommit });
+      }
+      if (!sawDiverged) {
+        const reason = sawUndeterminable ? "submodule_commit_unavailable" : "not_diverged";
+        return { converged: false, reason, resolutions: [], gitlinks };
+      }
+      return { converged: resolutions.length > 0, resolutions, gitlinks };
+    }
+    function rootRebaseResolvingGitlinks(worktreeRoot, baseHead, resolutions) {
+      const resolveByPath = new Map(resolutions.map((r) => [r.path, r.rebasedCommit]));
+      const runRebase = (args) => {
+        try {
+          (0, import_node_child_process12.execFileSync)(GIT4, args, {
+            cwd: worktreeRoot,
+            stdio: ["ignore", "pipe", "pipe"],
+            // A rebase editor prompt would hang; keep it non-interactive.
+            env: { ...process.env, GIT_EDITOR: "true", GIT_SEQUENCE_EDITOR: "true" }
+          });
+          return { ok: true };
+        } catch {
+          return { ok: false };
+        }
+      };
+      const unmergedPaths = () => {
+        try {
+          return (0, import_node_child_process12.execFileSync)(GIT4, ["diff", "--name-only", "--diff-filter=U"], { cwd: worktreeRoot, encoding: "utf8" }).split("\n").map((s2) => s2.trim()).filter(Boolean);
+        } catch {
+          return [];
+        }
+      };
+      const abort = (reason, conflictPaths) => {
+        try {
+          (0, import_node_child_process12.execFileSync)(GIT4, ["rebase", "--abort"], { cwd: worktreeRoot, stdio: "ignore" });
+        } catch {
+        }
+        return { ok: false, reason, conflictPaths };
+      };
+      let progress = runRebase(["rebase", baseHead]);
+      let guard = 0;
+      while (!progress.ok) {
+        if (guard++ > 100) return abort("rebase_error");
+        const conflicts = unmergedPaths();
+        if (conflicts.length === 0) {
+          return abort("rebase_error");
+        }
+        const unresolvable = conflicts.filter((p) => !resolveByPath.has(p));
+        if (unresolvable.length > 0) {
+          const unresolvableGitlink = unresolvable.some((p) => {
+            try {
+              const staged = (0, import_node_child_process12.execFileSync)(GIT4, ["ls-files", "--stage", "--", p], { cwd: worktreeRoot, encoding: "utf8" });
+              return /^160000\s/m.test(staged);
+            } catch {
+              return false;
+            }
+          });
+          const allGitlink = unresolvable.every((p) => {
+            try {
+              const staged = (0, import_node_child_process12.execFileSync)(GIT4, ["ls-files", "--stage", "--", p], { cwd: worktreeRoot, encoding: "utf8" });
+              return /^160000\s/m.test(staged);
+            } catch {
+              return false;
+            }
+          });
+          return abort(allGitlink && unresolvableGitlink ? "unexpected_gitlink" : "non_gitlink_conflict", conflicts);
+        }
+        for (const p of conflicts) {
+          const commit = resolveByPath.get(p);
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["checkout", "-q", "--detach", commit], { cwd: (0, import_path17.resolve)(worktreeRoot, p), stdio: "ignore" });
+          } catch {
+          }
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["add", p], { cwd: worktreeRoot, stdio: "ignore" });
+          } catch {
+            return abort("rebase_error", conflicts);
+          }
+        }
+        progress = runRebase(["rebase", "--continue"]);
+      }
+      let branchHead;
+      try {
+        branchHead = (0, import_node_child_process12.execFileSync)(GIT4, ["rev-parse", "HEAD"], { cwd: worktreeRoot, encoding: "utf8" }).trim();
+      } catch {
+      }
+      return { ok: true, branchHead };
+    }
+    var fs49;
+    var import_path17;
+    var import_node_child_process12;
+    var init_mesh_refine_submodule_converge = __esm2({
+      "src/mesh/mesh-refine-submodule-converge.ts"() {
+        "use strict";
+        fs49 = __toESM2(require("fs"));
+        import_path17 = require("path");
+        import_node_child_process12 = require("child_process");
+        init_mesh_refine_gitlink_utils();
+      }
+    });
     function truncateValidationOutput(value) {
       const text = typeof value === "string" ? value : value == null ? "" : String(value);
       if (text.length <= REFINE_VALIDATION_SUMMARY_CHARS) return text;
@@ -79036,13 +79587,13 @@ ${tail}`;
     }
     function writeValidationFailureLog(workspace, index, candidate, streams, now = () => /* @__PURE__ */ new Date()) {
       try {
-        const dir = (0, import_path17.join)(workspace, REFINE_VALIDATION_LOG_DIR);
-        fs48.mkdirSync(dir, { recursive: true });
+        const dir = (0, import_path18.join)(workspace, REFINE_VALIDATION_LOG_DIR);
+        fs50.mkdirSync(dir, { recursive: true });
         const stamp = now().toISOString().replace(/[:.]/g, "-");
-        const file2 = (0, import_path17.join)(dir, `refine-${stamp}-${index}.log`);
+        const file2 = (0, import_path18.join)(dir, `refine-${stamp}-${index}.log`);
         const asText = (v) => typeof v === "string" ? v : v == null ? "" : String(v);
         const shown = candidate.displayCommand || [candidate.command, ...candidate.args || []].join(" ");
-        fs48.writeFileSync(
+        fs50.writeFileSync(
           file2,
           `# refine validation failure
 # command: ${shown}
@@ -79116,18 +79667,18 @@ ${asText(streams.stderr)}
       return { enabled: false };
     }
     async function computeGitPatchId(cwd, fromRef, toRef, excludePaths = []) {
-      const { execFileSync: execFileSync13 } = await import("child_process");
+      const { execFileSync: execFileSync15 } = await import("child_process");
       const diffArgs = ["diff", "--patch", "--full-index", fromRef, toRef];
       if (excludePaths.length > 0) {
         diffArgs.push("--", ".", ...excludePaths.map((path58) => `:(exclude)${path58}`));
       }
-      const diff = execFileSync13(GIT4, diffArgs, {
+      const diff = execFileSync15(GIT4, diffArgs, {
         cwd,
         encoding: "utf8",
         maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
       });
       if (!diff.trim()) return "";
-      const patchId = execFileSync13(GIT4, ["patch-id", "--stable"], {
+      const patchId = execFileSync15(GIT4, ["patch-id", "--stable"], {
         cwd,
         input: diff,
         encoding: "utf8",
@@ -79138,8 +79689,8 @@ ${asText(streams.stderr)}
     async function runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead) {
       const startedAt = Date.now();
       try {
-        const { execFileSync: execFileSync13 } = await import("child_process");
-        const git3 = (args) => execFileSync13(GIT4, args, {
+        const { execFileSync: execFileSync15 } = await import("child_process");
+        const git3 = (args) => execFileSync15(GIT4, args, {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -79240,7 +79791,7 @@ ${e?.stderr || ""}`
         ...autoPublish !== void 0 ? { autoPublishSubmoduleMainCommits: autoPublish } : {}
       };
       try {
-        const git3 = (args) => (0, import_node_child_process11.execFileSync)(GIT4, args, {
+        const git3 = (args) => (0, import_node_child_process13.execFileSync)(GIT4, args, {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
@@ -79294,7 +79845,7 @@ ${e?.stderr || ""}`
             } catch {
               continue;
             }
-            const submoduleRepo = (0, import_path17.join)(repoRoot, p);
+            const submoduleRepo = (0, import_path18.join)(repoRoot, p);
             let fastForward;
             let reachableFromOriginMain;
             if (branchCommit) {
@@ -79365,7 +79916,7 @@ ${e?.stderr || ""}`
     }
     function execGitOk(cwd, args) {
       try {
-        (0, import_node_child_process11.execFileSync)(GIT4, args, { cwd, encoding: "utf8", maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES, windowsHide: true });
+        (0, import_node_child_process13.execFileSync)(GIT4, args, { cwd, encoding: "utf8", maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES, windowsHide: true });
         return true;
       } catch {
         return false;
@@ -79374,8 +79925,8 @@ ${e?.stderr || ""}`
     async function checkWorktreeChangesPatchEquivalentInRef(repoRoot, ref, worktreeHead) {
       const startedAt = Date.now();
       try {
-        const { execFileSync: execFileSync13 } = await import("child_process");
-        const git3 = (gitArgs) => execFileSync13(GIT4, gitArgs, {
+        const { execFileSync: execFileSync15 } = await import("child_process");
+        const git3 = (gitArgs) => execFileSync15(GIT4, gitArgs, {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -79438,8 +79989,8 @@ ${mergeTreeErr?.stderr || ""}`;
     async function runMeshRefineEffectiveDiffGate(repoRoot, baseHead, branchHead) {
       const startedAt = Date.now();
       try {
-        const { execFileSync: execFileSync13 } = await import("child_process");
-        const git3 = (args, opts) => execFileSync13(GIT4, args, {
+        const { execFileSync: execFileSync15 } = await import("child_process");
+        const git3 = (args, opts) => execFileSync15(GIT4, args, {
           cwd: opts?.cwd || repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -79513,45 +80064,8 @@ ${mergeTreeErr?.stderr || ""}`;
         ]
       };
     }
-    function readChangedGitlinkPaths(repoRoot, fromRef, toRef) {
-      try {
-        const output = (0, import_node_child_process11.execFileSync)(GIT4, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
-          cwd: repoRoot,
-          encoding: "utf8",
-          maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
-        });
-        const paths = /* @__PURE__ */ new Set();
-        for (const line of output.split("\n")) {
-          if (!line.trim()) continue;
-          const metaAndPath = line.split("	");
-          const meta3 = metaAndPath[0] || "";
-          const path58 = metaAndPath[metaAndPath.length - 1]?.trim();
-          if (!path58) continue;
-          const parts = meta3.split(/\s+/);
-          if (parts[0]?.includes("160000") || parts[1]?.includes("160000")) {
-            paths.add(path58);
-          }
-        }
-        return [...paths].sort();
-      } catch {
-        return [];
-      }
-    }
-    function readTreeObject(repoRoot, ref, path58) {
-      try {
-        const output = (0, import_node_child_process11.execFileSync)(GIT4, ["ls-tree", ref, "--", path58], {
-          cwd: repoRoot,
-          encoding: "utf8",
-          maxBuffer: 1024 * 1024
-        }).trim();
-        const match = output.match(/\bcommit\s+([0-9a-f]{40})\b/i);
-        return match?.[1];
-      } catch {
-        return void 0;
-      }
-    }
     function resolveGitDir(repoRoot) {
-      const out = (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", "--absolute-git-dir"], {
+      const out = (0, import_node_child_process13.execFileSync)(GIT4, ["rev-parse", "--absolute-git-dir"], {
         cwd: repoRoot,
         encoding: "utf8",
         maxBuffer: 1024 * 1024
@@ -79562,10 +80076,10 @@ ${mergeTreeErr?.stderr || ""}`;
       if (!baseCommit || !branchCommit) return false;
       if (baseCommit === branchCommit) return true;
       try {
-        if (!fs48.existsSync(submoduleRepoPath)) return false;
-        (0, import_node_child_process11.execFileSync)(GIT4, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
-        (0, import_node_child_process11.execFileSync)(GIT4, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
-        (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+        if (!fs50.existsSync(submoduleRepoPath)) return false;
+        (0, import_node_child_process13.execFileSync)(GIT4, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+        (0, import_node_child_process13.execFileSync)(GIT4, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+        (0, import_node_child_process13.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
         return true;
       } catch {
         return false;
@@ -79573,7 +80087,7 @@ ${mergeTreeErr?.stderr || ""}`;
     }
     function readChangedPathKinds(repoRoot, fromRef, toRef) {
       try {
-        const output = (0, import_node_child_process11.execFileSync)(GIT4, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
+        const output = (0, import_node_child_process13.execFileSync)(GIT4, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -79601,7 +80115,7 @@ ${mergeTreeErr?.stderr || ""}`;
         const baseCommit = readTreeObject(repoRoot, baseHead, path58);
         const branchCommit = readTreeObject(repoRoot, branchHead, path58);
         if (!baseCommit || !branchCommit) return false;
-        return isSubmoduleFastForward((0, import_path17.resolve)(repoRoot, path58), baseCommit, branchCommit);
+        return isSubmoduleFastForward((0, import_path18.resolve)(repoRoot, path58), baseCommit, branchCommit);
       });
     }
     function collectTrivialFastForwardGitlinkResolutions(worktreeRoot, baseRepoRoot, baseHead, branchHead) {
@@ -79610,8 +80124,8 @@ ${mergeTreeErr?.stderr || ""}`;
         const baseCommit = readTreeObject(baseRepoRoot, baseHead, path58);
         const branchCommit = readTreeObject(worktreeRoot, branchHead, path58);
         if (!baseCommit || !branchCommit) continue;
-        const submoduleRepoPath = (0, import_path17.resolve)(worktreeRoot, path58);
-        ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path17.resolve)(baseRepoRoot, path58), baseCommit);
+        const submoduleRepoPath = (0, import_path18.resolve)(worktreeRoot, path58);
+        ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path18.resolve)(baseRepoRoot, path58), baseCommit);
         if (baseCommit === branchCommit) {
           continue;
         }
@@ -79623,254 +80137,11 @@ ${mergeTreeErr?.stderr || ""}`;
       }
       return resolutions;
     }
-    function isSubmoduleDivergedSibling(submoduleRepoPath, baseCommit, branchCommit) {
-      if (!baseCommit || !branchCommit || baseCommit === branchCommit) return false;
-      try {
-        if (!fs48.existsSync(submoduleRepoPath)) return false;
-        (0, import_node_child_process11.execFileSync)(GIT4, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
-        (0, import_node_child_process11.execFileSync)(GIT4, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
-      } catch {
-        return false;
-      }
-      try {
-        (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
-        return false;
-      } catch {
-      }
-      try {
-        (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", "--is-ancestor", branchCommit, baseCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
-        return false;
-      } catch {
-      }
-      try {
-        const mb = (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", baseCommit, branchCommit], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
-        return !!mb;
-      } catch {
-        return false;
-      }
-    }
-    function resolveSubmoduleRemoteMainRef(submoduleRepoPath) {
-      try {
-        const sym = (0, import_node_child_process11.execFileSync)(GIT4, ["symbolic-ref", "-q", "refs/remotes/origin/HEAD"], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
-        if (sym) return sym;
-      } catch {
-      }
-      for (const branch of ["main", "master"]) {
-        try {
-          (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", "--verify", "-q", `refs/remotes/origin/${branch}`], { cwd: submoduleRepoPath, stdio: ["ignore", "pipe", "pipe"] });
-          return `refs/remotes/origin/${branch}`;
-        } catch {
-        }
-      }
-      return void 0;
-    }
-    function findEquivalentPublishedSubmoduleCommit(submoduleRepoPath, baseCommit, branchCommit, remoteRef) {
-      try {
-        const mergeTreeOut = (0, import_node_child_process11.execFileSync)(GIT4, ["merge-tree", "--write-tree", baseCommit, branchCommit], {
-          cwd: submoduleRepoPath,
-          encoding: "utf8",
-          stdio: ["ignore", "pipe", "pipe"]
-        });
-        const mergedTree = mergeTreeOut.trim().split(/\s+/)[0] || "";
-        if (!mergedTree) return void 0;
-        const candidates = (0, import_node_child_process11.execFileSync)(GIT4, ["rev-list", "--max-count=100", remoteRef, "--not", baseCommit], {
-          cwd: submoduleRepoPath,
-          encoding: "utf8"
-        }).split("\n").map((s2) => s2.trim()).filter(Boolean);
-        for (const candidate of candidates) {
-          try {
-            (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, candidate], { cwd: submoduleRepoPath, stdio: "ignore" });
-          } catch {
-            continue;
-          }
-          const tree = (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", `${candidate}^{tree}`], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
-          if (tree === mergedTree) return candidate;
-        }
-      } catch {
-      }
-      return void 0;
-    }
-    function ensureSubmoduleCommitLocal(submoduleRepoPath, baseSubmoduleRepoPath, commit) {
-      if (!commit) return;
-      try {
-        (0, import_node_child_process11.execFileSync)(GIT4, ["cat-file", "-e", `${commit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
-        return;
-      } catch {
-      }
-      try {
-        if (!fs48.existsSync(submoduleRepoPath) || !fs48.existsSync(baseSubmoduleRepoPath)) return;
-        (0, import_node_child_process11.execFileSync)(GIT4, ["-c", "protocol.file.allow=always", "fetch", "-q", baseSubmoduleRepoPath, "+refs/heads/*:refs/adhdev-refine-base/*"], {
-          cwd: submoduleRepoPath,
-          stdio: ["ignore", "ignore", "pipe"]
-        });
-      } catch {
-      }
-    }
-    function convergeDivergedSubmoduleGitlinks(worktreeRoot, baseRepoRoot, baseHead, branchHead) {
-      const changed = readChangedGitlinkPaths(worktreeRoot, baseHead, branchHead);
-      if (changed.length === 0) {
-        return { converged: false, reason: "no_changed_gitlinks", resolutions: [], gitlinks: [] };
-      }
-      const gitlinks = [];
-      const resolutions = [];
-      let sawDiverged = false;
-      for (const path58 of changed) {
-        const baseCommit = readTreeObject(baseRepoRoot, baseHead, path58);
-        const branchCommit = readTreeObject(worktreeRoot, branchHead, path58);
-        const submoduleRepoPath = (0, import_path17.resolve)(worktreeRoot, path58);
-        if (baseCommit) {
-          ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path17.resolve)(baseRepoRoot, path58), baseCommit);
-        }
-        if (!baseCommit || !branchCommit || !isSubmoduleDivergedSibling(submoduleRepoPath, baseCommit, branchCommit)) {
-          gitlinks.push({ path: path58, baseCommit, branchCommit, action: "skipped_not_diverged" });
-          continue;
-        }
-        sawDiverged = true;
-        try {
-          (0, import_node_child_process11.execFileSync)(GIT4, ["-c", "protocol.file.allow=always", "fetch", "-q", "origin"], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
-        } catch {
-        }
-        const remoteMainRef = resolveSubmoduleRemoteMainRef(submoduleRepoPath);
-        const publishedEquivalent = remoteMainRef ? findEquivalentPublishedSubmoduleCommit(submoduleRepoPath, baseCommit, branchCommit, remoteMainRef) : void 0;
-        if (publishedEquivalent) {
-          try {
-            (0, import_node_child_process11.execFileSync)(GIT4, ["checkout", "-q", "--detach", publishedEquivalent], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
-          } catch {
-          }
-          gitlinks.push({ path: path58, baseCommit, branchCommit, rebasedCommit: publishedEquivalent, action: "converged_to_published" });
-          resolutions.push({ path: path58, baseCommit, branchCommit, rebasedCommit: publishedEquivalent });
-          continue;
-        }
-        let rebasedCommit;
-        try {
-          (0, import_node_child_process11.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
-          (0, import_node_child_process11.execFileSync)(GIT4, ["rebase", baseCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "pipe", "pipe"] });
-          rebasedCommit = (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", "HEAD"], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
-        } catch {
-          try {
-            (0, import_node_child_process11.execFileSync)(GIT4, ["rebase", "--abort"], { cwd: submoduleRepoPath, stdio: "ignore" });
-          } catch {
-          }
-          try {
-            (0, import_node_child_process11.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
-          } catch {
-          }
-          gitlinks.push({ path: path58, baseCommit, branchCommit, action: "rebase_conflict" });
-          return { converged: false, reason: "rebase_conflict", resolutions: [], gitlinks };
-        }
-        const branchWorkSurvived = (() => {
-          if (!rebasedCommit) return false;
-          if (rebasedCommit === branchCommit) return true;
-          if (rebasedCommit === baseCommit) return false;
-          try {
-            const replayed = (0, import_node_child_process11.execFileSync)(GIT4, ["rev-list", "--count", `${baseCommit}..${rebasedCommit}`], {
-              cwd: submoduleRepoPath,
-              encoding: "utf8"
-            }).trim();
-            return Number.parseInt(replayed, 10) > 0;
-          } catch {
-            return false;
-          }
-        })();
-        if (!branchWorkSurvived) {
-          try {
-            (0, import_node_child_process11.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
-          } catch {
-          }
-          gitlinks.push({ path: path58, baseCommit, branchCommit, rebasedCommit, action: "rebase_dropped_branch_commits" });
-          return { converged: false, reason: "rebase_dropped_branch_commits", resolutions: [], gitlinks };
-        }
-        gitlinks.push({ path: path58, baseCommit, branchCommit, rebasedCommit, action: "rebased" });
-        resolutions.push({ path: path58, baseCommit, branchCommit, rebasedCommit });
-      }
-      if (!sawDiverged) {
-        return { converged: false, reason: "not_diverged", resolutions: [], gitlinks };
-      }
-      return { converged: resolutions.length > 0, resolutions, gitlinks };
-    }
-    function rootRebaseResolvingGitlinks(worktreeRoot, baseHead, resolutions) {
-      const resolveByPath = new Map(resolutions.map((r) => [r.path, r.rebasedCommit]));
-      const runRebase = (args) => {
-        try {
-          (0, import_node_child_process11.execFileSync)(GIT4, args, {
-            cwd: worktreeRoot,
-            stdio: ["ignore", "pipe", "pipe"],
-            // A rebase editor prompt would hang; keep it non-interactive.
-            env: { ...process.env, GIT_EDITOR: "true", GIT_SEQUENCE_EDITOR: "true" }
-          });
-          return { ok: true };
-        } catch {
-          return { ok: false };
-        }
-      };
-      const unmergedPaths = () => {
-        try {
-          return (0, import_node_child_process11.execFileSync)(GIT4, ["diff", "--name-only", "--diff-filter=U"], { cwd: worktreeRoot, encoding: "utf8" }).split("\n").map((s2) => s2.trim()).filter(Boolean);
-        } catch {
-          return [];
-        }
-      };
-      const abort = (reason, conflictPaths) => {
-        try {
-          (0, import_node_child_process11.execFileSync)(GIT4, ["rebase", "--abort"], { cwd: worktreeRoot, stdio: "ignore" });
-        } catch {
-        }
-        return { ok: false, reason, conflictPaths };
-      };
-      let progress = runRebase(["rebase", baseHead]);
-      let guard = 0;
-      while (!progress.ok) {
-        if (guard++ > 100) return abort("rebase_error");
-        const conflicts = unmergedPaths();
-        if (conflicts.length === 0) {
-          return abort("rebase_error");
-        }
-        const unresolvable = conflicts.filter((p) => !resolveByPath.has(p));
-        if (unresolvable.length > 0) {
-          const unresolvableGitlink = unresolvable.some((p) => {
-            try {
-              const staged = (0, import_node_child_process11.execFileSync)(GIT4, ["ls-files", "--stage", "--", p], { cwd: worktreeRoot, encoding: "utf8" });
-              return /^160000\s/m.test(staged);
-            } catch {
-              return false;
-            }
-          });
-          const allGitlink = unresolvable.every((p) => {
-            try {
-              const staged = (0, import_node_child_process11.execFileSync)(GIT4, ["ls-files", "--stage", "--", p], { cwd: worktreeRoot, encoding: "utf8" });
-              return /^160000\s/m.test(staged);
-            } catch {
-              return false;
-            }
-          });
-          return abort(allGitlink && unresolvableGitlink ? "unexpected_gitlink" : "non_gitlink_conflict", conflicts);
-        }
-        for (const p of conflicts) {
-          const commit = resolveByPath.get(p);
-          try {
-            (0, import_node_child_process11.execFileSync)(GIT4, ["checkout", "-q", "--detach", commit], { cwd: (0, import_path17.resolve)(worktreeRoot, p), stdio: "ignore" });
-          } catch {
-          }
-          try {
-            (0, import_node_child_process11.execFileSync)(GIT4, ["add", p], { cwd: worktreeRoot, stdio: "ignore" });
-          } catch {
-            return abort("rebase_error", conflicts);
-          }
-        }
-        progress = runRebase(["rebase", "--continue"]);
-      }
-      let branchHead;
-      try {
-        branchHead = (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", "HEAD"], { cwd: worktreeRoot, encoding: "utf8" }).trim();
-      } catch {
-      }
-      return { ok: true, branchHead };
-    }
     function evaluateGitlinkTrivialFastForward(repoRoot, baseHead, branchHead) {
       const changedGitlinks = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path58) => {
         const baseCommit = readTreeObject(repoRoot, baseHead, path58);
         const branchCommit = readTreeObject(repoRoot, branchHead, path58);
-        const submoduleRepoPath = (0, import_path17.resolve)(repoRoot, path58);
+        const submoduleRepoPath = (0, import_path18.resolve)(repoRoot, path58);
         const fastForward = !!baseCommit && !!branchCommit && isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit);
         return { path: path58, baseCommit, branchCommit, fastForward };
       });
@@ -79887,7 +80158,7 @@ ${mergeTreeErr?.stderr || ""}`;
       }
       let mergeBase = "";
       try {
-        mergeBase = (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", baseHead, branchHead], {
+        mergeBase = (0, import_node_child_process13.execFileSync)(GIT4, ["merge-base", baseHead, branchHead], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: 1024 * 1024
@@ -79917,7 +80188,7 @@ ${mergeTreeErr?.stderr || ""}`;
     }
     function buildTreeWithGitlinksEqualized(repoRoot, commitish, paths, placeholderCommit) {
       try {
-        const tree = (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", `${commitish}^{tree}`], {
+        const tree = (0, import_node_child_process13.execFileSync)(GIT4, ["rev-parse", `${commitish}^{tree}`], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: 1024 * 1024
@@ -79925,11 +80196,11 @@ ${mergeTreeErr?.stderr || ""}`;
         if (!tree) return void 0;
         const updates = paths.map((path58) => `160000 commit ${placeholderCommit}	${path58}`).join("\n");
         if (!updates) return tree;
-        const tmpIndex = (0, import_path17.join)(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
+        const tmpIndex = (0, import_path18.join)(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
         const env2 = { ...process.env, GIT_INDEX_FILE: tmpIndex };
         try {
-          (0, import_node_child_process11.execFileSync)(GIT4, ["read-tree", tree], { cwd: repoRoot, env: env2, stdio: "ignore" });
-          (0, import_node_child_process11.execFileSync)(GIT4, ["update-index", "--index-info"], {
+          (0, import_node_child_process13.execFileSync)(GIT4, ["read-tree", tree], { cwd: repoRoot, env: env2, stdio: "ignore" });
+          (0, import_node_child_process13.execFileSync)(GIT4, ["update-index", "--index-info"], {
             cwd: repoRoot,
             env: env2,
             input: `${updates}
@@ -79937,11 +80208,11 @@ ${mergeTreeErr?.stderr || ""}`;
             encoding: "utf8",
             stdio: ["pipe", "ignore", "ignore"]
           });
-          const newTree = (0, import_node_child_process11.execFileSync)(GIT4, ["write-tree"], { cwd: repoRoot, env: env2, encoding: "utf8" }).trim();
+          const newTree = (0, import_node_child_process13.execFileSync)(GIT4, ["write-tree"], { cwd: repoRoot, env: env2, encoding: "utf8" }).trim();
           return newTree || void 0;
         } finally {
           try {
-            fs48.rmSync(tmpIndex, { force: true });
+            fs50.rmSync(tmpIndex, { force: true });
           } catch {
           }
         }
@@ -79953,7 +80224,7 @@ ${mergeTreeErr?.stderr || ""}`;
       try {
         const branchGitlinks = gitlinks.filter((entry) => entry.branchCommit);
         const gitlinkPaths = branchGitlinks.map((entry) => entry.path);
-        const mergeBase = (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", baseHead, branchHead], {
+        const mergeBase = (0, import_node_child_process13.execFileSync)(GIT4, ["merge-base", baseHead, branchHead], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: 1024 * 1024
@@ -79966,22 +80237,22 @@ ${mergeTreeErr?.stderr || ""}`;
           const theirsEqTree = buildTreeWithGitlinksEqualized(repoRoot, branchHead, gitlinkPaths, placeholder);
           if (baseEqTree && oursEqTree && theirsEqTree) {
             try {
-              const baseEqCommit = (0, import_node_child_process11.execFileSync)(GIT4, ["commit-tree", baseEqTree, "-m", "refine-ff-base"], {
+              const baseEqCommit = (0, import_node_child_process13.execFileSync)(GIT4, ["commit-tree", baseEqTree, "-m", "refine-ff-base"], {
                 cwd: repoRoot,
                 encoding: "utf8",
                 maxBuffer: 1024 * 1024
               }).trim();
-              const oursEqCommit = (0, import_node_child_process11.execFileSync)(GIT4, ["commit-tree", oursEqTree, "-p", baseEqCommit, "-m", "refine-ff-ours"], {
+              const oursEqCommit = (0, import_node_child_process13.execFileSync)(GIT4, ["commit-tree", oursEqTree, "-p", baseEqCommit, "-m", "refine-ff-ours"], {
                 cwd: repoRoot,
                 encoding: "utf8",
                 maxBuffer: 1024 * 1024
               }).trim();
-              const theirsEqCommit = (0, import_node_child_process11.execFileSync)(GIT4, ["commit-tree", theirsEqTree, "-p", baseEqCommit, "-m", "refine-ff-theirs"], {
+              const theirsEqCommit = (0, import_node_child_process13.execFileSync)(GIT4, ["commit-tree", theirsEqTree, "-p", baseEqCommit, "-m", "refine-ff-theirs"], {
                 cwd: repoRoot,
                 encoding: "utf8",
                 maxBuffer: 1024 * 1024
               }).trim();
-              const mergeOut = (0, import_node_child_process11.execFileSync)(GIT4, ["merge-tree", "--write-tree", oursEqCommit, theirsEqCommit], {
+              const mergeOut = (0, import_node_child_process13.execFileSync)(GIT4, ["merge-tree", "--write-tree", oursEqCommit, theirsEqCommit], {
                 cwd: repoRoot,
                 encoding: "utf8",
                 maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -79992,7 +80263,7 @@ ${mergeTreeErr?.stderr || ""}`;
             }
           }
         }
-        const contentTree = mergedContentTree || (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", `${baseHead}^{tree}`], {
+        const contentTree = mergedContentTree || (0, import_node_child_process13.execFileSync)(GIT4, ["rev-parse", `${baseHead}^{tree}`], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: 1024 * 1024
@@ -80000,11 +80271,11 @@ ${mergeTreeErr?.stderr || ""}`;
         if (!contentTree) return void 0;
         const updates = branchGitlinks.map((entry) => `160000 commit ${entry.branchCommit}	${entry.path}`).join("\n");
         if (!updates) return contentTree;
-        const tmpIndex = (0, import_path17.join)(resolveGitDir(repoRoot), `adhdev-refine-ff-${baseHead.slice(0, 12)}-${branchHead.slice(0, 12)}.index`);
+        const tmpIndex = (0, import_path18.join)(resolveGitDir(repoRoot), `adhdev-refine-ff-${baseHead.slice(0, 12)}-${branchHead.slice(0, 12)}.index`);
         const env2 = { ...process.env, GIT_INDEX_FILE: tmpIndex };
         try {
-          (0, import_node_child_process11.execFileSync)(GIT4, ["read-tree", contentTree], { cwd: repoRoot, env: env2, stdio: "ignore" });
-          (0, import_node_child_process11.execFileSync)(GIT4, ["update-index", "--index-info"], {
+          (0, import_node_child_process13.execFileSync)(GIT4, ["read-tree", contentTree], { cwd: repoRoot, env: env2, stdio: "ignore" });
+          (0, import_node_child_process13.execFileSync)(GIT4, ["update-index", "--index-info"], {
             cwd: repoRoot,
             env: env2,
             input: `${updates}
@@ -80012,11 +80283,11 @@ ${mergeTreeErr?.stderr || ""}`;
             encoding: "utf8",
             stdio: ["pipe", "ignore", "ignore"]
           });
-          const newTree = (0, import_node_child_process11.execFileSync)(GIT4, ["write-tree"], { cwd: repoRoot, env: env2, encoding: "utf8" }).trim();
+          const newTree = (0, import_node_child_process13.execFileSync)(GIT4, ["write-tree"], { cwd: repoRoot, env: env2, encoding: "utf8" }).trim();
           return newTree || void 0;
         } finally {
           try {
-            fs48.rmSync(tmpIndex, { force: true });
+            fs50.rmSync(tmpIndex, { force: true });
           } catch {
           }
         }
@@ -80128,7 +80399,7 @@ ${mergeTreeErr?.stderr || ""}`;
           return { stdout: String(stdout || ""), stderr: String(stderr || ""), refspec };
         };
         const importCommitFromWorktreeSubmodule = async (submodulePath, worktreeSubmodulePath, commit) => {
-          if (!fs48.existsSync(worktreeSubmodulePath)) return false;
+          if (!fs50.existsSync(worktreeSubmodulePath)) return false;
           try {
             await runGit3(worktreeSubmodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
           } catch {
@@ -80157,7 +80428,7 @@ ${mergeTreeErr?.stderr || ""}`;
           return match ? { commit: match[1], path: match[2] } : null;
         }).filter((entry) => !!entry);
         for (const gitlink of gitlinks) {
-          const submodulePath = (0, import_path17.resolve)(repoRoot, gitlink.path);
+          const submodulePath = (0, import_path18.resolve)(repoRoot, gitlink.path);
           const entry = {
             path: gitlink.path,
             commit: gitlink.commit,
@@ -80165,7 +80436,7 @@ ${mergeTreeErr?.stderr || ""}`;
           };
           let submoduleDefaultBranch = "main";
           try {
-            if (!fs48.existsSync(submodulePath)) {
+            if (!fs50.existsSync(submodulePath)) {
               entry.error = `Submodule checkout missing at ${gitlink.path}`;
               entry.publishRequired = true;
               if (options.allowAutoPublishSubmoduleMainCommits === true) {
@@ -80184,7 +80455,7 @@ ${mergeTreeErr?.stderr || ""}`;
               entry.localReachable = false;
               if (options.allowAutoPublishSubmoduleMainCommits === true && options.worktreeRoot) {
                 try {
-                  const imported = await importCommitFromWorktreeSubmodule(submodulePath, (0, import_path17.resolve)(options.worktreeRoot, gitlink.path), gitlink.commit);
+                  const imported = await importCommitFromWorktreeSubmodule(submodulePath, (0, import_path18.resolve)(options.worktreeRoot, gitlink.path), gitlink.commit);
                   if (imported) {
                     entry.localReachable = true;
                     entry.importedFromWorktree = true;
@@ -80414,13 +80685,13 @@ ${mergeTreeErr?.stderr || ""}`;
         ...extras
       });
       const isPackageManagerValidation = (candidate) => {
-        const command = (0, import_path17.basename)(candidate.command).replace(/\.(?:cmd|exe)$/i, "");
+        const command = (0, import_path18.basename)(candidate.command).replace(/\.(?:cmd|exe)$/i, "");
         return ["npm", "pnpm", "yarn", "bun"].includes(command) && candidate.args.some((arg) => arg === "run" || arg === "test" || arg === "exec");
       };
       const dependenciesLikelyMissing = (cwd) => {
-        if (!fs48.existsSync((0, import_path17.join)(cwd, "package.json"))) return false;
-        if (fs48.existsSync((0, import_path17.join)(cwd, "node_modules"))) return false;
-        return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs48.existsSync((0, import_path17.join)(cwd, lock)));
+        if (!fs50.existsSync((0, import_path18.join)(cwd, "package.json"))) return false;
+        if (fs50.existsSync((0, import_path18.join)(cwd, "node_modules"))) return false;
+        return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs50.existsSync((0, import_path18.join)(cwd, lock)));
       };
       const needsNodeModules = (candidate, cwd) => isPackageManagerValidation(candidate) && dependenciesLikelyMissing(cwd);
       const isDaemonScopedCommand = (candidate) => {
@@ -80487,7 +80758,7 @@ ${mergeTreeErr?.stderr || ""}`;
         summary.bootstrap = { stage: "legacy" };
         for (const candidate of selection.bootstrapCommands) {
           const startedAt = Date.now();
-          const cwd = candidate.cwd ? (0, import_path17.resolve)(workspace, candidate.cwd) : workspace;
+          const cwd = candidate.cwd ? (0, import_path18.resolve)(workspace, candidate.cwd) : workspace;
           const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
           const resolvedCommand = resolveWin32Executable(candidate.command);
           const spawn7 = buildWin32ExecFileSpawn(resolvedCommand, candidate.args);
@@ -80520,7 +80791,7 @@ ${mergeTreeErr?.stderr || ""}`;
       let missingDepsBlocked = false;
       for (const candidate of commandsToRun) {
         const startedAt = Date.now();
-        const cwd = candidate.cwd ? (0, import_path17.resolve)(workspace, candidate.cwd) : workspace;
+        const cwd = candidate.cwd ? (0, import_path18.resolve)(workspace, candidate.cwd) : workspace;
         const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
         const bootstrapProvidedDependencies = summary.bootstrap?.stage === "cached" || summary.bootstrap?.stage === "ran" || summary.bootstrap?.stage === "legacy";
         if (!bootstrapProvidedDependencies && needsNodeModules(candidate, cwd)) {
@@ -80587,16 +80858,14 @@ ${mergeTreeErr?.stderr || ""}`;
       summary.status = "passed";
       return summary;
     }
-    var import_path17;
-    var fs48;
-    var import_node_child_process11;
-    var GIT4;
+    var import_path18;
+    var fs50;
+    var import_node_child_process13;
     var REFINE_VALIDATION_TIMEOUT_MS;
     var REFINE_VALIDATION_OUTPUT_LIMIT_BYTES;
     var REFINE_VALIDATION_SUMMARY_HEAD_CHARS;
     var REFINE_VALIDATION_SUMMARY_TAIL_CHARS;
     var REFINE_VALIDATION_SUMMARY_CHARS;
-    var REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES;
     var REFINE_VALIDATION_LOG_DIR;
     var init_mesh_refine_gates = __esm2({
       "src/mesh/mesh-refine-gates.ts"() {
@@ -80604,19 +80873,19 @@ ${mergeTreeErr?.stderr || ""}`;
         init_git_status();
         init_refine_config();
         init_worktree_bootstrap_config();
-        import_path17 = require("path");
-        fs48 = __toESM2(require("fs"));
-        import_node_child_process11 = require("child_process");
+        import_path18 = require("path");
+        fs50 = __toESM2(require("fs"));
+        import_node_child_process13 = require("child_process");
         init_resolve_executable();
         init_mesh_refine_worker_cap();
-        GIT4 = process.platform === "win32" ? resolveWin32Executable("git") : "git";
+        init_mesh_refine_gitlink_utils();
+        init_mesh_refine_submodule_converge();
         REFINE_VALIDATION_TIMEOUT_MS = 12e4;
         REFINE_VALIDATION_OUTPUT_LIMIT_BYTES = 128 * 1024;
         REFINE_VALIDATION_SUMMARY_HEAD_CHARS = 2e3;
         REFINE_VALIDATION_SUMMARY_TAIL_CHARS = 6e3;
         REFINE_VALIDATION_SUMMARY_CHARS = REFINE_VALIDATION_SUMMARY_HEAD_CHARS + REFINE_VALIDATION_SUMMARY_TAIL_CHARS;
-        REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES = 4 * 1024 * 1024;
-        REFINE_VALIDATION_LOG_DIR = (0, import_path17.join)(".adhdev", "logs");
+        REFINE_VALIDATION_LOG_DIR = (0, import_path18.join)(".adhdev", "logs");
       }
     });
     function findOpenRefineDispatchForNode(args) {
@@ -81303,6 +81572,9 @@ ${mergeTreeErr?.stderr || ""}`;
               convergeReason: converge.reason,
               gitlinks: converge.gitlinks
             });
+            if (converge.reason === "submodule_commit_unavailable") {
+              LOG2.warn("Mesh", `[Refinery] Could NOT determine submodule gitlink divergence for node ${node.id} \u2014 a gitlink commit is missing from the local submodule object store (auto-converge could not run): ` + converge.gitlinks.filter((g) => g.action === "skipped_commit_unavailable").map((g) => `${g.path} (missing: ${(g.unavailable || []).join("+") || "unknown"}; base=${(g.baseCommit || "?").slice(0, 12)} branch=${(g.branchCommit || "?").slice(0, 12)})`).join(", "));
+            }
             recordMeshRefineStage(refineStages, "sync_base", "passed", syncStarted, {
               ahead: divergence.ahead,
               behind: divergence.behind,
@@ -81345,12 +81617,12 @@ ${mergeTreeErr?.stderr || ""}`;
             throw err;
           }
         } else {
-          (0, import_node_child_process12.execFileSync)("git", ["rebase", baseHead], { cwd: node.workspace, stdio: ["ignore", "pipe", "pipe"] });
+          (0, import_node_child_process14.execFileSync)("git", ["rebase", baseHead], { cwd: node.workspace, stdio: ["ignore", "pipe", "pipe"] });
         }
       } catch (rebaseErr) {
         if (!rebaseErr?.alreadyAborted) {
           try {
-            (0, import_node_child_process12.execFileSync)("git", ["rebase", "--abort"], { cwd: node.workspace, stdio: "ignore" });
+            (0, import_node_child_process14.execFileSync)("git", ["rebase", "--abort"], { cwd: node.workspace, stdio: "ignore" });
           } catch {
           }
         }
@@ -82804,7 +83076,7 @@ ${e?.stderr || ""}`;
         if (!repoRoot || !workspace) return;
         const branch = typeof node?.worktreeBranch === "string" && node.worktreeBranch.trim() ? node.worktreeBranch.trim() : (() => {
           try {
-            return (0, import_node_child_process12.execFileSync)("git", ["branch", "--show-current"], { cwd: workspace, encoding: "utf8" }).trim();
+            return (0, import_node_child_process14.execFileSync)("git", ["branch", "--show-current"], { cwd: workspace, encoding: "utf8" }).trim();
           } catch {
             return "";
           }
@@ -82812,7 +83084,7 @@ ${e?.stderr || ""}`;
         if (!branch) return;
         const baseBranch = (() => {
           try {
-            return (0, import_node_child_process12.execFileSync)("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" }).trim() || "main";
+            return (0, import_node_child_process14.execFileSync)("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" }).trim() || "main";
           } catch {
             return "main";
           }
@@ -82880,13 +83152,13 @@ ${e?.stderr || ""}`;
       });
       return handle;
     }
-    var import_node_child_process12;
+    var import_node_child_process14;
     var import_node_fs9;
     var RETRYABLE_BASE_MOVEMENT_CODES;
     var init_router_refine = __esm2({
       "src/commands/router-refine.ts"() {
         "use strict";
-        import_node_child_process12 = require("child_process");
+        import_node_child_process14 = require("child_process");
         import_node_fs9 = require("fs");
         init_logger();
         init_debug_trace();
@@ -83053,6 +83325,7 @@ ${e?.stderr || ""}`;
       WORKSPACE_OWNER_GIT_CONFIG_KEY: () => WORKSPACE_OWNER_GIT_CONFIG_KEY,
       WORKSPACE_SAGA_LEASE_MS: () => WORKSPACE_SAGA_LEASE_MS,
       WorkspaceSagaPermanentError: () => WorkspaceSagaPermanentError,
+      abandonMeshGraphGate: () => abandonMeshGraphGate,
       addNode: () => addNode,
       appendLedgerEntry: () => appendLedgerEntry,
       appendRecentActivity: () => appendRecentActivity,
@@ -83126,6 +83399,7 @@ ${e?.stderr || ""}`;
       configureDebugTraceStore: () => configureDebugTraceStore,
       connectCdpManager: () => connectCdpManager,
       consoleSymbols: () => consoleSymbols,
+      coordinatorGateAbandonedReason: () => coordinatorGateAbandonedReason,
       coordinatorGateBlockReason: () => coordinatorGateBlockReason,
       coordinatorIdentityFromEmitFields: () => coordinatorIdentityFromEmitFields,
       createDebugTraceStore: () => createDebugTraceStore,
@@ -83390,6 +83664,7 @@ ${e?.stderr || ""}`;
       recordGraphEnqueueCommitted: () => recordGraphEnqueueCommitted,
       recordGraphEnqueueRolledBack: () => recordGraphEnqueueRolledBack,
       recordGraphEnqueueValidationFailed: () => recordGraphEnqueueValidationFailed,
+      recordGraphGateAbandoned: () => recordGraphGateAbandoned,
       recordGraphGateClaimed: () => recordGraphGateClaimed,
       recordGraphGateExpired: () => recordGraphGateExpired,
       recordGraphGateReleased: () => recordGraphGateReleased,
@@ -86551,8 +86826,25 @@ ${e?.stderr || ""}`;
         });
         const nodeStates = {};
         for (const node of nodes) nodeStates[node.state] = (nodeStates[node.state] ?? 0) + 1;
+        const orphanedGateIds = /* @__PURE__ */ new Set();
+        for (const gate of gates) {
+          if (gate.state !== "awaiting_coordinator" && gate.state !== "claimed" && gate.state !== "expired") continue;
+          const downstream = edges.filter((e) => e.fromNodeId === gate.nodeId).map((e) => byId.get(e.toNodeId)).filter((n) => !!n);
+          if (downstream.length === 0) continue;
+          if (downstream.every((n) => n.state === "cancelled" || n.state === "failed" || n.state === "skipped")) {
+            orphanedGateIds.add(gate.gateId);
+          }
+        }
         const actions = [];
         for (const gate of gateViews) {
+          if (orphanedGateIds.has(gate.gateId)) {
+            actions.push({
+              kind: "gate_abandon",
+              gateId: gate.gateId,
+              detail: `Gate '${gate.ref ?? gate.gateId}' (${gate.action}) is ORPHANED: every task it was gating is already cancelled, failed or skipped, so releasing it would open nothing. While it stays unsettled this graph cannot reach ANY terminal state \u2014 not even cancelled. Close it with mesh_graph_gate_abandon and a reason. Abandon cancels what the gate was holding; it never passes the gate.`
+            });
+            continue;
+          }
           if (gate.state === "awaiting_coordinator") {
             actions.push({
               kind: "gate_awaiting",
@@ -86575,7 +86867,7 @@ ${e?.stderr || ""}`;
             actions.push({
               kind: "gate_reclaim",
               gateId: gate.gateId,
-              detail: `Gate '${gate.ref ?? gate.gateId}' passed its deadline under on_timeout=hold \u2014 downstream is still held. Reclaim it (optionally with extend_deadline_seconds) to resume, or cancel the branch explicitly. A timeout is never passage: the gate cannot release itself.`
+              detail: `Gate '${gate.ref ?? gate.gateId}' passed its deadline under on_timeout=hold \u2014 downstream is still held. Reclaim it with mesh_graph_gate_claim (optionally with extend_deadline_seconds) to resume, or give it up with mesh_graph_gate_abandon, which cancels what it was holding instead of opening it. A timeout is never passage: the gate cannot release itself.`
             });
           }
         }
@@ -95210,7 +95502,7 @@ ${effect.notification.body || ""}`.trim();
         if (!["cli", "ide", "extension", "acp"].includes(category)) {
           return { success: false, error: `unknown category: ${category}` };
         }
-        const fs59 = require("fs");
+        const fs61 = require("fs");
         const path58 = require("path");
         try {
           const installRoot = this.getUpstreamInstallRoot();
@@ -95219,10 +95511,10 @@ ${effect.notification.body || ""}`.trim();
           if (!targetDir.startsWith(installRootResolved + path58.sep)) {
             return { success: false, error: "refusing to delete outside upstream root" };
           }
-          if (!fs59.existsSync(targetDir)) {
+          if (!fs61.existsSync(targetDir)) {
             return { success: false, error: "not installed" };
           }
-          fs59.rmSync(targetDir, { recursive: true, force: true });
+          fs61.rmSync(targetDir, { recursive: true, force: true });
           try {
             this._ctx.providerLoader?.deactivateVerifiedChannel?.(type2);
           } catch {
@@ -95242,28 +95534,28 @@ ${effect.notification.body || ""}`.trim();
        * the UI and by the update checker.
        */
       handleListInstalledProviders(_args) {
-        const fs59 = require("fs");
+        const fs61 = require("fs");
         const path58 = require("path");
         const installRoot = this.getUpstreamInstallRoot();
-        if (!fs59.existsSync(installRoot)) return { success: true, providers: [] };
+        if (!fs61.existsSync(installRoot)) return { success: true, providers: [] };
         const CATEGORIES = ["cli", "ide", "extension", "acp"];
         const items = [];
         for (const category of CATEGORIES) {
           const categoryDir = path58.join(installRoot, category);
-          if (!fs59.existsSync(categoryDir)) continue;
+          if (!fs61.existsSync(categoryDir)) continue;
           let entries;
           try {
-            entries = fs59.readdirSync(categoryDir);
+            entries = fs61.readdirSync(categoryDir);
           } catch {
             continue;
           }
           for (const type2 of entries) {
             const v1Path = path58.join(categoryDir, type2, "provider.v1.json");
             const v0Path = path58.join(categoryDir, type2, "provider.json");
-            const manifestPath = fs59.existsSync(v1Path) ? v1Path : fs59.existsSync(v0Path) ? v0Path : null;
+            const manifestPath = fs61.existsSync(v1Path) ? v1Path : fs61.existsSync(v0Path) ? v0Path : null;
             if (!manifestPath) continue;
             try {
-              const m = JSON.parse(fs59.readFileSync(manifestPath, "utf-8"));
+              const m = JSON.parse(fs61.readFileSync(manifestPath, "utf-8"));
               const modelOptions = Array.isArray(m.modelOptions) ? m.modelOptions.filter((x) => typeof x === "string" && !!x.trim()) : [];
               const thinkingLevelOptions = Array.isArray(m.thinkingLevelOptions) ? m.thinkingLevelOptions.filter((x) => typeof x === "string" && !!x.trim()) : [];
               items.push({
@@ -95484,7 +95776,7 @@ ${effect.notification.body || ""}`.trim();
         if (!/^@[a-z0-9_-]+$/i.test(requestedName)) {
           return { success: false, error: "name must match @[a-z0-9_-]+" };
         }
-        const fs59 = require("fs");
+        const fs61 = require("fs");
         const path58 = require("path");
         const { spawnSync: spawnSync3 } = require("child_process");
         const file2 = ext.loadExternalSources();
@@ -95495,8 +95787,8 @@ ${effect.notification.body || ""}`.trim();
           return { success: false, error: `source url+ref already registered (use a different name to track another ref)` };
         }
         const sourceDir = path58.join(ext.externalRoot(), requestedName);
-        if (!fs59.existsSync(ext.externalRoot())) fs59.mkdirSync(ext.externalRoot(), { recursive: true });
-        if (fs59.existsSync(sourceDir)) {
+        if (!fs61.existsSync(ext.externalRoot())) fs61.mkdirSync(ext.externalRoot(), { recursive: true });
+        if (fs61.existsSync(sourceDir)) {
           return { success: false, error: `directory already exists: ${sourceDir} (rename or remove first)` };
         }
         const clone2 = spawnSync3("git", ["clone", "--depth=1", "--branch", ref, "--", url2, sourceDir], {
@@ -95506,7 +95798,7 @@ ${effect.notification.body || ""}`.trim();
         });
         if (clone2.status !== 0) {
           try {
-            fs59.rmSync(sourceDir, { recursive: true, force: true });
+            fs61.rmSync(sourceDir, { recursive: true, force: true });
           } catch {
           }
           return { success: false, error: `git clone failed: ${(clone2.stderr || clone2.stdout || "").trim() || "unknown error"}` };
@@ -95550,15 +95842,15 @@ ${effect.notification.body || ""}`.trim();
         const name = typeof args?.name === "string" ? args.name.trim() : "";
         if (!name) return { success: false, error: "name is required" };
         const ext = (init_external_sources(), __toCommonJS2(external_sources_exports));
-        const fs59 = require("fs");
+        const fs61 = require("fs");
         const path58 = require("path");
         const file2 = ext.loadExternalSources();
         const match = file2.sources.find((s2) => s2.name === name);
         if (!match) return { success: false, error: `source "${name}" not registered` };
         const sourceDir = path58.join(ext.externalRoot(), name);
-        if (fs59.existsSync(sourceDir)) {
+        if (fs61.existsSync(sourceDir)) {
           try {
-            fs59.rmSync(sourceDir, { recursive: true, force: true });
+            fs61.rmSync(sourceDir, { recursive: true, force: true });
           } catch (e) {
             return { success: false, error: `failed to delete ${sourceDir}: ${e?.message || e}` };
           }
@@ -97885,14 +98177,14 @@ ${marker}`,
         }
       },
       list_coordinator_prompts: async (_ctx, _args) => {
-        const fs59 = await import("fs");
+        const fs61 = await import("fs");
         const path58 = await import("path");
         const { getConfigDir: getConfigDir22 } = await Promise.resolve().then(() => (init_config(), config_exports));
         const dir = path58.join(getConfigDir22(), "coordinator-prompts");
         const entries = {};
         try {
-          if (fs59.existsSync(dir)) {
-            for (const name of fs59.readdirSync(dir)) {
+          if (fs61.existsSync(dir)) {
+            for (const name of fs61.readdirSync(dir)) {
               const matchOverride = name.match(/^([a-zA-Z0-9_.-]+)\.md$/);
               const matchAppend = name.match(/^([a-zA-Z0-9_.-]+)\.append\.md$/);
               const m = matchAppend || matchOverride;
@@ -97902,7 +98194,7 @@ ${marker}`,
               const full = path58.join(dir, name);
               let content = "";
               try {
-                content = fs59.readFileSync(full, "utf8");
+                content = fs61.readFileSync(full, "utf8");
               } catch {
               }
               if (!entries[key2]) entries[key2] = { override: "", append: "" };
@@ -97916,7 +98208,7 @@ ${marker}`,
         return { success: true, dir, entries };
       },
       write_coordinator_prompt: async (_ctx, args) => {
-        const fs59 = await import("fs");
+        const fs61 = await import("fs");
         const path58 = await import("path");
         const { getConfigDir: getConfigDir22 } = await Promise.resolve().then(() => (init_config(), config_exports));
         const key2 = typeof args?.key === "string" ? args.key.trim() : "";
@@ -97929,11 +98221,11 @@ ${marker}`,
         const filename = kind === "append" ? `${key2}.append.md` : `${key2}.md`;
         const full = path58.join(dir, filename);
         try {
-          fs59.mkdirSync(dir, { recursive: true });
+          fs61.mkdirSync(dir, { recursive: true });
           if (content.trim()) {
-            fs59.writeFileSync(full, content, { encoding: "utf8", mode: 384 });
-          } else if (fs59.existsSync(full)) {
-            fs59.unlinkSync(full);
+            fs61.writeFileSync(full, content, { encoding: "utf8", mode: 384 });
+          } else if (fs61.existsSync(full)) {
+            fs61.unlinkSync(full);
           }
           return { success: true, path: full, kind, key: key2 };
         } catch (error48) {
@@ -116161,7 +116453,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
         if (providerDir) {
           try {
-            const fs59 = require("fs");
+            const fs61 = require("fs");
             const path58 = require("path");
             const candidates = [];
             if (Array.isArray(base.compatibility)) {
@@ -116173,13 +116465,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
             }
             candidates.push(path58.join(providerDir, "specs", "default.json"));
             candidates.push(path58.join(providerDir, "spec.json"));
-            const specPath = candidates.find((p) => fs59.existsSync(p));
+            const specPath = candidates.find((p) => fs61.existsSync(p));
             let nh;
             if (specPath) {
               resolved._resolvedSpecPath = specPath;
               let specControls;
               try {
-                const rawSpec = JSON.parse(fs59.readFileSync(specPath, "utf8"));
+                const rawSpec = JSON.parse(fs61.readFileSync(specPath, "utf8"));
                 specControls = rawSpec.control_bar;
                 nh = rawSpec.native_history;
               } catch {
@@ -116222,7 +116514,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 }
               } else if (nh.override_path) {
                 const overrideFile = path58.resolve(providerDir, nh.override_path);
-                if (fs59.existsSync(overrideFile)) {
+                if (fs61.existsSync(overrideFile)) {
                   try {
                     registerProviderScriptRootSafely(path58.dirname(path58.dirname(providerDir)));
                     delete require.cache[require.resolve(overrideFile)];
@@ -117139,7 +117431,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         }
       } else if (plat === "win32") {
         try {
-          const fs59 = require("fs");
+          const fs61 = require("fs");
           const appNameMap = getMacAppIdentifiers();
           const appName = appNameMap[ideId];
           if (appName) {
@@ -117148,8 +117440,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
               appName,
               "storage.json"
             );
-            if (fs59.existsSync(storagePath)) {
-              const data = JSON.parse(fs59.readFileSync(storagePath, "utf-8"));
+            if (fs61.existsSync(storagePath)) {
+              const data = JSON.parse(fs61.readFileSync(storagePath, "utf-8"));
               const workspaces = data?.openedPathsList?.workspaces3 || data?.openedPathsList?.entries || [];
               if (workspaces.length > 0) {
                 const recent = workspaces[0];
@@ -117839,7 +118131,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             normalizeRepoMeshDeclarativeConfig: normalizeRepoMeshDeclarativeConfig2,
             MESH_JSON_CONFIG_LOCATIONS: MESH_JSON_CONFIG_LOCATIONS2
           } = await Promise.resolve().then(() => (init_mesh_json_config(), mesh_json_config_exports));
-          const { existsSync: existsSync67, readFileSync: readFileSync55, mkdirSync: mkdirSync31, writeFileSync: writeFileSync31 } = await import("fs");
+          const { existsSync: existsSync69, readFileSync: readFileSync55, mkdirSync: mkdirSync31, writeFileSync: writeFileSync31 } = await import("fs");
           const { dirname: dirname24, join: join67 } = await import("path");
           const yaml6 = await Promise.resolve().then(() => (init_js_yaml(), js_yaml_exports));
           const relativePath = MESH_JSON_CONFIG_LOCATIONS2[0];
@@ -117848,7 +118140,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           let existedAsYaml = false;
           for (const relative8 of MESH_JSON_CONFIG_LOCATIONS2) {
             const candidate = join67(workspace, relative8);
-            if (!existsSync67(candidate)) continue;
+            if (!existsSync69(candidate)) continue;
             try {
               const text = readFileSync55(candidate, "utf-8");
               const parsed = /\.json$/i.test(candidate) ? JSON.parse(text) : yaml6.load(text);
@@ -120162,7 +120454,7 @@ ${ptyResult.output.slice(-2e3)}`);
               workspace
             };
           }
-          const { existsSync: existsSync67, readFileSync: readFileSync55, writeFileSync: writeFileSync31, copyFileSync: copyFileSync3, mkdirSync: mkdirSync31 } = await import("fs");
+          const { existsSync: existsSync69, readFileSync: readFileSync55, writeFileSync: writeFileSync31, copyFileSync: copyFileSync3, mkdirSync: mkdirSync31 } = await import("fs");
           const { dirname: dirname24 } = await import("path");
           const mcpConfigPath = coordinatorSetup.configPath;
           const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
@@ -120207,7 +120499,7 @@ ${ptyResult.output.slice(-2e3)}`);
             if (hermesManualFallback) return returnManualFallback(message);
             return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
           }
-          const hadExistingMcpConfig = existsSync67(mcpConfigPath);
+          const hadExistingMcpConfig = existsSync69(mcpConfigPath);
           let existingMcpConfig = hermesBaseConfig?.config || {};
           if (hermesBaseConfig) {
             copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname24(mcpConfigPath));
@@ -121008,7 +121300,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const { deriveMeshReviewInboxItems: deriveMeshReviewInboxItems2 } = await Promise.resolve().then(() => (init_mesh_review_inbox(), mesh_review_inbox_exports));
           const { readLedgerEntries: readLedgerEntries2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
           const { getGitDiffSummary: getGitDiffSummary2 } = await Promise.resolve().then(() => (init_git_diff(), git_diff_exports));
-          const { existsSync: existsSync67 } = await import("fs");
+          const { existsSync: existsSync69 } = await import("fs");
           const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
           const mesh = meshRecord?.mesh;
           if (!mesh) return { success: false, error: "Mesh not found" };
@@ -121027,7 +121319,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const derivation = deriveMeshReviewInboxItems2({ nodes: nodeStatuses, ledgerEntries });
           for (const item of derivation.items) {
             const workspace = item.workspace;
-            if (!workspace || !existsSync67(workspace)) continue;
+            if (!workspace || !existsSync69(workspace)) continue;
             const baseRef = item.defaultBranch ? `origin/${item.defaultBranch}` : "origin/main";
             try {
               const diffResult = await getGitDiffSummary2(workspace, { baseRef, maxFiles: 100 });
@@ -121222,12 +121514,12 @@ ${ptyResult.output.slice(-2e3)}`);
     }
     init_debug_trace();
     init_mesh_host_ownership();
-    var fs51 = __toESM2(require("fs"));
+    var fs53 = __toESM2(require("fs"));
     init_mesh_node_identity();
     init_router_refine();
-    var fs49 = __toESM2(require("fs"));
+    var fs51 = __toESM2(require("fs"));
     var import_node_os2 = require("os");
-    var import_path18 = require("path");
+    var import_path19 = require("path");
     init_logger();
     init_git_locale();
     init_dist();
@@ -121239,7 +121531,7 @@ ${ptyResult.output.slice(-2e3)}`);
     function acceptableManagedWorktreePaths(resolveWorktreePath2, normalizePath2, repoRoot, meshName, branch, worktreeBaseDir) {
       const safeBranch = branch.replace(/[/\\:*?"<>|]/g, "-").replace(/^\.+|\.+$/g, "");
       const safeMeshName = meshName.replace(/[/\\:*?"<>|]/g, "-").replace(/^\.+|\.+$/g, "");
-      const legacyPath = (0, import_path18.join)((0, import_path18.dirname)(repoRoot), LEGACY_WORKTREE_DIR_NAME, safeMeshName, safeBranch);
+      const legacyPath = (0, import_path19.join)((0, import_path19.dirname)(repoRoot), LEGACY_WORKTREE_DIR_NAME, safeMeshName, safeBranch);
       const candidates = [
         resolveWorktreePath2(repoRoot, meshName, branch, worktreeBaseDir),
         legacyPath
@@ -121263,8 +121555,8 @@ ${ptyResult.output.slice(-2e3)}`);
     function looksLikeCrossTrackWorktreePath(actualPath, normalizePath2) {
       const home = normalizePath2((0, import_node_os2.homedir)());
       return TRACK_CONFIG_DIR_NAMES.some((trackDirName) => {
-        const trackWorktreesDir = (0, import_path18.join)(home, trackDirName, "worktrees");
-        return actualPath === normalizePath2(trackWorktreesDir) || actualPath.startsWith(normalizePath2(trackWorktreesDir) + import_path18.sep);
+        const trackWorktreesDir = (0, import_path19.join)(home, trackDirName, "worktrees");
+        return actualPath === normalizePath2(trackWorktreesDir) || actualPath.startsWith(normalizePath2(trackWorktreesDir) + import_path19.sep);
       });
     }
     function unexpectedPathRecoveryHint(actualPath, normalizePath2, suffix) {
@@ -121322,14 +121614,14 @@ ${ptyResult.output.slice(-2e3)}`);
       return false;
     }
     async function bestEffortRemoveWorktreeDir(self, dir) {
-      if (!dir || !fs49.existsSync(dir)) return { removed: true, residue: false };
+      if (!dir || !fs51.existsSync(dir)) return { removed: true, residue: false };
       const sleep3 = (ms) => new Promise((resolve30) => setTimeout(resolve30, ms));
       const ABSORB = /* @__PURE__ */ new Set(["EINVAL", "EPERM", "EBUSY", "ENOTEMPTY", "EACCES", "EMFILE", "ENFILE"]);
       let lastErr;
       for (let attempt = 0; attempt < 4; attempt++) {
         try {
-          fs49.rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-          if (!fs49.existsSync(dir)) return { removed: true, residue: false };
+          fs51.rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+          if (!fs51.existsSync(dir)) return { removed: true, residue: false };
           lastErr = new Error("directory still present after rmSync");
         } catch (e) {
           lastErr = e;
@@ -121340,7 +121632,7 @@ ${ptyResult.output.slice(-2e3)}`);
         }
         await sleep3(150 * (attempt + 1));
       }
-      return fs49.existsSync(dir) ? { removed: false, residue: true, error: String(lastErr?.message || lastErr || "unknown rm error") } : { removed: true, residue: false };
+      return fs51.existsSync(dir) ? { removed: false, residue: true, error: String(lastErr?.message || lastErr || "unknown rm error") } : { removed: true, residue: false };
     }
     async function precheckLocalWorktreeRemovable(self, args) {
       const sessionPreservedNote = " The delegated session was left running (not stopped) \u2014 resolve the issue and retry mesh_remove_node.";
@@ -121353,10 +121645,10 @@ ${ptyResult.output.slice(-2e3)}`);
           recoveryHint: "Inspect the mesh node record before removing it, or remove stale metadata manually only after confirming no managed worktree remains." + sessionPreservedNote
         };
       }
-      if (!fs49.existsSync(workspace)) return { ok: true };
+      if (!fs51.existsSync(workspace)) return { ok: true };
       const sourceNode = args.node?.clonedFromNodeId ? args.mesh?.nodes?.find((n) => meshNodeIdMatches(n, args.node.clonedFromNodeId)) : args.mesh?.nodes?.find((n) => !n.isLocalWorktree);
       const repoRoot = typeof sourceNode?.repoRoot === "string" && sourceNode.repoRoot.trim() ? sourceNode.repoRoot.trim() : typeof sourceNode?.workspace === "string" && sourceNode.workspace.trim() ? sourceNode.workspace.trim() : "";
-      if (!repoRoot || !fs49.existsSync(repoRoot)) {
+      if (!repoRoot || !fs51.existsSync(repoRoot)) {
         return {
           ok: false,
           code: "mesh_worktree_cleanup_missing_source_repo",
@@ -121374,9 +121666,9 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
       const normalizePath2 = (value) => {
-        const resolved = (0, import_path18.resolve)(value);
+        const resolved = (0, import_path19.resolve)(value);
         try {
-          return fs49.realpathSync(resolved);
+          return fs51.realpathSync(resolved);
         } catch {
           return resolved;
         }
@@ -121477,13 +121769,13 @@ ${ptyResult.output.slice(-2e3)}`);
           recoveryHint: "Inspect the mesh node record before removing it, or remove stale metadata manually only after confirming no managed worktree remains."
         };
       }
-      const worktreeExists = fs49.existsSync(workspace);
+      const worktreeExists = fs51.existsSync(workspace);
       const sourceNode = args.node?.clonedFromNodeId ? args.mesh?.nodes?.find((n) => meshNodeIdMatches(n, args.node.clonedFromNodeId)) : args.mesh?.nodes?.find((n) => !n.isLocalWorktree);
       const repoRoot = typeof sourceNode?.repoRoot === "string" && sourceNode.repoRoot.trim() ? sourceNode.repoRoot.trim() : typeof sourceNode?.workspace === "string" && sourceNode.workspace.trim() ? sourceNode.workspace.trim() : "";
       if (!worktreeExists) {
         return { success: true, skipped: true, removedPath: workspace, repoRoot: repoRoot || void 0, reason: "worktree_path_missing" };
       }
-      if (!repoRoot || !fs49.existsSync(repoRoot)) {
+      if (!repoRoot || !fs51.existsSync(repoRoot)) {
         return {
           success: false,
           code: "mesh_worktree_cleanup_missing_source_repo",
@@ -121501,9 +121793,9 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2, removeWorktree: removeWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
       const normalizePath2 = (value) => {
-        const resolved = (0, import_path18.resolve)(value);
+        const resolved = (0, import_path19.resolve)(value);
         try {
-          return fs49.realpathSync(resolved);
+          return fs51.realpathSync(resolved);
         } catch {
           return resolved;
         }
@@ -122150,8 +122442,8 @@ ${ptyResult.output.slice(-2e3)}`);
     init_logger();
     var yaml5 = __toESM2(require_js_yaml());
     var import_os5 = require("os");
-    var import_path19 = require("path");
-    var fs50 = __toESM2(require("fs"));
+    var import_path20 = require("path");
+    var fs52 = __toESM2(require("fs"));
     var MESH_COORDINATOR_AUTO_IMPORT_FORMATS = ["claude_mcp_json", "hermes_config_yaml", "opencode_json"];
     function isSupportedMeshCoordinatorConfigFormat(format) {
       return MESH_COORDINATOR_AUTO_IMPORT_FORMATS.includes(format);
@@ -122191,14 +122483,14 @@ ${ptyResult.output.slice(-2e3)}`);
     }
     function resolveHermesUserHome() {
       const explicitHome = process.env.HERMES_HOME?.trim();
-      return explicitHome || (0, import_path19.join)((0, import_os5.homedir)(), ".hermes");
+      return explicitHome || (0, import_path20.join)((0, import_os5.homedir)(), ".hermes");
     }
     function loadHermesCoordinatorBaseConfig(targetConfigPath) {
       const sourceHome = resolveHermesUserHome();
-      const sourceConfigPath = (0, import_path19.join)(sourceHome, "config.yaml");
-      if (!fs50.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-      if ((0, import_path19.resolve)(sourceConfigPath) === (0, import_path19.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-      const parsed = parseMeshCoordinatorMcpConfig(fs50.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
+      const sourceConfigPath = (0, import_path20.join)(sourceHome, "config.yaml");
+      if (!fs52.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+      if ((0, import_path20.resolve)(sourceConfigPath) === (0, import_path20.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+      const parsed = parseMeshCoordinatorMcpConfig(fs52.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
       const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
       return { config: baseConfig, sourceHome, sourceConfigPath };
     }
@@ -122231,13 +122523,13 @@ ${ptyResult.output.slice(-2e3)}`);
       return sanitized;
     }
     function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
-      if ((0, import_path19.resolve)(sourceHome) === (0, import_path19.resolve)(targetHome)) return;
+      if ((0, import_path20.resolve)(sourceHome) === (0, import_path20.resolve)(targetHome)) return;
       for (const fileName of [".env", "auth.json"]) {
-        const sourcePath = (0, import_path19.join)(sourceHome, fileName);
-        const targetPath = (0, import_path19.join)(targetHome, fileName);
-        if (!fs50.existsSync(sourcePath)) continue;
+        const sourcePath = (0, import_path20.join)(sourceHome, fileName);
+        const targetPath = (0, import_path20.join)(targetHome, fileName);
+        if (!fs52.existsSync(sourcePath)) continue;
         try {
-          fs50.copyFileSync(sourcePath, targetPath);
+          fs52.copyFileSync(sourcePath, targetPath);
         } catch (error48) {
           LOG2.warn("MeshCoordinator", `Could not copy Hermes ${fileName} into isolated coordinator home: ${error48?.message || error48}`);
         }
@@ -122752,7 +123044,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const nodeId = readInlineMeshNodeId(node);
           if (!nodeId || !tombstones.has(nodeId)) return true;
           const workspace = readStringValue(node?.workspace);
-          if (workspace && fs51.existsSync(workspace)) {
+          if (workspace && fs53.existsSync(workspace)) {
             tombstones.delete(nodeId);
             return true;
           }
@@ -124812,7 +125104,7 @@ ${ptyResult.output.slice(-2e3)}`);
     };
     init_io_contracts();
     init_chat_message_normalization();
-    var fs52 = __toESM2(require("fs"));
+    var fs54 = __toESM2(require("fs"));
     var path522 = __toESM2(require("path"));
     var os28 = __toESM2(require("os"));
     var import_os6 = require("os");
@@ -124829,8 +125121,8 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       load() {
         try {
-          if (fs52.existsSync(getArchivePath2())) {
-            this.history = JSON.parse(fs52.readFileSync(getArchivePath2(), "utf-8"));
+          if (fs54.existsSync(getArchivePath2())) {
+            this.history = JSON.parse(fs54.readFileSync(getArchivePath2(), "utf-8"));
           }
         } catch {
           this.history = {};
@@ -124867,8 +125159,8 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       save() {
         try {
-          fs52.mkdirSync(path522.dirname(getArchivePath2()), { recursive: true });
-          fs52.writeFileSync(getArchivePath2(), JSON.stringify(this.history, null, 2));
+          fs54.mkdirSync(path522.dirname(getArchivePath2()), { recursive: true });
+          fs54.writeFileSync(getArchivePath2(), JSON.stringify(this.history, null, 2));
         } catch {
         }
       }
@@ -124893,8 +125185,8 @@ ${ptyResult.output.slice(-2e3)}`);
         for (const ext of exes) {
           const fullPath = path522.join(p, name + ext);
           try {
-            if (fs52.existsSync(fullPath)) {
-              const stat2 = fs52.statSync(fullPath);
+            if (fs54.existsSync(fullPath)) {
+              const stat2 = fs54.statSync(fullPath);
               if (stat2.isFile() && (isWin || stat2.mode & 73)) {
                 return fullPath;
               }
@@ -124941,9 +125233,9 @@ ${ptyResult.output.slice(-2e3)}`);
         if (p.includes("*")) {
           const home = os28.homedir();
           const resolved = p.replace(/\*/g, home.split(path522.sep).pop() || "");
-          if (fs52.existsSync(resolved)) return resolved;
+          if (fs54.existsSync(resolved)) return resolved;
         } else {
-          if (fs52.existsSync(p)) return p;
+          if (fs54.existsSync(p)) return p;
         }
       }
       return null;
@@ -124951,7 +125243,7 @@ ${ptyResult.output.slice(-2e3)}`);
     async function getMacAppVersion(appPath) {
       if ((0, import_os6.platform)() !== "darwin" || !appPath.endsWith(".app")) return null;
       const plistPath = path522.join(appPath, "Contents", "Info.plist");
-      if (!fs52.existsSync(plistPath)) return null;
+      if (!fs54.existsSync(plistPath)) return null;
       const raw = await runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
       return raw || null;
     }
@@ -124978,7 +125270,7 @@ ${ptyResult.output.slice(-2e3)}`);
           let resolvedBin = cliBin;
           if (!resolvedBin && appPath && currentOs === "darwin") {
             const bundled = path522.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
-            if (provider.cli && fs52.existsSync(bundled)) resolvedBin = bundled;
+            if (provider.cli && fs54.existsSync(bundled)) resolvedBin = bundled;
           }
           info.installed = !!(appPath || resolvedBin);
           info.path = appPath || null;
@@ -125024,7 +125316,7 @@ ${ptyResult.output.slice(-2e3)}`);
       return results;
     }
     var http3 = __toESM2(require("http"));
-    var fs56 = __toESM2(require("fs"));
+    var fs58 = __toESM2(require("fs"));
     var path56 = __toESM2(require("path"));
     init_config();
     function generateFiles(type2, name, category, opts = {}) {
@@ -125370,7 +125662,7 @@ async (params) => {
     }
     init_logger();
     init_builders();
-    var fs53 = __toESM2(require("fs"));
+    var fs55 = __toESM2(require("fs"));
     var path53 = __toESM2(require("path"));
     init_logger();
     async function handleCdpEvaluate(ctx, req, res) {
@@ -125551,17 +125843,17 @@ async (params) => {
       }
       let scriptsPath = "";
       const directScripts = path53.join(dir, "scripts.js");
-      if (fs53.existsSync(directScripts)) {
+      if (fs55.existsSync(directScripts)) {
         scriptsPath = directScripts;
       } else {
         const scriptsDir = path53.join(dir, "scripts");
-        if (fs53.existsSync(scriptsDir)) {
-          const versions = fs53.readdirSync(scriptsDir).filter((d) => {
-            return fs53.statSync(path53.join(scriptsDir, d)).isDirectory();
+        if (fs55.existsSync(scriptsDir)) {
+          const versions = fs55.readdirSync(scriptsDir).filter((d) => {
+            return fs55.statSync(path53.join(scriptsDir, d)).isDirectory();
           }).sort().reverse();
           for (const ver of versions) {
             const p = path53.join(scriptsDir, ver, "scripts.js");
-            if (fs53.existsSync(p)) {
+            if (fs55.existsSync(p)) {
               scriptsPath = p;
               break;
             }
@@ -125573,7 +125865,7 @@ async (params) => {
         return;
       }
       try {
-        const source = fs53.readFileSync(scriptsPath, "utf-8");
+        const source = fs55.readFileSync(scriptsPath, "utf-8");
         const hints = {};
         const funcRegex = /module\.exports\.(\w+)\s*=\s*function\s+\w+\s*\(params\)/g;
         let match;
@@ -126386,7 +126678,7 @@ async (params) => {
         ctx.json(res, 500, { error: `DOM context collection failed: ${e.message}` });
       }
     }
-    var fs54 = __toESM2(require("fs"));
+    var fs56 = __toESM2(require("fs"));
     var path54 = __toESM2(require("path"));
     function slugifyFixtureName(value) {
       const normalized = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -126402,10 +126694,10 @@ async (params) => {
     function readCliFixture(ctx, type2, name) {
       const fixtureDir = getCliFixtureDir(ctx, type2);
       const filePath = path54.join(fixtureDir, `${name}.json`);
-      if (!fs54.existsSync(filePath)) {
+      if (!fs56.existsSync(filePath)) {
         throw new Error(`Fixture not found: ${filePath}`);
       }
-      return JSON.parse(fs54.readFileSync(filePath, "utf-8"));
+      return JSON.parse(fs56.readFileSync(filePath, "utf-8"));
     }
     function getExerciseTranscriptText(result) {
       const parts = [];
@@ -127155,7 +127447,7 @@ async (params) => {
           return;
         }
         const fixtureDir = getCliFixtureDir(ctx, type2);
-        fs54.mkdirSync(fixtureDir, { recursive: true });
+        fs56.mkdirSync(fixtureDir, { recursive: true });
         const name = slugifyFixtureName(String(body?.name || `${type2}-${Date.now()}`));
         const result = await runCliExerciseInternal(ctx, { ...request, type: type2 });
         const fixture = {
@@ -127183,7 +127475,7 @@ async (params) => {
           notes: typeof body?.notes === "string" ? body.notes : void 0
         };
         const filePath = path54.join(fixtureDir, `${name}.json`);
-        fs54.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
+        fs56.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
         ctx.json(res, 200, {
           saved: true,
           name,
@@ -127201,14 +127493,14 @@ async (params) => {
     async function handleCliFixtureList(ctx, type2, _req, res) {
       try {
         const fixtureDir = getCliFixtureDir(ctx, type2);
-        if (!fs54.existsSync(fixtureDir)) {
+        if (!fs56.existsSync(fixtureDir)) {
           ctx.json(res, 200, { fixtures: [], count: 0 });
           return;
         }
-        const fixtures = fs54.readdirSync(fixtureDir).filter((file2) => file2.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file2) => {
+        const fixtures = fs56.readdirSync(fixtureDir).filter((file2) => file2.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file2) => {
           const fullPath = path54.join(fixtureDir, file2);
           try {
-            const raw = JSON.parse(fs54.readFileSync(fullPath, "utf-8"));
+            const raw = JSON.parse(fs56.readFileSync(fullPath, "utf-8"));
             return {
               name: raw.name || file2.replace(/\.json$/i, ""),
               path: fullPath,
@@ -127339,7 +127631,7 @@ async (params) => {
         ctx.json(res, 500, { error: `Raw send failed: ${e.message}` });
       }
     }
-    var fs55 = __toESM2(require("fs"));
+    var fs57 = __toESM2(require("fs"));
     var path55 = __toESM2(require("path"));
     var os29 = __toESM2(require("os"));
     var import_session_host_core10 = require_dist();
@@ -127388,10 +127680,10 @@ async (params) => {
       return fallback?.type || null;
     }
     function getLatestScriptVersionDir(scriptsDir) {
-      if (!fs55.existsSync(scriptsDir)) return null;
-      const versions = fs55.readdirSync(scriptsDir).filter((d) => {
+      if (!fs57.existsSync(scriptsDir)) return null;
+      const versions = fs57.readdirSync(scriptsDir).filter((d) => {
         try {
-          return fs55.statSync(path55.join(scriptsDir, d)).isDirectory();
+          return fs57.statSync(path55.join(scriptsDir, d)).isDirectory();
         } catch {
           return false;
         }
@@ -127413,13 +127705,13 @@ async (params) => {
       if (!sourceDir) {
         return { dir: null, reason: `Provider source directory not found for '${type2}'` };
       }
-      if (!fs55.existsSync(desiredDir)) {
-        fs55.mkdirSync(path55.dirname(desiredDir), { recursive: true });
-        fs55.cpSync(sourceDir, desiredDir, { recursive: true });
+      if (!fs57.existsSync(desiredDir)) {
+        fs57.mkdirSync(path55.dirname(desiredDir), { recursive: true });
+        fs57.cpSync(sourceDir, desiredDir, { recursive: true });
         ctx.log(`Auto-implement writable copy created: ${desiredDir}`);
       }
       const providerJson = path55.join(desiredDir, "provider.json");
-      if (!fs55.existsSync(providerJson)) {
+      if (!fs57.existsSync(providerJson)) {
         return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
       }
       return { dir: desiredDir };
@@ -127427,15 +127719,15 @@ async (params) => {
     function loadAutoImplReferenceScripts(ctx, referenceType) {
       if (!referenceType) return {};
       const refDir = ctx.findProviderDir(referenceType);
-      if (!refDir || !fs55.existsSync(refDir)) return {};
+      if (!refDir || !fs57.existsSync(refDir)) return {};
       const referenceScripts = {};
       const scriptsDir = path55.join(refDir, "scripts");
       const latestDir = getLatestScriptVersionDir(scriptsDir);
       if (!latestDir) return referenceScripts;
-      for (const file2 of fs55.readdirSync(latestDir)) {
+      for (const file2 of fs57.readdirSync(latestDir)) {
         if (!file2.endsWith(".js")) continue;
         try {
-          referenceScripts[file2] = fs55.readFileSync(path55.join(latestDir, file2), "utf-8");
+          referenceScripts[file2] = fs57.readFileSync(path55.join(latestDir, file2), "utf-8");
         } catch {
         }
       }
@@ -127544,15 +127836,15 @@ async (params) => {
         const referenceScripts = loadAutoImplReferenceScripts(ctx, resolvedReference);
         const prompt = buildAutoImplPrompt(ctx, type2, provider, providerDir, functions, domContext, referenceScripts, comment, resolvedReference, verification);
         const tmpDir = path55.join(os29.tmpdir(), "adhdev-autoimpl");
-        if (!fs55.existsSync(tmpDir)) fs55.mkdirSync(tmpDir, { recursive: true });
+        if (!fs57.existsSync(tmpDir)) fs57.mkdirSync(tmpDir, { recursive: true });
         const promptFile = path55.join(tmpDir, `prompt-${type2}-${Date.now()}.md`);
-        fs55.writeFileSync(promptFile, prompt, "utf-8");
+        fs57.writeFileSync(promptFile, prompt, "utf-8");
         ctx.log(`Auto-implement prompt written to ${promptFile} (${prompt.length} chars)`);
         const agentProvider = ctx.providerLoader.resolve(agent) || ctx.providerLoader.getMeta(agent);
         const spawn7 = agentProvider?.spawn;
         if (!spawn7?.command) {
           try {
-            fs55.unlinkSync(promptFile);
+            fs57.unlinkSync(promptFile);
           } catch {
           }
           ctx.json(res, 400, { error: `Agent '${agent}' has no spawn config. Select a CLI provider with a spawn configuration.` });
@@ -127654,7 +127946,7 @@ async (params) => {
             } catch {
             }
             try {
-              fs55.unlinkSync(promptFile);
+              fs57.unlinkSync(promptFile);
             } catch {
             }
             ctx.log(`Auto-implement (ACP) ${success2 ? "completed" : "failed"}: ${type2} (exit: ${code})`);
@@ -127877,7 +128169,7 @@ async (params) => {
             }
           });
           try {
-            fs55.unlinkSync(promptFile);
+            fs57.unlinkSync(promptFile);
           } catch {
           }
           ctx.log(`Auto-implement ${success2 ? "completed" : "failed"}: ${type2} (exit: ${code})${verificationSummary ? ` verify=${verificationSummary.pass ? "pass" : "fail"}` : ""}`);
@@ -127982,10 +128274,10 @@ async (params) => {
         lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
         lines.push("These are the ONLY files you are allowed to modify. Replace the TODO stubs with working implementations.");
         lines.push("");
-        for (const file2 of fs55.readdirSync(latestScriptsDir)) {
+        for (const file2 of fs57.readdirSync(latestScriptsDir)) {
           if (file2.endsWith(".js") && targetFileNames.has(file2)) {
             try {
-              const content = fs55.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
+              const content = fs57.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
               lines.push("```javascript");
               lines.push(content);
@@ -127995,14 +128287,14 @@ async (params) => {
             }
           }
         }
-        const refFiles = fs55.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+        const refFiles = fs57.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
         if (refFiles.length > 0) {
           lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
           lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
           lines.push("");
           for (const file2 of refFiles) {
             try {
-              const content = fs55.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
+              const content = fs57.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u{1F512}`);
               lines.push("```javascript");
               lines.push(content);
@@ -128047,7 +128339,7 @@ async (params) => {
       const loadGuide = (name) => {
         try {
           const p = path55.join(docsDir, name);
-          if (fs55.existsSync(p)) return fs55.readFileSync(p, "utf-8");
+          if (fs57.existsSync(p)) return fs57.readFileSync(p, "utf-8");
         } catch {
         }
         return null;
@@ -128291,11 +128583,11 @@ async (params) => {
         lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
         lines.push("These are the ONLY files you are allowed to modify. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
         lines.push("");
-        for (const file2 of fs55.readdirSync(latestScriptsDir)) {
+        for (const file2 of fs57.readdirSync(latestScriptsDir)) {
           if (!file2.endsWith(".js")) continue;
           if (!targetFileNames.has(file2)) continue;
           try {
-            const content = fs55.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
+            const content = fs57.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
             lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
             lines.push("```javascript");
             lines.push(content);
@@ -128304,14 +128596,14 @@ async (params) => {
           } catch {
           }
         }
-        const refFiles = fs55.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+        const refFiles = fs57.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
         if (refFiles.length > 0) {
           lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
           lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
           lines.push("");
           for (const file2 of refFiles) {
             try {
-              const content = fs55.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
+              const content = fs57.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u{1F512}`);
               lines.push("```javascript");
               lines.push(content);
@@ -128348,7 +128640,7 @@ async (params) => {
       const loadGuide = (name) => {
         try {
           const p = path55.join(docsDir, name);
-          if (fs55.existsSync(p)) return fs55.readFileSync(p, "utf-8");
+          if (fs57.existsSync(p)) return fs57.readFileSync(p, "utf-8");
         } catch {
         }
         return null;
@@ -129086,7 +129378,7 @@ data: ${JSON.stringify(msg.data)}
           path56.join(process.cwd(), "packages/web-devconsole/dist")
         ];
         for (const dir of candidates) {
-          if (fs56.existsSync(path56.join(dir, "index.html"))) return dir;
+          if (fs58.existsSync(path56.join(dir, "index.html"))) return dir;
         }
         return null;
       }
@@ -129098,7 +129390,7 @@ data: ${JSON.stringify(msg.data)}
         }
         const htmlPath = path56.join(distDir, "index.html");
         try {
-          const html = fs56.readFileSync(htmlPath, "utf-8");
+          const html = fs58.readFileSync(htmlPath, "utf-8");
           res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
           res.end(html);
         } catch (e) {
@@ -129128,7 +129420,7 @@ data: ${JSON.stringify(msg.data)}
           return;
         }
         try {
-          const content = fs56.readFileSync(filePath);
+          const content = fs58.readFileSync(filePath);
           const ext = path56.extname(filePath);
           const contentType = _DevServer.MIME_MAP[ext] || "application/octet-stream";
           res.writeHead(200, { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" });
@@ -129237,14 +129529,14 @@ data: ${JSON.stringify(msg.data)}
         const files = [];
         const scan = (d, prefix) => {
           try {
-            for (const entry of fs56.readdirSync(d, { withFileTypes: true })) {
+            for (const entry of fs58.readdirSync(d, { withFileTypes: true })) {
               if (entry.name.startsWith(".") || entry.name.endsWith(".bak")) continue;
               const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
               if (entry.isDirectory()) {
                 files.push({ path: rel, size: 0, type: "dir" });
                 scan(path56.join(d, entry.name), rel);
               } else {
-                const stat2 = fs56.statSync(path56.join(d, entry.name));
+                const stat2 = fs58.statSync(path56.join(d, entry.name));
                 files.push({ path: rel, size: stat2.size, type: "file" });
               }
             }
@@ -129272,11 +129564,11 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 403, { error: "Forbidden" });
           return;
         }
-        if (!fs56.existsSync(fullPath) || fs56.statSync(fullPath).isDirectory()) {
+        if (!fs58.existsSync(fullPath) || fs58.statSync(fullPath).isDirectory()) {
           this.json(res, 404, { error: `File not found: ${filePath}` });
           return;
         }
-        const content = fs56.readFileSync(fullPath, "utf-8");
+        const content = fs58.readFileSync(fullPath, "utf-8");
         this.json(res, 200, { type: type2, path: filePath, content, lines: content.split("\n").length });
       }
       /** POST /api/providers/:type/file — write a file { path, content } */
@@ -129298,9 +129590,9 @@ data: ${JSON.stringify(msg.data)}
           return;
         }
         try {
-          if (fs56.existsSync(fullPath)) fs56.copyFileSync(fullPath, fullPath + ".bak");
-          fs56.mkdirSync(path56.dirname(fullPath), { recursive: true });
-          fs56.writeFileSync(fullPath, content, "utf-8");
+          if (fs58.existsSync(fullPath)) fs58.copyFileSync(fullPath, fullPath + ".bak");
+          fs58.mkdirSync(path56.dirname(fullPath), { recursive: true });
+          fs58.writeFileSync(fullPath, content, "utf-8");
           this.log(`File saved: ${fullPath} (${content.length} chars)`);
           this.providerLoader.reload();
           this.json(res, 200, { saved: true, path: filePath, chars: content.length });
@@ -129317,8 +129609,8 @@ data: ${JSON.stringify(msg.data)}
         }
         for (const name of ["scripts.js", "provider.json"]) {
           const p = path56.join(dir, name);
-          if (fs56.existsSync(p)) {
-            const source = fs56.readFileSync(p, "utf-8");
+          if (fs58.existsSync(p)) {
+            const source = fs58.readFileSync(p, "utf-8");
             this.json(res, 200, { type: type2, path: p, source, lines: source.split("\n").length });
             return;
           }
@@ -129337,11 +129629,11 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 404, { error: `Provider not found: ${type2}` });
           return;
         }
-        const target = fs56.existsSync(path56.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
+        const target = fs58.existsSync(path56.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
         const targetPath = path56.join(dir, target);
         try {
-          if (fs56.existsSync(targetPath)) fs56.copyFileSync(targetPath, targetPath + ".bak");
-          fs56.writeFileSync(targetPath, source, "utf-8");
+          if (fs58.existsSync(targetPath)) fs58.copyFileSync(targetPath, targetPath + ".bak");
+          fs58.writeFileSync(targetPath, source, "utf-8");
           this.log(`Saved provider: ${targetPath} (${source.length} chars)`);
           this.providerLoader.reload();
           this.json(res, 200, { saved: true, path: targetPath, chars: source.length });
@@ -129486,20 +129778,20 @@ data: ${JSON.stringify(msg.data)}
         let targetDir;
         targetDir = this.providerLoader.getUserProviderDir(category, type2);
         const jsonPath = path56.join(targetDir, "provider.json");
-        if (fs56.existsSync(jsonPath)) {
+        if (fs58.existsSync(jsonPath)) {
           this.json(res, 409, { error: `Provider already exists at ${targetDir}`, path: targetDir });
           return;
         }
         try {
           const result = generateFiles(type2, name, category, { cdpPorts, cli, processName, installPath, binary: binary2, extensionId, version: version2, osPaths, processNames });
-          fs56.mkdirSync(targetDir, { recursive: true });
-          fs56.writeFileSync(jsonPath, result["provider.json"], "utf-8");
+          fs58.mkdirSync(targetDir, { recursive: true });
+          fs58.writeFileSync(jsonPath, result["provider.json"], "utf-8");
           const createdFiles = ["provider.json"];
           if (result.files) {
             for (const [relPath, content] of Object.entries(result.files)) {
               const fullPath = path56.join(targetDir, relPath);
-              fs56.mkdirSync(path56.dirname(fullPath), { recursive: true });
-              fs56.writeFileSync(fullPath, content, "utf-8");
+              fs58.mkdirSync(path56.dirname(fullPath), { recursive: true });
+              fs58.writeFileSync(fullPath, content, "utf-8");
               createdFiles.push(relPath);
             }
           }
@@ -129548,10 +129840,10 @@ data: ${JSON.stringify(msg.data)}
       }
       // ─── Phase 2: Auto-Implement Backend ───
       getLatestScriptVersionDir(scriptsDir) {
-        if (!fs56.existsSync(scriptsDir)) return null;
-        const versions = fs56.readdirSync(scriptsDir).filter((d) => {
+        if (!fs58.existsSync(scriptsDir)) return null;
+        const versions = fs58.readdirSync(scriptsDir).filter((d) => {
           try {
-            return fs56.statSync(path56.join(scriptsDir, d)).isDirectory();
+            return fs58.statSync(path56.join(scriptsDir, d)).isDirectory();
           } catch {
             return false;
           }
@@ -129573,13 +129865,13 @@ data: ${JSON.stringify(msg.data)}
         if (!sourceDir) {
           return { dir: null, reason: `Provider source directory not found for '${type2}'` };
         }
-        if (!fs56.existsSync(desiredDir)) {
-          fs56.mkdirSync(path56.dirname(desiredDir), { recursive: true });
-          fs56.cpSync(sourceDir, desiredDir, { recursive: true });
+        if (!fs58.existsSync(desiredDir)) {
+          fs58.mkdirSync(path56.dirname(desiredDir), { recursive: true });
+          fs58.cpSync(sourceDir, desiredDir, { recursive: true });
           this.log(`Auto-implement writable copy created: ${desiredDir}`);
         }
         const providerJson = path56.join(desiredDir, "provider.json");
-        if (!fs56.existsSync(providerJson)) {
+        if (!fs58.existsSync(providerJson)) {
           return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
         }
         return { dir: desiredDir };
@@ -130388,7 +130680,7 @@ data: ${JSON.stringify(msg.data)}
       }
     }
     var import_child_process14 = require("child_process");
-    var fs57 = __toESM2(require("fs"));
+    var fs59 = __toESM2(require("fs"));
     var os30 = __toESM2(require("os"));
     var path57 = __toESM2(require("path"));
     var import_session_host_core14 = require_dist();
@@ -130414,7 +130706,7 @@ data: ${JSON.stringify(msg.data)}
           path57.resolve(__dirname, "../../vendor/session-host-daemon/index.js")
         ];
         for (const candidate of packagedCandidates) {
-          if (fs57.existsSync(candidate)) {
+          if (fs59.existsSync(candidate)) {
             return candidate;
           }
         }
@@ -130434,8 +130726,8 @@ data: ${JSON.stringify(msg.data)}
       function getPid() {
         try {
           const pidFile = getPidFile();
-          if (!fs57.existsSync(pidFile)) return null;
-          const pid = Number.parseInt(fs57.readFileSync(pidFile, "utf8").trim(), 10);
+          if (!fs59.existsSync(pidFile)) return null;
+          const pid = Number.parseInt(fs59.readFileSync(pidFile, "utf8").trim(), 10);
           return Number.isFinite(pid) ? pid : null;
         } catch {
           return null;
@@ -130485,7 +130777,7 @@ data: ${JSON.stringify(msg.data)}
         if (markerIndex === -1) return;
         const activePrefix = entry.slice(0, markerIndex);
         const candidates = resolveConptyPrebuildCandidates(activePrefix);
-        const found = candidates.find((candidate) => fs57.existsSync(candidate));
+        const found = candidates.find((candidate) => fs59.existsSync(candidate));
         if (!found) {
           throw new Error(
             `conpty.node missing at boot despite passing the install-time gate \u2014 likely deleted post-install (checked: ${candidates.join(", ")}). Every session-host spawn would crash requiring node-pty; refusing to spawn.`
@@ -130501,8 +130793,8 @@ data: ${JSON.stringify(msg.data)}
         let logFd = null;
         if (options.spawnStdio === "logfile") {
           const logDir = path57.join(instance().configDir, "logs");
-          fs57.mkdirSync(logDir, { recursive: true });
-          logFd = fs57.openSync(path57.join(logDir, "session-host.log"), "a");
+          fs59.mkdirSync(logDir, { recursive: true });
+          logFd = fs59.openSync(path57.join(logDir, "session-host.log"), "a");
           stdio = ["ignore", logFd, logFd];
         }
         const child = (0, import_child_process14.spawn)(nodeExecutable, [entry], {
@@ -130514,7 +130806,7 @@ data: ${JSON.stringify(msg.data)}
         child.unref();
         if (logFd !== null) {
           try {
-            fs57.closeSync(logFd);
+            fs59.closeSync(logFd);
           } catch {
           }
         }
@@ -130532,8 +130824,8 @@ data: ${JSON.stringify(msg.data)}
         const pidFile = getPidFile();
         let keepPidFile = false;
         try {
-          if (fs57.existsSync(pidFile)) {
-            const pid = Number.parseInt(fs57.readFileSync(pidFile, "utf8").trim(), 10);
+          if (fs59.existsSync(pidFile)) {
+            const pid = Number.parseInt(fs59.readFileSync(pidFile, "utf8").trim(), 10);
             if (Number.isFinite(pid) && pid !== process.pid) {
               const managed = isManagedPid(pid);
               if (managed) {
@@ -130553,7 +130845,7 @@ data: ${JSON.stringify(msg.data)}
         } finally {
           if (!keepPidFile) {
             try {
-              fs57.unlinkSync(pidFile);
+              fs59.unlinkSync(pidFile);
             } catch {
             }
           }
@@ -130589,7 +130881,7 @@ data: ${JSON.stringify(msg.data)}
         }
         if (!reported) return;
         if (pathsEquivalent(reported, currentEntry)) return;
-        const reportedExists = fs57.existsSync(reported);
+        const reportedExists = fs59.existsSync(reported);
         LOG2.warn(
           "SessionHost",
           `Reachable session-host reports it is running from ${reported}${reportedExists ? "" : " (which no longer exists)"}, but this install runs from ${currentEntry}. That host would fail every create_session loading node-pty from its own prefix; stopping it so a current one is spawned in its place.`
@@ -130816,8 +131108,8 @@ data: ${JSON.stringify(msg.data)}
           const res = await fetch(extension.vsixUrl);
           if (res.ok) {
             const buffer = Buffer.from(await res.arrayBuffer());
-            const fs59 = await import("fs");
-            fs59.writeFileSync(vsixPath, buffer);
+            const fs61 = await import("fs");
+            fs61.writeFileSync(vsixPath, buffer);
             return new Promise((resolve30) => {
               const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
               (0, import_child_process15.exec)(cmd, { timeout: 6e4 }, (error48, _stdout, stderr) => {
@@ -130963,7 +131255,7 @@ data: ${JSON.stringify(msg.data)}
     init_mesh_events();
     init_mesh_reconcile_loop();
     var import_fs19 = require("fs");
-    var import_path20 = require("path");
+    var import_path21 = require("path");
     var import_crypto18 = require("crypto");
     init_logger();
     init_mesh_ledger();
@@ -131041,7 +131333,7 @@ data: ${JSON.stringify(msg.data)}
       }
       for (const name of names) {
         if (!isPendingEventsFile(name)) continue;
-        const path58 = (0, import_path20.join)(dir, name);
+        const path58 = (0, import_path21.join)(dir, name);
         result.filesScanned++;
         const claimed = `${path58}.migrating`;
         try {
@@ -131820,7 +132112,7 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
       Object.values(V1_PRIMITIVE_CATALOG).flat()
     );
     var V1_CONTRACT_VERSION = "1.0.0";
-    var fs58 = __toESM2(require("fs"));
+    var fs60 = __toESM2(require("fs"));
     var import_chalk2 = __toESM2((init_source(), __toCommonJS(source_exports)));
     init_dist();
     var CLAUDE_NO_API_LINE = "Claude has no quota API \u2014 adhdev borrows your statusLine to read it.";
@@ -131931,7 +132223,7 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         console.log(import_chalk2.default.gray(`  Backup: ${status.paths.backupFile}`));
         let snapshotMtimeMs = null;
         try {
-          snapshotMtimeMs = fs58.statSync(status.paths.snapshotFile).mtimeMs;
+          snapshotMtimeMs = fs60.statSync(status.paths.snapshotFile).mtimeMs;
         } catch {
         }
         console.log(import_chalk2.default.gray(