@adhdev/daemon-standalone 1.0.56-rc.6 → 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 ? "d143fc7369d10b184b4cad79ce3a4240bc811faf" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "d143fc73" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.56-rc.6" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-19T09:46:30.077Z" : void 0);
+      const commit = readInjected(true ? "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,
@@ -59520,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),
@@ -59565,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,
@@ -59910,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, {
@@ -59919,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();
@@ -65073,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);
@@ -65577,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);
@@ -65652,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",
@@ -65698,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({
@@ -65731,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";
@@ -65746,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",
@@ -65768,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
@@ -65786,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) {
@@ -66194,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);
@@ -66298,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) {
@@ -66407,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).
@@ -66727,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;
@@ -66771,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(
@@ -66821,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,
@@ -66865,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 } : {}
           }
@@ -66878,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) {
@@ -66929,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";
@@ -66949,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);
       });
     }
@@ -66980,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 };
     }
@@ -67054,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,
@@ -67207,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 {
@@ -67233,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";
@@ -67254,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, components.providerLoader) }
-        ).map((c) => c.node);
-        const skippedCandidates = [];
-        const SKIPPED_CANDIDATES_MAX = 5;
-        const markSkip = (nodeIdForSkip, reason, extra) => {
-          markAutoLaunch(meshId, task.id, { status: "skipped", reason, nodeId: nodeIdForSkip, ...extra || {} });
-          if (nodeIdForSkip && skippedCandidates.length < SKIPPED_CANDIDATES_MAX) {
-            skippedCandidates.push({ nodeId: nodeIdForSkip, reason });
-          }
-        };
-        for (const node of orderedCandidateNodes) {
-          const nodeId = readMeshNodeId(node);
-          if (!nodeId) continue;
-          const launchKey = `${meshId}:${nodeId}`;
-          const now = Date.now();
-          const cooldownUntil = autoLaunchCooldownUntil.get(launchKey) || 0;
-          if (cooldownUntil > 0 && now >= cooldownUntil) autoLaunchCooldownUntil.delete(launchKey);
-          if (autoLaunchInProgress.has(launchKey)) {
-            markSkip(nodeId, "auto_launch_in_progress");
-            continue;
-          }
-          if (now < cooldownUntil) {
-            markSkip(nodeId, "auto_launch_cooldown");
-            continue;
-          }
-          if (isDirtyNode(node)) {
-            markSkip(nodeId, "dirty_workspace");
-            continue;
-          }
-          if (!isLaunchableNode(node)) {
-            markSkip(nodeId, "node_health_not_launchable");
-            continue;
-          }
-          if (!isMeshNodeFreshEnoughToLaunch(node, freshnessGate)) {
-            markSkip(nodeId, "node_stale_behind_upstream");
             continue;
           }
-          const launchTarget = resolveAutoLaunchTarget(components, node);
-          if (launchTarget.mode === "skip") {
-            markSkip(nodeId, launchTarget.reason || "auto_launch_unavailable");
-            autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
-            sweepExpiredCooldowns();
-            continue;
-          }
-          if (nodeHasLiveSessionPendingClaim(components, meshId, nodeId, task, node)) {
-            markSkip(nodeId, "node_has_live_session_pending_claim");
-            continue;
-          }
-          if (!isTaskReadonly(task) && nodeHasActiveAssignment(meshId, nodeId)) {
-            markSkip(nodeId, "node_has_active_assignment");
+          if (task.targetSessionId) {
+            const deadTarget = resolveDeadTargetVerdict(components, meshId, mesh, task);
+            if (deadTarget.dead) {
+              const requeued = requeueTask(meshId, task.id, {
+                reason: deadTarget.reason,
+                clearTargetSession: true,
+                // Keep the node pin if only the SESSION died on a still-live node; clear it
+                // when the NODE itself is absent (nothing to pin to).
+                clearTargetNode: deadTarget.nodeDead
+              });
+              if (requeued) {
+                noteTargetPinCleared(deadTarget.reason);
+                LOG2.warn("MeshQueue", `DEAD-TARGET-SELFHEAL: task ${task.id} (mesh ${meshId}) was pinned to a dead target (${deadTarget.reason}); requeued${deadTarget.nodeDead ? " and unpinned node" : ""} (requeueCount=${requeued.requeueCount ?? "?"}, status=${requeued.status}).`);
+              }
+              markAutoLaunch(meshId, task.id, { status: "skipped", reason: "target_session_dead_requeued" });
+              continue;
+            }
+            if (parkExpiredTargetPin(meshId, task, resolveTargetPinTtlVerdict(components, task), TARGET_SESSION_PIN_TTL_MS, (m, t, r) => parkTaskTargetPin(m, t, { reason: r }))) {
+              markAutoLaunch(meshId, task.id, { status: "skipped", reason: PARKED_SKIP_REASON });
+              continue;
+            }
+            markAutoLaunch(meshId, task.id, { status: "skipped", reason: "target_session_constraint" });
             continue;
           }
-          const maxConcurrentSessions = Number(node?.policy?.maxConcurrentSessions);
-          if (Number.isFinite(maxConcurrentSessions) && maxConcurrentSessions >= 0 && liveSessionCountForNode(components, meshId, nodeId) >= maxConcurrentSessions) {
-            markSkip(nodeId, "max_concurrent_sessions_reached");
+          if (task.autoLaunch?.status === "completed" && task.autoLaunch.sessionId) {
+            const launchedAtMs = Date.parse(task.autoLaunch.updatedAt);
+            const alSessionId = readNonEmptyString(task.autoLaunch.sessionId);
+            const alNodeId = readNonEmptyString(task.autoLaunch.nodeId);
+            const alProvider = readNonEmptyString(task.autoLaunch.providerType);
+            if (Number.isFinite(launchedAtMs) && Date.now() - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS) {
+              recordAutoLaunchEvent(meshId, { phase: "skipped", taskId: task.id, reason: "awaiting_launched_session_claim", nodeId: alNodeId, sessionId: alSessionId });
+              continue;
+            }
+            if (Number.isFinite(launchedAtMs) && alSessionId && alNodeId) {
+              const outcome = driveExpiredAwaitClaim(components, meshId, task, { sessionId: alSessionId, nodeId: alNodeId, providerType: alProvider });
+              if (outcome === "claimed" || outcome === "fallback") return true;
+              if (outcome === "backoff") continue;
+            }
+          }
+          const candidateNodes = Array.isArray(mesh?.nodes) ? mesh.nodes.filter((node) => {
+            if (task.targetNodeId && !meshNodeIdMatches(node, task.targetNodeId)) return false;
+            if (task.taskMode === "convergence" && node?.isLocalWorktree === true) return false;
+            if (task.requiredTags?.length) {
+              const slotProviders = resolveNodeCapabilitySlots(node, meshId).map((s2) => s2.provider).filter(Boolean);
+              const priorities = slotProviders.length ? slotProviders : normalizeProviderPriority2(node?.policy);
+              const providerCandidates = priorities.length ? priorities : [void 0];
+              return providerCandidates.some(
+                (p) => nodeSatisfiesRequiredTags(task.requiredTags, buildMeshNodeCapabilityTags(node, p))
+              );
+            }
+            return true;
+          }) : [];
+          if (!candidateNodes.length) {
+            const targetPinUnmatched = !!task.targetNodeId && !(Array.isArray(mesh?.nodes) && mesh.nodes.some((n) => meshNodeIdMatches(n, task.targetNodeId)));
+            const convergenceOntoWorktree = task.taskMode === "convergence" && Array.isArray(mesh?.nodes) && (() => {
+              const matched = mesh.nodes.filter((n) => !task.targetNodeId || meshNodeIdMatches(n, task.targetNodeId));
+              return matched.length > 0 && matched.every((n) => n?.isLocalWorktree === true);
+            })();
+            const targetTransientlyUnresolved = targetPinUnmatched && isTargetNodeTransientlyUnresolved(mesh, task);
+            markAutoLaunch(meshId, task.id, {
+              status: "skipped",
+              reason: convergenceOntoWorktree ? "mesh_convergence_target_is_worktree" : targetTransientlyUnresolved ? TRANSIENT_TARGET_NODE_BOOTSTRAP_PENDING_REASON : targetPinUnmatched ? "target_node_id_unmatched" : "no_node_satisfies_required_tags",
+              nodeId: task.targetNodeId
+            });
             continue;
           }
-          autoLaunchInProgress.add(launchKey);
-          try {
-            const resolved = await resolveUsableProvider(components, nodeId, node, meshId, task.requiredTags, { difficulty: task.difficulty, requiredTags: task.requiredTags }, mesh?.policy?.quotaRouting ?? null, quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader), task.id);
-            if (!resolved.providerType) {
-              markSkip(nodeId, resolved.reason || "provider_unusable");
+          const strategy = resolveSchedulingStrategy(mesh);
+          const orderedCandidateNodes = strategy === "first_eligible" ? candidateNodes : orderEligibleNodes(
+            meshId,
+            strategy,
+            candidateNodes.map((node, index) => ({ nodeId: readMeshNodeId(node), node, index })).filter((c) => c.nodeId),
+            // Auto-launch drains one task at a time, so the task IS in scope here —
+            // pass it through for the 'fitness' strategy's task→slot ranking. The
+            // mesh's quotaRouting thresholds ride along so the fitness score can
+            // include the quota-headroom spread bonus (fail-open when unset).
+            { bumpCursor: true, task: { difficulty: task.difficulty, requiredTags: task.requiredTags }, quotaRouting: mesh?.policy?.quotaRouting ?? null, quotaFactsContext: quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader) }
+          ).map((c) => c.node);
+          const skippedCandidates = [];
+          const SKIPPED_CANDIDATES_MAX = 5;
+          const markSkip = (nodeIdForSkip, reason, extra) => {
+            markAutoLaunch(meshId, task.id, { status: "skipped", reason, nodeId: nodeIdForSkip, ...extra || {} });
+            if (nodeIdForSkip && skippedCandidates.length < SKIPPED_CANDIDATES_MAX) {
+              skippedCandidates.push({ nodeId: nodeIdForSkip, reason });
+            }
+          };
+          for (const node of orderedCandidateNodes) {
+            const nodeId = readMeshNodeId(node);
+            if (!nodeId) continue;
+            const launchKey = `${meshId}:${nodeId}`;
+            const now = Date.now();
+            const cooldownUntil = autoLaunchCooldownUntil.get(launchKey) || 0;
+            if (cooldownUntil > 0 && now >= cooldownUntil) autoLaunchCooldownUntil.delete(launchKey);
+            if (autoLaunchInProgress.has(launchKey)) {
+              markSkip(nodeId, "auto_launch_in_progress");
               continue;
             }
-            const slotCoversDifficulty = slotCoversTaskDifficulty(resolved.slot, task.difficulty);
-            const requestedModel = resolveLaunchAxis(task.model, task.modelSource, resolved.model, slotCoversDifficulty);
-            const effectiveThinkingLevel = resolveLaunchAxis(task.thinkingLevel, task.thinkingLevelSource, resolved.thinkingLevel, slotCoversDifficulty);
-            const slotDecision = decideSlotForModel({
-              requestedModel,
-              slots: resolveNodeCapabilitySlots(node, meshId).map((slot) => ({
-                slot,
-                available: slotHasCapacity(meshId, nodeId, node, slot, mesh?.nodes, isReadonly)
-              }))
-            });
-            if (slotDecision.outcome === "wait") {
-              LOG2.info("MeshQueue", `SLOT MODEL GUARD: model '${requestedModel}' is declared on node ${nodeId} but every matching slot is at its maxParallel cap (task ${task.id}); leaving the task queued until a slot goes idle`);
-              markSkip(nodeId, slotDecision.reason, { providerType: resolved.providerType });
+            if (now < cooldownUntil) {
+              markSkip(nodeId, "auto_launch_cooldown");
               continue;
             }
-            if (slotDecision.outcome === "notify") {
-              LOG2.warn("MeshQueue", `SLOT MODEL GUARD: no slot on node ${nodeId} declares model '${requestedModel}' (declared: ${slotDecision.declaredModels.join(", ") || "none"}) for task ${task.id}; not launching \u2014 surfacing to the coordinator to re-drive`);
-              markSkip(nodeId, slotDecision.reason, { providerType: resolved.providerType });
+            if (isDirtyNode(node)) {
+              markSkip(nodeId, "dirty_workspace");
               continue;
             }
-            const rawEffectiveModel = slotDecision.model;
-            const winningModel = resolved.slot?.model?.trim() || void 0;
-            const finalizedModel = slotDecision.slot.model?.trim() || void 0;
-            const slotWasDemoted = resolved.slot?.provider !== slotDecision.slot.provider || winningModel !== finalizedModel;
-            const demotionReason = slotWasDemoted ? slotHasCapacity(meshId, nodeId, node, resolved.slot, mesh?.nodes, isReadonly) ? "slot_reselected_during_launch" : "winning_slot_capacity_exhausted" : void 0;
-            const effectiveModel = isModelCompatibleWithProvider(rawEffectiveModel, resolved.providerType) ? rawEffectiveModel : void 0;
-            if (rawEffectiveModel && effectiveModel === void 0) {
-              LOG2.info("MeshQueue", `CODEX-400 GUARD: dropped incompatible launch model '${rawEffectiveModel}' for non-Anthropic provider '${resolved.providerType}' on node ${nodeId} (task ${task.id}); provider will use its own default model`);
-            }
-            const providerCap = effectiveSlotCap(
-              resolveProviderMaxParallel(resolveNodeCapabilitySlots(node, meshId), resolved.providerType),
-              isReadonly
-            );
-            if (providerCap !== void 0 && activeProviderAssignedCount(
-              meshId,
-              nodeId,
-              resolved.providerType,
-              resolveDaemonSiblingNodeIds(nodeId, mesh?.nodes)
-            ) >= providerCap) {
-              markSkip(nodeId, "max_provider_parallel_reached", { providerType: resolved.providerType });
+            if (!isLaunchableNode(node)) {
+              markSkip(nodeId, "node_health_not_launchable");
               continue;
             }
-            const launchSettings = {
-              // Worker launch envelope: role + mesh context so worker can route completion events.
-              role: "worker",
-              meshNodeFor: meshId,
-              meshNodeId: nodeId,
-              spawnedSessionVisibility: mesh?.policy?.spawnedSessionVisibility || "hidden",
-              // Coordinator-dispatched worker: auto-approve unless mesh/node policy
-              // opts out (default true). Lands in settingsOverride and beats the
-              // global per-provider-type boolean/mode through explicit opposite-key clearing.
-              ...delegatedWorkerAutoApproveSettingsForNode(
-                mesh,
-                node,
-                components.providerLoader?.getMeta(resolved.providerType),
-                resolved.providerType
-              ),
-              launchedByCoordinator: true,
-              autoLaunchedForQueueTaskId: task.id
-            };
-            if (launchTarget.mode === "remote") {
-              const remoteSettings = {
-                ...launchSettings,
-                meshCoordinatorDaemonId: launchTarget.coordinatorDaemonId,
-                meshCoordinatorNodeId: nodeId
+            if (!isMeshNodeFreshEnoughToLaunch(node, freshnessGate)) {
+              markSkip(nodeId, "node_stale_behind_upstream");
+              continue;
+            }
+            const launchTarget = resolveAutoLaunchTarget(components, node);
+            if (launchTarget.mode === "skip") {
+              markSkip(nodeId, launchTarget.reason || "auto_launch_unavailable");
+              autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
+              sweepExpiredCooldowns();
+              continue;
+            }
+            if (nodeHasLiveSessionPendingClaim(components, meshId, nodeId, task, node)) {
+              markSkip(nodeId, "node_has_live_session_pending_claim");
+              continue;
+            }
+            if (!isTaskReadonly(task) && nodeHasActiveAssignment(meshId, nodeId)) {
+              markSkip(nodeId, "node_has_active_assignment");
+              continue;
+            }
+            const maxConcurrentSessions = Number(node?.policy?.maxConcurrentSessions);
+            if (Number.isFinite(maxConcurrentSessions) && maxConcurrentSessions >= 0 && liveSessionCountForNode(components, meshId, nodeId) >= maxConcurrentSessions) {
+              markSkip(nodeId, "max_concurrent_sessions_reached");
+              continue;
+            }
+            autoLaunchInProgress.add(launchKey);
+            try {
+              const resolved = await resolveUsableProvider(components, nodeId, node, meshId, task.requiredTags, { difficulty: task.difficulty, requiredTags: task.requiredTags }, mesh?.policy?.quotaRouting ?? null, quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader), task.id);
+              if (!resolved.providerType) {
+                markSkip(nodeId, resolved.reason || "provider_unusable");
+                continue;
+              }
+              const slotCoversDifficulty = slotCoversTaskDifficulty(resolved.slot, task.difficulty);
+              const requestedModel = resolveLaunchAxis(task.model, task.modelSource, resolved.model, slotCoversDifficulty);
+              const effectiveThinkingLevel = resolveLaunchAxis(task.thinkingLevel, task.thinkingLevelSource, resolved.thinkingLevel, slotCoversDifficulty);
+              const slotDecision = decideSlotForModel({
+                requestedModel,
+                slots: resolveNodeCapabilitySlots(node, meshId).map((slot) => ({
+                  slot,
+                  available: slotHasCapacity(meshId, nodeId, node, slot, mesh?.nodes, isReadonly)
+                }))
+              });
+              if (slotDecision.outcome === "wait") {
+                LOG2.info("MeshQueue", `SLOT MODEL GUARD: model '${requestedModel}' is declared on node ${nodeId} but every matching slot is at its maxParallel cap (task ${task.id}); leaving the task queued until a slot goes idle`);
+                markSkip(nodeId, slotDecision.reason, { providerType: resolved.providerType });
+                continue;
+              }
+              if (slotDecision.outcome === "notify") {
+                LOG2.warn("MeshQueue", `SLOT MODEL GUARD: no slot on node ${nodeId} declares model '${requestedModel}' (declared: ${slotDecision.declaredModels.join(", ") || "none"}) for task ${task.id}; not launching \u2014 surfacing to the coordinator to re-drive`);
+                markSkip(nodeId, slotDecision.reason, { providerType: resolved.providerType });
+                continue;
+              }
+              const rawEffectiveModel = slotDecision.model;
+              const winningModel = resolved.slot?.model?.trim() || void 0;
+              const finalizedModel = slotDecision.slot.model?.trim() || void 0;
+              const slotWasDemoted = resolved.slot?.provider !== slotDecision.slot.provider || winningModel !== finalizedModel;
+              const demotionReason = slotWasDemoted ? slotHasCapacity(meshId, nodeId, node, resolved.slot, mesh?.nodes, isReadonly) ? "slot_reselected_during_launch" : "winning_slot_capacity_exhausted" : void 0;
+              const effectiveModel = isModelCompatibleWithProvider(rawEffectiveModel, resolved.providerType) ? rawEffectiveModel : void 0;
+              if (rawEffectiveModel && effectiveModel === void 0) {
+                LOG2.info("MeshQueue", `CODEX-400 GUARD: dropped incompatible launch model '${rawEffectiveModel}' for non-Anthropic provider '${resolved.providerType}' on node ${nodeId} (task ${task.id}); provider will use its own default model`);
+              }
+              const providerCap = effectiveSlotCap(
+                resolveProviderMaxParallel(resolveNodeCapabilitySlots(node, meshId), resolved.providerType),
+                isReadonly
+              );
+              if (providerCap !== void 0 && activeProviderAssignedCount(
+                meshId,
+                nodeId,
+                resolved.providerType,
+                resolveDaemonSiblingNodeIds(nodeId, mesh?.nodes)
+              ) >= providerCap) {
+                markSkip(nodeId, "max_provider_parallel_reached", { providerType: resolved.providerType });
+                continue;
+              }
+              const launchSettings = {
+                // Worker launch envelope: role + mesh context so worker can route completion events.
+                role: "worker",
+                meshNodeFor: meshId,
+                meshNodeId: nodeId,
+                spawnedSessionVisibility: mesh?.policy?.spawnedSessionVisibility || "hidden",
+                // Coordinator-dispatched worker: auto-approve unless mesh/node policy
+                // opts out (default true). Lands in settingsOverride and beats the
+                // global per-provider-type boolean/mode through explicit opposite-key clearing.
+                ...delegatedWorkerAutoApproveSettingsForNode(
+                  mesh,
+                  node,
+                  components.providerLoader?.getMeta(resolved.providerType),
+                  resolved.providerType
+                ),
+                launchedByCoordinator: true,
+                autoLaunchedForQueueTaskId: task.id
               };
+              if (launchTarget.mode === "remote") {
+                const remoteSettings = {
+                  ...launchSettings,
+                  meshCoordinatorDaemonId: launchTarget.coordinatorDaemonId,
+                  meshCoordinatorNodeId: nodeId
+                };
+                markAutoLaunch(meshId, task.id, { status: "started", nodeId, providerType: resolved.providerType, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
+                let launchResult2;
+                try {
+                  launchResult2 = await components.dispatchMeshCommand(launchTarget.daemonId, "launch_cli", withStatusProbeMarker({
+                    cliType: resolved.providerType,
+                    dir: node.workspace,
+                    settings: remoteSettings,
+                    // MAGI-KIND-PANEL model axis: forward the task's model override so the
+                    // remote worker session launches with it (initialModel). Best-effort.
+                    // Slot-aware: task override wins, else the matched slot's model.
+                    ...effectiveModel ? { initialModel: effectiveModel } : {},
+                    // BRAIN-ROUTING thinking axis: forward the effective thinking level (initialThinkingLevel).
+                    ...effectiveThinkingLevel ? { initialThinkingLevel: effectiveThinkingLevel } : {}
+                  }));
+                } catch (e) {
+                  markAutoLaunch(meshId, task.id, { status: "failed", reason: `remote_launch_dispatch_failed: ${e?.message || String(e)}`, nodeId, providerType: resolved.providerType });
+                  autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
+                  sweepExpiredCooldowns();
+                  return false;
+                }
+                const payload = launchResult2 && typeof launchResult2 === "object" && "payload" in launchResult2 && launchResult2.payload && typeof launchResult2.payload === "object" ? launchResult2.payload : launchResult2;
+                if (!payload?.success) {
+                  const reason = readNonEmptyString(payload?.error) || "remote_launch_cli_failed";
+                  markAutoLaunch(meshId, task.id, { status: "failed", reason, nodeId, providerType: resolved.providerType });
+                  autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
+                  sweepExpiredCooldowns();
+                  return false;
+                }
+                const remoteSessionId = readNonEmptyString(payload.sessionId) || readNonEmptyString(payload.id) || readNonEmptyString(payload.runtimeSessionId);
+                markAutoLaunch(meshId, task.id, { status: "completed", nodeId, providerType: resolved.providerType, sessionId: remoteSessionId || void 0, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
+                logAutoLaunchQuotaFallbackSuccess(resolved, task.id, nodeId, remoteSessionId || void 0);
+                autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
+                sweepExpiredCooldowns();
+                return true;
+              }
               markAutoLaunch(meshId, task.id, { status: "started", nodeId, providerType: resolved.providerType, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
-              let launchResult2;
-              try {
-                launchResult2 = await components.dispatchMeshCommand(launchTarget.daemonId, "launch_cli", withStatusProbeMarker({
-                  cliType: resolved.providerType,
-                  dir: node.workspace,
-                  settings: remoteSettings,
-                  // MAGI-KIND-PANEL model axis: forward the task's model override so the
-                  // remote worker session launches with it (initialModel). Best-effort.
-                  // Slot-aware: task override wins, else the matched slot's model.
-                  ...effectiveModel ? { initialModel: effectiveModel } : {},
-                  // BRAIN-ROUTING thinking axis: forward the effective thinking level (initialThinkingLevel).
-                  ...effectiveThinkingLevel ? { initialThinkingLevel: effectiveThinkingLevel } : {}
-                }));
-              } catch (e) {
-                markAutoLaunch(meshId, task.id, { status: "failed", reason: `remote_launch_dispatch_failed: ${e?.message || String(e)}`, nodeId, providerType: resolved.providerType });
+              const launchResult = await components.cliManager.handleCliCommand("launch_cli", {
+                cliType: resolved.providerType,
+                dir: node.workspace,
+                settings: launchSettings,
+                // MAGI-KIND-PANEL model axis: local launch forwards the effective model
+                // (task override, else matched slot) as initialModel (CLI → modelLaunchArgs; ACP → setConfigOption).
+                ...effectiveModel ? { initialModel: effectiveModel } : {},
+                // BRAIN-ROUTING thinking axis: forward the effective thinking level (initialThinkingLevel).
+                ...effectiveThinkingLevel ? { initialThinkingLevel: effectiveThinkingLevel } : {}
+              });
+              if (!launchResult?.success) {
+                const reason = launchResult?.error || "launch_cli_failed";
+                markAutoLaunch(meshId, task.id, { status: "failed", reason, nodeId, providerType: resolved.providerType });
                 autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
                 sweepExpiredCooldowns();
                 return false;
               }
-              const payload = launchResult2 && typeof launchResult2 === "object" && "payload" in launchResult2 && launchResult2.payload && typeof launchResult2.payload === "object" ? launchResult2.payload : launchResult2;
-              if (!payload?.success) {
-                const reason = readNonEmptyString(payload?.error) || "remote_launch_cli_failed";
-                markAutoLaunch(meshId, task.id, { status: "failed", reason, nodeId, providerType: resolved.providerType });
+              const sessionId = readNonEmptyString(launchResult.sessionId) || readNonEmptyString(launchResult.id) || readNonEmptyString(launchResult.runtimeSessionId);
+              if (!sessionId) {
+                markAutoLaunch(meshId, task.id, { status: "failed", reason: "launch_missing_session_id", nodeId, providerType: resolved.providerType });
                 autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
                 sweepExpiredCooldowns();
                 return false;
               }
-              const remoteSessionId = readNonEmptyString(payload.sessionId) || readNonEmptyString(payload.id) || readNonEmptyString(payload.runtimeSessionId);
-              markAutoLaunch(meshId, task.id, { status: "completed", nodeId, providerType: resolved.providerType, sessionId: remoteSessionId || void 0, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
-              logAutoLaunchQuotaFallbackSuccess(resolved, task.id, nodeId, remoteSessionId || void 0);
-              autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
-              sweepExpiredCooldowns();
+              markAutoLaunch(meshId, task.id, { status: "completed", nodeId, providerType: resolved.providerType, sessionId, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
+              logAutoLaunchQuotaFallbackSuccess(resolved, task.id, nodeId, sessionId);
+              await waitForLocalSessionReady(components, sessionId);
+              const requiredTags = Array.isArray(task.requiredTags) ? task.requiredTags.filter((t) => !!t) : [];
+              const routingDecision = buildAutoLaunchRoutingDecision({
+                node,
+                meshId,
+                task: { difficulty: task.difficulty, requiredTags: task.requiredTags },
+                resolved,
+                quotaRouting: mesh?.policy?.quotaRouting ?? null,
+                quotaFactsContext: quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader),
+                skippedCandidates,
+                requiredTagsResult: {
+                  required: requiredTags,
+                  satisfied: !requiredTags.length || nodeSatisfiesRequiredTags(requiredTags, buildMeshNodeCapabilityTags(node, resolved.providerType)),
+                  missing: requiredTags.filter((t) => !buildMeshNodeCapabilityTags(node, resolved.providerType).includes(t))
+                },
+                effectiveModel,
+                effectiveThinkingLevel,
+                executedSlot: slotDecision.slot,
+                demotionReason
+              });
+              tryAssignQueueTask(components, meshId, nodeId, sessionId, resolved.providerType, routingDecision);
               return true;
-            }
-            markAutoLaunch(meshId, task.id, { status: "started", nodeId, providerType: resolved.providerType, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
-            const launchResult = await components.cliManager.handleCliCommand("launch_cli", {
-              cliType: resolved.providerType,
-              dir: node.workspace,
-              settings: launchSettings,
-              // MAGI-KIND-PANEL model axis: local launch forwards the effective model
-              // (task override, else matched slot) as initialModel (CLI → modelLaunchArgs; ACP → setConfigOption).
-              ...effectiveModel ? { initialModel: effectiveModel } : {},
-              // BRAIN-ROUTING thinking axis: forward the effective thinking level (initialThinkingLevel).
-              ...effectiveThinkingLevel ? { initialThinkingLevel: effectiveThinkingLevel } : {}
-            });
-            if (!launchResult?.success) {
-              const reason = launchResult?.error || "launch_cli_failed";
-              markAutoLaunch(meshId, task.id, { status: "failed", reason, nodeId, providerType: resolved.providerType });
-              autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
-              sweepExpiredCooldowns();
-              return false;
-            }
-            const sessionId = readNonEmptyString(launchResult.sessionId) || readNonEmptyString(launchResult.id) || readNonEmptyString(launchResult.runtimeSessionId);
-            if (!sessionId) {
-              markAutoLaunch(meshId, task.id, { status: "failed", reason: "launch_missing_session_id", nodeId, providerType: resolved.providerType });
+            } catch (e) {
+              markAutoLaunch(meshId, task.id, { status: "failed", error: e?.message || String(e), nodeId });
               autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
-              sweepExpiredCooldowns();
               return false;
+            } finally {
+              autoLaunchInProgress.delete(launchKey);
             }
-            markAutoLaunch(meshId, task.id, { status: "completed", nodeId, providerType: resolved.providerType, sessionId, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
-            logAutoLaunchQuotaFallbackSuccess(resolved, task.id, nodeId, sessionId);
-            await waitForLocalSessionReady(components, sessionId);
-            const requiredTags = Array.isArray(task.requiredTags) ? task.requiredTags.filter((t) => !!t) : [];
-            const routingDecision = buildAutoLaunchRoutingDecision({
-              node,
-              meshId,
-              task: { difficulty: task.difficulty, requiredTags: task.requiredTags },
-              resolved,
-              quotaRouting: mesh?.policy?.quotaRouting ?? null,
-              quotaFactsContext: quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader),
-              skippedCandidates,
-              requiredTagsResult: {
-                required: requiredTags,
-                satisfied: !requiredTags.length || nodeSatisfiesRequiredTags(requiredTags, buildMeshNodeCapabilityTags(node, resolved.providerType)),
-                missing: requiredTags.filter((t) => !buildMeshNodeCapabilityTags(node, resolved.providerType).includes(t))
-              },
-              effectiveModel,
-              effectiveThinkingLevel,
-              executedSlot: slotDecision.slot,
-              demotionReason
-            });
-            tryAssignQueueTask(components, meshId, nodeId, sessionId, resolved.providerType, routingDecision);
-            return true;
-          } catch (e) {
-            markAutoLaunch(meshId, task.id, { status: "failed", error: e?.message || String(e), nodeId });
-            autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
-            return false;
-          } finally {
-            autoLaunchInProgress.delete(launchKey);
           }
+        } finally {
+          autoLaunchTaskInProgress.delete(taskLaunchKey);
         }
       }
       return false;
@@ -67627,7 +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,
@@ -67700,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;
@@ -67758,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";
@@ -67796,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;
@@ -67811,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) {
@@ -70550,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;
@@ -71187,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
           }
@@ -82466,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,
@@ -82475,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,
@@ -82500,6 +82964,7 @@ ${e?.stderr || ""}`;
       DaemonStatusReporter: () => DaemonStatusReporter,
       DevServer: () => DevServer,
       DuplicateMeshDispatchError: () => DuplicateMeshDispatchError,
+      ESC: () => ESC,
       FsmDriver: () => FsmDriver,
       GOAL_PREVIEW_MAX: () => GOAL_PREVIEW_MAX,
       GitCommandError: () => GitCommandError,
@@ -82554,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,
@@ -82567,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,
@@ -82617,6 +83087,7 @@ ${e?.stderr || ""}`;
       buildMissionPromptSection: () => buildMissionPromptSection,
       buildOrphanedPinNotice: () => buildOrphanedPinNotice,
       buildP2pRelayFailurePayload: () => buildP2pRelayFailurePayload,
+      buildParkedTaskNotice: () => buildParkedTaskNotice,
       buildPinnedGlobalInstallCommand: () => buildPinnedGlobalInstallCommand,
       buildRuntimeSystemChatMessage: () => buildRuntimeSystemChatMessage,
       buildSessionEntries: () => buildSessionEntries,
@@ -82696,6 +83167,7 @@ ${e?.stderr || ""}`;
       evaluateProviderQuotaGate: () => evaluateProviderQuotaGate,
       execNpmCommandSync: () => execNpmCommandSync,
       expandDaemonIdForms: () => expandDaemonIdForms,
+      failRetentionExpiredParkedTask: () => failRetentionExpiredParkedTask,
       fastForwardMeshNode: () => fastForwardMeshNode,
       fetchAntigravityQuota: () => fetchAntigravityQuota2,
       fetchClaudeQuota: () => fetchClaudeQuota2,
@@ -82748,6 +83220,7 @@ ${e?.stderr || ""}`;
       getMeshStatusMissionSummaries: () => getMeshStatusMissionSummaries,
       getMeshStatusMissionsCompact: () => getMeshStatusMissionsCompact,
       getNpmExecOptions: () => getNpmExecOptions,
+      getParkedTasks: () => getParkedTasks,
       getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
       getProcessInstanceContext: () => getProcessInstanceContext,
       getQueue: () => getQueue,
@@ -82847,6 +83320,7 @@ ${e?.stderr || ""}`;
       normalizeChatMessageKind: () => normalizeChatMessageKind,
       normalizeChatMessages: () => normalizeChatMessages,
       normalizeChatTailActiveModal: () => normalizeChatTailActiveModal,
+      normalizeDeliveryMode: () => normalizeDeliveryMode,
       normalizeGitOutput: () => normalizeGitOutput,
       normalizeGitWorkspaceSubscriptionParams: () => normalizeGitWorkspaceSubscriptionParams2,
       normalizeInputEnvelope: () => normalizeInputEnvelope,
@@ -82867,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,
@@ -82951,6 +83429,7 @@ ${e?.stderr || ""}`;
       resolveGitRepository: () => resolveGitRepository,
       resolveInstanceContext: () => resolveInstanceContext,
       resolveInstanceDir: () => resolveInstanceDir,
+      resolveInterruptCapability: () => resolveInterruptCapability,
       resolveMagiSessionCleanupMode: () => resolveMagiSessionCleanupMode,
       resolveMaxParallelTasks: () => resolveMaxParallelTasks,
       resolveMeshHostStatus: () => resolveMeshHostStatus,
@@ -83008,6 +83487,7 @@ ${e?.stderr || ""}`;
       supportsUnicodeSymbols: () => supportsUnicodeSymbols,
       sweepMeshGraphGateTimeouts: () => sweepMeshGraphGateTimeouts,
       taskDependenciesSatisfied: () => taskDependenciesSatisfied,
+      taskIsParked: () => taskIsParked,
       tombstoneOperatingNote: () => tombstoneOperatingNote,
       totalTokens: () => totalTokens,
       triggerMeshQueue: () => triggerMeshQueue,
@@ -85505,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();
@@ -86104,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 {
@@ -86270,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.";
@@ -102077,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
@@ -110692,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}`);
           }
@@ -110854,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,
@@ -118475,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) {