@adhdev/daemon-standalone 1.0.58-rc.40 → 1.0.58-rc.42

package/dist/index.js

@@ -36911,10 +36911,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "5921978d3a1d5394648991c58ba1eaa4ddcdf15f" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "5921978d" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.58-rc.40" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-29T09:16:34.881Z" : void 0);
+      const commit = readInjected(true ? "2c1c52a4b48387753bcbd8c0b2d003d18fd5f544" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "2c1c52a4" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.58-rc.42" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-29T14:25:11.174Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -38708,6 +38708,48 @@ var require_dist3 = __commonJS({
         MONTHLY_WINDOW_MINUTES = 43200;
       }
     });
+    function isSecretLikeEnvKey(key2) {
+      return SECRET_LIKE_KEY_PATTERN.test(key2);
+    }
+    function applyDaemonEnvOverrides(overrides, env2 = process.env, logFn = () => {
+    }) {
+      const result = {
+        applied: {},
+        skippedRejected: [],
+        skippedExplicitEnv: [],
+        unknownKeys: []
+      };
+      if (!overrides) return result;
+      for (const [key2, value] of Object.entries(overrides)) {
+        if (typeof key2 !== "string" || !key2.trim()) continue;
+        if (typeof value !== "string") continue;
+        if (isSecretLikeEnvKey(key2)) {
+          result.skippedRejected.push(key2);
+          logFn(`rejected secret-shaped key "${key2}" from config.envOverrides \u2014 identity/secret persistence is out of scope for this map`);
+          continue;
+        }
+        if (typeof env2[key2] === "string" && env2[key2] !== "") {
+          result.skippedExplicitEnv.push(key2);
+          continue;
+        }
+        if (!KNOWN_FLAG_KEYS.has(key2)) {
+          result.unknownKeys.push(key2);
+          logFn(`applying unrecognized key "${key2}" from config.envOverrides \u2014 verify spelling if this doesn't take effect`);
+        }
+        env2[key2] = value;
+        result.applied[key2] = value;
+      }
+      return result;
+    }
+    var SECRET_LIKE_KEY_PATTERN;
+    var KNOWN_FLAG_KEYS;
+    var init_env_overrides = __esm2({
+      "src/config/env-overrides.ts"() {
+        "use strict";
+        SECRET_LIKE_KEY_PATTERN = /TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIAL|API[_-]?KEY|PRIVATE[_-]?KEY|COOKIE/i;
+        KNOWN_FLAG_KEYS = /* @__PURE__ */ new Set(["ADHDEV_WORKER_MCP"]);
+      }
+    });
     var config_exports = {};
     __export2(config_exports, {
       clearAuthCredentials: () => clearAuthCredentials,
@@ -38753,6 +38795,17 @@ var require_dist3 = __commonJS({
       }
       return fallback;
     }
+    function normalizeEnvOverrides(value) {
+      if (!isPlainObject2(value)) return {};
+      const result = {};
+      for (const [key2, raw] of Object.entries(value)) {
+        if (typeof key2 !== "string" || !key2.trim()) continue;
+        if (typeof raw !== "string") continue;
+        if (isSecretLikeEnvKey(key2)) continue;
+        result[key2] = raw;
+      }
+      return result;
+    }
     function normalizeMachineProviders(value) {
       if (!isPlainObject2(value)) return {};
       const result = {};
@@ -38813,7 +38866,8 @@ var require_dist3 = __commonJS({
         // behavior-neutral for stale configs; anything absent or unknown
         // resolves to THIS binary's build track instead of failing.
         updateChannel: parsed.updateChannel === "preview" || parsed.updateChannel === "next" ? "preview" : parsed.updateChannel === "stable" || parsed.updateChannel === "latest" ? "stable" : TRACK,
-        terminalSizingMode: parsed.terminalSizingMode === "fit" ? "fit" : "measured"
+        terminalSizingMode: parsed.terminalSizingMode === "fit" ? "fit" : "measured",
+        envOverrides: normalizeEnvOverrides(parsed.envOverrides)
       };
     }
     function generateMachineId() {
@@ -38966,6 +39020,7 @@ var require_dist3 = __commonJS({
         import_crypto2 = require("crypto");
         init_config_dir();
         init_track_identity();
+        init_env_overrides();
         DEFAULT_CONFIG = {
           // Track-stamped default origin: identical to the historical literal on
           // stable builds ('https://api.adhf.dev'); preview builds default to the
@@ -38992,7 +39047,8 @@ var require_dist3 = __commonJS({
           ideSettings: {},
           providerSourceMode: "normal",
           updateChannel: "stable",
-          terminalSizingMode: "measured"
+          terminalSizingMode: "measured",
+          envOverrides: {}
         };
         MACHINE_ID_PREFIX = "mach_";
       }
@@ -39011,7 +39067,8 @@ var require_dist3 = __commonJS({
         env: overrides.env ?? process.env,
         spawn: overrides.spawn ?? ((command, args, options) => (0, import_node_child_process2.spawn)(command, args, {
           env: options.env,
-          stdio: ["pipe", "pipe", "pipe"]
+          stdio: ["pipe", "pipe", "pipe"],
+          windowsHide: true
         })),
         readFile: overrides.readFile ?? ((filePath) => (0, import_promises3.readFile)(filePath, "utf-8")),
         setTimeout: overrides.setTimeout ?? ((handler, ms) => setTimeout(handler, ms)),
@@ -39792,6 +39849,7 @@ const shellArgs = process.platform === 'win32' ? ['/d', '/s', '/c', ORIGINAL_COM
 
 const child = spawn(shell, shellArgs, {
     stdio: ['pipe', 'inherit', 'inherit'],
+    windowsHide: true,
     windowsVerbatimArguments: process.platform === 'win32',
 });
 
@@ -65502,7 +65560,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         `).run(meshId, nodeId, sessionId, providerType, expiresAt, metadata ? JSON.stringify(metadata) : null);
           }
           getRemoteIdleSessions(meshId) {
-            const rows = this.db.prepare("SELECT node_id, session_id, provider_type, expires_at, metadata FROM remote_idle_sessions WHERE mesh_id = ?").all(meshId);
+            const rows = this.db.prepare("SELECT node_id, session_id, provider_type, expires_at, metadata FROM remote_idle_sessions WHERE mesh_id = ? AND expires_at > ?").all(meshId, Date.now());
             return rows.map((r) => ({
               nodeId: r.node_id,
               sessionId: r.session_id,
@@ -65514,6 +65572,11 @@ CREATE TABLE IF NOT EXISTS sq_archive (
           deleteRemoteIdleSession(meshId, nodeId, sessionId) {
             this.db.prepare("DELETE FROM remote_idle_sessions WHERE mesh_id = ? AND node_id = ? AND session_id = ?").run(meshId, nodeId, sessionId);
           }
+          // CLAIM-RETRY-LOOP-LIFECYCLE: deleteRemoteIdleSession above fires only on a successful
+          // claim; called from remove_mesh_node to clear a node's row on removal instead.
+          deleteRemoteIdleSessionsForNode(meshId, nodeId) {
+            this.db.prepare("DELETE FROM remote_idle_sessions WHERE mesh_id = ? AND node_id = ?").run(meshId, nodeId);
+          }
           pruneExpiredRemoteIdleSessions() {
             this.db.prepare("DELETE FROM remote_idle_sessions WHERE expires_at <= ?").run(Date.now());
           }
@@ -78732,376 +78795,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         REMOTE_LAUNCH_READY_POLL_MS = 100;
       }
     });
-    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?.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,
-        // Mirror the manual mesh_fast_forward_node update_submodules behavior: if the
-        // ff-only merge moves a submodule gitlink, run `git submodule update --init
-        // --recursive` in the same cycle so the checkout never drifts from the gitlink.
-        // Without this, drift accumulates and self-blocks every subsequent auto-ff
-        // (collectPreflightBlockers treats out-of-sync submodules as a hard blocker).
-        updateSubmodules: true
-      };
-      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,
-          // See delegateRemoteAutoFastForward's updateSubmodules comment: mirrors the
-          // manual tool so a gitlink-moving ff cannot leave the submodule drifted.
-          updateSubmodules: true,
-          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: true,
-          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_fs17.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,
-            // Same gitlink-drift-prevention rationale as executeLocalAutoFastForward /
-            // delegateRemoteAutoFastForward — this path pushed the base branch itself,
-            // so a submodule gitlink bump here is exactly as likely.
-            updateSubmodules: 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_fs17;
-    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_fs17 = 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 }) ?? "";
-    }
-    function noteRecentlyClonedNode(nodeId, nowMs = Date.now()) {
-      const key2 = normalizeNodeIdKey(nodeId);
-      if (!key2) return;
-      recentlyClonedNodeExpiry.set(key2, nowMs + CLONE_BOOTSTRAP_GRACE_MS);
-      if (recentlyClonedNodeExpiry.size > MAX_TRACKED_CLONED_NODES) {
-        const oldest = recentlyClonedNodeExpiry.keys().next().value;
-        if (oldest !== void 0) recentlyClonedNodeExpiry.delete(oldest);
-      }
-    }
-    function isWithinCloneBootstrapGrace(nodeId, nowMs = Date.now()) {
-      const key2 = normalizeNodeIdKey(nodeId);
-      if (!key2) return false;
-      const expiry = recentlyClonedNodeExpiry.get(key2);
-      if (expiry === void 0) return false;
-      if (nowMs >= expiry) {
-        recentlyClonedNodeExpiry.delete(key2);
-        return false;
-      }
-      return true;
-    }
-    var CLONE_BOOTSTRAP_GRACE_MS;
-    var recentlyClonedNodeExpiry;
-    var MAX_TRACKED_CLONED_NODES;
-    var init_mesh_clone_grace = __esm2({
-      "src/mesh/mesh-clone-grace.ts"() {
-        "use strict";
-        init_dist();
-        CLONE_BOOTSTRAP_GRACE_MS = 10 * 60 * 1e3;
-        recentlyClonedNodeExpiry = /* @__PURE__ */ new Map();
-        MAX_TRACKED_CLONED_NODES = 512;
-      }
-    });
     function quotaClaimBlockKey(meshId, observation) {
       return `${meshId}:${observation.nodeId}:${observation.sessionId}:${observation.providerType}`;
     }
@@ -79118,30 +78811,41 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         if (oldest !== void 0) map3.delete(oldest);
       }
     }
-    function logQuotaClaimBlockTransition(meshId, observation) {
+    function logQuotaClaimBlockTransition(meshId, observation, phase = "blocked") {
       const key2 = quotaClaimBlockKey(meshId, observation);
-      const fingerprint = `${observation.block.reason}:${observation.block.window}:${observation.block.remainingPercent}:${observation.block.thresholdPercent}`;
+      const fingerprint = `${phase}:${observation.block.reason}:${observation.block.window}:${observation.block.remainingPercent}:${observation.block.thresholdPercent}`;
       if (lastQuotaClaimBlockLog.get(key2) === fingerprint) return;
       const wasBlocked = lastQuotaClaimBlockLog.has(key2);
       rememberBounded(lastQuotaClaimBlockLog, key2, fingerprint);
-      LOG2.info("MeshQueue", `QUOTA GATE: deferring queue claim for node ${observation.nodeId} (${observation.sessionId}): ${quotaClaimBlockDescription(observation.providerType, observation.block)} \u2014 trying remaining provider candidates; the task stays pending only if none can claim`);
+      const overrideNote = phase === "overridden_by_pin" ? " (provider pinned by requiredTags \u2014 gate overridden to honor the pin)" : "";
+      LOG2.info("MeshQueue", `QUOTA GATE: ${phase === "overridden_by_pin" ? "allowing" : "deferring"} queue claim for node ${observation.nodeId} (${observation.sessionId}): ${quotaClaimBlockDescription(observation.providerType, observation.block)}${overrideNote}${phase === "blocked" ? " \u2014 trying remaining provider candidates; the task stays pending only if none can claim" : ""}`);
       try {
+        const payload = {
+          phase,
+          nodeId: observation.nodeId,
+          sessionId: observation.sessionId,
+          providerType: observation.providerType,
+          reason: observation.block.reason,
+          window: observation.block.window,
+          remainingPercent: observation.block.remainingPercent,
+          thresholdPercent: observation.block.thresholdPercent,
+          previouslyBlocked: wasBlocked
+        };
+        if (observation.context?.trigger) {
+          payload.trigger = observation.context.trigger;
+        }
+        if (observation.context?.candidateTaskId) {
+          payload.candidateTaskId = observation.context.candidateTaskId;
+        }
+        if (observation.context?.pinOverride) {
+          payload.pinOverride = true;
+        }
         appendLedgerEntry(meshId, {
           kind: "quota_claim_gate",
           nodeId: observation.nodeId,
           sessionId: observation.sessionId,
           providerType: observation.providerType,
-          payload: {
-            phase: "blocked",
-            nodeId: observation.nodeId,
-            sessionId: observation.sessionId,
-            providerType: observation.providerType,
-            reason: observation.block.reason,
-            window: observation.block.window,
-            remainingPercent: observation.block.remainingPercent,
-            thresholdPercent: observation.block.thresholdPercent,
-            previouslyBlocked: wasBlocked
-          }
+          payload
         });
       } catch {
       }
@@ -79275,301 +78979,10 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         AUTO_LAUNCH_LEDGER_DEDUP_MAX = 2e3;
       }
     });
-    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 resolveTargetPinTtlVerdict(components, task, nowMs = Date.now()) {
-      const wallAgeMs = targetPinAgeMs(task, nowMs);
-      if (wallAgeMs === null) return { expired: false, ageMs: null, suspended: false };
-      const targetSessionId = readNonEmptyString(task.targetSessionId);
-      const key2 = `${task.meshId}::${task.id}`;
-      const prior = targetPinGeneratingCreditMs.get(key2);
-      const generating = !!targetSessionId && resolveSessionBusyVerdict(components, targetSessionId) === "GENERATING";
-      let creditMs = prior?.creditMs ?? 0;
-      if (generating && prior) {
-        creditMs += Math.max(0, nowMs - prior.lastSeenMs);
-      }
-      targetPinGeneratingCreditMs.set(key2, { creditMs, lastSeenMs: nowMs });
-      const unproductiveAgeMs = Math.max(0, wallAgeMs - creditMs);
-      return {
-        // A tick on which the addressee is OBSERVABLY GENERATING never expires the pin,
-        // independently of the accumulated credit.
-        //
-        // The credit ledger alone is not sufficient here, and the difference is the
-        // whole live defect. Credit only accrues from the SECOND observation onward
-        // (the first has no prior interval to bank), and it is in-memory — so a pin
-        // that crossed the wall-clock TTL while the daemon was not watching, or before
-        // a restart, would arrive at its very first post-restart observation with zero
-        // credit and expire on the spot, while the session it is addressed to is
-        // visibly mid-turn. That is exactly the observed failure (`unclaimed 902s`
-        // logged on an `agent:ready`, i.e. at the end of real work) reproduced by a
-        // different route.
-        //
-        // Gating on the live verdict makes "is the addressee working right now?" the
-        // decisive question and leaves the credit ledger as what it should be: an
-        // optimisation that stops intermittent work from silently burning the budget.
-        // It cannot make a pin immortal — the verdict is re-evaluated every tick from
-        // live state and only a LOCAL, observably-generating session can produce it.
-        expired: !generating && unproductiveAgeMs >= TARGET_SESSION_PIN_TTL_MS,
-        ageMs: unproductiveAgeMs,
-        suspended: generating
-      };
-    }
-    function resolveDeadTargetVerdict(components, meshId, mesh, task) {
-      const NOT_DEAD = { dead: false, nodeDead: false, reason: "" };
-      const targetSessionId = readNonEmptyString(task.targetSessionId);
-      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 current provider scan found no usable provider for this task (provider priority missing/unusable, or the provider loader is unavailable; ${reason})`,
-        nextAction: "Check the node's providerPriority policy and that the required CLI/ACP provider is installed and enabled on that machine. Quota-gated candidates use a separate, self-resolving reason and are not proof of this configuration blocker."
-      };
-      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 === PARKED_SKIP_REASON) {
-        const base = "it was pinned to a specific session, that pin went stale, and the task is now PARKED \u2014 deliberately held for you rather than re-homed onto another session, because a delta written for one session's context becomes a context-free instruction anywhere else";
-        if (evidence === "consumed") return {
-          summary: `${base}. The delivery record shows the addressed session DID receive and start acting on this message, so the parked row is a bookkeeping remnant, not a lost delta`,
-          nextAction: "Do NOT re-send it. Confirm with mesh_read_chat / mesh_read_terminal that the work is under way, then clear the park with mesh_queue_cancel (or requeue it only if you genuinely want it run again)."
-        };
-        if (evidence === "delivered") return {
-          summary: `${base}. The message WAS handed to that session's transport but no turn start was echoed, so whether it acted on it is unconfirmed`,
-          nextAction: "Check the session (mesh_read_chat / mesh_read_terminal) before acting. If it is already handling it, cancel the parked row; if not, mesh_queue_requeue with target_session_id=<live session> \u2014 and pass message=<rewritten instruction> if the situation moved on while it waited."
-        };
-        return {
-          summary: `${base}. No delivery to that session was ever recorded, so the message did not reach it and the worker is still acting on its previous instructions`,
-          nextAction: "Re-target it with mesh_queue_requeue(target_session_id=<live session>), or drop the pin with clear_target_session to let any compatible session take it. Re-read the work produced meanwhile and pass message=<rewritten instruction> if the delta is now partly stale; mesh_queue_cancel if it is moot."
-        };
-      }
-      if (reason === "target_session_pin_expired") {
-        if (evidence === "consumed") return {
-          summary: "it was pinned to a specific session and the pin TTL expired before the queue row was claimed \u2014 but the delivery record shows this session DID receive and start acting on the message (a turn was started for it), so the queue row lagging is a bookkeeping gap, not a lost delta",
-          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 {
-      }
-      if (task && task.status !== "pending") {
-        LOG2.info("MeshQueue", `Suppressed stale dispatch-blocked page for task ${taskId} (mesh ${meshId}): reason '${reason}' was computed against a pre-await snapshot, but the task is now '${task.status}'.`);
-        lastActionableSkipNotified.delete(dedupKey);
-        return;
-      }
-      const targetCoordinatorDaemonId = readNonEmptyString(loadConfig2().machineId);
-      const targetCoordinatorSessionId = readNonEmptyString(task?.sourceCoordinatorSessionId);
-      const nodeLabel = readNonEmptyString(nodeId) || readNonEmptyString(task?.targetNodeId);
-      const evidence = reason === "target_session_pin_expired" || reason === PARKED_SKIP_REASON ? resolveTaskDeliveryEvidence(meshId, taskId) : void 0;
-      const { summary, nextAction } = actionableSkipGuidance(reason, evidence);
-      const providerAvailabilityResult = reason.startsWith("provider") || reason === "missing_provider_priority";
-      const reachabilityResult = reason.startsWith("remote_auto_launch");
-      const closing = reason === PARKED_SKIP_REASON ? `This task is claimable by NOBODY until you act on it \u2014 no session will pick it up and no timer will re-home it. It is held for ${Math.round(PARKED_TASK_RETENTION_MS / 36e5)}h and then failed (with another notification), so it is never silently discarded. Parked rows are listed under parkedTasks in mesh_view_queue, and any mesh_queue_requeue unparks it \u2014 including one that only rewrites its message.` : reason === "target_session_pin_expired" ? "The stale pin has already been cleared, so the task is now claimable by any compatible session \u2014 the action above is about the session it was originally addressed to." : providerAvailabilityResult ? "This result needs action if it persists: a later provider-status refresh or an already-starting usable session can clear it, but a genuinely missing, disabled, or misconfigured provider will keep the task pending until you fix that configuration." : reachabilityResult ? "This result needs action if it persists: the node reconnecting (or re-registering its daemon id) clears it on its own, but a node that stays unreachable will keep the task pending until you bring it back or re-target the task." : "This is an actionable blocker \u2014 it will NOT clear on its own; the task stays pending until you resolve it.";
-      const coordinatorMessage = `[System] A queued mesh task${nodeLabel ? ` for node ${nodeLabel}` : ""} is not being dispatched because ${summary}. ${nextAction} ${closing}`;
-      try {
-        queuePendingMeshCoordinatorEvent({
-          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 targetPinGeneratingCreditMs;
-    var init_mesh_skip_notify = __esm2({
-      "src/mesh/mesh-skip-notify.ts"() {
-        "use strict";
-        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();
-        init_mesh_queue_observability();
-        init_mesh_task_parking();
-        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",
-          // PIN-PARKING: the reason above's successor. The pin no longer CLEARS on expiry
-          // (that silently re-homed a context-bound delta onto an arbitrary session); the
-          // task PARKS instead — held, still addressed, claimable by nobody. That state is
-          // by construction actionable and terminal-until-touched: nothing in the daemon
-          // will ever move a parked task, so if the coordinator is not told, the work is
-          // lost exactly as surely as if it had been dropped. Both reasons stay listed —
-          // the old one so a version-skewed daemon's rows still page.
-          PARKED_SKIP_REASON,
-          // SLOT MODEL GUARD (absent): no slot on the node declares the task's model.
-          // Permanent — no amount of waiting produces a slot, so the coordinator must
-          // re-drive (adjust difficulty, target another node, ask the owner). Its
-          // 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' /
-          // 'provider_quota_exhausted' / 'all_providers_quota_gated' 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). The
-          // all-gated reason exists precisely so this WAIT is never conflated with
-          // the actionable 'provider_priority_unusable' above.
-        ];
-        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;
-        targetPinGeneratingCreditMs = /* @__PURE__ */ new Map();
-      }
-    });
     function localCoordinatorDaemonId() {
       return canonicalDaemonId(readNonEmptyString(loadConfig2().machineId));
     }
-    function isIdleSessionState2(state) {
+    function isIdleSessionState(state) {
       const status = readNonEmptyString(state?.status).toLowerCase();
       if (TERMINAL_SESSION_STATUSES.includes(status)) return false;
       return status === "idle" || state?.activeChat?.status === "waiting_input";
@@ -79602,7 +79015,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         if (!originTaskId) continue;
         const sessionId = readNonEmptyString(state?.instanceId);
         if (!sessionId) continue;
-        if (!isIdleSessionState2(state)) continue;
+        if (!isIdleSessionState(state)) continue;
         if (sessionHasActiveAssignment(meshId, sessionId)) continue;
         const originTask = byId.get(originTaskId);
         const assignedElsewhere = !!originTask && originTask.status === "assigned" && !!readNonEmptyString(originTask.assignedSessionId) && !sessionIdsEquivalent(readNonEmptyString(originTask.assignedSessionId), sessionId);
@@ -79852,166 +79265,872 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         });
       }
     }
-    var DIFFICULTY_FLOOR_REPORT_AFTER_MS;
-    var TASK_DIFFICULTY_FLOOR_REASON_PREFIX;
-    var TASK_DIFFICULTY_FLOOR_REPORTED_PREFIX;
-    var difficultyFloorTimeoutReported;
-    var DIFFICULTY_FLOOR_REPORT_DEDUP_MAX;
-    var CLASSIFIED_DIFFICULTIES;
-    var init_mesh_difficulty_floor = __esm2({
-      "src/mesh/mesh-difficulty-floor.ts"() {
+    var DIFFICULTY_FLOOR_REPORT_AFTER_MS;
+    var TASK_DIFFICULTY_FLOOR_REASON_PREFIX;
+    var TASK_DIFFICULTY_FLOOR_REPORTED_PREFIX;
+    var difficultyFloorTimeoutReported;
+    var DIFFICULTY_FLOOR_REPORT_DEDUP_MAX;
+    var CLASSIFIED_DIFFICULTIES;
+    var init_mesh_difficulty_floor = __esm2({
+      "src/mesh/mesh-difficulty-floor.ts"() {
+        "use strict";
+        init_mesh_work_queue();
+        init_mesh_events_pending();
+        init_slot_model_enforcement();
+        init_mesh_quota_routing();
+        init_dist();
+        DIFFICULTY_FLOOR_REPORT_AFTER_MS = 10 * 6e4;
+        TASK_DIFFICULTY_FLOOR_REASON_PREFIX = "task_difficulty_floor_";
+        TASK_DIFFICULTY_FLOOR_REPORTED_PREFIX = "task_difficulty_floor_reported:";
+        difficultyFloorTimeoutReported = /* @__PURE__ */ new Set();
+        DIFFICULTY_FLOOR_REPORT_DEDUP_MAX = 2e3;
+        CLASSIFIED_DIFFICULTIES = ["easy", "medium", "difficult"];
+      }
+    });
+    function normalizeProviderPriority2(policy) {
+      const raw = policy && typeof policy === "object" && !Array.isArray(policy) ? policy.providerPriority : void 0;
+      if (!Array.isArray(raw)) return [];
+      const seen = /* @__PURE__ */ new Set();
+      return raw.map((type2) => typeof type2 === "string" ? type2.trim() : "").filter(Boolean).filter((type2) => {
+        if (seen.has(type2)) return false;
+        seen.add(type2);
+        return true;
+      });
+    }
+    function isTerminalSessionStatus(status) {
+      return ["stopped", "failed", "terminated", "exited", "closed"].includes(status);
+    }
+    function isIdleSessionState2(state) {
+      const status = readNonEmptyString(state?.status).toLowerCase();
+      if (isTerminalSessionStatus(status)) return false;
+      return status === "idle" || state?.activeChat?.status === "waiting_input";
+    }
+    function sessionStateLooksActive(state) {
+      const status = readNonEmptyString(state?.status).toLowerCase();
+      const chatStatus = readNonEmptyString(state?.activeChat?.status).toLowerCase();
+      const active = /* @__PURE__ */ new Set(["generating", "streaming", "no_progress", "long_generating", "working", "starting", "waiting_approval"]);
+      return active.has(status) || active.has(chatStatus);
+    }
+    function nodeHasActiveMeshWork(components, meshId, nodeId, currentSessionId) {
+      if (nodeHasActiveAssignment(meshId, nodeId)) return true;
+      return components.instanceManager.getByCategory("cli").some((inst) => {
+        const state = inst.getState();
+        const settings = state.settings || {};
+        if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
+        const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
+        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
+        const sessionId = readNonEmptyString(state.instanceId);
+        if (currentSessionId && sessionIdsEquivalent(sessionId, currentSessionId) && isIdleSessionState2(state)) return false;
+        return sessionStateLooksActive(state);
+      });
+    }
+    function isLaunchableNode(node) {
+      if (!node || node.status === "disabled" || node.status === "removed") return false;
+      if (shouldDeferDispatchForBootstrap(node)) {
+        return false;
+      }
+      return isMeshNodeHealthLaunchable(node);
+    }
+    function isLocalAutoLaunchNode(node) {
+      const daemonId = readNonEmptyString(node?.daemonId);
+      const machineId = readNonEmptyString(node?.machineId);
+      const appConfig = loadConfig2();
+      const localMachineId = readNonEmptyString(appConfig.machineId) || readNonEmptyString(appConfig.registeredMachineId);
+      const daemonMatchesLocal = !daemonId || daemonIdsEquivalent(daemonId, localMachineId);
+      const machineMatchesLocal = !machineId || daemonIdsEquivalent(machineId, localMachineId);
+      if (node?.isLocalWorktree === true) {
+        return daemonMatchesLocal && machineMatchesLocal;
+      }
+      if (daemonId || machineId) {
+        return daemonMatchesLocal && machineMatchesLocal;
+      }
+      return true;
+    }
+    function isSessionActivelyGenerating(components, sessionId) {
+      if (!sessionId) return false;
+      const state = components.instanceManager?.getInstance?.(sessionId)?.getState?.();
+      if (!state) return false;
+      return sessionStateLooksActive(state);
+    }
+    function resolveSessionBusyVerdict(components, sessionId) {
+      if (!sessionId) return "UNKNOWN";
+      try {
+        const instances = components.instanceManager?.getByCategory?.("cli") || [];
+        const inst = instances.find((i) => {
+          const sid = readNonEmptyString(i?.getState?.().instanceId);
+          return sid && sessionIdsEquivalent(sid, sessionId);
+        });
+        if (!inst) return "UNKNOWN";
+        const state = inst.getState?.();
+        if (!state) return "UNKNOWN";
+        return sessionStateLooksActive(state) ? "GENERATING" : "IDLE_CONFIRMED";
+      } catch {
+        return "UNKNOWN";
+      }
+    }
+    function liveSessionCountForNode(components, meshId, nodeId) {
+      const localInstances = components.instanceManager.getByCategory("cli").filter((inst) => {
+        const state = inst.getState();
+        const settings = state.settings || {};
+        if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
+        const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
+        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
+        const status = readNonEmptyString(state.status).toLowerCase();
+        return !isTerminalSessionStatus(status);
+      });
+      let count = localInstances.length;
+      const localSessionIds = localInstances.map((inst) => readNonEmptyString(inst.getState().instanceId)).filter(Boolean);
+      for (const sid of inWindowAutoLaunchSessionIdsForNode(meshId, nodeId)) {
+        if (!localSessionIds.some((local) => sessionIdsEquivalent(local, sid))) count += 1;
+      }
+      return count;
+    }
+    function nodeHasLiveSessionPendingClaim(components, meshId, nodeId, task, node) {
+      if (inWindowAutoLaunchSessionIdsForNode(meshId, nodeId).length > 0) return true;
+      const busySessionIds = new Set(
+        getQueue(meshId, { status: ["assigned"] }).filter((task2) => daemonIdsEquivalent(task2.assignedNodeId, nodeId)).map((task2) => readNonEmptyString(task2.assignedSessionId)).filter(Boolean)
+      );
+      return components.instanceManager.getByCategory("cli").some((inst) => {
+        const state = inst.getState();
+        const settings = state.settings || {};
+        if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
+        if (readNonEmptyString(settings.meshCoordinatorFor) === meshId) return false;
+        const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
+        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
+        const status = readNonEmptyString(state.status).toLowerCase();
+        if (isTerminalSessionStatus(status)) return false;
+        const sessionId = readNonEmptyString(state.instanceId);
+        if (sessionId && busySessionIds.has(sessionId)) return false;
+        const sessionProviderType = state.type || readNonEmptyString(settings.providerType);
+        if (task.requiredTags?.length) {
+          if (sessionProviderType && !nodeSatisfiesRequiredTags(task.requiredTags, buildMeshNodeCapabilityTags(node, sessionProviderType))) {
+            return false;
+          }
+        }
+        const allowance = allowedClassifiedDifficultiesForSession(node, resolveNodeCapabilitySlots(node, meshId), sessionProviderType, readSessionModel(state));
+        if (!taskMeetsSessionDifficultyFloor(task, allowance)) return false;
+        return true;
+      });
+    }
+    var init_mesh_candidacy_predicates = __esm2({
+      "src/mesh/mesh-candidacy-predicates.ts"() {
+        "use strict";
+        init_config();
+        init_mesh_work_queue();
+        init_dist();
+        init_mesh_events_utils();
+        init_mesh_node_identity();
+        init_worktree_bootstrap_config();
+        init_mesh_autolaunch_integrity();
+        init_mesh_scheduling_fitness();
+        init_mesh_node_slots();
+        init_mesh_difficulty_floor();
+      }
+    });
+    function providerPinOverrideCandidateTaskId(meshId, providerType) {
+      const pending = getQueue(meshId, { status: ["pending"] });
+      for (const task of pending) {
+        const tags = task.requiredTags ?? [];
+        if (tags.includes(`provider=${providerType}`)) {
+          return task.id;
+        }
+      }
+      return void 0;
+    }
+    function evaluateQuotaClaimGateForAssignment(args) {
+      const { meshId, nodeId, sessionId, providerType, trigger, node, mesh, providerLoader, quotaClaimTrace } = args;
+      const pinCandidateTaskId = providerPinOverrideCandidateTaskId(meshId, providerType);
+      const isPinOverride = !!pinCandidateTaskId;
+      const quotaClaimBlock = evaluateProviderQuotaGate(node, providerType, mesh?.policy?.quotaRouting ?? null, Date.now(), quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, providerLoader));
+      if (quotaClaimTrace) quotaClaimTrace.evaluated += 1;
+      if (quotaClaimBlock) {
+        const observation = {
+          nodeId,
+          sessionId,
+          providerType,
+          block: quotaClaimBlock,
+          context: { trigger, candidateTaskId: pinCandidateTaskId, pinOverride: isPinOverride }
+        };
+        if (isPinOverride) {
+          logQuotaClaimBlockTransition(meshId, observation, "overridden_by_pin");
+          return false;
+        }
+        logQuotaClaimBlockTransition(meshId, observation, "blocked");
+        quotaClaimTrace?.blocked.push(observation);
+        return true;
+      }
+      clearQuotaClaimBlockState(meshId, nodeId, sessionId, providerType);
+      if (quotaClaimTrace) quotaClaimTrace.clear += 1;
+      return false;
+    }
+    var init_mesh_queue_claim_gate = __esm2({
+      "src/mesh/mesh-queue-claim-gate.ts"() {
+        "use strict";
+        init_mesh_quota_routing();
+        init_mesh_queue_observability();
+        init_mesh_work_queue();
+        init_mesh_candidacy_predicates();
+      }
+    });
+    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?.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,
+        // Mirror the manual mesh_fast_forward_node update_submodules behavior: if the
+        // ff-only merge moves a submodule gitlink, run `git submodule update --init
+        // --recursive` in the same cycle so the checkout never drifts from the gitlink.
+        // Without this, drift accumulates and self-blocks every subsequent auto-ff
+        // (collectPreflightBlockers treats out-of-sync submodules as a hard blocker).
+        updateSubmodules: true
+      };
+      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,
+          // See delegateRemoteAutoFastForward's updateSubmodules comment: mirrors the
+          // manual tool so a gitlink-moving ff cannot leave the submodule drifted.
+          updateSubmodules: true,
+          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: true,
+          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_fs17.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,
+            // Same gitlink-drift-prevention rationale as executeLocalAutoFastForward /
+            // delegateRemoteAutoFastForward — this path pushed the base branch itself,
+            // so a submodule gitlink bump here is exactly as likely.
+            updateSubmodules: 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_fs17;
+    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_fs17 = 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 }) ?? "";
+    }
+    function noteRecentlyClonedNode(nodeId, nowMs = Date.now()) {
+      const key2 = normalizeNodeIdKey(nodeId);
+      if (!key2) return;
+      recentlyClonedNodeExpiry.set(key2, nowMs + CLONE_BOOTSTRAP_GRACE_MS);
+      if (recentlyClonedNodeExpiry.size > MAX_TRACKED_CLONED_NODES) {
+        const oldest = recentlyClonedNodeExpiry.keys().next().value;
+        if (oldest !== void 0) recentlyClonedNodeExpiry.delete(oldest);
+      }
+    }
+    function isWithinCloneBootstrapGrace(nodeId, nowMs = Date.now()) {
+      const key2 = normalizeNodeIdKey(nodeId);
+      if (!key2) return false;
+      const expiry = recentlyClonedNodeExpiry.get(key2);
+      if (expiry === void 0) return false;
+      if (nowMs >= expiry) {
+        recentlyClonedNodeExpiry.delete(key2);
+        return false;
+      }
+      return true;
+    }
+    var CLONE_BOOTSTRAP_GRACE_MS;
+    var recentlyClonedNodeExpiry;
+    var MAX_TRACKED_CLONED_NODES;
+    var init_mesh_clone_grace = __esm2({
+      "src/mesh/mesh-clone-grace.ts"() {
         "use strict";
-        init_mesh_work_queue();
-        init_mesh_events_pending();
-        init_slot_model_enforcement();
-        init_mesh_quota_routing();
         init_dist();
-        DIFFICULTY_FLOOR_REPORT_AFTER_MS = 10 * 6e4;
-        TASK_DIFFICULTY_FLOOR_REASON_PREFIX = "task_difficulty_floor_";
-        TASK_DIFFICULTY_FLOOR_REPORTED_PREFIX = "task_difficulty_floor_reported:";
-        difficultyFloorTimeoutReported = /* @__PURE__ */ new Set();
-        DIFFICULTY_FLOOR_REPORT_DEDUP_MAX = 2e3;
-        CLASSIFIED_DIFFICULTIES = ["easy", "medium", "difficult"];
+        CLONE_BOOTSTRAP_GRACE_MS = 10 * 60 * 1e3;
+        recentlyClonedNodeExpiry = /* @__PURE__ */ new Map();
+        MAX_TRACKED_CLONED_NODES = 512;
       }
     });
-    function normalizeProviderPriority2(policy) {
-      const raw = policy && typeof policy === "object" && !Array.isArray(policy) ? policy.providerPriority : void 0;
-      if (!Array.isArray(raw)) return [];
-      const seen = /* @__PURE__ */ new Set();
-      return raw.map((type2) => typeof type2 === "string" ? type2.trim() : "").filter(Boolean).filter((type2) => {
-        if (seen.has(type2)) return false;
-        seen.add(type2);
-        return true;
-      });
-    }
-    function isTerminalSessionStatus(status) {
-      return ["stopped", "failed", "terminated", "exited", "closed"].includes(status);
-    }
-    function isIdleSessionState3(state) {
-      const status = readNonEmptyString(state?.status).toLowerCase();
-      if (isTerminalSessionStatus(status)) return false;
-      return status === "idle" || state?.activeChat?.status === "waiting_input";
+    function isActionableSkipReason(reason) {
+      if (!reason) return false;
+      return ACTIONABLE_SKIP_REASON_PREFIXES.some((prefix) => reason === prefix || reason.startsWith(prefix));
     }
-    function sessionStateLooksActive(state) {
-      const status = readNonEmptyString(state?.status).toLowerCase();
-      const chatStatus = readNonEmptyString(state?.activeChat?.status).toLowerCase();
-      const active = /* @__PURE__ */ new Set(["generating", "streaming", "no_progress", "long_generating", "working", "starting", "waiting_approval"]);
-      return active.has(status) || active.has(chatStatus);
+    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 nodeHasActiveMeshWork(components, meshId, nodeId, currentSessionId) {
-      if (nodeHasActiveAssignment(meshId, nodeId)) return true;
-      return components.instanceManager.getByCategory("cli").some((inst) => {
-        const state = inst.getState();
-        const settings = state.settings || {};
-        if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
-        const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
-        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
-        const sessionId = readNonEmptyString(state.instanceId);
-        if (currentSessionId && sessionIdsEquivalent(sessionId, currentSessionId) && isIdleSessionState3(state)) return false;
-        return sessionStateLooksActive(state);
-      });
+    function targetPinAgeMs(task, nowMs = Date.now()) {
+      const anchorMs = Date.parse(task.requeuedAt || task.createdAt || "");
+      return Number.isFinite(anchorMs) ? nowMs - anchorMs : null;
     }
-    function isLaunchableNode(node) {
-      if (!node || node.status === "disabled" || node.status === "removed") return false;
-      if (shouldDeferDispatchForBootstrap(node)) {
-        return false;
+    function resolveTargetPinTtlVerdict(components, task, nowMs = Date.now()) {
+      const wallAgeMs = targetPinAgeMs(task, nowMs);
+      if (wallAgeMs === null) return { expired: false, ageMs: null, suspended: false };
+      const targetSessionId = readNonEmptyString(task.targetSessionId);
+      const key2 = `${task.meshId}::${task.id}`;
+      const prior = targetPinGeneratingCreditMs.get(key2);
+      const generating = !!targetSessionId && resolveSessionBusyVerdict(components, targetSessionId) === "GENERATING";
+      let creditMs = prior?.creditMs ?? 0;
+      if (generating && prior) {
+        creditMs += Math.max(0, nowMs - prior.lastSeenMs);
       }
-      return isMeshNodeHealthLaunchable(node);
+      targetPinGeneratingCreditMs.set(key2, { creditMs, lastSeenMs: nowMs });
+      const unproductiveAgeMs = Math.max(0, wallAgeMs - creditMs);
+      return {
+        // A tick on which the addressee is OBSERVABLY GENERATING never expires the pin,
+        // independently of the accumulated credit.
+        //
+        // The credit ledger alone is not sufficient here, and the difference is the
+        // whole live defect. Credit only accrues from the SECOND observation onward
+        // (the first has no prior interval to bank), and it is in-memory — so a pin
+        // that crossed the wall-clock TTL while the daemon was not watching, or before
+        // a restart, would arrive at its very first post-restart observation with zero
+        // credit and expire on the spot, while the session it is addressed to is
+        // visibly mid-turn. That is exactly the observed failure (`unclaimed 902s`
+        // logged on an `agent:ready`, i.e. at the end of real work) reproduced by a
+        // different route.
+        //
+        // Gating on the live verdict makes "is the addressee working right now?" the
+        // decisive question and leaves the credit ledger as what it should be: an
+        // optimisation that stops intermittent work from silently burning the budget.
+        // It cannot make a pin immortal — the verdict is re-evaluated every tick from
+        // live state and only a LOCAL, observably-generating session can produce it.
+        expired: !generating && unproductiveAgeMs >= TARGET_SESSION_PIN_TTL_MS,
+        ageMs: unproductiveAgeMs,
+        suspended: generating
+      };
     }
-    function isLocalAutoLaunchNode(node) {
-      const daemonId = readNonEmptyString(node?.daemonId);
-      const machineId = readNonEmptyString(node?.machineId);
-      const appConfig = loadConfig2();
-      const localMachineId = readNonEmptyString(appConfig.machineId) || readNonEmptyString(appConfig.registeredMachineId);
-      const daemonMatchesLocal = !daemonId || daemonIdsEquivalent(daemonId, localMachineId);
-      const machineMatchesLocal = !machineId || daemonIdsEquivalent(machineId, localMachineId);
-      if (node?.isLocalWorktree === true) {
-        return daemonMatchesLocal && machineMatchesLocal;
+    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 (daemonId || machineId) {
-        return daemonMatchesLocal && machineMatchesLocal;
+      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 true;
+      return NOT_DEAD;
     }
-    function isSessionActivelyGenerating(components, sessionId) {
-      if (!sessionId) return false;
-      const state = components.instanceManager?.getInstance?.(sessionId)?.getState?.();
-      if (!state) return false;
-      return sessionStateLooksActive(state);
+    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 resolveSessionBusyVerdict(components, sessionId) {
-      if (!sessionId) return "UNKNOWN";
+    function resolveTaskDeliveryEvidence(meshId, taskId) {
       try {
-        const instances = components.instanceManager?.getByCategory?.("cli") || [];
-        const inst = instances.find((i) => {
-          const sid = readNonEmptyString(i?.getState?.().instanceId);
-          return sid && sessionIdsEquivalent(sid, sessionId);
-        });
-        if (!inst) return "UNKNOWN";
-        const state = inst.getState?.();
-        if (!state) return "UNKNOWN";
-        return sessionStateLooksActive(state) ? "GENERATING" : "IDLE_CONFIRMED";
+        const store = MeshRuntimeStore.getInstance();
+        if (store.taskDeliveryConsumed(meshId, taskId)) return "consumed";
+        if (store.taskHasConfirmedDelivery(meshId, taskId)) return "delivered";
       } catch {
-        return "UNKNOWN";
+        return "delivered";
       }
+      return "never_dispatched";
     }
-    function liveSessionCountForNode(components, meshId, nodeId) {
-      const localInstances = components.instanceManager.getByCategory("cli").filter((inst) => {
-        const state = inst.getState();
-        const settings = state.settings || {};
-        if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
-        const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
-        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
-        const status = readNonEmptyString(state.status).toLowerCase();
-        return !isTerminalSessionStatus(status);
-      });
-      let count = localInstances.length;
-      const localSessionIds = localInstances.map((inst) => readNonEmptyString(inst.getState().instanceId)).filter(Boolean);
-      for (const sid of inWindowAutoLaunchSessionIdsForNode(meshId, nodeId)) {
-        if (!localSessionIds.some((local) => sessionIdsEquivalent(local, sid))) count += 1;
+    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 current provider scan found no usable provider for this task (provider priority missing/unusable, or the provider loader is unavailable; ${reason})`,
+        nextAction: "Check the node's providerPriority policy and that the required CLI/ACP provider is installed and enabled on that machine. Quota-gated candidates use a separate, self-resolving reason and are not proof of this configuration blocker."
+      };
+      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 === PARKED_SKIP_REASON) {
+        const base = "it was pinned to a specific session, that pin went stale, and the task is now PARKED \u2014 deliberately held for you rather than re-homed onto another session, because a delta written for one session's context becomes a context-free instruction anywhere else";
+        if (evidence === "consumed") return {
+          summary: `${base}. The delivery record shows the addressed session DID receive and start acting on this message, so the parked row is a bookkeeping remnant, not a lost delta`,
+          nextAction: "Do NOT re-send it. Confirm with mesh_read_chat / mesh_read_terminal that the work is under way, then clear the park with mesh_queue_cancel (or requeue it only if you genuinely want it run again)."
+        };
+        if (evidence === "delivered") return {
+          summary: `${base}. The message WAS handed to that session's transport but no turn start was echoed, so whether it acted on it is unconfirmed`,
+          nextAction: "Check the session (mesh_read_chat / mesh_read_terminal) before acting. If it is already handling it, cancel the parked row; if not, mesh_queue_requeue with target_session_id=<live session> \u2014 and pass message=<rewritten instruction> if the situation moved on while it waited."
+        };
+        return {
+          summary: `${base}. No delivery to that session was ever recorded, so the message did not reach it and the worker is still acting on its previous instructions`,
+          nextAction: "Re-target it with mesh_queue_requeue(target_session_id=<live session>), or drop the pin with clear_target_session to let any compatible session take it. Re-read the work produced meanwhile and pass message=<rewritten instruction> if the delta is now partly stale; mesh_queue_cancel if it is moot."
+        };
       }
-      return count;
+      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 nodeHasLiveSessionPendingClaim(components, meshId, nodeId, task, node) {
-      if (inWindowAutoLaunchSessionIdsForNode(meshId, nodeId).length > 0) return true;
-      const busySessionIds = new Set(
-        getQueue(meshId, { status: ["assigned"] }).filter((task2) => daemonIdsEquivalent(task2.assignedNodeId, nodeId)).map((task2) => readNonEmptyString(task2.assignedSessionId)).filter(Boolean)
-      );
-      return components.instanceManager.getByCategory("cli").some((inst) => {
-        const state = inst.getState();
-        const settings = state.settings || {};
-        if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
-        if (readNonEmptyString(settings.meshCoordinatorFor) === meshId) return false;
-        const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
-        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
-        const status = readNonEmptyString(state.status).toLowerCase();
-        if (isTerminalSessionStatus(status)) return false;
-        const sessionId = readNonEmptyString(state.instanceId);
-        if (sessionId && busySessionIds.has(sessionId)) return false;
-        const sessionProviderType = state.type || readNonEmptyString(settings.providerType);
-        if (task.requiredTags?.length) {
-          if (sessionProviderType && !nodeSatisfiesRequiredTags(task.requiredTags, buildMeshNodeCapabilityTags(node, sessionProviderType))) {
-            return false;
-          }
-        }
-        const allowance = allowedClassifiedDifficultiesForSession(node, resolveNodeCapabilitySlots(node, meshId), sessionProviderType, readSessionModel(state));
-        if (!taskMeetsSessionDifficultyFloor(task, allowance)) return false;
-        return true;
-      });
+    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 {
+      }
+      if (task && task.status !== "pending") {
+        LOG2.info("MeshQueue", `Suppressed stale dispatch-blocked page for task ${taskId} (mesh ${meshId}): reason '${reason}' was computed against a pre-await snapshot, but the task is now '${task.status}'.`);
+        lastActionableSkipNotified.delete(dedupKey);
+        return;
+      }
+      const targetCoordinatorDaemonId = readNonEmptyString(loadConfig2().machineId);
+      const targetCoordinatorSessionId = readNonEmptyString(task?.sourceCoordinatorSessionId);
+      const nodeLabel = readNonEmptyString(nodeId) || readNonEmptyString(task?.targetNodeId);
+      const evidence = reason === "target_session_pin_expired" || reason === PARKED_SKIP_REASON ? resolveTaskDeliveryEvidence(meshId, taskId) : void 0;
+      const { summary, nextAction } = actionableSkipGuidance(reason, evidence);
+      const providerAvailabilityResult = reason.startsWith("provider") || reason === "missing_provider_priority";
+      const reachabilityResult = reason.startsWith("remote_auto_launch");
+      const closing = reason === PARKED_SKIP_REASON ? `This task is claimable by NOBODY until you act on it \u2014 no session will pick it up and no timer will re-home it. It is held for ${Math.round(PARKED_TASK_RETENTION_MS / 36e5)}h and then failed (with another notification), so it is never silently discarded. Parked rows are listed under parkedTasks in mesh_view_queue, and any mesh_queue_requeue unparks it \u2014 including one that only rewrites its message.` : reason === "target_session_pin_expired" ? "The stale pin has already been cleared, so the task is now claimable by any compatible session \u2014 the action above is about the session it was originally addressed to." : providerAvailabilityResult ? "This result needs action if it persists: a later provider-status refresh or an already-starting usable session can clear it, but a genuinely missing, disabled, or misconfigured provider will keep the task pending until you fix that configuration." : reachabilityResult ? "This result needs action if it persists: the node reconnecting (or re-registering its daemon id) clears it on its own, but a node that stays unreachable will keep the task pending until you bring it back or re-target the task." : "This is an actionable blocker \u2014 it will NOT clear on its own; the task stays pending until you resolve it.";
+      const coordinatorMessage = `[System] A queued mesh task${nodeLabel ? ` for node ${nodeLabel}` : ""} is not being dispatched because ${summary}. ${nextAction} ${closing}`;
+      try {
+        queuePendingMeshCoordinatorEvent({
+          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 init_mesh_candidacy_predicates = __esm2({
-      "src/mesh/mesh-candidacy-predicates.ts"() {
+    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 targetPinGeneratingCreditMs;
+    var init_mesh_skip_notify = __esm2({
+      "src/mesh/mesh-skip-notify.ts"() {
         "use strict";
-        init_config();
+        init_logger();
         init_mesh_work_queue();
+        init_mesh_runtime_store();
         init_dist();
         init_mesh_events_utils();
-        init_mesh_node_identity();
+        init_mesh_events_pending();
         init_worktree_bootstrap_config();
-        init_mesh_autolaunch_integrity();
-        init_mesh_scheduling_fitness();
-        init_mesh_node_slots();
-        init_mesh_difficulty_floor();
+        init_mesh_clone_grace();
+        init_config();
+        init_slot_model_enforcement();
+        init_mesh_queue_assignment();
+        init_mesh_queue_observability();
+        init_mesh_task_parking();
+        ACTIONABLE_SKIP_REASON_PREFIXES = [
+          "target_node_id_unmatched",
+          "no_node_satisfies_required_tags",
+          "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",
+          // PIN-PARKING: the reason above's successor. The pin no longer CLEARS on expiry
+          // (that silently re-homed a context-bound delta onto an arbitrary session); the
+          // task PARKS instead — held, still addressed, claimable by nobody. That state is
+          // by construction actionable and terminal-until-touched: nothing in the daemon
+          // will ever move a parked task, so if the coordinator is not told, the work is
+          // lost exactly as surely as if it had been dropped. Both reasons stay listed —
+          // the old one so a version-skewed daemon's rows still page.
+          PARKED_SKIP_REASON,
+          // SLOT MODEL GUARD (absent): no slot on the node declares the task's model.
+          // Permanent — no amount of waiting produces a slot, so the coordinator must
+          // re-drive (adjust difficulty, target another node, ask the owner). Its
+          // 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' /
+          // 'provider_quota_exhausted' / 'all_providers_quota_gated' 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). The
+          // all-gated reason exists precisely so this WAIT is never conflated with
+          // the actionable 'provider_priority_unusable' above.
+        ];
+        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;
+        targetPinGeneratingCreditMs = /* @__PURE__ */ new Map();
       }
     });
     function liveSessionsForNode(components, meshId, nodeId) {
@@ -81141,7 +81260,7 @@ ${block2.text}`,
         return void 0;
       }
     }
-    function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType, routingDecision, quotaClaimTrace) {
+    function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType, routingDecision, quotaClaimTrace, trigger = "queue_claim") {
       const mesh = getMeshWithCache(components, meshId);
       const node = mesh?.nodes.find((n) => meshNodeIdMatches(n, nodeId));
       if (routingDecision?.source !== "autoLaunch") {
@@ -81152,16 +81271,9 @@ ${block2.text}`,
         noteClaimDeferredForNode(meshId, nodeId);
         return false;
       }
-      const quotaClaimBlock = evaluateProviderQuotaGate(node, providerType, mesh?.policy?.quotaRouting ?? null, Date.now(), quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader));
-      if (quotaClaimTrace) quotaClaimTrace.evaluated += 1;
-      if (quotaClaimBlock) {
-        const observation = { nodeId, sessionId, providerType, block: quotaClaimBlock };
-        logQuotaClaimBlockTransition(meshId, observation);
-        quotaClaimTrace?.blocked.push(observation);
+      if (evaluateQuotaClaimGateForAssignment({ meshId, nodeId, sessionId, providerType, trigger, node, mesh, providerLoader: components.providerLoader, quotaClaimTrace })) {
         return false;
       }
-      clearQuotaClaimBlockState(meshId, nodeId, sessionId, providerType);
-      if (quotaClaimTrace) quotaClaimTrace.clear += 1;
       const inlineBootstrapNode = (() => {
         try {
           const inlineMesh = components.router?.getCachedInlineMesh?.(meshId);
@@ -81694,7 +81806,7 @@ ${block2.text}`,
               if (shouldRedriveDeferredClaim(meshId, alNodeId, alSessionId, () => isWorkspaceAutoFastForwardInFlight(readNonEmptyString(
                 (Array.isArray(mesh?.nodes) ? mesh.nodes.find((n) => meshNodeIdMatches(n, alNodeId)) : void 0)?.workspace
               )))) {
-                if (tryAssignQueueTask(components, meshId, alNodeId, alSessionId, alProvider)) {
+                if (tryAssignQueueTask(components, meshId, alNodeId, alSessionId, alProvider, void 0, void 0, "auto_launch")) {
                   clearClaimDeferralForNode(meshId, alNodeId);
                   recordAutoLaunchEvent(meshId, { phase: "completed", taskId: task.id, reason: "fast_forward_deferred_claim_redriven", nodeId: alNodeId, sessionId: alSessionId });
                   LOG2.info("MeshQueue", `Auto-launch re-drove the auto-fast-forward-deferred claim for task ${task.id} into session ${alSessionId} on node ${alNodeId} (mesh ${meshId})`);
@@ -82014,7 +82126,7 @@ ${block2.text}`,
                 executedSlot: slotDecision.slot,
                 demotionReason
               });
-              tryAssignQueueTask(components, meshId, nodeId, sessionId, effectiveProviderType, routingDecision);
+              tryAssignQueueTask(components, meshId, nodeId, sessionId, effectiveProviderType, routingDecision, void 0, "auto_launch");
               return true;
             } catch (e) {
               markAutoLaunch(meshId, task.id, { status: "failed", error: e?.message || String(e), nodeId });
@@ -82072,7 +82184,7 @@ ${block2.text}`,
         if (instMeshId !== meshId) continue;
         const nodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
         if (!nodeId) continue;
-        if (!isIdleSessionState3(state)) {
+        if (!isIdleSessionState2(state)) {
           const status = readNonEmptyString(state.status).toLowerCase();
           skippedSessions.push({
             nodeId,
@@ -82110,7 +82222,7 @@ ${block2.text}`,
       }
       const quotaClaimTrace = { blocked: [], evaluated: 0, clear: 0 };
       const assignIdleCandidate = (candidate) => {
-        const assigned = tryAssignQueueTask(components, meshId, candidate.nodeId, candidate.sessionId, candidate.providerType, void 0, quotaClaimTrace);
+        const assigned = tryAssignQueueTask(components, meshId, candidate.nodeId, candidate.sessionId, candidate.providerType, void 0, quotaClaimTrace, "idle_claim_scan");
         if (assigned && candidate.origin === "remote") {
           try {
             MeshRuntimeStore.getInstance().deleteRemoteIdleSession(meshId, candidate.nodeId, candidate.sessionId);
@@ -82190,7 +82302,7 @@ ${block2.text}`,
       setImmediate(() => {
         maybeAutoFastForwardIdleNode(components, args).finally(() => {
           try {
-            tryAssignQueueTask(components, args.meshId, args.nodeId, args.sessionId, args.providerType);
+            tryAssignQueueTask(components, args.meshId, args.nodeId, args.sessionId, args.providerType, void 0, void 0, "idle_maintenance");
           } catch (e) {
             LOG2.warn("MeshQueue", `Failed to assign idle queue task after maintenance for ${args.nodeId}: ${e?.message || e}`);
           }
@@ -82231,6 +82343,7 @@ ${block2.text}`,
         init_mesh_node_slots();
         init_mesh_daemon_slot_axis();
         init_mesh_quota_routing();
+        init_mesh_queue_claim_gate();
         init_mesh_events_stale();
         init_mesh_events_utils();
         init_mesh_node_identity();
@@ -88213,6 +88326,97 @@ ${cleanBody}`;
         init_chat_message_normalization();
       }
     });
+    function flattenMessage(message) {
+      const meta3 = message.meta && typeof message.meta === "object" ? message.meta : void 0;
+      return {
+        role: message.role,
+        kind: message.kind,
+        content: flattenContent(message.content),
+        receivedAt: message.receivedAt,
+        timestamp: message.timestamp,
+        turnKey: message._turnKey,
+        bubbleState: message.bubbleState,
+        senderName: message.senderName,
+        toolName: void 0,
+        meta: meta3
+      };
+    }
+    function buildTranscriptObservationFromReadChat(input) {
+      if (!input.sessionId || !input.providerType) return null;
+      return {
+        sessionId: input.sessionId,
+        historySessionId: input.historySessionId ?? null,
+        providerType: input.providerType,
+        providerSessionId: input.providerSessionId ?? null,
+        status: input.status,
+        providerObservedStatus: input.providerObservedStatus,
+        title: input.title ?? null,
+        activeModal: input.activeModal ?? null,
+        activeInteractivePrompt: input.activeInteractivePrompt ?? null,
+        turn: input.turn,
+        provenance: input.provenance,
+        messages: input.messages.map(flattenMessage),
+        terminalMarkers: [],
+        coverage: input.coverage
+      };
+    }
+    var init_transcript_observation_builder = __esm2({
+      "src/commands/transcript-observation-builder.ts"() {
+        "use strict";
+        init_contracts2();
+      }
+    });
+    var TRANSCRIPT_REVISION_CHUNK_BYTES;
+    var MAX_TRANSCRIPT_REVISION_ROWS;
+    var MAX_TRANSCRIPT_REVISION_CHUNKS;
+    var init_transcript_revision_codec = __esm2({
+      "src/seqscribe/transcript-revision-codec.ts"() {
+        "use strict";
+        init_dist();
+        init_dist2();
+        TRANSCRIPT_REVISION_CHUNK_BYTES = 36 * 1024;
+        MAX_TRANSCRIPT_REVISION_ROWS = 240;
+        MAX_TRANSCRIPT_REVISION_CHUNKS = MAX_TRANSCRIPT_REVISION_ROWS - 2;
+      }
+    });
+    var init_transcript_projection = __esm2({
+      "src/seqscribe/transcript-projection.ts"() {
+        "use strict";
+        init_dist2();
+      }
+    });
+    var init_transcript_observation = __esm2({
+      "src/seqscribe/transcript-observation.ts"() {
+        "use strict";
+        init_dist2();
+      }
+    });
+    var init_transcript_mode = __esm2({
+      "src/seqscribe/transcript-mode.ts"() {
+        "use strict";
+        init_logger();
+      }
+    });
+    function notifyTranscriptObservation(sessionId, observation) {
+      activeService?.observe(sessionId, observation);
+    }
+    function markTranscriptSessionDirty(sessionId) {
+      activeService?.markDirty(sessionId);
+    }
+    var import_node_crypto4;
+    var activeService;
+    var init_transcript_publisher = __esm2({
+      "src/seqscribe/transcript-publisher.ts"() {
+        "use strict";
+        import_node_crypto4 = require("crypto");
+        init_logger();
+        init_transcript_revision_codec();
+        init_transcript_projection();
+        init_transcript_observation();
+        init_transcript_mode();
+        activeService = null;
+      }
+    });
     function shouldPreserveReadChatPayloadField(key2) {
       return key2 === "messageSource" || key2 === "transcriptProvenance";
     }
@@ -88347,6 +88551,30 @@ ${cleanBody}`;
       if (preservedPayloadFields.transcriptProvenance) {
         preservedPayloadFields.transcriptProvenance = updateMessageSourceReturnedCount(preservedPayloadFields.transcriptProvenance, sync.messages.length);
       }
+      try {
+        const observation = buildTranscriptObservationFromReadChat({
+          sessionId: sessionIdHint || presentationSessionIdHint,
+          historySessionId: typeof validatedPayload.historySessionId === "string" ? validatedPayload.historySessionId : null,
+          providerType: providerHint || turnPresentation.providerType || "",
+          providerSessionId: typeof validatedPayload.providerSessionId === "string" ? validatedPayload.providerSessionId : null,
+          status: effectiveStatus,
+          providerObservedStatus: legacyStatus,
+          title: typeof validatedPayload.title === "string" ? validatedPayload.title : null,
+          activeModal: validatedPayload.activeModal ?? null,
+          activeInteractivePrompt: validatedPayload.activeInteractivePrompt ?? null,
+          turn: turnPresentation.authority === "turn_reducer" ? turnPresentation : null,
+          provenance: preservedPayloadFields,
+          messages: visibleMessages,
+          coverage: {
+            mode: "full",
+            totalMessageCount: messages.length,
+            returnedMessageCount: visibleMessages.length,
+            omittedBefore: false
+          }
+        });
+        if (observation) notifyTranscriptObservation(observation.sessionId, observation);
+      } catch {
+      }
       const returnedDebugReadChat = debugReadChat ? {
         ...debugReadChat,
         fullMsgCount: typeof debugReadChat.fullMsgCount === "number" ? debugReadChat.fullMsgCount : messages.length,
@@ -88395,6 +88623,8 @@ ${cleanBody}`;
         init_mesh_turn_presentation();
         init_chat_message_normalization();
         init_read_chat_message_filters();
+        init_transcript_observation_builder();
+        init_transcript_publisher();
       }
     });
     function getMeshV2BackstopCounters() {
@@ -90685,8 +90915,9 @@ ${cleanBody}`;
         for (const mesh of listMeshes()) {
           const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
           if (!daemonHostsMesh(mesh, selfIds)) continue;
+          const nodeAwareMesh = getMeshWithCache(components, mesh.id) ?? mesh;
           try {
-            await pullRemoteNodeQueues(components, mesh, localDaemonId, selfIds);
+            await pullRemoteNodeQueues(components, nodeAwareMesh, localDaemonId, selfIds);
           } catch (e) {
             LOG2.warn("MeshReconcile", `Remote node pull failed for mesh ${mesh.id}: ${e?.message || e}`);
           }
@@ -96156,6 +96387,7 @@ ${mergeTreeErr?.stderr || ""}`;
             const result = await execFileAsync8(spawn7.file, spawn7.args, {
               cwd,
               encoding: "utf8",
+              windowsHide: true,
               timeout,
               maxBuffer: candidate.outputLimitBytes || REFINE_VALIDATION_OUTPUT_LIMIT_BYTES,
               env: { ...process.env, CI: process.env.CI || "1", ...refineGateChildEnv(), ...candidate.env || {} },
@@ -96201,6 +96433,7 @@ ${mergeTreeErr?.stderr || ""}`;
           const result = await execFileAsync8(spawn7.file, spawn7.args, {
             cwd,
             encoding: "utf8",
+            windowsHide: true,
             timeout,
             maxBuffer: candidate.outputLimitBytes || REFINE_VALIDATION_OUTPUT_LIMIT_BYTES,
             env: { ...process.env, CI: process.env.CI || "1", ...refineGateChildEnv(), ...candidate.env || {} },
@@ -99723,6 +99956,7 @@ ${e?.stderr || ""}`;
       appendLedgerEntry: () => appendLedgerEntry,
       appendRecentActivity: () => appendRecentActivity,
       appendRemoteLedgerEntries: () => appendRemoteLedgerEntries,
+      applyDaemonEnvOverrides: () => applyDaemonEnvOverrides,
       armBeacon: () => armBeacon,
       assertNoDependencyCycle: () => assertNoDependencyCycle,
       assertNoPlaintextHintTopics: () => assertNoPlaintextHintTopics,
@@ -99985,6 +100219,7 @@ ${e?.stderr || ""}`;
       isPreviewReleaseChannel: () => isPreviewReleaseChannel,
       isProjectedPayloadKey: () => isProjectedPayloadKey,
       isRestartBlockingPresentation: () => isRestartBlockingPresentation,
+      isSecretLikeEnvKey: () => isSecretLikeEnvKey,
       isSessionHostLiveRuntime: () => import_session_host_core32.isSessionHostLiveRuntime,
       isSessionHostRecoverySnapshot: () => import_session_host_core32.isSessionHostRecoverySnapshot,
       isSetupComplete: () => isSetupComplete,
@@ -101617,6 +101852,7 @@ ${e?.stderr || ""}`;
     };
     init_git_worktree();
     init_config();
+    init_env_overrides();
     init_config_dir();
     init_embedded_path_health();
     var os11 = __toESM2(require("os"));
@@ -106962,7 +107198,7 @@ ${effect.notification.body || ""}`.trim();
     }
     var fs21 = __toESM2(require("fs"));
     var path30 = __toESM2(require("path"));
-    var import_node_crypto4 = require("crypto");
+    var import_node_crypto5 = require("crypto");
     init_config();
     init_logger();
     init_debug_trace();
@@ -109105,7 +109341,7 @@ ${effect.notification.body || ""}`.trim();
     function createChatDebugBundleId(targetSessionId) {
       const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:.]/g, "").replace("T", "T").replace("Z", "Z");
       const sessionSegment = safeBundleIdSegment(targetSessionId, "unknown-session");
-      return `chat-debug-${timestamp2}-${sessionSegment}-${(0, import_node_crypto4.randomUUID)().slice(0, 8)}`;
+      return `chat-debug-${timestamp2}-${sessionSegment}-${(0, import_node_crypto5.randomUUID)().slice(0, 8)}`;
     }
     function buildChatDebugBundleSummary(bundle) {
       const target = bundle.target && typeof bundle.target === "object" ? bundle.target : {};
@@ -121552,8 +121788,102 @@ ${marker}`,
       }
       return out;
     }
+    var USER_RE = /^>\s+(\S.*)$/;
+    var EMPTY_COMPOSER_RE = /^>\s*$/;
+    var TOOL_RE = /^●\s+\S+/;
+    var THOUGHT_RE = /^▸\s/;
+    var RULE_RE = /^[─━═\-]{3,}\s*$/;
+    var JSON_START_RE = /^\s*[{\[]/;
+    var CHROME_RES = [
+      RULE_RE,
+      EMPTY_COMPOSER_RE,
+      /^\s*\? for shortcuts/,
+      /esc to cancel/i,
+      /^Resume:\s+agy\b/i,
+      /^Antigravity CLI\b/,
+      /\(Google AI (?:Ultra|Pro|Free)\)/,
+      /^\s*↑\/↓\s+Navigate/,
+      /^Requesting permission for:/,
+      /^Do you want to proceed\?/,
+      /^Accept this file edit\?/,
+      /^Allow (?:access to|creation of) this file\?/,
+      /^Allow sandbox bypass/,
+      /^Command\s*$/
+    ];
+    function isChrome(line) {
+      for (const re of CHROME_RES) {
+        if (re.test(line)) return true;
+      }
+      return false;
+    }
+    function isIndented(line) {
+      return /^\s+\S/.test(line);
+    }
+    function assistantMessage(content) {
+      return {
+        role: "assistant",
+        kind: "standard",
+        content,
+        source: "assistant_text",
+        userFacing: true,
+        bubbleState: "final"
+      };
+    }
+    function extractAntigravityScreenAssistantMessages(screenText) {
+      const lines = String(screenText || "").split(/\r?\n/).map((l) => l.replace(/\s+$/, ""));
+      const messages = [];
+      let afterTool = false;
+      let inUser = false;
+      let inThought = false;
+      let seenRole = false;
+      const pushOrAppendAssistant = (text) => {
+        const last = messages[messages.length - 1];
+        if (last && last.role === "assistant" && typeof last.content === "string") {
+          last.content = last.content ? `${last.content}
+${text}` : text;
+        } else {
+          messages.push(assistantMessage(text));
+        }
+      };
+      for (const line of lines) {
+        if (line.trim() === "") continue;
+        if (isChrome(line)) continue;
+        if (USER_RE.test(line)) {
+          inUser = true;
+          inThought = false;
+          afterTool = false;
+          seenRole = true;
+          continue;
+        }
+        if (TOOL_RE.test(line)) {
+          inUser = false;
+          inThought = false;
+          afterTool = true;
+          seenRole = true;
+          continue;
+        }
+        if (THOUGHT_RE.test(line)) {
+          inUser = false;
+          inThought = true;
+          seenRole = true;
+          continue;
+        }
+        if (!seenRole) continue;
+        if (inUser && isIndented(line)) continue;
+        if (inThought && isIndented(line) && !JSON_START_RE.test(line) && !afterTool) continue;
+        if (afterTool || inThought && JSON_START_RE.test(line)) {
+          const text = line.replace(/^\s+/, "");
+          if (text) {
+            pushOrAppendAssistant(text);
+            inThought = false;
+            inUser = false;
+          }
+        }
+      }
+      return messages.filter((m) => typeof m.content === "string" && m.content.trim().length > 0);
+    }
     var fs40 = __toESM2(require("fs"));
-    var import_node_crypto5 = require("crypto");
+    var import_node_crypto6 = require("crypto");
     init_provider_cli_shared();
     init_logger();
     init_logger();
@@ -122007,7 +122337,7 @@ ${marker}`,
         const bg = this.detectBackgroundTask();
         return {
           ...status,
-          messages: this.readClaudeScreenAssistantMessages(),
+          messages: this.readScreenAssistantMessages(),
           ...this.providerSessionId ? { providerSessionId: this.providerSessionId } : {},
           backgroundTaskSupport: bg.support ?? "unknown",
           ...bg.active ? { backgroundTaskActive: true, backgroundTaskCount: bg.count, backgroundTaskIds: bg.ids } : {}
@@ -122121,7 +122451,7 @@ ${marker}`,
         } catch {
         }
         const truncation = truncateToByteTailByLine(rawViewport, cap);
-        const hash2 = (0, import_node_crypto5.createHash)("sha256").update(rawViewport, "utf8").digest("hex").slice(0, 16);
+        const hash2 = (0, import_node_crypto6.createHash)("sha256").update(rawViewport, "utf8").digest("hex").slice(0, 16);
         return {
           text: truncation.text,
           cursor: { col: cursor.col, row: cursor.row },
@@ -122548,7 +122878,7 @@ ${marker}`,
           } catch {
           }
         } else {
-          messages = this.readClaudeScreenAssistantMessages();
+          messages = this.readScreenAssistantMessages();
         }
         return {
           cliType: this.cliType,
@@ -122761,6 +123091,29 @@ ${marker}`,
         const match = clean2.match(/(?:gpt-|o\d|codex-)[^\n·]*·[^\n·]*·\s*([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i);
         return match?.[1] || this.providerSessionId;
       }
+      /**
+       * PTY-scrape assistant bubbles for the live parse / spec-debug snapshot.
+       *
+       * Native-history remains the completion-path authority
+       * (`chatMessagesOwnedExternally`). This scrape is the fail-closed
+       * fallback the gate already consults via getScriptParsedStatus().messages
+       * when the on-disk transcript has no final standard assistant — which is
+       * the antigravity layout where the JSON report is on screen under
+       * `● Bash(...)` but never lands as a step_type-15 field-20 answer.
+       */
+      readScreenAssistantMessages() {
+        if (this.cliType === "claude-cli") return this.readClaudeScreenAssistantMessages();
+        if (this.cliType === "antigravity-cli") {
+          let screenText = "";
+          try {
+            screenText = this.driver.snapshot();
+          } catch {
+            return [];
+          }
+          return extractAntigravityScreenAssistantMessages(screenText);
+        }
+        return [];
+      }
       readClaudeScreenAssistantMessages() {
         if (this.cliType !== "claude-cli") return [];
         let screenText = "";
@@ -123171,7 +123524,7 @@ ${marker}`,
           } catch (e) {
           }
         } else {
-          messages = this.readClaudeScreenAssistantMessages();
+          messages = this.readScreenAssistantMessages();
         }
         const latestState = this.latestState;
         const latestModal = this.latestModal;
@@ -131370,7 +131723,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 && isIdleSessionState3(dispatchSessionState);
+              const sessionConfirmedReady = !!dispatchSessionState && isIdleSessionState2(dispatchSessionState);
               if (!sessionConfirmedReady) {
                 return {
                   success: false,
@@ -134821,7 +135174,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     }
     async function execQuiet(command, options = {}) {
       return new Promise((resolve32) => {
-        (0, import_child_process12.exec)(command, options, (error48, stdout) => {
+        (0, import_child_process12.exec)(command, { windowsHide: true, ...options }, (error48, stdout) => {
           if (error48) return resolve32("");
           resolve32(stdout.toString());
         });
@@ -135396,6 +135749,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     init_worktree_bootstrap_config();
     init_mesh_events();
     init_mesh_clone_grace();
+    init_mesh_events_utils();
     init_config();
     async function decideOssCloneSync(ossCtx, worktreeOssSha, sourceSha, rg) {
       if (!worktreeOssSha || !sourceSha || worktreeOssSha === sourceSha) return "noop";
@@ -136311,6 +136665,13 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
               if (cachedMesh) ctx.removeInlineMeshNode(meshId, cachedMesh, nodeId);
             }
           }
+          if (removed) {
+            try {
+              const { MeshRuntimeStore: MeshRuntimeStore2 } = await Promise.resolve().then(() => (init_mesh_runtime_store(), mesh_runtime_store_exports));
+              MeshRuntimeStore2.getInstance().deleteRemoteIdleSessionsForNode(meshId, nodeId);
+            } catch {
+            }
+          }
           if (worktreeCleanup && worktreeCleanup.success === true && worktreeCleanup.skipped !== true) {
             try {
               const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
@@ -136411,6 +136772,14 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             if (forwardedNodeId) noteRecentlyClonedNode(forwardedNodeId);
             return forwarded ?? { success: false, error: "no response from remote node" };
           }
+          const effectiveDaemonId = readMeshNodeDaemonId(sourceNode) || readNonEmptyString(ctx.deps.statusInstanceId) || void 0;
+          const effectiveMachineId = readMeshNodeMachineId(sourceNode) || (() => {
+            try {
+              return readNonEmptyString(loadConfig2().machineId);
+            } catch {
+              return "";
+            }
+          })() || void 0;
           const repoRoot = sourceNode.repoRoot || sourceNode.workspace;
           const worktreeBaseDir = typeof mesh.policy?.worktreeBaseDir === "string" && mesh.policy.worktreeBaseDir.trim() ? mesh.policy.worktreeBaseDir.trim() : void 0;
           const { createWorktree: createWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
@@ -136429,15 +136798,15 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           let node;
           const { migrateProviderRolesToSlots: migrateProviderRolesToSlots2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
           if (meshRecord.inline) {
-            const { randomUUID: randomUUID22 } = await import("crypto");
+            const { randomUUID: randomUUID23 } = await import("crypto");
             const clonedPolicy = { ...sourceNode.policy || {} };
             migrateProviderRolesToSlots2(clonedPolicy);
             node = {
-              id: `node_${randomUUID22().replace(/-/g, "")}`,
+              id: `node_${randomUUID23().replace(/-/g, "")}`,
               workspace: result.worktreePath,
               repoRoot: result.worktreePath,
-              daemonId: sourceNode.daemonId,
-              machineId: sourceNode.machineId ?? sourceNode.machine_id,
+              daemonId: effectiveDaemonId,
+              machineId: effectiveMachineId,
               userOverrides: { ...sourceNode.userOverrides || {} },
               policy: clonedPolicy,
               isLocalWorktree: true,
@@ -136451,8 +136820,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
                 id: node.id,
                 workspace: result.worktreePath,
                 repoRoot: result.worktreePath,
-                daemonId: sourceNode.daemonId,
-                machineId: sourceNode.machineId ?? sourceNode.machine_id,
+                daemonId: effectiveDaemonId,
+                machineId: effectiveMachineId,
                 userOverrides: { ...sourceNode.userOverrides || {} },
                 isLocalWorktree: true,
                 worktreeBranch: result.branch,
@@ -136468,8 +136837,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             node = addNode2(meshId, {
               workspace: result.worktreePath,
               repoRoot: result.worktreePath,
-              daemonId: sourceNode.daemonId,
-              machineId: sourceNode.machineId ?? sourceNode.machine_id,
+              daemonId: effectiveDaemonId,
+              machineId: effectiveMachineId,
               userOverrides: { ...sourceNode.userOverrides || {} },
               isLocalWorktree: true,
               worktreeBranch: result.branch,
@@ -141406,6 +141775,7 @@ ${ptyResult.output.slice(-2e3)}`);
     }
     init_snapshot3();
     init_runtime_defaults();
+    init_transcript_publisher();
     var DEFAULT_GIT_REFRESH_CONCURRENCY = 2;
     var DEFAULT_CHAT_TAIL_FLUSH_DEBOUNCE_MS = 700;
     var PUSH_TOPICS = ["machine.runtime", "session_host.diagnostics", "session.modal", "daemon.metadata"];
@@ -141759,6 +142129,7 @@ ${ptyResult.output.slice(-2e3)}`);
       markChatOutputActivity(sessionId) {
         const cfg = this.opts.chatTail;
         if (!sessionId || !(cfg?.isCliSession?.(sessionId) ?? false)) return;
+        markTranscriptSessionDirty(sessionId);
         this.chatOutputActiveAt.set(sessionId, this.now());
         if (this.chatOutputFlushTimer) return;
         if (cfg?.scheduleGate && !cfg.scheduleGate()) return;
@@ -142252,7 +142623,17 @@ ${ptyResult.output.slice(-2e3)}`);
         parityRan: seqscribe.parityRan === true,
         parityMissingInShadowBucket: count(seqscribe.parityMissingInShadowBucket),
         parityExtraInShadowBucket: count(seqscribe.parityExtraInShadowBucket),
-        parityFieldMismatchBucket: count(seqscribe.parityFieldMismatchBucket)
+        parityFieldMismatchBucket: count(seqscribe.parityFieldMismatchBucket),
+        // §8 unit 2. transcriptParityPersistentMismatchBucket stays LOCAL-ONLY,
+        // absent here — same asymmetry as parityPersistentMismatchBucket above.
+        transcriptPublish: seqscribe.transcriptPublish === true,
+        transcriptPublishedBucket: count(seqscribe.transcriptPublishedBucket),
+        transcriptPublishFailedBucket: count(seqscribe.transcriptPublishFailedBucket),
+        transcriptDedupedBucket: count(seqscribe.transcriptDedupedBucket),
+        transcriptOversizedBucket: count(seqscribe.transcriptOversizedBucket),
+        transcriptDroppedBucket: count(seqscribe.transcriptDroppedBucket),
+        transcriptParityRan: seqscribe.transcriptParityRan === true,
+        transcriptParityMismatchBucket: count(seqscribe.transcriptParityMismatchBucket)
       };
     }
     function buildCloudStatusReportPayload(sessions, p2p, timestamp2, seqscribe) {
@@ -146835,6 +147216,7 @@ async (params) => {
             cwd: providerDir,
             stdio: ["pipe", "pipe", "pipe"],
             shell: spawn7.shell ?? false,
+            windowsHide: true,
             env: { ...process.env, ...spawn7.env || {} }
           });
           ctx.autoImplProcess = child2;
@@ -147011,6 +147393,7 @@ async (params) => {
           child = spawnFn(isWin ? "cmd.exe" : "sh", [isWin ? "/c" : "-c", shellCmd], {
             cwd: providerDir,
             shell: false,
+            windowsHide: true,
             timeout: 9e5,
             stdio: ["pipe", "pipe", "pipe"],
             env: {
@@ -148163,6 +148546,7 @@ data: ${JSON.stringify(msg.data)}
         try {
           const child = spawnFn(spawn7.command, [...spawn7.args || []], {
             shell: spawn7.shell ?? false,
+            windowsHide: true,
             timeout: 5e3,
             stdio: ["pipe", "pipe", "pipe"]
           });
@@ -148678,6 +149062,7 @@ data: ${JSON.stringify(msg.data)}
           const args = [...spawn7.args || [], message];
           const child = spawnFn(spawn7.command, args, {
             shell: spawn7.shell ?? false,
+            windowsHide: true,
             timeout,
             stdio: ["pipe", "pipe", "pipe"],
             env: { ...process.env, ...spawn7.env || {} }
@@ -150057,6 +150442,7 @@ data: ${JSON.stringify(msg.data)}
       try {
         const { stdout } = await execAsync4(`"${ide.cliCommand}" --list-extensions`, {
           encoding: "utf-8",
+          windowsHide: true,
           timeout: 15e3
         });
         const installed = stdout.trim().split("\n").map((e) => e.trim().toLowerCase());
@@ -150234,6 +150620,7 @@ data: ${JSON.stringify(msg.data)}
     init_logger();
     init_runtime_defaults();
     init_config();
+    init_env_overrides();
     init_config_dir();
     init_contract();
     init_mesh_events();
@@ -151107,6 +151494,18 @@ data: ${JSON.stringify(msg.data)}
         parityMissingInShadowBucket: bucket(opts.parity?.missingInShadow ?? 0, BACKLOG_BUCKETS),
         parityExtraInShadowBucket: bucket(opts.parity?.extraInShadow ?? 0, BACKLOG_BUCKETS),
         parityFieldMismatchBucket: bucket(opts.parity?.fieldMismatch ?? 0, BACKLOG_BUCKETS),
+        transcriptPublish: opts.transcript?.active ?? false,
+        transcriptPublishedBucket: bucket(opts.transcript?.published ?? 0, BACKLOG_BUCKETS),
+        transcriptPublishFailedBucket: bucket(opts.transcript?.publishFailed ?? 0, BACKLOG_BUCKETS),
+        transcriptDedupedBucket: bucket(opts.transcript?.deduped ?? 0, BACKLOG_BUCKETS),
+        transcriptOversizedBucket: bucket(opts.transcript?.oversized ?? 0, BACKLOG_BUCKETS),
+        transcriptDroppedBucket: bucket(opts.transcript?.dropped ?? 0, BACKLOG_BUCKETS),
+        transcriptParityRan: (opts.transcriptParity?.runs ?? 0) > 0,
+        transcriptParityMismatchBucket: bucket(opts.transcriptParity?.mismatches ?? 0, BACKLOG_BUCKETS),
+        transcriptParityPersistentMismatchBucket: bucket(
+          opts.transcriptParity?.persistentMismatches ?? 0,
+          BACKLOG_BUCKETS
+        ),
         ...localDiagnostics
       };
     }
@@ -151532,6 +151931,15 @@ data: ${JSON.stringify(msg.data)}
       installProviderProcessShim();
       installGlobalInterceptor();
       loadMeshCoordinatorRegistry();
+      const envOverrideResult = applyDaemonEnvOverrides(
+        loadConfig2().envOverrides,
+        process.env,
+        (msg) => LOG2.warn("EnvOverrides", msg)
+      );
+      const appliedOverrideKeys = Object.keys(envOverrideResult.applied);
+      if (appliedOverrideKeys.length > 0) {
+        LOG2.info("EnvOverrides", `Applied ${appliedOverrideKeys.length} persisted env override(s) from config.json: ${appliedOverrideKeys.join(", ")}`);
+      }
       const upgradeFailureNotice = readUpgradeFailureNotice();
       if (upgradeFailureNotice) {
         const age = upgradeFailureNotice.ageLabel ? `${upgradeFailureNotice.ageLabel}, recorded ${upgradeFailureNotice.recordedAt}` : "recorded at an unknown time";