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

package/dist/index.js

@@ -36620,10 +36620,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "d41089a0d560d75e670a90d3c4e9955bf955bbbc" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "d41089a0" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.56-rc.5" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-19T05:42:19.473Z" : void 0);
+      const commit = readInjected(true ? "13ea4fe8748ca3d97f0e4f9cc10a4c5969855fff" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "13ea4fe8" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.56-rc.7" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-19T14:43:40.002Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -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,7 +47892,8 @@ ${blocks.join("\n\n")}`;
         providerSessionId || "",
         taskId || "",
         jobId || "",
-        timestamp2 || ""
+        timestamp2 || "",
+        ...alertReason ? [alertReason] : []
       ].join("::");
     }
     function hasPendingCoordinatorEventDuplicate(event) {
@@ -48400,6 +48342,7 @@ ${blocks.join("\n\n")}`;
     var warnedV2Violations;
     var loggedSqlitePendingDrainFailure;
     var TERMINAL_COMPLETION_EVENTS;
+    var COORDINATOR_ALERT_EVENTS_WITH_REASON_FINGERPRINT;
     var PENDING_EVENTS_DRAINED_RETENTION_MS;
     var PENDING_EVENTS_UNDRAINED_RETENTION_MS;
     var PENDING_RETENTION_EXPIRED_HOLD_REASON;
@@ -48450,6 +48393,9 @@ ${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"
+        ]);
         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 +48416,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 +49040,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 +49057,7 @@ ${blocks.join("\n\n")}`;
       normalizeMeshCapabilityTags: () => normalizeMeshCapabilityTags,
       normalizeMeshTaskMode: () => normalizeMeshTaskMode,
       normalizeMeshTaskPriority: () => normalizeMeshTaskPriority,
+      parkTaskTargetPin: () => parkTaskTargetPin,
       reclaimStrandedAssignedTask: () => reclaimStrandedAssignedTask,
       recordDirectDispatchTask: () => recordDirectDispatchTask,
       recordMeshToolCall: () => recordMeshToolCall,
@@ -49352,6 +49539,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 +49572,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 +49612,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 +49642,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 +49653,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 +49920,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 +52792,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 +53761,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";
@@ -55255,6 +55478,7 @@ ${blocks.join("\n\n")}`;
       compactLedger: () => compactLedger,
       enforceAllLedgerRotationCaps: () => enforceAllLedgerRotationCaps,
       enforceLedgerRotationCap: () => enforceLedgerRotationCap,
+      extractJsonObjectFromSummary: () => extractJsonObjectFromSummary,
       getLedgerDir: () => getLedgerDir2,
       getLedgerSummary: () => getLedgerSummary,
       getSessionRecoveryContext: () => getSessionRecoveryContext,
@@ -56873,11 +57097,12 @@ ${rules.join("\n")}`;
       return `## Rules
 
 - **Route, don't implement.** Delegate all code reading, analysis, and execution to node agents. Never read source files or run commands in the coordinator \u2014 keep context lean. See also: **Never use local sub-agents** below.${destructiveGitRule}
-- **Never use local sub-agents.** Do NOT spawn your runtime's own sub-agents (e.g. Claude Code's Task/Explore/Agent tools, or any equivalent in-process agent-spawning tool) to read code, investigate, run RCA, or implement. Such sub-agents execute on the coordinator's machine, outside the mesh \u2014 they escape mesh parallelism, the ledger/audit trail, node capability profiles, and worktree isolation, and leave no \`mesh_task_history\` record. ALL code reading, analysis, RCA, and implementation must be delegated through \`mesh_enqueue_batch\` for a currently known multi-step graph, \`mesh_enqueue_task\` for one ready task, or \`mesh_send_task\` for a same-session continuation (use \`task_mode: "live_debug_readonly"\` for read-only investigation), or cross-verified via \`mesh_magi_review\` for read-only fan-out. The coordinator's own actions are limited to \`mesh_*\` tool orchestration and synthesizing results.
-- **Front-load immutable task instructions.** Include everything the agent needs (files, problem, expected fix) in \`mesh_enqueue_batch\` / \`mesh_enqueue_task\` / \`mesh_send_task\`. Put predecessor-produced data in explicit \`inputs_from\` bindings and coordinator decisions in gates; never copy untrusted worker output into a new instruction by hand when a binding can preserve provenance. Append a structured result request at the end: ask the worker to conclude with a JSON block containing \`status\`, \`changedFiles\`, \`gitStatus\`, \`validationResults\`, \`errors\`, \`nextAction\`. The daemon parses this automatically; you can read it from \`mesh_task_history\`.
+- **Never use local sub-agents.** Do NOT spawn your runtime's own sub-agents (e.g. Claude Code's Task/Explore/Agent tools, or any equivalent in-process agent-spawning tool) to read code, investigate, run RCA, or implement. Such sub-agents execute on the coordinator's machine, outside the mesh \u2014 they escape mesh parallelism, the ledger/audit trail, node capability profiles, and worktree isolation, and leave no \`mesh_task_history\` record. ALL code reading, analysis, RCA, and implementation must be delegated through \`mesh_enqueue_batch\` (the default \u2014 see Workflow 3.a), falling back to \`mesh_enqueue_task\` only for a terminal single step, to \`mesh_send_task\` for a same-session continuation (use \`task_mode: "live_debug_readonly"\` for read-only investigation), or cross-verified via \`mesh_magi_review\` for read-only fan-out. The coordinator's own actions are limited to \`mesh_*\` tool orchestration and synthesizing results.
+- **Front-load immutable task instructions.** Include everything the agent needs (files, problem, expected fix) in whichever dispatch surface Workflow 3.a selects (\`mesh_enqueue_batch\` by default; \`mesh_enqueue_task\` / \`mesh_send_task\` in their narrower cases). Put predecessor-produced data in explicit \`inputs_from\` bindings and coordinator decisions in gates; never copy untrusted worker output into a new instruction by hand when a binding can preserve provenance. Append a structured result request at the end: ask the worker to conclude with a JSON block containing \`status\`, \`changedFiles\`, \`gitStatus\`, \`validationResults\`, \`errors\`, \`nextAction\`. The daemon parses this automatically; you can read it from \`mesh_task_history\`.
 - **Reuse idle sessions.** For follow-up, retry, commit/push, or cleanup on the same issue, send only the delta to the existing idle session. Start a fresh session only when: (a) branch/worktree isolation is required, (b) the existing session had a dispatch failure or provider mismatch, (c) the transcript/runtime is contaminated or interrupted, (d) the user explicitly asks for a different provider/session, or (e) **the delta is a genuinely NEW subject rather than a continuation** \u2014 a new topic appended to an existing session can be dropped or re-run as the previous task, so give it its own task even when a session sits idle. Continuation of the same issue in an already-idle session is allowed and preferred \u2014 this rule blocks concurrent unrelated work interleaved into a live (still-generating) session, not sequential same-issue follow-ups. The test is subject continuity, not timing: carrying an investigation forward into its own fix is the SAME subject and belongs in that session (Workflow 3f), while an unrelated bug is a new subject even if the same session just went idle.
 - **Nodes are separate machines with separate checkouts \u2014 not interchangeable execution slots.** Each node is a different physical computer with its own clone of the repo. Work done on another node must be committed, pushed, and pulled back before this machine sees it, and since RELEASE/DEPLOY runs on the coordinator's own machine, sending a code change elsewhere buys a round trip out and another one back. So **default to this coordinator's own machine for code changes** \u2014 its local node (base or a worktree cloned from it). Routing to a DIFFERENT machine is the exception and needs a reason, of which there are exactly two: (a) **platform-specific verification** that cannot be done here \u2014 win32 PATH/registry, a clean install/uninstall on that OS, that machine's package-manager state; or (b) **parallelizing read-only investigation** across machines. "That node is idle" is not a reason. If you catch yourself dispatching a fix to another machine without (a) or (b), route it here instead.
 - **Don't split investigation from the fix.** When a task will plainly end in a code change, dispatch it as \`code_change\` from the start \u2014 the in-session handoff and split criteria live in Workflow 3f. Split only when the fix genuinely belongs on another machine for reason (a) above; redoing an investigator's context in a fresh session (worse, on another machine) is pure loss.
+- **Batch is the default enqueue surface.** Apply Workflow 3.a: before every enqueue, ask whether you will read this task's result and then dispatch more work. If yes, that successor is declarable \u2014 submit the whole plan as one \`mesh_enqueue_batch\` with \`inputs_from\` / \`run_if\` / \`gated_by\`, rather than enqueueing a step, waiting, and enqueueing the next by hand. \`mesh_enqueue_task\` is the fallback for a genuinely terminal single step, and it takes an \`orchestration_decision\` stating which \`single_reason\` applies.
 - **Base nodes are reserved for environment-specific testing.** Apply Workflow 3.b0: only work that verifies a machine's physical environment runs on a base node (pinned with \`required_tags\`/\`target_node_id\`); every ordinary \`code_change\` gets its own cloned worktree. Node availability is not branch isolation.
 - **Worktree affinity.** Apply Workflow 3.b1: route a branch's follow-ups back to its own worktree node (\`required_tags: ["worktree=<branch>"]\` or \`target_node_id\`, taken from the \`mesh_clone_node\` result or a live \`mesh_status\`); only \`convergence\` (merge/push) runs base-side.
 - **Classify task difficulty honestly.** Judge each task's real difficulty (\`easy\`/\`medium\`/\`difficult\`/\`freeform\`) per the Task difficulty section above \u2014 it is a routing hint, and the matched slot's own model/thinking is what launches. Never bend difficulty to chase a model; retune slots instead (\`mesh_node_slots_set\`).
@@ -56943,7 +57168,7 @@ When you compose the task message you dispatch to a node, include this requireme
 | \`mesh_view_queue\` | Queue status \u2014 pending/assigned/completed/failed/cancelled |
 | \`mesh_graph_view\` | Inspect orchestration graphs \u2014 node states, gates awaiting you, workspace sagas, why something is blocked |
 | \`mesh_graph_gate_claim\` | Take the lease on a gate awaiting a coordinator; returns the fencing token + generation a release needs |
-| \`mesh_graph_gate_release\` | Pass a gate you hold \u2014 the ONLY way through one (no timeout ever passes a gate) |
+| \`mesh_graph_gate_release\` | Pass a gate you hold \u2014 the ONLY way through one (no timeout ever passes a gate). **A gate and its dependents are one unit**: a gate earns its keep only when some task names it in \`gated_by\`, because releasing it is what dispatches that task. A gate nothing depends on opens nothing and is pure claim/release overhead \u2014 declare the follower in the same batch, or skip the gate |
 | \`mesh_queue_cancel\` | Cancel a queue task (audit history kept) |
 | \`mesh_queue_requeue\` | Return a task to pending for retry |
 | \`mesh_send_task\` | Push a task straight to a specific node/session |
@@ -57008,13 +57233,22 @@ Before doing any coordinator work, confirm that the actual callable tool list in
         WORKFLOW_SECTION = `## Orchestration Workflow
 
 1. **Assess** \u2014 Call \`mesh_status\` to see which nodes are healthy and available. Check \`mesh_task_history\` to understand what has already been done in this mesh \u2014 previous delegations, completions, and failures.
-2. **Plan** \u2014 Decompose the user's request into independent tasks for parallel execution, or sequential tasks when dependencies exist. If \`mesh_task_history\` shows a recent failure for a task, decide whether to retry or reassign. **For multi-task work, create a mission first**: call \`mesh_mission_upsert\` with a title and goal, then attach every enqueued task with \`mission_id\`. Express "B after A" ordering with \`depends_on\` instead of waiting and polling \u2014 the system claims dependents automatically when their dependencies complete. When the mission's outcome is decided, update its status (\`completed\`/\`abandoned\`) via \`mesh_mission_upsert\`. If the prompt already shows an **Active Mission**, continue it from its current task state \u2014 do not re-enqueue tasks that already exist.
+2. **Plan** \u2014 Decompose the user's request into independent tasks for parallel execution, or sequential tasks when dependencies exist. If \`mesh_task_history\` shows a recent failure for a task, decide whether to retry or reassign. **For multi-task work, create a mission first**: call \`mesh_mission_upsert\` with a title and goal, then submit the plan as one \`mesh_enqueue_batch\` carrying that \`mission_id\` (a top-level \`mission_id\` applies to every entry). Express "B after A" ordering with \`depends_on\` instead of waiting and polling \u2014 the system claims dependents automatically when their dependencies complete. When the mission's outcome is decided, update its status (\`completed\`/\`abandoned\`) via \`mesh_mission_upsert\`. If the prompt already shows an **Active Mission**, continue it from its current task state \u2014 do not re-enqueue tasks that already exist.
 3. **Queue / Delegate** \u2014 The Mesh uses an autonomous pull-based Work Queue:
-   a. **Batch-first rule:** submit one \`mesh_enqueue_batch\` whenever the currently known plan contains two or more graph steps. A graph may include worker tasks, selected predecessor outputs via \`inputs_from\`, declarative \`run_if\` branches, delayed \`workspace_ref\` preparation, and coordinator gates for approval, Refinery, CI waiting, publish, or deployment. Submit the whole materializable plan once; do not wait and enqueue each known step separately.
+   a. **Batch-first rule.** Before enqueueing anything, answer ONE question: *when this task reports back, will I read its result and then dispatch more work \u2014 or does the result go to the user with nothing behind it?*
+       - **You will act on the result \u2192 \`mesh_enqueue_batch\`.** If you already intend to read the output and dispatch a next step, that next step is a step you can declare. Declare it: bind the evidence with \`inputs_from\`, branch on it with \`run_if\`, or put your own decision behind a coordinator gate and point the follower at it with \`gated_by\`. "I need to see the result first" is HOW a graph edge is expressed, not a reason to skip the graph \u2014 that is exactly what \`inputs_from\` and gates are for. An investigation you plan to act on is, by this test, a declarable two-step plan.
+       - **The result goes to the user and nothing follows \u2192 \`mesh_enqueue_task\`.** One task, no successor you intend to dispatch yourself. Same-subject continuation of an already-running session is \`mesh_send_task\`, not a new enqueue either way.
+       - Submit the whole materializable plan in ONE batch. A batch may mix worker tasks, \`inputs_from\` bindings, \`run_if\` branches, delayed \`workspace_ref\` preparation, and coordinator gates for approval, Refinery, CI waiting, publish, or deployment. Do not enqueue one known step, wait for it, and then enqueue the next known step by hand.
+       - **A mesh with idle nodes or a short plan does not remove this requirement.** "It is only two steps" and "I will just enqueue the next one when this finishes" are the two ways the graph gets skipped; neither is a reason. Two declarable steps is precisely the case the batch surface exists for.
+       - **"The only thing I am sure of right now is this one task" is not evidence of a single.** That feeling is about your confidence, not about how many steps are settled; two steps are routinely settled at once while it still feels that way. Count the steps you would actually dispatch. If that count is two or more, it is a batch no matter how the plan feels.
+       - **"I cannot choose the next step until I see this result" states that the next step EXISTS.** What the result decides is *which branch you take*, not *whether* there is a follow-up \u2014 and a branch that turns on a predecessor's output is what \`run_if\` selects, what \`inputs_from\` feeds, and what a coordinator gate holds until you decide. Needing to look at evidence before choosing is the ordinary case for a graph edge, not an exception to it.
+       - **A gate or a batch is not overhead when something follows it.** The extra call buys the dispatch of everything behind it, so it costs one call and saves a whole round-trip through you. The only genuinely wasteful gate is one nothing depends on \u2014 a gate no task names in \`gated_by\` opens nothing when released, which the release response tells you about; that case is answered by declaring the follower, not by abandoning the batch.
 
-   Use \`mesh_enqueue_task\` only when exactly one new worker task is currently known and there is no known downstream step to declare, or when continuing an already-running session via \`mesh_send_task\` is the correct same-subject handoff. If later work is genuinely unknown, enqueue the one ready task and start a new batch when the next frontier becomes known.
+   When you do use \`mesh_enqueue_task\`, pass \`orchestration_decision\` recording why a single was right (\`single_reason\`: \`only_one_step_known\` / \`future_step_not_specifiable\` / \`same_session_continuation\` / \`legacy_client\` / \`operator_override\`). Omitting it is recorded as \`decision_missing\`.
 
-   Do not invent speculative downstream instructions merely to form a batch. Use an \`inputs_from\` binding when the instruction is stable but needs predecessor evidence; use a coordinator gate when a human/coordinator decision or external side effect must happen first; use \`run_if\` for a structured result predicate. If none can state the future step faithfully, single-task enqueue is correct.
+   Do not invent speculative downstream instructions merely to form a batch \u2014 a step you would not actually dispatch does not belong in the graph. But check the three declaration surfaces before concluding a step is unstatable: \`inputs_from\` when the instruction is stable and only needs predecessor evidence, a coordinator gate when a human/coordinator decision or external side effect must come first, \`run_if\` when the branch turns on a structured result predicate. Only when none of the three can state the future step faithfully is single-task enqueue correct.
+
+   **The line between the two failures.** The rebuttals above are aimed at declining to declare a step you already intend to dispatch; this guard is aimed at fabricating one you do not. They never both apply to the same step: the test is whether the step exists in your plan, not whether its details are settled. A step you intend to run but whose exact branch depends on evidence is KNOWN and belongs in the batch \u2014 that dependency is what the three surfaces express. A step you would have to make up to fill the batch is UNKNOWN and belongs nowhere. When you genuinely cannot tell which one you are looking at, enqueue the single and record \`future_step_not_specifiable\`; that is the honest answer and it is measured.
 
    Either way, idle node agents automatically pull tasks from the queue and begin working. A batch inserts atomically (a mid-batch error such as a cycle or bad difficulty rolls the whole set back, so no half-registered chain), and each task's \`depends_on\` may name sibling tasks by their batch-local \`ref\` label, forward references included.
    b. **Node Preparation**: Reuse an existing idle session on the correct node/provider before launching a new chat/session. Call \`mesh_launch_session\` only when no suitable session exists, when the user explicitly asks for a fresh provider/session, or when branch/worktree isolation requires it. **A node is not limited to one live session for read-only work** \u2014 \`readonly\`/\`live_debug_readonly\` tasks are exempt from the one-active-per-node invariant, so the SAME node can auto-launch multiple concurrent read-only sessions with no worktree needed. Cloning a worktree costs roughly 10 seconds, so it is cheap enough to create one whenever write work needs a free node; use it for branch isolation, for parallel write tasks (one active write per node), or when a node's read-only queue is deep enough that a second node would clearly finish faster \u2014 call \`mesh_clone_node\` to create the worktree node first.
@@ -59510,6 +59744,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),
@@ -59555,6 +59790,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,
@@ -59900,8 +60169,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, {
@@ -59909,7 +60196,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();
@@ -60537,9 +60824,11 @@ ${rendered}`, "utf-8");
         const materializedNodeIds = advanceReleasedGateDownstream(store, gate, node, nowIso);
         const freshNodes = graphStore.listNodes(gate.graphId);
         const graph = graphStore.getGraph(gate.graphId);
+        let graphCompleted = false;
         if (graph && freshNodes.every(isTerminalEquivalent)) {
           graphStore.updateGraphStatus(gate.graphId, "completed", nowIso, true);
           insertGateOutbox(graphStore, gate.meshId, gate.graphId, "graph_completed", { graphId: gate.graphId }, nowIso);
+          graphCompleted = true;
         } else if (graph?.status === "waiting_gate") {
           const stillWaiting = graphStore.listGatesByGraph(gate.graphId).some((g) => g.gateId !== gate.gateId && (g.state === "awaiting_coordinator" || g.state === "claimed"));
           if (!stillWaiting) graphStore.updateGraphStatus(gate.graphId, "active", nowIso);
@@ -60563,7 +60852,16 @@ ${rendered}`, "utf-8");
             gateId: gate.gateId
           }, nowIso);
         }
-        return { released: true, duplicate: false, gate: graphStore.getGate(gate.gateId), materializedNodeIds };
+        return {
+          released: true,
+          duplicate: false,
+          gate: graphStore.getGate(gate.gateId),
+          materializedNodeIds,
+          // Read from the edge set this release already walked — a gate with an empty
+          // directDownstream is terminal, and terminal gates materialize nothing by design.
+          downstreamNodeCount: directDownstream.size,
+          graphCompleted
+        };
       });
       try {
         drainMeshGraphOutbox(input.meshId);
@@ -60824,6 +61122,18 @@ ${rendered}`, "utf-8");
         ...p.replayed ? { replayed: true } : {}
       });
     }
+    function recordSingleEnqueueDecision(meshId, p) {
+      safeAppend(meshId, "single_enqueue_decision", {
+        taskId: p.taskId,
+        enqueueSurface: "single",
+        ...p.missionId ? { missionId: p.missionId } : {},
+        ...p.coordinatorSessionId ? { coordinatorSessionId: p.coordinatorSessionId } : {},
+        orchestrationDecision: p.decision,
+        ...p.decisionMissing ? { decisionMissing: true } : {},
+        ...p.declaredEligibleSingle ? { declaredEligibleSingle: true } : {},
+        ...p.batchCapabilityAvailable ? { batchCapabilityAvailable: p.batchCapabilityAvailable } : {}
+      }, p.taskId);
+    }
     function recordGraphEnqueueValidationFailed(meshId, p) {
       safeAppend(meshId, "graph_enqueue_validation_failed", {
         code: p.code,
@@ -60881,6 +61191,7 @@ ${rendered}`, "utf-8");
     }
     var MESH_VALID_SINGLE_REASONS;
     var MESH_SUPERSEDED_SINGLE_REASONS;
+    var MESH_DECLARED_ELIGIBLE_SINGLE_HINT;
     var init_mesh_graph_provenance = __esm2({
       "src/mesh/mesh-graph-provenance.ts"() {
         "use strict";
@@ -60898,6 +61209,7 @@ ${rendered}`, "utf-8");
           "workspace_unresolved",
           "coordinator_action_between"
         ];
+        MESH_DECLARED_ELIGIBLE_SINGLE_HINT = "You declared known_graph_steps >= 2 but used the single-task surface. Submit the known steps as one mesh_enqueue_batch \u2014 its input bindings, conditions and coordinator gates declare the ones that need predecessor evidence, a condition, or a coordinator action \u2014 instead of enqueueing them one at a time.";
       }
     });
     function turnProjectionActiveWorkStatus(meshId, taskId) {
@@ -61748,8 +62060,28 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         }
       };
     }
-    function quotaFactsContextForLiveRouting(mesh, isLocalNode) {
-      return { nodes: mesh?.nodes, liveLocalQuota: liveLocalQuotaForRouting(isLocalNode) };
+    function liveLocalProviderEnablementForRouting(loader2, isLocalNode) {
+      if (!loader2) return null;
+      const verdicts = /* @__PURE__ */ new Map();
+      return {
+        isMachineProviderEnabled: (providerType) => loader2.isMachineProviderEnabled(providerType),
+        isMachineQuotaEnabled: (providerType) => loader2.isMachineQuotaEnabled ? loader2.isMachineQuotaEnabled(providerType) : true,
+        isLocalNode(node) {
+          let verdict = verdicts.get(node);
+          if (verdict === void 0) {
+            verdict = !!node && isLocalNode(node) === true;
+            verdicts.set(node, verdict);
+          }
+          return verdict;
+        }
+      };
+    }
+    function quotaFactsContextForLiveRouting(mesh, isLocalNode, providerLoader) {
+      return {
+        nodes: mesh?.nodes,
+        liveLocalQuota: liveLocalQuotaForRouting(isLocalNode),
+        providerEnablement: liveLocalProviderEnablementForRouting(providerLoader, isLocalNode)
+      };
     }
     function directQuotaEntryFor(node, providerType) {
       const facts = node?.nodeFacts;
@@ -61806,6 +62138,28 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       const ageText = Number.isFinite(ageMs2) ? `${Math.round(ageMs2 / 6e4)}m` : "unparseable";
       LOG2.info("MeshQuota", `QUOTA GATE: provider '${providerType}' on node ${nodeId} fails open \u2014 snapshot age ${ageText} exceeds the ${Math.round(staleAfterMs / 6e4)}m freshness threshold`);
     }
+    function classifyAbsentQuotaReason(node, providerType, context) {
+      const enablement = context?.providerEnablement;
+      if (!enablement) return "unclassified_remote";
+      const sourceNode = cloneSourceNodeFor(node, context);
+      if (!enablement.isLocalNode(node) && !(sourceNode !== void 0 && enablement.isLocalNode(sourceNode))) {
+        return "unclassified_remote";
+      }
+      if (!enablement.isMachineProviderEnabled(providerType)) return "provider_disabled";
+      if (!enablement.isMachineQuotaEnabled(providerType)) return "probe_disabled";
+      return "not_measured";
+    }
+    function logAbsentQuotaFailOpen(node, providerType, policy, now, context) {
+      const staleAfterMs = resolveQuotaRoutingPolicy(policy).staleAfterMs;
+      const nodeId = typeof node?.nodeId === "string" && node.nodeId ? node.nodeId : typeof node?.id === "string" && node.id ? node.id : "unknown";
+      const key2 = `${nodeId} ${providerType}`;
+      const last = absentFailOpenLoggedAt.get(key2);
+      if (last !== void 0 && now - last < staleAfterMs) return;
+      absentFailOpenLoggedAt.set(key2, now);
+      const reason = classifyAbsentQuotaReason(node, providerType, context);
+      const reasonText = reason === "probe_disabled" ? "quota probing is disabled for this provider on this machine (quotaEnabled: false \u2014 an intended opt-out, not a fault)" : reason === "provider_disabled" ? "this provider is not enabled on this machine" : reason === "not_measured" ? "no snapshot has been measured yet" : "this daemon cannot read that node's machineProviders config (remote node, or its own daemon has not injected one) \u2014 cannot tell not-yet-measured from an opt-out; check the owning node's config directly";
+      LOG2.info("MeshQuota", `QUOTA GATE: provider '${providerType}' on node ${nodeId} fails open \u2014 no quota entry (${reason}: ${reasonText})`);
+    }
     function isSessionResetImminent(session, facts, quota, imminentMs, now) {
       const resetsAt = Number(session?.resetsAt);
       if (!Number.isFinite(resetsAt) || resetsAt <= 0) return false;
@@ -61827,7 +62181,10 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     }
     function evaluateProviderQuotaGate(node, providerType, policy, now = Date.now(), context) {
       const entry = quotaEntryFor(node, providerType, context, now);
-      if (!entry) return null;
+      if (!entry) {
+        logAbsentQuotaFailOpen(node, providerType, policy, now, context);
+        return null;
+      }
       const { facts, quota } = entry;
       let sessionTrustworthy = true;
       let weeklyTrustworthy = true;
@@ -61989,6 +62346,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     var PROVIDER_QUOTA_EXHAUSTED_SKIP_REASON;
     var ALL_PROVIDERS_QUOTA_GATED_SKIP_REASON;
     var staleFailOpenLoggedAt;
+    var absentFailOpenLoggedAt;
     var DEFAULT_WEEKLY_WINDOW_MINUTES;
     var DEFAULT_SESSION_WINDOW_MINUTES;
     var lastQuotaRankingByNode;
@@ -62004,6 +62362,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         PROVIDER_QUOTA_EXHAUSTED_SKIP_REASON = "provider_quota_exhausted";
         ALL_PROVIDERS_QUOTA_GATED_SKIP_REASON = "all_providers_quota_gated";
         staleFailOpenLoggedAt = /* @__PURE__ */ new Map();
+        absentFailOpenLoggedAt = /* @__PURE__ */ new Map();
         DEFAULT_WEEKLY_WINDOW_MINUTES = 7 * 24 * 60;
         DEFAULT_SESSION_WINDOW_MINUTES = 5 * 60;
         lastQuotaRankingByNode = /* @__PURE__ */ new Map();
@@ -64991,36 +65350,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);
@@ -65495,6 +65824,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);
@@ -65570,6 +65936,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",
@@ -65616,11 +65997,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({
@@ -65649,6 +66030,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";
@@ -65664,6 +66046,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",
@@ -65686,6 +66069,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
@@ -65704,6 +66095,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) {
@@ -66112,6 +66504,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);
@@ -66216,7 +66775,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) {
@@ -66325,7 +66884,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).
@@ -66540,7 +67099,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         LOG2.info("MeshQueue", `Deferring queue claim for node ${nodeId} (${sessionId}): an auto fast-forward is mutating its workspace \u2014 task left pending, claim re-fires next tick`);
         return false;
       }
-      const quotaClaimBlock = evaluateProviderQuotaGate(node, providerType, mesh?.policy?.quotaRouting ?? null, Date.now(), quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode));
+      const quotaClaimBlock = evaluateProviderQuotaGate(node, providerType, mesh?.policy?.quotaRouting ?? null, Date.now(), quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader));
       if (quotaClaimTrace) quotaClaimTrace.evaluated += 1;
       if (quotaClaimBlock) {
         const observation = { nodeId, sessionId, providerType, block: quotaClaimBlock };
@@ -66645,7 +67204,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;
@@ -66689,7 +67248,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(
@@ -66739,7 +67298,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,
@@ -66783,7 +67342,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 } : {}
           }
@@ -66796,38 +67355,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) {
@@ -66847,7 +67380,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";
@@ -66867,7 +67400,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);
       });
     }
@@ -66898,7 +67431,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 };
     }
@@ -66972,8 +67505,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,
@@ -67125,7 +67658,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 {
@@ -67151,7 +67684,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";
@@ -67172,333 +67705,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" });
+          } else if (activeWriteAssignedCount(meshId) >= maxParallelTasks) {
+            markAutoLaunch(meshId, task.id, { status: "skipped", reason: "max_parallel_tasks_reached" });
             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 });
-            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) }
-        ).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), 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),
-              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;
@@ -67545,7 +68084,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,
@@ -67618,6 +68157,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;
@@ -67676,12 +68216,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";
@@ -67714,14 +68252,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;
@@ -67729,12 +68270,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) {
@@ -70468,6 +71007,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;
@@ -71105,7 +71649,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
           }
@@ -71531,7 +72075,7 @@ ${cleanBody}`;
                   // daemon's live quota cache, not the git_status-stamped
                   // nodeFacts copy (mesh-quota-routing). Remote nodes keep
                   // reading their reported nodeFacts.
-                  quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode)
+                  quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader)
                 ) : { action: "block" };
                 const relaunchProviderType = relaunch.action === "block" ? null : relaunch.providerType;
                 if (node) {
@@ -82384,6 +82928,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,
@@ -82393,6 +82938,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,
@@ -82418,6 +82964,7 @@ ${e?.stderr || ""}`;
       DaemonStatusReporter: () => DaemonStatusReporter,
       DevServer: () => DevServer,
       DuplicateMeshDispatchError: () => DuplicateMeshDispatchError,
+      ESC: () => ESC,
       FsmDriver: () => FsmDriver,
       GOAL_PREVIEW_MAX: () => GOAL_PREVIEW_MAX,
       GitCommandError: () => GitCommandError,
@@ -82437,6 +82984,7 @@ ${e?.stderr || ""}`;
       MAX_SIZE_ROTATION_GENERATIONS: () => MAX_SIZE_ROTATION_GENERATIONS,
       MESH_CONVERGE_FAST_FORWARD_TAG: () => MESH_CONVERGE_FAST_FORWARD_TAG,
       MESH_CONVERGE_REFINE_TAG: () => MESH_CONVERGE_REFINE_TAG,
+      MESH_DECLARED_ELIGIBLE_SINGLE_HINT: () => MESH_DECLARED_ELIGIBLE_SINGLE_HINT,
       MESH_GATE_DEFAULT_LEASE_SECONDS: () => MESH_GATE_DEFAULT_LEASE_SECONDS,
       MESH_GATE_NAMED_OUTCOMES: () => MESH_GATE_NAMED_OUTCOMES,
       MESH_GATE_RELEASE_PATCH_KEYS: () => MESH_GATE_RELEASE_PATCH_KEYS,
@@ -82471,6 +83019,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,
@@ -82484,6 +83036,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,
@@ -82534,6 +83087,7 @@ ${e?.stderr || ""}`;
       buildMissionPromptSection: () => buildMissionPromptSection,
       buildOrphanedPinNotice: () => buildOrphanedPinNotice,
       buildP2pRelayFailurePayload: () => buildP2pRelayFailurePayload,
+      buildParkedTaskNotice: () => buildParkedTaskNotice,
       buildPinnedGlobalInstallCommand: () => buildPinnedGlobalInstallCommand,
       buildRuntimeSystemChatMessage: () => buildRuntimeSystemChatMessage,
       buildSessionEntries: () => buildSessionEntries,
@@ -82613,6 +83167,7 @@ ${e?.stderr || ""}`;
       evaluateProviderQuotaGate: () => evaluateProviderQuotaGate,
       execNpmCommandSync: () => execNpmCommandSync,
       expandDaemonIdForms: () => expandDaemonIdForms,
+      failRetentionExpiredParkedTask: () => failRetentionExpiredParkedTask,
       fastForwardMeshNode: () => fastForwardMeshNode,
       fetchAntigravityQuota: () => fetchAntigravityQuota2,
       fetchClaudeQuota: () => fetchClaudeQuota2,
@@ -82665,6 +83220,7 @@ ${e?.stderr || ""}`;
       getMeshStatusMissionSummaries: () => getMeshStatusMissionSummaries,
       getMeshStatusMissionsCompact: () => getMeshStatusMissionsCompact,
       getNpmExecOptions: () => getNpmExecOptions,
+      getParkedTasks: () => getParkedTasks,
       getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
       getProcessInstanceContext: () => getProcessInstanceContext,
       getQueue: () => getQueue,
@@ -82764,6 +83320,7 @@ ${e?.stderr || ""}`;
       normalizeChatMessageKind: () => normalizeChatMessageKind,
       normalizeChatMessages: () => normalizeChatMessages,
       normalizeChatTailActiveModal: () => normalizeChatTailActiveModal,
+      normalizeDeliveryMode: () => normalizeDeliveryMode,
       normalizeGitOutput: () => normalizeGitOutput,
       normalizeGitWorkspaceSubscriptionParams: () => normalizeGitWorkspaceSubscriptionParams2,
       normalizeInputEnvelope: () => normalizeInputEnvelope,
@@ -82784,7 +83341,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,
@@ -82835,6 +83396,7 @@ ${e?.stderr || ""}`;
       recordMeshToolCall: () => recordMeshToolCall,
       recordMissingSessionAttempt: () => recordMissingSessionAttempt2,
       recordSessionUsage: () => recordSessionUsage,
+      recordSingleEnqueueDecision: () => recordSingleEnqueueDecision,
       recoverExpiredWorkspaceSagas: () => recoverExpiredWorkspaceSagas,
       registerExtensionProviders: () => registerExtensionProviders,
       registerMeshCoordinator: () => registerMeshCoordinator,
@@ -82867,6 +83429,7 @@ ${e?.stderr || ""}`;
       resolveGitRepository: () => resolveGitRepository,
       resolveInstanceContext: () => resolveInstanceContext,
       resolveInstanceDir: () => resolveInstanceDir,
+      resolveInterruptCapability: () => resolveInterruptCapability,
       resolveMagiSessionCleanupMode: () => resolveMagiSessionCleanupMode,
       resolveMaxParallelTasks: () => resolveMaxParallelTasks,
       resolveMeshHostStatus: () => resolveMeshHostStatus,
@@ -82924,6 +83487,7 @@ ${e?.stderr || ""}`;
       supportsUnicodeSymbols: () => supportsUnicodeSymbols,
       sweepMeshGraphGateTimeouts: () => sweepMeshGraphGateTimeouts,
       taskDependenciesSatisfied: () => taskDependenciesSatisfied,
+      taskIsParked: () => taskIsParked,
       tombstoneOperatingNote: () => tombstoneOperatingNote,
       totalTokens: () => totalTokens,
       triggerMeshQueue: () => triggerMeshQueue,
@@ -85421,6 +85985,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();
@@ -86020,6 +86586,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 {
@@ -86186,6 +86758,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.";
@@ -101993,6 +102606,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
@@ -110608,6 +111267,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}`);
           }
@@ -110770,7 +111462,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,
@@ -118391,7 +119083,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) {