@adhdev/daemon-standalone 1.0.43 → 1.0.44-rc.2

package/dist/index.js

@@ -31423,9 +31423,9 @@ var require_streamx = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/b4a/index.js
+// ../../node_modules/tar-stream/node_modules/b4a/index.js
 var require_b4a2 = __commonJS({
-  "../daemon-core/node_modules/b4a/index.js"(exports2, module2) {
+  "../../node_modules/tar-stream/node_modules/b4a/index.js"(exports2, module2) {
     "use strict";
     function isBuffer(value) {
       return Buffer.isBuffer(value) || value instanceof Uint8Array;
@@ -31581,9 +31581,9 @@ var require_b4a2 = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-stream/headers.js
+// ../../node_modules/tar-stream/headers.js
 var require_headers = __commonJS({
-  "../daemon-core/node_modules/tar-stream/headers.js"(exports2) {
+  "../../node_modules/tar-stream/headers.js"(exports2) {
     "use strict";
     var b4a = require_b4a2();
     var ZEROS = "0000000000000000000";
@@ -31844,9 +31844,9 @@ var require_headers = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-stream/extract.js
+// ../../node_modules/tar-stream/extract.js
 var require_extract = __commonJS({
-  "../daemon-core/node_modules/tar-stream/extract.js"(exports2, module2) {
+  "../../node_modules/tar-stream/extract.js"(exports2, module2) {
     "use strict";
     var { Writable, Readable, getStreamError } = require_streamx();
     var FIFO = require_fast_fifo();
@@ -32189,9 +32189,9 @@ var require_extract = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-stream/constants.js
+// ../../node_modules/tar-stream/constants.js
 var require_constants = __commonJS({
-  "../daemon-core/node_modules/tar-stream/constants.js"(exports2, module2) {
+  "../../node_modules/tar-stream/constants.js"(exports2, module2) {
     "use strict";
     var constants = {
       // just for envs without fs
@@ -32210,9 +32210,9 @@ var require_constants = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-stream/pack.js
+// ../../node_modules/tar-stream/pack.js
 var require_pack = __commonJS({
-  "../daemon-core/node_modules/tar-stream/pack.js"(exports2, module2) {
+  "../../node_modules/tar-stream/pack.js"(exports2, module2) {
     "use strict";
     var { Readable, Writable, getStreamError } = require_streamx();
     var b4a = require_b4a2();
@@ -32445,9 +32445,9 @@ var require_pack = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-stream/index.js
+// ../../node_modules/tar-stream/index.js
 var require_tar_stream = __commonJS({
-  "../daemon-core/node_modules/tar-stream/index.js"(exports2) {
+  "../../node_modules/tar-stream/index.js"(exports2) {
     "use strict";
     exports2.extract = require_extract();
     exports2.pack = require_pack();
@@ -32690,9 +32690,9 @@ var require_pump = __commonJS({
   }
 });
 
-// ../daemon-core/node_modules/tar-fs/index.js
+// ../../node_modules/tar-fs/index.js
 var require_tar_fs = __commonJS({
-  "../daemon-core/node_modules/tar-fs/index.js"(exports2) {
+  "../../node_modules/tar-fs/index.js"(exports2) {
     "use strict";
     var tar = require_tar_stream();
     var pump = require_pump();
@@ -36556,10 +36556,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "f1fa888e818dbbc75fb7136f3d46d1a44c65b540" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "f1fa888" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.43" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-11T02:54:10.096Z" : void 0);
+      const commit = readInjected(true ? "648305378fc7e0a1970cfe964a80ce7a68172964" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "64830537" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.44-rc.2" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-11T08:23:49.936Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -37817,7 +37817,7 @@ var require_dist3 = __commonJS({
       }
     });
     function resolveBuildTrack(env2 = process.env) {
-      const injected = true ? "" : void 0;
+      const injected = true ? "preview" : void 0;
       const stamped = typeof injected === "string" ? injected.trim() : "";
       const raw = (stamped || (env2[BUILD_CHANNEL_ENV_VAR] ?? "").trim()).toLowerCase();
       return raw === "preview" || raw === "next" ? "preview" : "stable";
@@ -38723,7 +38723,7 @@ child.on('exit', () => process.exit(0));
       return typeof value === "boolean" ? value : fallback;
     }
     function resolveQuotaShowAccountEmail(parsed) {
-      const fallback = DEFAULT_CONFIG.quotaShowAccountEmail ?? true;
+      const fallback = DEFAULT_CONFIG.quotaShowAccountEmail ?? false;
       if (parsed.quotaShowAccountEmailSetByUser === true) {
         return asBoolean(parsed.quotaShowAccountEmail, fallback);
       }
@@ -38948,7 +38948,7 @@ child.on('exit', () => process.exit(0));
           // preview API instead of silently pinning stable.
           serverUrl: IDENTITY.serverUrl,
           allowServerApiProxy: false,
-          quotaShowAccountEmail: true,
+          quotaShowAccountEmail: false,
           selectedIde: null,
           configuredIdes: [],
           installedExtensions: [],
@@ -40271,7 +40271,7 @@ child.on('exit', () => process.exit(0));
       return Array.from(new Set(merged));
     }
     function npmGlobalPrefix() {
-      if (cachedNpmPrefix !== void 0) return cachedNpmPrefix ?? void 0;
+      if (cachedNpmPrefix !== void 0) return cachedNpmPrefix;
       try {
         const prefix = (0, import_child_process.execSync)("npm config get prefix", {
           encoding: "utf-8",
@@ -40279,11 +40279,10 @@ child.on('exit', () => process.exit(0));
           windowsHide: true,
           stdio: ["ignore", "pipe", "ignore"]
         }).trim();
-        cachedNpmPrefix = prefix && prefix !== "undefined" ? prefix : null;
+        if (prefix && prefix !== "undefined") cachedNpmPrefix = prefix;
       } catch {
-        cachedNpmPrefix = null;
       }
-      return cachedNpmPrefix ?? void 0;
+      return cachedNpmPrefix;
     }
     function windowsExtraBinDirs() {
       const dirs = [];
@@ -40658,7 +40657,6 @@ child.on('exit', () => process.exit(0));
         MESH_SEND_KEYS_MAX_ITEMS = 64;
         MESH_SEND_KEYS_MAX_TEXT_BYTES = 4096;
         buildCliSpawnEnv = import_session_host_core3.sanitizeSpawnEnv;
-        cachedNpmPrefix = void 0;
       }
     });
     function parseVersion(raw) {
@@ -41692,6 +41690,7 @@ ${error48.message || ""}`;
       DEFAULT_DIFFICULTY_BRAINS: () => DEFAULT_DIFFICULTY_BRAINS,
       MAGI_RAW_ANSWER_CAP: () => MAGI_RAW_ANSWER_CAP,
       MESH_TASK_DIFFICULTIES: () => MESH_TASK_DIFFICULTIES,
+      QUOTA_SUPPORTED_PROVIDERS: () => QUOTA_SUPPORTED_PROVIDERS,
       STATUS_PROBE_ARG_KEY: () => STATUS_PROBE_ARG_KEY,
       UNKNOWN_CLI_SLOT_RECIPE: () => UNKNOWN_CLI_SLOT_RECIPE,
       argsCarryStatusProbeMarker: () => argsCarryStatusProbeMarker,
@@ -41733,6 +41732,7 @@ ${error48.message || ""}`;
       sessionIdsEquivalent: () => sessionIdsEquivalent,
       stripStatusProbeMarker: () => stripStatusProbeMarker,
       summarizeGitShape: () => summarizeGitShape,
+      supportsQuota: () => supportsQuota,
       withStatusProbeMarker: () => withStatusProbeMarker
     });
     function readRecord(value) {
@@ -41980,6 +41980,9 @@ ${error48.message || ""}`;
       if (!Number.isFinite(reportedAt) || reportedAt <= 0) return void 0;
       return { ...record2, schemaVersion, reportedAt };
     }
+    function supportsQuota(providerType) {
+      return !!providerType && QUOTA_SUPPORTED_PROVIDERS.includes(providerType);
+    }
     function formatQuotaAccount(quota) {
       const meta3 = quota?.metadata;
       const email3 = typeof meta3?.accountEmail === "string" ? meta3.accountEmail.trim() : "";
@@ -42270,6 +42273,7 @@ ${error48.message || ""}`;
       const { [STATUS_PROBE_ARG_KEY]: _drop, ...rest } = args;
       return rest;
     }
+    var QUOTA_SUPPORTED_PROVIDERS;
     var DAEMON_ID_PREFIXES;
     var MAGI_RAW_ANSWER_CAP;
     var MESH_TASK_DIFFICULTIES;
@@ -42282,6 +42286,12 @@ ${error48.message || ""}`;
     var init_dist = __esm2({
       "../mesh-shared/dist/index.mjs"() {
         "use strict";
+        QUOTA_SUPPORTED_PROVIDERS = [
+          "claude-cli",
+          "codex-cli",
+          "kimi",
+          "opencode"
+        ];
         DAEMON_ID_PREFIXES = ["daemon_", "standalone_"];
         MAGI_RAW_ANSWER_CAP = 4e3;
         MESH_TASK_DIFFICULTIES = ["easy", "medium", "difficult", "freeform"];
@@ -45707,14 +45717,60 @@ Next step: ${nextStep}`;
       const reconciled = terminalJobIds.size === 0 ? events : events.filter((event) => !(event.event === "refine:accepted" && terminalJobIds.has(readRefineJobId2(event))));
       return backfilled.length === 0 ? reconciled : [...reconciled, ...backfilled];
     }
+    function getPendingRetentionCounters() {
+      return { ...pendingRetentionCounters };
+    }
+    function ledgerRecordExpiredUndrainedEvent(row) {
+      try {
+        const restored = row.payload && typeof row.payload === "object" ? row.payload : void 0;
+        const finalSummary = restored?.metadataEvent ? readMeshCompletionSummary(restored.metadataEvent) : void 0;
+        appendLedgerEntry(row.meshId, {
+          kind: "event_held",
+          ...restored?.nodeId ? { nodeId: restored.nodeId } : {},
+          payload: {
+            event: row.event,
+            reason: PENDING_RETENTION_EXPIRED_HOLD_REASON,
+            recoverable: true,
+            nodeLabel: restored?.nodeLabel ?? "",
+            ...restored?.workspace ? { workspace: restored.workspace } : {},
+            targetCoordinatorDaemonId: restored?.targetCoordinatorDaemonId ?? null,
+            ...readNonEmptyString(restored?.eventId) ? { eventId: restored.eventId } : {},
+            queuedAt: restored?.queuedAt ?? null,
+            ...finalSummary ? { finalSummary } : {},
+            // Full original event so mesh_requeue_held_events can restore it
+            // losslessly (event_held→pending), same as every other event_held feeder.
+            ...restored ? { heldEvent: restored } : {}
+          }
+        });
+      } catch (e) {
+        pendingRetentionCounters.undrainedExpiredMirrorFailed++;
+        LOG2.warn("MeshEvents", `Failed to ledger-record retention-expired pending event ${row.event} (row ${row.id}, mesh ${row.meshId}) \u2014 it is being deleted UNRECOVERABLY: ${e?.message || e}`);
+      }
+    }
     function prunePendingMeshCoordinatorEventsRetention() {
       try {
-        const removed = MeshRuntimeStore.getInstance().prunePendingEvents({
+        const { drainedExpired, undrainedExpired, undrainedRows } = MeshRuntimeStore.getInstance().prunePendingEvents({
           drainedOlderThanMs: PENDING_EVENTS_DRAINED_RETENTION_MS,
           undrainedOlderThanMs: PENDING_EVENTS_UNDRAINED_RETENTION_MS
         });
+        pendingRetentionCounters.drainedExpired += drainedExpired;
+        pendingRetentionCounters.undrainedExpired += undrainedExpired;
+        if (undrainedRows.length > 0) {
+          for (const row of undrainedRows) {
+            ledgerRecordExpiredUndrainedEvent(row);
+          }
+          const meshIds = [...new Set(undrainedRows.map((r) => r.meshId))];
+          const droppedAt = (/* @__PURE__ */ new Date()).toISOString();
+          LOG2.warn(
+            "MeshEvents",
+            `Pending-event retention DROPPED ${undrainedRows.length} never-delivered event(s) at ${droppedAt} (queued >30d, still undrained) across mesh(es) ${meshIds.join(", ")} \u2014 mirrored to the ledger as event_held (reason: ${PENDING_RETENTION_EXPIRED_HOLD_REASON}); recover with mesh_requeue_held_events.`
+          );
+        }
+        const removed = drainedExpired + undrainedExpired;
         if (removed > 0) {
           LOG2.info("MeshEvents", `Pruned ${removed} stale pending-event row(s) (drained >7d / undrained >30d)`);
+        } else {
+          pendingRetentionCounters.sweepsNoop++;
         }
         return removed;
       } catch (e) {
@@ -46043,6 +46099,8 @@ Next step: ${nextStep}`;
     var TERMINAL_COMPLETION_EVENTS;
     var PENDING_EVENTS_DRAINED_RETENTION_MS;
     var PENDING_EVENTS_UNDRAINED_RETENTION_MS;
+    var PENDING_RETENTION_EXPIRED_HOLD_REASON;
+    var pendingRetentionCounters;
     var init_mesh_events_pending = __esm2({
       "src/mesh/mesh-events-pending.ts"() {
         "use strict";
@@ -46091,6 +46149,22 @@ Next step: ${nextStep}`;
         TERMINAL_COMPLETION_EVENTS = /* @__PURE__ */ new Set(["agent:generating_completed", "agent:stopped"]);
         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";
+        pendingRetentionCounters = {
+          /** Already-drained rows deleted past the 7-day dedup-useful window. Not a drop. */
+          drainedExpired: 0,
+          /** Never-delivered rows deleted past the 30-day undrained window. A genuine
+           *  silent-drop risk — mirrored to event_held before deletion (see below). */
+          undrainedExpired: 0,
+          /** undrainedExpired rows that failed to mirror to the ledger (ledger write threw).
+           *  Non-zero here means those specific rows are NOT recoverable via
+           *  mesh_requeue_held_events — the delete still proceeds (retention must not wedge
+           *  on a ledger fault), but this count is the operator's signal of true loss. */
+          undrainedExpiredMirrorFailed: 0,
+          /** How many times the sweep has run and found nothing to prune (0 in both
+           *  windows). Purely diagnostic — confirms the sweep is actually firing. */
+          sweepsNoop: 0
+        };
       }
     });
     var mesh_missions_exports = {};
@@ -49828,21 +49902,43 @@ Next step: ${nextStep}`;
            *     receives its backlog; only genuinely unrecoverable orphans are swept.
            *
            * Both windows key off `queued_at` (always present) — `drained_at` can be NULL on
-           * legacy rows. Returns the number of rows deleted. Best-effort / idempotent:
-           * running it repeatedly with nothing to prune is a cheap no-op.
+           * legacy rows. Returns the number of rows deleted, split by which window matched:
+           * `drainedExpired` (already-delivered rows past the dedup-useful window — not a
+           * drop, the coordinator already got these) and `undrainedExpired` (rows that were
+           * NEVER delivered — a genuine silent drop, same shape as the retired JSONL trim's
+           * `pending_trim_dropped`). `undrainedRows` carries the id/meshId/event/payload of
+           * every undrained-expired row BEFORE deletion so the caller can mirror it to the
+           * mesh ledger as `event_held` (recoverable via mesh_requeue_held_events) instead of
+           * losing it silently — this is the observability gap the retired trim used to cover
+           * and the SQLite-only cutover left open. Best-effort / idempotent: running it
+           * repeatedly with nothing to prune is a cheap no-op.
            */
           prunePendingEvents(opts) {
             const now = Date.now();
             const drainedCutoff = now - Math.max(0, opts.drainedOlderThanMs);
             const undrainedCutoff = now - Math.max(0, opts.undrainedOlderThanMs);
-            let removed = 0;
-            removed += this.db.prepare(
+            const undrainedSelectRows = this.db.prepare(
+              "SELECT id, mesh_id, event, payload FROM mesh_pending_events WHERE drained = 0 AND queued_at < ?"
+            ).all(undrainedCutoff);
+            const undrainedRows = undrainedSelectRows.map((r) => ({
+              id: r.id,
+              meshId: r.mesh_id,
+              event: r.event,
+              payload: (() => {
+                try {
+                  return JSON.parse(r.payload);
+                } catch {
+                  return {};
+                }
+              })()
+            }));
+            const drainedExpired = this.db.prepare(
               "DELETE FROM mesh_pending_events WHERE drained = 1 AND queued_at < ?"
             ).run(drainedCutoff).changes;
-            removed += this.db.prepare(
+            const undrainedExpired = this.db.prepare(
               "DELETE FROM mesh_pending_events WHERE drained = 0 AND queued_at < ?"
             ).run(undrainedCutoff).changes;
-            return removed;
+            return { drainedExpired, undrainedExpired, undrainedRows };
           }
           // ── TURN-LEDGER (Stage 5): authoritative turn attempts ───────────────────
           /**
@@ -59943,6 +60039,332 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         PROVIDER_QUOTA_WEEKLY_LOW_SKIP_REASON = "provider_quota_weekly_low";
       }
     });
+    function isAnthropicProvider(providerType) {
+      const p = typeof providerType === "string" ? providerType.trim().toLowerCase() : "";
+      return p.length > 0 && ANTHROPIC_PROVIDER_TYPES.has(p);
+    }
+    function isAnthropicModel(model) {
+      const m = typeof model === "string" ? model.trim().toLowerCase() : "";
+      if (!m) return false;
+      if (m.startsWith("claude") || m.startsWith("anthropic")) return true;
+      return /^(opus|sonnet|haiku)(\b|[-_])/.test(m);
+    }
+    function isModelCompatibleWithProvider(model, providerType) {
+      if (!isAnthropicModel(model)) return true;
+      if (isAnthropicProvider(providerType)) return true;
+      return false;
+    }
+    var ANTHROPIC_PROVIDER_TYPES;
+    var init_model_provider_compat = __esm2({
+      "src/mesh/model-provider-compat.ts"() {
+        "use strict";
+        ANTHROPIC_PROVIDER_TYPES = /* @__PURE__ */ new Set([
+          "claude-cli"
+        ]);
+      }
+    });
+    function encodeDuplicateMeshDispatchCode(holderSessionId) {
+      const holder = typeof holderSessionId === "string" ? holderSessionId.trim() : "";
+      return holder ? `${DUPLICATE_MESH_DISPATCH_CODE}:${holder}` : DUPLICATE_MESH_DISPATCH_CODE;
+    }
+    function classifyDuplicateMeshDispatch(err) {
+      if (!err || typeof err !== "object") return null;
+      const e = err;
+      if (e.code === DUPLICATE_MESH_DISPATCH_CODE) {
+        const holder = typeof e.holderSessionId === "string" ? e.holderSessionId.trim() : "";
+        return holder ? { holderSessionId: holder } : {};
+      }
+      for (const raw of [e.meshCode, e.code]) {
+        if (typeof raw !== "string") continue;
+        if (raw !== DUPLICATE_MESH_DISPATCH_CODE && !raw.startsWith(`${DUPLICATE_MESH_DISPATCH_CODE}:`)) continue;
+        const holder = raw.slice(DUPLICATE_MESH_DISPATCH_CODE.length + 1).trim();
+        return holder ? { holderSessionId: holder } : {};
+      }
+      return null;
+    }
+    var DUPLICATE_MESH_DISPATCH_CODE;
+    var DuplicateMeshDispatchError;
+    var init_mesh_duplicate_dispatch = __esm2({
+      "src/mesh/mesh-duplicate-dispatch.ts"() {
+        "use strict";
+        DUPLICATE_MESH_DISPATCH_CODE = "DUPLICATE_MESH_DISPATCH";
+        DuplicateMeshDispatchError = class extends Error {
+          code = DUPLICATE_MESH_DISPATCH_CODE;
+          holderSessionId;
+          constructor(message, info = {}) {
+            super(message);
+            this.name = "DuplicateMeshDispatchError";
+            this.holderSessionId = info.holderSessionId;
+          }
+        };
+      }
+    });
+    function acquireAutoFastForwardLease(workspace) {
+      const key2 = normalizeMeshWorkspaceForCompare(workspace);
+      if (!key2) return false;
+      if (autoFastForwardWorkspaceLease.has(key2)) return false;
+      autoFastForwardWorkspaceLease.add(key2);
+      return true;
+    }
+    function releaseAutoFastForwardLease(workspace) {
+      const key2 = normalizeMeshWorkspaceForCompare(workspace);
+      if (key2) autoFastForwardWorkspaceLease.delete(key2);
+    }
+    function isWorkspaceAutoFastForwardInFlight(workspace) {
+      const key2 = normalizeMeshWorkspaceForCompare(workspace || "");
+      return !!key2 && autoFastForwardWorkspaceLease.has(key2);
+    }
+    function __resetIdleAutoFastForwardForTests() {
+      idleAutoFastForwardLastAttempt.clear();
+      continuousAutoFastForwardLastScan.clear();
+      autoFastForwardWorkspaceLease.clear();
+    }
+    function isDirtyNode(node) {
+      return node?.health === "dirty" || node?.git?.dirty === true;
+    }
+    function resolveAutoFastForwardPolicy(mesh) {
+      const record2 = mesh?.policy?.autoFastForward && typeof mesh.policy.autoFastForward === "object" && !Array.isArray(mesh.policy.autoFastForward) ? mesh.policy.autoFastForward : {};
+      const maxBehind = Number(record2.maxBehind);
+      return {
+        enabled: record2.enabled !== false,
+        ...Number.isFinite(maxBehind) && maxBehind >= 0 ? { maxBehind: Math.floor(maxBehind) } : {},
+        requireCleanSubmodules: record2.requireCleanSubmodules !== false,
+        // Strict opt-in: absent/false → self-only (historical behavior). Only an
+        // explicit `true` extends auto ff to remote owning-daemon nodes.
+        remoteNodes: record2.remoteNodes === true,
+        // Absent/anything-but-continuous → 'idle' (historical idle-edge-only detection).
+        mode: record2.mode === "continuous" ? "continuous" : "idle"
+      };
+    }
+    function dryRunSatisfiesAutoFastForwardPolicy(dryRun, policy) {
+      if (!dryRun || dryRun.code !== "fast_forward_available" || dryRun.allowed !== true) return false;
+      const behind = Number(dryRun.current?.behind);
+      if (!Number.isFinite(behind) || behind <= 0) return false;
+      if (policy.maxBehind !== void 0 && behind > policy.maxBehind) return false;
+      if (policy.requireCleanSubmodules) {
+        const submodules = Array.isArray(dryRun.current?.submodules) ? dryRun.current.submodules : [];
+        if (submodules.some((submodule) => submodule?.dirty || submodule?.outOfSync || submodule?.error)) return false;
+      }
+      return true;
+    }
+    function readNodeSubmoduleIgnorePaths(node) {
+      return Array.isArray(node?.policy?.submoduleIgnorePaths) ? node.policy.submoduleIgnorePaths.filter((value) => typeof value === "string") : void 0;
+    }
+    function nodeIsAutoFastForwardEligible(components, meshId, nodeId, node, currentSessionId) {
+      if (!node) return false;
+      if (node.status === "disabled" || node.status === "removed") return false;
+      if (node.readOnly === true || node.policy?.readOnly === true) return false;
+      if (isWorktreeBootstrapStaleRunning(node)) return false;
+      if (node.worktreeBootstrap?.status === "running") return false;
+      if (nodeHasActiveMeshWork(components, meshId, nodeId, currentSessionId)) return false;
+      return true;
+    }
+    function remoteNodeIsConnected(components, node) {
+      const daemonId = readMeshNodeDaemonId(node ?? {});
+      if (!daemonId) return false;
+      const getPeerStatus = components.getMeshPeerConnectionStatus;
+      if (getPeerStatus) {
+        const snapshot = getPeerStatus(daemonId);
+        return !!snapshot && String(snapshot.state) === "connected";
+      }
+      return readNonEmptyString(node?.connection?.state).toLowerCase() === "connected";
+    }
+    async function delegateRemoteAutoFastForward(components, args) {
+      const dispatchMeshCommand = components.dispatchMeshCommand;
+      if (!dispatchMeshCommand) return;
+      if (!acquireAutoFastForwardLease(args.workspace)) return;
+      const submoduleIgnorePaths = readNodeSubmoduleIgnorePaths(args.node);
+      const mesh = getMeshWithCache(components, args.meshId);
+      const baseArgs = {
+        meshId: args.meshId,
+        nodeId: args.nodeId,
+        workspace: args.workspace,
+        inlineMesh: mesh,
+        ...submoduleIgnorePaths ? { submoduleIgnorePaths } : {},
+        trigger: args.trigger,
+        // Preserve the pre-fix self-only semantics for submodules: the local idle path
+        // never updated submodules (updateSubmodules:false), so the remote path matches.
+        updateSubmodules: false
+      };
+      try {
+        const remoteDry = await dispatchMeshCommand(args.daemonId, "fast_forward_mesh_node", {
+          ...baseArgs,
+          execute: false,
+          dryRun: true
+        });
+        if (!dryRunSatisfiesAutoFastForwardPolicy(remoteDry, args.policy)) return;
+        if (nodeHasActiveMeshWork(components, args.meshId, args.nodeId)) return;
+        const executed = await dispatchMeshCommand(args.daemonId, "fast_forward_mesh_node", {
+          ...baseArgs,
+          execute: true,
+          dryRun: false
+        });
+        if (executed?.executed === true) {
+          LOG2.info("MeshFastForward", `Remote auto fast-forward executed for node ${args.nodeId} (daemon ${String(args.daemonId).slice(0, 12)}, trigger ${args.trigger})`);
+        }
+      } catch (e) {
+        LOG2.warn("MeshFastForward", `Remote auto fast-forward delegation failed for ${args.nodeId}: ${e?.message || e}`);
+      } finally {
+        releaseAutoFastForwardLease(args.workspace);
+      }
+    }
+    async function executeLocalAutoFastForward(args) {
+      if (!acquireAutoFastForwardLease(args.workspace)) return;
+      const submoduleIgnorePaths = readNodeSubmoduleIgnorePaths(args.node);
+      try {
+        const dryRun = await fastForwardMeshNode({
+          meshId: args.meshId,
+          nodeId: args.nodeId,
+          workspace: args.workspace,
+          execute: false,
+          dryRun: true,
+          updateSubmodules: false,
+          submoduleIgnorePaths,
+          trigger: args.trigger
+        });
+        if (!dryRunSatisfiesAutoFastForwardPolicy(dryRun, args.policy)) return;
+        await fastForwardMeshNode({
+          meshId: args.meshId,
+          nodeId: args.nodeId,
+          workspace: args.workspace,
+          execute: true,
+          dryRun: false,
+          updateSubmodules: false,
+          submoduleIgnorePaths,
+          trigger: args.trigger
+        });
+      } catch (e) {
+        LOG2.warn("MeshFastForward", `Idle auto fast-forward check failed for ${args.nodeId}: ${e?.message || e}`);
+      } finally {
+        releaseAutoFastForwardLease(args.workspace);
+      }
+    }
+    async function maybeAutoFastForwardIdleNode(components, args) {
+      const mesh = getMeshWithCache(components, args.meshId);
+      const node = mesh?.nodes?.find((candidate) => meshNodeIdMatches(candidate, args.nodeId));
+      const workspace = readNonEmptyString(node?.workspace);
+      if (!workspace) return;
+      const policy = resolveAutoFastForwardPolicy(mesh);
+      if (!policy.enabled) return;
+      if (nodeHasActiveMeshWork(components, args.meshId, args.nodeId, args.sessionId)) return;
+      const throttleKey = `${args.meshId}:${args.nodeId}`;
+      const now = Date.now();
+      const lastAttempt = idleAutoFastForwardLastAttempt.get(throttleKey) || 0;
+      if (now - lastAttempt < IDLE_AUTO_FAST_FORWARD_THROTTLE_MS) return;
+      idleAutoFastForwardLastAttempt.set(throttleKey, now);
+      if (isLocalAutoLaunchNode(node)) {
+        if (!(0, import_fs14.existsSync)(workspace)) return;
+        await executeLocalAutoFastForward({ meshId: args.meshId, nodeId: args.nodeId, node, workspace, policy, trigger: "idle_auto" });
+        return;
+      }
+      if (!policy.remoteNodes) return;
+      const daemonId = readMeshNodeDaemonId(node ?? {});
+      if (!daemonId || !components.dispatchMeshCommand) return;
+      if (!remoteNodeIsConnected(components, node)) return;
+      await delegateRemoteAutoFastForward(components, { meshId: args.meshId, nodeId: args.nodeId, node, daemonId, workspace, policy, trigger: "idle_auto" });
+    }
+    async function runContinuousAutoFastForwardScan(components, mesh) {
+      if (!components.dispatchMeshCommand) return;
+      const policy = resolveAutoFastForwardPolicy(mesh);
+      if (!policy.enabled || !policy.remoteNodes || policy.mode !== "continuous") return;
+      const meshId = readNonEmptyString(mesh?.id);
+      if (!meshId) return;
+      const nodes = Array.isArray(mesh?.nodes) ? mesh.nodes : [];
+      const now = Date.now();
+      for (const node of nodes) {
+        const nodeId = normalizeMeshNodeId(node);
+        if (!nodeId) continue;
+        if (node?.isLocalWorktree === true) continue;
+        if (isLocalAutoLaunchNode(node)) continue;
+        const workspace = readNonEmptyString(node?.workspace);
+        if (!workspace) continue;
+        const daemonId = readMeshNodeDaemonId(node ?? {});
+        if (!daemonId) continue;
+        if (!nodeIsAutoFastForwardEligible(components, meshId, nodeId, node)) continue;
+        if (!remoteNodeIsConnected(components, node)) continue;
+        const cooldownKey = `${meshId}:${nodeId}`;
+        const lastScan = continuousAutoFastForwardLastScan.get(cooldownKey) || 0;
+        if (now - lastScan < CONTINUOUS_AUTO_FAST_FORWARD_SCAN_COOLDOWN_MS) continue;
+        continuousAutoFastForwardLastScan.set(cooldownKey, now);
+        await delegateRemoteAutoFastForward(components, { meshId, nodeId, node, daemonId, workspace, policy, trigger: "reconcile_auto" });
+      }
+    }
+    async function runPendingCoordinatorCatchupScan(components, mesh) {
+      const meshId = readNonEmptyString(mesh?.id);
+      if (!meshId) return;
+      const localIds = expandDaemonIdForms([
+        readNonEmptyString(components.statusInstanceId),
+        readNonEmptyString(loadConfig2().machineId)
+      ]);
+      let markers = [];
+      try {
+        markers = drainPendingMeshCoordinatorEvents(
+          meshId,
+          localIds.length > 0 ? localIds : void 0,
+          { onlyEvents: /* @__PURE__ */ new Set(["coordinator_catchup"]) }
+        );
+      } catch (e) {
+        LOG2.warn("MeshReconcile", `Coordinator-catchup drain failed for mesh ${meshId}: ${e?.message || e}`);
+        return;
+      }
+      if (markers.length === 0) return;
+      const nodes = Array.isArray(mesh?.nodes) ? mesh.nodes : [];
+      for (const marker of markers) {
+        const meta3 = marker.metadataEvent || {};
+        const nodeId = readNonEmptyString(marker.nodeId) || readNonEmptyString(meta3.nodeId);
+        const workspace = readNonEmptyString(marker.workspace) || readNonEmptyString(meta3.workspace);
+        const baseBranch = readNonEmptyString(meta3.baseBranch);
+        if (!workspace) continue;
+        if (nodeId && nodeHasActiveMeshWork(components, meshId, nodeId)) {
+          try {
+            queuePendingMeshCoordinatorEvent(marker);
+          } catch {
+          }
+          continue;
+        }
+        try {
+          const ff = await fastForwardMeshNode({
+            meshId,
+            ...nodeId ? { nodeId } : {},
+            workspace,
+            ...baseBranch ? { branch: baseBranch } : {},
+            mode: "merge",
+            execute: true,
+            trigger: "refine_post_push_catchup",
+            allowAutoPublishSubmoduleMainCommits: mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true
+          });
+          LOG2.info("MeshReconcile", `Coordinator catch-up ff for ${meshId}/${nodeId || workspace}: ${ff.code} (executed=${ff.executed})`);
+        } catch (e) {
+          LOG2.warn("MeshReconcile", `Coordinator catch-up ff failed for ${meshId}/${nodeId || workspace}: ${e?.message || e}`);
+        }
+      }
+    }
+    var import_fs14;
+    var IDLE_AUTO_FAST_FORWARD_THROTTLE_MS;
+    var idleAutoFastForwardLastAttempt;
+    var CONTINUOUS_AUTO_FAST_FORWARD_SCAN_COOLDOWN_MS;
+    var continuousAutoFastForwardLastScan;
+    var autoFastForwardWorkspaceLease;
+    var init_mesh_auto_fast_forward = __esm2({
+      "src/mesh/mesh-auto-fast-forward.ts"() {
+        "use strict";
+        import_fs14 = require("fs");
+        init_logger();
+        init_config();
+        init_mesh_fast_forward();
+        init_dist();
+        init_mesh_events_utils();
+        init_mesh_node_identity();
+        init_mesh_events_pending();
+        init_worktree_bootstrap_config();
+        init_mesh_queue_assignment();
+        IDLE_AUTO_FAST_FORWARD_THROTTLE_MS = 30 * 60 * 1e3;
+        idleAutoFastForwardLastAttempt = /* @__PURE__ */ new Map();
+        CONTINUOUS_AUTO_FAST_FORWARD_SCAN_COOLDOWN_MS = 45 * 1e3;
+        continuousAutoFastForwardLastScan = /* @__PURE__ */ new Map();
+        autoFastForwardWorkspaceLease = /* @__PURE__ */ new Set();
+      }
+    });
     function normalizeNodeIdKey(nodeId) {
       return normalizeMeshNodeId({ id: nodeId ?? void 0 }) ?? "";
     }
@@ -59978,88 +60400,407 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         MAX_TRACKED_CLONED_NODES = 512;
       }
     });
-    function isAnthropicProvider(providerType) {
-      const p = typeof providerType === "string" ? providerType.trim().toLowerCase() : "";
-      return p.length > 0 && ANTHROPIC_PROVIDER_TYPES.has(p);
+    function isActionableSkipReason(reason) {
+      if (!reason) return false;
+      return ACTIONABLE_SKIP_REASON_PREFIXES.some((prefix) => reason === prefix || reason.startsWith(prefix));
     }
-    function isAnthropicModel(model) {
-      const m = typeof model === "string" ? model.trim().toLowerCase() : "";
-      if (!m) return false;
-      if (m.startsWith("claude") || m.startsWith("anthropic")) return true;
-      return /^(opus|sonnet|haiku)(\b|[-_])/.test(m);
+    function isTargetNodeTransientlyUnresolved(mesh, task) {
+      const targetNodeId = readNonEmptyString(task.targetNodeId);
+      if (!targetNodeId) return false;
+      const node = Array.isArray(mesh?.nodes) ? mesh.nodes.find((n) => meshNodeIdMatches(n, targetNodeId)) : void 0;
+      if (node && node.worktreeBootstrap?.status === "running" && !isWorktreeBootstrapStaleRunning(node)) {
+        return true;
+      }
+      return isWithinCloneBootstrapGrace(targetNodeId);
     }
-    function isModelCompatibleWithProvider(model, providerType) {
-      if (!isAnthropicModel(model)) return true;
-      if (isAnthropicProvider(providerType)) return true;
-      return false;
+    function targetPinAgeMs(task, nowMs = Date.now()) {
+      const anchorMs = Date.parse(task.requeuedAt || task.createdAt || "");
+      return Number.isFinite(anchorMs) ? nowMs - anchorMs : null;
     }
-    var ANTHROPIC_PROVIDER_TYPES;
-    var init_model_provider_compat = __esm2({
-      "src/mesh/model-provider-compat.ts"() {
+    function resolveDeadTargetVerdict(components, meshId, mesh, task) {
+      const NOT_DEAD = { dead: false, nodeDead: false, reason: "" };
+      const targetSessionId = readNonEmptyString(task.targetSessionId);
+      const targetNodeId = readNonEmptyString(task.targetNodeId);
+      if (!targetSessionId && !targetNodeId) return NOT_DEAD;
+      const lastUpdateMs = Date.parse(task.updatedAt || task.createdAt || "");
+      if (Number.isFinite(lastUpdateMs) && Date.now() - lastUpdateMs < DEAD_TARGET_GRACE_MS) return NOT_DEAD;
+      const nodes = Array.isArray(mesh?.nodes) ? mesh.nodes : [];
+      if (targetNodeId) {
+        const nodePresent = nodes.some((n) => meshNodeIdMatches(n, targetNodeId));
+        if (!nodePresent) {
+          if (isTargetNodeTransientlyUnresolved(mesh, task)) return NOT_DEAD;
+          return { dead: true, nodeDead: true, reason: "dead_target_node_absent" };
+        }
+      }
+      if (targetSessionId) {
+        const node = targetNodeId ? nodes.find((n) => meshNodeIdMatches(n, targetNodeId)) : void 0;
+        const nodeIsLocal = node ? isLocalAutoLaunchNode(node) : true;
+        if (nodeIsLocal) {
+          const verdict = resolveSessionBusyVerdict(components, targetSessionId);
+          if (verdict === "UNKNOWN") {
+            return { dead: true, nodeDead: false, reason: "dead_target_session_absent" };
+          }
+        }
+      }
+      return NOT_DEAD;
+    }
+    function retractActionableSkipIfPreviouslyNotified(meshId, taskId) {
+      const dedupKey = `${meshId}:${taskId}`;
+      if (!lastActionableSkipNotified.delete(dedupKey)) return;
+      try {
+        const coordinatorDaemonId = readNonEmptyString(loadConfig2().machineId) || void 0;
+        const removed = retractPendingDispatchBlockedEvent(meshId, taskId, coordinatorDaemonId);
+        if (removed > 0) {
+          LOG2.info("MeshQueue", `Retracted ${removed} stale dispatch-blocked event(s) for task ${taskId} (mesh ${meshId}) \u2014 its blocker resolved`);
+        }
+      } catch (e) {
+        LOG2.warn("MeshQueue", `Failed to retract stale dispatch-blocked event for task ${taskId} (mesh ${meshId}): ${e?.message || e}`);
+      }
+    }
+    function resolveTaskDeliveryEvidence(meshId, taskId) {
+      try {
+        const store = MeshRuntimeStore.getInstance();
+        if (store.taskDeliveryConsumed(meshId, taskId)) return "consumed";
+        if (store.taskHasConfirmedDelivery(meshId, taskId)) return "delivered";
+      } catch {
+        return "delivered";
+      }
+      return "never_dispatched";
+    }
+    function actionableSkipGuidance(reason, evidence) {
+      if (reason === "target_node_id_unmatched") return {
+        summary: "it is pinned to a target node id that matches no node in the mesh (the node may have been removed, or its id form does not resolve)",
+        nextAction: "Verify the target node still exists with mesh_status, then re-enqueue without the node pin or with a valid node id (or re-clone the node)."
+      };
+      if (reason === "no_node_satisfies_required_tags") return {
+        summary: "no node in the mesh can satisfy the task's required capability tags",
+        nextAction: "Relax the task's requiredTags, or add/launch a node whose provider produces the required capabilities."
+      };
+      if (reason === "mesh_convergence_target_is_worktree") return {
+        summary: "it is a convergence task (base-only: merge \u2192 push \u2192 cleanup) but every candidate node is a worktree clone",
+        nextAction: "Dispatch the convergence task to the base node, or run the deterministic fast-forward path (mesh_fast_forward_node / mesh_refine_node) instead."
+      };
+      if (reason.startsWith("remote_auto_launch")) return {
+        summary: "the target node is on a remote daemon this coordinator cannot auto-launch a session on (no dispatch transport, or no coordinator daemon id to stamp)",
+        nextAction: "Launch a session on that node yourself with mesh_launch_session, or ensure the remote daemon is connected over P2P."
+      };
+      if (reason.startsWith("provider") || reason === "missing_provider_priority") return {
+        summary: "the node has no usable provider for this task (provider priority missing/unusable, or the provider loader is unavailable)",
+        nextAction: "Check the node's providerPriority policy and that the required CLI/ACP provider is installed and enabled on that machine."
+      };
+      if (reason === "dirty_workspace") return {
+        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 === "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",
+          nextAction: "Do NOT re-send it \u2014 the session already has this message and re-sending would run the same instruction twice. Check its current output (mesh_read_chat / mesh_read_terminal) to confirm the work is under way."
+        };
+        if (evidence === "delivered") return {
+          summary: "it was pinned to a specific session and the pin TTL expired before the queue row was claimed; the message WAS handed to that session's transport, but the session never echoed a turn start, so whether it acted on it is unconfirmed",
+          nextAction: "Verify before re-sending: check the session with mesh_read_chat / mesh_read_terminal. Re-send only if its output shows no sign of this message \u2014 it may already be acting on it, and re-sending would duplicate the instruction."
+        };
+        return {
+          summary: "it was pinned to a specific session (a follow-up/delta for work already in flight) that never claimed it within the pin TTL, so the pin was cleared; no delivery to that session was ever recorded, so the message did not reach it",
+          nextAction: "The addressed session never received this delta and is still acting on its previous instructions. Re-send it to that session once it is idle (or re-target it), and re-check the work it produced in the meantime."
+        };
+      }
+      if (reason === SLOT_MODEL_ABSENT_SKIP_REASON) return {
+        summary: "no capability slot on the node declares the model this task resolved to (its difficulty\u2192brain preset picked a model the node was never configured to run)",
+        nextAction: "Re-enqueue with a difficulty/model the node's slots declare, target a node that declares this model, or add a slot for it. The task is NOT run on a substitute model \u2014 an undeclared model is never launched."
+      };
+      return {
+        summary: `it cannot be dispatched (${reason})`,
+        nextAction: "Inspect the node/mesh state with mesh_status and resolve the blocker, or re-enqueue the task."
+      };
+    }
+    function notifyCoordinatorOfActionableSkip(meshId, taskId, reason, nodeId) {
+      if (!isActionableSkipReason(reason)) return;
+      if (reason === "target_node_id_unmatched" && isWithinCloneBootstrapGrace(readNonEmptyString(nodeId))) return;
+      const dedupKey = `${meshId}:${taskId}`;
+      if (lastActionableSkipNotified.get(dedupKey) === reason) return;
+      lastActionableSkipNotified.set(dedupKey, reason);
+      if (lastActionableSkipNotified.size > AUTO_LAUNCH_LEDGER_DEDUP_MAX) {
+        const oldest = lastActionableSkipNotified.keys().next().value;
+        if (oldest !== void 0) lastActionableSkipNotified.delete(oldest);
+      }
+      let task;
+      try {
+        task = getQueue(meshId).find((t) => t.id === taskId);
+      } catch {
+      }
+      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 { summary, nextAction } = actionableSkipGuidance(reason, evidence);
+      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." : "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({
+          event: "mesh:dispatch_blocked",
+          meshId,
+          nodeLabel: nodeLabel || meshId,
+          ...nodeLabel ? { nodeId: nodeLabel } : {},
+          metadataEvent: {
+            source: "mesh_queue_dispatch_skip",
+            taskId,
+            reason,
+            ...nodeLabel ? { nodeId: nodeLabel } : {},
+            coordinatorMessage
+          },
+          coordinatorMessage,
+          queuedAt: Date.now(),
+          ...targetCoordinatorDaemonId ? { targetCoordinatorDaemonId } : {},
+          ...targetCoordinatorSessionId ? { targetCoordinatorSessionId } : {}
+        });
+      } catch (e) {
+        LOG2.warn("MeshQueue", `Failed to surface actionable dispatch-skip (${reason}) for task ${taskId}: ${e?.message || e}`);
+      }
+    }
+    var ACTIONABLE_SKIP_REASON_PREFIXES;
+    var TRANSIENT_TARGET_NODE_BOOTSTRAP_PENDING_REASON;
+    var lastActionableSkipNotified;
+    var DEAD_TARGET_GRACE_MS;
+    var TARGET_SESSION_PIN_TTL_MS;
+    var init_mesh_skip_notify = __esm2({
+      "src/mesh/mesh-skip-notify.ts"() {
         "use strict";
-        ANTHROPIC_PROVIDER_TYPES = /* @__PURE__ */ new Set([
-          "claude-cli"
-        ]);
+        init_logger();
+        init_mesh_work_queue();
+        init_mesh_runtime_store();
+        init_dist();
+        init_mesh_events_utils();
+        init_mesh_events_pending();
+        init_worktree_bootstrap_config();
+        init_mesh_clone_grace();
+        init_config();
+        init_slot_model_enforcement();
+        init_mesh_queue_assignment();
+        ACTIONABLE_SKIP_REASON_PREFIXES = [
+          "target_node_id_unmatched",
+          "no_node_satisfies_required_tags",
+          "mesh_convergence_target_is_worktree",
+          "remote_auto_launch_unsupported",
+          "remote_auto_launch_no_coordinator_daemon_id",
+          "missing_provider_priority",
+          "provider_loader_unavailable",
+          "provider_priority_unusable",
+          "provider_unusable",
+          "dirty_workspace",
+          // TARGET-PIN-TTL EXPIRY: the task was pinned to a specific session (a delta —
+          // a correction addressed to work already in flight) and that session never
+          // claimed it within the TTL, so the pin was cleared. Unlike the transient
+          // skips, this does NOT self-resolve into the intended outcome: the delta is
+          // now claimable by ANY compatible session, i.e. it will not reach the session
+          // it was written for. Previously this only bumped a metrics counter and wrote
+          // a log, so the coordinator kept waiting for a delivery that could no longer
+          // happen — measured live as 74min of silence while a worker continued on a
+          // premise the delta was meant to correct. The coordinator must know its
+          // addressed message lost its address.
+          "target_session_pin_expired",
+          // 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
+          // busy counterpart SLOT_MODEL_BUSY_SKIP_REASON is deliberately NOT listed:
+          // that one clears on its own when the slot goes idle.
+          SLOT_MODEL_ABSENT_SKIP_REASON
+          // QUOTA GATE: 'provider_quota_session_low' / 'provider_quota_weekly_low' are
+          // deliberately NOT listed either — an exhausted quota window RESETS, so the
+          // block self-resolves exactly like the slot-busy case; the task waits in the
+          // queue and the coordinator is not paged (mesh-quota-routing.ts).
+        ];
+        TRANSIENT_TARGET_NODE_BOOTSTRAP_PENDING_REASON = "target_node_bootstrap_pending";
+        lastActionableSkipNotified = /* @__PURE__ */ new Map();
+        DEAD_TARGET_GRACE_MS = 6e4;
+        TARGET_SESSION_PIN_TTL_MS = 15 * 6e4;
       }
     });
-    function encodeDuplicateMeshDispatchCode(holderSessionId) {
-      const holder = typeof holderSessionId === "string" ? holderSessionId.trim() : "";
-      return holder ? `${DUPLICATE_MESH_DISPATCH_CODE}:${holder}` : DUPLICATE_MESH_DISPATCH_CODE;
+    function activeWriteAssignedCount(meshId) {
+      return getQueue(meshId, { status: ["assigned"] }).filter((task) => !isTaskReadonly(task)).length;
     }
-    function classifyDuplicateMeshDispatch(err) {
-      if (!err || typeof err !== "object") return null;
-      const e = err;
-      if (e.code === DUPLICATE_MESH_DISPATCH_CODE) {
-        const holder = typeof e.holderSessionId === "string" ? e.holderSessionId.trim() : "";
-        return holder ? { holderSessionId: holder } : {};
+    function activeReadonlyAssignedCount(meshId) {
+      return getQueue(meshId, { status: ["assigned"] }).filter(isTaskReadonly).length;
+    }
+    function nodeHasActiveAssignment(meshId, nodeId) {
+      return getQueue(meshId, { status: ["assigned"] }).some((task) => daemonIdsEquivalent(task.assignedNodeId, nodeId));
+    }
+    function nodeActiveLoad(meshId, nodeId) {
+      return MeshRuntimeStore.getInstance().nodeActiveAssignmentCount(meshId, nodeId);
+    }
+    function meshHasExplicitSlots(mesh) {
+      const nodes = Array.isArray(mesh?.nodes) ? mesh.nodes : [];
+      return nodes.some((n) => normalizeNodeCapabilitySlots(n?.policy?.slots).length > 0);
+    }
+    function resolveSchedulingStrategy(mesh) {
+      const raw = mesh?.policy?.schedulingStrategy;
+      if (typeof raw === "string" && raw.trim()) {
+        return normalizeMeshSchedulingStrategy(raw);
       }
-      for (const raw of [e.meshCode, e.code]) {
-        if (typeof raw !== "string") continue;
-        if (raw !== DUPLICATE_MESH_DISPATCH_CODE && !raw.startsWith(`${DUPLICATE_MESH_DISPATCH_CODE}:`)) continue;
-        const holder = raw.slice(DUPLICATE_MESH_DISPATCH_CODE.length + 1).trim();
-        return holder ? { holderSessionId: holder } : {};
+      return meshHasExplicitSlots(mesh) ? "fitness" : normalizeMeshSchedulingStrategy(void 0);
+    }
+    function buildSchedulingPool(localCandidates, remoteCandidates) {
+      const pool = [...localCandidates, ...remoteCandidates].map((c) => ({
+        ...c,
+        nodeId: normalizeMeshNodeId(c.node) ?? c.nodeId
+      }));
+      const uniqueNodes = [...new Set(pool.map((c) => c.nodeId))].map((nodeId, index) => ({
+        nodeId,
+        node: pool.find((c) => meshNodeIdMatches({ id: c.nodeId }, nodeId))?.node,
+        index
+      }));
+      return { pool, uniqueNodes };
+    }
+    function scoreSlotForTask(slot, task, quotaBonus = 0) {
+      let score = 1;
+      const diff = isMeshTaskDifficulty(task.difficulty) ? task.difficulty : void 0;
+      if (diff) {
+        if (slot.difficulty?.length) {
+          score += slot.difficulty.includes(diff) ? 100 : 0;
+        } else {
+          score += 20;
+        }
       }
-      return null;
+      const req = task.requiredTags?.filter((t) => !!t) ?? [];
+      if (req.length) {
+        const cap = new Set(slot.capability ?? []);
+        const covered = req.every((t) => cap.has(t));
+        score += covered ? 30 : 0;
+      }
+      score += quotaBonus;
+      return score;
     }
-    var DUPLICATE_MESH_DISPATCH_CODE;
-    var DuplicateMeshDispatchError;
-    var init_mesh_duplicate_dispatch = __esm2({
-      "src/mesh/mesh-duplicate-dispatch.ts"() {
-        "use strict";
-        DUPLICATE_MESH_DISPATCH_CODE = "DUPLICATE_MESH_DISPATCH";
-        DuplicateMeshDispatchError = class extends Error {
-          code = DUPLICATE_MESH_DISPATCH_CODE;
-          holderSessionId;
-          constructor(message, info = {}) {
-            super(message);
-            this.name = "DuplicateMeshDispatchError";
-            this.holderSessionId = info.holderSessionId;
+    function orderSlotsForProviderSelection(slots, meshId, nodeId, node, task, quotaBonusByProvider) {
+      return [...slots].sort((a, b) => {
+        const capDelta = Number(slotHasCapacity(meshId, nodeId, node, b)) - Number(slotHasCapacity(meshId, nodeId, node, a));
+        if (capDelta !== 0) return capDelta;
+        return scoreSlotForTask(b, task, quotaBonusByProvider?.[b.provider] ?? 0) - scoreSlotForTask(a, task, quotaBonusByProvider?.[a.provider] ?? 0);
+      });
+    }
+    function bestSlotForTask(node, task, meshId, quotaBonusByProvider) {
+      const slots = resolveNodeCapabilitySlots(node, meshId);
+      if (!slots.length) return null;
+      let best = null;
+      for (const slot of slots) {
+        const score = scoreSlotForTask(slot, task, quotaBonusByProvider?.[slot.provider] ?? 0);
+        if (!best || score > best.score) best = { slot, score };
+      }
+      return best;
+    }
+    function nodeFitnessForTask(node, task, meshId, quotaBonusByProvider) {
+      return bestSlotForTask(node, task, meshId, quotaBonusByProvider)?.score ?? 0;
+    }
+    function slotCoversTaskDifficulty(slot, difficulty) {
+      if (!slot) return false;
+      if (!isMeshTaskDifficulty(difficulty)) return false;
+      if (!slot.difficulty?.length) return true;
+      return slot.difficulty.includes(difficulty);
+    }
+    function resolveLaunchAxis(taskValue, taskSource, slotValue, slotCoversDifficulty) {
+      const stamped = typeof taskValue === "string" && taskValue.trim() ? taskValue.trim() : void 0;
+      if (!stamped) return slotValue;
+      if (taskSource !== "preset") return stamped;
+      return slotCoversDifficulty && slotValue ? slotValue : stamped;
+    }
+    function orderEligibleNodes(meshId, strategy, nodes, opts) {
+      if (strategy === "first_eligible" || nodes.length <= 1) {
+        return nodes;
+      }
+      if (strategy === "fitness" && opts?.task) {
+        const task = opts.task;
+        const bonusCache = /* @__PURE__ */ new Map();
+        const bonusFor = (c) => {
+          let bonus = bonusCache.get(c.nodeId);
+          if (!bonus) {
+            bonus = quotaSpreadBonusByProvider(c.node, opts.quotaRouting);
+            bonusCache.set(c.nodeId, bonus);
           }
+          return bonus;
         };
+        return [...nodes].sort((a, b) => {
+          const fitDelta = nodeFitnessForTask(b.node, task, meshId, bonusFor(b)) - nodeFitnessForTask(a.node, task, meshId, bonusFor(a));
+          if (fitDelta !== 0) return fitDelta;
+          const prioDelta = resolveNodeSchedulingPriority(b.node?.policy) - resolveNodeSchedulingPriority(a.node?.policy);
+          if (prioDelta !== 0) return prioDelta;
+          const loadDelta = nodeActiveLoad(meshId, a.nodeId) - nodeActiveLoad(meshId, b.nodeId);
+          if (loadDelta !== 0) return loadDelta;
+          return a.index - b.index;
+        });
       }
-    });
-    function localCoordinatorDaemonId() {
-      return canonicalDaemonId(readNonEmptyString(loadConfig2().machineId));
+      const priorityOf = (n) => resolveNodeSchedulingPriority(n.node?.policy);
+      let rotation = 0;
+      if (strategy === "least_loaded" || strategy === "round_robin") {
+        const cursor = opts?.bumpCursor ? MeshRuntimeStore.getInstance().bumpSchedulerCursor(meshId) : MeshRuntimeStore.getInstance().getSchedulerCursor(meshId);
+        rotation = (cursor % nodes.length + nodes.length) % nodes.length;
+      }
+      const rotationRank = (index) => (index - rotation + nodes.length) % nodes.length;
+      return [...nodes].sort((a, b) => {
+        const prioDelta = priorityOf(b) - priorityOf(a);
+        if (prioDelta !== 0) return prioDelta;
+        if (strategy === "least_loaded" || strategy === "round_robin") {
+          const loadDelta = nodeActiveLoad(meshId, a.nodeId) - nodeActiveLoad(meshId, b.nodeId);
+          if (loadDelta !== 0) return loadDelta;
+        }
+        return rotationRank(a.index) - rotationRank(b.index);
+      });
     }
-    function acquireAutoFastForwardLease(workspace) {
-      const key2 = normalizeMeshWorkspaceForCompare(workspace);
-      if (!key2) return false;
-      if (autoFastForwardWorkspaceLease.has(key2)) return false;
-      autoFastForwardWorkspaceLease.add(key2);
-      return true;
+    function activeProviderAssignedCount(meshId, nodeId, providerType) {
+      return getQueue(meshId, { status: ["assigned"] }).filter((task) => daemonIdsEquivalent(task.assignedNodeId, nodeId) && task.assignedProviderType === providerType).length;
     }
-    function releaseAutoFastForwardLease(workspace) {
-      const key2 = normalizeMeshWorkspaceForCompare(workspace);
-      if (key2) autoFastForwardWorkspaceLease.delete(key2);
+    function activeSlotAssignedCount(meshId, nodeId, providerType, slot) {
+      return getQueue(meshId, { status: ["assigned"] }).filter((task) => {
+        if (!daemonIdsEquivalent(task.assignedNodeId, nodeId)) return false;
+        if (task.assignedProviderType !== providerType) return false;
+        const assignedModel = task.assignedModel;
+        if (typeof assignedModel !== "string" || !assignedModel.trim()) return true;
+        return isModelAllowedBySlot(assignedModel, slot);
+      }).length;
     }
-    function isWorkspaceAutoFastForwardInFlight(workspace) {
-      const key2 = normalizeMeshWorkspaceForCompare(workspace || "");
-      return !!key2 && autoFastForwardWorkspaceLease.has(key2);
+    function slotCapacityRemaining(meshId, nodeId, node, slot) {
+      const providerType = typeof slot.provider === "string" ? slot.provider.trim() : "";
+      if (!providerType) return { available: false };
+      const slots = resolveNodeCapabilitySlots(node, meshId);
+      const slotCap = resolveSlotMaxParallel(slots, providerType, slot.model, isModelAllowedBySlot);
+      if (slotCap !== void 0 && activeSlotAssignedCount(meshId, nodeId, providerType, slot) >= slotCap) {
+        return { available: false, slotCap };
+      }
+      const providerCap = resolveProviderMaxParallel(slots, providerType);
+      if (providerCap !== void 0 && activeProviderAssignedCount(meshId, nodeId, providerType) >= providerCap) {
+        return { available: false, slotCap, providerCap };
+      }
+      return { available: true, slotCap, providerCap };
     }
-    function __resetIdleAutoFastForwardForTests() {
-      idleAutoFastForwardLastAttempt.clear();
-      continuousAutoFastForwardLastScan.clear();
-      autoFastForwardWorkspaceLease.clear();
+    function slotHasCapacity(meshId, nodeId, node, slot) {
+      return slotCapacityRemaining(meshId, nodeId, node, slot).available;
+    }
+    function sessionHasActiveAssignment(meshId, sessionId) {
+      if (getQueue(meshId, { status: ["assigned"] }).some((task) => sessionIdsEquivalent(task.assignedSessionId, sessionId))) {
+        return true;
+      }
+      try {
+        if (getActiveDirectDispatches(meshId).some((d) => sessionIdsEquivalent(d.sessionId, sessionId))) return true;
+        if (hasUnterminalDirectDispatchLedgerEntry(meshId, sessionId)) return true;
+      } catch {
+      }
+      return false;
+    }
+    var init_mesh_scheduling_fitness = __esm2({
+      "src/mesh/mesh-scheduling-fitness.ts"() {
+        "use strict";
+        init_mesh_work_queue();
+        init_mesh_runtime_store();
+        init_mesh_work_queue();
+        init_repo_mesh_types();
+        init_dist();
+        init_mesh_node_slots();
+        init_mesh_quota_routing();
+        init_mesh_events_stale();
+        init_slot_model_enforcement();
+      }
+    });
+    function localCoordinatorDaemonId() {
+      return canonicalDaemonId(readNonEmptyString(loadConfig2().machineId));
     }
     function loadRepoConfigForNode(node) {
       const workspace = typeof node?.workspace === "string" && node.workspace.trim() ? node.workspace.trim() : "";
@@ -60247,14 +60988,15 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         if (timer) clearTimeout(timer);
         const isQueued = res && typeof res === "object" && res.status === "queued";
         updateSessionDeliveryStatus(delivery.id, isQueued ? "queued" : "delivered");
-        if (!isQueued && ctx.task.attemptId) {
+        if (ctx.task.attemptId) {
           try {
             recordTurnAck({
               meshId: ctx.meshId,
               taskId: ctx.task.id,
-              kind: "delivered",
+              kind: isQueued ? "accepted" : "delivered",
               attemptId: ctx.task.attemptId,
-              sessionId: ctx.sessionId
+              sessionId: ctx.sessionId,
+              ...isQueued ? { evidence: { source: "transport_queued_in_adapter" } } : {}
             });
           } catch {
           }
@@ -60295,22 +61037,52 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         LOG2.error("MeshQueue", `Failed to dispatch task via ${ctx.transport} to node ${ctx.nodeId}: ${e?.message}`);
         updateSessionDeliveryStatus(delivery.id, "failed", { lastError: e?.message, incrementAttempt: true });
         endTaskDispatchInFlight(ctx.meshId, ctx.task.id);
-        updateTaskStatus(ctx.meshId, ctx.task.id, "pending");
         try {
           closeAttemptForReassignment({ meshId: ctx.meshId, taskId: ctx.task.id, reason: "dispatch_failed" });
         } catch {
         }
+        const retryable = isRetryableDispatchFailure(e);
+        if (!retryable) {
+          failTaskAsUndeliverable(ctx, `dispatch_unrecoverable: ${e?.message || "transport reported the failure as non-recoverable"}`);
+        } else {
+          const requeued = requeueTask(ctx.meshId, ctx.task.id, {
+            reason: "dispatch_failed",
+            clearTargetSession: false
+          });
+          if (requeued?.status === "failed") {
+            LOG2.error("MeshQueue", `Task ${ctx.task.id} (mesh ${ctx.meshId}) failed after repeated undeliverable dispatches to node ${ctx.nodeId}: ${requeued.cancelReason || "max_retries_exceeded"}. Dependents were unblocked.`);
+          }
+        }
         try {
           appendLedgerEntry(ctx.meshId, {
             kind: "dispatch_failed",
             nodeId: ctx.nodeId,
             sessionId: ctx.sessionId,
-            payload: { taskId: ctx.task.id, deliveryId: delivery.id, error: e?.message, retryable: isRetryableDispatchFailure(e), transport: ctx.transport }
+            payload: { taskId: ctx.task.id, deliveryId: delivery.id, error: e?.message, retryable, transport: ctx.transport }
           });
         } catch {
         }
       });
     }
+    function failTaskAsUndeliverable(ctx, reason) {
+      try {
+        const failed = requeueTask(ctx.meshId, ctx.task.id, { maxRetries: 0, reason, clearTargetSession: false });
+        if (!failed) return;
+      } catch (err) {
+        LOG2.warn("MeshQueue", `Failed to mark undeliverable task ${ctx.task.id} (mesh ${ctx.meshId}) terminal: ${err?.message || err}`);
+        return;
+      }
+      LOG2.error("MeshQueue", `Task ${ctx.task.id} (mesh ${ctx.meshId}) is undeliverable to node ${ctx.nodeId} (session ${ctx.sessionId ?? "?"}) and will NOT be retried: ${reason}`);
+      try {
+        appendLedgerEntry(ctx.meshId, {
+          kind: "task_failed",
+          nodeId: ctx.nodeId,
+          sessionId: ctx.sessionId,
+          payload: { taskId: ctx.task.id, reason, undeliverable: true }
+        });
+      } catch {
+      }
+    }
     function isRetryableDispatchFailure(e) {
       if (e && typeof e === "object") {
         if (e.retryRecommended === false) return false;
@@ -60604,143 +61376,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       }
       return out;
     }
-    function isActionableSkipReason(reason) {
-      if (!reason) return false;
-      return ACTIONABLE_SKIP_REASON_PREFIXES.some((prefix) => reason === prefix || reason.startsWith(prefix));
-    }
-    function isTargetNodeTransientlyUnresolved(mesh, task) {
-      const targetNodeId = readNonEmptyString(task.targetNodeId);
-      if (!targetNodeId) return false;
-      const node = Array.isArray(mesh?.nodes) ? mesh.nodes.find((n) => meshNodeIdMatches(n, targetNodeId)) : void 0;
-      if (node && node.worktreeBootstrap?.status === "running" && !isWorktreeBootstrapStaleRunning(node)) {
-        return true;
-      }
-      return isWithinCloneBootstrapGrace(targetNodeId);
-    }
-    function targetPinAgeMs(task, nowMs = Date.now()) {
-      const anchorMs = Date.parse(task.requeuedAt || task.createdAt || "");
-      return Number.isFinite(anchorMs) ? nowMs - anchorMs : null;
-    }
-    function resolveDeadTargetVerdict(components, meshId, mesh, task) {
-      const NOT_DEAD = { dead: false, nodeDead: false, reason: "" };
-      const targetSessionId = readNonEmptyString(task.targetSessionId);
-      const targetNodeId = readNonEmptyString(task.targetNodeId);
-      if (!targetSessionId && !targetNodeId) return NOT_DEAD;
-      const lastUpdateMs = Date.parse(task.updatedAt || task.createdAt || "");
-      if (Number.isFinite(lastUpdateMs) && Date.now() - lastUpdateMs < DEAD_TARGET_GRACE_MS) return NOT_DEAD;
-      const nodes = Array.isArray(mesh?.nodes) ? mesh.nodes : [];
-      if (targetNodeId) {
-        const nodePresent = nodes.some((n) => meshNodeIdMatches(n, targetNodeId));
-        if (!nodePresent) {
-          if (isTargetNodeTransientlyUnresolved(mesh, task)) return NOT_DEAD;
-          return { dead: true, nodeDead: true, reason: "dead_target_node_absent" };
-        }
-      }
-      if (targetSessionId) {
-        const node = targetNodeId ? nodes.find((n) => meshNodeIdMatches(n, targetNodeId)) : void 0;
-        const nodeIsLocal = node ? isLocalAutoLaunchNode(node) : true;
-        if (nodeIsLocal) {
-          const verdict = resolveSessionBusyVerdict(components, targetSessionId);
-          if (verdict === "UNKNOWN") {
-            return { dead: true, nodeDead: false, reason: "dead_target_session_absent" };
-          }
-        }
-      }
-      return NOT_DEAD;
-    }
-    function retractActionableSkipIfPreviouslyNotified(meshId, taskId) {
-      const dedupKey = `${meshId}:${taskId}`;
-      if (!lastActionableSkipNotified.delete(dedupKey)) return;
-      try {
-        const coordinatorDaemonId = readNonEmptyString(loadConfig2().machineId) || void 0;
-        const removed = retractPendingDispatchBlockedEvent(meshId, taskId, coordinatorDaemonId);
-        if (removed > 0) {
-          LOG2.info("MeshQueue", `Retracted ${removed} stale dispatch-blocked event(s) for task ${taskId} (mesh ${meshId}) \u2014 its blocker resolved`);
-        }
-      } catch (e) {
-        LOG2.warn("MeshQueue", `Failed to retract stale dispatch-blocked event for task ${taskId} (mesh ${meshId}): ${e?.message || e}`);
-      }
-    }
-    function actionableSkipGuidance(reason) {
-      if (reason === "target_node_id_unmatched") return {
-        summary: "it is pinned to a target node id that matches no node in the mesh (the node may have been removed, or its id form does not resolve)",
-        nextAction: "Verify the target node still exists with mesh_status, then re-enqueue without the node pin or with a valid node id (or re-clone the node)."
-      };
-      if (reason === "no_node_satisfies_required_tags") return {
-        summary: "no node in the mesh can satisfy the task's required capability tags",
-        nextAction: "Relax the task's requiredTags, or add/launch a node whose provider produces the required capabilities."
-      };
-      if (reason === "mesh_convergence_target_is_worktree") return {
-        summary: "it is a convergence task (base-only: merge \u2192 push \u2192 cleanup) but every candidate node is a worktree clone",
-        nextAction: "Dispatch the convergence task to the base node, or run the deterministic fast-forward path (mesh_fast_forward_node / mesh_refine_node) instead."
-      };
-      if (reason.startsWith("remote_auto_launch")) return {
-        summary: "the target node is on a remote daemon this coordinator cannot auto-launch a session on (no dispatch transport, or no coordinator daemon id to stamp)",
-        nextAction: "Launch a session on that node yourself with mesh_launch_session, or ensure the remote daemon is connected over P2P."
-      };
-      if (reason.startsWith("provider") || reason === "missing_provider_priority") return {
-        summary: "the node has no usable provider for this task (provider priority missing/unusable, or the provider loader is unavailable)",
-        nextAction: "Check the node's providerPriority policy and that the required CLI/ACP provider is installed and enabled on that machine."
-      };
-      if (reason === "dirty_workspace") return {
-        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 === "target_session_pin_expired") return {
-        summary: "it was pinned to a specific session (a follow-up/delta for work already in flight) that never claimed it within the pin TTL, so the pin was cleared and the message will NOT reach the session it was addressed to",
-        nextAction: "Assume the addressed session never received this delta and is still acting on its previous instructions. Re-send it to that session once it is idle (or re-target it), and re-check the work it produced in the meantime."
-      };
-      if (reason === SLOT_MODEL_ABSENT_SKIP_REASON) return {
-        summary: "no capability slot on the node declares the model this task resolved to (its difficulty\u2192brain preset picked a model the node was never configured to run)",
-        nextAction: "Re-enqueue with a difficulty/model the node's slots declare, target a node that declares this model, or add a slot for it. The task is NOT run on a substitute model \u2014 an undeclared model is never launched."
-      };
-      return {
-        summary: `it cannot be dispatched (${reason})`,
-        nextAction: "Inspect the node/mesh state with mesh_status and resolve the blocker, or re-enqueue the task."
-      };
-    }
-    function notifyCoordinatorOfActionableSkip(meshId, taskId, reason, nodeId) {
-      if (!isActionableSkipReason(reason)) return;
-      if (reason === "target_node_id_unmatched" && isWithinCloneBootstrapGrace(readNonEmptyString(nodeId))) return;
-      const dedupKey = `${meshId}:${taskId}`;
-      if (lastActionableSkipNotified.get(dedupKey) === reason) return;
-      lastActionableSkipNotified.set(dedupKey, reason);
-      if (lastActionableSkipNotified.size > AUTO_LAUNCH_LEDGER_DEDUP_MAX) {
-        const oldest = lastActionableSkipNotified.keys().next().value;
-        if (oldest !== void 0) lastActionableSkipNotified.delete(oldest);
-      }
-      let task;
-      try {
-        task = getQueue(meshId).find((t) => t.id === taskId);
-      } catch {
-      }
-      const targetCoordinatorDaemonId = readNonEmptyString(loadConfig2().machineId);
-      const targetCoordinatorSessionId = readNonEmptyString(task?.sourceCoordinatorSessionId);
-      const nodeLabel = readNonEmptyString(nodeId) || readNonEmptyString(task?.targetNodeId);
-      const { summary, nextAction } = actionableSkipGuidance(reason);
-      const coordinatorMessage = `[System] A queued mesh task${nodeLabel ? ` for node ${nodeLabel}` : ""} is not being dispatched because ${summary}. ${nextAction} This is an actionable blocker \u2014 it will NOT clear on its own; the task stays pending until you resolve it.`;
-      try {
-        queuePendingMeshCoordinatorEvent({
-          event: "mesh:dispatch_blocked",
-          meshId,
-          nodeLabel: nodeLabel || meshId,
-          ...nodeLabel ? { nodeId: nodeLabel } : {},
-          metadataEvent: {
-            source: "mesh_queue_dispatch_skip",
-            taskId,
-            reason,
-            ...nodeLabel ? { nodeId: nodeLabel } : {},
-            coordinatorMessage
-          },
-          coordinatorMessage,
-          queuedAt: Date.now(),
-          ...targetCoordinatorDaemonId ? { targetCoordinatorDaemonId } : {},
-          ...targetCoordinatorSessionId ? { targetCoordinatorSessionId } : {}
-        });
-      } catch (e) {
-        LOG2.warn("MeshQueue", `Failed to surface actionable dispatch-skip (${reason}) for task ${taskId}: ${e?.message || e}`);
-      }
-    }
     function sweepExpiredCooldowns() {
       const now = Date.now();
       for (const [key2, until] of autoLaunchCooldownUntil) {
@@ -60760,28 +61395,11 @@ 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 isIdleSessionState(state) {
+    function isIdleSessionState2(state) {
       const status = readNonEmptyString(state?.status).toLowerCase();
       if (isTerminalSessionStatus(status)) return false;
       return status === "idle" || state?.activeChat?.status === "waiting_input";
     }
-    function isDirtyNode(node) {
-      return node?.health === "dirty" || node?.git?.dirty === true;
-    }
-    function resolveAutoFastForwardPolicy(mesh) {
-      const record2 = mesh?.policy?.autoFastForward && typeof mesh.policy.autoFastForward === "object" && !Array.isArray(mesh.policy.autoFastForward) ? mesh.policy.autoFastForward : {};
-      const maxBehind = Number(record2.maxBehind);
-      return {
-        enabled: record2.enabled !== false,
-        ...Number.isFinite(maxBehind) && maxBehind >= 0 ? { maxBehind: Math.floor(maxBehind) } : {},
-        requireCleanSubmodules: record2.requireCleanSubmodules !== false,
-        // Strict opt-in: absent/false → self-only (historical behavior). Only an
-        // explicit `true` extends auto ff to remote owning-daemon nodes.
-        remoteNodes: record2.remoteNodes === true,
-        // Absent/anything-but-continuous → 'idle' (historical idle-edge-only detection).
-        mode: record2.mode === "continuous" ? "continuous" : "idle"
-      };
-    }
     function sessionStateLooksActive(state) {
       const status = readNonEmptyString(state?.status).toLowerCase();
       const chatStatus = readNonEmptyString(state?.activeChat?.status).toLowerCase();
@@ -60797,7 +61415,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) && isIdleSessionState(state)) return false;
+        if (currentSessionId && sessionIdsEquivalent(sessionId, currentSessionId) && isIdleSessionState2(state)) return false;
         return sessionStateLooksActive(state);
       });
     }
@@ -60832,174 +61450,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       if (!coordinatorDaemonId) return { mode: "skip", reason: "remote_auto_launch_no_coordinator_daemon_id" };
       return { mode: "remote", daemonId, coordinatorDaemonId };
     }
-    function activeWriteAssignedCount(meshId) {
-      return getQueue(meshId, { status: ["assigned"] }).filter((task) => !isTaskReadonly(task)).length;
-    }
-    function activeReadonlyAssignedCount(meshId) {
-      return getQueue(meshId, { status: ["assigned"] }).filter(isTaskReadonly).length;
-    }
-    function nodeHasActiveAssignment(meshId, nodeId) {
-      return getQueue(meshId, { status: ["assigned"] }).some((task) => daemonIdsEquivalent(task.assignedNodeId, nodeId));
-    }
-    function nodeActiveLoad(meshId, nodeId) {
-      return MeshRuntimeStore.getInstance().nodeActiveAssignmentCount(meshId, nodeId);
-    }
-    function meshHasExplicitSlots(mesh) {
-      const nodes = Array.isArray(mesh?.nodes) ? mesh.nodes : [];
-      return nodes.some((n) => normalizeNodeCapabilitySlots(n?.policy?.slots).length > 0);
-    }
-    function resolveSchedulingStrategy(mesh) {
-      const raw = mesh?.policy?.schedulingStrategy;
-      if (typeof raw === "string" && raw.trim()) {
-        return normalizeMeshSchedulingStrategy(raw);
-      }
-      return meshHasExplicitSlots(mesh) ? "fitness" : normalizeMeshSchedulingStrategy(void 0);
-    }
-    function buildSchedulingPool(localCandidates, remoteCandidates) {
-      const pool = [...localCandidates, ...remoteCandidates].map((c) => ({
-        ...c,
-        nodeId: normalizeMeshNodeId(c.node) ?? c.nodeId
-      }));
-      const uniqueNodes = [...new Set(pool.map((c) => c.nodeId))].map((nodeId, index) => ({
-        nodeId,
-        node: pool.find((c) => meshNodeIdMatches({ id: c.nodeId }, nodeId))?.node,
-        index
-      }));
-      return { pool, uniqueNodes };
-    }
-    function scoreSlotForTask(slot, task, quotaBonus = 0) {
-      let score = 1;
-      const diff = isMeshTaskDifficulty(task.difficulty) ? task.difficulty : void 0;
-      if (diff) {
-        if (slot.difficulty?.length) {
-          score += slot.difficulty.includes(diff) ? 100 : 0;
-        } else {
-          score += 20;
-        }
-      }
-      const req = task.requiredTags?.filter((t) => !!t) ?? [];
-      if (req.length) {
-        const cap = new Set(slot.capability ?? []);
-        const covered = req.every((t) => cap.has(t));
-        score += covered ? 30 : 0;
-      }
-      score += quotaBonus;
-      return score;
-    }
-    function orderSlotsForProviderSelection(slots, meshId, nodeId, node, task, quotaBonusByProvider) {
-      return [...slots].sort((a, b) => {
-        const capDelta = Number(slotHasCapacity(meshId, nodeId, node, b)) - Number(slotHasCapacity(meshId, nodeId, node, a));
-        if (capDelta !== 0) return capDelta;
-        return scoreSlotForTask(b, task, quotaBonusByProvider?.[b.provider] ?? 0) - scoreSlotForTask(a, task, quotaBonusByProvider?.[a.provider] ?? 0);
-      });
-    }
-    function bestSlotForTask(node, task, meshId, quotaBonusByProvider) {
-      const slots = resolveNodeCapabilitySlots(node, meshId);
-      if (!slots.length) return null;
-      let best = null;
-      for (const slot of slots) {
-        const score = scoreSlotForTask(slot, task, quotaBonusByProvider?.[slot.provider] ?? 0);
-        if (!best || score > best.score) best = { slot, score };
-      }
-      return best;
-    }
-    function nodeFitnessForTask(node, task, meshId, quotaBonusByProvider) {
-      return bestSlotForTask(node, task, meshId, quotaBonusByProvider)?.score ?? 0;
-    }
-    function slotCoversTaskDifficulty(slot, difficulty) {
-      if (!slot) return false;
-      if (!isMeshTaskDifficulty(difficulty)) return false;
-      if (!slot.difficulty?.length) return true;
-      return slot.difficulty.includes(difficulty);
-    }
-    function resolveLaunchAxis(taskValue, taskSource, slotValue, slotCoversDifficulty) {
-      const stamped = typeof taskValue === "string" && taskValue.trim() ? taskValue.trim() : void 0;
-      if (!stamped) return slotValue;
-      if (taskSource !== "preset") return stamped;
-      return slotCoversDifficulty && slotValue ? slotValue : stamped;
-    }
-    function orderEligibleNodes(meshId, strategy, nodes, opts) {
-      if (strategy === "first_eligible" || nodes.length <= 1) {
-        return nodes;
-      }
-      if (strategy === "fitness" && opts?.task) {
-        const task = opts.task;
-        const bonusCache = /* @__PURE__ */ new Map();
-        const bonusFor = (c) => {
-          let bonus = bonusCache.get(c.nodeId);
-          if (!bonus) {
-            bonus = quotaSpreadBonusByProvider(c.node, opts.quotaRouting);
-            bonusCache.set(c.nodeId, bonus);
-          }
-          return bonus;
-        };
-        return [...nodes].sort((a, b) => {
-          const fitDelta = nodeFitnessForTask(b.node, task, meshId, bonusFor(b)) - nodeFitnessForTask(a.node, task, meshId, bonusFor(a));
-          if (fitDelta !== 0) return fitDelta;
-          const prioDelta = resolveNodeSchedulingPriority(b.node?.policy) - resolveNodeSchedulingPriority(a.node?.policy);
-          if (prioDelta !== 0) return prioDelta;
-          const loadDelta = nodeActiveLoad(meshId, a.nodeId) - nodeActiveLoad(meshId, b.nodeId);
-          if (loadDelta !== 0) return loadDelta;
-          return a.index - b.index;
-        });
-      }
-      const priorityOf = (n) => resolveNodeSchedulingPriority(n.node?.policy);
-      let rotation = 0;
-      if (strategy === "least_loaded" || strategy === "round_robin") {
-        const cursor = opts?.bumpCursor ? MeshRuntimeStore.getInstance().bumpSchedulerCursor(meshId) : MeshRuntimeStore.getInstance().getSchedulerCursor(meshId);
-        rotation = (cursor % nodes.length + nodes.length) % nodes.length;
-      }
-      const rotationRank = (index) => (index - rotation + nodes.length) % nodes.length;
-      return [...nodes].sort((a, b) => {
-        const prioDelta = priorityOf(b) - priorityOf(a);
-        if (prioDelta !== 0) return prioDelta;
-        if (strategy === "least_loaded" || strategy === "round_robin") {
-          const loadDelta = nodeActiveLoad(meshId, a.nodeId) - nodeActiveLoad(meshId, b.nodeId);
-          if (loadDelta !== 0) return loadDelta;
-        }
-        return rotationRank(a.index) - rotationRank(b.index);
-      });
-    }
-    function activeProviderAssignedCount(meshId, nodeId, providerType) {
-      return getQueue(meshId, { status: ["assigned"] }).filter((task) => daemonIdsEquivalent(task.assignedNodeId, nodeId) && task.assignedProviderType === providerType).length;
-    }
-    function activeSlotAssignedCount(meshId, nodeId, providerType, slot) {
-      return getQueue(meshId, { status: ["assigned"] }).filter((task) => {
-        if (!daemonIdsEquivalent(task.assignedNodeId, nodeId)) return false;
-        if (task.assignedProviderType !== providerType) return false;
-        const assignedModel = task.assignedModel;
-        if (typeof assignedModel !== "string" || !assignedModel.trim()) return true;
-        return isModelAllowedBySlot(assignedModel, slot);
-      }).length;
-    }
-    function slotCapacityRemaining(meshId, nodeId, node, slot) {
-      const providerType = typeof slot.provider === "string" ? slot.provider.trim() : "";
-      if (!providerType) return { available: false };
-      const slots = resolveNodeCapabilitySlots(node, meshId);
-      const slotCap = resolveSlotMaxParallel(slots, providerType, slot.model, isModelAllowedBySlot);
-      if (slotCap !== void 0 && activeSlotAssignedCount(meshId, nodeId, providerType, slot) >= slotCap) {
-        return { available: false, slotCap };
-      }
-      const providerCap = resolveProviderMaxParallel(slots, providerType);
-      if (providerCap !== void 0 && activeProviderAssignedCount(meshId, nodeId, providerType) >= providerCap) {
-        return { available: false, slotCap, providerCap };
-      }
-      return { available: true, slotCap, providerCap };
-    }
-    function slotHasCapacity(meshId, nodeId, node, slot) {
-      return slotCapacityRemaining(meshId, nodeId, node, slot).available;
-    }
-    function sessionHasActiveAssignment(meshId, sessionId) {
-      if (getQueue(meshId, { status: ["assigned"] }).some((task) => sessionIdsEquivalent(task.assignedSessionId, sessionId))) {
-        return true;
-      }
-      try {
-        if (getActiveDirectDispatches(meshId).some((d) => sessionIdsEquivalent(d.sessionId, sessionId))) return true;
-        if (hasUnterminalDirectDispatchLedgerEntry(meshId, sessionId)) return true;
-      } catch {
-      }
-      return false;
-    }
     function isSessionActivelyGenerating(components, sessionId) {
       if (!sessionId) return false;
       const state = components.instanceManager?.getInstance?.(sessionId)?.getState?.();
@@ -61594,7 +62044,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 (!isIdleSessionState(state)) {
+        if (!isIdleSessionState2(state)) {
           const status = readNonEmptyString(state.status).toLowerCase();
           skippedSessions.push({
             nodeId,
@@ -61701,209 +62151,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         ...pendingAfter > 0 && newlyAssignedTasks.length === 0 && localIdleSessionsChecked === 0 && remoteIdleSessionsChecked === 0 && !autoLaunchPending ? { noIdleMeshSessionAvailable: true } : {}
       };
     }
-    function dryRunSatisfiesAutoFastForwardPolicy(dryRun, policy) {
-      if (!dryRun || dryRun.code !== "fast_forward_available" || dryRun.allowed !== true) return false;
-      const behind = Number(dryRun.current?.behind);
-      if (!Number.isFinite(behind) || behind <= 0) return false;
-      if (policy.maxBehind !== void 0 && behind > policy.maxBehind) return false;
-      if (policy.requireCleanSubmodules) {
-        const submodules = Array.isArray(dryRun.current?.submodules) ? dryRun.current.submodules : [];
-        if (submodules.some((submodule) => submodule?.dirty || submodule?.outOfSync || submodule?.error)) return false;
-      }
-      return true;
-    }
-    function readNodeSubmoduleIgnorePaths(node) {
-      return Array.isArray(node?.policy?.submoduleIgnorePaths) ? node.policy.submoduleIgnorePaths.filter((value) => typeof value === "string") : void 0;
-    }
-    function nodeIsAutoFastForwardEligible(components, meshId, nodeId, node, currentSessionId) {
-      if (!node) return false;
-      if (node.status === "disabled" || node.status === "removed") return false;
-      if (node.readOnly === true || node.policy?.readOnly === true) return false;
-      if (isWorktreeBootstrapStaleRunning(node)) return false;
-      if (node.worktreeBootstrap?.status === "running") return false;
-      if (nodeHasActiveMeshWork(components, meshId, nodeId, currentSessionId)) return false;
-      return true;
-    }
-    function remoteNodeIsConnected(components, node) {
-      const daemonId = readMeshNodeDaemonId(node ?? {});
-      if (!daemonId) return false;
-      const getPeerStatus = components.getMeshPeerConnectionStatus;
-      if (getPeerStatus) {
-        const snapshot = getPeerStatus(daemonId);
-        return !!snapshot && String(snapshot.state) === "connected";
-      }
-      return readNonEmptyString(node?.connection?.state).toLowerCase() === "connected";
-    }
-    async function delegateRemoteAutoFastForward(components, args) {
-      const dispatchMeshCommand = components.dispatchMeshCommand;
-      if (!dispatchMeshCommand) return;
-      if (!acquireAutoFastForwardLease(args.workspace)) return;
-      const submoduleIgnorePaths = readNodeSubmoduleIgnorePaths(args.node);
-      const mesh = getMeshWithCache(components, args.meshId);
-      const baseArgs = {
-        meshId: args.meshId,
-        nodeId: args.nodeId,
-        workspace: args.workspace,
-        inlineMesh: mesh,
-        ...submoduleIgnorePaths ? { submoduleIgnorePaths } : {},
-        trigger: args.trigger,
-        // Preserve the pre-fix self-only semantics for submodules: the local idle path
-        // never updated submodules (updateSubmodules:false), so the remote path matches.
-        updateSubmodules: false
-      };
-      try {
-        const remoteDry = await dispatchMeshCommand(args.daemonId, "fast_forward_mesh_node", {
-          ...baseArgs,
-          execute: false,
-          dryRun: true
-        });
-        if (!dryRunSatisfiesAutoFastForwardPolicy(remoteDry, args.policy)) return;
-        if (nodeHasActiveMeshWork(components, args.meshId, args.nodeId)) return;
-        const executed = await dispatchMeshCommand(args.daemonId, "fast_forward_mesh_node", {
-          ...baseArgs,
-          execute: true,
-          dryRun: false
-        });
-        if (executed?.executed === true) {
-          LOG2.info("MeshFastForward", `Remote auto fast-forward executed for node ${args.nodeId} (daemon ${String(args.daemonId).slice(0, 12)}, trigger ${args.trigger})`);
-        }
-      } catch (e) {
-        LOG2.warn("MeshFastForward", `Remote auto fast-forward delegation failed for ${args.nodeId}: ${e?.message || e}`);
-      } finally {
-        releaseAutoFastForwardLease(args.workspace);
-      }
-    }
-    async function executeLocalAutoFastForward(args) {
-      if (!acquireAutoFastForwardLease(args.workspace)) return;
-      const submoduleIgnorePaths = readNodeSubmoduleIgnorePaths(args.node);
-      try {
-        const dryRun = await fastForwardMeshNode({
-          meshId: args.meshId,
-          nodeId: args.nodeId,
-          workspace: args.workspace,
-          execute: false,
-          dryRun: true,
-          updateSubmodules: false,
-          submoduleIgnorePaths,
-          trigger: args.trigger
-        });
-        if (!dryRunSatisfiesAutoFastForwardPolicy(dryRun, args.policy)) return;
-        await fastForwardMeshNode({
-          meshId: args.meshId,
-          nodeId: args.nodeId,
-          workspace: args.workspace,
-          execute: true,
-          dryRun: false,
-          updateSubmodules: false,
-          submoduleIgnorePaths,
-          trigger: args.trigger
-        });
-      } catch (e) {
-        LOG2.warn("MeshFastForward", `Idle auto fast-forward check failed for ${args.nodeId}: ${e?.message || e}`);
-      } finally {
-        releaseAutoFastForwardLease(args.workspace);
-      }
-    }
-    async function maybeAutoFastForwardIdleNode(components, args) {
-      const mesh = getMeshWithCache(components, args.meshId);
-      const node = mesh?.nodes?.find((candidate) => meshNodeIdMatches(candidate, args.nodeId));
-      const workspace = readNonEmptyString(node?.workspace);
-      if (!workspace) return;
-      const policy = resolveAutoFastForwardPolicy(mesh);
-      if (!policy.enabled) return;
-      if (nodeHasActiveMeshWork(components, args.meshId, args.nodeId, args.sessionId)) return;
-      const throttleKey = `${args.meshId}:${args.nodeId}`;
-      const now = Date.now();
-      const lastAttempt = idleAutoFastForwardLastAttempt.get(throttleKey) || 0;
-      if (now - lastAttempt < IDLE_AUTO_FAST_FORWARD_THROTTLE_MS) return;
-      idleAutoFastForwardLastAttempt.set(throttleKey, now);
-      if (isLocalAutoLaunchNode(node)) {
-        if (!(0, import_fs14.existsSync)(workspace)) return;
-        await executeLocalAutoFastForward({ meshId: args.meshId, nodeId: args.nodeId, node, workspace, policy, trigger: "idle_auto" });
-        return;
-      }
-      if (!policy.remoteNodes) return;
-      const daemonId = readMeshNodeDaemonId(node ?? {});
-      if (!daemonId || !components.dispatchMeshCommand) return;
-      if (!remoteNodeIsConnected(components, node)) return;
-      await delegateRemoteAutoFastForward(components, { meshId: args.meshId, nodeId: args.nodeId, node, daemonId, workspace, policy, trigger: "idle_auto" });
-    }
-    async function runContinuousAutoFastForwardScan(components, mesh) {
-      if (!components.dispatchMeshCommand) return;
-      const policy = resolveAutoFastForwardPolicy(mesh);
-      if (!policy.enabled || !policy.remoteNodes || policy.mode !== "continuous") return;
-      const meshId = readNonEmptyString(mesh?.id);
-      if (!meshId) return;
-      const nodes = Array.isArray(mesh?.nodes) ? mesh.nodes : [];
-      const now = Date.now();
-      for (const node of nodes) {
-        const nodeId = normalizeMeshNodeId(node);
-        if (!nodeId) continue;
-        if (node?.isLocalWorktree === true) continue;
-        if (isLocalAutoLaunchNode(node)) continue;
-        const workspace = readNonEmptyString(node?.workspace);
-        if (!workspace) continue;
-        const daemonId = readMeshNodeDaemonId(node ?? {});
-        if (!daemonId) continue;
-        if (!nodeIsAutoFastForwardEligible(components, meshId, nodeId, node)) continue;
-        if (!remoteNodeIsConnected(components, node)) continue;
-        const cooldownKey = `${meshId}:${nodeId}`;
-        const lastScan = continuousAutoFastForwardLastScan.get(cooldownKey) || 0;
-        if (now - lastScan < CONTINUOUS_AUTO_FAST_FORWARD_SCAN_COOLDOWN_MS) continue;
-        continuousAutoFastForwardLastScan.set(cooldownKey, now);
-        await delegateRemoteAutoFastForward(components, { meshId, nodeId, node, daemonId, workspace, policy, trigger: "reconcile_auto" });
-      }
-    }
-    async function runPendingCoordinatorCatchupScan(components, mesh) {
-      const meshId = readNonEmptyString(mesh?.id);
-      if (!meshId) return;
-      const localIds = expandDaemonIdForms([
-        readNonEmptyString(components.statusInstanceId),
-        readNonEmptyString(loadConfig2().machineId)
-      ]);
-      let markers = [];
-      try {
-        markers = drainPendingMeshCoordinatorEvents(
-          meshId,
-          localIds.length > 0 ? localIds : void 0,
-          { onlyEvents: /* @__PURE__ */ new Set(["coordinator_catchup"]) }
-        );
-      } catch (e) {
-        LOG2.warn("MeshReconcile", `Coordinator-catchup drain failed for mesh ${meshId}: ${e?.message || e}`);
-        return;
-      }
-      if (markers.length === 0) return;
-      const nodes = Array.isArray(mesh?.nodes) ? mesh.nodes : [];
-      for (const marker of markers) {
-        const meta3 = marker.metadataEvent || {};
-        const nodeId = readNonEmptyString(marker.nodeId) || readNonEmptyString(meta3.nodeId);
-        const workspace = readNonEmptyString(marker.workspace) || readNonEmptyString(meta3.workspace);
-        const baseBranch = readNonEmptyString(meta3.baseBranch);
-        if (!workspace) continue;
-        if (nodeId && nodeHasActiveMeshWork(components, meshId, nodeId)) {
-          try {
-            queuePendingMeshCoordinatorEvent(marker);
-          } catch {
-          }
-          continue;
-        }
-        try {
-          const ff = await fastForwardMeshNode({
-            meshId,
-            ...nodeId ? { nodeId } : {},
-            workspace,
-            ...baseBranch ? { branch: baseBranch } : {},
-            mode: "merge",
-            execute: true,
-            trigger: "refine_post_push_catchup",
-            allowAutoPublishSubmoduleMainCommits: mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true
-          });
-          LOG2.info("MeshReconcile", `Coordinator catch-up ff for ${meshId}/${nodeId || workspace}: ${ff.code} (executed=${ff.executed})`);
-        } catch (e) {
-          LOG2.warn("MeshReconcile", `Coordinator catch-up ff failed for ${meshId}/${nodeId || workspace}: ${e?.message || e}`);
-        }
-      }
-    }
     function runIdleMaintenanceThenAssignQueue(components, args) {
       setImmediate(() => {
         maybeAutoFastForwardIdleNode(components, args).finally(() => {
@@ -61915,12 +62162,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         });
       });
     }
-    var import_fs14;
-    var IDLE_AUTO_FAST_FORWARD_THROTTLE_MS;
-    var idleAutoFastForwardLastAttempt;
-    var CONTINUOUS_AUTO_FAST_FORWARD_SCAN_COOLDOWN_MS;
-    var continuousAutoFastForwardLastScan;
-    var autoFastForwardWorkspaceLease;
     var BOOTSTRAP_TERMINAL_STATUSES;
     var DISPATCH_CONFIRM_TIMEOUT_MS;
     var DISPATCH_CONNECT_TIMEOUT_MS;
@@ -61936,15 +62177,9 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     var autoLaunchAwaitClaimBackoff;
     var lastAutoLaunchLedgerKey;
     var AUTO_LAUNCH_LEDGER_DEDUP_MAX;
-    var ACTIONABLE_SKIP_REASON_PREFIXES;
-    var TRANSIENT_TARGET_NODE_BOOTSTRAP_PENDING_REASON;
-    var lastActionableSkipNotified;
-    var DEAD_TARGET_GRACE_MS;
-    var TARGET_SESSION_PIN_TTL_MS;
     var init_mesh_queue_assignment = __esm2({
       "src/mesh/mesh-queue-assignment.ts"() {
         "use strict";
-        import_fs14 = require("fs");
         init_runtime_defaults();
         init_config();
         init_mesh_config();
@@ -61953,7 +62188,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         init_mesh_ledger();
         init_mesh_work_queue();
         init_transcript_evidence();
-        init_mesh_fast_forward();
         init_mesh_delivery_policy();
         init_mesh_runtime_store();
         init_mesh_event_trace();
@@ -61966,19 +62200,18 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         init_mesh_events_stale();
         init_mesh_events_utils();
         init_mesh_node_identity();
-        init_mesh_events_pending();
         init_worktree_bootstrap_config();
-        init_mesh_clone_grace();
         init_mesh_task_inflight();
         init_model_provider_compat();
         init_slot_model_enforcement();
         init_mesh_turn_ledger();
         init_mesh_duplicate_dispatch();
-        IDLE_AUTO_FAST_FORWARD_THROTTLE_MS = 30 * 60 * 1e3;
-        idleAutoFastForwardLastAttempt = /* @__PURE__ */ new Map();
-        CONTINUOUS_AUTO_FAST_FORWARD_SCAN_COOLDOWN_MS = 45 * 1e3;
-        continuousAutoFastForwardLastScan = /* @__PURE__ */ new Map();
-        autoFastForwardWorkspaceLease = /* @__PURE__ */ new Set();
+        init_mesh_auto_fast_forward();
+        init_mesh_skip_notify();
+        init_mesh_scheduling_fitness();
+        init_mesh_auto_fast_forward();
+        init_mesh_skip_notify();
+        init_mesh_scheduling_fitness();
         BOOTSTRAP_TERMINAL_STATUSES = /* @__PURE__ */ new Set(["complete", "failed"]);
         DISPATCH_CONFIRM_TIMEOUT_MS = 12e4;
         DISPATCH_CONNECT_TIMEOUT_MS = MESH_CONNECT_TIMEOUT_MS2;
@@ -61994,43 +62227,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         autoLaunchAwaitClaimBackoff = /* @__PURE__ */ new Map();
         lastAutoLaunchLedgerKey = /* @__PURE__ */ new Map();
         AUTO_LAUNCH_LEDGER_DEDUP_MAX = 2e3;
-        ACTIONABLE_SKIP_REASON_PREFIXES = [
-          "target_node_id_unmatched",
-          "no_node_satisfies_required_tags",
-          "mesh_convergence_target_is_worktree",
-          "remote_auto_launch_unsupported",
-          "remote_auto_launch_no_coordinator_daemon_id",
-          "missing_provider_priority",
-          "provider_loader_unavailable",
-          "provider_priority_unusable",
-          "provider_unusable",
-          "dirty_workspace",
-          // TARGET-PIN-TTL EXPIRY: the task was pinned to a specific session (a delta —
-          // a correction addressed to work already in flight) and that session never
-          // claimed it within the TTL, so the pin was cleared. Unlike the transient
-          // skips, this does NOT self-resolve into the intended outcome: the delta is
-          // now claimable by ANY compatible session, i.e. it will not reach the session
-          // it was written for. Previously this only bumped a metrics counter and wrote
-          // a log, so the coordinator kept waiting for a delivery that could no longer
-          // happen — measured live as 74min of silence while a worker continued on a
-          // premise the delta was meant to correct. The coordinator must know its
-          // addressed message lost its address.
-          "target_session_pin_expired",
-          // 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
-          // busy counterpart SLOT_MODEL_BUSY_SKIP_REASON is deliberately NOT listed:
-          // that one clears on its own when the slot goes idle.
-          SLOT_MODEL_ABSENT_SKIP_REASON
-          // QUOTA GATE: 'provider_quota_session_low' / 'provider_quota_weekly_low' are
-          // deliberately NOT listed either — an exhausted quota window RESETS, so the
-          // block self-resolves exactly like the slot-busy case; the task waits in the
-          // queue and the coordinator is not paged (mesh-quota-routing.ts).
-        ];
-        TRANSIENT_TARGET_NODE_BOOTSTRAP_PENDING_REASON = "target_node_bootstrap_pending";
-        lastActionableSkipNotified = /* @__PURE__ */ new Map();
-        DEAD_TARGET_GRACE_MS = 6e4;
-        TARGET_SESSION_PIN_TTL_MS = 15 * 6e4;
       }
     });
     function readSettings(state) {
@@ -62504,6 +62700,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         return cachedBinding;
       }
       const errors = [];
+      let allModuleNotFound = true;
       for (const ref of getBindingCandidates()) {
         try {
           const mod = require(ref);
@@ -62515,15 +62712,19 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
             errors.push(`${ref}: module not found`);
             continue;
           }
+          allModuleNotFound = false;
           const message = error48 instanceof Error ? error48.message : String(error48);
           errors.push(`${ref}: ${message}`);
         }
       }
-      cachedBinding = null;
-      cachedBindingError = new Error(
+      const buildError = () => new Error(
         `ghostty-vt binding unavailable for runtime ${runtimeTriplet()} (${errors.join("; ") || "no candidates tried"})`
       );
-      throw cachedBindingError;
+      if (allModuleNotFound) {
+        cachedBinding = null;
+        cachedBindingError = buildError();
+      }
+      throw buildError();
     }
     var DEFAULT_BINDING_CANDIDATES;
     var cachedBinding;
@@ -68949,6 +69150,7 @@ ${cleanBody}`;
     });
     var mesh_events_exports = {};
     __export2(mesh_events_exports, {
+      PENDING_RETENTION_EXPIRED_HOLD_REASON: () => PENDING_RETENTION_EXPIRED_HOLD_REASON,
       __resetIdleAutoFastForwardForTests: () => __resetIdleAutoFastForwardForTests,
       __resetMeshWorkspaceCacheForTests: () => __resetMeshWorkspaceCacheForTests,
       clearPendingMeshCoordinatorEvents: () => clearPendingMeshCoordinatorEvents,
@@ -68956,6 +69158,7 @@ ${cleanBody}`;
       getMeshV2BackstopCounters: () => getMeshV2BackstopCounters,
       getMeshV2DrainCounters: () => getMeshV2DrainCounters,
       getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
+      getPendingRetentionCounters: () => getPendingRetentionCounters,
       handleMeshForwardEvent: () => handleMeshForwardEvent,
       isMeshCoordinatorEvent: () => isMeshCoordinatorEvent,
       isMeshProtocolV2EnforceEnabled: () => isMeshProtocolV2EnforceEnabled,
@@ -69936,20 +70139,31 @@ ${cleanBody}`;
     });
     var pty_transport_exports = {};
     __export2(pty_transport_exports, {
-      NodePtyTransportFactory: () => NodePtyTransportFactory
+      NodePtyTransportFactory: () => NodePtyTransportFactory,
+      __setNodePtyLoaderForTests: () => __setNodePtyLoaderForTests
     });
+    function isModuleNotFoundError2(error48) {
+      return error48 instanceof Error && "code" in error48 && error48.code === "MODULE_NOT_FOUND";
+    }
     function loadNodePty() {
       if (cachedPty !== void 0) return cachedPty;
       try {
-        cachedPty = require("node-pty");
+        cachedPty = requireNodePty();
         (0, import_session_host_core3.ensureNodePtySpawnHelperPermissions)();
-      } catch {
-        cachedPty = null;
+      } catch (error48) {
+        if (isModuleNotFoundError2(error48)) {
+          cachedPty = null;
+        }
       }
-      return cachedPty;
+      return cachedPty ?? null;
+    }
+    function __setNodePtyLoaderForTests(loader2) {
+      cachedPty = void 0;
+      requireNodePty = loader2 ?? (() => require("node-pty"));
     }
     var os12;
     var cachedPty;
+    var requireNodePty;
     var NodePtyRuntimeTransport;
     var NodePtyTransportFactory;
     var init_pty_transport = __esm2({
@@ -69958,6 +70172,7 @@ ${cleanBody}`;
         os12 = __toESM2(require("os"));
         init_spawn_env();
         init_resolve_executable();
+        requireNodePty = () => require("node-pty");
         NodePtyRuntimeTransport = class {
           constructor(handle) {
             this.handle = handle;
@@ -70012,6 +70227,100 @@ ${cleanBody}`;
         };
       }
     });
+    function resolveTerminationSignal(termination) {
+      if (typeof termination.signal === "number" && termination.signal > 0) return termination.signal;
+      const code = termination.exitCode;
+      if (typeof code === "number" && code > 128 && code <= 159) return code - 128;
+      return null;
+    }
+    function terminationSignalName(signal) {
+      return signal !== null ? SIGNAL_NAMES[signal] : void 0;
+    }
+    function classifyMeshTerminationStop(termination) {
+      const signal = resolveTerminationSignal(termination);
+      const signalName = terminationSignalName(signal);
+      if (termination.requestedStop) {
+        return { reason: "host_requested_stop", intentional: true, signal, signalName };
+      }
+      if (signal !== null) return { reason: "external_signal", intentional: false, signal, signalName };
+      if (termination.exitCode === null) return { reason: "unknown_termination", intentional: false, signal, signalName };
+      if (termination.exitCode === 0) return { reason: "self_exit", intentional: false, signal, signalName };
+      return { reason: "unexpected_exit", intentional: false, signal, signalName };
+    }
+    function buildMeshTerminationStopPayload(input) {
+      const { termination } = input;
+      const classified = classifyMeshTerminationStop(termination);
+      const terminatedAtIso = Number.isFinite(termination.terminatedAt) ? new Date(termination.terminatedAt).toISOString() : void 0;
+      const lastOutputAtIso = typeof termination.lastOutputAt === "number" && Number.isFinite(termination.lastOutputAt) ? new Date(termination.lastOutputAt).toISOString() : void 0;
+      const silentForMs = typeof termination.lastOutputAt === "number" && Number.isFinite(termination.lastOutputAt) && Number.isFinite(termination.terminatedAt) && termination.terminatedAt >= termination.lastOutputAt ? termination.terminatedAt - termination.lastOutputAt : void 0;
+      return {
+        intentional: classified.intentional,
+        reason: classified.reason,
+        // `source` marks who wrote the row, mirroring the operator-cleanup path's
+        // convention so a reader can tell the two writers apart.
+        source: "session_host_tombstone",
+        observedVia: "session_exit",
+        exitCode: termination.exitCode,
+        signal: classified.signal,
+        ...classified.signalName ? { signalName: classified.signalName } : {},
+        // session-host's own classification, kept verbatim alongside ours so the
+        // ledger never silently disagrees with the tombstone on disk.
+        terminationReason: termination.reason,
+        lifecycle: termination.lifecycle,
+        ...termination.previousLifecycle ? { previousLifecycle: termination.previousLifecycle } : {},
+        ...termination.requestedStop ? { requestedStop: termination.requestedStop } : {},
+        ...typeof termination.osPid === "number" ? { osPid: termination.osPid } : {},
+        ...terminatedAtIso ? { terminatedAt: terminatedAtIso } : {},
+        ...lastOutputAtIso ? { lastOutputAt: lastOutputAtIso } : {},
+        ...silentForMs !== void 0 ? { silentForMs } : {},
+        ...input.isCoordinator ? { coordinatorSession: true } : {},
+        ...input.workspace ? { workspace: input.workspace } : {}
+      };
+    }
+    function resolveMeshTerminationBinding(settings) {
+      if (!settings || typeof settings !== "object") return null;
+      const read = (value) => typeof value === "string" ? value.trim() : "";
+      const workerMeshId = read(settings.meshNodeFor);
+      if (workerMeshId) {
+        const nodeId = read(settings.meshNodeId);
+        return { meshId: workerMeshId, ...nodeId ? { nodeId } : {}, isCoordinator: false };
+      }
+      const coordinatorMeshId = read(settings.meshCoordinatorFor);
+      if (coordinatorMeshId) return { meshId: coordinatorMeshId, isCoordinator: true };
+      return null;
+    }
+    async function recordMeshSessionTerminationStop(input) {
+      if (!input.meshId || !input.sessionId) return;
+      try {
+        const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+        appendLedgerEntry2(input.meshId, {
+          kind: "session_stopped",
+          ...input.nodeId ? { nodeId: input.nodeId } : {},
+          sessionId: input.sessionId,
+          ...input.providerType ? { providerType: input.providerType } : {},
+          payload: buildMeshTerminationStopPayload(input)
+        });
+      } catch (e) {
+        LOG2.warn("MeshTermination", `Failed to record termination stop for ${input.sessionId}: ${e?.message || e}`);
+      }
+    }
+    var SIGNAL_NAMES;
+    var init_mesh_termination_bridge = __esm2({
+      "src/mesh/mesh-termination-bridge.ts"() {
+        "use strict";
+        init_logger();
+        SIGNAL_NAMES = {
+          1: "SIGHUP",
+          2: "SIGINT",
+          3: "SIGQUIT",
+          6: "SIGABRT",
+          9: "SIGKILL",
+          11: "SIGSEGV",
+          13: "SIGPIPE",
+          15: "SIGTERM"
+        };
+      }
+    });
     function chunkPreservingSurrogates(text, size) {
       const chunks = [];
       let offset = 0;
@@ -74444,6 +74753,7 @@ ${cont}` : cont;
         init_terminal_screen();
         import_session_host_core8 = require_dist();
         init_pty_transport();
+        init_mesh_termination_bridge();
         init_pty_write_chunking();
         init_provider_cli_shared();
         init_cli_script_runner();
@@ -74457,9 +74767,10 @@ ${cont}` : cont;
         missingBackgroundSourceWarned = /* @__PURE__ */ new Set();
         FORCE_SUBMIT_SETTLE_MS = 150;
         ProviderCliAdapter = class _ProviderCliAdapter {
-          constructor(provider, workingDir, extraArgs = [], extraEnv = {}, transportFactory = new NodePtyTransportFactory()) {
+          constructor(provider, workingDir, extraArgs = [], extraEnv = {}, transportFactory = new NodePtyTransportFactory(), owningSessionId) {
             this.extraArgs = extraArgs;
             this.extraEnv = extraEnv;
+            this.owningSessionId = owningSessionId;
             this.runner = new CliScriptRunner(provider.type);
             this.provider = provider;
             this.transportFactory = transportFactory;
@@ -74909,8 +75220,9 @@ ${lastSnapshot}`;
                 }
               }
             });
-            this.ptyProcess.onExit(({ exitCode, signal }) => {
+            this.ptyProcess.onExit(({ exitCode, signal, termination }) => {
               LOG2.info("CLI", `[${this.cliType}] Exit code ${exitCode === null || exitCode === void 0 ? "unknown" : exitCode}${signal ? ` (signal ${signal})` : ""}`);
+              this.recordMeshTerminationIfBound(termination);
               this.flushPendingOutputParse();
               this.ptyProcess = null;
               this.engine.onPtyExit();
@@ -74938,6 +75250,38 @@ ${lastSnapshot}`;
             this.scheduleStartupSettleCheck();
             this.onStatusChange?.();
           }
+          /**
+           * TOMBSTONE-LEDGER-BRIDGE: write a mesh `session_stopped` ledger entry for a
+           * terminated mesh session.
+           *
+           * This is the daemon's existing observation point for a dying CLI child — the
+           * session host already emits `session_exit` carrying its termination
+           * classification, so no watcher or polling loop is added. Previously the
+           * classification was discarded here, which is why an externally-killed mesh
+           * session (e.g. a SIGTERM from outside the mesh) left the ledger with no entry
+           * at all and its death read as an unexplained gap in the record.
+           *
+           * Silent no-op for a non-mesh session or a transport that reports no
+           * termination (raw node-pty), and never throws into the exit path.
+           */
+          recordMeshTerminationIfBound(termination) {
+            if (!termination || !this.owningSessionId) return;
+            try {
+              const binding = resolveMeshTerminationBinding(this.runtimeSettings);
+              if (!binding) return;
+              void recordMeshSessionTerminationStop({
+                meshId: binding.meshId,
+                sessionId: this.owningSessionId,
+                nodeId: binding.nodeId,
+                providerType: this.cliType,
+                workspace: this.workingDir,
+                isCoordinator: binding.isCoordinator,
+                termination
+              });
+            } catch (e) {
+              LOG2.warn("CLI", `[${this.cliType}] mesh termination ledger bridge failed: ${e?.message || e}`);
+            }
+          }
           // ─── Output Handling ────────────────────────────
           handleOutput(rawData) {
             this.terminalScreen.write(rawData);
@@ -84198,10 +84542,50 @@ ${effect.notification.body || ""}`.trim();
     init_contracts2();
     init_chat_history();
     init_state_store();
-    init_coordinator_registry();
-    init_mesh_turn_presentation();
     init_logger();
     init_debug_trace();
+    init_chat_message_normalization();
+    init_contracts2();
+    init_coordinator_registry();
+    init_logger();
+    init_chat_message_normalization();
+    function normalizeReadChatTailLimit(args) {
+      const value = Number(args?.tailLimit || 0);
+      return Number.isFinite(value) ? Math.max(0, value) : 0;
+    }
+    function normalizeReadChatMessages(payload) {
+      const messages = Array.isArray(payload.messages) ? payload.messages : [];
+      return normalizeChatMessages(messages);
+    }
+    function maybeHideCoordinatorPromptMessage(h, providerType, sessionId, messages) {
+      if (!Array.isArray(messages) || messages.length === 0) return messages;
+      if (!sessionId) return messages;
+      const loader2 = h.ctx?.providerLoader;
+      if (!loader2) return messages;
+      let showSetting = void 0;
+      try {
+        showSetting = loader2.getSettingValue?.(providerType, "showCoordinatorSystemPrompt");
+      } catch {
+      }
+      if (showSetting === true) return messages;
+      const coord = getCoordinatorForSession(sessionId);
+      if (!coord) return messages;
+      const promptBody = typeof coord.systemPrompt === "string" ? coord.systemPrompt : "";
+      const MARKER = "adhdev-mesh-coordinator-prompt";
+      const filtered = messages.filter((m) => {
+        const role = String(m?.role || "").toLowerCase();
+        if (role !== "user" && role !== "system") return true;
+        const content = flattenContent(m?.content);
+        if (!content) return true;
+        if (content.includes(MARKER)) return false;
+        if (promptBody && content.includes(promptBody.slice(0, Math.min(400, promptBody.length)))) return false;
+        return true;
+      });
+      if (filtered.length !== messages.length) {
+        LOG2.debug("ChatFilter", `[${providerType}] hid ${messages.length - filtered.length} coordinator-prompt message(s) from ${sessionId}`);
+      }
+      return filtered;
+    }
     var INITIAL_CHAT_SOURCE_STATE = Object.freeze({
       name: "Booting",
       nativeSequencePeak: void 0,
@@ -84571,9 +84955,394 @@ ${effect.notification.body || ""}`.trim();
       return `v1:${providerType}:${sessionId}:${ts2 ?? ""}:${positionalSeq}:${role}`;
     }
     var CHAT_SOURCE_REGISTRY = new ChatSourceRegistry();
+    init_chat_history();
+    var CLI_NATIVE_TRANSCRIPT_PROVIDERS = /* @__PURE__ */ new Set(["codex-cli", "claude-cli", "hermes-cli", "antigravity-cli"]);
+    var warnedLegacyNativeAllowlistHits = /* @__PURE__ */ new Set();
+    function warnLegacyNativeAllowlistHit(providerType) {
+      if (warnedLegacyNativeAllowlistHits.has(providerType)) return;
+      warnedLegacyNativeAllowlistHits.add(providerType);
+      console.warn(
+        `[chat-commands] supportsCliNativeTranscript fell back to the hardcoded CLI_NATIVE_TRANSCRIPT_PROVIDERS set for "${providerType}". The provider module was unavailable or did not declare canonicalHistory. Set canonicalHistory.contractVersion in the provider.json to remove this dependency.`
+      );
+    }
+    function supportsCliNativeTranscript(providerType, provider) {
+      if (provider?.category === "cli" && isNativeSourceCanonicalHistory(provider?.nativeHistory)) {
+        return true;
+      }
+      if (CLI_NATIVE_TRANSCRIPT_PROVIDERS.has(providerType)) {
+        warnLegacyNativeAllowlistHit(providerType);
+        return true;
+      }
+      return false;
+    }
+    function getMessageNewestReceivedAt(messages) {
+      let newest = 0;
+      for (const message of messages) {
+        const receivedAt = Number(message?.receivedAt ?? message?.timestamp ?? 0);
+        if (Number.isFinite(receivedAt) && receivedAt > newest) newest = receivedAt;
+      }
+      return newest;
+    }
+    function buildCliMessageSourceProvenance(args) {
+      const sourceMtimeMs = Number(args.sourceMtimeMs || 0);
+      const sourceMtimeAgeMs = sourceMtimeMs > 0 ? Math.max(0, Date.now() - sourceMtimeMs) : void 0;
+      const nativeMessages = args.nativeMessages || [];
+      const ptyMessages = args.ptyMessages || [];
+      const returnedMessages = args.returnedMessages || [];
+      const identityStatus = args.selected === "native-history" ? "safe" : args.fallbackReason === "native_history_not_safely_mapped" ? "ambiguous_session_identity" : args.fallbackReason?.startsWith("native_history_unavailable") ? "transcript_unmapped" : void 0;
+      return {
+        selected: args.selected,
+        provider: args.provider,
+        providerType: args.provider,
+        ...identityStatus ? { identityStatus } : {},
+        ...args.nativeHandle ? { nativeHandle: args.nativeHandle } : {},
+        ...args.nativeHandle ? { nativeSessionId: args.nativeHandle } : {},
+        ...args.sessionWorkspace ? { sessionWorkspace: args.sessionWorkspace } : {},
+        ...args.intendedWorkspace ? { intendedWorkspace: args.intendedWorkspace } : {},
+        ...args.transcriptWorkspace ? { transcriptWorkspace: args.transcriptWorkspace } : {},
+        ...args.fallbackReason ? { fallbackReason: args.fallbackReason } : {},
+        ...args.nativeSource ? { nativeSource: args.nativeSource } : {},
+        ...args.sourcePath ? { sourcePath: args.sourcePath } : {},
+        ...args.nativeHistoryCoverage ? { nativeHistoryCoverage: args.nativeHistoryCoverage } : {},
+        ...args.partialReason ? { partialReason: args.partialReason } : {},
+        ...args.unavailableReason ? { unavailableReason: args.unavailableReason } : {},
+        ptyStatusApprovalOnly: args.ptyStatusApprovalOnly === true,
+        staleness: {
+          sourceMtimeMs: sourceMtimeMs || void 0,
+          sourceMtimeAgeMs,
+          nativeNewestMessageAt: getMessageNewestReceivedAt(nativeMessages),
+          ptyNewestMessageAt: getMessageNewestReceivedAt(ptyMessages),
+          freshEnough: args.freshEnough === true
+        },
+        coverage: {
+          nativeMessageCount: nativeMessages.length,
+          ptyMessageCount: ptyMessages.length,
+          returnedMessageCount: returnedMessages.length,
+          safeMapping: args.safeMapping === true,
+          // true when PTY message bodies are suppressed and must not be treated as
+          // chat content. PTY may still contribute status/approval/screen evidence.
+          ptyMessagesSuppressed: args.selected === "native-history" || args.ptyStatusApprovalOnly === true
+        }
+      };
+    }
+    function causeToLegacyFallbackReason(cause, selected, extraDetail) {
+      if (selected === "native-history") return void 0;
+      switch (cause) {
+        case "initial":
+          return "native_history_not_checked";
+        case "native_progressed":
+          return "native_history_not_selected";
+        case "native_regressed_shrunk":
+          return "native_history_empty";
+        case "native_regressed_unsafe_mapping":
+          return "native_history_not_safely_mapped";
+        case "native_regressed_coverage_partial":
+          return "native_history_partial";
+        case "native_regressed_coverage_unavailable":
+          return "native_history_unavailable";
+        case "native_unavailable_read_error":
+          return extraDetail?.unavailableReason ? `native_history_unavailable:${extraDetail.unavailableReason}` : "native_history_unavailable";
+        case "native_unavailable_provider_unsupported":
+          return "provider_native_transcript_not_supported";
+        case "native_unavailable_empty":
+          return "native_history_empty";
+        case "native_unavailable_not_native_source":
+          return extraDetail?.nativeSource ? `native_history_source_${extraDetail.nativeSource}` : "native_history_unavailable";
+      }
+    }
+    function decideCliReadChatSource(args) {
+      const supportsNative = supportsCliNativeTranscript(args.providerType, args.provider);
+      const observation = buildObservationForCli(args, supportsNative);
+      const sessionKey = chatSourceSessionKey(args.providerType, args.sessionId);
+      const priorSnapshot = CHAT_SOURCE_REGISTRY.snapshotRecord(sessionKey);
+      const priorState = priorSnapshot?.state ?? CHAT_SOURCE_REGISTRY.getState(sessionKey);
+      const eligibleForStickyHold = args.trustedExactNativeIdentity === true && (priorState.name === "NativeLocked" || priorState.name === "Recovering");
+      let decision = CHAT_SOURCE_REGISTRY.observe(sessionKey, observation);
+      const heldNativeMessages = observation.kind === "native_present" ? extractNativeMessagesFromResult(args.providerType, args.nativeHistoryResult) : [];
+      const mayHoldNativeSlice = heldNativeMessages.length > 0 && args.safeMapping === true;
+      if (eligibleForStickyHold && decision.selected === "pty-parser" && mayHoldNativeSlice) {
+        CHAT_SOURCE_REGISTRY.restoreRecord(sessionKey, priorSnapshot);
+        const messageSource2 = buildCliMessageSourceProvenance({
+          selected: "native-history",
+          provider: args.providerType,
+          nativeHandle: typeof args.nativeHistoryResult?.providerSessionId === "string" ? args.nativeHistoryResult.providerSessionId : void 0,
+          sessionWorkspace: args.sessionWorkspace,
+          intendedWorkspace: args.intendedWorkspace,
+          transcriptWorkspace: void 0,
+          fallbackReason: "native_history_transient_gap_held",
+          nativeSource: "provider-native",
+          sourcePath: typeof args.nativeHistoryResult?.sourcePath === "string" ? args.nativeHistoryResult.sourcePath : void 0,
+          sourceMtimeMs: typeof args.nativeHistoryResult?.sourceMtimeMs === "number" ? args.nativeHistoryResult.sourceMtimeMs : void 0,
+          nativeHistoryCoverage: void 0,
+          partialReason: void 0,
+          unavailableReason: observation.kind === "native_unavailable" ? observation.reason : void 0,
+          nativeMessages: heldNativeMessages,
+          ptyMessages: args.ptyMessages,
+          returnedMessages: heldNativeMessages,
+          safeMapping: args.safeMapping,
+          freshEnough: true,
+          ptyStatusApprovalOnly: true
+        });
+        return {
+          decision: {
+            selected: "native-history",
+            nextState: priorState,
+            transition: {
+              fromState: priorState.name,
+              toState: priorState.name,
+              event: "NoOp",
+              cause: decision.transition.cause,
+              at: Date.now()
+            },
+            lockState: { locked: priorState.name === "NativeLocked" }
+          },
+          messageSource: messageSource2,
+          nativeMessages: heldNativeMessages,
+          nativeSelected: true
+        };
+      }
+      if (decision.selected === "pty-parser" && args.trustedExactNativeIdentity === true && args.safeMapping && args.ptyMessages.length === 0 && observation.kind === "native_present" && observation.coverage !== "partial" && observation.messages.length > 0) {
+        CHAT_SOURCE_REGISTRY.clear(sessionKey);
+        decision = CHAT_SOURCE_REGISTRY.observe(sessionKey, observation);
+      }
+      const nativeMessages = observation.kind === "native_present" ? extractNativeMessagesFromResult(args.providerType, args.nativeHistoryResult) : [];
+      const nativeSource = typeof args.nativeHistoryResult?.source === "string" ? args.nativeHistoryResult.source : void 0;
+      const sourcePath = typeof args.nativeHistoryResult?.sourcePath === "string" ? args.nativeHistoryResult.sourcePath : void 0;
+      const sourceMtimeMs = typeof args.nativeHistoryResult?.sourceMtimeMs === "number" ? args.nativeHistoryResult.sourceMtimeMs : void 0;
+      const coverageHint = typeof args.nativeHistoryResult?.nativeHistoryCoverage === "string" ? args.nativeHistoryResult.nativeHistoryCoverage : void 0;
+      const partialReason = typeof args.nativeHistoryResult?.partialReason === "string" ? args.nativeHistoryResult.partialReason : void 0;
+      const unavailableReason = typeof args.nativeHistoryResult?.unavailableReason === "string" ? args.nativeHistoryResult.unavailableReason : args.nativeHistoryError ? `error:${args.nativeHistoryError?.message || String(args.nativeHistoryError)}` : void 0;
+      const nativeHandle = typeof args.nativeHistoryResult?.providerSessionId === "string" ? args.nativeHistoryResult.providerSessionId : void 0;
+      const transcriptWorkspace = typeof args.nativeHistoryResult?.workspace === "string" ? args.nativeHistoryResult.workspace : nativeMessages.map((m) => typeof m?.workspace === "string" ? m.workspace.trim() : "").find(Boolean);
+      const fallbackReason = causeToLegacyFallbackReason(decision.transition.cause, decision.selected, {
+        unavailableReason,
+        nativeSource: nativeSource && nativeSource !== "provider-native" ? nativeSource : void 0
+      });
+      const ptyStatusApprovalOnly = decision.selected === "native-history" ? true : args.ptyStatusApprovalOnly;
+      const messageSource = buildCliMessageSourceProvenance({
+        selected: decision.selected,
+        provider: args.providerType,
+        nativeHandle,
+        sessionWorkspace: args.sessionWorkspace,
+        intendedWorkspace: args.intendedWorkspace,
+        transcriptWorkspace,
+        fallbackReason,
+        nativeSource,
+        sourcePath,
+        sourceMtimeMs,
+        nativeHistoryCoverage: coverageHint,
+        partialReason,
+        unavailableReason,
+        nativeMessages,
+        ptyMessages: args.ptyMessages,
+        returnedMessages: decision.selected === "native-history" ? nativeMessages : args.ptyMessages,
+        safeMapping: args.safeMapping,
+        // freshEnough is a v1 concept the machine does not model directly.
+        // We surface lockState.locked here so v1 consumers reading
+        // staleness.freshEnough still get a meaningful boolean.
+        freshEnough: decision.lockState.locked,
+        ptyStatusApprovalOnly
+      });
+      return {
+        decision,
+        messageSource,
+        nativeMessages,
+        nativeSelected: decision.selected === "native-history"
+      };
+    }
+    function buildObservationForCli(args, supportsNative) {
+      if (!supportsNative) {
+        return { kind: "native_unavailable", reason: "provider_not_supported" };
+      }
+      if (args.nativeHistoryError) {
+        return { kind: "native_unavailable", reason: "read_error" };
+      }
+      const result = args.nativeHistoryResult;
+      if (!result || typeof result !== "object") {
+        return { kind: "native_unavailable", reason: "read_error" };
+      }
+      const source = typeof result.source === "string" ? result.source : "";
+      if (source && source !== "provider-native") {
+        return { kind: "native_unavailable", reason: source === "native-unavailable" ? "empty" : "not_native_source" };
+      }
+      const messages = Array.isArray(result.messages) ? result.messages : [];
+      if (messages.length === 0) {
+        return { kind: "native_unavailable", reason: "empty" };
+      }
+      const coverage = typeof result.nativeHistoryCoverage === "string" ? result.nativeHistoryCoverage : "tail";
+      if (coverage === "unavailable") {
+        return { kind: "native_unavailable", reason: "coverage_unavailable" };
+      }
+      return buildV1NativePresentObservation({
+        providerType: args.providerType,
+        sessionId: args.sessionId,
+        messages,
+        coverage: coverage === "full" || coverage === "tail" || coverage === "current-turn" || coverage === "partial" ? coverage : "tail",
+        safeMapping: args.safeMapping
+      });
+    }
+    function extractNativeMessagesFromResult(providerType, result) {
+      if (!result || !Array.isArray(result.messages)) return [];
+      return normalizeNativeHistoryMessages(
+        providerType,
+        result.messages,
+        typeof result.providerSessionId === "string" ? result.providerSessionId : void 0
+      );
+    }
+    init_mesh_turn_presentation();
     init_chat_message_normalization();
+    function shouldPreserveReadChatPayloadField(key2) {
+      return key2 === "messageSource" || key2 === "transcriptProvenance";
+    }
+    function updateMessageSourceReturnedCount(value, returnedMessageCount) {
+      if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+      const record2 = value;
+      const coverage = record2.coverage && typeof record2.coverage === "object" && !Array.isArray(record2.coverage) ? record2.coverage : void 0;
+      if (!coverage) return value;
+      return {
+        ...record2,
+        coverage: {
+          ...coverage,
+          returnedMessageCount
+        }
+      };
+    }
+    function buildFullTail(messages, tailLimit) {
+      const totalMessages = messages.length;
+      const tailMessages = tailLimit > 0 ? messages.slice(-tailLimit) : messages;
+      return {
+        messages: tailMessages,
+        totalMessages
+      };
+    }
+    function hasNonEmptyModalButtons(activeModal) {
+      if (!activeModal || typeof activeModal !== "object") return false;
+      const buttons = activeModal.buttons;
+      return Array.isArray(buttons) && buttons.some((button) => typeof button === "string" && button.trim().length > 0);
+    }
+    function normalizeReadChatCommandStatus(status, activeModal) {
+      const raw = typeof status === "string" ? status.trim() : "";
+      if (!raw) {
+        return hasNonEmptyModalButtons(activeModal) ? "waiting_approval" : "idle";
+      }
+      switch (raw) {
+        case "starting":
+          return hasNonEmptyModalButtons(activeModal) ? "waiting_approval" : "starting";
+        case "stopped":
+        case "disconnected":
+        case "not_monitored":
+          return "error";
+        case "waiting_approval":
+          return hasNonEmptyModalButtons(activeModal) ? "waiting_approval" : "generating";
+        default:
+          return raw;
+      }
+    }
+    function finalizeStreamingMessagesWhenIdle(messages, status) {
+      if (status !== "idle") return messages;
+      return messages.map((message) => {
+        const meta3 = message.meta && typeof message.meta === "object" ? message.meta : void 0;
+        const hasStreamingMeta = meta3?.streaming === true;
+        if (message.bubbleState !== "streaming" && !hasStreamingMeta) return message;
+        return {
+          ...message,
+          ...message.bubbleState === "streaming" ? { bubbleState: "final" } : {},
+          ...hasStreamingMeta ? { meta: { ...meta3, streaming: false } } : {}
+        };
+      });
+    }
+    function collapseAdjacentDuplicateChatMessages(messages) {
+      if (!Array.isArray(messages) || messages.length <= 1) return messages;
+      const result = [];
+      let prevRoleKind = "";
+      let prevStripped = "";
+      for (const message of messages) {
+        const role = typeof message.role === "string" ? message.role : "";
+        const kind = typeof message.kind === "string" ? message.kind : "standard";
+        const content = typeof message.content === "string" ? message.content : Array.isArray(message.content) ? message.content.map((p) => typeof p?.text === "string" ? p.text : "").join("") : "";
+        const strippedContent = content.replace(/\s+/g, "");
+        if (!strippedContent || role === "system") {
+          result.push(message);
+          prevRoleKind = "";
+          prevStripped = "";
+          continue;
+        }
+        const roleKind = `${role}:${kind}`;
+        const sameStripped = strippedContent === prevStripped && roleKind === prevRoleKind;
+        if (result.length > 0 && sameStripped) {
+          result[result.length - 1] = message;
+          prevRoleKind = roleKind;
+          prevStripped = strippedContent;
+          continue;
+        }
+        result.push(message);
+        prevRoleKind = roleKind;
+        prevStripped = strippedContent;
+      }
+      return result;
+    }
+    function buildReadChatCommandResult(payload, args, h) {
+      let validatedPayload;
+      const debugReadChat = payload?.debugReadChat && typeof payload.debugReadChat === "object" ? payload.debugReadChat : void 0;
+      const presentationSessionIdHint = typeof args?.targetSessionId === "string" && args.targetSessionId.trim() ? args.targetSessionId.trim() : typeof args?.sessionId === "string" && args.sessionId.trim() ? args.sessionId.trim() : typeof h?.currentSession?.sessionId === "string" ? String(h.currentSession.sessionId) : "";
+      const providerHint = typeof args?.cliType === "string" ? args.cliType : typeof args?.providerType === "string" ? args.providerType : typeof args?.agentType === "string" ? args.agentType : "";
+      const legacyStatus = normalizeReadChatCommandStatus(payload?.status, payload?.activeModal);
+      const turnPresentation = resolveSessionTurnPresentation({
+        sessionId: presentationSessionIdHint || void 0,
+        legacyStatus,
+        providerType: providerHint || void 0,
+        surface: "read_chat"
+      });
+      let effectiveStatus = legacyStatus;
+      if (turnPresentation.authority === "turn_reducer") {
+        effectiveStatus = turnPresentation.status;
+        if (effectiveStatus === "waiting_approval" && !hasNonEmptyModalButtons(payload?.activeModal)) {
+          effectiveStatus = "generating";
+        }
+      }
+      try {
+        validatedPayload = validateReadChatResultPayload({
+          ...payload,
+          status: effectiveStatus
+        }, "read_chat command result");
+      } catch (error48) {
+        return { success: false, error: error48?.message || String(error48) };
+      }
+      const messages = normalizeReadChatMessages(validatedPayload);
+      const sessionIdHint = typeof args?.targetSessionId === "string" ? args.targetSessionId : typeof args?.sessionId === "string" ? args.sessionId : "";
+      const filteredMessages = h ? maybeHideCoordinatorPromptMessage(h, providerHint, sessionIdHint, messages) : messages;
+      const includeActivity = args?.includeActivity === true || args?.includeActivity === "true";
+      const visibleMessages = includeActivity ? filteredMessages.filter((m) => isUserFacingChatMessage(m) || isActivityChatMessage(m)) : filterUserFacingChatMessages(filteredMessages);
+      const sync = buildFullTail(visibleMessages, normalizeReadChatTailLimit(args));
+      const hiddenMsgCount = Math.max(0, messages.length - visibleMessages.length);
+      const preservedPayloadFields = Object.fromEntries(Object.entries(payload).filter(([key2]) => shouldPreserveReadChatPayloadField(key2)));
+      if (preservedPayloadFields.messageSource) {
+        preservedPayloadFields.messageSource = updateMessageSourceReturnedCount(preservedPayloadFields.messageSource, sync.messages.length);
+      }
+      if (preservedPayloadFields.transcriptProvenance) {
+        preservedPayloadFields.transcriptProvenance = updateMessageSourceReturnedCount(preservedPayloadFields.transcriptProvenance, sync.messages.length);
+      }
+      const returnedDebugReadChat = debugReadChat ? {
+        ...debugReadChat,
+        fullMsgCount: typeof debugReadChat.fullMsgCount === "number" ? debugReadChat.fullMsgCount : messages.length,
+        visibleMsgCount: visibleMessages.length,
+        hiddenMsgCount,
+        returnedMsgCount: sync.messages.length
+      } : void 0;
+      return {
+        success: true,
+        ...validatedPayload,
+        ...preservedPayloadFields,
+        messages: sync.messages,
+        totalMessages: sync.totalMessages,
+        // Stage 6: the authoritative turn presentation rides the read_chat
+        // payload for mesh-owned sessions (identity + stage + evidence
+        // timestamps; the `status` field above already reflects it).
+        ...turnPresentation.authority === "turn_reducer" ? { turn: turnPresentation } : {},
+        ...returnedDebugReadChat ? { debugReadChat: returnedDebugReadChat } : {}
+      };
+    }
     var HOT_TAIL_MIN_LIMIT = 60;
-    var CLI_NATIVE_TRANSCRIPT_PROVIDERS = /* @__PURE__ */ new Set(["codex-cli", "claude-cli", "hermes-cli", "antigravity-cli"]);
     var lastBoundProviderSessionIdByMeshSession = /* @__PURE__ */ new Map();
     var persistedProviderSessionPinsHydrated = false;
     function hydratePersistedProviderSessionPinsOnce() {
@@ -84609,14 +85378,6 @@ ${effect.notification.body || ""}`.trim();
       const pinned = lastBoundProviderSessionIdByMeshSession.get(key2);
       return pinned && pinned.trim() ? pinned.trim() : void 0;
     }
-    var warnedLegacyNativeAllowlistHits = /* @__PURE__ */ new Set();
-    function warnLegacyNativeAllowlistHit(providerType) {
-      if (warnedLegacyNativeAllowlistHits.has(providerType)) return;
-      warnedLegacyNativeAllowlistHits.add(providerType);
-      console.warn(
-        `[chat-commands] supportsCliNativeTranscript fell back to the hardcoded CLI_NATIVE_TRANSCRIPT_PROVIDERS set for "${providerType}". The provider module was unavailable or did not declare canonicalHistory. Set canonicalHistory.contractVersion in the provider.json to remove this dependency.`
-      );
-    }
     function getExplicitHistorySessionId(args) {
       const explicit = typeof args?.historySessionId === "string" ? args.historySessionId.trim() : "";
       if (explicit) return explicit;
@@ -84695,22 +85456,6 @@ ${effect.notification.body || ""}`.trim();
         payload: options.payload
       });
     }
-    function normalizeReadChatTailLimit(args) {
-      const value = Number(args?.tailLimit || 0);
-      return Number.isFinite(value) ? Math.max(0, value) : 0;
-    }
-    function normalizeReadChatMessages(payload) {
-      const messages = Array.isArray(payload.messages) ? payload.messages : [];
-      return normalizeChatMessages(messages);
-    }
-    function getMessageNewestReceivedAt(messages) {
-      let newest = 0;
-      for (const message of messages) {
-        const receivedAt = Number(message?.receivedAt ?? message?.timestamp ?? 0);
-        if (Number.isFinite(receivedAt) && receivedAt > newest) newest = receivedAt;
-      }
-      return newest;
-    }
     function readHistorySessionIdFromMessages(messages) {
       for (const message of messages) {
         const historySessionId = typeof message?.historySessionId === "string" ? message.historySessionId.trim() : "";
@@ -84731,35 +85476,6 @@ ${effect.notification.body || ""}`.trim();
       }
       return true;
     }
-    function maybeHideCoordinatorPromptMessage(h, providerType, sessionId, messages) {
-      if (!Array.isArray(messages) || messages.length === 0) return messages;
-      if (!sessionId) return messages;
-      const loader2 = h.ctx?.providerLoader;
-      if (!loader2) return messages;
-      let showSetting = void 0;
-      try {
-        showSetting = loader2.getSettingValue?.(providerType, "showCoordinatorSystemPrompt");
-      } catch {
-      }
-      if (showSetting === true) return messages;
-      const coord = getCoordinatorForSession(sessionId);
-      if (!coord) return messages;
-      const promptBody = typeof coord.systemPrompt === "string" ? coord.systemPrompt : "";
-      const MARKER = "adhdev-mesh-coordinator-prompt";
-      const filtered = messages.filter((m) => {
-        const role = String(m?.role || "").toLowerCase();
-        if (role !== "user" && role !== "system") return true;
-        const content = flattenContent(m?.content);
-        if (!content) return true;
-        if (content.includes(MARKER)) return false;
-        if (promptBody && content.includes(promptBody.slice(0, Math.min(400, promptBody.length)))) return false;
-        return true;
-      });
-      if (filtered.length !== messages.length) {
-        LOG2.debug("ChatFilter", `[${providerType}] hid ${messages.length - filtered.length} coordinator-prompt message(s) from ${sessionId}`);
-      }
-      return filtered;
-    }
     function normalizeAndFilterNativeHistory(h, providerType, args, messages, nativeSessionId) {
       const normalized = normalizeNativeHistoryMessages(providerType, messages, nativeSessionId);
       const sessionId = typeof args?.targetSessionId === "string" ? args.targetSessionId : typeof args?.sessionId === "string" ? args.sessionId : void 0;
@@ -84833,212 +85549,6 @@ ${effect.notification.body || ""}`.trim();
         };
       });
     }
-    function buildCliMessageSourceProvenance(args) {
-      const sourceMtimeMs = Number(args.sourceMtimeMs || 0);
-      const sourceMtimeAgeMs = sourceMtimeMs > 0 ? Math.max(0, Date.now() - sourceMtimeMs) : void 0;
-      const nativeMessages = args.nativeMessages || [];
-      const ptyMessages = args.ptyMessages || [];
-      const returnedMessages = args.returnedMessages || [];
-      const identityStatus = args.selected === "native-history" ? "safe" : args.fallbackReason === "native_history_not_safely_mapped" ? "ambiguous_session_identity" : args.fallbackReason?.startsWith("native_history_unavailable") ? "transcript_unmapped" : void 0;
-      return {
-        selected: args.selected,
-        provider: args.provider,
-        providerType: args.provider,
-        ...identityStatus ? { identityStatus } : {},
-        ...args.nativeHandle ? { nativeHandle: args.nativeHandle } : {},
-        ...args.nativeHandle ? { nativeSessionId: args.nativeHandle } : {},
-        ...args.sessionWorkspace ? { sessionWorkspace: args.sessionWorkspace } : {},
-        ...args.intendedWorkspace ? { intendedWorkspace: args.intendedWorkspace } : {},
-        ...args.transcriptWorkspace ? { transcriptWorkspace: args.transcriptWorkspace } : {},
-        ...args.fallbackReason ? { fallbackReason: args.fallbackReason } : {},
-        ...args.nativeSource ? { nativeSource: args.nativeSource } : {},
-        ...args.sourcePath ? { sourcePath: args.sourcePath } : {},
-        ...args.nativeHistoryCoverage ? { nativeHistoryCoverage: args.nativeHistoryCoverage } : {},
-        ...args.partialReason ? { partialReason: args.partialReason } : {},
-        ...args.unavailableReason ? { unavailableReason: args.unavailableReason } : {},
-        ptyStatusApprovalOnly: args.ptyStatusApprovalOnly === true,
-        staleness: {
-          sourceMtimeMs: sourceMtimeMs || void 0,
-          sourceMtimeAgeMs,
-          nativeNewestMessageAt: getMessageNewestReceivedAt(nativeMessages),
-          ptyNewestMessageAt: getMessageNewestReceivedAt(ptyMessages),
-          freshEnough: args.freshEnough === true
-        },
-        coverage: {
-          nativeMessageCount: nativeMessages.length,
-          ptyMessageCount: ptyMessages.length,
-          returnedMessageCount: returnedMessages.length,
-          safeMapping: args.safeMapping === true,
-          // true when PTY message bodies are suppressed and must not be treated as
-          // chat content. PTY may still contribute status/approval/screen evidence.
-          ptyMessagesSuppressed: args.selected === "native-history" || args.ptyStatusApprovalOnly === true
-        }
-      };
-    }
-    function causeToLegacyFallbackReason(cause, selected, extraDetail) {
-      if (selected === "native-history") return void 0;
-      switch (cause) {
-        case "initial":
-          return "native_history_not_checked";
-        case "native_progressed":
-          return "native_history_not_selected";
-        case "native_regressed_shrunk":
-          return "native_history_empty";
-        case "native_regressed_unsafe_mapping":
-          return "native_history_not_safely_mapped";
-        case "native_regressed_coverage_partial":
-          return "native_history_partial";
-        case "native_regressed_coverage_unavailable":
-          return "native_history_unavailable";
-        case "native_unavailable_read_error":
-          return extraDetail?.unavailableReason ? `native_history_unavailable:${extraDetail.unavailableReason}` : "native_history_unavailable";
-        case "native_unavailable_provider_unsupported":
-          return "provider_native_transcript_not_supported";
-        case "native_unavailable_empty":
-          return "native_history_empty";
-        case "native_unavailable_not_native_source":
-          return extraDetail?.nativeSource ? `native_history_source_${extraDetail.nativeSource}` : "native_history_unavailable";
-      }
-    }
-    function decideCliReadChatSource(args) {
-      const supportsNative = supportsCliNativeTranscript(args.providerType, args.provider);
-      const observation = buildObservationForCli(args, supportsNative);
-      const sessionKey = chatSourceSessionKey(args.providerType, args.sessionId);
-      const priorSnapshot = CHAT_SOURCE_REGISTRY.snapshotRecord(sessionKey);
-      const priorState = priorSnapshot?.state ?? CHAT_SOURCE_REGISTRY.getState(sessionKey);
-      const eligibleForStickyHold = args.trustedExactNativeIdentity === true && (priorState.name === "NativeLocked" || priorState.name === "Recovering");
-      let decision = CHAT_SOURCE_REGISTRY.observe(sessionKey, observation);
-      const heldNativeMessages = observation.kind === "native_present" ? extractNativeMessagesFromResult(args.providerType, args.nativeHistoryResult) : [];
-      const mayHoldNativeSlice = heldNativeMessages.length > 0 && args.safeMapping === true;
-      if (eligibleForStickyHold && decision.selected === "pty-parser" && mayHoldNativeSlice) {
-        CHAT_SOURCE_REGISTRY.restoreRecord(sessionKey, priorSnapshot);
-        const messageSource2 = buildCliMessageSourceProvenance({
-          selected: "native-history",
-          provider: args.providerType,
-          nativeHandle: typeof args.nativeHistoryResult?.providerSessionId === "string" ? args.nativeHistoryResult.providerSessionId : void 0,
-          sessionWorkspace: args.sessionWorkspace,
-          intendedWorkspace: args.intendedWorkspace,
-          transcriptWorkspace: void 0,
-          fallbackReason: "native_history_transient_gap_held",
-          nativeSource: "provider-native",
-          sourcePath: typeof args.nativeHistoryResult?.sourcePath === "string" ? args.nativeHistoryResult.sourcePath : void 0,
-          sourceMtimeMs: typeof args.nativeHistoryResult?.sourceMtimeMs === "number" ? args.nativeHistoryResult.sourceMtimeMs : void 0,
-          nativeHistoryCoverage: void 0,
-          partialReason: void 0,
-          unavailableReason: observation.kind === "native_unavailable" ? observation.reason : void 0,
-          nativeMessages: heldNativeMessages,
-          ptyMessages: args.ptyMessages,
-          returnedMessages: heldNativeMessages,
-          safeMapping: args.safeMapping,
-          freshEnough: true,
-          ptyStatusApprovalOnly: true
-        });
-        return {
-          decision: {
-            selected: "native-history",
-            nextState: priorState,
-            transition: {
-              fromState: priorState.name,
-              toState: priorState.name,
-              event: "NoOp",
-              cause: decision.transition.cause,
-              at: Date.now()
-            },
-            lockState: { locked: priorState.name === "NativeLocked" }
-          },
-          messageSource: messageSource2,
-          nativeMessages: heldNativeMessages,
-          nativeSelected: true
-        };
-      }
-      if (decision.selected === "pty-parser" && args.trustedExactNativeIdentity === true && args.safeMapping && args.ptyMessages.length === 0 && observation.kind === "native_present" && observation.coverage !== "partial" && observation.messages.length > 0) {
-        CHAT_SOURCE_REGISTRY.clear(sessionKey);
-        decision = CHAT_SOURCE_REGISTRY.observe(sessionKey, observation);
-      }
-      const nativeMessages = observation.kind === "native_present" ? extractNativeMessagesFromResult(args.providerType, args.nativeHistoryResult) : [];
-      const nativeSource = typeof args.nativeHistoryResult?.source === "string" ? args.nativeHistoryResult.source : void 0;
-      const sourcePath = typeof args.nativeHistoryResult?.sourcePath === "string" ? args.nativeHistoryResult.sourcePath : void 0;
-      const sourceMtimeMs = typeof args.nativeHistoryResult?.sourceMtimeMs === "number" ? args.nativeHistoryResult.sourceMtimeMs : void 0;
-      const coverageHint = typeof args.nativeHistoryResult?.nativeHistoryCoverage === "string" ? args.nativeHistoryResult.nativeHistoryCoverage : void 0;
-      const partialReason = typeof args.nativeHistoryResult?.partialReason === "string" ? args.nativeHistoryResult.partialReason : void 0;
-      const unavailableReason = typeof args.nativeHistoryResult?.unavailableReason === "string" ? args.nativeHistoryResult.unavailableReason : args.nativeHistoryError ? `error:${args.nativeHistoryError?.message || String(args.nativeHistoryError)}` : void 0;
-      const nativeHandle = typeof args.nativeHistoryResult?.providerSessionId === "string" ? args.nativeHistoryResult.providerSessionId : void 0;
-      const transcriptWorkspace = typeof args.nativeHistoryResult?.workspace === "string" ? args.nativeHistoryResult.workspace : nativeMessages.map((m) => typeof m?.workspace === "string" ? m.workspace.trim() : "").find(Boolean);
-      const fallbackReason = causeToLegacyFallbackReason(decision.transition.cause, decision.selected, {
-        unavailableReason,
-        nativeSource: nativeSource && nativeSource !== "provider-native" ? nativeSource : void 0
-      });
-      const ptyStatusApprovalOnly = decision.selected === "native-history" ? true : args.ptyStatusApprovalOnly;
-      const messageSource = buildCliMessageSourceProvenance({
-        selected: decision.selected,
-        provider: args.providerType,
-        nativeHandle,
-        sessionWorkspace: args.sessionWorkspace,
-        intendedWorkspace: args.intendedWorkspace,
-        transcriptWorkspace,
-        fallbackReason,
-        nativeSource,
-        sourcePath,
-        sourceMtimeMs,
-        nativeHistoryCoverage: coverageHint,
-        partialReason,
-        unavailableReason,
-        nativeMessages,
-        ptyMessages: args.ptyMessages,
-        returnedMessages: decision.selected === "native-history" ? nativeMessages : args.ptyMessages,
-        safeMapping: args.safeMapping,
-        // freshEnough is a v1 concept the machine does not model directly.
-        // We surface lockState.locked here so v1 consumers reading
-        // staleness.freshEnough still get a meaningful boolean.
-        freshEnough: decision.lockState.locked,
-        ptyStatusApprovalOnly
-      });
-      return {
-        decision,
-        messageSource,
-        nativeMessages,
-        nativeSelected: decision.selected === "native-history"
-      };
-    }
-    function buildObservationForCli(args, supportsNative) {
-      if (!supportsNative) {
-        return { kind: "native_unavailable", reason: "provider_not_supported" };
-      }
-      if (args.nativeHistoryError) {
-        return { kind: "native_unavailable", reason: "read_error" };
-      }
-      const result = args.nativeHistoryResult;
-      if (!result || typeof result !== "object") {
-        return { kind: "native_unavailable", reason: "read_error" };
-      }
-      const source = typeof result.source === "string" ? result.source : "";
-      if (source && source !== "provider-native") {
-        return { kind: "native_unavailable", reason: source === "native-unavailable" ? "empty" : "not_native_source" };
-      }
-      const messages = Array.isArray(result.messages) ? result.messages : [];
-      if (messages.length === 0) {
-        return { kind: "native_unavailable", reason: "empty" };
-      }
-      const coverage = typeof result.nativeHistoryCoverage === "string" ? result.nativeHistoryCoverage : "tail";
-      if (coverage === "unavailable") {
-        return { kind: "native_unavailable", reason: "coverage_unavailable" };
-      }
-      return buildV1NativePresentObservation({
-        providerType: args.providerType,
-        sessionId: args.sessionId,
-        messages,
-        coverage: coverage === "full" || coverage === "tail" || coverage === "current-turn" || coverage === "partial" ? coverage : "tail",
-        safeMapping: args.safeMapping
-      });
-    }
-    function extractNativeMessagesFromResult(providerType, result) {
-      if (!result || !Array.isArray(result.messages)) return [];
-      return normalizeNativeHistoryMessages(
-        providerType,
-        result.messages,
-        typeof result.providerSessionId === "string" ? result.providerSessionId : void 0
-      );
-    }
     function applyUnsafeNativeDaemonFallback(args) {
       if (args.adapter.cliType !== "codex-cli") {
         return;
@@ -85210,16 +85720,6 @@ ${effect.notification.body || ""}`.trim();
       const start = Math.max(0, end - args.limit);
       return { messages: ptyMessages.slice(start, end), hasMore: start > 0 };
     }
-    function supportsCliNativeTranscript(providerType, provider) {
-      if (provider?.category === "cli" && isNativeSourceCanonicalHistory(provider?.nativeHistory)) {
-        return true;
-      }
-      if (CLI_NATIVE_TRANSCRIPT_PROVIDERS.has(providerType)) {
-        warnLegacyNativeAllowlistHit(providerType);
-        return true;
-      }
-      return false;
-    }
     function getComparableVisibleText(message) {
       if (!message) return "";
       const role = String(message.role || "").trim().toLowerCase();
@@ -85352,22 +85852,6 @@ ${effect.notification.body || ""}`.trim();
       });
       return { ...history, lookup: "workspace" };
     }
-    function shouldPreserveReadChatPayloadField(key2) {
-      return key2 === "messageSource" || key2 === "transcriptProvenance";
-    }
-    function updateMessageSourceReturnedCount(value, returnedMessageCount) {
-      if (!value || typeof value !== "object" || Array.isArray(value)) return value;
-      const record2 = value;
-      const coverage = record2.coverage && typeof record2.coverage === "object" && !Array.isArray(record2.coverage) ? record2.coverage : void 0;
-      if (!coverage) return value;
-      return {
-        ...record2,
-        coverage: {
-          ...coverage,
-          returnedMessageCount
-        }
-      };
-    }
     function deriveHistoryDedupKey(message) {
       const unitKey = typeof message._unitKey === "string" ? message._unitKey.trim() : "";
       if (unitKey) return `read_chat:${unitKey}`;
@@ -85391,37 +85875,6 @@ ${effect.notification.body || ""}`.trim();
         historyDedupKey: deriveHistoryDedupKey(message)
       }));
     }
-    function buildFullTail(messages, tailLimit) {
-      const totalMessages = messages.length;
-      const tailMessages = tailLimit > 0 ? messages.slice(-tailLimit) : messages;
-      return {
-        messages: tailMessages,
-        totalMessages
-      };
-    }
-    function hasNonEmptyModalButtons(activeModal) {
-      if (!activeModal || typeof activeModal !== "object") return false;
-      const buttons = activeModal.buttons;
-      return Array.isArray(buttons) && buttons.some((button) => typeof button === "string" && button.trim().length > 0);
-    }
-    function normalizeReadChatCommandStatus(status, activeModal) {
-      const raw = typeof status === "string" ? status.trim() : "";
-      if (!raw) {
-        return hasNonEmptyModalButtons(activeModal) ? "waiting_approval" : "idle";
-      }
-      switch (raw) {
-        case "starting":
-          return hasNonEmptyModalButtons(activeModal) ? "waiting_approval" : "starting";
-        case "stopped":
-        case "disconnected":
-        case "not_monitored":
-          return "error";
-        case "waiting_approval":
-          return hasNonEmptyModalButtons(activeModal) ? "waiting_approval" : "generating";
-        default:
-          return raw;
-      }
-    }
     function isGeneratingLikeStatus(status) {
       return status === "generating" || status === "streaming" || status === "no_progress" || status === "long_generating" || status === "starting";
     }
@@ -85461,110 +85914,6 @@ ${effect.notification.body || ""}`.trim();
       if (shouldTrustCliAdapterTerminalStatus(parsedStatus, activeModal, adapter, adapterStatus)) return "idle";
       return typeof parsedStatus === "string" && parsedStatus.trim() ? parsedStatus : "idle";
     }
-    function finalizeStreamingMessagesWhenIdle(messages, status) {
-      if (status !== "idle") return messages;
-      return messages.map((message) => {
-        const meta3 = message.meta && typeof message.meta === "object" ? message.meta : void 0;
-        const hasStreamingMeta = meta3?.streaming === true;
-        if (message.bubbleState !== "streaming" && !hasStreamingMeta) return message;
-        return {
-          ...message,
-          ...message.bubbleState === "streaming" ? { bubbleState: "final" } : {},
-          ...hasStreamingMeta ? { meta: { ...meta3, streaming: false } } : {}
-        };
-      });
-    }
-    function collapseAdjacentDuplicateChatMessages(messages) {
-      if (!Array.isArray(messages) || messages.length <= 1) return messages;
-      const result = [];
-      let prevRoleKind = "";
-      let prevStripped = "";
-      for (const message of messages) {
-        const role = typeof message.role === "string" ? message.role : "";
-        const kind = typeof message.kind === "string" ? message.kind : "standard";
-        const content = typeof message.content === "string" ? message.content : Array.isArray(message.content) ? message.content.map((p) => typeof p?.text === "string" ? p.text : "").join("") : "";
-        const strippedContent = content.replace(/\s+/g, "");
-        if (!strippedContent || role === "system") {
-          result.push(message);
-          prevRoleKind = "";
-          prevStripped = "";
-          continue;
-        }
-        const roleKind = `${role}:${kind}`;
-        const sameStripped = strippedContent === prevStripped && roleKind === prevRoleKind;
-        if (result.length > 0 && sameStripped) {
-          result[result.length - 1] = message;
-          prevRoleKind = roleKind;
-          prevStripped = strippedContent;
-          continue;
-        }
-        result.push(message);
-        prevRoleKind = roleKind;
-        prevStripped = strippedContent;
-      }
-      return result;
-    }
-    function buildReadChatCommandResult(payload, args, h) {
-      let validatedPayload;
-      const debugReadChat = payload?.debugReadChat && typeof payload.debugReadChat === "object" ? payload.debugReadChat : void 0;
-      const presentationSessionIdHint = typeof args?.targetSessionId === "string" && args.targetSessionId.trim() ? args.targetSessionId.trim() : typeof args?.sessionId === "string" && args.sessionId.trim() ? args.sessionId.trim() : typeof h?.currentSession?.sessionId === "string" ? String(h.currentSession.sessionId) : "";
-      const providerHint = typeof args?.cliType === "string" ? args.cliType : typeof args?.providerType === "string" ? args.providerType : typeof args?.agentType === "string" ? args.agentType : "";
-      const legacyStatus = normalizeReadChatCommandStatus(payload?.status, payload?.activeModal);
-      const turnPresentation = resolveSessionTurnPresentation({
-        sessionId: presentationSessionIdHint || void 0,
-        legacyStatus,
-        providerType: providerHint || void 0,
-        surface: "read_chat"
-      });
-      let effectiveStatus = legacyStatus;
-      if (turnPresentation.authority === "turn_reducer") {
-        effectiveStatus = turnPresentation.status;
-        if (effectiveStatus === "waiting_approval" && !hasNonEmptyModalButtons(payload?.activeModal)) {
-          effectiveStatus = "generating";
-        }
-      }
-      try {
-        validatedPayload = validateReadChatResultPayload({
-          ...payload,
-          status: effectiveStatus
-        }, "read_chat command result");
-      } catch (error48) {
-        return { success: false, error: error48?.message || String(error48) };
-      }
-      const messages = normalizeReadChatMessages(validatedPayload);
-      const sessionIdHint = typeof args?.targetSessionId === "string" ? args.targetSessionId : typeof args?.sessionId === "string" ? args.sessionId : "";
-      const filteredMessages = h ? maybeHideCoordinatorPromptMessage(h, providerHint, sessionIdHint, messages) : messages;
-      const includeActivity = args?.includeActivity === true || args?.includeActivity === "true";
-      const visibleMessages = includeActivity ? filteredMessages.filter((m) => isUserFacingChatMessage(m) || isActivityChatMessage(m)) : filterUserFacingChatMessages(filteredMessages);
-      const sync = buildFullTail(visibleMessages, normalizeReadChatTailLimit(args));
-      const hiddenMsgCount = Math.max(0, messages.length - visibleMessages.length);
-      const preservedPayloadFields = Object.fromEntries(Object.entries(payload).filter(([key2]) => shouldPreserveReadChatPayloadField(key2)));
-      if (preservedPayloadFields.messageSource) {
-        preservedPayloadFields.messageSource = updateMessageSourceReturnedCount(preservedPayloadFields.messageSource, sync.messages.length);
-      }
-      if (preservedPayloadFields.transcriptProvenance) {
-        preservedPayloadFields.transcriptProvenance = updateMessageSourceReturnedCount(preservedPayloadFields.transcriptProvenance, sync.messages.length);
-      }
-      const returnedDebugReadChat = debugReadChat ? {
-        ...debugReadChat,
-        fullMsgCount: typeof debugReadChat.fullMsgCount === "number" ? debugReadChat.fullMsgCount : messages.length,
-        visibleMsgCount: visibleMessages.length,
-        hiddenMsgCount,
-        returnedMsgCount: sync.messages.length
-      } : void 0;
-      return {
-        success: true,
-        ...validatedPayload,
-        ...preservedPayloadFields,
-        messages: sync.messages,
-        totalMessages: sync.totalMessages,
-        // Stage 6: the authoritative turn presentation rides the read_chat
-        // payload for mesh-owned sessions (identity + stage + evidence
-        // timestamps; the `status` field above already reflects it).
-        ...turnPresentation.authority === "turn_reducer" ? { turn: turnPresentation } : {},
-        ...returnedDebugReadChat ? { debugReadChat: returnedDebugReadChat } : {}
-      };
-    }
     function toNonNegativeNumber(value) {
       const numeric = Number(value ?? 0);
       return Number.isFinite(numeric) ? Math.max(0, numeric) : 0;
@@ -95473,7 +95822,7 @@ ${marker}`,
           LOG2.warn("spec-route", `[${provider.type}] spec invalid, falling back to ProviderCliAdapter: ${err.message}`);
         }
       }
-      return new ProviderCliAdapter(provider, workingDir, cliArgs, extraEnv, transportFactory);
+      return new ProviderCliAdapter(provider, workingDir, cliArgs, extraEnv, transportFactory, sessionId);
     }
     init_chat_history();
     init_logger();
@@ -102801,7 +103150,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 && isIdleSessionState(dispatchSessionState);
+              const sessionConfirmedReady = !!dispatchSessionState && isIdleSessionState2(dispatchSessionState);
               if (!sessionConfirmedReady) {
                 return {
                   success: false,
@@ -110641,7 +110990,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           drain: { ...getMeshV2DrainCounters() },
           backstop: { ...getMeshV2BackstopCounters() }
         };
-        return { success: true, events, hasLiveCliCoordinator, meshProtocolV2Counters, ...selfCoordinatorInboxRead ? { surfacedForSelfCoordinator: true } : {} };
+        const pendingRetentionCounters2 = { ...getPendingRetentionCounters() };
+        return { success: true, events, hasLiveCliCoordinator, meshProtocolV2Counters, pendingRetentionCounters: pendingRetentionCounters2, ...selfCoordinatorInboxRead ? { surfacedForSelfCoordinator: true } : {} };
       },
       interactive_prompt_response: async (ctx, args) => {
         const sessionId = typeof args?.targetSessionId === "string" && args.targetSessionId.trim() ? args.targetSessionId.trim() : typeof args?.sessionId === "string" && args.sessionId.trim() ? args.sessionId.trim() : "";
@@ -111798,6 +112148,7 @@ ${ptyResult.output.slice(-2e3)}`);
             drain: { ...getMeshV2DrainCounters() },
             backstop: { ...getMeshV2BackstopCounters() }
           };
+          const pendingRetentionCounters2 = { ...getPendingRetentionCounters() };
           const turnPresentationCounters = getTurnPresentationMetrics();
           const previewFreshness = (() => {
             const localRepoRoot = nodeStatuses.map((node) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace)).find((candidate) => !!candidate && fs43.existsSync(candidate));
@@ -111889,6 +112240,7 @@ ${ptyResult.output.slice(-2e3)}`);
             ...pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {},
             ...unroutableDeliveries.length > 0 ? { unroutableDeliveries } : {},
             meshProtocolV2Counters,
+            pendingRetentionCounters: pendingRetentionCounters2,
             turnPresentationCounters,
             activeRefineJobs: Array.from(ctx.runningRefineJobs.values()).filter((job) => job.meshId === meshId).map((job) => ({
               jobId: job.jobId,
@@ -111899,13 +112251,14 @@ ${ptyResult.output.slice(-2e3)}`);
               targetCoordinatorDaemonId: job.targetCoordinatorDaemonId
             }))
           };
-          const { pendingCoordinatorEvents: _pendingCoordinatorEvents, unroutableDeliveries: _unroutableDeliveries, meshProtocolV2Counters: _meshProtocolV2Counters, turnPresentationCounters: _turnPresentationCounters, ...cacheableStatusResult } = statusResult;
+          const { pendingCoordinatorEvents: _pendingCoordinatorEvents, unroutableDeliveries: _unroutableDeliveries, meshProtocolV2Counters: _meshProtocolV2Counters, pendingRetentionCounters: _pendingRetentionCounters, turnPresentationCounters: _turnPresentationCounters, ...cacheableStatusResult } = statusResult;
           const rememberedStatus = verboseMissions ? cacheableStatusResult : ctx.rememberAggregateMeshStatus(meshId, cacheableStatusResult, refreshReason);
           const returnedStatus = {
             ...rememberedStatus,
             ...pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {},
             ...unroutableDeliveries.length > 0 ? { unroutableDeliveries } : {},
             meshProtocolV2Counters,
+            pendingRetentionCounters: pendingRetentionCounters2,
             turnPresentationCounters
           };
           logRepoMeshStatusDebug("return_live", {
@@ -115770,17 +116123,27 @@ ${e?.stderr || ""}`;
     }
     async function startMeshRefineJob(self, meshId, nodeId, args) {
       const key2 = buildRefineJobKey(self, meshId, nodeId);
-      const running = self.runningRefineJobs.get(key2);
-      if (running) return { ...running, duplicate: true };
       const terminal = self.terminalRefineJobs.get(key2);
+      const alreadyRunning = self.runningRefineJobs.get(key2);
+      if (alreadyRunning) return { ...alreadyRunning, duplicate: true };
+      const jobId = `refine_${createInteractionId()}`;
+      const interactionId = createInteractionId();
+      const placeholder = buildRefineJobHandle(self, { meshId, nodeId, jobId, interactionId, retryOfJobId: terminal?.jobId });
+      self.runningRefineJobs.set(key2, placeholder);
       const meshRecord = await self.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
       const mesh = meshRecord?.mesh;
       const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
-      if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
-      if (!node.isLocalWorktree || !node.workspace) return { success: false, error: `Refinery requires a local worktree node` };
+      if (!node) {
+        self.runningRefineJobs.delete(key2);
+        return { success: false, error: `Node '${nodeId}' not found in mesh` };
+      }
+      if (!node.isLocalWorktree || !node.workspace) {
+        self.runningRefineJobs.delete(key2);
+        return { success: false, error: `Refinery requires a local worktree node` };
+      }
       const coordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : self.deps.statusInstanceId || void 0;
       const coordinatorSessionId = typeof args?.coordinatorSessionId === "string" && args.coordinatorSessionId.trim() ? args.coordinatorSessionId.trim() : void 0;
-      const handle = buildRefineJobHandle(self, { meshId, nodeId, node, retryOfJobId: terminal?.jobId, coordinatorDaemonId, coordinatorSessionId });
+      const handle = buildRefineJobHandle(self, { meshId, nodeId, node, jobId, interactionId, retryOfJobId: terminal?.jobId, coordinatorDaemonId, coordinatorSessionId });
       self.runningRefineJobs.set(key2, handle);
       await appendRefineJobLedger(self, "task_dispatched", handle);
       queueRefineJobEvent(self, "refine:accepted", handle);
@@ -124411,8 +124774,9 @@ data: ${JSON.stringify(msg.data)}
         if (event.type === "session_exit") {
           const exitCode = typeof event.exitCode === "number" ? event.exitCode : null;
           const signal = typeof event.signal === "number" ? event.signal : null;
+          const termination = event.termination;
           for (const callback of this.exitCallbacks) {
-            callback({ exitCode, signal });
+            callback({ exitCode, signal, termination });
           }
           void this.closeClient(false);
         }