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

package/dist/index.js

@@ -36620,10 +36620,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "d143fc7369d10b184b4cad79ce3a4240bc811faf" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "d143fc73" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.56-rc.6" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-19T09:46:30.077Z" : void 0);
+      const commit = readInjected(true ? "f45b1ccbf70f856ec2232e2dc5a87acaf875243e" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "f45b1ccb" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.56-rc.8" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-19T16:04:19.674Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -40952,11 +40952,11 @@ child.on('exit', () => process.exit(0));
     }
     function windowsExtraBinDirs() {
       const dirs = [];
-      const fs59 = require("fs");
+      const fs61 = require("fs");
       const push = (dir) => {
         if (!dir) return;
         try {
-          if (fs59.existsSync(dir)) dirs.push(dir);
+          if (fs61.existsSync(dir)) dirs.push(dir);
         } catch {
         }
       };
@@ -40972,12 +40972,12 @@ child.on('exit', () => process.exit(0));
     }
     function unixExtraBinDirs() {
       const dirs = [];
-      const fs59 = require("fs");
+      const fs61 = require("fs");
       const home = os52.homedir();
       const push = (dir) => {
         if (!dir) return;
         try {
-          if (fs59.existsSync(dir)) dirs.push(dir);
+          if (fs61.existsSync(dir)) dirs.push(dir);
         } catch {
         }
       };
@@ -41016,9 +41016,9 @@ child.on('exit', () => process.exit(0));
         for (const ext of exes) {
           const fullPath = path9.join(p, trimmed + ext);
           try {
-            const fs59 = require("fs");
-            if (fs59.existsSync(fullPath)) {
-              const stat2 = fs59.statSync(fullPath);
+            const fs61 = require("fs");
+            if (fs61.existsSync(fullPath)) {
+              const stat2 = fs61.statSync(fullPath);
               if (stat2.isFile() && (isWin || stat2.mode & 73)) {
                 return fullPath;
               }
@@ -41032,12 +41032,12 @@ child.on('exit', () => process.exit(0));
     function isScriptBinary(binaryPath) {
       if (!path9.isAbsolute(binaryPath)) return false;
       try {
-        const fs59 = require("fs");
-        const resolved = fs59.realpathSync(binaryPath);
+        const fs61 = require("fs");
+        const resolved = fs61.realpathSync(binaryPath);
         const head = Buffer.alloc(8);
-        const fd = fs59.openSync(resolved, "r");
-        fs59.readSync(fd, head, 0, 8, 0);
-        fs59.closeSync(fd);
+        const fd = fs61.openSync(resolved, "r");
+        fs61.readSync(fd, head, 0, 8, 0);
+        fs61.closeSync(fd);
         let i = 0;
         if (head[0] === 239 && head[1] === 187 && head[2] === 191) i = 3;
         return head[i] === 35 && head[i + 1] === 33;
@@ -41048,12 +41048,12 @@ child.on('exit', () => process.exit(0));
     function looksLikeMachOOrElf(filePath) {
       if (!path9.isAbsolute(filePath)) return false;
       try {
-        const fs59 = require("fs");
-        const resolved = fs59.realpathSync(filePath);
+        const fs61 = require("fs");
+        const resolved = fs61.realpathSync(filePath);
         const buf = Buffer.alloc(8);
-        const fd = fs59.openSync(resolved, "r");
-        fs59.readSync(fd, buf, 0, 8, 0);
-        fs59.closeSync(fd);
+        const fd = fs61.openSync(resolved, "r");
+        fs61.readSync(fd, buf, 0, 8, 0);
+        fs61.closeSync(fd);
         let i = 0;
         if (buf[0] === 239 && buf[1] === 187 && buf[2] === 191) i = 3;
         const b = buf.subarray(i);
@@ -44261,6 +44261,13 @@ Next step: ${nextStep}`;
         import_meta = {};
       }
     });
+    function normalizeDeliveryMode(raw) {
+      if (raw === void 0 || raw === null || raw === "") return { mode: DEFAULT_DELIVERY_MODE };
+      const v = String(raw).trim().toLowerCase();
+      if (v === "when_idle" || v === "whenidle") return { mode: "when_idle" };
+      if (v === "interrupt") return { mode: "interrupt" };
+      return { mode: DEFAULT_DELIVERY_MODE, unrecognized: String(raw) };
+    }
     function resolveDeliveryDecision(sessionStatus, opts) {
       const status = (sessionStatus || "").trim().toLowerCase();
       if (!status) {
@@ -44292,6 +44299,20 @@ Next step: ${nextStep}`;
             message: "Session is waiting for approval \u2014 approval message delivered immediately."
           };
         }
+        if (opts?.deliveryMode === "interrupt") {
+          if (!opts.interruptSupported) {
+            return {
+              decision: "rejected",
+              reason: "interrupt_unsupported_for_provider",
+              message: opts.interruptUnsupportedMessage ?? `Session is ${status} and delivery mode 'interrupt' was requested, but this provider cannot interrupt a running turn. Refusing rather than silently queueing: queueing would let the current turn finish on the old instructions. Re-dispatch with delivery mode 'when_idle' if delivery-after-completion is acceptable.`
+            };
+          }
+          return {
+            decision: "interrupt",
+            reason: `session_${status}_interrupt_requested`,
+            message: `Session is ${status}. Aborting the in-flight turn via the provider's stop control, then delivering the task once it settles to idle. The work the session had not yet finished is discarded.`
+          };
+        }
         return {
           decision: "queued",
           reason: `session_${status}_busy`,
@@ -44380,6 +44401,7 @@ Next step: ${nextStep}`;
       }
     }
     var import_crypto4;
+    var DEFAULT_DELIVERY_MODE;
     var IMMEDIATE_DELIVERY_STATUSES;
     var BUSY_DELIVERY_STATUSES;
     var TERMINAL_DELIVERY_STATUSES;
@@ -44388,6 +44410,7 @@ Next step: ${nextStep}`;
         "use strict";
         import_crypto4 = require("crypto");
         init_mesh_runtime_store();
+        DEFAULT_DELIVERY_MODE = "when_idle";
         IMMEDIATE_DELIVERY_STATUSES = /* @__PURE__ */ new Set([
           "idle",
           "waiting_input",
@@ -45688,6 +45711,25 @@ Next step: ${nextStep}`;
       while (end > 0 && (buf[end] & 192) === 128) end -= 1;
       return `${buf.subarray(0, end).toString("utf8")}${marker}`;
     }
+    function describeAvailablePointers(upstream) {
+      if (!upstream) return " (no output is recorded for that ref yet)";
+      const envelope = upstream.envelope;
+      if (!envelope || typeof envelope !== "object" || Array.isArray(envelope)) {
+        return " (that ref has an output, but its envelope is not an object)";
+      }
+      const pointers = [];
+      for (const key2 of Object.keys(envelope)) {
+        pointers.push(`/${key2}`);
+        if (key2 !== "worker_result") continue;
+        const workerResult = envelope.worker_result;
+        if (!workerResult || typeof workerResult !== "object" || Array.isArray(workerResult)) continue;
+        for (const sub of Object.keys(workerResult)) {
+          pointers.push(`/worker_result/${sub}`);
+        }
+      }
+      if (pointers.length === 0) return " (that ref's envelope is empty)";
+      return `. Available pointers on ref '${upstream.ref}': ${pointers.join(", ")}`;
+    }
     function resolveInputBindings(bindings, outputsByRef) {
       const resolved = [];
       let totalBytes = 0;
@@ -45698,7 +45740,7 @@ Next step: ${nextStep}`;
           if (binding.required) {
             throw new MeshMaterializationError(
               "required_input_missing",
-              `required binding '${binding.as}' found nothing at '${binding.select}' of ref '${binding.from}'`,
+              `required binding '${binding.as}' found nothing at '${binding.select}' of ref '${binding.from}'` + describeAvailablePointers(upstream),
               binding.as
             );
           }
@@ -47122,108 +47164,6 @@ ${blocks.join("\n\n")}`;
         GIT_STASH_READONLY_SUBCOMMANDS = /* @__PURE__ */ new Set(["list", "show"]);
       }
     });
-    function readPayloadTaskId(entry) {
-      const value = entry.payload?.taskId;
-      return typeof value === "string" && value.trim() ? value.trim() : "";
-    }
-    function parseTime(value) {
-      if (!value) return null;
-      const parsed = new Date(value).getTime();
-      return Number.isFinite(parsed) ? parsed : null;
-    }
-    function computeMeshTaskStats(meshId, opts) {
-      const queue = getQueue(meshId);
-      const queueById = new Map(queue.map((task) => [task.id, task]));
-      let targetIds;
-      if (opts?.taskIds?.length) {
-        targetIds = [...new Set(opts.taskIds)];
-      } else if (opts?.missionId) {
-        targetIds = queue.filter((task) => task.missionId === opts.missionId).map((task) => task.id);
-      } else {
-        targetIds = queue.map((task) => task.id);
-      }
-      if (targetIds.length === 0) return [];
-      const targetSet = new Set(targetIds);
-      const entries = readLedgerEntries(meshId, { tail: opts?.tail ?? 1e3 });
-      const dispatches = /* @__PURE__ */ new Map();
-      const terminals = /* @__PURE__ */ new Map();
-      for (const entry of entries) {
-        const taskId = readPayloadTaskId(entry);
-        if (!taskId || !targetSet.has(taskId)) continue;
-        if (entry.kind === "task_dispatched") {
-          const existing = dispatches.get(taskId);
-          if (existing) existing.count += 1;
-          else dispatches.set(taskId, { first: entry.timestamp, count: 1 });
-        } else if (entry.kind === "task_completed" || entry.kind === "task_failed") {
-          terminals.set(taskId, { at: entry.timestamp, kind: entry.kind });
-        }
-      }
-      return targetIds.map((taskId) => {
-        const queueEntry = queueById.get(taskId);
-        const dispatch = dispatches.get(taskId);
-        const terminal = terminals.get(taskId);
-        const status = queueEntry?.status ?? (terminal ? terminal.kind === "task_completed" ? "completed" : "failed" : "unknown");
-        const isTerminalStatus = status === "completed" || status === "failed" || status === "cancelled";
-        const dispatchTime = parseTime(dispatch?.first ?? queueEntry?.dispatchTimestamp);
-        const terminalTime = parseTime(terminal?.at);
-        const stats = {
-          taskId,
-          status,
-          dispatchedAt: dispatch?.first ?? queueEntry?.dispatchTimestamp ?? null,
-          terminalAt: terminal?.at ?? null,
-          terminalKind: terminal?.kind ?? null,
-          durationMs: null,
-          dispatchCount: dispatch?.count ?? 0,
-          requeueCount: queueEntry?.requeueCount ?? 0
-        };
-        if (dispatchTime !== null && terminalTime !== null && terminalTime >= dispatchTime) {
-          stats.durationMs = terminalTime - dispatchTime;
-        } else if (isTerminalStatus) {
-          stats.incompleteEvidence = true;
-        }
-        return stats;
-      });
-    }
-    function computeMeshMissionStats(meshId, missionId) {
-      const tasks = computeMeshTaskStats(meshId, { missionId });
-      const stats = {
-        missionId,
-        taskCount: tasks.length,
-        completed: 0,
-        failed: 0,
-        totalDurationMs: 0,
-        wallClockMs: null,
-        retries: 0,
-        incompleteTaskIds: []
-      };
-      let firstDispatch = null;
-      let lastTerminal = null;
-      for (const task of tasks) {
-        if (task.status === "completed") stats.completed += 1;
-        else if (task.status === "failed") stats.failed += 1;
-        stats.retries += task.requeueCount;
-        if (task.incompleteEvidence) {
-          stats.incompleteTaskIds.push(task.taskId);
-          continue;
-        }
-        if (task.durationMs !== null) stats.totalDurationMs += task.durationMs;
-        const dispatchTime = parseTime(task.dispatchedAt);
-        const terminalTime = parseTime(task.terminalAt);
-        if (dispatchTime !== null && (firstDispatch === null || dispatchTime < firstDispatch)) firstDispatch = dispatchTime;
-        if (terminalTime !== null && (lastTerminal === null || terminalTime > lastTerminal)) lastTerminal = terminalTime;
-      }
-      if (firstDispatch !== null && lastTerminal !== null && lastTerminal >= firstDispatch) {
-        stats.wallClockMs = lastTerminal - firstDispatch;
-      }
-      return stats;
-    }
-    var init_mesh_task_stats = __esm2({
-      "src/mesh/mesh-task-stats.ts"() {
-        "use strict";
-        init_mesh_ledger();
-        init_mesh_work_queue();
-      }
-    });
     function truncateString(value, maxChars) {
       if (value.length <= maxChars) return value;
       if (maxChars <= 12) return value.slice(0, Math.max(0, maxChars));
@@ -47943,6 +47883,7 @@ ${blocks.join("\n\n")}`;
       const taskId = readNonEmptyString(metadata.taskId) || readNonEmptyString(readRecord2(metadata.payload)?.taskId);
       const jobId = readRefineJobId2(event);
       const timestamp2 = metadata.timestamp !== void 0 && metadata.timestamp !== null ? String(metadata.timestamp) : "";
+      const alertReason = COORDINATOR_ALERT_EVENTS_WITH_REASON_FINGERPRINT.has(event.event) ? readNonEmptyString(metadata.reason) : void 0;
       return [
         event.meshId,
         event.event,
@@ -47951,14 +47892,35 @@ ${blocks.join("\n\n")}`;
         providerSessionId || "",
         taskId || "",
         jobId || "",
-        timestamp2 || ""
+        timestamp2 || "",
+        ...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;
       }
@@ -48181,6 +48143,7 @@ ${blocks.join("\n\n")}`;
           dispatchedBy: event.dispatchedBy ? JSON.stringify(event.dispatchedBy) : null,
           intendedFor: event.intendedFor ? JSON.stringify(event.intendedFor) : null
         });
+        recordDurableTerminalDedup(event, fingerprint);
         return true;
       } catch (e) {
         LOG2.error(
@@ -48400,6 +48363,8 @@ ${blocks.join("\n\n")}`;
     var warnedV2Violations;
     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;
@@ -48450,6 +48415,10 @@ ${blocks.join("\n\n")}`;
         warnedV2Violations = /* @__PURE__ */ new Set();
         loggedSqlitePendingDrainFailure = false;
         TERMINAL_COMPLETION_EVENTS = /* @__PURE__ */ new Set(["agent:generating_completed", "agent:stopped"]);
+        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";
@@ -48470,6 +48439,245 @@ ${blocks.join("\n\n")}`;
         };
       }
     });
+    function s(v) {
+      return typeof v === "string" && v.trim() ? v.trim() : "";
+    }
+    function meshEventTraceKey(ctx) {
+      const segs = [`task=${s(ctx.taskId) || "-"}`];
+      const eventId = s(ctx.eventId);
+      if (eventId) segs.push(`evt=${eventId}`);
+      segs.push(`sess=${s(ctx.sessionId) || "-"}`);
+      const nodeId = s(ctx.nodeId);
+      if (nodeId) segs.push(`node=${nodeId}`);
+      const meshId = s(ctx.meshId);
+      if (meshId) segs.push(`mesh=${meshId}`);
+      const event = s(ctx.event);
+      if (event) segs.push(`event=${event}`);
+      return segs.join(" ");
+    }
+    function traceMeshEventStage(stage, ctx, detail) {
+      LOG2.info(CAT, `[stage:${stage}] ${meshEventTraceKey(ctx)}${detail ? ` \u2014 ${detail}` : ""}`);
+    }
+    function traceMeshEventDrop(reason, ctx, detail) {
+      LOG2.warn(CAT, `[drop:${reason}] ${meshEventTraceKey(ctx)}${detail ? ` \u2014 ${detail}` : ""}`);
+    }
+    var CAT;
+    var init_mesh_event_trace = __esm2({
+      "src/mesh/mesh-event-trace.ts"() {
+        "use strict";
+        init_logger();
+        CAT = "EvtTrace";
+      }
+    });
+    function taskIsParked(task) {
+      return !!readNonEmptyString(task?.parked?.reason);
+    }
+    function buildParkingRecord(task, reason, nowIso = (/* @__PURE__ */ new Date()).toISOString()) {
+      return {
+        reason,
+        parkedAt: nowIso,
+        // Mirror the ORIGINAL address. `targetSessionId` also stays on the row
+        // (that is what keeps the row unclaimable), but a later re-target
+        // overwrites it — this copy is what still answers "who was this delta
+        // written for?" after the coordinator has moved it.
+        ...readNonEmptyString(task.targetSessionId) ? { targetSessionId: task.targetSessionId } : {},
+        ...readNonEmptyString(task.targetNodeId) ? { targetNodeId: task.targetNodeId } : {}
+      };
+    }
+    function parkedAgeMs(task, nowMs = Date.now()) {
+      const parkedAt = readNonEmptyString(task.parked?.parkedAt);
+      if (!parkedAt) return null;
+      const parsed = Date.parse(parkedAt);
+      return Number.isFinite(parsed) ? nowMs - parsed : null;
+    }
+    function parkedTaskRetentionExpired(task, nowMs = Date.now(), retentionMs = PARKED_TASK_RETENTION_MS) {
+      if (!taskIsParked(task)) return false;
+      const age = parkedAgeMs(task, nowMs);
+      return age !== null && age >= retentionMs;
+    }
+    function buildParkedTaskNotice(taskId, targetSessionId, reason) {
+      const addressee = readNonEmptyString(targetSessionId);
+      return `The delta was addressed to session '${addressee || "(unknown)"}' and that pin went stale (${reason || PARK_REASON_PIN_EXPIRED}), so the task is now PARKED \u2014 held for you, deliberately NOT re-homed onto another session. A message written for one session's context becomes a context-free instruction anywhere else, so the daemon will not choose a new addressee for you. The task is claimable by nobody until you act on it, and it is dropped (as a terminal failure, with another notification) if left parked for ${Math.round(PARKED_TASK_RETENTION_MS / 36e5)}h. Four ways out \u2014 inspect it with mesh_view_queue (parked rows are listed under parkedTasks with their original addressee), then either re-target it with mesh_queue_requeue(task_id='${taskId}', target_session_id='<live session>') \u2014 or clear_target_session to let any compatible session take it; REWRITE it first with mesh_queue_requeue(task_id='${taskId}', message='<updated instruction>') if the situation moved on while it waited (the common case: the worker already did the part your delta was about); or cancel it with mesh_queue_cancel(task_id='${taskId}') if it is no longer wanted. Any requeue unparks the task.`;
+    }
+    function notifyCoordinatorOfParkedTaskDropped(meshId, task) {
+      const taskId = task.id;
+      const addressee = readNonEmptyString(task.parked?.targetSessionId);
+      const hours = Math.round(PARKED_TASK_RETENTION_MS / 36e5);
+      const coordinatorMessage = `[System] A PARKED mesh task was dropped after ${hours}h with no coordinator decision.
+Task ${taskId} was parked because its delta was addressed to session '${addressee || "(unknown)"}' and that pin went stale. It was held \u2014 claimable by nobody \u2014 waiting for you to re-target, rewrite, or cancel it. That never happened, so it is now marked FAILED (${PARK_RETENTION_EXPIRED_REASON}) and any dependent tasks have been unblocked.
+The instruction it carried was never delivered to anyone. If it still matters, re-enqueue it (mesh_enqueue_task) against a live session; the failed row remains in the queue as the audit record. To avoid this next time, check parkedTasks in mesh_view_queue \u2014 parked rows are surfaced there from the moment they park.`;
+      const nodeLabel = readNonEmptyString(task.targetNodeId) || readNonEmptyString(task.parked?.targetNodeId) || meshId;
+      try {
+        const targetCoordinatorDaemonId = readNonEmptyString(loadConfig2().machineId);
+        const targetCoordinatorSessionId = readNonEmptyString(task.sourceCoordinatorSessionId);
+        queuePendingMeshCoordinatorEvent({
+          event: "mesh:dispatch_blocked",
+          meshId,
+          nodeLabel,
+          metadataEvent: {
+            source: "mesh_parked_task_retention_expired",
+            taskId,
+            reason: PARK_RETENTION_EXPIRED_REASON,
+            ...addressee ? { parkedTargetSessionId: addressee } : {},
+            coordinatorMessage
+          },
+          coordinatorMessage,
+          queuedAt: Date.now(),
+          ...targetCoordinatorDaemonId ? { targetCoordinatorDaemonId } : {},
+          ...targetCoordinatorSessionId ? { targetCoordinatorSessionId } : {}
+        });
+      } catch (e) {
+        LOG2.warn("MeshQueue", `Failed to surface parked-task retention drop for task ${taskId} (mesh ${meshId}): ${e?.message || e}`);
+      }
+    }
+    function parkExpiredTargetPin(meshId, task, verdict, ttlMs, park) {
+      if (!verdict.expired) return false;
+      const parked = park(meshId, task.id, PARK_REASON_PIN_EXPIRED);
+      if (parked) {
+        noteTargetPinCleared(PARK_REASON_PIN_EXPIRED);
+        traceMeshEventDrop("target_session_pin_expired", {
+          taskId: task.id,
+          sessionId: readNonEmptyString(task.targetSessionId),
+          nodeId: readNonEmptyString(task.targetNodeId),
+          meshId,
+          event: "agent:ready"
+        }, `unproductive ${Math.round((verdict.ageMs ?? 0) / 1e3)}s \u2265 ttl ${Math.round(ttlMs / 1e3)}s \u2192 task PARKED (held for the coordinator, NOT re-homed)`);
+      }
+      return true;
+    }
+    function settleParkedQueueTask(meshId, task, markSkip, sweep) {
+      const swept = sweep(meshId, task.id);
+      if (swept) {
+        notifyCoordinatorOfParkedTaskDropped(meshId, task);
+        return "swept";
+      }
+      markSkip(PARKED_SKIP_REASON);
+      return "held";
+    }
+    function logTaskParked(meshId, taskId, reason, targetSessionId) {
+      LOG2.warn("MeshQueue", `PIN-PARKING: task ${taskId} (mesh ${meshId}) PARKED (${reason})${targetSessionId ? ` \u2014 original addressee session ${targetSessionId}` : ""}; it is claimable by nobody until the coordinator re-targets, edits, or cancels it.`);
+    }
+    var PARKED_TASK_RETENTION_MS;
+    var PARK_REASON_PIN_EXPIRED;
+    var PARKED_SKIP_REASON;
+    var PARK_RETENTION_EXPIRED_REASON;
+    var init_mesh_task_parking = __esm2({
+      "src/mesh/mesh-task-parking.ts"() {
+        "use strict";
+        init_logger();
+        init_mesh_events_utils();
+        init_mesh_events_pending();
+        init_mesh_turn_ledger();
+        init_mesh_event_trace();
+        init_config();
+        PARKED_TASK_RETENTION_MS = 24 * 60 * 6e4;
+        PARK_REASON_PIN_EXPIRED = "target_session_pin_expired_parked";
+        PARKED_SKIP_REASON = "target_session_pin_parked";
+        PARK_RETENTION_EXPIRED_REASON = "parked_task_retention_expired";
+      }
+    });
+    function readPayloadTaskId(entry) {
+      const value = entry.payload?.taskId;
+      return typeof value === "string" && value.trim() ? value.trim() : "";
+    }
+    function parseTime(value) {
+      if (!value) return null;
+      const parsed = new Date(value).getTime();
+      return Number.isFinite(parsed) ? parsed : null;
+    }
+    function computeMeshTaskStats(meshId, opts) {
+      const queue = getQueue(meshId);
+      const queueById = new Map(queue.map((task) => [task.id, task]));
+      let targetIds;
+      if (opts?.taskIds?.length) {
+        targetIds = [...new Set(opts.taskIds)];
+      } else if (opts?.missionId) {
+        targetIds = queue.filter((task) => task.missionId === opts.missionId).map((task) => task.id);
+      } else {
+        targetIds = queue.map((task) => task.id);
+      }
+      if (targetIds.length === 0) return [];
+      const targetSet = new Set(targetIds);
+      const entries = readLedgerEntries(meshId, { tail: opts?.tail ?? 1e3 });
+      const dispatches = /* @__PURE__ */ new Map();
+      const terminals = /* @__PURE__ */ new Map();
+      for (const entry of entries) {
+        const taskId = readPayloadTaskId(entry);
+        if (!taskId || !targetSet.has(taskId)) continue;
+        if (entry.kind === "task_dispatched") {
+          const existing = dispatches.get(taskId);
+          if (existing) existing.count += 1;
+          else dispatches.set(taskId, { first: entry.timestamp, count: 1 });
+        } else if (entry.kind === "task_completed" || entry.kind === "task_failed") {
+          terminals.set(taskId, { at: entry.timestamp, kind: entry.kind });
+        }
+      }
+      return targetIds.map((taskId) => {
+        const queueEntry = queueById.get(taskId);
+        const dispatch = dispatches.get(taskId);
+        const terminal = terminals.get(taskId);
+        const status = queueEntry?.status ?? (terminal ? terminal.kind === "task_completed" ? "completed" : "failed" : "unknown");
+        const isTerminalStatus = status === "completed" || status === "failed" || status === "cancelled";
+        const dispatchTime = parseTime(dispatch?.first ?? queueEntry?.dispatchTimestamp);
+        const terminalTime = parseTime(terminal?.at);
+        const stats = {
+          taskId,
+          status,
+          dispatchedAt: dispatch?.first ?? queueEntry?.dispatchTimestamp ?? null,
+          terminalAt: terminal?.at ?? null,
+          terminalKind: terminal?.kind ?? null,
+          durationMs: null,
+          dispatchCount: dispatch?.count ?? 0,
+          requeueCount: queueEntry?.requeueCount ?? 0
+        };
+        if (dispatchTime !== null && terminalTime !== null && terminalTime >= dispatchTime) {
+          stats.durationMs = terminalTime - dispatchTime;
+        } else if (isTerminalStatus) {
+          stats.incompleteEvidence = true;
+        }
+        return stats;
+      });
+    }
+    function computeMeshMissionStats(meshId, missionId) {
+      const tasks = computeMeshTaskStats(meshId, { missionId });
+      const stats = {
+        missionId,
+        taskCount: tasks.length,
+        completed: 0,
+        failed: 0,
+        totalDurationMs: 0,
+        wallClockMs: null,
+        retries: 0,
+        incompleteTaskIds: []
+      };
+      let firstDispatch = null;
+      let lastTerminal = null;
+      for (const task of tasks) {
+        if (task.status === "completed") stats.completed += 1;
+        else if (task.status === "failed") stats.failed += 1;
+        stats.retries += task.requeueCount;
+        if (task.incompleteEvidence) {
+          stats.incompleteTaskIds.push(task.taskId);
+          continue;
+        }
+        if (task.durationMs !== null) stats.totalDurationMs += task.durationMs;
+        const dispatchTime = parseTime(task.dispatchedAt);
+        const terminalTime = parseTime(task.terminalAt);
+        if (dispatchTime !== null && (firstDispatch === null || dispatchTime < firstDispatch)) firstDispatch = dispatchTime;
+        if (terminalTime !== null && (lastTerminal === null || terminalTime > lastTerminal)) lastTerminal = terminalTime;
+      }
+      if (firstDispatch !== null && lastTerminal !== null && lastTerminal >= firstDispatch) {
+        stats.wallClockMs = lastTerminal - firstDispatch;
+      }
+      return stats;
+    }
+    var init_mesh_task_stats = __esm2({
+      "src/mesh/mesh-task-stats.ts"() {
+        "use strict";
+        init_mesh_ledger();
+        init_mesh_work_queue();
+      }
+    });
     var mesh_missions_exports = {};
     __export2(mesh_missions_exports, {
       COMPACT_STATUS_GOAL_PREVIEW_MAX: () => COMPACT_STATUS_GOAL_PREVIEW_MAX,
@@ -48855,11 +49063,12 @@ ${blocks.join("\n\n")}`;
       describeTaskDependencyState: () => describeTaskDependencyState,
       enqueueTask: () => enqueueTask,
       enqueueTaskGraph: () => enqueueTaskGraph,
-      expireTaskTargetPin: () => expireTaskTargetPin,
+      failRetentionExpiredParkedTask: () => failRetentionExpiredParkedTask,
       formatMeshTaskModeViolations: () => formatMeshTaskModeViolations,
       getActiveDirectDispatches: () => getActiveDirectDispatches,
       getMeshQueueRevision: () => getMeshQueueRevision,
       getMeshQueueStats: () => getMeshQueueStats,
+      getParkedTasks: () => getParkedTasks,
       getQueue: () => getQueue,
       hasPendingDependents: () => hasPendingDependents,
       insertDirectDispatch: () => insertDirectDispatch,
@@ -48871,6 +49080,7 @@ ${blocks.join("\n\n")}`;
       normalizeMeshCapabilityTags: () => normalizeMeshCapabilityTags,
       normalizeMeshTaskMode: () => normalizeMeshTaskMode,
       normalizeMeshTaskPriority: () => normalizeMeshTaskPriority,
+      parkTaskTargetPin: () => parkTaskTargetPin,
       reclaimStrandedAssignedTask: () => reclaimStrandedAssignedTask,
       recordDirectDispatchTask: () => recordDirectDispatchTask,
       recordMeshToolCall: () => recordMeshToolCall,
@@ -49352,6 +49562,7 @@ ${blocks.join("\n\n")}`;
         entry.status = "cancelled";
         entry.cancelledAt = now;
         if (opts?.reason) entry.cancelReason = opts.reason;
+        delete entry.parked;
         delete entry.assignedNodeId;
         delete entry.assignedSessionId;
         delete entry.assignedProviderType;
@@ -49384,6 +49595,12 @@ ${blocks.join("\n\n")}`;
       if (value) lastCancelledTaskAssignment.delete(key2);
       return value;
     }
+    function applyRequeueMessageEdit(entry, message) {
+      if (typeof message !== "string") return;
+      const next = message.trim();
+      if (!next || next === entry.message) return;
+      entry.message = next;
+    }
     function requeueTask(meshId, taskId, opts) {
       requireMeshHostQueueOwner(opts);
       const result = withQueueLock(meshId, () => {
@@ -49418,6 +49635,8 @@ ${blocks.join("\n\n")}`;
           entry.requeuedAt = (/* @__PURE__ */ new Date()).toISOString();
           entry.dispatchFailureCount = dispatchFailures;
           if (opts?.reason) entry.requeueReason = opts.reason;
+          applyRequeueMessageEdit(entry, opts?.message);
+          delete entry.parked;
           const backoffMs = DISPATCH_RETRY_BACKOFF_BASE_MS * Math.pow(2, dispatchFailures - 1);
           entry.notBefore = resolveNotBefore(Math.min(backoffMs, DISPATCH_RETRY_BACKOFF_MAX_MS));
           MeshRuntimeStore.getInstance().updateQueueEntry(entry);
@@ -49446,6 +49665,8 @@ ${blocks.join("\n\n")}`;
         entry.requeuedAt = (/* @__PURE__ */ new Date()).toISOString();
         entry.requeueCount = currentCount + 1;
         if (opts?.reason) entry.requeueReason = opts.reason;
+        applyRequeueMessageEdit(entry, opts?.message);
+        delete entry.parked;
         const notBefore = resolveNotBefore(opts?.notBefore);
         if (notBefore) entry.notBefore = notBefore;
         else delete entry.notBefore;
@@ -49455,24 +49676,46 @@ ${blocks.join("\n\n")}`;
       if (result?.missionAffected) scheduleMissionCloseCandidateCheck(meshId, [result.entry, ...result.cascaded]);
       return result ? result.entry : null;
     }
-    function expireTaskTargetPin(meshId, taskId, opts) {
+    function parkTaskTargetPin(meshId, taskId, opts) {
       requireMeshHostQueueOwner(opts);
       return withQueueLock(meshId, () => {
         const entry = MeshRuntimeStore.getInstance().findQueueEntryById(meshId, taskId);
         if (!entry) return null;
         if (entry.status !== "pending") return null;
         if (!entry.targetSessionId && !entry.targetNodeId) return null;
-        const clearedSession = entry.targetSessionId;
-        const clearedNode = opts?.clearTargetNode ? entry.targetNodeId : void 0;
-        delete entry.targetSessionId;
-        if (opts?.clearTargetNode) delete entry.targetNodeId;
-        entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-        if (opts?.reason) entry.requeueReason = opts.reason;
+        if (taskIsParked(entry)) return null;
+        const reason = opts?.reason || PARK_REASON_PIN_EXPIRED;
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        entry.parked = buildParkingRecord(entry, reason, now);
+        entry.updatedAt = now;
+        entry.requeueReason = reason;
         MeshRuntimeStore.getInstance().updateQueueEntry(entry);
-        LOG2.warn("MeshQueue", `Expired stale target pin on task ${taskId} (mesh ${meshId}): cleared${clearedSession ? ` targetSessionId=${clearedSession}` : ""}${clearedNode ? ` targetNodeId=${clearedNode}` : ""} (${opts?.reason ?? "target_pin_expired"}) \u2014 the task is now claimable by any compatible session`);
+        logTaskParked(meshId, taskId, reason, entry.targetSessionId);
         return entry;
       });
     }
+    function failRetentionExpiredParkedTask(meshId, taskId, opts) {
+      requireMeshHostQueueOwner(opts);
+      const result = withQueueLock(meshId, () => {
+        const entry = MeshRuntimeStore.getInstance().findQueueEntryById(meshId, taskId);
+        if (!entry) return null;
+        if (entry.status !== "pending" || !taskIsParked(entry)) return null;
+        if (!parkedTaskRetentionExpired(entry, Date.now(), opts?.retentionMs)) return null;
+        const hours = Math.round((opts?.retentionMs ?? PARKED_TASK_RETENTION_MS) / 36e5);
+        entry.status = "failed";
+        entry.cancelReason = `${PARK_RETENTION_EXPIRED_REASON}: parked for over ${hours}h (addressed to session ${entry.parked?.targetSessionId || "unknown"}) with no coordinator decision`;
+        entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        MeshRuntimeStore.getInstance().updateQueueEntry(entry);
+        const cascaded = propagateDependencyFailure(meshId, taskId);
+        LOG2.warn("MeshQueue", `PIN-PARKING retention: task ${taskId} (mesh ${meshId}) stayed parked past ${hours}h with no coordinator decision; failed it (dependents unblocked). This is reported to the coordinator, never a silent drop.`);
+        return { entry, cascaded, missionAffected: true };
+      });
+      if (result?.missionAffected) scheduleMissionCloseCandidateCheck(meshId, [result.entry, ...result.cascaded]);
+      return result ? result.entry : null;
+    }
+    function getParkedTasks(meshId) {
+      return getQueue(meshId, { status: ["pending"] }).filter(taskIsParked);
+    }
     function reclaimStrandedAssignedTask(meshId, taskId, opts) {
       requireMeshHostQueueOwner(opts);
       const result = withQueueLock(meshId, () => {
@@ -49700,6 +49943,7 @@ ${blocks.join("\n\n")}`;
         init_mesh_graph_derived_failure();
         init_dist();
         init_mesh_task_mode_guardrail();
+        init_mesh_task_parking();
         init_mesh_task_mode_guardrail();
         ACTIVE_MESH_QUEUE_STATUSES = ["pending", "assigned"];
         HISTORICAL_MESH_QUEUE_STATUSES = ["completed", "failed", "cancelled"];
@@ -52571,6 +52815,7 @@ ${blocks.join("\n\n")}`;
         init_config();
         init_mesh_ledger();
         init_mesh_work_queue();
+        init_mesh_task_parking();
         init_mesh_graph_schema();
         init_mesh_graph_store();
         init_slot_model_enforcement();
@@ -53539,7 +53784,8 @@ ${blocks.join("\n\n")}`;
               };
               const allowedTaskDifficulties = opts?.allowedTaskDifficulties;
               const difficultyAllows = (candidate) => !allowedTaskDifficulties || candidate.difficulty === "freeform" || !candidate.difficulty || allowedTaskDifficulties.includes(candidate.difficulty);
-              const entry = candidates.find((candidate) => nodeSatisfiesRequiredTags(candidate.requiredTags, capabilityTags) && dependenciesSatisfied(candidate) && notBeforeReady(candidate) && convergenceAllows(candidate) && targetMatches(candidate) && difficultyAllows(candidate) && parallelCapsAllow(candidate) && nodeConflictAllows(candidate));
+              const notParked = (candidate) => !taskIsParked(candidate);
+              const entry = candidates.find((candidate) => nodeSatisfiesRequiredTags(candidate.requiredTags, capabilityTags) && dependenciesSatisfied(candidate) && notBeforeReady(candidate) && notParked(candidate) && convergenceAllows(candidate) && targetMatches(candidate) && difficultyAllows(candidate) && parallelCapsAllow(candidate) && nodeConflictAllows(candidate));
               if (!entry) return null;
               const now = (/* @__PURE__ */ new Date()).toISOString();
               entry.status = "assigned";
@@ -54638,7 +54884,11 @@ ${blocks.join("\n\n")}`;
           }
           /** 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(
@@ -55255,6 +55505,7 @@ ${blocks.join("\n\n")}`;
       compactLedger: () => compactLedger,
       enforceAllLedgerRotationCaps: () => enforceAllLedgerRotationCaps,
       enforceLedgerRotationCap: () => enforceLedgerRotationCap,
+      extractJsonObjectFromSummary: () => extractJsonObjectFromSummary,
       getLedgerDir: () => getLedgerDir2,
       getLedgerSummary: () => getLedgerSummary,
       getSessionRecoveryContext: () => getSessionRecoveryContext,
@@ -58579,8 +58830,8 @@ ${rendered}`, "utf-8");
         if (!(0, import_node_fs3.existsSync)(filePath)) return;
         if (owned) {
           try {
-            const fs59 = require("fs");
-            fs59.unlinkSync(filePath);
+            const fs61 = require("fs");
+            fs61.unlinkSync(filePath);
           } catch {
           }
           return;
@@ -58593,8 +58844,8 @@ ${rendered}`, "utf-8");
         const remaining = (existing.slice(0, openIdx) + existing.slice(closeIdx + CLOSE.length)).replace(/^\s*\n+/, "").replace(/\n+\s*$/, "");
         if (!remaining.trim()) {
           try {
-            const fs59 = require("fs");
-            fs59.unlinkSync(filePath);
+            const fs61 = require("fs");
+            fs61.unlinkSync(filePath);
           } catch {
           }
         } else {
@@ -59520,6 +59771,7 @@ ${rendered}`, "utf-8");
       void opts.registerNode;
       return {
         nowMs: () => Date.now(),
+        resolveBaseRevision: (req) => defaultResolveBaseRevision(req),
         createWorktree: (req) => defaultCreateWorktree(req),
         findOwnedWorktree: (req) => defaultFindOwnedWorktree(req),
         inspectWorktree: (req) => defaultInspectWorktree(req),
@@ -59565,6 +59817,40 @@ ${rendered}`, "utf-8");
         env: gitChildEnv()
       });
     }
+    async function defaultResolveBaseRevision(req) {
+      let repoRoot;
+      try {
+        ({ repoRoot } = resolveSourceRepo(req.meshId, req.sourceNodeId));
+      } catch {
+        return void 0;
+      }
+      try {
+        const { stdout } = await execFileAsync4("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+          cwd: repoRoot,
+          encoding: "utf8",
+          timeout: GIT_TIMEOUT_MS3,
+          maxBuffer: GIT_MAX_BUFFER2,
+          windowsHide: true,
+          env: gitChildEnv()
+        });
+        const branch = stdout.trim();
+        if (branch && branch !== "HEAD") return branch;
+      } catch {
+      }
+      try {
+        const { stdout } = await execFileAsync4("git", ["rev-parse", "HEAD"], {
+          cwd: repoRoot,
+          encoding: "utf8",
+          timeout: GIT_TIMEOUT_MS3,
+          maxBuffer: GIT_MAX_BUFFER2,
+          windowsHide: true,
+          env: gitChildEnv()
+        });
+        return stdout.trim() || void 0;
+      } catch {
+        return void 0;
+      }
+    }
     async function defaultCreateWorktree(req) {
       const existing = await defaultFindOwnedWorktree({
         meshId: req.meshId,
@@ -59910,8 +60196,26 @@ ${rendered}`, "utf-8");
         }
         return compensateClaimedIntent({ ...intent, ownerTag }, ports, generation);
       }
-      if (intent.sagaState === "declared" && !intent.baseRevision) {
-        return { graphId, workspaceRef, sagaState: "declared", action: "skipped_no_base" };
+      let baseRevision = intent.baseRevision;
+      if (intent.sagaState === "declared" && !baseRevision) {
+        const derived = await ports.resolveBaseRevision({
+          meshId: intent.meshId,
+          graphId,
+          workspaceRef,
+          sourceNodeId: intent.sourceNodeId
+        }).catch(() => void 0);
+        if (derived) {
+          store.transaction(() => {
+            store.graphStore().patchWorkspaceIntent(graphId, workspaceRef, {
+              baseRevision: derived
+            }, nowIso, { leaseGeneration: generation });
+          });
+          baseRevision = derived;
+          LOG2.info("MeshGraphWorkspace", `derived base revision '${derived}' for ${graphId}/${workspaceRef} from source node ${intent.sourceNodeId ?? "base"}`);
+        } else {
+          LOG2.debug("MeshGraphWorkspace", `${graphId}/${workspaceRef} stays declared: no base_revision and none derivable from source node ${intent.sourceNodeId ?? "(none declared)"}`);
+          return { graphId, workspaceRef, sagaState: "declared", action: "skipped_no_base" };
+        }
       }
       store.transaction(() => {
         store.graphStore().patchWorkspaceIntent(graphId, workspaceRef, {
@@ -59919,7 +60223,7 @@ ${rendered}`, "utf-8");
           ownerTag
         }, nowIso, { leaseGeneration: generation });
       });
-      return prepareClaimedIntent({ ...intent, sagaState: "preparing", ownerTag }, ports, generation, faults);
+      return prepareClaimedIntent({ ...intent, baseRevision, sagaState: "preparing", ownerTag }, ports, generation, faults);
     }
     async function prepareClaimedIntent(intent, ports, generation, faults) {
       const store = MeshRuntimeStore.getInstance();
@@ -62371,6 +62675,13 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       }
       return false;
     }
+    function isReplayOfRecordedSynthSummary(recorded, incoming) {
+      if (recorded === incoming) return true;
+      if (!recorded || !incoming) return false;
+      const [shorter, longer] = recorded.length <= incoming.length ? [recorded, incoming] : [incoming, recorded];
+      if (!longer.startsWith(shorter)) return false;
+      return longer.length <= shorter.length + 32;
+    }
     function hasIdenticalSynthesizedTerminal(args) {
       const entries = readLedgerEntriesByKind(args.meshId, ["task_dispatched", ...TERMINAL_LEDGER_KINDS2]);
       let afterDispatch = !args.dispatchEntryId && !args.dispatchTimestamp;
@@ -62390,7 +62701,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         if (entry.kind !== "task_completed" && entry.kind !== "task_failed") continue;
         const diagnostic = readRecord2(entry.payload?.completionDiagnostic);
         if (readNonEmptyString(diagnostic?.reason) !== "direct_task_transcript_reconciliation") continue;
-        if (readNonEmptyString(entry.payload?.finalSummary) !== args.finalSummary) continue;
+        if (!isReplayOfRecordedSynthSummary(readNonEmptyString(entry.payload?.finalSummary), args.finalSummary)) continue;
         const terminalTaskId = readNonEmptyString(entry.payload?.taskId);
         if (terminalTaskId && terminalTaskId !== args.taskId) continue;
         if (terminalTaskId && terminalTaskId === args.taskId) return true;
@@ -65073,36 +65384,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         init_chat_history();
       }
     });
-    function s(v) {
-      return typeof v === "string" && v.trim() ? v.trim() : "";
-    }
-    function meshEventTraceKey(ctx) {
-      const segs = [`task=${s(ctx.taskId) || "-"}`];
-      const eventId = s(ctx.eventId);
-      if (eventId) segs.push(`evt=${eventId}`);
-      segs.push(`sess=${s(ctx.sessionId) || "-"}`);
-      const nodeId = s(ctx.nodeId);
-      if (nodeId) segs.push(`node=${nodeId}`);
-      const meshId = s(ctx.meshId);
-      if (meshId) segs.push(`mesh=${meshId}`);
-      const event = s(ctx.event);
-      if (event) segs.push(`event=${event}`);
-      return segs.join(" ");
-    }
-    function traceMeshEventStage(stage, ctx, detail) {
-      LOG2.info(CAT, `[stage:${stage}] ${meshEventTraceKey(ctx)}${detail ? ` \u2014 ${detail}` : ""}`);
-    }
-    function traceMeshEventDrop(reason, ctx, detail) {
-      LOG2.warn(CAT, `[drop:${reason}] ${meshEventTraceKey(ctx)}${detail ? ` \u2014 ${detail}` : ""}`);
-    }
-    var CAT;
-    var init_mesh_event_trace = __esm2({
-      "src/mesh/mesh-event-trace.ts"() {
-        "use strict";
-        init_logger();
-        CAT = "EvtTrace";
-      }
-    });
     function isAnthropicProvider(providerType) {
       const p = typeof providerType === "string" ? providerType.trim().toLowerCase() : "";
       return p.length > 0 && ANTHROPIC_PROVIDER_TYPES.has(p);
@@ -65577,6 +65858,43 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       const anchorMs = Date.parse(task.requeuedAt || task.createdAt || "");
       return Number.isFinite(anchorMs) ? nowMs - anchorMs : null;
     }
+    function resolveTargetPinTtlVerdict(components, task, nowMs = Date.now()) {
+      const wallAgeMs = targetPinAgeMs(task, nowMs);
+      if (wallAgeMs === null) return { expired: false, ageMs: null, suspended: false };
+      const targetSessionId = readNonEmptyString(task.targetSessionId);
+      const key2 = `${task.meshId}::${task.id}`;
+      const prior = targetPinGeneratingCreditMs.get(key2);
+      const generating = !!targetSessionId && resolveSessionBusyVerdict(components, targetSessionId) === "GENERATING";
+      let creditMs = prior?.creditMs ?? 0;
+      if (generating && prior) {
+        creditMs += Math.max(0, nowMs - prior.lastSeenMs);
+      }
+      targetPinGeneratingCreditMs.set(key2, { creditMs, lastSeenMs: nowMs });
+      const unproductiveAgeMs = Math.max(0, wallAgeMs - creditMs);
+      return {
+        // A tick on which the addressee is OBSERVABLY GENERATING never expires the pin,
+        // independently of the accumulated credit.
+        //
+        // The credit ledger alone is not sufficient here, and the difference is the
+        // whole live defect. Credit only accrues from the SECOND observation onward
+        // (the first has no prior interval to bank), and it is in-memory — so a pin
+        // that crossed the wall-clock TTL while the daemon was not watching, or before
+        // a restart, would arrive at its very first post-restart observation with zero
+        // credit and expire on the spot, while the session it is addressed to is
+        // visibly mid-turn. That is exactly the observed failure (`unclaimed 902s`
+        // logged on an `agent:ready`, i.e. at the end of real work) reproduced by a
+        // different route.
+        //
+        // Gating on the live verdict makes "is the addressee working right now?" the
+        // decisive question and leaves the credit ledger as what it should be: an
+        // optimisation that stops intermittent work from silently burning the budget.
+        // It cannot make a pin immortal — the verdict is re-evaluated every tick from
+        // live state and only a LOCAL, observably-generating session can produce it.
+        expired: !generating && unproductiveAgeMs >= TARGET_SESSION_PIN_TTL_MS,
+        ageMs: unproductiveAgeMs,
+        suspended: generating
+      };
+    }
     function resolveDeadTargetVerdict(components, meshId, mesh, task) {
       const NOT_DEAD = { dead: false, nodeDead: false, reason: "" };
       const targetSessionId = readNonEmptyString(task.targetSessionId);
@@ -65652,6 +65970,21 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         summary: "the node's workspace is dirty, so auto-launch is blocked to avoid clobbering uncommitted changes",
         nextAction: "Clean or commit the node's working tree (or fast-forward it); the task will then auto-assign."
       };
+      if (reason === PARKED_SKIP_REASON) {
+        const base = "it was pinned to a specific session, that pin went stale, and the task is now PARKED \u2014 deliberately held for you rather than re-homed onto another session, because a delta written for one session's context becomes a context-free instruction anywhere else";
+        if (evidence === "consumed") return {
+          summary: `${base}. The delivery record shows the addressed session DID receive and start acting on this message, so the parked row is a bookkeeping remnant, not a lost delta`,
+          nextAction: "Do NOT re-send it. Confirm with mesh_read_chat / mesh_read_terminal that the work is under way, then clear the park with mesh_queue_cancel (or requeue it only if you genuinely want it run again)."
+        };
+        if (evidence === "delivered") return {
+          summary: `${base}. The message WAS handed to that session's transport but no turn start was echoed, so whether it acted on it is unconfirmed`,
+          nextAction: "Check the session (mesh_read_chat / mesh_read_terminal) before acting. If it is already handling it, cancel the parked row; if not, mesh_queue_requeue with target_session_id=<live session> \u2014 and pass message=<rewritten instruction> if the situation moved on while it waited."
+        };
+        return {
+          summary: `${base}. No delivery to that session was ever recorded, so the message did not reach it and the worker is still acting on its previous instructions`,
+          nextAction: "Re-target it with mesh_queue_requeue(target_session_id=<live session>), or drop the pin with clear_target_session to let any compatible session take it. Re-read the work produced meanwhile and pass message=<rewritten instruction> if the delta is now partly stale; mesh_queue_cancel if it is moot."
+        };
+      }
       if (reason === "target_session_pin_expired") {
         if (evidence === "consumed") return {
           summary: "it was pinned to a specific session and the pin TTL expired before the queue row was claimed \u2014 but the delivery record shows this session DID receive and start acting on the message (a turn was started for it), so the queue row lagging is a bookkeeping gap, not a lost delta",
@@ -65698,11 +66031,11 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       const targetCoordinatorDaemonId = readNonEmptyString(loadConfig2().machineId);
       const targetCoordinatorSessionId = readNonEmptyString(task?.sourceCoordinatorSessionId);
       const nodeLabel = readNonEmptyString(nodeId) || readNonEmptyString(task?.targetNodeId);
-      const evidence = reason === "target_session_pin_expired" ? resolveTaskDeliveryEvidence(meshId, taskId) : void 0;
+      const evidence = reason === "target_session_pin_expired" || reason === PARKED_SKIP_REASON ? resolveTaskDeliveryEvidence(meshId, taskId) : void 0;
       const { summary, nextAction } = actionableSkipGuidance(reason, evidence);
       const providerAvailabilityResult = reason.startsWith("provider") || reason === "missing_provider_priority";
       const reachabilityResult = reason.startsWith("remote_auto_launch");
-      const closing = reason === "target_session_pin_expired" ? "The stale pin has already been cleared, so the task is now claimable by any compatible session \u2014 the action above is about the session it was originally addressed to." : providerAvailabilityResult ? "This result needs action if it persists: a later provider-status refresh or an already-starting usable session can clear it, but a genuinely missing, disabled, or misconfigured provider will keep the task pending until you fix that configuration." : reachabilityResult ? "This result needs action if it persists: the node reconnecting (or re-registering its daemon id) clears it on its own, but a node that stays unreachable will keep the task pending until you bring it back or re-target the task." : "This is an actionable blocker \u2014 it will NOT clear on its own; the task stays pending until you resolve it.";
+      const closing = reason === PARKED_SKIP_REASON ? `This task is claimable by NOBODY until you act on it \u2014 no session will pick it up and no timer will re-home it. It is held for ${Math.round(PARKED_TASK_RETENTION_MS / 36e5)}h and then failed (with another notification), so it is never silently discarded. Parked rows are listed under parkedTasks in mesh_view_queue, and any mesh_queue_requeue unparks it \u2014 including one that only rewrites its message.` : reason === "target_session_pin_expired" ? "The stale pin has already been cleared, so the task is now claimable by any compatible session \u2014 the action above is about the session it was originally addressed to." : providerAvailabilityResult ? "This result needs action if it persists: a later provider-status refresh or an already-starting usable session can clear it, but a genuinely missing, disabled, or misconfigured provider will keep the task pending until you fix that configuration." : reachabilityResult ? "This result needs action if it persists: the node reconnecting (or re-registering its daemon id) clears it on its own, but a node that stays unreachable will keep the task pending until you bring it back or re-target the task." : "This is an actionable blocker \u2014 it will NOT clear on its own; the task stays pending until you resolve it.";
       const coordinatorMessage = `[System] A queued mesh task${nodeLabel ? ` for node ${nodeLabel}` : ""} is not being dispatched because ${summary}. ${nextAction} ${closing}`;
       try {
         queuePendingMeshCoordinatorEvent({
@@ -65731,6 +66064,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     var lastActionableSkipNotified;
     var DEAD_TARGET_GRACE_MS;
     var TARGET_SESSION_PIN_TTL_MS;
+    var targetPinGeneratingCreditMs;
     var init_mesh_skip_notify = __esm2({
       "src/mesh/mesh-skip-notify.ts"() {
         "use strict";
@@ -65746,6 +66080,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         init_slot_model_enforcement();
         init_mesh_queue_assignment();
         init_mesh_queue_observability();
+        init_mesh_task_parking();
         ACTIONABLE_SKIP_REASON_PREFIXES = [
           "target_node_id_unmatched",
           "no_node_satisfies_required_tags",
@@ -65768,6 +66103,14 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           // premise the delta was meant to correct. The coordinator must know its
           // addressed message lost its address.
           "target_session_pin_expired",
+          // PIN-PARKING: the reason above's successor. The pin no longer CLEARS on expiry
+          // (that silently re-homed a context-bound delta onto an arbitrary session); the
+          // task PARKS instead — held, still addressed, claimable by nobody. That state is
+          // by construction actionable and terminal-until-touched: nothing in the daemon
+          // will ever move a parked task, so if the coordinator is not told, the work is
+          // lost exactly as surely as if it had been dropped. Both reasons stay listed —
+          // the old one so a version-skewed daemon's rows still page.
+          PARKED_SKIP_REASON,
           // SLOT MODEL GUARD (absent): no slot on the node declares the task's model.
           // Permanent — no amount of waiting produces a slot, so the coordinator must
           // re-drive (adjust difficulty, target another node, ask the owner). Its
@@ -65786,6 +66129,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         lastActionableSkipNotified = /* @__PURE__ */ new Map();
         DEAD_TARGET_GRACE_MS = 6e4;
         TARGET_SESSION_PIN_TTL_MS = 15 * 6e4;
+        targetPinGeneratingCreditMs = /* @__PURE__ */ new Map();
       }
     });
     function nodesForMesh(meshId) {
@@ -66194,6 +66538,173 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         INTRA_NODE_LOSERS_MAX = 2;
       }
     });
+    function localCoordinatorDaemonId() {
+      return canonicalDaemonId(readNonEmptyString(loadConfig2().machineId));
+    }
+    function isIdleSessionState2(state) {
+      const status = readNonEmptyString(state?.status).toLowerCase();
+      if (TERMINAL_SESSION_STATUSES.includes(status)) return false;
+      return status === "idle" || state?.activeChat?.status === "waiting_input";
+    }
+    function sweepAutoLaunchOrphanSessions(components, meshId) {
+      let sessions;
+      try {
+        sessions = components.instanceManager?.getByCategory?.("cli") || [];
+      } catch {
+        return;
+      }
+      if (!sessions.length) return;
+      let queue;
+      try {
+        queue = getQueue(meshId);
+      } catch {
+        return;
+      }
+      const byId = new Map(queue.map((t) => [t.id, t]));
+      for (const inst of sessions) {
+        let state;
+        try {
+          state = inst.getState();
+        } catch {
+          continue;
+        }
+        const settings = state?.settings || {};
+        if (readNonEmptyString(settings.meshNodeFor) !== meshId) continue;
+        const originTaskId = readNonEmptyString(settings.autoLaunchedForQueueTaskId);
+        if (!originTaskId) continue;
+        const sessionId = readNonEmptyString(state?.instanceId);
+        if (!sessionId) continue;
+        if (!isIdleSessionState2(state)) continue;
+        if (sessionHasActiveAssignment(meshId, sessionId)) continue;
+        const originTask = byId.get(originTaskId);
+        const assignedElsewhere = !!originTask && originTask.status === "assigned" && !!readNonEmptyString(originTask.assignedSessionId) && !sessionIdsEquivalent(readNonEmptyString(originTask.assignedSessionId), sessionId);
+        const originGone = !originTask || originTask.status !== "pending" && originTask.status !== "assigned";
+        const dedupKey = `${meshId}::${sessionId}`;
+        if (!assignedElsewhere && !originGone) {
+          autoLaunchOrphanFirstSeenAtMs.delete(dedupKey);
+          continue;
+        }
+        const nowMs = Date.now();
+        const firstSeenAtMs = autoLaunchOrphanFirstSeenAtMs.get(dedupKey);
+        if (firstSeenAtMs === void 0) {
+          autoLaunchOrphanFirstSeenAtMs.set(dedupKey, nowMs);
+          if (autoLaunchOrphanFirstSeenAtMs.size > AUTO_LAUNCH_LEDGER_DEDUP_MAX) {
+            const oldest = autoLaunchOrphanFirstSeenAtMs.keys().next().value;
+            if (oldest !== void 0) autoLaunchOrphanFirstSeenAtMs.delete(oldest);
+          }
+          continue;
+        }
+        if (nowMs - firstSeenAtMs < AUTO_LAUNCH_ORPHAN_GRACE_MS) continue;
+        if (autoLaunchOrphanNotified.has(dedupKey)) continue;
+        autoLaunchOrphanNotified.add(dedupKey);
+        if (autoLaunchOrphanNotified.size > AUTO_LAUNCH_LEDGER_DEDUP_MAX) {
+          const oldest = autoLaunchOrphanNotified.values().next().value;
+          if (oldest !== void 0) autoLaunchOrphanNotified.delete(oldest);
+        }
+        const nodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
+        const detail = assignedElsewhere ? `task ${originTaskId} is assigned to a different session (${readNonEmptyString(originTask.assignedSessionId)})` : `task ${originTaskId} is no longer active (${originTask ? originTask.status : "absent from the queue"})`;
+        recordAutoLaunchEvent(meshId, {
+          phase: "skipped",
+          taskId: originTaskId,
+          reason: "auto_launch_orphan_session_detected",
+          nodeId,
+          sessionId
+        });
+        LOG2.warn("MeshQueue", `AUTOLAUNCH-ORPHAN-SWEEP: session ${sessionId}${nodeId ? ` on node ${nodeId}` : ""} (mesh ${meshId}) was auto-launched for task ${originTaskId} but ${detail}; it is idle with no work and will not self-recover.`);
+        try {
+          queuePendingMeshCoordinatorEvent({
+            event: "mesh:dispatch_blocked",
+            meshId,
+            nodeLabel: nodeId || meshId,
+            ...nodeId ? { nodeId } : {},
+            metadataEvent: {
+              source: "mesh_auto_launch_orphan_session",
+              taskId: originTaskId,
+              sessionId,
+              reason: "auto_launch_orphan_session_detected"
+            },
+            coordinatorMessage: `[System] Mesh session ${sessionId}${nodeId ? ` on node ${nodeId}` : ""} was auto-launched for task ${originTaskId}, but ${detail}. The session is idle with no work assigned and nothing reclaims it on its own. Reuse it for other queued work or stop it.`,
+            queuedAt: Date.now(),
+            ...readNonEmptyString(originTask?.sourceCoordinatorSessionId) ? { targetCoordinatorSessionId: readNonEmptyString(originTask.sourceCoordinatorSessionId) } : {},
+            ...localCoordinatorDaemonId() ? { targetCoordinatorDaemonId: localCoordinatorDaemonId() } : {}
+          });
+        } catch (e) {
+          LOG2.warn("MeshQueue", `AUTOLAUNCH-ORPHAN-SWEEP: failed to queue the coordinator notification for session ${sessionId}: ${e?.message || e}`);
+        }
+      }
+    }
+    function autoLaunchWriteWouldClobberWinner(meshId, taskId, args, awaitClaimWindowMs2) {
+      if (args.status === "completed" && readNonEmptyString(args.sessionId)) return false;
+      let existing;
+      try {
+        existing = getQueue(meshId).find((t) => t.id === taskId)?.autoLaunch;
+      } catch {
+        return false;
+      }
+      const heldSessionId = existing ? readNonEmptyString(existing.sessionId) : "";
+      if (!existing || existing.status !== "completed" || !heldSessionId) return false;
+      const heldAtMs = Date.parse(existing.updatedAt);
+      if (!Number.isFinite(heldAtMs) || Date.now() - heldAtMs >= awaitClaimWindowMs2) return false;
+      if (sessionIdsEquivalent(readNonEmptyString(args.sessionId), heldSessionId)) return false;
+      LOG2.info("MeshQueue", `AUTOLAUNCH-WINNER-CLOBBER: suppressed a '${args.status}' autoLaunch write for task ${taskId} (mesh ${meshId}) that would have overwritten the in-window launch record for session ${heldSessionId}; the field keeps pointing at the actually-launched session.`);
+      return true;
+    }
+    function awaitClaimWindowMs(cycles) {
+      return AUTO_LAUNCH_AWAIT_CLAIM_MS * Math.pow(2, Math.min(cycles, AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES));
+    }
+    function remoteSessionAppearsLive(meshId, sessionId) {
+      if (!sessionId) return false;
+      try {
+        return MeshRuntimeStore.getInstance().getRemoteIdleSessions(meshId).some((s2) => sessionIdsEquivalent(s2.sessionId, sessionId));
+      } catch {
+        return false;
+      }
+    }
+    function inWindowAutoLaunchSessionIdsForNode(meshId, nodeId) {
+      const nowMs = Date.now();
+      const out = [];
+      for (const task of getQueue(meshId, { status: ["pending"] })) {
+        const al = task.autoLaunch;
+        const sid = al ? readNonEmptyString(al.sessionId) : "";
+        if (!al || al.status !== "started" && al.status !== "completed" || !sid) continue;
+        if (!daemonIdsEquivalent(al.nodeId, nodeId)) continue;
+        const launchedAtMs = Date.parse(al.updatedAt);
+        const inBaseWindow = Number.isFinite(launchedAtMs) && nowMs - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS;
+        const inBackoff = autoLaunchAwaitClaimBackoff.has(`${meshId}::${task.id}`);
+        if (inBaseWindow || inBackoff) out.push(sid);
+      }
+      return out;
+    }
+    var AUTO_LAUNCH_AWAIT_CLAIM_MS;
+    var AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES;
+    var AUTO_LAUNCH_REMOTE_IDLE_TTL_MS;
+    var TERMINAL_SESSION_STATUSES;
+    var autoLaunchOrphanNotified;
+    var autoLaunchOrphanFirstSeenAtMs;
+    var AUTO_LAUNCH_ORPHAN_GRACE_MS;
+    var autoLaunchAwaitClaimBackoff;
+    var init_mesh_autolaunch_integrity = __esm2({
+      "src/mesh/mesh-autolaunch-integrity.ts"() {
+        "use strict";
+        init_config();
+        init_logger();
+        init_dist();
+        init_mesh_work_queue();
+        init_mesh_events_utils();
+        init_mesh_events_pending();
+        init_mesh_queue_observability();
+        init_mesh_scheduling_fitness();
+        init_mesh_runtime_store();
+        AUTO_LAUNCH_AWAIT_CLAIM_MS = 9e4;
+        AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES = 2;
+        AUTO_LAUNCH_REMOTE_IDLE_TTL_MS = 5 * 60 * 1e3;
+        TERMINAL_SESSION_STATUSES = ["stopped", "failed", "terminated", "exited", "closed"];
+        autoLaunchOrphanNotified = /* @__PURE__ */ new Set();
+        autoLaunchOrphanFirstSeenAtMs = /* @__PURE__ */ new Map();
+        AUTO_LAUNCH_ORPHAN_GRACE_MS = 3e4;
+        autoLaunchAwaitClaimBackoff = /* @__PURE__ */ new Map();
+      }
+    });
     function classifiedDifficultiesForSlot(slot) {
       const highest = slot.difficulty?.reduce((rank, value) => {
         const candidate = CLASSIFIED_DIFFICULTIES.indexOf(value);
@@ -66298,7 +66809,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         CLASSIFIED_DIFFICULTIES = ["easy", "medium", "difficult"];
       }
     });
-    function localCoordinatorDaemonId() {
+    function localCoordinatorDaemonId2() {
       return canonicalDaemonId(readNonEmptyString(loadConfig2().machineId));
     }
     function loadRepoConfigForNode(node) {
@@ -66407,7 +66918,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       const routingDecision = {
         source: routing?.source ?? "queue",
         selectedNodeId: ctx.nodeId,
-        ...localCoordinatorDaemonId() ? { daemonId: localCoordinatorDaemonId() } : {},
+        ...localCoordinatorDaemonId2() ? { daemonId: localCoordinatorDaemonId2() } : {},
         transport: ctx.transport,
         // D: resolved execution profile — prefer the caller's resolved values, fall back
         // to what the claimed task row carries (queue/idle drains carry it on the task).
@@ -66727,7 +67238,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           nodeId,
           sessionId,
           providerType,
-          coordinatorDaemonId: localCoordinatorDaemonId(),
+          coordinatorDaemonId: localCoordinatorDaemonId2(),
           coordinatorSessionId: readNonEmptyString(task.sourceCoordinatorSessionId) || void 0
         });
         dispatchAttemptId = attempt.attemptId;
@@ -66771,7 +67282,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       if (remoteDaemonId && components.dispatchMeshCommand) {
         const isLocalNode = isLocalAutoLaunchNode(node) || components.cliManager.adapters.has(sessionId);
         if (!isLocalNode) {
-          const localDaemonIdForDispatch = localCoordinatorDaemonId();
+          const localDaemonIdForDispatch = localCoordinatorDaemonId2();
           const sourceCoordinatorSessionId = readNonEmptyString(task.sourceCoordinatorSessionId) || void 0;
           const dispatchMeshCommand = components.dispatchMeshCommand;
           deliverTaskToSession(
@@ -66821,7 +67332,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       try {
         const inst = components.instanceManager.getInstance(sessionId);
         if (inst && typeof inst.updateSettings === "function") {
-          const localDaemonId = localCoordinatorDaemonId();
+          const localDaemonId = localCoordinatorDaemonId2();
           const localSourceCoordinatorSessionId = readNonEmptyString(task.sourceCoordinatorSessionId);
           inst.updateSettings({
             meshNodeFor: meshId,
@@ -66865,7 +67376,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
             ...typeof task.dispatchNonce === "number" ? { dispatchNonce: task.dispatchNonce } : {},
             // TURN-LEDGER (Stage 5): the opaque attempt identity (see remote branch above).
             ...dispatchAttemptId ? { attemptId: dispatchAttemptId } : {},
-            ...localCoordinatorDaemonId() ? { coordinatorDaemonId: localCoordinatorDaemonId() } : {},
+            ...localCoordinatorDaemonId2() ? { coordinatorDaemonId: localCoordinatorDaemonId2() } : {},
             ...readNonEmptyString(task.sourceCoordinatorSessionId) ? { coordinatorSessionId: readNonEmptyString(task.sourceCoordinatorSessionId) } : {},
             ...silentIdlePushOnDispatch ? { silentIdlePush: true } : {}
           }
@@ -66878,38 +67389,12 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           task,
           transport: "local",
           ...readNonEmptyString(task.sourceCoordinatorSessionId) ? { sourceCoordinatorSessionId: readNonEmptyString(task.sourceCoordinatorSessionId) } : {},
-          ...localCoordinatorDaemonId() ? { sourceCoordinatorDaemonId: localCoordinatorDaemonId() } : {},
+          ...localCoordinatorDaemonId2() ? { sourceCoordinatorDaemonId: localCoordinatorDaemonId2() } : {},
           ...routingDecision ? { routingDecision } : {}
         }
       );
       return true;
     }
-    function awaitClaimWindowMs(cycles) {
-      return AUTO_LAUNCH_AWAIT_CLAIM_MS * Math.pow(2, Math.min(cycles, AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES));
-    }
-    function remoteSessionAppearsLive(meshId, sessionId) {
-      if (!sessionId) return false;
-      try {
-        return MeshRuntimeStore.getInstance().getRemoteIdleSessions(meshId).some((s2) => sessionIdsEquivalent(s2.sessionId, sessionId));
-      } catch {
-        return false;
-      }
-    }
-    function inWindowAutoLaunchSessionIdsForNode(meshId, nodeId) {
-      const nowMs = Date.now();
-      const out = [];
-      for (const task of getQueue(meshId, { status: ["pending"] })) {
-        const al = task.autoLaunch;
-        const sid = al ? readNonEmptyString(al.sessionId) : "";
-        if (!al || al.status !== "started" && al.status !== "completed" || !sid) continue;
-        if (!daemonIdsEquivalent(al.nodeId, nodeId)) continue;
-        const launchedAtMs = Date.parse(al.updatedAt);
-        const inBaseWindow = Number.isFinite(launchedAtMs) && nowMs - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS;
-        const inBackoff = autoLaunchAwaitClaimBackoff.has(`${meshId}::${task.id}`);
-        if (inBaseWindow || inBackoff) out.push(sid);
-      }
-      return out;
-    }
     function sweepExpiredCooldowns() {
       const now = Date.now();
       for (const [key2, until] of autoLaunchCooldownUntil) {
@@ -66929,7 +67414,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     function isTerminalSessionStatus(status) {
       return ["stopped", "failed", "terminated", "exited", "closed"].includes(status);
     }
-    function isIdleSessionState2(state) {
+    function isIdleSessionState3(state) {
       const status = readNonEmptyString(state?.status).toLowerCase();
       if (isTerminalSessionStatus(status)) return false;
       return status === "idle" || state?.activeChat?.status === "waiting_input";
@@ -66949,7 +67434,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
         if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
         const sessionId = readNonEmptyString(state.instanceId);
-        if (currentSessionId && sessionIdsEquivalent(sessionId, currentSessionId) && isIdleSessionState2(state)) return false;
+        if (currentSessionId && sessionIdsEquivalent(sessionId, currentSessionId) && isIdleSessionState3(state)) return false;
         return sessionStateLooksActive(state);
       });
     }
@@ -66980,7 +67465,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       const daemonId = readMeshNodeDaemonId(node ?? {});
       if (!daemonId) return { mode: "skip", reason: "remote_auto_launch_unsupported" };
       if (!components.dispatchMeshCommand) return { mode: "skip", reason: "remote_auto_launch_unsupported" };
-      const coordinatorDaemonId = localCoordinatorDaemonId();
+      const coordinatorDaemonId = localCoordinatorDaemonId2();
       if (!coordinatorDaemonId) return { mode: "skip", reason: "remote_auto_launch_no_coordinator_daemon_id" };
       return { mode: "remote", daemonId, coordinatorDaemonId };
     }
@@ -67054,8 +67539,8 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       const reason = args.reason || args.error;
       const difficultyFloorSkip = args.status === "skipped" && isDifficultyFloorWaitReason(reason);
       if (difficultyFloorSkip) {
-        handleDifficultyFloorSkip({ meshId, taskId, reason, nodeId: args.nodeId, coordinatorDaemonId: localCoordinatorDaemonId() });
-      } else {
+        handleDifficultyFloorSkip({ meshId, taskId, reason, nodeId: args.nodeId, coordinatorDaemonId: localCoordinatorDaemonId2() });
+      } else if (!autoLaunchWriteWouldClobberWinner(meshId, taskId, args, AUTO_LAUNCH_AWAIT_CLAIM_MS)) {
         recordTaskAutoLaunch(meshId, taskId, {
           status: args.status,
           reason,
@@ -67207,7 +67692,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       const nowMs = Date.now();
       const state = autoLaunchAwaitClaimBackoff.get(backoffKey) || { cycles: 0, nextAttemptAtMs: 0 };
       if (state.nextAttemptAtMs && nowMs < state.nextAttemptAtMs) return "backoff";
-      const atCap = state.cycles >= AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES;
+      const atCap = state.cycles >= AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES2;
       const live = remoteSessionAppearsLive(meshId, sessionId);
       if ((live || atCap) && nodeId && providerType) {
         try {
@@ -67233,7 +67718,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           return "respawn";
         }
       }
-      const cycles = Math.min(state.cycles + 1, AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES);
+      const cycles = Math.min(state.cycles + 1, AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES2);
       autoLaunchAwaitClaimBackoff.set(backoffKey, { cycles, nextAttemptAtMs: nowMs + awaitClaimWindowMs(cycles) });
       recordAutoLaunchEvent(meshId, { phase: "skipped", taskId: task.id, reason: "awaiting_launched_session_claim_backoff", nodeId, sessionId });
       return "backoff";
@@ -67254,333 +67739,339 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       const maxParallelTasks = resolveMaxParallelTasks(mesh?.policy?.maxParallelTasks);
       const maxReadonlyParallelTasks = resolveMaxReadonlyParallelTasks(maxParallelTasks);
       for (const task of pending) {
-        if (!taskDependenciesSatisfied(task, statusById)) {
-          markAutoLaunch(meshId, task.id, { status: "skipped", reason: "dependencies_unsatisfied" });
+        const taskLaunchKey = `${meshId}::${task.id}`;
+        if (autoLaunchTaskInProgress.has(taskLaunchKey)) {
+          recordAutoLaunchEvent(meshId, { phase: "skipped", taskId: task.id, reason: "auto_launch_task_in_progress" });
           continue;
         }
-        if (!meshTaskNotBeforeReady(task)) {
-          markAutoLaunch(meshId, task.id, { status: "skipped", reason: "not_before_delayed" });
-          continue;
-        }
-        const isReadonly = isTaskReadonly(task);
-        if (isReadonly) {
-          if (activeReadonlyAssignedCount(meshId) >= maxReadonlyParallelTasks) {
-            markAutoLaunch(meshId, task.id, { status: "skipped", reason: "max_readonly_parallel_tasks_reached" });
+        autoLaunchTaskInProgress.add(taskLaunchKey);
+        try {
+          if (!taskDependenciesSatisfied(task, statusById)) {
+            markAutoLaunch(meshId, task.id, { status: "skipped", reason: "dependencies_unsatisfied" });
             continue;
           }
-        } else if (activeWriteAssignedCount(meshId) >= maxParallelTasks) {
-          markAutoLaunch(meshId, task.id, { status: "skipped", reason: "max_parallel_tasks_reached" });
-          continue;
-        }
-        if (task.targetSessionId) {
-          const deadTarget = resolveDeadTargetVerdict(components, meshId, mesh, task);
-          if (deadTarget.dead) {
-            const requeued = requeueTask(meshId, task.id, {
-              reason: deadTarget.reason,
-              clearTargetSession: true,
-              // Keep the node pin if only the SESSION died on a still-live node; clear it
-              // when the NODE itself is absent (nothing to pin to).
-              clearTargetNode: deadTarget.nodeDead
-            });
-            if (requeued) {
-              noteTargetPinCleared(deadTarget.reason);
-              LOG2.warn("MeshQueue", `DEAD-TARGET-SELFHEAL: task ${task.id} (mesh ${meshId}) was pinned to a dead target (${deadTarget.reason}); requeued${deadTarget.nodeDead ? " and unpinned node" : ""} (requeueCount=${requeued.requeueCount ?? "?"}, status=${requeued.status}).`);
-            }
-            markAutoLaunch(meshId, task.id, { status: "skipped", reason: "target_session_dead_requeued" });
+          if (!meshTaskNotBeforeReady(task)) {
+            markAutoLaunch(meshId, task.id, { status: "skipped", reason: "not_before_delayed" });
             continue;
           }
-          const pinAgeMs = targetPinAgeMs(task);
-          if (pinAgeMs !== null && pinAgeMs >= TARGET_SESSION_PIN_TTL_MS) {
-            const expired = expireTaskTargetPin(meshId, task.id, { reason: "target_session_pin_expired_unclaimed" });
-            if (expired) {
-              noteTargetPinCleared("target_session_pin_expired_unclaimed");
-              traceMeshEventDrop("target_session_pin_expired", {
-                taskId: task.id,
-                sessionId: readNonEmptyString(task.targetSessionId),
-                nodeId: readNonEmptyString(task.targetNodeId),
-                meshId,
-                event: "agent:ready"
-              }, `unclaimed ${Math.round(pinAgeMs / 1e3)}s \u2265 ttl ${Math.round(TARGET_SESSION_PIN_TTL_MS / 1e3)}s \u2192 pin cleared, claimable`);
-              LOG2.warn("MeshQueue", `TARGET-PIN-TTL: task ${task.id} (mesh ${meshId}) stayed pinned-but-unclaimed for ${Math.round(pinAgeMs / 1e3)}s (ttl ${Math.round(TARGET_SESSION_PIN_TTL_MS / 1e3)}s); expired the stale target pin so a compatible session can claim it.`);
+          const isReadonly = isTaskReadonly(task);
+          if (isReadonly) {
+            if (activeReadonlyAssignedCount(meshId) >= maxReadonlyParallelTasks) {
+              markAutoLaunch(meshId, task.id, { status: "skipped", reason: "max_readonly_parallel_tasks_reached" });
+              continue;
             }
-            markAutoLaunch(meshId, task.id, { status: "skipped", reason: "target_session_pin_expired" });
-            continue;
-          }
-          markAutoLaunch(meshId, task.id, { status: "skipped", reason: "target_session_constraint" });
-          continue;
-        }
-        if (task.autoLaunch?.status === "completed" && task.autoLaunch.sessionId) {
-          const launchedAtMs = Date.parse(task.autoLaunch.updatedAt);
-          const alSessionId = readNonEmptyString(task.autoLaunch.sessionId);
-          const alNodeId = readNonEmptyString(task.autoLaunch.nodeId);
-          const alProvider = readNonEmptyString(task.autoLaunch.providerType);
-          if (Number.isFinite(launchedAtMs) && Date.now() - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS) {
-            recordAutoLaunchEvent(meshId, { phase: "skipped", taskId: task.id, reason: "awaiting_launched_session_claim", nodeId: alNodeId, sessionId: alSessionId });
+          } else if (activeWriteAssignedCount(meshId) >= maxParallelTasks) {
+            markAutoLaunch(meshId, task.id, { status: "skipped", reason: "max_parallel_tasks_reached" });
             continue;
           }
-          if (Number.isFinite(launchedAtMs) && alSessionId && alNodeId) {
-            const outcome = driveExpiredAwaitClaim(components, meshId, task, { sessionId: alSessionId, nodeId: alNodeId, providerType: alProvider });
-            if (outcome === "claimed" || outcome === "fallback") return true;
-            if (outcome === "backoff") continue;
-          }
-        }
-        const candidateNodes = Array.isArray(mesh?.nodes) ? mesh.nodes.filter((node) => {
-          if (task.targetNodeId && !meshNodeIdMatches(node, task.targetNodeId)) return false;
-          if (task.taskMode === "convergence" && node?.isLocalWorktree === true) return false;
-          if (task.requiredTags?.length) {
-            const slotProviders = resolveNodeCapabilitySlots(node, meshId).map((s2) => s2.provider).filter(Boolean);
-            const priorities = slotProviders.length ? slotProviders : normalizeProviderPriority2(node?.policy);
-            const providerCandidates = priorities.length ? priorities : [void 0];
-            return providerCandidates.some(
-              (p) => nodeSatisfiesRequiredTags(task.requiredTags, buildMeshNodeCapabilityTags(node, p))
+          if (taskIsParked(task)) {
+            settleParkedQueueTask(
+              meshId,
+              task,
+              (reason) => markAutoLaunch(meshId, task.id, { status: "skipped", reason }),
+              failRetentionExpiredParkedTask
             );
-          }
-          return true;
-        }) : [];
-        if (!candidateNodes.length) {
-          const targetPinUnmatched = !!task.targetNodeId && !(Array.isArray(mesh?.nodes) && mesh.nodes.some((n) => meshNodeIdMatches(n, task.targetNodeId)));
-          const convergenceOntoWorktree = task.taskMode === "convergence" && Array.isArray(mesh?.nodes) && (() => {
-            const matched = mesh.nodes.filter((n) => !task.targetNodeId || meshNodeIdMatches(n, task.targetNodeId));
-            return matched.length > 0 && matched.every((n) => n?.isLocalWorktree === true);
-          })();
-          const targetTransientlyUnresolved = targetPinUnmatched && isTargetNodeTransientlyUnresolved(mesh, task);
-          markAutoLaunch(meshId, task.id, {
-            status: "skipped",
-            reason: convergenceOntoWorktree ? "mesh_convergence_target_is_worktree" : targetTransientlyUnresolved ? TRANSIENT_TARGET_NODE_BOOTSTRAP_PENDING_REASON : targetPinUnmatched ? "target_node_id_unmatched" : "no_node_satisfies_required_tags",
-            nodeId: task.targetNodeId
-          });
-          continue;
-        }
-        const strategy = resolveSchedulingStrategy(mesh);
-        const orderedCandidateNodes = strategy === "first_eligible" ? candidateNodes : orderEligibleNodes(
-          meshId,
-          strategy,
-          candidateNodes.map((node, index) => ({ nodeId: readMeshNodeId(node), node, index })).filter((c) => c.nodeId),
-          // Auto-launch drains one task at a time, so the task IS in scope here —
-          // pass it through for the 'fitness' strategy's task→slot ranking. The
-          // mesh's quotaRouting thresholds ride along so the fitness score can
-          // include the quota-headroom spread bonus (fail-open when unset).
-          { bumpCursor: true, task: { difficulty: task.difficulty, requiredTags: task.requiredTags }, quotaRouting: mesh?.policy?.quotaRouting ?? null, quotaFactsContext: quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader) }
-        ).map((c) => c.node);
-        const skippedCandidates = [];
-        const SKIPPED_CANDIDATES_MAX = 5;
-        const markSkip = (nodeIdForSkip, reason, extra) => {
-          markAutoLaunch(meshId, task.id, { status: "skipped", reason, nodeId: nodeIdForSkip, ...extra || {} });
-          if (nodeIdForSkip && skippedCandidates.length < SKIPPED_CANDIDATES_MAX) {
-            skippedCandidates.push({ nodeId: nodeIdForSkip, reason });
-          }
-        };
-        for (const node of orderedCandidateNodes) {
-          const nodeId = readMeshNodeId(node);
-          if (!nodeId) continue;
-          const launchKey = `${meshId}:${nodeId}`;
-          const now = Date.now();
-          const cooldownUntil = autoLaunchCooldownUntil.get(launchKey) || 0;
-          if (cooldownUntil > 0 && now >= cooldownUntil) autoLaunchCooldownUntil.delete(launchKey);
-          if (autoLaunchInProgress.has(launchKey)) {
-            markSkip(nodeId, "auto_launch_in_progress");
-            continue;
-          }
-          if (now < cooldownUntil) {
-            markSkip(nodeId, "auto_launch_cooldown");
-            continue;
-          }
-          if (isDirtyNode(node)) {
-            markSkip(nodeId, "dirty_workspace");
             continue;
           }
-          if (!isLaunchableNode(node)) {
-            markSkip(nodeId, "node_health_not_launchable");
-            continue;
-          }
-          if (!isMeshNodeFreshEnoughToLaunch(node, freshnessGate)) {
-            markSkip(nodeId, "node_stale_behind_upstream");
-            continue;
-          }
-          const launchTarget = resolveAutoLaunchTarget(components, node);
-          if (launchTarget.mode === "skip") {
-            markSkip(nodeId, launchTarget.reason || "auto_launch_unavailable");
-            autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
-            sweepExpiredCooldowns();
-            continue;
-          }
-          if (nodeHasLiveSessionPendingClaim(components, meshId, nodeId, task, node)) {
-            markSkip(nodeId, "node_has_live_session_pending_claim");
-            continue;
-          }
-          if (!isTaskReadonly(task) && nodeHasActiveAssignment(meshId, nodeId)) {
-            markSkip(nodeId, "node_has_active_assignment");
+          if (task.targetSessionId) {
+            const deadTarget = resolveDeadTargetVerdict(components, meshId, mesh, task);
+            if (deadTarget.dead) {
+              const requeued = requeueTask(meshId, task.id, {
+                reason: deadTarget.reason,
+                clearTargetSession: true,
+                // Keep the node pin if only the SESSION died on a still-live node; clear it
+                // when the NODE itself is absent (nothing to pin to).
+                clearTargetNode: deadTarget.nodeDead
+              });
+              if (requeued) {
+                noteTargetPinCleared(deadTarget.reason);
+                LOG2.warn("MeshQueue", `DEAD-TARGET-SELFHEAL: task ${task.id} (mesh ${meshId}) was pinned to a dead target (${deadTarget.reason}); requeued${deadTarget.nodeDead ? " and unpinned node" : ""} (requeueCount=${requeued.requeueCount ?? "?"}, status=${requeued.status}).`);
+              }
+              markAutoLaunch(meshId, task.id, { status: "skipped", reason: "target_session_dead_requeued" });
+              continue;
+            }
+            if (parkExpiredTargetPin(meshId, task, resolveTargetPinTtlVerdict(components, task), TARGET_SESSION_PIN_TTL_MS, (m, t, r) => parkTaskTargetPin(m, t, { reason: r }))) {
+              markAutoLaunch(meshId, task.id, { status: "skipped", reason: PARKED_SKIP_REASON });
+              continue;
+            }
+            markAutoLaunch(meshId, task.id, { status: "skipped", reason: "target_session_constraint" });
             continue;
           }
-          const maxConcurrentSessions = Number(node?.policy?.maxConcurrentSessions);
-          if (Number.isFinite(maxConcurrentSessions) && maxConcurrentSessions >= 0 && liveSessionCountForNode(components, meshId, nodeId) >= maxConcurrentSessions) {
-            markSkip(nodeId, "max_concurrent_sessions_reached");
+          if (task.autoLaunch?.status === "completed" && task.autoLaunch.sessionId) {
+            const launchedAtMs = Date.parse(task.autoLaunch.updatedAt);
+            const alSessionId = readNonEmptyString(task.autoLaunch.sessionId);
+            const alNodeId = readNonEmptyString(task.autoLaunch.nodeId);
+            const alProvider = readNonEmptyString(task.autoLaunch.providerType);
+            if (Number.isFinite(launchedAtMs) && Date.now() - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS) {
+              recordAutoLaunchEvent(meshId, { phase: "skipped", taskId: task.id, reason: "awaiting_launched_session_claim", nodeId: alNodeId, sessionId: alSessionId });
+              continue;
+            }
+            if (Number.isFinite(launchedAtMs) && alSessionId && alNodeId) {
+              const outcome = driveExpiredAwaitClaim(components, meshId, task, { sessionId: alSessionId, nodeId: alNodeId, providerType: alProvider });
+              if (outcome === "claimed" || outcome === "fallback") return true;
+              if (outcome === "backoff") continue;
+            }
+          }
+          const candidateNodes = Array.isArray(mesh?.nodes) ? mesh.nodes.filter((node) => {
+            if (task.targetNodeId && !meshNodeIdMatches(node, task.targetNodeId)) return false;
+            if (task.taskMode === "convergence" && node?.isLocalWorktree === true) return false;
+            if (task.requiredTags?.length) {
+              const slotProviders = resolveNodeCapabilitySlots(node, meshId).map((s2) => s2.provider).filter(Boolean);
+              const priorities = slotProviders.length ? slotProviders : normalizeProviderPriority2(node?.policy);
+              const providerCandidates = priorities.length ? priorities : [void 0];
+              return providerCandidates.some(
+                (p) => nodeSatisfiesRequiredTags(task.requiredTags, buildMeshNodeCapabilityTags(node, p))
+              );
+            }
+            return true;
+          }) : [];
+          if (!candidateNodes.length) {
+            const targetPinUnmatched = !!task.targetNodeId && !(Array.isArray(mesh?.nodes) && mesh.nodes.some((n) => meshNodeIdMatches(n, task.targetNodeId)));
+            const convergenceOntoWorktree = task.taskMode === "convergence" && Array.isArray(mesh?.nodes) && (() => {
+              const matched = mesh.nodes.filter((n) => !task.targetNodeId || meshNodeIdMatches(n, task.targetNodeId));
+              return matched.length > 0 && matched.every((n) => n?.isLocalWorktree === true);
+            })();
+            const targetTransientlyUnresolved = targetPinUnmatched && isTargetNodeTransientlyUnresolved(mesh, task);
+            markAutoLaunch(meshId, task.id, {
+              status: "skipped",
+              reason: convergenceOntoWorktree ? "mesh_convergence_target_is_worktree" : targetTransientlyUnresolved ? TRANSIENT_TARGET_NODE_BOOTSTRAP_PENDING_REASON : targetPinUnmatched ? "target_node_id_unmatched" : "no_node_satisfies_required_tags",
+              nodeId: task.targetNodeId
+            });
             continue;
           }
-          autoLaunchInProgress.add(launchKey);
-          try {
-            const resolved = await resolveUsableProvider(components, nodeId, node, meshId, task.requiredTags, { difficulty: task.difficulty, requiredTags: task.requiredTags }, mesh?.policy?.quotaRouting ?? null, quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader), task.id);
-            if (!resolved.providerType) {
-              markSkip(nodeId, resolved.reason || "provider_unusable");
+          const strategy = resolveSchedulingStrategy(mesh);
+          const orderedCandidateNodes = strategy === "first_eligible" ? candidateNodes : orderEligibleNodes(
+            meshId,
+            strategy,
+            candidateNodes.map((node, index) => ({ nodeId: readMeshNodeId(node), node, index })).filter((c) => c.nodeId),
+            // Auto-launch drains one task at a time, so the task IS in scope here —
+            // pass it through for the 'fitness' strategy's task→slot ranking. The
+            // mesh's quotaRouting thresholds ride along so the fitness score can
+            // include the quota-headroom spread bonus (fail-open when unset).
+            { bumpCursor: true, task: { difficulty: task.difficulty, requiredTags: task.requiredTags }, quotaRouting: mesh?.policy?.quotaRouting ?? null, quotaFactsContext: quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader) }
+          ).map((c) => c.node);
+          const skippedCandidates = [];
+          const SKIPPED_CANDIDATES_MAX = 5;
+          const markSkip = (nodeIdForSkip, reason, extra) => {
+            markAutoLaunch(meshId, task.id, { status: "skipped", reason, nodeId: nodeIdForSkip, ...extra || {} });
+            if (nodeIdForSkip && skippedCandidates.length < SKIPPED_CANDIDATES_MAX) {
+              skippedCandidates.push({ nodeId: nodeIdForSkip, reason });
+            }
+          };
+          for (const node of orderedCandidateNodes) {
+            const nodeId = readMeshNodeId(node);
+            if (!nodeId) continue;
+            const launchKey = `${meshId}:${nodeId}`;
+            const now = Date.now();
+            const cooldownUntil = autoLaunchCooldownUntil.get(launchKey) || 0;
+            if (cooldownUntil > 0 && now >= cooldownUntil) autoLaunchCooldownUntil.delete(launchKey);
+            if (autoLaunchInProgress.has(launchKey)) {
+              markSkip(nodeId, "auto_launch_in_progress");
               continue;
             }
-            const slotCoversDifficulty = slotCoversTaskDifficulty(resolved.slot, task.difficulty);
-            const requestedModel = resolveLaunchAxis(task.model, task.modelSource, resolved.model, slotCoversDifficulty);
-            const effectiveThinkingLevel = resolveLaunchAxis(task.thinkingLevel, task.thinkingLevelSource, resolved.thinkingLevel, slotCoversDifficulty);
-            const slotDecision = decideSlotForModel({
-              requestedModel,
-              slots: resolveNodeCapabilitySlots(node, meshId).map((slot) => ({
-                slot,
-                available: slotHasCapacity(meshId, nodeId, node, slot, mesh?.nodes, isReadonly)
-              }))
-            });
-            if (slotDecision.outcome === "wait") {
-              LOG2.info("MeshQueue", `SLOT MODEL GUARD: model '${requestedModel}' is declared on node ${nodeId} but every matching slot is at its maxParallel cap (task ${task.id}); leaving the task queued until a slot goes idle`);
-              markSkip(nodeId, slotDecision.reason, { providerType: resolved.providerType });
+            if (now < cooldownUntil) {
+              markSkip(nodeId, "auto_launch_cooldown");
               continue;
             }
-            if (slotDecision.outcome === "notify") {
-              LOG2.warn("MeshQueue", `SLOT MODEL GUARD: no slot on node ${nodeId} declares model '${requestedModel}' (declared: ${slotDecision.declaredModels.join(", ") || "none"}) for task ${task.id}; not launching \u2014 surfacing to the coordinator to re-drive`);
-              markSkip(nodeId, slotDecision.reason, { providerType: resolved.providerType });
+            if (isDirtyNode(node)) {
+              markSkip(nodeId, "dirty_workspace");
               continue;
             }
-            const rawEffectiveModel = slotDecision.model;
-            const winningModel = resolved.slot?.model?.trim() || void 0;
-            const finalizedModel = slotDecision.slot.model?.trim() || void 0;
-            const slotWasDemoted = resolved.slot?.provider !== slotDecision.slot.provider || winningModel !== finalizedModel;
-            const demotionReason = slotWasDemoted ? slotHasCapacity(meshId, nodeId, node, resolved.slot, mesh?.nodes, isReadonly) ? "slot_reselected_during_launch" : "winning_slot_capacity_exhausted" : void 0;
-            const effectiveModel = isModelCompatibleWithProvider(rawEffectiveModel, resolved.providerType) ? rawEffectiveModel : void 0;
-            if (rawEffectiveModel && effectiveModel === void 0) {
-              LOG2.info("MeshQueue", `CODEX-400 GUARD: dropped incompatible launch model '${rawEffectiveModel}' for non-Anthropic provider '${resolved.providerType}' on node ${nodeId} (task ${task.id}); provider will use its own default model`);
-            }
-            const providerCap = effectiveSlotCap(
-              resolveProviderMaxParallel(resolveNodeCapabilitySlots(node, meshId), resolved.providerType),
-              isReadonly
-            );
-            if (providerCap !== void 0 && activeProviderAssignedCount(
-              meshId,
-              nodeId,
-              resolved.providerType,
-              resolveDaemonSiblingNodeIds(nodeId, mesh?.nodes)
-            ) >= providerCap) {
-              markSkip(nodeId, "max_provider_parallel_reached", { providerType: resolved.providerType });
+            if (!isLaunchableNode(node)) {
+              markSkip(nodeId, "node_health_not_launchable");
               continue;
             }
-            const launchSettings = {
-              // Worker launch envelope: role + mesh context so worker can route completion events.
-              role: "worker",
-              meshNodeFor: meshId,
-              meshNodeId: nodeId,
-              spawnedSessionVisibility: mesh?.policy?.spawnedSessionVisibility || "hidden",
-              // Coordinator-dispatched worker: auto-approve unless mesh/node policy
-              // opts out (default true). Lands in settingsOverride and beats the
-              // global per-provider-type boolean/mode through explicit opposite-key clearing.
-              ...delegatedWorkerAutoApproveSettingsForNode(
-                mesh,
-                node,
-                components.providerLoader?.getMeta(resolved.providerType),
-                resolved.providerType
-              ),
-              launchedByCoordinator: true,
-              autoLaunchedForQueueTaskId: task.id
-            };
-            if (launchTarget.mode === "remote") {
-              const remoteSettings = {
-                ...launchSettings,
-                meshCoordinatorDaemonId: launchTarget.coordinatorDaemonId,
-                meshCoordinatorNodeId: nodeId
+            if (!isMeshNodeFreshEnoughToLaunch(node, freshnessGate)) {
+              markSkip(nodeId, "node_stale_behind_upstream");
+              continue;
+            }
+            const launchTarget = resolveAutoLaunchTarget(components, node);
+            if (launchTarget.mode === "skip") {
+              markSkip(nodeId, launchTarget.reason || "auto_launch_unavailable");
+              autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
+              sweepExpiredCooldowns();
+              continue;
+            }
+            if (nodeHasLiveSessionPendingClaim(components, meshId, nodeId, task, node)) {
+              markSkip(nodeId, "node_has_live_session_pending_claim");
+              continue;
+            }
+            if (!isTaskReadonly(task) && nodeHasActiveAssignment(meshId, nodeId)) {
+              markSkip(nodeId, "node_has_active_assignment");
+              continue;
+            }
+            const maxConcurrentSessions = Number(node?.policy?.maxConcurrentSessions);
+            if (Number.isFinite(maxConcurrentSessions) && maxConcurrentSessions >= 0 && liveSessionCountForNode(components, meshId, nodeId) >= maxConcurrentSessions) {
+              markSkip(nodeId, "max_concurrent_sessions_reached");
+              continue;
+            }
+            autoLaunchInProgress.add(launchKey);
+            try {
+              const resolved = await resolveUsableProvider(components, nodeId, node, meshId, task.requiredTags, { difficulty: task.difficulty, requiredTags: task.requiredTags }, mesh?.policy?.quotaRouting ?? null, quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader), task.id);
+              if (!resolved.providerType) {
+                markSkip(nodeId, resolved.reason || "provider_unusable");
+                continue;
+              }
+              const slotCoversDifficulty = slotCoversTaskDifficulty(resolved.slot, task.difficulty);
+              const requestedModel = resolveLaunchAxis(task.model, task.modelSource, resolved.model, slotCoversDifficulty);
+              const effectiveThinkingLevel = resolveLaunchAxis(task.thinkingLevel, task.thinkingLevelSource, resolved.thinkingLevel, slotCoversDifficulty);
+              const slotDecision = decideSlotForModel({
+                requestedModel,
+                slots: resolveNodeCapabilitySlots(node, meshId).map((slot) => ({
+                  slot,
+                  available: slotHasCapacity(meshId, nodeId, node, slot, mesh?.nodes, isReadonly)
+                }))
+              });
+              if (slotDecision.outcome === "wait") {
+                LOG2.info("MeshQueue", `SLOT MODEL GUARD: model '${requestedModel}' is declared on node ${nodeId} but every matching slot is at its maxParallel cap (task ${task.id}); leaving the task queued until a slot goes idle`);
+                markSkip(nodeId, slotDecision.reason, { providerType: resolved.providerType });
+                continue;
+              }
+              if (slotDecision.outcome === "notify") {
+                LOG2.warn("MeshQueue", `SLOT MODEL GUARD: no slot on node ${nodeId} declares model '${requestedModel}' (declared: ${slotDecision.declaredModels.join(", ") || "none"}) for task ${task.id}; not launching \u2014 surfacing to the coordinator to re-drive`);
+                markSkip(nodeId, slotDecision.reason, { providerType: resolved.providerType });
+                continue;
+              }
+              const rawEffectiveModel = slotDecision.model;
+              const winningModel = resolved.slot?.model?.trim() || void 0;
+              const finalizedModel = slotDecision.slot.model?.trim() || void 0;
+              const slotWasDemoted = resolved.slot?.provider !== slotDecision.slot.provider || winningModel !== finalizedModel;
+              const demotionReason = slotWasDemoted ? slotHasCapacity(meshId, nodeId, node, resolved.slot, mesh?.nodes, isReadonly) ? "slot_reselected_during_launch" : "winning_slot_capacity_exhausted" : void 0;
+              const effectiveModel = isModelCompatibleWithProvider(rawEffectiveModel, resolved.providerType) ? rawEffectiveModel : void 0;
+              if (rawEffectiveModel && effectiveModel === void 0) {
+                LOG2.info("MeshQueue", `CODEX-400 GUARD: dropped incompatible launch model '${rawEffectiveModel}' for non-Anthropic provider '${resolved.providerType}' on node ${nodeId} (task ${task.id}); provider will use its own default model`);
+              }
+              const providerCap = effectiveSlotCap(
+                resolveProviderMaxParallel(resolveNodeCapabilitySlots(node, meshId), resolved.providerType),
+                isReadonly
+              );
+              if (providerCap !== void 0 && activeProviderAssignedCount(
+                meshId,
+                nodeId,
+                resolved.providerType,
+                resolveDaemonSiblingNodeIds(nodeId, mesh?.nodes)
+              ) >= providerCap) {
+                markSkip(nodeId, "max_provider_parallel_reached", { providerType: resolved.providerType });
+                continue;
+              }
+              const launchSettings = {
+                // Worker launch envelope: role + mesh context so worker can route completion events.
+                role: "worker",
+                meshNodeFor: meshId,
+                meshNodeId: nodeId,
+                spawnedSessionVisibility: mesh?.policy?.spawnedSessionVisibility || "hidden",
+                // Coordinator-dispatched worker: auto-approve unless mesh/node policy
+                // opts out (default true). Lands in settingsOverride and beats the
+                // global per-provider-type boolean/mode through explicit opposite-key clearing.
+                ...delegatedWorkerAutoApproveSettingsForNode(
+                  mesh,
+                  node,
+                  components.providerLoader?.getMeta(resolved.providerType),
+                  resolved.providerType
+                ),
+                launchedByCoordinator: true,
+                autoLaunchedForQueueTaskId: task.id
               };
+              if (launchTarget.mode === "remote") {
+                const remoteSettings = {
+                  ...launchSettings,
+                  meshCoordinatorDaemonId: launchTarget.coordinatorDaemonId,
+                  meshCoordinatorNodeId: nodeId
+                };
+                markAutoLaunch(meshId, task.id, { status: "started", nodeId, providerType: resolved.providerType, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
+                let launchResult2;
+                try {
+                  launchResult2 = await components.dispatchMeshCommand(launchTarget.daemonId, "launch_cli", withStatusProbeMarker({
+                    cliType: resolved.providerType,
+                    dir: node.workspace,
+                    settings: remoteSettings,
+                    // MAGI-KIND-PANEL model axis: forward the task's model override so the
+                    // remote worker session launches with it (initialModel). Best-effort.
+                    // Slot-aware: task override wins, else the matched slot's model.
+                    ...effectiveModel ? { initialModel: effectiveModel } : {},
+                    // BRAIN-ROUTING thinking axis: forward the effective thinking level (initialThinkingLevel).
+                    ...effectiveThinkingLevel ? { initialThinkingLevel: effectiveThinkingLevel } : {}
+                  }));
+                } catch (e) {
+                  markAutoLaunch(meshId, task.id, { status: "failed", reason: `remote_launch_dispatch_failed: ${e?.message || String(e)}`, nodeId, providerType: resolved.providerType });
+                  autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
+                  sweepExpiredCooldowns();
+                  return false;
+                }
+                const payload = launchResult2 && typeof launchResult2 === "object" && "payload" in launchResult2 && launchResult2.payload && typeof launchResult2.payload === "object" ? launchResult2.payload : launchResult2;
+                if (!payload?.success) {
+                  const reason = readNonEmptyString(payload?.error) || "remote_launch_cli_failed";
+                  markAutoLaunch(meshId, task.id, { status: "failed", reason, nodeId, providerType: resolved.providerType });
+                  autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
+                  sweepExpiredCooldowns();
+                  return false;
+                }
+                const remoteSessionId = readNonEmptyString(payload.sessionId) || readNonEmptyString(payload.id) || readNonEmptyString(payload.runtimeSessionId);
+                markAutoLaunch(meshId, task.id, { status: "completed", nodeId, providerType: resolved.providerType, sessionId: remoteSessionId || void 0, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
+                logAutoLaunchQuotaFallbackSuccess(resolved, task.id, nodeId, remoteSessionId || void 0);
+                autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
+                sweepExpiredCooldowns();
+                return true;
+              }
               markAutoLaunch(meshId, task.id, { status: "started", nodeId, providerType: resolved.providerType, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
-              let launchResult2;
-              try {
-                launchResult2 = await components.dispatchMeshCommand(launchTarget.daemonId, "launch_cli", withStatusProbeMarker({
-                  cliType: resolved.providerType,
-                  dir: node.workspace,
-                  settings: remoteSettings,
-                  // MAGI-KIND-PANEL model axis: forward the task's model override so the
-                  // remote worker session launches with it (initialModel). Best-effort.
-                  // Slot-aware: task override wins, else the matched slot's model.
-                  ...effectiveModel ? { initialModel: effectiveModel } : {},
-                  // BRAIN-ROUTING thinking axis: forward the effective thinking level (initialThinkingLevel).
-                  ...effectiveThinkingLevel ? { initialThinkingLevel: effectiveThinkingLevel } : {}
-                }));
-              } catch (e) {
-                markAutoLaunch(meshId, task.id, { status: "failed", reason: `remote_launch_dispatch_failed: ${e?.message || String(e)}`, nodeId, providerType: resolved.providerType });
+              const launchResult = await components.cliManager.handleCliCommand("launch_cli", {
+                cliType: resolved.providerType,
+                dir: node.workspace,
+                settings: launchSettings,
+                // MAGI-KIND-PANEL model axis: local launch forwards the effective model
+                // (task override, else matched slot) as initialModel (CLI → modelLaunchArgs; ACP → setConfigOption).
+                ...effectiveModel ? { initialModel: effectiveModel } : {},
+                // BRAIN-ROUTING thinking axis: forward the effective thinking level (initialThinkingLevel).
+                ...effectiveThinkingLevel ? { initialThinkingLevel: effectiveThinkingLevel } : {}
+              });
+              if (!launchResult?.success) {
+                const reason = launchResult?.error || "launch_cli_failed";
+                markAutoLaunch(meshId, task.id, { status: "failed", reason, nodeId, providerType: resolved.providerType });
                 autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
                 sweepExpiredCooldowns();
                 return false;
               }
-              const payload = launchResult2 && typeof launchResult2 === "object" && "payload" in launchResult2 && launchResult2.payload && typeof launchResult2.payload === "object" ? launchResult2.payload : launchResult2;
-              if (!payload?.success) {
-                const reason = readNonEmptyString(payload?.error) || "remote_launch_cli_failed";
-                markAutoLaunch(meshId, task.id, { status: "failed", reason, nodeId, providerType: resolved.providerType });
+              const sessionId = readNonEmptyString(launchResult.sessionId) || readNonEmptyString(launchResult.id) || readNonEmptyString(launchResult.runtimeSessionId);
+              if (!sessionId) {
+                markAutoLaunch(meshId, task.id, { status: "failed", reason: "launch_missing_session_id", nodeId, providerType: resolved.providerType });
                 autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
                 sweepExpiredCooldowns();
                 return false;
               }
-              const remoteSessionId = readNonEmptyString(payload.sessionId) || readNonEmptyString(payload.id) || readNonEmptyString(payload.runtimeSessionId);
-              markAutoLaunch(meshId, task.id, { status: "completed", nodeId, providerType: resolved.providerType, sessionId: remoteSessionId || void 0, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
-              logAutoLaunchQuotaFallbackSuccess(resolved, task.id, nodeId, remoteSessionId || void 0);
-              autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
-              sweepExpiredCooldowns();
+              markAutoLaunch(meshId, task.id, { status: "completed", nodeId, providerType: resolved.providerType, sessionId, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
+              logAutoLaunchQuotaFallbackSuccess(resolved, task.id, nodeId, sessionId);
+              await waitForLocalSessionReady(components, sessionId);
+              const requiredTags = Array.isArray(task.requiredTags) ? task.requiredTags.filter((t) => !!t) : [];
+              const routingDecision = buildAutoLaunchRoutingDecision({
+                node,
+                meshId,
+                task: { difficulty: task.difficulty, requiredTags: task.requiredTags },
+                resolved,
+                quotaRouting: mesh?.policy?.quotaRouting ?? null,
+                quotaFactsContext: quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader),
+                skippedCandidates,
+                requiredTagsResult: {
+                  required: requiredTags,
+                  satisfied: !requiredTags.length || nodeSatisfiesRequiredTags(requiredTags, buildMeshNodeCapabilityTags(node, resolved.providerType)),
+                  missing: requiredTags.filter((t) => !buildMeshNodeCapabilityTags(node, resolved.providerType).includes(t))
+                },
+                effectiveModel,
+                effectiveThinkingLevel,
+                executedSlot: slotDecision.slot,
+                demotionReason
+              });
+              tryAssignQueueTask(components, meshId, nodeId, sessionId, resolved.providerType, routingDecision);
               return true;
-            }
-            markAutoLaunch(meshId, task.id, { status: "started", nodeId, providerType: resolved.providerType, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
-            const launchResult = await components.cliManager.handleCliCommand("launch_cli", {
-              cliType: resolved.providerType,
-              dir: node.workspace,
-              settings: launchSettings,
-              // MAGI-KIND-PANEL model axis: local launch forwards the effective model
-              // (task override, else matched slot) as initialModel (CLI → modelLaunchArgs; ACP → setConfigOption).
-              ...effectiveModel ? { initialModel: effectiveModel } : {},
-              // BRAIN-ROUTING thinking axis: forward the effective thinking level (initialThinkingLevel).
-              ...effectiveThinkingLevel ? { initialThinkingLevel: effectiveThinkingLevel } : {}
-            });
-            if (!launchResult?.success) {
-              const reason = launchResult?.error || "launch_cli_failed";
-              markAutoLaunch(meshId, task.id, { status: "failed", reason, nodeId, providerType: resolved.providerType });
-              autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
-              sweepExpiredCooldowns();
-              return false;
-            }
-            const sessionId = readNonEmptyString(launchResult.sessionId) || readNonEmptyString(launchResult.id) || readNonEmptyString(launchResult.runtimeSessionId);
-            if (!sessionId) {
-              markAutoLaunch(meshId, task.id, { status: "failed", reason: "launch_missing_session_id", nodeId, providerType: resolved.providerType });
+            } catch (e) {
+              markAutoLaunch(meshId, task.id, { status: "failed", error: e?.message || String(e), nodeId });
               autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
-              sweepExpiredCooldowns();
               return false;
+            } finally {
+              autoLaunchInProgress.delete(launchKey);
             }
-            markAutoLaunch(meshId, task.id, { status: "completed", nodeId, providerType: resolved.providerType, sessionId, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
-            logAutoLaunchQuotaFallbackSuccess(resolved, task.id, nodeId, sessionId);
-            await waitForLocalSessionReady(components, sessionId);
-            const requiredTags = Array.isArray(task.requiredTags) ? task.requiredTags.filter((t) => !!t) : [];
-            const routingDecision = buildAutoLaunchRoutingDecision({
-              node,
-              meshId,
-              task: { difficulty: task.difficulty, requiredTags: task.requiredTags },
-              resolved,
-              quotaRouting: mesh?.policy?.quotaRouting ?? null,
-              quotaFactsContext: quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader),
-              skippedCandidates,
-              requiredTagsResult: {
-                required: requiredTags,
-                satisfied: !requiredTags.length || nodeSatisfiesRequiredTags(requiredTags, buildMeshNodeCapabilityTags(node, resolved.providerType)),
-                missing: requiredTags.filter((t) => !buildMeshNodeCapabilityTags(node, resolved.providerType).includes(t))
-              },
-              effectiveModel,
-              effectiveThinkingLevel,
-              executedSlot: slotDecision.slot,
-              demotionReason
-            });
-            tryAssignQueueTask(components, meshId, nodeId, sessionId, resolved.providerType, routingDecision);
-            return true;
-          } catch (e) {
-            markAutoLaunch(meshId, task.id, { status: "failed", error: e?.message || String(e), nodeId });
-            autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
-            return false;
-          } finally {
-            autoLaunchInProgress.delete(launchKey);
           }
+        } finally {
+          autoLaunchTaskInProgress.delete(taskLaunchKey);
         }
       }
       return false;
@@ -67627,7 +68118,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         if (instMeshId !== meshId) continue;
         const nodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
         if (!nodeId) continue;
-        if (!isIdleSessionState2(state)) {
+        if (!isIdleSessionState3(state)) {
           const status = readNonEmptyString(state.status).toLowerCase();
           skippedSessions.push({
             nodeId,
@@ -67700,6 +68191,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         }
       }
       autoLaunchStarted = await maybeAutoLaunchOneQueueSession(components, meshId, mesh);
+      sweepAutoLaunchOrphanSessions(components, meshId);
       const afterQueue = getQueue(meshId);
       const pendingAfter = afterQueue.filter((task) => task.status === "pending").length;
       const assignedAfter = afterQueue.filter((task) => task.status === "assigned").length;
@@ -67758,12 +68250,10 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     var LOCAL_LAUNCH_READY_TIMEOUT_MS;
     var LOCAL_LAUNCH_READY_POLL_MS;
     var autoLaunchInProgress;
+    var autoLaunchTaskInProgress;
     var autoLaunchCooldownUntil;
     var AUTO_LAUNCH_COOLDOWN_MS;
-    var AUTO_LAUNCH_AWAIT_CLAIM_MS;
-    var AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES;
-    var AUTO_LAUNCH_REMOTE_IDLE_TTL_MS;
-    var autoLaunchAwaitClaimBackoff;
+    var AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES2;
     var init_mesh_queue_assignment = __esm2({
       "src/mesh/mesh-queue-assignment.ts"() {
         "use strict";
@@ -67796,14 +68286,17 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         init_mesh_duplicate_dispatch();
         init_mesh_auto_fast_forward();
         init_mesh_skip_notify();
+        init_mesh_task_parking();
         init_mesh_scheduling_fitness();
         init_mesh_queue_observability();
         init_mesh_routing_decision();
+        init_mesh_autolaunch_integrity();
         init_mesh_difficulty_floor();
         init_mesh_difficulty_floor();
         init_mesh_auto_fast_forward();
         init_mesh_skip_notify();
         init_mesh_scheduling_fitness();
+        init_mesh_autolaunch_integrity();
         BOOTSTRAP_TERMINAL_STATUSES = /* @__PURE__ */ new Set(["complete", "failed"]);
         DISPATCH_CONFIRM_TIMEOUT_MS = 12e4;
         DISPATCH_CONNECT_TIMEOUT_MS = MESH_CONNECT_TIMEOUT_MS2;
@@ -67811,12 +68304,10 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         LOCAL_LAUNCH_READY_TIMEOUT_MS = 15e3;
         LOCAL_LAUNCH_READY_POLL_MS = 100;
         autoLaunchInProgress = /* @__PURE__ */ new Set();
+        autoLaunchTaskInProgress = /* @__PURE__ */ new Set();
         autoLaunchCooldownUntil = /* @__PURE__ */ new Map();
         AUTO_LAUNCH_COOLDOWN_MS = 5e3;
-        AUTO_LAUNCH_AWAIT_CLAIM_MS = 9e4;
-        AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES = 2;
-        AUTO_LAUNCH_REMOTE_IDLE_TTL_MS = 5 * 60 * 1e3;
-        autoLaunchAwaitClaimBackoff = /* @__PURE__ */ new Map();
+        AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES2 = 2;
       }
     });
     function readSettings(state) {
@@ -70550,6 +71041,11 @@ ${cleanBody}`;
       if (isFalseIdleCompletion(metadataEvent)) return false;
       return !!readWorkerResultMetadata(metadataEvent) || !!readNonEmptyString(metadataEvent.finalSummary);
     }
+    function resolveGraphEnvelopeWorkerResult(metadataEvent) {
+      const explicit = readWorkerResultMetadata(metadataEvent);
+      if (explicit) return explicit;
+      return extractJsonObjectFromSummary(readNonEmptyString(metadataEvent.finalSummary) || void 0);
+    }
     function supersedesTruncatedTerminalSummary(args) {
       if (!args.terminalTaskId || !args.eventTaskId || args.terminalTaskId !== args.eventTaskId) return false;
       if (!isGenuineCompletionEvidence(args.metadataEvent)) return false;
@@ -71187,7 +71683,7 @@ ${cleanBody}`;
           // as the terminal flip (design :317-327 step 2).
           envelope: {
             finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || void 0,
-            workerResult: readWorkerResultMetadata(args.metadataEvent),
+            workerResult: resolveGraphEnvelopeWorkerResult(args.metadataEvent),
             nodeId: readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || void 0,
             providerType: readNonEmptyString(args.metadataEvent.providerType) || void 0
           }
@@ -77159,8 +77655,8 @@ ${cleanBody}`;
             let cwd = options.cwd;
             if (cwd) {
               try {
-                const fs59 = require("fs");
-                const stat2 = fs59.statSync(cwd);
+                const fs61 = require("fs");
+                const stat2 = fs61.statSync(cwd);
                 if (!stat2.isDirectory()) cwd = os14.homedir();
               } catch {
                 cwd = os14.homedir();
@@ -78557,6 +79053,360 @@ ${cleanBody}`;
         DEFAULT_REFINE_VITEST_MAX_WORKERS = 2;
       }
     });
+    function readChangedGitlinkPaths(repoRoot, fromRef, toRef) {
+      try {
+        const output = (0, import_node_child_process11.execFileSync)(GIT4, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
+          cwd: repoRoot,
+          encoding: "utf8",
+          maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
+        });
+        const paths = /* @__PURE__ */ new Set();
+        for (const line of output.split("\n")) {
+          if (!line.trim()) continue;
+          const metaAndPath = line.split("	");
+          const meta3 = metaAndPath[0] || "";
+          const path58 = metaAndPath[metaAndPath.length - 1]?.trim();
+          if (!path58) continue;
+          const parts = meta3.split(/\s+/);
+          if (parts[0]?.includes("160000") || parts[1]?.includes("160000")) {
+            paths.add(path58);
+          }
+        }
+        return [...paths].sort();
+      } catch {
+        return [];
+      }
+    }
+    function readTreeObject(repoRoot, ref, path58) {
+      try {
+        const output = (0, import_node_child_process11.execFileSync)(GIT4, ["ls-tree", ref, "--", path58], {
+          cwd: repoRoot,
+          encoding: "utf8",
+          maxBuffer: 1024 * 1024
+        }).trim();
+        const match = output.match(/\bcommit\s+([0-9a-f]{40})\b/i);
+        return match?.[1];
+      } catch {
+        return void 0;
+      }
+    }
+    function submoduleCommitPresent(submoduleRepoPath, commit) {
+      if (!commit) return false;
+      try {
+        (0, import_node_child_process11.execFileSync)(GIT4, ["cat-file", "-e", `${commit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    function ensureSubmoduleCommitLocal(submoduleRepoPath, baseSubmoduleRepoPath, commit) {
+      if (!commit) return false;
+      const present = () => {
+        try {
+          (0, import_node_child_process11.execFileSync)(GIT4, ["cat-file", "-e", `${commit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+          return true;
+        } catch {
+          return false;
+        }
+      };
+      if (present()) return true;
+      try {
+        if (!fs48.existsSync(submoduleRepoPath) || !fs48.existsSync(baseSubmoduleRepoPath)) return false;
+      } catch {
+        return false;
+      }
+      const strategies = [
+        // 1. All local branches (historical behaviour).
+        ["fetch", "-q", baseSubmoduleRepoPath, "+refs/heads/*:refs/adhdev-refine-base/*"],
+        // 2. The base checkout's detached HEAD plus every ref it has.
+        ["fetch", "-q", baseSubmoduleRepoPath, "HEAD", "+refs/*:refs/adhdev-refine-base-all/*"],
+        // 3. The exact object, allowing a bare-sha want on the source side.
+        ["fetch", "-q", "--upload-pack", "git -c uploadpack.allowAnySHA1InWant=true upload-pack", baseSubmoduleRepoPath, commit]
+      ];
+      for (const args of strategies) {
+        try {
+          (0, import_node_child_process11.execFileSync)(GIT4, ["-c", "protocol.file.allow=always", ...args], {
+            cwd: submoduleRepoPath,
+            stdio: ["ignore", "ignore", "pipe"]
+          });
+        } catch {
+        }
+        if (present()) return true;
+      }
+      return false;
+    }
+    var fs48;
+    var import_node_child_process11;
+    var GIT4;
+    var REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES;
+    var init_mesh_refine_gitlink_utils = __esm2({
+      "src/mesh/mesh-refine-gitlink-utils.ts"() {
+        "use strict";
+        fs48 = __toESM2(require("fs"));
+        import_node_child_process11 = require("child_process");
+        init_resolve_executable();
+        GIT4 = process.platform === "win32" ? resolveWin32Executable("git") : "git";
+        REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES = 4 * 1024 * 1024;
+      }
+    });
+    function classifySubmoduleDivergence(submoduleRepoPath, baseCommit, branchCommit) {
+      if (!baseCommit || !branchCommit) return "undeterminable";
+      if (baseCommit === branchCommit) return "not_diverged";
+      try {
+        if (!fs49.existsSync(submoduleRepoPath)) return "undeterminable";
+        (0, import_node_child_process12.execFileSync)(GIT4, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+        (0, import_node_child_process12.execFileSync)(GIT4, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+      } catch {
+        return "undeterminable";
+      }
+      try {
+        (0, import_node_child_process12.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+        return "not_diverged";
+      } catch {
+      }
+      try {
+        (0, import_node_child_process12.execFileSync)(GIT4, ["merge-base", "--is-ancestor", branchCommit, baseCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+        return "not_diverged";
+      } catch {
+      }
+      try {
+        const mb = (0, import_node_child_process12.execFileSync)(GIT4, ["merge-base", baseCommit, branchCommit], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+        return mb ? "diverged" : "not_diverged";
+      } catch {
+        return "not_diverged";
+      }
+    }
+    function resolveSubmoduleRemoteMainRef(submoduleRepoPath) {
+      try {
+        const sym = (0, import_node_child_process12.execFileSync)(GIT4, ["symbolic-ref", "-q", "refs/remotes/origin/HEAD"], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+        if (sym) return sym;
+      } catch {
+      }
+      for (const branch of ["main", "master"]) {
+        try {
+          (0, import_node_child_process12.execFileSync)(GIT4, ["rev-parse", "--verify", "-q", `refs/remotes/origin/${branch}`], { cwd: submoduleRepoPath, stdio: ["ignore", "pipe", "pipe"] });
+          return `refs/remotes/origin/${branch}`;
+        } catch {
+        }
+      }
+      return void 0;
+    }
+    function findEquivalentPublishedSubmoduleCommit(submoduleRepoPath, baseCommit, branchCommit, remoteRef) {
+      try {
+        const mergeTreeOut = (0, import_node_child_process12.execFileSync)(GIT4, ["merge-tree", "--write-tree", baseCommit, branchCommit], {
+          cwd: submoduleRepoPath,
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        const mergedTree = mergeTreeOut.trim().split(/\s+/)[0] || "";
+        if (!mergedTree) return void 0;
+        const candidates = (0, import_node_child_process12.execFileSync)(GIT4, ["rev-list", "--max-count=100", remoteRef, "--not", baseCommit], {
+          cwd: submoduleRepoPath,
+          encoding: "utf8"
+        }).split("\n").map((s2) => s2.trim()).filter(Boolean);
+        for (const candidate of candidates) {
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, candidate], { cwd: submoduleRepoPath, stdio: "ignore" });
+          } catch {
+            continue;
+          }
+          const tree = (0, import_node_child_process12.execFileSync)(GIT4, ["rev-parse", `${candidate}^{tree}`], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+          if (tree === mergedTree) return candidate;
+        }
+      } catch {
+      }
+      return void 0;
+    }
+    function convergeDivergedSubmoduleGitlinks(worktreeRoot, baseRepoRoot, baseHead, branchHead) {
+      const changed = readChangedGitlinkPaths(worktreeRoot, baseHead, branchHead);
+      if (changed.length === 0) {
+        return { converged: false, reason: "no_changed_gitlinks", resolutions: [], gitlinks: [] };
+      }
+      const gitlinks = [];
+      const resolutions = [];
+      let sawDiverged = false;
+      let sawUndeterminable = false;
+      for (const path58 of changed) {
+        const baseCommit = readTreeObject(baseRepoRoot, baseHead, path58);
+        const branchCommit = readTreeObject(worktreeRoot, branchHead, path58);
+        const submoduleRepoPath = (0, import_path17.resolve)(worktreeRoot, path58);
+        if (baseCommit) {
+          ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path17.resolve)(baseRepoRoot, path58), baseCommit);
+        }
+        const markUndeterminable = () => {
+          const unavailable = [];
+          if (!baseCommit || !submoduleCommitPresent(submoduleRepoPath, baseCommit)) unavailable.push("base");
+          if (!branchCommit || !submoduleCommitPresent(submoduleRepoPath, branchCommit)) unavailable.push("branch");
+          sawUndeterminable = true;
+          gitlinks.push({ path: path58, baseCommit, branchCommit, action: "skipped_commit_unavailable", unavailable });
+        };
+        if (!baseCommit || !branchCommit) {
+          markUndeterminable();
+          continue;
+        }
+        const divergence = classifySubmoduleDivergence(submoduleRepoPath, baseCommit, branchCommit);
+        if (divergence === "undeterminable") {
+          markUndeterminable();
+          continue;
+        }
+        if (divergence !== "diverged") {
+          gitlinks.push({ path: path58, baseCommit, branchCommit, action: "skipped_not_diverged" });
+          continue;
+        }
+        sawDiverged = true;
+        try {
+          (0, import_node_child_process12.execFileSync)(GIT4, ["-c", "protocol.file.allow=always", "fetch", "-q", "origin"], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
+        } catch {
+        }
+        const remoteMainRef = resolveSubmoduleRemoteMainRef(submoduleRepoPath);
+        const publishedEquivalent = remoteMainRef ? findEquivalentPublishedSubmoduleCommit(submoduleRepoPath, baseCommit, branchCommit, remoteMainRef) : void 0;
+        if (publishedEquivalent) {
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["checkout", "-q", "--detach", publishedEquivalent], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
+          } catch {
+          }
+          gitlinks.push({ path: path58, baseCommit, branchCommit, rebasedCommit: publishedEquivalent, action: "converged_to_published" });
+          resolutions.push({ path: path58, baseCommit, branchCommit, rebasedCommit: publishedEquivalent });
+          continue;
+        }
+        let rebasedCommit;
+        try {
+          (0, import_node_child_process12.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
+          (0, import_node_child_process12.execFileSync)(GIT4, ["rebase", baseCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "pipe", "pipe"] });
+          rebasedCommit = (0, import_node_child_process12.execFileSync)(GIT4, ["rev-parse", "HEAD"], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
+        } catch {
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["rebase", "--abort"], { cwd: submoduleRepoPath, stdio: "ignore" });
+          } catch {
+          }
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+          } catch {
+          }
+          gitlinks.push({ path: path58, baseCommit, branchCommit, action: "rebase_conflict" });
+          return { converged: false, reason: "rebase_conflict", resolutions: [], gitlinks };
+        }
+        const branchWorkSurvived = (() => {
+          if (!rebasedCommit) return false;
+          if (rebasedCommit === branchCommit) return true;
+          if (rebasedCommit === baseCommit) return false;
+          try {
+            const replayed = (0, import_node_child_process12.execFileSync)(GIT4, ["rev-list", "--count", `${baseCommit}..${rebasedCommit}`], {
+              cwd: submoduleRepoPath,
+              encoding: "utf8"
+            }).trim();
+            return Number.parseInt(replayed, 10) > 0;
+          } catch {
+            return false;
+          }
+        })();
+        if (!branchWorkSurvived) {
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+          } catch {
+          }
+          gitlinks.push({ path: path58, baseCommit, branchCommit, rebasedCommit, action: "rebase_dropped_branch_commits" });
+          return { converged: false, reason: "rebase_dropped_branch_commits", resolutions: [], gitlinks };
+        }
+        gitlinks.push({ path: path58, baseCommit, branchCommit, rebasedCommit, action: "rebased" });
+        resolutions.push({ path: path58, baseCommit, branchCommit, rebasedCommit });
+      }
+      if (!sawDiverged) {
+        const reason = sawUndeterminable ? "submodule_commit_unavailable" : "not_diverged";
+        return { converged: false, reason, resolutions: [], gitlinks };
+      }
+      return { converged: resolutions.length > 0, resolutions, gitlinks };
+    }
+    function rootRebaseResolvingGitlinks(worktreeRoot, baseHead, resolutions) {
+      const resolveByPath = new Map(resolutions.map((r) => [r.path, r.rebasedCommit]));
+      const runRebase = (args) => {
+        try {
+          (0, import_node_child_process12.execFileSync)(GIT4, args, {
+            cwd: worktreeRoot,
+            stdio: ["ignore", "pipe", "pipe"],
+            // A rebase editor prompt would hang; keep it non-interactive.
+            env: { ...process.env, GIT_EDITOR: "true", GIT_SEQUENCE_EDITOR: "true" }
+          });
+          return { ok: true };
+        } catch {
+          return { ok: false };
+        }
+      };
+      const unmergedPaths = () => {
+        try {
+          return (0, import_node_child_process12.execFileSync)(GIT4, ["diff", "--name-only", "--diff-filter=U"], { cwd: worktreeRoot, encoding: "utf8" }).split("\n").map((s2) => s2.trim()).filter(Boolean);
+        } catch {
+          return [];
+        }
+      };
+      const abort = (reason, conflictPaths) => {
+        try {
+          (0, import_node_child_process12.execFileSync)(GIT4, ["rebase", "--abort"], { cwd: worktreeRoot, stdio: "ignore" });
+        } catch {
+        }
+        return { ok: false, reason, conflictPaths };
+      };
+      let progress = runRebase(["rebase", baseHead]);
+      let guard = 0;
+      while (!progress.ok) {
+        if (guard++ > 100) return abort("rebase_error");
+        const conflicts = unmergedPaths();
+        if (conflicts.length === 0) {
+          return abort("rebase_error");
+        }
+        const unresolvable = conflicts.filter((p) => !resolveByPath.has(p));
+        if (unresolvable.length > 0) {
+          const unresolvableGitlink = unresolvable.some((p) => {
+            try {
+              const staged = (0, import_node_child_process12.execFileSync)(GIT4, ["ls-files", "--stage", "--", p], { cwd: worktreeRoot, encoding: "utf8" });
+              return /^160000\s/m.test(staged);
+            } catch {
+              return false;
+            }
+          });
+          const allGitlink = unresolvable.every((p) => {
+            try {
+              const staged = (0, import_node_child_process12.execFileSync)(GIT4, ["ls-files", "--stage", "--", p], { cwd: worktreeRoot, encoding: "utf8" });
+              return /^160000\s/m.test(staged);
+            } catch {
+              return false;
+            }
+          });
+          return abort(allGitlink && unresolvableGitlink ? "unexpected_gitlink" : "non_gitlink_conflict", conflicts);
+        }
+        for (const p of conflicts) {
+          const commit = resolveByPath.get(p);
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["checkout", "-q", "--detach", commit], { cwd: (0, import_path17.resolve)(worktreeRoot, p), stdio: "ignore" });
+          } catch {
+          }
+          try {
+            (0, import_node_child_process12.execFileSync)(GIT4, ["add", p], { cwd: worktreeRoot, stdio: "ignore" });
+          } catch {
+            return abort("rebase_error", conflicts);
+          }
+        }
+        progress = runRebase(["rebase", "--continue"]);
+      }
+      let branchHead;
+      try {
+        branchHead = (0, import_node_child_process12.execFileSync)(GIT4, ["rev-parse", "HEAD"], { cwd: worktreeRoot, encoding: "utf8" }).trim();
+      } catch {
+      }
+      return { ok: true, branchHead };
+    }
+    var fs49;
+    var import_path17;
+    var import_node_child_process12;
+    var init_mesh_refine_submodule_converge = __esm2({
+      "src/mesh/mesh-refine-submodule-converge.ts"() {
+        "use strict";
+        fs49 = __toESM2(require("fs"));
+        import_path17 = require("path");
+        import_node_child_process12 = require("child_process");
+        init_mesh_refine_gitlink_utils();
+      }
+    });
     function truncateValidationOutput(value) {
       const text = typeof value === "string" ? value : value == null ? "" : String(value);
       if (text.length <= REFINE_VALIDATION_SUMMARY_CHARS) return text;
@@ -78574,13 +79424,13 @@ ${tail}`;
     }
     function writeValidationFailureLog(workspace, index, candidate, streams, now = () => /* @__PURE__ */ new Date()) {
       try {
-        const dir = (0, import_path17.join)(workspace, REFINE_VALIDATION_LOG_DIR);
-        fs48.mkdirSync(dir, { recursive: true });
+        const dir = (0, import_path18.join)(workspace, REFINE_VALIDATION_LOG_DIR);
+        fs50.mkdirSync(dir, { recursive: true });
         const stamp = now().toISOString().replace(/[:.]/g, "-");
-        const file2 = (0, import_path17.join)(dir, `refine-${stamp}-${index}.log`);
+        const file2 = (0, import_path18.join)(dir, `refine-${stamp}-${index}.log`);
         const asText = (v) => typeof v === "string" ? v : v == null ? "" : String(v);
         const shown = candidate.displayCommand || [candidate.command, ...candidate.args || []].join(" ");
-        fs48.writeFileSync(
+        fs50.writeFileSync(
           file2,
           `# refine validation failure
 # command: ${shown}
@@ -78654,18 +79504,18 @@ ${asText(streams.stderr)}
       return { enabled: false };
     }
     async function computeGitPatchId(cwd, fromRef, toRef, excludePaths = []) {
-      const { execFileSync: execFileSync13 } = await import("child_process");
+      const { execFileSync: execFileSync15 } = await import("child_process");
       const diffArgs = ["diff", "--patch", "--full-index", fromRef, toRef];
       if (excludePaths.length > 0) {
         diffArgs.push("--", ".", ...excludePaths.map((path58) => `:(exclude)${path58}`));
       }
-      const diff = execFileSync13(GIT4, diffArgs, {
+      const diff = execFileSync15(GIT4, diffArgs, {
         cwd,
         encoding: "utf8",
         maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
       });
       if (!diff.trim()) return "";
-      const patchId = execFileSync13(GIT4, ["patch-id", "--stable"], {
+      const patchId = execFileSync15(GIT4, ["patch-id", "--stable"], {
         cwd,
         input: diff,
         encoding: "utf8",
@@ -78676,8 +79526,8 @@ ${asText(streams.stderr)}
     async function runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead) {
       const startedAt = Date.now();
       try {
-        const { execFileSync: execFileSync13 } = await import("child_process");
-        const git3 = (args) => execFileSync13(GIT4, args, {
+        const { execFileSync: execFileSync15 } = await import("child_process");
+        const git3 = (args) => execFileSync15(GIT4, args, {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -78778,7 +79628,7 @@ ${e?.stderr || ""}`
         ...autoPublish !== void 0 ? { autoPublishSubmoduleMainCommits: autoPublish } : {}
       };
       try {
-        const git3 = (args) => (0, import_node_child_process11.execFileSync)(GIT4, args, {
+        const git3 = (args) => (0, import_node_child_process13.execFileSync)(GIT4, args, {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
@@ -78832,7 +79682,7 @@ ${e?.stderr || ""}`
             } catch {
               continue;
             }
-            const submoduleRepo = (0, import_path17.join)(repoRoot, p);
+            const submoduleRepo = (0, import_path18.join)(repoRoot, p);
             let fastForward;
             let reachableFromOriginMain;
             if (branchCommit) {
@@ -78903,7 +79753,7 @@ ${e?.stderr || ""}`
     }
     function execGitOk(cwd, args) {
       try {
-        (0, import_node_child_process11.execFileSync)(GIT4, args, { cwd, encoding: "utf8", maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES, windowsHide: true });
+        (0, import_node_child_process13.execFileSync)(GIT4, args, { cwd, encoding: "utf8", maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES, windowsHide: true });
         return true;
       } catch {
         return false;
@@ -78912,8 +79762,8 @@ ${e?.stderr || ""}`
     async function checkWorktreeChangesPatchEquivalentInRef(repoRoot, ref, worktreeHead) {
       const startedAt = Date.now();
       try {
-        const { execFileSync: execFileSync13 } = await import("child_process");
-        const git3 = (gitArgs) => execFileSync13(GIT4, gitArgs, {
+        const { execFileSync: execFileSync15 } = await import("child_process");
+        const git3 = (gitArgs) => execFileSync15(GIT4, gitArgs, {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -78976,8 +79826,8 @@ ${mergeTreeErr?.stderr || ""}`;
     async function runMeshRefineEffectiveDiffGate(repoRoot, baseHead, branchHead) {
       const startedAt = Date.now();
       try {
-        const { execFileSync: execFileSync13 } = await import("child_process");
-        const git3 = (args, opts) => execFileSync13(GIT4, args, {
+        const { execFileSync: execFileSync15 } = await import("child_process");
+        const git3 = (args, opts) => execFileSync15(GIT4, args, {
           cwd: opts?.cwd || repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -79051,45 +79901,8 @@ ${mergeTreeErr?.stderr || ""}`;
         ]
       };
     }
-    function readChangedGitlinkPaths(repoRoot, fromRef, toRef) {
-      try {
-        const output = (0, import_node_child_process11.execFileSync)(GIT4, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
-          cwd: repoRoot,
-          encoding: "utf8",
-          maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
-        });
-        const paths = /* @__PURE__ */ new Set();
-        for (const line of output.split("\n")) {
-          if (!line.trim()) continue;
-          const metaAndPath = line.split("	");
-          const meta3 = metaAndPath[0] || "";
-          const path58 = metaAndPath[metaAndPath.length - 1]?.trim();
-          if (!path58) continue;
-          const parts = meta3.split(/\s+/);
-          if (parts[0]?.includes("160000") || parts[1]?.includes("160000")) {
-            paths.add(path58);
-          }
-        }
-        return [...paths].sort();
-      } catch {
-        return [];
-      }
-    }
-    function readTreeObject(repoRoot, ref, path58) {
-      try {
-        const output = (0, import_node_child_process11.execFileSync)(GIT4, ["ls-tree", ref, "--", path58], {
-          cwd: repoRoot,
-          encoding: "utf8",
-          maxBuffer: 1024 * 1024
-        }).trim();
-        const match = output.match(/\bcommit\s+([0-9a-f]{40})\b/i);
-        return match?.[1];
-      } catch {
-        return void 0;
-      }
-    }
     function resolveGitDir(repoRoot) {
-      const out = (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", "--absolute-git-dir"], {
+      const out = (0, import_node_child_process13.execFileSync)(GIT4, ["rev-parse", "--absolute-git-dir"], {
         cwd: repoRoot,
         encoding: "utf8",
         maxBuffer: 1024 * 1024
@@ -79100,10 +79913,10 @@ ${mergeTreeErr?.stderr || ""}`;
       if (!baseCommit || !branchCommit) return false;
       if (baseCommit === branchCommit) return true;
       try {
-        if (!fs48.existsSync(submoduleRepoPath)) return false;
-        (0, import_node_child_process11.execFileSync)(GIT4, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
-        (0, import_node_child_process11.execFileSync)(GIT4, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
-        (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+        if (!fs50.existsSync(submoduleRepoPath)) return false;
+        (0, import_node_child_process13.execFileSync)(GIT4, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+        (0, import_node_child_process13.execFileSync)(GIT4, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+        (0, import_node_child_process13.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
         return true;
       } catch {
         return false;
@@ -79111,7 +79924,7 @@ ${mergeTreeErr?.stderr || ""}`;
     }
     function readChangedPathKinds(repoRoot, fromRef, toRef) {
       try {
-        const output = (0, import_node_child_process11.execFileSync)(GIT4, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
+        const output = (0, import_node_child_process13.execFileSync)(GIT4, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -79139,7 +79952,7 @@ ${mergeTreeErr?.stderr || ""}`;
         const baseCommit = readTreeObject(repoRoot, baseHead, path58);
         const branchCommit = readTreeObject(repoRoot, branchHead, path58);
         if (!baseCommit || !branchCommit) return false;
-        return isSubmoduleFastForward((0, import_path17.resolve)(repoRoot, path58), baseCommit, branchCommit);
+        return isSubmoduleFastForward((0, import_path18.resolve)(repoRoot, path58), baseCommit, branchCommit);
       });
     }
     function collectTrivialFastForwardGitlinkResolutions(worktreeRoot, baseRepoRoot, baseHead, branchHead) {
@@ -79148,8 +79961,8 @@ ${mergeTreeErr?.stderr || ""}`;
         const baseCommit = readTreeObject(baseRepoRoot, baseHead, path58);
         const branchCommit = readTreeObject(worktreeRoot, branchHead, path58);
         if (!baseCommit || !branchCommit) continue;
-        const submoduleRepoPath = (0, import_path17.resolve)(worktreeRoot, path58);
-        ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path17.resolve)(baseRepoRoot, path58), baseCommit);
+        const submoduleRepoPath = (0, import_path18.resolve)(worktreeRoot, path58);
+        ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path18.resolve)(baseRepoRoot, path58), baseCommit);
         if (baseCommit === branchCommit) {
           continue;
         }
@@ -79161,254 +79974,11 @@ ${mergeTreeErr?.stderr || ""}`;
       }
       return resolutions;
     }
-    function isSubmoduleDivergedSibling(submoduleRepoPath, baseCommit, branchCommit) {
-      if (!baseCommit || !branchCommit || baseCommit === branchCommit) return false;
-      try {
-        if (!fs48.existsSync(submoduleRepoPath)) return false;
-        (0, import_node_child_process11.execFileSync)(GIT4, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
-        (0, import_node_child_process11.execFileSync)(GIT4, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
-      } catch {
-        return false;
-      }
-      try {
-        (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
-        return false;
-      } catch {
-      }
-      try {
-        (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", "--is-ancestor", branchCommit, baseCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
-        return false;
-      } catch {
-      }
-      try {
-        const mb = (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", baseCommit, branchCommit], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
-        return !!mb;
-      } catch {
-        return false;
-      }
-    }
-    function resolveSubmoduleRemoteMainRef(submoduleRepoPath) {
-      try {
-        const sym = (0, import_node_child_process11.execFileSync)(GIT4, ["symbolic-ref", "-q", "refs/remotes/origin/HEAD"], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
-        if (sym) return sym;
-      } catch {
-      }
-      for (const branch of ["main", "master"]) {
-        try {
-          (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", "--verify", "-q", `refs/remotes/origin/${branch}`], { cwd: submoduleRepoPath, stdio: ["ignore", "pipe", "pipe"] });
-          return `refs/remotes/origin/${branch}`;
-        } catch {
-        }
-      }
-      return void 0;
-    }
-    function findEquivalentPublishedSubmoduleCommit(submoduleRepoPath, baseCommit, branchCommit, remoteRef) {
-      try {
-        const mergeTreeOut = (0, import_node_child_process11.execFileSync)(GIT4, ["merge-tree", "--write-tree", baseCommit, branchCommit], {
-          cwd: submoduleRepoPath,
-          encoding: "utf8",
-          stdio: ["ignore", "pipe", "pipe"]
-        });
-        const mergedTree = mergeTreeOut.trim().split(/\s+/)[0] || "";
-        if (!mergedTree) return void 0;
-        const candidates = (0, import_node_child_process11.execFileSync)(GIT4, ["rev-list", "--max-count=100", remoteRef, "--not", baseCommit], {
-          cwd: submoduleRepoPath,
-          encoding: "utf8"
-        }).split("\n").map((s2) => s2.trim()).filter(Boolean);
-        for (const candidate of candidates) {
-          try {
-            (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", "--is-ancestor", baseCommit, candidate], { cwd: submoduleRepoPath, stdio: "ignore" });
-          } catch {
-            continue;
-          }
-          const tree = (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", `${candidate}^{tree}`], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
-          if (tree === mergedTree) return candidate;
-        }
-      } catch {
-      }
-      return void 0;
-    }
-    function ensureSubmoduleCommitLocal(submoduleRepoPath, baseSubmoduleRepoPath, commit) {
-      if (!commit) return;
-      try {
-        (0, import_node_child_process11.execFileSync)(GIT4, ["cat-file", "-e", `${commit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
-        return;
-      } catch {
-      }
-      try {
-        if (!fs48.existsSync(submoduleRepoPath) || !fs48.existsSync(baseSubmoduleRepoPath)) return;
-        (0, import_node_child_process11.execFileSync)(GIT4, ["-c", "protocol.file.allow=always", "fetch", "-q", baseSubmoduleRepoPath, "+refs/heads/*:refs/adhdev-refine-base/*"], {
-          cwd: submoduleRepoPath,
-          stdio: ["ignore", "ignore", "pipe"]
-        });
-      } catch {
-      }
-    }
-    function convergeDivergedSubmoduleGitlinks(worktreeRoot, baseRepoRoot, baseHead, branchHead) {
-      const changed = readChangedGitlinkPaths(worktreeRoot, baseHead, branchHead);
-      if (changed.length === 0) {
-        return { converged: false, reason: "no_changed_gitlinks", resolutions: [], gitlinks: [] };
-      }
-      const gitlinks = [];
-      const resolutions = [];
-      let sawDiverged = false;
-      for (const path58 of changed) {
-        const baseCommit = readTreeObject(baseRepoRoot, baseHead, path58);
-        const branchCommit = readTreeObject(worktreeRoot, branchHead, path58);
-        const submoduleRepoPath = (0, import_path17.resolve)(worktreeRoot, path58);
-        if (baseCommit) {
-          ensureSubmoduleCommitLocal(submoduleRepoPath, (0, import_path17.resolve)(baseRepoRoot, path58), baseCommit);
-        }
-        if (!baseCommit || !branchCommit || !isSubmoduleDivergedSibling(submoduleRepoPath, baseCommit, branchCommit)) {
-          gitlinks.push({ path: path58, baseCommit, branchCommit, action: "skipped_not_diverged" });
-          continue;
-        }
-        sawDiverged = true;
-        try {
-          (0, import_node_child_process11.execFileSync)(GIT4, ["-c", "protocol.file.allow=always", "fetch", "-q", "origin"], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
-        } catch {
-        }
-        const remoteMainRef = resolveSubmoduleRemoteMainRef(submoduleRepoPath);
-        const publishedEquivalent = remoteMainRef ? findEquivalentPublishedSubmoduleCommit(submoduleRepoPath, baseCommit, branchCommit, remoteMainRef) : void 0;
-        if (publishedEquivalent) {
-          try {
-            (0, import_node_child_process11.execFileSync)(GIT4, ["checkout", "-q", "--detach", publishedEquivalent], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
-          } catch {
-          }
-          gitlinks.push({ path: path58, baseCommit, branchCommit, rebasedCommit: publishedEquivalent, action: "converged_to_published" });
-          resolutions.push({ path: path58, baseCommit, branchCommit, rebasedCommit: publishedEquivalent });
-          continue;
-        }
-        let rebasedCommit;
-        try {
-          (0, import_node_child_process11.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "ignore", "pipe"] });
-          (0, import_node_child_process11.execFileSync)(GIT4, ["rebase", baseCommit], { cwd: submoduleRepoPath, stdio: ["ignore", "pipe", "pipe"] });
-          rebasedCommit = (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", "HEAD"], { cwd: submoduleRepoPath, encoding: "utf8" }).trim();
-        } catch {
-          try {
-            (0, import_node_child_process11.execFileSync)(GIT4, ["rebase", "--abort"], { cwd: submoduleRepoPath, stdio: "ignore" });
-          } catch {
-          }
-          try {
-            (0, import_node_child_process11.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
-          } catch {
-          }
-          gitlinks.push({ path: path58, baseCommit, branchCommit, action: "rebase_conflict" });
-          return { converged: false, reason: "rebase_conflict", resolutions: [], gitlinks };
-        }
-        const branchWorkSurvived = (() => {
-          if (!rebasedCommit) return false;
-          if (rebasedCommit === branchCommit) return true;
-          if (rebasedCommit === baseCommit) return false;
-          try {
-            const replayed = (0, import_node_child_process11.execFileSync)(GIT4, ["rev-list", "--count", `${baseCommit}..${rebasedCommit}`], {
-              cwd: submoduleRepoPath,
-              encoding: "utf8"
-            }).trim();
-            return Number.parseInt(replayed, 10) > 0;
-          } catch {
-            return false;
-          }
-        })();
-        if (!branchWorkSurvived) {
-          try {
-            (0, import_node_child_process11.execFileSync)(GIT4, ["checkout", "-q", "--detach", branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
-          } catch {
-          }
-          gitlinks.push({ path: path58, baseCommit, branchCommit, rebasedCommit, action: "rebase_dropped_branch_commits" });
-          return { converged: false, reason: "rebase_dropped_branch_commits", resolutions: [], gitlinks };
-        }
-        gitlinks.push({ path: path58, baseCommit, branchCommit, rebasedCommit, action: "rebased" });
-        resolutions.push({ path: path58, baseCommit, branchCommit, rebasedCommit });
-      }
-      if (!sawDiverged) {
-        return { converged: false, reason: "not_diverged", resolutions: [], gitlinks };
-      }
-      return { converged: resolutions.length > 0, resolutions, gitlinks };
-    }
-    function rootRebaseResolvingGitlinks(worktreeRoot, baseHead, resolutions) {
-      const resolveByPath = new Map(resolutions.map((r) => [r.path, r.rebasedCommit]));
-      const runRebase = (args) => {
-        try {
-          (0, import_node_child_process11.execFileSync)(GIT4, args, {
-            cwd: worktreeRoot,
-            stdio: ["ignore", "pipe", "pipe"],
-            // A rebase editor prompt would hang; keep it non-interactive.
-            env: { ...process.env, GIT_EDITOR: "true", GIT_SEQUENCE_EDITOR: "true" }
-          });
-          return { ok: true };
-        } catch {
-          return { ok: false };
-        }
-      };
-      const unmergedPaths = () => {
-        try {
-          return (0, import_node_child_process11.execFileSync)(GIT4, ["diff", "--name-only", "--diff-filter=U"], { cwd: worktreeRoot, encoding: "utf8" }).split("\n").map((s2) => s2.trim()).filter(Boolean);
-        } catch {
-          return [];
-        }
-      };
-      const abort = (reason, conflictPaths) => {
-        try {
-          (0, import_node_child_process11.execFileSync)(GIT4, ["rebase", "--abort"], { cwd: worktreeRoot, stdio: "ignore" });
-        } catch {
-        }
-        return { ok: false, reason, conflictPaths };
-      };
-      let progress = runRebase(["rebase", baseHead]);
-      let guard = 0;
-      while (!progress.ok) {
-        if (guard++ > 100) return abort("rebase_error");
-        const conflicts = unmergedPaths();
-        if (conflicts.length === 0) {
-          return abort("rebase_error");
-        }
-        const unresolvable = conflicts.filter((p) => !resolveByPath.has(p));
-        if (unresolvable.length > 0) {
-          const unresolvableGitlink = unresolvable.some((p) => {
-            try {
-              const staged = (0, import_node_child_process11.execFileSync)(GIT4, ["ls-files", "--stage", "--", p], { cwd: worktreeRoot, encoding: "utf8" });
-              return /^160000\s/m.test(staged);
-            } catch {
-              return false;
-            }
-          });
-          const allGitlink = unresolvable.every((p) => {
-            try {
-              const staged = (0, import_node_child_process11.execFileSync)(GIT4, ["ls-files", "--stage", "--", p], { cwd: worktreeRoot, encoding: "utf8" });
-              return /^160000\s/m.test(staged);
-            } catch {
-              return false;
-            }
-          });
-          return abort(allGitlink && unresolvableGitlink ? "unexpected_gitlink" : "non_gitlink_conflict", conflicts);
-        }
-        for (const p of conflicts) {
-          const commit = resolveByPath.get(p);
-          try {
-            (0, import_node_child_process11.execFileSync)(GIT4, ["checkout", "-q", "--detach", commit], { cwd: (0, import_path17.resolve)(worktreeRoot, p), stdio: "ignore" });
-          } catch {
-          }
-          try {
-            (0, import_node_child_process11.execFileSync)(GIT4, ["add", p], { cwd: worktreeRoot, stdio: "ignore" });
-          } catch {
-            return abort("rebase_error", conflicts);
-          }
-        }
-        progress = runRebase(["rebase", "--continue"]);
-      }
-      let branchHead;
-      try {
-        branchHead = (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", "HEAD"], { cwd: worktreeRoot, encoding: "utf8" }).trim();
-      } catch {
-      }
-      return { ok: true, branchHead };
-    }
     function evaluateGitlinkTrivialFastForward(repoRoot, baseHead, branchHead) {
       const changedGitlinks = readChangedGitlinkPaths(repoRoot, baseHead, branchHead).map((path58) => {
         const baseCommit = readTreeObject(repoRoot, baseHead, path58);
         const branchCommit = readTreeObject(repoRoot, branchHead, path58);
-        const submoduleRepoPath = (0, import_path17.resolve)(repoRoot, path58);
+        const submoduleRepoPath = (0, import_path18.resolve)(repoRoot, path58);
         const fastForward = !!baseCommit && !!branchCommit && isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit);
         return { path: path58, baseCommit, branchCommit, fastForward };
       });
@@ -79425,7 +79995,7 @@ ${mergeTreeErr?.stderr || ""}`;
       }
       let mergeBase = "";
       try {
-        mergeBase = (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", baseHead, branchHead], {
+        mergeBase = (0, import_node_child_process13.execFileSync)(GIT4, ["merge-base", baseHead, branchHead], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: 1024 * 1024
@@ -79455,7 +80025,7 @@ ${mergeTreeErr?.stderr || ""}`;
     }
     function buildTreeWithGitlinksEqualized(repoRoot, commitish, paths, placeholderCommit) {
       try {
-        const tree = (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", `${commitish}^{tree}`], {
+        const tree = (0, import_node_child_process13.execFileSync)(GIT4, ["rev-parse", `${commitish}^{tree}`], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: 1024 * 1024
@@ -79463,11 +80033,11 @@ ${mergeTreeErr?.stderr || ""}`;
         if (!tree) return void 0;
         const updates = paths.map((path58) => `160000 commit ${placeholderCommit}	${path58}`).join("\n");
         if (!updates) return tree;
-        const tmpIndex = (0, import_path17.join)(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
+        const tmpIndex = (0, import_path18.join)(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
         const env2 = { ...process.env, GIT_INDEX_FILE: tmpIndex };
         try {
-          (0, import_node_child_process11.execFileSync)(GIT4, ["read-tree", tree], { cwd: repoRoot, env: env2, stdio: "ignore" });
-          (0, import_node_child_process11.execFileSync)(GIT4, ["update-index", "--index-info"], {
+          (0, import_node_child_process13.execFileSync)(GIT4, ["read-tree", tree], { cwd: repoRoot, env: env2, stdio: "ignore" });
+          (0, import_node_child_process13.execFileSync)(GIT4, ["update-index", "--index-info"], {
             cwd: repoRoot,
             env: env2,
             input: `${updates}
@@ -79475,11 +80045,11 @@ ${mergeTreeErr?.stderr || ""}`;
             encoding: "utf8",
             stdio: ["pipe", "ignore", "ignore"]
           });
-          const newTree = (0, import_node_child_process11.execFileSync)(GIT4, ["write-tree"], { cwd: repoRoot, env: env2, encoding: "utf8" }).trim();
+          const newTree = (0, import_node_child_process13.execFileSync)(GIT4, ["write-tree"], { cwd: repoRoot, env: env2, encoding: "utf8" }).trim();
           return newTree || void 0;
         } finally {
           try {
-            fs48.rmSync(tmpIndex, { force: true });
+            fs50.rmSync(tmpIndex, { force: true });
           } catch {
           }
         }
@@ -79491,7 +80061,7 @@ ${mergeTreeErr?.stderr || ""}`;
       try {
         const branchGitlinks = gitlinks.filter((entry) => entry.branchCommit);
         const gitlinkPaths = branchGitlinks.map((entry) => entry.path);
-        const mergeBase = (0, import_node_child_process11.execFileSync)(GIT4, ["merge-base", baseHead, branchHead], {
+        const mergeBase = (0, import_node_child_process13.execFileSync)(GIT4, ["merge-base", baseHead, branchHead], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: 1024 * 1024
@@ -79504,22 +80074,22 @@ ${mergeTreeErr?.stderr || ""}`;
           const theirsEqTree = buildTreeWithGitlinksEqualized(repoRoot, branchHead, gitlinkPaths, placeholder);
           if (baseEqTree && oursEqTree && theirsEqTree) {
             try {
-              const baseEqCommit = (0, import_node_child_process11.execFileSync)(GIT4, ["commit-tree", baseEqTree, "-m", "refine-ff-base"], {
+              const baseEqCommit = (0, import_node_child_process13.execFileSync)(GIT4, ["commit-tree", baseEqTree, "-m", "refine-ff-base"], {
                 cwd: repoRoot,
                 encoding: "utf8",
                 maxBuffer: 1024 * 1024
               }).trim();
-              const oursEqCommit = (0, import_node_child_process11.execFileSync)(GIT4, ["commit-tree", oursEqTree, "-p", baseEqCommit, "-m", "refine-ff-ours"], {
+              const oursEqCommit = (0, import_node_child_process13.execFileSync)(GIT4, ["commit-tree", oursEqTree, "-p", baseEqCommit, "-m", "refine-ff-ours"], {
                 cwd: repoRoot,
                 encoding: "utf8",
                 maxBuffer: 1024 * 1024
               }).trim();
-              const theirsEqCommit = (0, import_node_child_process11.execFileSync)(GIT4, ["commit-tree", theirsEqTree, "-p", baseEqCommit, "-m", "refine-ff-theirs"], {
+              const theirsEqCommit = (0, import_node_child_process13.execFileSync)(GIT4, ["commit-tree", theirsEqTree, "-p", baseEqCommit, "-m", "refine-ff-theirs"], {
                 cwd: repoRoot,
                 encoding: "utf8",
                 maxBuffer: 1024 * 1024
               }).trim();
-              const mergeOut = (0, import_node_child_process11.execFileSync)(GIT4, ["merge-tree", "--write-tree", oursEqCommit, theirsEqCommit], {
+              const mergeOut = (0, import_node_child_process13.execFileSync)(GIT4, ["merge-tree", "--write-tree", oursEqCommit, theirsEqCommit], {
                 cwd: repoRoot,
                 encoding: "utf8",
                 maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -79530,7 +80100,7 @@ ${mergeTreeErr?.stderr || ""}`;
             }
           }
         }
-        const contentTree = mergedContentTree || (0, import_node_child_process11.execFileSync)(GIT4, ["rev-parse", `${baseHead}^{tree}`], {
+        const contentTree = mergedContentTree || (0, import_node_child_process13.execFileSync)(GIT4, ["rev-parse", `${baseHead}^{tree}`], {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: 1024 * 1024
@@ -79538,11 +80108,11 @@ ${mergeTreeErr?.stderr || ""}`;
         if (!contentTree) return void 0;
         const updates = branchGitlinks.map((entry) => `160000 commit ${entry.branchCommit}	${entry.path}`).join("\n");
         if (!updates) return contentTree;
-        const tmpIndex = (0, import_path17.join)(resolveGitDir(repoRoot), `adhdev-refine-ff-${baseHead.slice(0, 12)}-${branchHead.slice(0, 12)}.index`);
+        const tmpIndex = (0, import_path18.join)(resolveGitDir(repoRoot), `adhdev-refine-ff-${baseHead.slice(0, 12)}-${branchHead.slice(0, 12)}.index`);
         const env2 = { ...process.env, GIT_INDEX_FILE: tmpIndex };
         try {
-          (0, import_node_child_process11.execFileSync)(GIT4, ["read-tree", contentTree], { cwd: repoRoot, env: env2, stdio: "ignore" });
-          (0, import_node_child_process11.execFileSync)(GIT4, ["update-index", "--index-info"], {
+          (0, import_node_child_process13.execFileSync)(GIT4, ["read-tree", contentTree], { cwd: repoRoot, env: env2, stdio: "ignore" });
+          (0, import_node_child_process13.execFileSync)(GIT4, ["update-index", "--index-info"], {
             cwd: repoRoot,
             env: env2,
             input: `${updates}
@@ -79550,11 +80120,11 @@ ${mergeTreeErr?.stderr || ""}`;
             encoding: "utf8",
             stdio: ["pipe", "ignore", "ignore"]
           });
-          const newTree = (0, import_node_child_process11.execFileSync)(GIT4, ["write-tree"], { cwd: repoRoot, env: env2, encoding: "utf8" }).trim();
+          const newTree = (0, import_node_child_process13.execFileSync)(GIT4, ["write-tree"], { cwd: repoRoot, env: env2, encoding: "utf8" }).trim();
           return newTree || void 0;
         } finally {
           try {
-            fs48.rmSync(tmpIndex, { force: true });
+            fs50.rmSync(tmpIndex, { force: true });
           } catch {
           }
         }
@@ -79666,7 +80236,7 @@ ${mergeTreeErr?.stderr || ""}`;
           return { stdout: String(stdout || ""), stderr: String(stderr || ""), refspec };
         };
         const importCommitFromWorktreeSubmodule = async (submodulePath, worktreeSubmodulePath, commit) => {
-          if (!fs48.existsSync(worktreeSubmodulePath)) return false;
+          if (!fs50.existsSync(worktreeSubmodulePath)) return false;
           try {
             await runGit3(worktreeSubmodulePath, ["cat-file", "-e", `${commit}^{commit}`]);
           } catch {
@@ -79695,7 +80265,7 @@ ${mergeTreeErr?.stderr || ""}`;
           return match ? { commit: match[1], path: match[2] } : null;
         }).filter((entry) => !!entry);
         for (const gitlink of gitlinks) {
-          const submodulePath = (0, import_path17.resolve)(repoRoot, gitlink.path);
+          const submodulePath = (0, import_path18.resolve)(repoRoot, gitlink.path);
           const entry = {
             path: gitlink.path,
             commit: gitlink.commit,
@@ -79703,7 +80273,7 @@ ${mergeTreeErr?.stderr || ""}`;
           };
           let submoduleDefaultBranch = "main";
           try {
-            if (!fs48.existsSync(submodulePath)) {
+            if (!fs50.existsSync(submodulePath)) {
               entry.error = `Submodule checkout missing at ${gitlink.path}`;
               entry.publishRequired = true;
               if (options.allowAutoPublishSubmoduleMainCommits === true) {
@@ -79722,7 +80292,7 @@ ${mergeTreeErr?.stderr || ""}`;
               entry.localReachable = false;
               if (options.allowAutoPublishSubmoduleMainCommits === true && options.worktreeRoot) {
                 try {
-                  const imported = await importCommitFromWorktreeSubmodule(submodulePath, (0, import_path17.resolve)(options.worktreeRoot, gitlink.path), gitlink.commit);
+                  const imported = await importCommitFromWorktreeSubmodule(submodulePath, (0, import_path18.resolve)(options.worktreeRoot, gitlink.path), gitlink.commit);
                   if (imported) {
                     entry.localReachable = true;
                     entry.importedFromWorktree = true;
@@ -79952,13 +80522,13 @@ ${mergeTreeErr?.stderr || ""}`;
         ...extras
       });
       const isPackageManagerValidation = (candidate) => {
-        const command = (0, import_path17.basename)(candidate.command).replace(/\.(?:cmd|exe)$/i, "");
+        const command = (0, import_path18.basename)(candidate.command).replace(/\.(?:cmd|exe)$/i, "");
         return ["npm", "pnpm", "yarn", "bun"].includes(command) && candidate.args.some((arg) => arg === "run" || arg === "test" || arg === "exec");
       };
       const dependenciesLikelyMissing = (cwd) => {
-        if (!fs48.existsSync((0, import_path17.join)(cwd, "package.json"))) return false;
-        if (fs48.existsSync((0, import_path17.join)(cwd, "node_modules"))) return false;
-        return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs48.existsSync((0, import_path17.join)(cwd, lock)));
+        if (!fs50.existsSync((0, import_path18.join)(cwd, "package.json"))) return false;
+        if (fs50.existsSync((0, import_path18.join)(cwd, "node_modules"))) return false;
+        return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs50.existsSync((0, import_path18.join)(cwd, lock)));
       };
       const needsNodeModules = (candidate, cwd) => isPackageManagerValidation(candidate) && dependenciesLikelyMissing(cwd);
       const isDaemonScopedCommand = (candidate) => {
@@ -80025,7 +80595,7 @@ ${mergeTreeErr?.stderr || ""}`;
         summary.bootstrap = { stage: "legacy" };
         for (const candidate of selection.bootstrapCommands) {
           const startedAt = Date.now();
-          const cwd = candidate.cwd ? (0, import_path17.resolve)(workspace, candidate.cwd) : workspace;
+          const cwd = candidate.cwd ? (0, import_path18.resolve)(workspace, candidate.cwd) : workspace;
           const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
           const resolvedCommand = resolveWin32Executable(candidate.command);
           const spawn7 = buildWin32ExecFileSpawn(resolvedCommand, candidate.args);
@@ -80058,7 +80628,7 @@ ${mergeTreeErr?.stderr || ""}`;
       let missingDepsBlocked = false;
       for (const candidate of commandsToRun) {
         const startedAt = Date.now();
-        const cwd = candidate.cwd ? (0, import_path17.resolve)(workspace, candidate.cwd) : workspace;
+        const cwd = candidate.cwd ? (0, import_path18.resolve)(workspace, candidate.cwd) : workspace;
         const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
         const bootstrapProvidedDependencies = summary.bootstrap?.stage === "cached" || summary.bootstrap?.stage === "ran" || summary.bootstrap?.stage === "legacy";
         if (!bootstrapProvidedDependencies && needsNodeModules(candidate, cwd)) {
@@ -80125,16 +80695,14 @@ ${mergeTreeErr?.stderr || ""}`;
       summary.status = "passed";
       return summary;
     }
-    var import_path17;
-    var fs48;
-    var import_node_child_process11;
-    var GIT4;
+    var import_path18;
+    var fs50;
+    var import_node_child_process13;
     var REFINE_VALIDATION_TIMEOUT_MS;
     var REFINE_VALIDATION_OUTPUT_LIMIT_BYTES;
     var REFINE_VALIDATION_SUMMARY_HEAD_CHARS;
     var REFINE_VALIDATION_SUMMARY_TAIL_CHARS;
     var REFINE_VALIDATION_SUMMARY_CHARS;
-    var REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES;
     var REFINE_VALIDATION_LOG_DIR;
     var init_mesh_refine_gates = __esm2({
       "src/mesh/mesh-refine-gates.ts"() {
@@ -80142,19 +80710,19 @@ ${mergeTreeErr?.stderr || ""}`;
         init_git_status();
         init_refine_config();
         init_worktree_bootstrap_config();
-        import_path17 = require("path");
-        fs48 = __toESM2(require("fs"));
-        import_node_child_process11 = require("child_process");
+        import_path18 = require("path");
+        fs50 = __toESM2(require("fs"));
+        import_node_child_process13 = require("child_process");
         init_resolve_executable();
         init_mesh_refine_worker_cap();
-        GIT4 = process.platform === "win32" ? resolveWin32Executable("git") : "git";
+        init_mesh_refine_gitlink_utils();
+        init_mesh_refine_submodule_converge();
         REFINE_VALIDATION_TIMEOUT_MS = 12e4;
         REFINE_VALIDATION_OUTPUT_LIMIT_BYTES = 128 * 1024;
         REFINE_VALIDATION_SUMMARY_HEAD_CHARS = 2e3;
         REFINE_VALIDATION_SUMMARY_TAIL_CHARS = 6e3;
         REFINE_VALIDATION_SUMMARY_CHARS = REFINE_VALIDATION_SUMMARY_HEAD_CHARS + REFINE_VALIDATION_SUMMARY_TAIL_CHARS;
-        REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES = 4 * 1024 * 1024;
-        REFINE_VALIDATION_LOG_DIR = (0, import_path17.join)(".adhdev", "logs");
+        REFINE_VALIDATION_LOG_DIR = (0, import_path18.join)(".adhdev", "logs");
       }
     });
     function findOpenRefineDispatchForNode(args) {
@@ -80841,6 +81409,9 @@ ${mergeTreeErr?.stderr || ""}`;
               convergeReason: converge.reason,
               gitlinks: converge.gitlinks
             });
+            if (converge.reason === "submodule_commit_unavailable") {
+              LOG2.warn("Mesh", `[Refinery] Could NOT determine submodule gitlink divergence for node ${node.id} \u2014 a gitlink commit is missing from the local submodule object store (auto-converge could not run): ` + converge.gitlinks.filter((g) => g.action === "skipped_commit_unavailable").map((g) => `${g.path} (missing: ${(g.unavailable || []).join("+") || "unknown"}; base=${(g.baseCommit || "?").slice(0, 12)} branch=${(g.branchCommit || "?").slice(0, 12)})`).join(", "));
+            }
             recordMeshRefineStage(refineStages, "sync_base", "passed", syncStarted, {
               ahead: divergence.ahead,
               behind: divergence.behind,
@@ -80883,12 +81454,12 @@ ${mergeTreeErr?.stderr || ""}`;
             throw err;
           }
         } else {
-          (0, import_node_child_process12.execFileSync)("git", ["rebase", baseHead], { cwd: node.workspace, stdio: ["ignore", "pipe", "pipe"] });
+          (0, import_node_child_process14.execFileSync)("git", ["rebase", baseHead], { cwd: node.workspace, stdio: ["ignore", "pipe", "pipe"] });
         }
       } catch (rebaseErr) {
         if (!rebaseErr?.alreadyAborted) {
           try {
-            (0, import_node_child_process12.execFileSync)("git", ["rebase", "--abort"], { cwd: node.workspace, stdio: "ignore" });
+            (0, import_node_child_process14.execFileSync)("git", ["rebase", "--abort"], { cwd: node.workspace, stdio: "ignore" });
           } catch {
           }
         }
@@ -82342,7 +82913,7 @@ ${e?.stderr || ""}`;
         if (!repoRoot || !workspace) return;
         const branch = typeof node?.worktreeBranch === "string" && node.worktreeBranch.trim() ? node.worktreeBranch.trim() : (() => {
           try {
-            return (0, import_node_child_process12.execFileSync)("git", ["branch", "--show-current"], { cwd: workspace, encoding: "utf8" }).trim();
+            return (0, import_node_child_process14.execFileSync)("git", ["branch", "--show-current"], { cwd: workspace, encoding: "utf8" }).trim();
           } catch {
             return "";
           }
@@ -82350,7 +82921,7 @@ ${e?.stderr || ""}`;
         if (!branch) return;
         const baseBranch = (() => {
           try {
-            return (0, import_node_child_process12.execFileSync)("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" }).trim() || "main";
+            return (0, import_node_child_process14.execFileSync)("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" }).trim() || "main";
           } catch {
             return "main";
           }
@@ -82418,13 +82989,13 @@ ${e?.stderr || ""}`;
       });
       return handle;
     }
-    var import_node_child_process12;
+    var import_node_child_process14;
     var import_node_fs9;
     var RETRYABLE_BASE_MOVEMENT_CODES;
     var init_router_refine = __esm2({
       "src/commands/router-refine.ts"() {
         "use strict";
-        import_node_child_process12 = require("child_process");
+        import_node_child_process14 = require("child_process");
         import_node_fs9 = require("fs");
         init_logger();
         init_debug_trace();
@@ -82466,6 +83037,7 @@ ${e?.stderr || ""}`;
       CHAT_MESSAGE_TRANSCRIPT_VISIBILITIES: () => CHAT_MESSAGE_TRANSCRIPT_VISIBILITIES,
       CHAT_MESSAGE_VISIBILITIES: () => CHAT_MESSAGE_VISIBILITIES,
       COMPACT_STATUS_GOAL_PREVIEW_MAX: () => COMPACT_STATUS_GOAL_PREVIEW_MAX,
+      CTRL_C: () => CTRL_C,
       CdpDomHandlers: () => CdpDomHandlers,
       CliProviderInstance: () => CliProviderInstance,
       DAEMON_WS_PATH: () => DAEMON_WS_PATH2,
@@ -82475,6 +83047,7 @@ ${e?.stderr || ""}`;
       DEFAULT_CHAT_TAIL_MISSING_SESSION_POLICY: () => DEFAULT_CHAT_TAIL_MISSING_SESSION_POLICY,
       DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS: () => DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS2,
       DEFAULT_DAEMON_PORT: () => DEFAULT_DAEMON_PORT2,
+      DEFAULT_DELIVERY_MODE: () => DEFAULT_DELIVERY_MODE,
       DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS: () => DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS,
       DEFAULT_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS: () => DEFAULT_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS2,
       DEFAULT_MESH_POLICY: () => DEFAULT_MESH_POLICY,
@@ -82500,6 +83073,7 @@ ${e?.stderr || ""}`;
       DaemonStatusReporter: () => DaemonStatusReporter,
       DevServer: () => DevServer,
       DuplicateMeshDispatchError: () => DuplicateMeshDispatchError,
+      ESC: () => ESC,
       FsmDriver: () => FsmDriver,
       GOAL_PREVIEW_MAX: () => GOAL_PREVIEW_MAX,
       GitCommandError: () => GitCommandError,
@@ -82554,6 +83128,10 @@ ${e?.stderr || ""}`;
       OPERATING_NOTE_KIND: () => OPERATING_NOTE_KIND,
       OPERATING_NOTE_TOMBSTONE_KIND: () => OPERATING_NOTE_TOMBSTONE_KIND,
       P2pRelayFailureError: () => P2pRelayFailureError,
+      PARKED_SKIP_REASON: () => PARKED_SKIP_REASON,
+      PARKED_TASK_RETENTION_MS: () => PARKED_TASK_RETENTION_MS,
+      PARK_REASON_PIN_EXPIRED: () => PARK_REASON_PIN_EXPIRED,
+      PARK_RETENTION_EXPIRED_REASON: () => PARK_RETENTION_EXPIRED_REASON,
       PROVIDER_CHANNEL_ENV_VAR: () => PROVIDER_CHANNEL_ENV_VAR,
       PRUNABLE_ORPHAN_STALE_REASONS: () => PRUNABLE_ORPHAN_STALE_REASONS,
       ProviderChannelError: () => ProviderChannelError,
@@ -82567,6 +83145,7 @@ ${e?.stderr || ""}`;
       STALE_MAGI_WINDOW_MS: () => STALE_MAGI_WINDOW_MS,
       STALE_TERMINAL_REFINE_WINDOW_MS: () => STALE_TERMINAL_REFINE_WINDOW_MS,
       STANDALONE_CDP_SCAN_INTERVAL_MS: () => STANDALONE_CDP_SCAN_INTERVAL_MS2,
+      STOP_CONTROL_ID: () => STOP_CONTROL_ID,
       SYM: () => SYM,
       SessionHostPtyTransportFactory: () => SessionHostPtyTransportFactory2,
       StatuslineInstallError: () => StatuslineInstallError2,
@@ -82617,6 +83196,7 @@ ${e?.stderr || ""}`;
       buildMissionPromptSection: () => buildMissionPromptSection,
       buildOrphanedPinNotice: () => buildOrphanedPinNotice,
       buildP2pRelayFailurePayload: () => buildP2pRelayFailurePayload,
+      buildParkedTaskNotice: () => buildParkedTaskNotice,
       buildPinnedGlobalInstallCommand: () => buildPinnedGlobalInstallCommand,
       buildRuntimeSystemChatMessage: () => buildRuntimeSystemChatMessage,
       buildSessionEntries: () => buildSessionEntries,
@@ -82696,6 +83276,7 @@ ${e?.stderr || ""}`;
       evaluateProviderQuotaGate: () => evaluateProviderQuotaGate,
       execNpmCommandSync: () => execNpmCommandSync,
       expandDaemonIdForms: () => expandDaemonIdForms,
+      failRetentionExpiredParkedTask: () => failRetentionExpiredParkedTask,
       fastForwardMeshNode: () => fastForwardMeshNode,
       fetchAntigravityQuota: () => fetchAntigravityQuota2,
       fetchClaudeQuota: () => fetchClaudeQuota2,
@@ -82748,6 +83329,7 @@ ${e?.stderr || ""}`;
       getMeshStatusMissionSummaries: () => getMeshStatusMissionSummaries,
       getMeshStatusMissionsCompact: () => getMeshStatusMissionsCompact,
       getNpmExecOptions: () => getNpmExecOptions,
+      getParkedTasks: () => getParkedTasks,
       getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
       getProcessInstanceContext: () => getProcessInstanceContext,
       getQueue: () => getQueue,
@@ -82847,6 +83429,7 @@ ${e?.stderr || ""}`;
       normalizeChatMessageKind: () => normalizeChatMessageKind,
       normalizeChatMessages: () => normalizeChatMessages,
       normalizeChatTailActiveModal: () => normalizeChatTailActiveModal,
+      normalizeDeliveryMode: () => normalizeDeliveryMode,
       normalizeGitOutput: () => normalizeGitOutput,
       normalizeGitWorkspaceSubscriptionParams: () => normalizeGitWorkspaceSubscriptionParams2,
       normalizeInputEnvelope: () => normalizeInputEnvelope,
@@ -82867,7 +83450,11 @@ ${e?.stderr || ""}`;
       normalizeRepoMeshDeclarativeConfig: () => normalizeRepoMeshDeclarativeConfig,
       normalizeSessionModalFields: () => normalizeSessionModalFields,
       notifyCoordinatorOfOrphanedPins: () => notifyCoordinatorOfOrphanedPins,
+      notifyCoordinatorOfParkedTaskDropped: () => notifyCoordinatorOfParkedTaskDropped,
       otherTrackConfigDir: () => otherTrackConfigDir,
+      parkTaskTargetPin: () => parkTaskTargetPin,
+      parkedAgeMs: () => parkedAgeMs,
+      parkedTaskRetentionExpired: () => parkedTaskRetentionExpired,
       parseOnDependencyFailurePolicy: () => parseOnDependencyFailurePolicy,
       parsePorcelainV2Status: () => parsePorcelainV2Status,
       parseProviderSourceConfigUpdate: () => parseProviderSourceConfigUpdate,
@@ -82951,6 +83538,7 @@ ${e?.stderr || ""}`;
       resolveGitRepository: () => resolveGitRepository,
       resolveInstanceContext: () => resolveInstanceContext,
       resolveInstanceDir: () => resolveInstanceDir,
+      resolveInterruptCapability: () => resolveInterruptCapability,
       resolveMagiSessionCleanupMode: () => resolveMagiSessionCleanupMode,
       resolveMaxParallelTasks: () => resolveMaxParallelTasks,
       resolveMeshHostStatus: () => resolveMeshHostStatus,
@@ -83008,6 +83596,7 @@ ${e?.stderr || ""}`;
       supportsUnicodeSymbols: () => supportsUnicodeSymbols,
       sweepMeshGraphGateTimeouts: () => sweepMeshGraphGateTimeouts,
       taskDependenciesSatisfied: () => taskDependenciesSatisfied,
+      taskIsParked: () => taskIsParked,
       tombstoneOperatingNote: () => tombstoneOperatingNote,
       totalTokens: () => totalTokens,
       triggerMeshQueue: () => triggerMeshQueue,
@@ -85505,6 +86094,8 @@ ${e?.stderr || ""}`;
       };
     }
     init_mesh_work_queue();
+    init_mesh_work_queue();
+    init_mesh_task_parking();
     init_mesh_graph_derived_failure();
     init_mesh_graph_workspace_saga();
     init_mesh_graph_workspace_safety();
@@ -86104,6 +86695,12 @@ ${e?.stderr || ""}`;
               workspaceRef: ws.workspaceRef,
               detail: `Workspace '${ws.workspaceRef}' needs manual compensation: ${ws.lastError ?? "compensation refused"}.`
             });
+          } else if (ws.sagaState === "declared" && !ws.baseRevision) {
+            actions.push({
+              kind: "workspace_declared_no_base",
+              workspaceRef: ws.workspaceRef,
+              detail: `Workspace '${ws.workspaceRef}' is stuck in 'declared': no base_revision was given and none could be derived from ${ws.sourceNodeId ? `source node '${ws.sourceNodeId}' (its repo is unreachable on this daemon, or git could not resolve its HEAD)` : "a source node, because the declaration named none"}. The workspace will never clone and every task bound to it stays blocked. Re-declare the workspace with an explicit base_revision (e.g. 'main')${ws.sourceNodeId ? "" : " and a source_node_id"}.`
+            });
           }
         }
         return {
@@ -86270,6 +86867,47 @@ The pin is NOT cleared automatically: a pin often encodes required context conti
     init_contracts();
     init_mesh_events_utils();
     init_mesh_delivery_policy();
+    var CTRL_C = "";
+    var ESC = "\x1B";
+    var STOP_CONTROL_ID = "stop";
+    var LIVE_VERIFIED_PROVIDERS = /* @__PURE__ */ new Set(["claude-cli"]);
+    function nameForKeys(keys) {
+      if (keys === CTRL_C) return "Ctrl-C";
+      if (keys === ESC) return "ESC";
+      return "custom";
+    }
+    function resolveInterruptCapability(providerType, controlBar) {
+      const stop = (controlBar ?? []).find((c) => c.id === STOP_CONTROL_ID);
+      if (!stop) {
+        return {
+          supported: false,
+          reason: "no_stop_control",
+          message: `Provider '${providerType}' declares no '${STOP_CONTROL_ID}' control, so a running turn cannot be interrupted. Dispatch with delivery mode when_idle and the task will be delivered once the session finishes on its own.`
+        };
+      }
+      if (stop.action?.type !== "send_keys") {
+        return {
+          supported: false,
+          reason: "stop_control_not_send_keys",
+          message: `Provider '${providerType}' declares a '${STOP_CONTROL_ID}' control of type '${stop.action?.type}', not a key write, so it cannot be used to abort a turn. Dispatch with delivery mode when_idle instead.`
+        };
+      }
+      const keys = stop.action.keys;
+      if (typeof keys !== "string" || keys.length === 0) {
+        return {
+          supported: false,
+          reason: "stop_keys_empty",
+          message: `Provider '${providerType}' declares a '${STOP_CONTROL_ID}' control with an EMPTY key sequence, so pressing it would write nothing to the terminal while still reporting success. Treating this as unsupported rather than silently doing nothing. Dispatch with delivery mode when_idle, or fix the provider spec to declare a real stop key.`
+        };
+      }
+      return {
+        supported: true,
+        keys,
+        keyName: nameForKeys(keys),
+        confidence: LIVE_VERIFIED_PROVIDERS.has(providerType) ? "proven" : "declared",
+        ...stop.visible_when_state ? { visibleWhenState: stop.visible_when_state } : {}
+      };
+    }
     var NO_FALLBACK_REASON = "This mesh operation needs a live peer-to-peer connection to the node, which is not open right now. This is often transient \u2014 the peer may be connecting, slow via TURN relay, or briefly offline. Wait a moment and retry, or re-establish the node's connection. Mesh commands use P2P only by design \u2014 there is no cloud/WS relay fallback.";
     var P2P_NEXT_ACTION = "The peer connection is recoverable. Wait a moment for the connection to establish (especially over TURN relay), then retry. If the node remains unreachable, check that the target daemon is running and online, then re-establish its connection.";
     var NON_P2P_NEXT_ACTION = "Inspect the provider/command error and fix the underlying logic or configuration before retrying.";
@@ -94681,7 +95319,7 @@ ${effect.notification.body || ""}`.trim();
         if (!["cli", "ide", "extension", "acp"].includes(category)) {
           return { success: false, error: `unknown category: ${category}` };
         }
-        const fs59 = require("fs");
+        const fs61 = require("fs");
         const path58 = require("path");
         try {
           const installRoot = this.getUpstreamInstallRoot();
@@ -94690,10 +95328,10 @@ ${effect.notification.body || ""}`.trim();
           if (!targetDir.startsWith(installRootResolved + path58.sep)) {
             return { success: false, error: "refusing to delete outside upstream root" };
           }
-          if (!fs59.existsSync(targetDir)) {
+          if (!fs61.existsSync(targetDir)) {
             return { success: false, error: "not installed" };
           }
-          fs59.rmSync(targetDir, { recursive: true, force: true });
+          fs61.rmSync(targetDir, { recursive: true, force: true });
           try {
             this._ctx.providerLoader?.deactivateVerifiedChannel?.(type2);
           } catch {
@@ -94713,28 +95351,28 @@ ${effect.notification.body || ""}`.trim();
        * the UI and by the update checker.
        */
       handleListInstalledProviders(_args) {
-        const fs59 = require("fs");
+        const fs61 = require("fs");
         const path58 = require("path");
         const installRoot = this.getUpstreamInstallRoot();
-        if (!fs59.existsSync(installRoot)) return { success: true, providers: [] };
+        if (!fs61.existsSync(installRoot)) return { success: true, providers: [] };
         const CATEGORIES = ["cli", "ide", "extension", "acp"];
         const items = [];
         for (const category of CATEGORIES) {
           const categoryDir = path58.join(installRoot, category);
-          if (!fs59.existsSync(categoryDir)) continue;
+          if (!fs61.existsSync(categoryDir)) continue;
           let entries;
           try {
-            entries = fs59.readdirSync(categoryDir);
+            entries = fs61.readdirSync(categoryDir);
           } catch {
             continue;
           }
           for (const type2 of entries) {
             const v1Path = path58.join(categoryDir, type2, "provider.v1.json");
             const v0Path = path58.join(categoryDir, type2, "provider.json");
-            const manifestPath = fs59.existsSync(v1Path) ? v1Path : fs59.existsSync(v0Path) ? v0Path : null;
+            const manifestPath = fs61.existsSync(v1Path) ? v1Path : fs61.existsSync(v0Path) ? v0Path : null;
             if (!manifestPath) continue;
             try {
-              const m = JSON.parse(fs59.readFileSync(manifestPath, "utf-8"));
+              const m = JSON.parse(fs61.readFileSync(manifestPath, "utf-8"));
               const modelOptions = Array.isArray(m.modelOptions) ? m.modelOptions.filter((x) => typeof x === "string" && !!x.trim()) : [];
               const thinkingLevelOptions = Array.isArray(m.thinkingLevelOptions) ? m.thinkingLevelOptions.filter((x) => typeof x === "string" && !!x.trim()) : [];
               items.push({
@@ -94955,7 +95593,7 @@ ${effect.notification.body || ""}`.trim();
         if (!/^@[a-z0-9_-]+$/i.test(requestedName)) {
           return { success: false, error: "name must match @[a-z0-9_-]+" };
         }
-        const fs59 = require("fs");
+        const fs61 = require("fs");
         const path58 = require("path");
         const { spawnSync: spawnSync3 } = require("child_process");
         const file2 = ext.loadExternalSources();
@@ -94966,8 +95604,8 @@ ${effect.notification.body || ""}`.trim();
           return { success: false, error: `source url+ref already registered (use a different name to track another ref)` };
         }
         const sourceDir = path58.join(ext.externalRoot(), requestedName);
-        if (!fs59.existsSync(ext.externalRoot())) fs59.mkdirSync(ext.externalRoot(), { recursive: true });
-        if (fs59.existsSync(sourceDir)) {
+        if (!fs61.existsSync(ext.externalRoot())) fs61.mkdirSync(ext.externalRoot(), { recursive: true });
+        if (fs61.existsSync(sourceDir)) {
           return { success: false, error: `directory already exists: ${sourceDir} (rename or remove first)` };
         }
         const clone2 = spawnSync3("git", ["clone", "--depth=1", "--branch", ref, "--", url2, sourceDir], {
@@ -94977,7 +95615,7 @@ ${effect.notification.body || ""}`.trim();
         });
         if (clone2.status !== 0) {
           try {
-            fs59.rmSync(sourceDir, { recursive: true, force: true });
+            fs61.rmSync(sourceDir, { recursive: true, force: true });
           } catch {
           }
           return { success: false, error: `git clone failed: ${(clone2.stderr || clone2.stdout || "").trim() || "unknown error"}` };
@@ -95021,15 +95659,15 @@ ${effect.notification.body || ""}`.trim();
         const name = typeof args?.name === "string" ? args.name.trim() : "";
         if (!name) return { success: false, error: "name is required" };
         const ext = (init_external_sources(), __toCommonJS2(external_sources_exports));
-        const fs59 = require("fs");
+        const fs61 = require("fs");
         const path58 = require("path");
         const file2 = ext.loadExternalSources();
         const match = file2.sources.find((s2) => s2.name === name);
         if (!match) return { success: false, error: `source "${name}" not registered` };
         const sourceDir = path58.join(ext.externalRoot(), name);
-        if (fs59.existsSync(sourceDir)) {
+        if (fs61.existsSync(sourceDir)) {
           try {
-            fs59.rmSync(sourceDir, { recursive: true, force: true });
+            fs61.rmSync(sourceDir, { recursive: true, force: true });
           } catch (e) {
             return { success: false, error: `failed to delete ${sourceDir}: ${e?.message || e}` };
           }
@@ -97356,14 +97994,14 @@ ${marker}`,
         }
       },
       list_coordinator_prompts: async (_ctx, _args) => {
-        const fs59 = await import("fs");
+        const fs61 = await import("fs");
         const path58 = await import("path");
         const { getConfigDir: getConfigDir22 } = await Promise.resolve().then(() => (init_config(), config_exports));
         const dir = path58.join(getConfigDir22(), "coordinator-prompts");
         const entries = {};
         try {
-          if (fs59.existsSync(dir)) {
-            for (const name of fs59.readdirSync(dir)) {
+          if (fs61.existsSync(dir)) {
+            for (const name of fs61.readdirSync(dir)) {
               const matchOverride = name.match(/^([a-zA-Z0-9_.-]+)\.md$/);
               const matchAppend = name.match(/^([a-zA-Z0-9_.-]+)\.append\.md$/);
               const m = matchAppend || matchOverride;
@@ -97373,7 +98011,7 @@ ${marker}`,
               const full = path58.join(dir, name);
               let content = "";
               try {
-                content = fs59.readFileSync(full, "utf8");
+                content = fs61.readFileSync(full, "utf8");
               } catch {
               }
               if (!entries[key2]) entries[key2] = { override: "", append: "" };
@@ -97387,7 +98025,7 @@ ${marker}`,
         return { success: true, dir, entries };
       },
       write_coordinator_prompt: async (_ctx, args) => {
-        const fs59 = await import("fs");
+        const fs61 = await import("fs");
         const path58 = await import("path");
         const { getConfigDir: getConfigDir22 } = await Promise.resolve().then(() => (init_config(), config_exports));
         const key2 = typeof args?.key === "string" ? args.key.trim() : "";
@@ -97400,11 +98038,11 @@ ${marker}`,
         const filename = kind === "append" ? `${key2}.append.md` : `${key2}.md`;
         const full = path58.join(dir, filename);
         try {
-          fs59.mkdirSync(dir, { recursive: true });
+          fs61.mkdirSync(dir, { recursive: true });
           if (content.trim()) {
-            fs59.writeFileSync(full, content, { encoding: "utf8", mode: 384 });
-          } else if (fs59.existsSync(full)) {
-            fs59.unlinkSync(full);
+            fs61.writeFileSync(full, content, { encoding: "utf8", mode: 384 });
+          } else if (fs61.existsSync(full)) {
+            fs61.unlinkSync(full);
           }
           return { success: true, path: full, kind, key: key2 };
         } catch (error48) {
@@ -102077,6 +102715,52 @@ ${marker}`,
           hash: hash2
         };
       }
+      /**
+       * Report whether this provider can have its in-flight turn interrupted,
+       * resolved from the spec THIS session actually loaded (never a hardcoded
+       * per-provider table — the stop key varies by spec version; hermes-cli
+       * ships Ctrl-C in specs/0.14.json and an EMPTY key in specs/4.0.json).
+       */
+      getInterruptCapability() {
+        return resolveInterruptCapability(this.cliType, this.spec.control_bar);
+      }
+      /**
+       * Abort the turn currently in flight by writing the provider's own stop
+       * key to the PTY. Used by delivery mode 'interrupt': the caller then waits
+       * for the FSM to report idle and lets the ordinary queued-send drain
+       * deliver the new prompt as a genuine new turn.
+       *
+       * ★ Deliberately NOT routed through invokeScript('stop'). That path calls
+       * FsmDriver.handleClickControl, which silently returns when the control's
+       * `visible_when_state` does not include the current state, and calls
+       * send_keys("") for a provider whose stop key is empty — while
+       * invokeScript unconditionally returns `{ ok: true, effects:[sent_keys] }`
+       * either way. Reporting a successful interrupt that wrote nothing is
+       * exactly the failure this feature exists to remove, so capability is
+       * validated HERE, before any write, and the outcome is reported honestly.
+       */
+      async interruptTurn() {
+        if (!this.spawned || this.exited) {
+          return { ok: false, reason: "not_running", message: `${this.cliName} is not running.` };
+        }
+        const cap = this.getInterruptCapability();
+        if (!cap.supported) {
+          LOG2.warn("SpecAdapter", `[${this.cliType}] interrupt refused: ${cap.reason}`);
+          return { ok: false, reason: cap.reason, message: cap.message };
+        }
+        const status = this.latestState?.status;
+        if (status !== "generating") {
+          return {
+            ok: false,
+            reason: "not_busy",
+            message: `Session is '${status ?? "unknown"}', not generating \u2014 nothing to interrupt.`
+          };
+        }
+        this.driver.dispatch({ kind: "pty_write", data: cap.keys });
+        const bytes = Buffer.byteLength(cap.keys, "utf8");
+        LOG2.info("SpecAdapter", `[${this.cliType}] turn interrupted via ${cap.keyName} (bytes=${bytes}, confidence=${cap.confidence})`);
+        return { ok: true, keyName: cap.keyName, bytes, confidence: cap.confidence };
+      }
       /**
        * MESH-SEND-KEYS (feature 3: key injection). Inject a STRUCTURED key
        * sequence into the spec-driven PTY for mesh_send_keys. Mirrors
@@ -110692,6 +111376,39 @@ Run 'adhdev doctor' for detailed diagnostics.`
             } else if (action === "stop") {
               await this.stopSession(key2);
               return { success: true, stopped: true };
+            } else if (action === "interrupt_capability") {
+              const probe = adapter;
+              if (typeof probe.getInterruptCapability !== "function") {
+                return {
+                  success: true,
+                  supported: false,
+                  reason: "interrupt_not_implemented",
+                  message: `Provider '${agentType}' runs on an adapter with no interrupt support.`
+                };
+              }
+              const cap = probe.getInterruptCapability();
+              return { success: true, ...cap };
+            } else if (action === "interrupt_turn") {
+              const interruptible = adapter;
+              if (typeof interruptible.interruptTurn !== "function") {
+                return {
+                  success: false,
+                  interrupted: false,
+                  reason: "interrupt_not_implemented",
+                  error: `Provider '${agentType}' runs on an adapter that cannot interrupt a turn.`
+                };
+              }
+              const outcome = await interruptible.interruptTurn();
+              if (!outcome.ok) {
+                return { success: false, interrupted: false, reason: outcome.reason, error: outcome.message };
+              }
+              return {
+                success: true,
+                interrupted: true,
+                keyName: outcome.keyName,
+                bytes: outcome.bytes,
+                confidence: outcome.confidence
+              };
             }
             throw new Error(`Unknown action: ${action}`);
           }
@@ -110854,7 +111571,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
             const { shouldDeferDispatchForBootstrap: shouldDeferDispatchForBootstrap2 } = await Promise.resolve().then(() => (init_worktree_bootstrap_config(), worktree_bootstrap_config_exports));
             if (shouldDeferDispatchForBootstrap2(nodeObj)) {
               const dispatchSessionState = dispatchSessionId ? ctx.deps.instanceManager?.getInstance?.(dispatchSessionId)?.getState?.() : void 0;
-              const sessionConfirmedReady = !!dispatchSessionState && isIdleSessionState2(dispatchSessionState);
+              const sessionConfirmedReady = !!dispatchSessionState && isIdleSessionState3(dispatchSessionState);
               if (!sessionConfirmedReady) {
                 return {
                   success: false,
@@ -115553,7 +116270,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
         if (providerDir) {
           try {
-            const fs59 = require("fs");
+            const fs61 = require("fs");
             const path58 = require("path");
             const candidates = [];
             if (Array.isArray(base.compatibility)) {
@@ -115565,13 +116282,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
             }
             candidates.push(path58.join(providerDir, "specs", "default.json"));
             candidates.push(path58.join(providerDir, "spec.json"));
-            const specPath = candidates.find((p) => fs59.existsSync(p));
+            const specPath = candidates.find((p) => fs61.existsSync(p));
             let nh;
             if (specPath) {
               resolved._resolvedSpecPath = specPath;
               let specControls;
               try {
-                const rawSpec = JSON.parse(fs59.readFileSync(specPath, "utf8"));
+                const rawSpec = JSON.parse(fs61.readFileSync(specPath, "utf8"));
                 specControls = rawSpec.control_bar;
                 nh = rawSpec.native_history;
               } catch {
@@ -115614,7 +116331,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 }
               } else if (nh.override_path) {
                 const overrideFile = path58.resolve(providerDir, nh.override_path);
-                if (fs59.existsSync(overrideFile)) {
+                if (fs61.existsSync(overrideFile)) {
                   try {
                     registerProviderScriptRootSafely(path58.dirname(path58.dirname(providerDir)));
                     delete require.cache[require.resolve(overrideFile)];
@@ -116531,7 +117248,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         }
       } else if (plat === "win32") {
         try {
-          const fs59 = require("fs");
+          const fs61 = require("fs");
           const appNameMap = getMacAppIdentifiers();
           const appName = appNameMap[ideId];
           if (appName) {
@@ -116540,8 +117257,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
               appName,
               "storage.json"
             );
-            if (fs59.existsSync(storagePath)) {
-              const data = JSON.parse(fs59.readFileSync(storagePath, "utf-8"));
+            if (fs61.existsSync(storagePath)) {
+              const data = JSON.parse(fs61.readFileSync(storagePath, "utf-8"));
               const workspaces = data?.openedPathsList?.workspaces3 || data?.openedPathsList?.entries || [];
               if (workspaces.length > 0) {
                 const recent = workspaces[0];
@@ -117231,7 +117948,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             normalizeRepoMeshDeclarativeConfig: normalizeRepoMeshDeclarativeConfig2,
             MESH_JSON_CONFIG_LOCATIONS: MESH_JSON_CONFIG_LOCATIONS2
           } = await Promise.resolve().then(() => (init_mesh_json_config(), mesh_json_config_exports));
-          const { existsSync: existsSync67, readFileSync: readFileSync55, mkdirSync: mkdirSync31, writeFileSync: writeFileSync31 } = await import("fs");
+          const { existsSync: existsSync69, readFileSync: readFileSync55, mkdirSync: mkdirSync31, writeFileSync: writeFileSync31 } = await import("fs");
           const { dirname: dirname24, join: join67 } = await import("path");
           const yaml6 = await Promise.resolve().then(() => (init_js_yaml(), js_yaml_exports));
           const relativePath = MESH_JSON_CONFIG_LOCATIONS2[0];
@@ -117240,7 +117957,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           let existedAsYaml = false;
           for (const relative8 of MESH_JSON_CONFIG_LOCATIONS2) {
             const candidate = join67(workspace, relative8);
-            if (!existsSync67(candidate)) continue;
+            if (!existsSync69(candidate)) continue;
             try {
               const text = readFileSync55(candidate, "utf-8");
               const parsed = /\.json$/i.test(candidate) ? JSON.parse(text) : yaml6.load(text);
@@ -118475,7 +119192,12 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             // CANON-IDENTITY: an in-flight (actively-generating) task is refused by
             // default to avoid a duplicate second dispatch; an explicit operator
             // force overrides that guard (and the retry cap).
-            force: args?.force === true
+            force: args?.force === true,
+            // PIN-PARKING (edit): optional instruction rewrite, so a coordinator in
+            // IPC/cloud mode has the same exit from parking as the in-process path.
+            // Without this the field would be silently dropped exactly where the
+            // multi-coordinator topology needs it most.
+            message: typeof args?.message === "string" ? args.message : void 0
           });
           if (!task) return { success: false, error: `Queue task '${taskId}' not found` };
           if (task.status === "assigned" && args?.force !== true) {
@@ -119549,7 +120271,7 @@ ${ptyResult.output.slice(-2e3)}`);
               workspace
             };
           }
-          const { existsSync: existsSync67, readFileSync: readFileSync55, writeFileSync: writeFileSync31, copyFileSync: copyFileSync3, mkdirSync: mkdirSync31 } = await import("fs");
+          const { existsSync: existsSync69, readFileSync: readFileSync55, writeFileSync: writeFileSync31, copyFileSync: copyFileSync3, mkdirSync: mkdirSync31 } = await import("fs");
           const { dirname: dirname24 } = await import("path");
           const mcpConfigPath = coordinatorSetup.configPath;
           const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
@@ -119594,7 +120316,7 @@ ${ptyResult.output.slice(-2e3)}`);
             if (hermesManualFallback) return returnManualFallback(message);
             return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
           }
-          const hadExistingMcpConfig = existsSync67(mcpConfigPath);
+          const hadExistingMcpConfig = existsSync69(mcpConfigPath);
           let existingMcpConfig = hermesBaseConfig?.config || {};
           if (hermesBaseConfig) {
             copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname24(mcpConfigPath));
@@ -120395,7 +121117,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const { deriveMeshReviewInboxItems: deriveMeshReviewInboxItems2 } = await Promise.resolve().then(() => (init_mesh_review_inbox(), mesh_review_inbox_exports));
           const { readLedgerEntries: readLedgerEntries2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
           const { getGitDiffSummary: getGitDiffSummary2 } = await Promise.resolve().then(() => (init_git_diff(), git_diff_exports));
-          const { existsSync: existsSync67 } = await import("fs");
+          const { existsSync: existsSync69 } = await import("fs");
           const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
           const mesh = meshRecord?.mesh;
           if (!mesh) return { success: false, error: "Mesh not found" };
@@ -120414,7 +121136,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const derivation = deriveMeshReviewInboxItems2({ nodes: nodeStatuses, ledgerEntries });
           for (const item of derivation.items) {
             const workspace = item.workspace;
-            if (!workspace || !existsSync67(workspace)) continue;
+            if (!workspace || !existsSync69(workspace)) continue;
             const baseRef = item.defaultBranch ? `origin/${item.defaultBranch}` : "origin/main";
             try {
               const diffResult = await getGitDiffSummary2(workspace, { baseRef, maxFiles: 100 });
@@ -120609,12 +121331,12 @@ ${ptyResult.output.slice(-2e3)}`);
     }
     init_debug_trace();
     init_mesh_host_ownership();
-    var fs51 = __toESM2(require("fs"));
+    var fs53 = __toESM2(require("fs"));
     init_mesh_node_identity();
     init_router_refine();
-    var fs49 = __toESM2(require("fs"));
+    var fs51 = __toESM2(require("fs"));
     var import_node_os2 = require("os");
-    var import_path18 = require("path");
+    var import_path19 = require("path");
     init_logger();
     init_git_locale();
     init_dist();
@@ -120626,7 +121348,7 @@ ${ptyResult.output.slice(-2e3)}`);
     function acceptableManagedWorktreePaths(resolveWorktreePath2, normalizePath2, repoRoot, meshName, branch, worktreeBaseDir) {
       const safeBranch = branch.replace(/[/\\:*?"<>|]/g, "-").replace(/^\.+|\.+$/g, "");
       const safeMeshName = meshName.replace(/[/\\:*?"<>|]/g, "-").replace(/^\.+|\.+$/g, "");
-      const legacyPath = (0, import_path18.join)((0, import_path18.dirname)(repoRoot), LEGACY_WORKTREE_DIR_NAME, safeMeshName, safeBranch);
+      const legacyPath = (0, import_path19.join)((0, import_path19.dirname)(repoRoot), LEGACY_WORKTREE_DIR_NAME, safeMeshName, safeBranch);
       const candidates = [
         resolveWorktreePath2(repoRoot, meshName, branch, worktreeBaseDir),
         legacyPath
@@ -120650,8 +121372,8 @@ ${ptyResult.output.slice(-2e3)}`);
     function looksLikeCrossTrackWorktreePath(actualPath, normalizePath2) {
       const home = normalizePath2((0, import_node_os2.homedir)());
       return TRACK_CONFIG_DIR_NAMES.some((trackDirName) => {
-        const trackWorktreesDir = (0, import_path18.join)(home, trackDirName, "worktrees");
-        return actualPath === normalizePath2(trackWorktreesDir) || actualPath.startsWith(normalizePath2(trackWorktreesDir) + import_path18.sep);
+        const trackWorktreesDir = (0, import_path19.join)(home, trackDirName, "worktrees");
+        return actualPath === normalizePath2(trackWorktreesDir) || actualPath.startsWith(normalizePath2(trackWorktreesDir) + import_path19.sep);
       });
     }
     function unexpectedPathRecoveryHint(actualPath, normalizePath2, suffix) {
@@ -120709,14 +121431,14 @@ ${ptyResult.output.slice(-2e3)}`);
       return false;
     }
     async function bestEffortRemoveWorktreeDir(self, dir) {
-      if (!dir || !fs49.existsSync(dir)) return { removed: true, residue: false };
+      if (!dir || !fs51.existsSync(dir)) return { removed: true, residue: false };
       const sleep3 = (ms) => new Promise((resolve30) => setTimeout(resolve30, ms));
       const ABSORB = /* @__PURE__ */ new Set(["EINVAL", "EPERM", "EBUSY", "ENOTEMPTY", "EACCES", "EMFILE", "ENFILE"]);
       let lastErr;
       for (let attempt = 0; attempt < 4; attempt++) {
         try {
-          fs49.rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-          if (!fs49.existsSync(dir)) return { removed: true, residue: false };
+          fs51.rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+          if (!fs51.existsSync(dir)) return { removed: true, residue: false };
           lastErr = new Error("directory still present after rmSync");
         } catch (e) {
           lastErr = e;
@@ -120727,7 +121449,7 @@ ${ptyResult.output.slice(-2e3)}`);
         }
         await sleep3(150 * (attempt + 1));
       }
-      return fs49.existsSync(dir) ? { removed: false, residue: true, error: String(lastErr?.message || lastErr || "unknown rm error") } : { removed: true, residue: false };
+      return fs51.existsSync(dir) ? { removed: false, residue: true, error: String(lastErr?.message || lastErr || "unknown rm error") } : { removed: true, residue: false };
     }
     async function precheckLocalWorktreeRemovable(self, args) {
       const sessionPreservedNote = " The delegated session was left running (not stopped) \u2014 resolve the issue and retry mesh_remove_node.";
@@ -120740,10 +121462,10 @@ ${ptyResult.output.slice(-2e3)}`);
           recoveryHint: "Inspect the mesh node record before removing it, or remove stale metadata manually only after confirming no managed worktree remains." + sessionPreservedNote
         };
       }
-      if (!fs49.existsSync(workspace)) return { ok: true };
+      if (!fs51.existsSync(workspace)) return { ok: true };
       const sourceNode = args.node?.clonedFromNodeId ? args.mesh?.nodes?.find((n) => meshNodeIdMatches(n, args.node.clonedFromNodeId)) : args.mesh?.nodes?.find((n) => !n.isLocalWorktree);
       const repoRoot = typeof sourceNode?.repoRoot === "string" && sourceNode.repoRoot.trim() ? sourceNode.repoRoot.trim() : typeof sourceNode?.workspace === "string" && sourceNode.workspace.trim() ? sourceNode.workspace.trim() : "";
-      if (!repoRoot || !fs49.existsSync(repoRoot)) {
+      if (!repoRoot || !fs51.existsSync(repoRoot)) {
         return {
           ok: false,
           code: "mesh_worktree_cleanup_missing_source_repo",
@@ -120761,9 +121483,9 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
       const normalizePath2 = (value) => {
-        const resolved = (0, import_path18.resolve)(value);
+        const resolved = (0, import_path19.resolve)(value);
         try {
-          return fs49.realpathSync(resolved);
+          return fs51.realpathSync(resolved);
         } catch {
           return resolved;
         }
@@ -120864,13 +121586,13 @@ ${ptyResult.output.slice(-2e3)}`);
           recoveryHint: "Inspect the mesh node record before removing it, or remove stale metadata manually only after confirming no managed worktree remains."
         };
       }
-      const worktreeExists = fs49.existsSync(workspace);
+      const worktreeExists = fs51.existsSync(workspace);
       const sourceNode = args.node?.clonedFromNodeId ? args.mesh?.nodes?.find((n) => meshNodeIdMatches(n, args.node.clonedFromNodeId)) : args.mesh?.nodes?.find((n) => !n.isLocalWorktree);
       const repoRoot = typeof sourceNode?.repoRoot === "string" && sourceNode.repoRoot.trim() ? sourceNode.repoRoot.trim() : typeof sourceNode?.workspace === "string" && sourceNode.workspace.trim() ? sourceNode.workspace.trim() : "";
       if (!worktreeExists) {
         return { success: true, skipped: true, removedPath: workspace, repoRoot: repoRoot || void 0, reason: "worktree_path_missing" };
       }
-      if (!repoRoot || !fs49.existsSync(repoRoot)) {
+      if (!repoRoot || !fs51.existsSync(repoRoot)) {
         return {
           success: false,
           code: "mesh_worktree_cleanup_missing_source_repo",
@@ -120888,9 +121610,9 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2, removeWorktree: removeWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
       const normalizePath2 = (value) => {
-        const resolved = (0, import_path18.resolve)(value);
+        const resolved = (0, import_path19.resolve)(value);
         try {
-          return fs49.realpathSync(resolved);
+          return fs51.realpathSync(resolved);
         } catch {
           return resolved;
         }
@@ -121537,8 +122259,8 @@ ${ptyResult.output.slice(-2e3)}`);
     init_logger();
     var yaml5 = __toESM2(require_js_yaml());
     var import_os5 = require("os");
-    var import_path19 = require("path");
-    var fs50 = __toESM2(require("fs"));
+    var import_path20 = require("path");
+    var fs52 = __toESM2(require("fs"));
     var MESH_COORDINATOR_AUTO_IMPORT_FORMATS = ["claude_mcp_json", "hermes_config_yaml", "opencode_json"];
     function isSupportedMeshCoordinatorConfigFormat(format) {
       return MESH_COORDINATOR_AUTO_IMPORT_FORMATS.includes(format);
@@ -121578,14 +122300,14 @@ ${ptyResult.output.slice(-2e3)}`);
     }
     function resolveHermesUserHome() {
       const explicitHome = process.env.HERMES_HOME?.trim();
-      return explicitHome || (0, import_path19.join)((0, import_os5.homedir)(), ".hermes");
+      return explicitHome || (0, import_path20.join)((0, import_os5.homedir)(), ".hermes");
     }
     function loadHermesCoordinatorBaseConfig(targetConfigPath) {
       const sourceHome = resolveHermesUserHome();
-      const sourceConfigPath = (0, import_path19.join)(sourceHome, "config.yaml");
-      if (!fs50.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-      if ((0, import_path19.resolve)(sourceConfigPath) === (0, import_path19.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-      const parsed = parseMeshCoordinatorMcpConfig(fs50.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
+      const sourceConfigPath = (0, import_path20.join)(sourceHome, "config.yaml");
+      if (!fs52.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+      if ((0, import_path20.resolve)(sourceConfigPath) === (0, import_path20.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+      const parsed = parseMeshCoordinatorMcpConfig(fs52.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
       const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
       return { config: baseConfig, sourceHome, sourceConfigPath };
     }
@@ -121618,13 +122340,13 @@ ${ptyResult.output.slice(-2e3)}`);
       return sanitized;
     }
     function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
-      if ((0, import_path19.resolve)(sourceHome) === (0, import_path19.resolve)(targetHome)) return;
+      if ((0, import_path20.resolve)(sourceHome) === (0, import_path20.resolve)(targetHome)) return;
       for (const fileName of [".env", "auth.json"]) {
-        const sourcePath = (0, import_path19.join)(sourceHome, fileName);
-        const targetPath = (0, import_path19.join)(targetHome, fileName);
-        if (!fs50.existsSync(sourcePath)) continue;
+        const sourcePath = (0, import_path20.join)(sourceHome, fileName);
+        const targetPath = (0, import_path20.join)(targetHome, fileName);
+        if (!fs52.existsSync(sourcePath)) continue;
         try {
-          fs50.copyFileSync(sourcePath, targetPath);
+          fs52.copyFileSync(sourcePath, targetPath);
         } catch (error48) {
           LOG2.warn("MeshCoordinator", `Could not copy Hermes ${fileName} into isolated coordinator home: ${error48?.message || error48}`);
         }
@@ -122139,7 +122861,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const nodeId = readInlineMeshNodeId(node);
           if (!nodeId || !tombstones.has(nodeId)) return true;
           const workspace = readStringValue(node?.workspace);
-          if (workspace && fs51.existsSync(workspace)) {
+          if (workspace && fs53.existsSync(workspace)) {
             tombstones.delete(nodeId);
             return true;
           }
@@ -124199,7 +124921,7 @@ ${ptyResult.output.slice(-2e3)}`);
     };
     init_io_contracts();
     init_chat_message_normalization();
-    var fs52 = __toESM2(require("fs"));
+    var fs54 = __toESM2(require("fs"));
     var path522 = __toESM2(require("path"));
     var os28 = __toESM2(require("os"));
     var import_os6 = require("os");
@@ -124216,8 +124938,8 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       load() {
         try {
-          if (fs52.existsSync(getArchivePath2())) {
-            this.history = JSON.parse(fs52.readFileSync(getArchivePath2(), "utf-8"));
+          if (fs54.existsSync(getArchivePath2())) {
+            this.history = JSON.parse(fs54.readFileSync(getArchivePath2(), "utf-8"));
           }
         } catch {
           this.history = {};
@@ -124254,8 +124976,8 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       save() {
         try {
-          fs52.mkdirSync(path522.dirname(getArchivePath2()), { recursive: true });
-          fs52.writeFileSync(getArchivePath2(), JSON.stringify(this.history, null, 2));
+          fs54.mkdirSync(path522.dirname(getArchivePath2()), { recursive: true });
+          fs54.writeFileSync(getArchivePath2(), JSON.stringify(this.history, null, 2));
         } catch {
         }
       }
@@ -124280,8 +125002,8 @@ ${ptyResult.output.slice(-2e3)}`);
         for (const ext of exes) {
           const fullPath = path522.join(p, name + ext);
           try {
-            if (fs52.existsSync(fullPath)) {
-              const stat2 = fs52.statSync(fullPath);
+            if (fs54.existsSync(fullPath)) {
+              const stat2 = fs54.statSync(fullPath);
               if (stat2.isFile() && (isWin || stat2.mode & 73)) {
                 return fullPath;
               }
@@ -124328,9 +125050,9 @@ ${ptyResult.output.slice(-2e3)}`);
         if (p.includes("*")) {
           const home = os28.homedir();
           const resolved = p.replace(/\*/g, home.split(path522.sep).pop() || "");
-          if (fs52.existsSync(resolved)) return resolved;
+          if (fs54.existsSync(resolved)) return resolved;
         } else {
-          if (fs52.existsSync(p)) return p;
+          if (fs54.existsSync(p)) return p;
         }
       }
       return null;
@@ -124338,7 +125060,7 @@ ${ptyResult.output.slice(-2e3)}`);
     async function getMacAppVersion(appPath) {
       if ((0, import_os6.platform)() !== "darwin" || !appPath.endsWith(".app")) return null;
       const plistPath = path522.join(appPath, "Contents", "Info.plist");
-      if (!fs52.existsSync(plistPath)) return null;
+      if (!fs54.existsSync(plistPath)) return null;
       const raw = await runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
       return raw || null;
     }
@@ -124365,7 +125087,7 @@ ${ptyResult.output.slice(-2e3)}`);
           let resolvedBin = cliBin;
           if (!resolvedBin && appPath && currentOs === "darwin") {
             const bundled = path522.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
-            if (provider.cli && fs52.existsSync(bundled)) resolvedBin = bundled;
+            if (provider.cli && fs54.existsSync(bundled)) resolvedBin = bundled;
           }
           info.installed = !!(appPath || resolvedBin);
           info.path = appPath || null;
@@ -124411,7 +125133,7 @@ ${ptyResult.output.slice(-2e3)}`);
       return results;
     }
     var http3 = __toESM2(require("http"));
-    var fs56 = __toESM2(require("fs"));
+    var fs58 = __toESM2(require("fs"));
     var path56 = __toESM2(require("path"));
     init_config();
     function generateFiles(type2, name, category, opts = {}) {
@@ -124757,7 +125479,7 @@ async (params) => {
     }
     init_logger();
     init_builders();
-    var fs53 = __toESM2(require("fs"));
+    var fs55 = __toESM2(require("fs"));
     var path53 = __toESM2(require("path"));
     init_logger();
     async function handleCdpEvaluate(ctx, req, res) {
@@ -124938,17 +125660,17 @@ async (params) => {
       }
       let scriptsPath = "";
       const directScripts = path53.join(dir, "scripts.js");
-      if (fs53.existsSync(directScripts)) {
+      if (fs55.existsSync(directScripts)) {
         scriptsPath = directScripts;
       } else {
         const scriptsDir = path53.join(dir, "scripts");
-        if (fs53.existsSync(scriptsDir)) {
-          const versions = fs53.readdirSync(scriptsDir).filter((d) => {
-            return fs53.statSync(path53.join(scriptsDir, d)).isDirectory();
+        if (fs55.existsSync(scriptsDir)) {
+          const versions = fs55.readdirSync(scriptsDir).filter((d) => {
+            return fs55.statSync(path53.join(scriptsDir, d)).isDirectory();
           }).sort().reverse();
           for (const ver of versions) {
             const p = path53.join(scriptsDir, ver, "scripts.js");
-            if (fs53.existsSync(p)) {
+            if (fs55.existsSync(p)) {
               scriptsPath = p;
               break;
             }
@@ -124960,7 +125682,7 @@ async (params) => {
         return;
       }
       try {
-        const source = fs53.readFileSync(scriptsPath, "utf-8");
+        const source = fs55.readFileSync(scriptsPath, "utf-8");
         const hints = {};
         const funcRegex = /module\.exports\.(\w+)\s*=\s*function\s+\w+\s*\(params\)/g;
         let match;
@@ -125773,7 +126495,7 @@ async (params) => {
         ctx.json(res, 500, { error: `DOM context collection failed: ${e.message}` });
       }
     }
-    var fs54 = __toESM2(require("fs"));
+    var fs56 = __toESM2(require("fs"));
     var path54 = __toESM2(require("path"));
     function slugifyFixtureName(value) {
       const normalized = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -125789,10 +126511,10 @@ async (params) => {
     function readCliFixture(ctx, type2, name) {
       const fixtureDir = getCliFixtureDir(ctx, type2);
       const filePath = path54.join(fixtureDir, `${name}.json`);
-      if (!fs54.existsSync(filePath)) {
+      if (!fs56.existsSync(filePath)) {
         throw new Error(`Fixture not found: ${filePath}`);
       }
-      return JSON.parse(fs54.readFileSync(filePath, "utf-8"));
+      return JSON.parse(fs56.readFileSync(filePath, "utf-8"));
     }
     function getExerciseTranscriptText(result) {
       const parts = [];
@@ -126542,7 +127264,7 @@ async (params) => {
           return;
         }
         const fixtureDir = getCliFixtureDir(ctx, type2);
-        fs54.mkdirSync(fixtureDir, { recursive: true });
+        fs56.mkdirSync(fixtureDir, { recursive: true });
         const name = slugifyFixtureName(String(body?.name || `${type2}-${Date.now()}`));
         const result = await runCliExerciseInternal(ctx, { ...request, type: type2 });
         const fixture = {
@@ -126570,7 +127292,7 @@ async (params) => {
           notes: typeof body?.notes === "string" ? body.notes : void 0
         };
         const filePath = path54.join(fixtureDir, `${name}.json`);
-        fs54.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
+        fs56.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
         ctx.json(res, 200, {
           saved: true,
           name,
@@ -126588,14 +127310,14 @@ async (params) => {
     async function handleCliFixtureList(ctx, type2, _req, res) {
       try {
         const fixtureDir = getCliFixtureDir(ctx, type2);
-        if (!fs54.existsSync(fixtureDir)) {
+        if (!fs56.existsSync(fixtureDir)) {
           ctx.json(res, 200, { fixtures: [], count: 0 });
           return;
         }
-        const fixtures = fs54.readdirSync(fixtureDir).filter((file2) => file2.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file2) => {
+        const fixtures = fs56.readdirSync(fixtureDir).filter((file2) => file2.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file2) => {
           const fullPath = path54.join(fixtureDir, file2);
           try {
-            const raw = JSON.parse(fs54.readFileSync(fullPath, "utf-8"));
+            const raw = JSON.parse(fs56.readFileSync(fullPath, "utf-8"));
             return {
               name: raw.name || file2.replace(/\.json$/i, ""),
               path: fullPath,
@@ -126726,7 +127448,7 @@ async (params) => {
         ctx.json(res, 500, { error: `Raw send failed: ${e.message}` });
       }
     }
-    var fs55 = __toESM2(require("fs"));
+    var fs57 = __toESM2(require("fs"));
     var path55 = __toESM2(require("path"));
     var os29 = __toESM2(require("os"));
     var import_session_host_core10 = require_dist();
@@ -126775,10 +127497,10 @@ async (params) => {
       return fallback?.type || null;
     }
     function getLatestScriptVersionDir(scriptsDir) {
-      if (!fs55.existsSync(scriptsDir)) return null;
-      const versions = fs55.readdirSync(scriptsDir).filter((d) => {
+      if (!fs57.existsSync(scriptsDir)) return null;
+      const versions = fs57.readdirSync(scriptsDir).filter((d) => {
         try {
-          return fs55.statSync(path55.join(scriptsDir, d)).isDirectory();
+          return fs57.statSync(path55.join(scriptsDir, d)).isDirectory();
         } catch {
           return false;
         }
@@ -126800,13 +127522,13 @@ async (params) => {
       if (!sourceDir) {
         return { dir: null, reason: `Provider source directory not found for '${type2}'` };
       }
-      if (!fs55.existsSync(desiredDir)) {
-        fs55.mkdirSync(path55.dirname(desiredDir), { recursive: true });
-        fs55.cpSync(sourceDir, desiredDir, { recursive: true });
+      if (!fs57.existsSync(desiredDir)) {
+        fs57.mkdirSync(path55.dirname(desiredDir), { recursive: true });
+        fs57.cpSync(sourceDir, desiredDir, { recursive: true });
         ctx.log(`Auto-implement writable copy created: ${desiredDir}`);
       }
       const providerJson = path55.join(desiredDir, "provider.json");
-      if (!fs55.existsSync(providerJson)) {
+      if (!fs57.existsSync(providerJson)) {
         return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
       }
       return { dir: desiredDir };
@@ -126814,15 +127536,15 @@ async (params) => {
     function loadAutoImplReferenceScripts(ctx, referenceType) {
       if (!referenceType) return {};
       const refDir = ctx.findProviderDir(referenceType);
-      if (!refDir || !fs55.existsSync(refDir)) return {};
+      if (!refDir || !fs57.existsSync(refDir)) return {};
       const referenceScripts = {};
       const scriptsDir = path55.join(refDir, "scripts");
       const latestDir = getLatestScriptVersionDir(scriptsDir);
       if (!latestDir) return referenceScripts;
-      for (const file2 of fs55.readdirSync(latestDir)) {
+      for (const file2 of fs57.readdirSync(latestDir)) {
         if (!file2.endsWith(".js")) continue;
         try {
-          referenceScripts[file2] = fs55.readFileSync(path55.join(latestDir, file2), "utf-8");
+          referenceScripts[file2] = fs57.readFileSync(path55.join(latestDir, file2), "utf-8");
         } catch {
         }
       }
@@ -126931,15 +127653,15 @@ async (params) => {
         const referenceScripts = loadAutoImplReferenceScripts(ctx, resolvedReference);
         const prompt = buildAutoImplPrompt(ctx, type2, provider, providerDir, functions, domContext, referenceScripts, comment, resolvedReference, verification);
         const tmpDir = path55.join(os29.tmpdir(), "adhdev-autoimpl");
-        if (!fs55.existsSync(tmpDir)) fs55.mkdirSync(tmpDir, { recursive: true });
+        if (!fs57.existsSync(tmpDir)) fs57.mkdirSync(tmpDir, { recursive: true });
         const promptFile = path55.join(tmpDir, `prompt-${type2}-${Date.now()}.md`);
-        fs55.writeFileSync(promptFile, prompt, "utf-8");
+        fs57.writeFileSync(promptFile, prompt, "utf-8");
         ctx.log(`Auto-implement prompt written to ${promptFile} (${prompt.length} chars)`);
         const agentProvider = ctx.providerLoader.resolve(agent) || ctx.providerLoader.getMeta(agent);
         const spawn7 = agentProvider?.spawn;
         if (!spawn7?.command) {
           try {
-            fs55.unlinkSync(promptFile);
+            fs57.unlinkSync(promptFile);
           } catch {
           }
           ctx.json(res, 400, { error: `Agent '${agent}' has no spawn config. Select a CLI provider with a spawn configuration.` });
@@ -127041,7 +127763,7 @@ async (params) => {
             } catch {
             }
             try {
-              fs55.unlinkSync(promptFile);
+              fs57.unlinkSync(promptFile);
             } catch {
             }
             ctx.log(`Auto-implement (ACP) ${success2 ? "completed" : "failed"}: ${type2} (exit: ${code})`);
@@ -127264,7 +127986,7 @@ async (params) => {
             }
           });
           try {
-            fs55.unlinkSync(promptFile);
+            fs57.unlinkSync(promptFile);
           } catch {
           }
           ctx.log(`Auto-implement ${success2 ? "completed" : "failed"}: ${type2} (exit: ${code})${verificationSummary ? ` verify=${verificationSummary.pass ? "pass" : "fail"}` : ""}`);
@@ -127369,10 +128091,10 @@ async (params) => {
         lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
         lines.push("These are the ONLY files you are allowed to modify. Replace the TODO stubs with working implementations.");
         lines.push("");
-        for (const file2 of fs55.readdirSync(latestScriptsDir)) {
+        for (const file2 of fs57.readdirSync(latestScriptsDir)) {
           if (file2.endsWith(".js") && targetFileNames.has(file2)) {
             try {
-              const content = fs55.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
+              const content = fs57.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
               lines.push("```javascript");
               lines.push(content);
@@ -127382,14 +128104,14 @@ async (params) => {
             }
           }
         }
-        const refFiles = fs55.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+        const refFiles = fs57.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
         if (refFiles.length > 0) {
           lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
           lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
           lines.push("");
           for (const file2 of refFiles) {
             try {
-              const content = fs55.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
+              const content = fs57.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u{1F512}`);
               lines.push("```javascript");
               lines.push(content);
@@ -127434,7 +128156,7 @@ async (params) => {
       const loadGuide = (name) => {
         try {
           const p = path55.join(docsDir, name);
-          if (fs55.existsSync(p)) return fs55.readFileSync(p, "utf-8");
+          if (fs57.existsSync(p)) return fs57.readFileSync(p, "utf-8");
         } catch {
         }
         return null;
@@ -127678,11 +128400,11 @@ async (params) => {
         lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
         lines.push("These are the ONLY files you are allowed to modify. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
         lines.push("");
-        for (const file2 of fs55.readdirSync(latestScriptsDir)) {
+        for (const file2 of fs57.readdirSync(latestScriptsDir)) {
           if (!file2.endsWith(".js")) continue;
           if (!targetFileNames.has(file2)) continue;
           try {
-            const content = fs55.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
+            const content = fs57.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
             lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
             lines.push("```javascript");
             lines.push(content);
@@ -127691,14 +128413,14 @@ async (params) => {
           } catch {
           }
         }
-        const refFiles = fs55.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+        const refFiles = fs57.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
         if (refFiles.length > 0) {
           lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
           lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
           lines.push("");
           for (const file2 of refFiles) {
             try {
-              const content = fs55.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
+              const content = fs57.readFileSync(path55.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u{1F512}`);
               lines.push("```javascript");
               lines.push(content);
@@ -127735,7 +128457,7 @@ async (params) => {
       const loadGuide = (name) => {
         try {
           const p = path55.join(docsDir, name);
-          if (fs55.existsSync(p)) return fs55.readFileSync(p, "utf-8");
+          if (fs57.existsSync(p)) return fs57.readFileSync(p, "utf-8");
         } catch {
         }
         return null;
@@ -128473,7 +129195,7 @@ data: ${JSON.stringify(msg.data)}
           path56.join(process.cwd(), "packages/web-devconsole/dist")
         ];
         for (const dir of candidates) {
-          if (fs56.existsSync(path56.join(dir, "index.html"))) return dir;
+          if (fs58.existsSync(path56.join(dir, "index.html"))) return dir;
         }
         return null;
       }
@@ -128485,7 +129207,7 @@ data: ${JSON.stringify(msg.data)}
         }
         const htmlPath = path56.join(distDir, "index.html");
         try {
-          const html = fs56.readFileSync(htmlPath, "utf-8");
+          const html = fs58.readFileSync(htmlPath, "utf-8");
           res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
           res.end(html);
         } catch (e) {
@@ -128515,7 +129237,7 @@ data: ${JSON.stringify(msg.data)}
           return;
         }
         try {
-          const content = fs56.readFileSync(filePath);
+          const content = fs58.readFileSync(filePath);
           const ext = path56.extname(filePath);
           const contentType = _DevServer.MIME_MAP[ext] || "application/octet-stream";
           res.writeHead(200, { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" });
@@ -128624,14 +129346,14 @@ data: ${JSON.stringify(msg.data)}
         const files = [];
         const scan = (d, prefix) => {
           try {
-            for (const entry of fs56.readdirSync(d, { withFileTypes: true })) {
+            for (const entry of fs58.readdirSync(d, { withFileTypes: true })) {
               if (entry.name.startsWith(".") || entry.name.endsWith(".bak")) continue;
               const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
               if (entry.isDirectory()) {
                 files.push({ path: rel, size: 0, type: "dir" });
                 scan(path56.join(d, entry.name), rel);
               } else {
-                const stat2 = fs56.statSync(path56.join(d, entry.name));
+                const stat2 = fs58.statSync(path56.join(d, entry.name));
                 files.push({ path: rel, size: stat2.size, type: "file" });
               }
             }
@@ -128659,11 +129381,11 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 403, { error: "Forbidden" });
           return;
         }
-        if (!fs56.existsSync(fullPath) || fs56.statSync(fullPath).isDirectory()) {
+        if (!fs58.existsSync(fullPath) || fs58.statSync(fullPath).isDirectory()) {
           this.json(res, 404, { error: `File not found: ${filePath}` });
           return;
         }
-        const content = fs56.readFileSync(fullPath, "utf-8");
+        const content = fs58.readFileSync(fullPath, "utf-8");
         this.json(res, 200, { type: type2, path: filePath, content, lines: content.split("\n").length });
       }
       /** POST /api/providers/:type/file — write a file { path, content } */
@@ -128685,9 +129407,9 @@ data: ${JSON.stringify(msg.data)}
           return;
         }
         try {
-          if (fs56.existsSync(fullPath)) fs56.copyFileSync(fullPath, fullPath + ".bak");
-          fs56.mkdirSync(path56.dirname(fullPath), { recursive: true });
-          fs56.writeFileSync(fullPath, content, "utf-8");
+          if (fs58.existsSync(fullPath)) fs58.copyFileSync(fullPath, fullPath + ".bak");
+          fs58.mkdirSync(path56.dirname(fullPath), { recursive: true });
+          fs58.writeFileSync(fullPath, content, "utf-8");
           this.log(`File saved: ${fullPath} (${content.length} chars)`);
           this.providerLoader.reload();
           this.json(res, 200, { saved: true, path: filePath, chars: content.length });
@@ -128704,8 +129426,8 @@ data: ${JSON.stringify(msg.data)}
         }
         for (const name of ["scripts.js", "provider.json"]) {
           const p = path56.join(dir, name);
-          if (fs56.existsSync(p)) {
-            const source = fs56.readFileSync(p, "utf-8");
+          if (fs58.existsSync(p)) {
+            const source = fs58.readFileSync(p, "utf-8");
             this.json(res, 200, { type: type2, path: p, source, lines: source.split("\n").length });
             return;
           }
@@ -128724,11 +129446,11 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 404, { error: `Provider not found: ${type2}` });
           return;
         }
-        const target = fs56.existsSync(path56.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
+        const target = fs58.existsSync(path56.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
         const targetPath = path56.join(dir, target);
         try {
-          if (fs56.existsSync(targetPath)) fs56.copyFileSync(targetPath, targetPath + ".bak");
-          fs56.writeFileSync(targetPath, source, "utf-8");
+          if (fs58.existsSync(targetPath)) fs58.copyFileSync(targetPath, targetPath + ".bak");
+          fs58.writeFileSync(targetPath, source, "utf-8");
           this.log(`Saved provider: ${targetPath} (${source.length} chars)`);
           this.providerLoader.reload();
           this.json(res, 200, { saved: true, path: targetPath, chars: source.length });
@@ -128873,20 +129595,20 @@ data: ${JSON.stringify(msg.data)}
         let targetDir;
         targetDir = this.providerLoader.getUserProviderDir(category, type2);
         const jsonPath = path56.join(targetDir, "provider.json");
-        if (fs56.existsSync(jsonPath)) {
+        if (fs58.existsSync(jsonPath)) {
           this.json(res, 409, { error: `Provider already exists at ${targetDir}`, path: targetDir });
           return;
         }
         try {
           const result = generateFiles(type2, name, category, { cdpPorts, cli, processName, installPath, binary: binary2, extensionId, version: version2, osPaths, processNames });
-          fs56.mkdirSync(targetDir, { recursive: true });
-          fs56.writeFileSync(jsonPath, result["provider.json"], "utf-8");
+          fs58.mkdirSync(targetDir, { recursive: true });
+          fs58.writeFileSync(jsonPath, result["provider.json"], "utf-8");
           const createdFiles = ["provider.json"];
           if (result.files) {
             for (const [relPath, content] of Object.entries(result.files)) {
               const fullPath = path56.join(targetDir, relPath);
-              fs56.mkdirSync(path56.dirname(fullPath), { recursive: true });
-              fs56.writeFileSync(fullPath, content, "utf-8");
+              fs58.mkdirSync(path56.dirname(fullPath), { recursive: true });
+              fs58.writeFileSync(fullPath, content, "utf-8");
               createdFiles.push(relPath);
             }
           }
@@ -128935,10 +129657,10 @@ data: ${JSON.stringify(msg.data)}
       }
       // ─── Phase 2: Auto-Implement Backend ───
       getLatestScriptVersionDir(scriptsDir) {
-        if (!fs56.existsSync(scriptsDir)) return null;
-        const versions = fs56.readdirSync(scriptsDir).filter((d) => {
+        if (!fs58.existsSync(scriptsDir)) return null;
+        const versions = fs58.readdirSync(scriptsDir).filter((d) => {
           try {
-            return fs56.statSync(path56.join(scriptsDir, d)).isDirectory();
+            return fs58.statSync(path56.join(scriptsDir, d)).isDirectory();
           } catch {
             return false;
           }
@@ -128960,13 +129682,13 @@ data: ${JSON.stringify(msg.data)}
         if (!sourceDir) {
           return { dir: null, reason: `Provider source directory not found for '${type2}'` };
         }
-        if (!fs56.existsSync(desiredDir)) {
-          fs56.mkdirSync(path56.dirname(desiredDir), { recursive: true });
-          fs56.cpSync(sourceDir, desiredDir, { recursive: true });
+        if (!fs58.existsSync(desiredDir)) {
+          fs58.mkdirSync(path56.dirname(desiredDir), { recursive: true });
+          fs58.cpSync(sourceDir, desiredDir, { recursive: true });
           this.log(`Auto-implement writable copy created: ${desiredDir}`);
         }
         const providerJson = path56.join(desiredDir, "provider.json");
-        if (!fs56.existsSync(providerJson)) {
+        if (!fs58.existsSync(providerJson)) {
           return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
         }
         return { dir: desiredDir };
@@ -129775,7 +130497,7 @@ data: ${JSON.stringify(msg.data)}
       }
     }
     var import_child_process14 = require("child_process");
-    var fs57 = __toESM2(require("fs"));
+    var fs59 = __toESM2(require("fs"));
     var os30 = __toESM2(require("os"));
     var path57 = __toESM2(require("path"));
     var import_session_host_core14 = require_dist();
@@ -129801,7 +130523,7 @@ data: ${JSON.stringify(msg.data)}
           path57.resolve(__dirname, "../../vendor/session-host-daemon/index.js")
         ];
         for (const candidate of packagedCandidates) {
-          if (fs57.existsSync(candidate)) {
+          if (fs59.existsSync(candidate)) {
             return candidate;
           }
         }
@@ -129821,8 +130543,8 @@ data: ${JSON.stringify(msg.data)}
       function getPid() {
         try {
           const pidFile = getPidFile();
-          if (!fs57.existsSync(pidFile)) return null;
-          const pid = Number.parseInt(fs57.readFileSync(pidFile, "utf8").trim(), 10);
+          if (!fs59.existsSync(pidFile)) return null;
+          const pid = Number.parseInt(fs59.readFileSync(pidFile, "utf8").trim(), 10);
           return Number.isFinite(pid) ? pid : null;
         } catch {
           return null;
@@ -129872,7 +130594,7 @@ data: ${JSON.stringify(msg.data)}
         if (markerIndex === -1) return;
         const activePrefix = entry.slice(0, markerIndex);
         const candidates = resolveConptyPrebuildCandidates(activePrefix);
-        const found = candidates.find((candidate) => fs57.existsSync(candidate));
+        const found = candidates.find((candidate) => fs59.existsSync(candidate));
         if (!found) {
           throw new Error(
             `conpty.node missing at boot despite passing the install-time gate \u2014 likely deleted post-install (checked: ${candidates.join(", ")}). Every session-host spawn would crash requiring node-pty; refusing to spawn.`
@@ -129888,8 +130610,8 @@ data: ${JSON.stringify(msg.data)}
         let logFd = null;
         if (options.spawnStdio === "logfile") {
           const logDir = path57.join(instance().configDir, "logs");
-          fs57.mkdirSync(logDir, { recursive: true });
-          logFd = fs57.openSync(path57.join(logDir, "session-host.log"), "a");
+          fs59.mkdirSync(logDir, { recursive: true });
+          logFd = fs59.openSync(path57.join(logDir, "session-host.log"), "a");
           stdio = ["ignore", logFd, logFd];
         }
         const child = (0, import_child_process14.spawn)(nodeExecutable, [entry], {
@@ -129901,7 +130623,7 @@ data: ${JSON.stringify(msg.data)}
         child.unref();
         if (logFd !== null) {
           try {
-            fs57.closeSync(logFd);
+            fs59.closeSync(logFd);
           } catch {
           }
         }
@@ -129919,8 +130641,8 @@ data: ${JSON.stringify(msg.data)}
         const pidFile = getPidFile();
         let keepPidFile = false;
         try {
-          if (fs57.existsSync(pidFile)) {
-            const pid = Number.parseInt(fs57.readFileSync(pidFile, "utf8").trim(), 10);
+          if (fs59.existsSync(pidFile)) {
+            const pid = Number.parseInt(fs59.readFileSync(pidFile, "utf8").trim(), 10);
             if (Number.isFinite(pid) && pid !== process.pid) {
               const managed = isManagedPid(pid);
               if (managed) {
@@ -129940,7 +130662,7 @@ data: ${JSON.stringify(msg.data)}
         } finally {
           if (!keepPidFile) {
             try {
-              fs57.unlinkSync(pidFile);
+              fs59.unlinkSync(pidFile);
             } catch {
             }
           }
@@ -129976,7 +130698,7 @@ data: ${JSON.stringify(msg.data)}
         }
         if (!reported) return;
         if (pathsEquivalent(reported, currentEntry)) return;
-        const reportedExists = fs57.existsSync(reported);
+        const reportedExists = fs59.existsSync(reported);
         LOG2.warn(
           "SessionHost",
           `Reachable session-host reports it is running from ${reported}${reportedExists ? "" : " (which no longer exists)"}, but this install runs from ${currentEntry}. That host would fail every create_session loading node-pty from its own prefix; stopping it so a current one is spawned in its place.`
@@ -130203,8 +130925,8 @@ data: ${JSON.stringify(msg.data)}
           const res = await fetch(extension.vsixUrl);
           if (res.ok) {
             const buffer = Buffer.from(await res.arrayBuffer());
-            const fs59 = await import("fs");
-            fs59.writeFileSync(vsixPath, buffer);
+            const fs61 = await import("fs");
+            fs61.writeFileSync(vsixPath, buffer);
             return new Promise((resolve30) => {
               const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
               (0, import_child_process15.exec)(cmd, { timeout: 6e4 }, (error48, _stdout, stderr) => {
@@ -130350,7 +131072,7 @@ data: ${JSON.stringify(msg.data)}
     init_mesh_events();
     init_mesh_reconcile_loop();
     var import_fs19 = require("fs");
-    var import_path20 = require("path");
+    var import_path21 = require("path");
     var import_crypto18 = require("crypto");
     init_logger();
     init_mesh_ledger();
@@ -130428,7 +131150,7 @@ data: ${JSON.stringify(msg.data)}
       }
       for (const name of names) {
         if (!isPendingEventsFile(name)) continue;
-        const path58 = (0, import_path20.join)(dir, name);
+        const path58 = (0, import_path21.join)(dir, name);
         result.filesScanned++;
         const claimed = `${path58}.migrating`;
         try {
@@ -131207,7 +131929,7 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
       Object.values(V1_PRIMITIVE_CATALOG).flat()
     );
     var V1_CONTRACT_VERSION = "1.0.0";
-    var fs58 = __toESM2(require("fs"));
+    var fs60 = __toESM2(require("fs"));
     var import_chalk2 = __toESM2((init_source(), __toCommonJS(source_exports)));
     init_dist();
     var CLAUDE_NO_API_LINE = "Claude has no quota API \u2014 adhdev borrows your statusLine to read it.";
@@ -131318,7 +132040,7 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         console.log(import_chalk2.default.gray(`  Backup: ${status.paths.backupFile}`));
         let snapshotMtimeMs = null;
         try {
-          snapshotMtimeMs = fs58.statSync(status.paths.snapshotFile).mtimeMs;
+          snapshotMtimeMs = fs60.statSync(status.paths.snapshotFile).mtimeMs;
         } catch {
         }
         console.log(import_chalk2.default.gray(