@adhdev/daemon-standalone 1.0.58-rc.41 → 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 ? "384bdc1ff5122cbff80c9a54e478fcc80827b0c8" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "384bdc1f" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.58-rc.41" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-29T12:46:51.807Z" : 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;
     }
@@ -39067,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)),
@@ -39848,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',
 });
 
@@ -78793,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}`;
     }
@@ -79179,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 {
       }
@@ -79336,6 +78979,869 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         AUTO_LAUNCH_LEDGER_DEDUP_MAX = 2e3;
       }
     });
+    function localCoordinatorDaemonId() {
+      return canonicalDaemonId(readNonEmptyString(loadConfig2().machineId));
+    }
+    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";
+    }
+    function sweepAutoLaunchOrphanSessions(components, meshId) {
+      let sessions;
+      try {
+        sessions = components.instanceManager?.getByCategory?.("cli") || [];
+      } catch {
+        return;
+      }
+      if (!sessions.length) return;
+      let queue;
+      try {
+        queue = getQueue(meshId);
+      } catch {
+        return;
+      }
+      const byId = new Map(queue.map((t) => [t.id, t]));
+      for (const inst of sessions) {
+        let state;
+        try {
+          state = inst.getState();
+        } catch {
+          continue;
+        }
+        const settings = state?.settings || {};
+        if (readNonEmptyString(settings.meshNodeFor) !== meshId) continue;
+        const originTaskId = readNonEmptyString(settings.autoLaunchedForQueueTaskId);
+        if (!originTaskId) continue;
+        const sessionId = readNonEmptyString(state?.instanceId);
+        if (!sessionId) continue;
+        if (!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);
+        const originGone = !originTask || originTask.status !== "pending" && originTask.status !== "assigned";
+        const dedupKey = `${meshId}::${sessionId}`;
+        if (!assignedElsewhere && !originGone) {
+          autoLaunchOrphanFirstSeenAtMs.delete(dedupKey);
+          continue;
+        }
+        const nowMs = Date.now();
+        const firstSeenAtMs = autoLaunchOrphanFirstSeenAtMs.get(dedupKey);
+        if (firstSeenAtMs === void 0) {
+          autoLaunchOrphanFirstSeenAtMs.set(dedupKey, nowMs);
+          if (autoLaunchOrphanFirstSeenAtMs.size > AUTO_LAUNCH_LEDGER_DEDUP_MAX) {
+            const oldest = autoLaunchOrphanFirstSeenAtMs.keys().next().value;
+            if (oldest !== void 0) autoLaunchOrphanFirstSeenAtMs.delete(oldest);
+          }
+          continue;
+        }
+        if (nowMs - firstSeenAtMs < AUTO_LAUNCH_ORPHAN_GRACE_MS) continue;
+        if (autoLaunchOrphanNotified.has(dedupKey)) continue;
+        autoLaunchOrphanNotified.add(dedupKey);
+        if (autoLaunchOrphanNotified.size > AUTO_LAUNCH_LEDGER_DEDUP_MAX) {
+          const oldest = autoLaunchOrphanNotified.values().next().value;
+          if (oldest !== void 0) autoLaunchOrphanNotified.delete(oldest);
+        }
+        const nodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
+        const detail = assignedElsewhere ? `task ${originTaskId} is assigned to a different session (${readNonEmptyString(originTask.assignedSessionId)})` : `task ${originTaskId} is no longer active (${originTask ? originTask.status : "absent from the queue"})`;
+        recordAutoLaunchEvent(meshId, {
+          phase: "skipped",
+          taskId: originTaskId,
+          reason: "auto_launch_orphan_session_detected",
+          nodeId,
+          sessionId
+        });
+        LOG2.warn("MeshQueue", `AUTOLAUNCH-ORPHAN-SWEEP: session ${sessionId}${nodeId ? ` on node ${nodeId}` : ""} (mesh ${meshId}) was auto-launched for task ${originTaskId} but ${detail}; it is idle with no work and will not self-recover.`);
+        try {
+          queuePendingMeshCoordinatorEvent({
+            event: "mesh:dispatch_blocked",
+            meshId,
+            nodeLabel: nodeId || meshId,
+            ...nodeId ? { nodeId } : {},
+            metadataEvent: {
+              source: "mesh_auto_launch_orphan_session",
+              taskId: originTaskId,
+              sessionId,
+              reason: "auto_launch_orphan_session_detected"
+            },
+            coordinatorMessage: `[System] Mesh session ${sessionId}${nodeId ? ` on node ${nodeId}` : ""} was auto-launched for task ${originTaskId}, but ${detail}. The session is idle with no work assigned and nothing reclaims it on its own. Reuse it for other queued work or stop it.`,
+            queuedAt: Date.now(),
+            ...readNonEmptyString(originTask?.sourceCoordinatorSessionId) ? { targetCoordinatorSessionId: readNonEmptyString(originTask.sourceCoordinatorSessionId) } : {},
+            ...localCoordinatorDaemonId() ? { targetCoordinatorDaemonId: localCoordinatorDaemonId() } : {}
+          });
+        } catch (e) {
+          LOG2.warn("MeshQueue", `AUTOLAUNCH-ORPHAN-SWEEP: failed to queue the coordinator notification for session ${sessionId}: ${e?.message || e}`);
+        }
+      }
+    }
+    function autoLaunchWriteWouldClobberWinner(meshId, taskId, args, awaitClaimWindowMs3) {
+      if (args.status === "completed" && readNonEmptyString(args.sessionId)) return false;
+      let existing;
+      try {
+        existing = getQueue(meshId).find((t) => t.id === taskId)?.autoLaunch;
+      } catch {
+        return false;
+      }
+      const heldSessionId = existing ? readNonEmptyString(existing.sessionId) : "";
+      if (!existing || existing.status !== "completed" || !heldSessionId) return false;
+      const heldAtMs = Date.parse(existing.updatedAt);
+      if (!Number.isFinite(heldAtMs) || Date.now() - heldAtMs >= awaitClaimWindowMs3) return false;
+      if (sessionIdsEquivalent(readNonEmptyString(args.sessionId), heldSessionId)) return false;
+      LOG2.info("MeshQueue", `AUTOLAUNCH-WINNER-CLOBBER: suppressed a '${args.status}' autoLaunch write for task ${taskId} (mesh ${meshId}) that would have overwritten the in-window launch record for session ${heldSessionId}; the field keeps pointing at the actually-launched session.`);
+      return true;
+    }
+    function awaitClaimWindowMs(cycles) {
+      return AUTO_LAUNCH_AWAIT_CLAIM_MS * Math.pow(2, Math.min(cycles, AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES));
+    }
+    function remoteSessionAppearsLive(meshId, sessionId) {
+      if (!sessionId) return false;
+      try {
+        return MeshRuntimeStore.getInstance().getRemoteIdleSessions(meshId).some((s2) => sessionIdsEquivalent(s2.sessionId, sessionId));
+      } catch {
+        return false;
+      }
+    }
+    function inWindowAutoLaunchSessionIdsForNode(meshId, nodeId) {
+      const nowMs = Date.now();
+      const out = [];
+      for (const task of getQueue(meshId, { status: ["pending"] })) {
+        const al = task.autoLaunch;
+        const sid = al ? readNonEmptyString(al.sessionId) : "";
+        if (!al || al.status !== "started" && al.status !== "completed" || !sid) continue;
+        if (!daemonIdsEquivalent(al.nodeId, nodeId)) continue;
+        const launchedAtMs = Date.parse(al.updatedAt);
+        const inBaseWindow = Number.isFinite(launchedAtMs) && nowMs - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS;
+        const inBackoff = autoLaunchAwaitClaimBackoff.has(`${meshId}::${task.id}`);
+        if (inBaseWindow || inBackoff) out.push(sid);
+      }
+      return out;
+    }
+    function driveExpiredAwaitClaim(components, meshId, task, ctx, assignQueueTask) {
+      const { sessionId, nodeId, providerType } = ctx;
+      const backoffKey = `${meshId}::${task.id}`;
+      const nowMs = Date.now();
+      const state = autoLaunchAwaitClaimBackoff.get(backoffKey) || { cycles: 0, nextAttemptAtMs: 0 };
+      if (state.nextAttemptAtMs && nowMs < state.nextAttemptAtMs) return "backoff";
+      const atCap = state.cycles >= AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES;
+      const live = remoteSessionAppearsLive(meshId, sessionId);
+      if ((live || atCap) && nodeId && providerType) {
+        try {
+          MeshRuntimeStore.getInstance().setRemoteIdleSession(meshId, nodeId, sessionId, providerType, nowMs + AUTO_LAUNCH_REMOTE_IDLE_TTL_MS);
+        } catch {
+        }
+        const assigned = assignQueueTask(components, meshId, nodeId, sessionId, providerType);
+        if (assigned) {
+          autoLaunchAwaitClaimBackoff.delete(backoffKey);
+          const isFallback = atCap && !live;
+          recordAutoLaunchEvent(meshId, {
+            phase: "completed",
+            taskId: task.id,
+            reason: isFallback ? "await_claim_direct_dispatch_fallback" : "await_claim_redriven",
+            nodeId,
+            sessionId
+          });
+          LOG2.info("MeshQueue", `Auto-launch await-claim ${isFallback ? "direct-dispatch fallback" : "re-drive"} claimed task ${task.id} into existing session ${sessionId} on node ${nodeId} (mesh ${meshId})`);
+          return isFallback ? "fallback" : "claimed";
+        }
+        if (atCap) {
+          autoLaunchAwaitClaimBackoff.delete(backoffKey);
+          return "respawn";
+        }
+      }
+      const cycles = Math.min(state.cycles + 1, AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES);
+      autoLaunchAwaitClaimBackoff.set(backoffKey, { cycles, nextAttemptAtMs: nowMs + awaitClaimWindowMs(cycles) });
+      recordAutoLaunchEvent(meshId, { phase: "skipped", taskId: task.id, reason: "awaiting_launched_session_claim_backoff", nodeId, sessionId });
+      return "backoff";
+    }
+    var AUTO_LAUNCH_AWAIT_CLAIM_MS;
+    var AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES;
+    var AUTO_LAUNCH_REMOTE_IDLE_TTL_MS;
+    var TERMINAL_SESSION_STATUSES;
+    var autoLaunchOrphanNotified;
+    var autoLaunchOrphanFirstSeenAtMs;
+    var AUTO_LAUNCH_ORPHAN_GRACE_MS;
+    var autoLaunchAwaitClaimBackoff;
+    var init_mesh_autolaunch_integrity = __esm2({
+      "src/mesh/mesh-autolaunch-integrity.ts"() {
+        "use strict";
+        init_config();
+        init_logger();
+        init_dist();
+        init_mesh_work_queue();
+        init_mesh_events_utils();
+        init_mesh_events_pending();
+        init_mesh_queue_observability();
+        init_mesh_scheduling_fitness();
+        init_mesh_runtime_store();
+        AUTO_LAUNCH_AWAIT_CLAIM_MS = 9e4;
+        AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES = 2;
+        AUTO_LAUNCH_REMOTE_IDLE_TTL_MS = 5 * 60 * 1e3;
+        TERMINAL_SESSION_STATUSES = ["stopped", "failed", "terminated", "exited", "closed"];
+        autoLaunchOrphanNotified = /* @__PURE__ */ new Set();
+        autoLaunchOrphanFirstSeenAtMs = /* @__PURE__ */ new Map();
+        AUTO_LAUNCH_ORPHAN_GRACE_MS = 3e4;
+        autoLaunchAwaitClaimBackoff = /* @__PURE__ */ new Map();
+      }
+    });
+    function classifiedDifficultiesForSlot(slot) {
+      const highest = slot.difficulty?.reduce((rank, value) => {
+        const candidate = CLASSIFIED_DIFFICULTIES.indexOf(value);
+        return Math.max(rank, candidate);
+      }, -1) ?? -1;
+      return highest < 0 ? [] : CLASSIFIED_DIFFICULTIES.slice(0, highest + 1);
+    }
+    function allowedClassifiedDifficultiesForSession(node, slots, providerType, model) {
+      if (normalizeNodeCapabilitySlots(node?.policy?.slots).length === 0) return void 0;
+      const providerSlots = slots.filter((slot) => slot.provider?.trim() === providerType);
+      const possibleSlots = model ? providerSlots.filter((slot) => isModelAllowedBySlot(model, slot)) : providerSlots;
+      if (possibleSlots.length === 0) return [];
+      const supported = possibleSlots.map((slot) => new Set(classifiedDifficultiesForSlot(slot)));
+      return CLASSIFIED_DIFFICULTIES.filter((difficulty) => model ? supported.some((grades) => grades.has(difficulty)) : supported.every((grades) => grades.has(difficulty)));
+    }
+    function taskMeetsSessionDifficultyFloor(task, allowed) {
+      if (!allowed || !isMeshTaskDifficulty(task.difficulty) || task.difficulty === "freeform") return true;
+      return allowed.includes(task.difficulty);
+    }
+    function readSessionModel(state) {
+      const controlModel = typeof state?.controlValues?.model === "string" ? state.controlValues.model.trim() : "";
+      if (controlModel) return controlModel;
+      const modelItem = Array.isArray(state?.summaryMetadata?.items) ? state.summaryMetadata.items.find((item) => item?.id === "model") : void 0;
+      const summaryModel = typeof modelItem?.shortValue === "string" && modelItem.shortValue.trim() ? modelItem.shortValue.trim() : typeof modelItem?.value === "string" ? modelItem.value.trim() : "";
+      return summaryModel || void 0;
+    }
+    function isDifficultyFloorWaitReason(reason) {
+      return typeof reason === "string" && (reason.startsWith(TASK_DIFFICULTY_FLOOR_REASON_PREFIX) || reason.startsWith(ALL_PROVIDERS_QUOTA_GATED_SKIP_REASON));
+    }
+    function handleDifficultyFloorSkip(args) {
+      let previousTask;
+      try {
+        previousTask = getQueue(args.meshId).find((task2) => task2.id === args.taskId);
+      } catch {
+      }
+      if (previousTask?.autoLaunch?.reason?.startsWith(TASK_DIFFICULTY_FLOOR_REPORTED_PREFIX)) return;
+      const continuing = previousTask?.autoLaunch?.status === "skipped" && isDifficultyFloorWaitReason(previousTask.autoLaunch.reason);
+      if (!continuing) {
+        recordTaskAutoLaunch(args.meshId, args.taskId, {
+          status: "skipped",
+          reason: args.reason,
+          nodeId: args.nodeId
+        });
+      }
+      const waitStartedAt = Date.parse(previousTask?.autoLaunch?.updatedAt || (/* @__PURE__ */ new Date()).toISOString());
+      const waitedMs = Number.isFinite(waitStartedAt) ? Date.now() - waitStartedAt : 0;
+      const reportKey = `${args.meshId}:${args.taskId}`;
+      if (waitedMs < DIFFICULTY_FLOOR_REPORT_AFTER_MS || difficultyFloorTimeoutReported.has(reportKey)) return;
+      const task = previousTask ?? getQueue(args.meshId).find((candidate) => candidate.id === args.taskId);
+      const difficulty = task?.difficulty || args.reason.split(":")[1] || "classified";
+      const coordinatorMessage = `[System] Queued task ${args.taskId} has waited ${Math.round(waitedMs / 6e4)} minutes because no available slot meets its ${difficulty} difficulty floor. It remains pending and was not downgraded. Ask the user whether to grant an explicit task-scoped downgrade; do not change a mesh-wide policy.`;
+      const queued = queuePendingMeshCoordinatorEvent({
+        event: "mesh:dispatch_blocked",
+        meshId: args.meshId,
+        nodeLabel: args.nodeId || args.meshId,
+        ...args.nodeId ? { nodeId: args.nodeId } : {},
+        metadataEvent: {
+          source: "mesh_queue_difficulty_floor_timeout",
+          taskId: args.taskId,
+          reason: "task_difficulty_floor_timeout",
+          difficulty,
+          waitedMs,
+          coordinatorMessage
+        },
+        coordinatorMessage,
+        queuedAt: Date.now(),
+        ...args.coordinatorDaemonId ? { targetCoordinatorDaemonId: args.coordinatorDaemonId } : {},
+        ...task?.sourceCoordinatorSessionId ? { targetCoordinatorSessionId: task.sourceCoordinatorSessionId } : {}
+      });
+      if (queued) {
+        if (difficultyFloorTimeoutReported.size >= DIFFICULTY_FLOOR_REPORT_DEDUP_MAX) {
+          const oldest = difficultyFloorTimeoutReported.values().next().value;
+          if (oldest) difficultyFloorTimeoutReported.delete(oldest);
+        }
+        difficultyFloorTimeoutReported.add(reportKey);
+        recordTaskAutoLaunch(args.meshId, args.taskId, {
+          status: "skipped",
+          reason: `${TASK_DIFFICULTY_FLOOR_REPORTED_PREFIX}${difficulty}`,
+          nodeId: args.nodeId
+        });
+      }
+    }
+    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_dist();
+        CLONE_BOOTSTRAP_GRACE_MS = 10 * 60 * 1e3;
+        recentlyClonedNodeExpiry = /* @__PURE__ */ new Map();
+        MAX_TRACKED_CLONED_NODES = 512;
+      }
+    });
     function isActionableSkipReason(reason) {
       if (!reason) return false;
       return ACTIONABLE_SKIP_REASON_PREFIXES.some((prefix) => reason === prefix || reason.startsWith(prefix));
@@ -79627,454 +80133,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         targetPinGeneratingCreditMs = /* @__PURE__ */ new Map();
       }
     });
-    function localCoordinatorDaemonId() {
-      return canonicalDaemonId(readNonEmptyString(loadConfig2().machineId));
-    }
-    function isIdleSessionState2(state) {
-      const status = readNonEmptyString(state?.status).toLowerCase();
-      if (TERMINAL_SESSION_STATUSES.includes(status)) return false;
-      return status === "idle" || state?.activeChat?.status === "waiting_input";
-    }
-    function sweepAutoLaunchOrphanSessions(components, meshId) {
-      let sessions;
-      try {
-        sessions = components.instanceManager?.getByCategory?.("cli") || [];
-      } catch {
-        return;
-      }
-      if (!sessions.length) return;
-      let queue;
-      try {
-        queue = getQueue(meshId);
-      } catch {
-        return;
-      }
-      const byId = new Map(queue.map((t) => [t.id, t]));
-      for (const inst of sessions) {
-        let state;
-        try {
-          state = inst.getState();
-        } catch {
-          continue;
-        }
-        const settings = state?.settings || {};
-        if (readNonEmptyString(settings.meshNodeFor) !== meshId) continue;
-        const originTaskId = readNonEmptyString(settings.autoLaunchedForQueueTaskId);
-        if (!originTaskId) continue;
-        const sessionId = readNonEmptyString(state?.instanceId);
-        if (!sessionId) continue;
-        if (!isIdleSessionState2(state)) continue;
-        if (sessionHasActiveAssignment(meshId, sessionId)) continue;
-        const originTask = byId.get(originTaskId);
-        const assignedElsewhere = !!originTask && originTask.status === "assigned" && !!readNonEmptyString(originTask.assignedSessionId) && !sessionIdsEquivalent(readNonEmptyString(originTask.assignedSessionId), sessionId);
-        const originGone = !originTask || originTask.status !== "pending" && originTask.status !== "assigned";
-        const dedupKey = `${meshId}::${sessionId}`;
-        if (!assignedElsewhere && !originGone) {
-          autoLaunchOrphanFirstSeenAtMs.delete(dedupKey);
-          continue;
-        }
-        const nowMs = Date.now();
-        const firstSeenAtMs = autoLaunchOrphanFirstSeenAtMs.get(dedupKey);
-        if (firstSeenAtMs === void 0) {
-          autoLaunchOrphanFirstSeenAtMs.set(dedupKey, nowMs);
-          if (autoLaunchOrphanFirstSeenAtMs.size > AUTO_LAUNCH_LEDGER_DEDUP_MAX) {
-            const oldest = autoLaunchOrphanFirstSeenAtMs.keys().next().value;
-            if (oldest !== void 0) autoLaunchOrphanFirstSeenAtMs.delete(oldest);
-          }
-          continue;
-        }
-        if (nowMs - firstSeenAtMs < AUTO_LAUNCH_ORPHAN_GRACE_MS) continue;
-        if (autoLaunchOrphanNotified.has(dedupKey)) continue;
-        autoLaunchOrphanNotified.add(dedupKey);
-        if (autoLaunchOrphanNotified.size > AUTO_LAUNCH_LEDGER_DEDUP_MAX) {
-          const oldest = autoLaunchOrphanNotified.values().next().value;
-          if (oldest !== void 0) autoLaunchOrphanNotified.delete(oldest);
-        }
-        const nodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
-        const detail = assignedElsewhere ? `task ${originTaskId} is assigned to a different session (${readNonEmptyString(originTask.assignedSessionId)})` : `task ${originTaskId} is no longer active (${originTask ? originTask.status : "absent from the queue"})`;
-        recordAutoLaunchEvent(meshId, {
-          phase: "skipped",
-          taskId: originTaskId,
-          reason: "auto_launch_orphan_session_detected",
-          nodeId,
-          sessionId
-        });
-        LOG2.warn("MeshQueue", `AUTOLAUNCH-ORPHAN-SWEEP: session ${sessionId}${nodeId ? ` on node ${nodeId}` : ""} (mesh ${meshId}) was auto-launched for task ${originTaskId} but ${detail}; it is idle with no work and will not self-recover.`);
-        try {
-          queuePendingMeshCoordinatorEvent({
-            event: "mesh:dispatch_blocked",
-            meshId,
-            nodeLabel: nodeId || meshId,
-            ...nodeId ? { nodeId } : {},
-            metadataEvent: {
-              source: "mesh_auto_launch_orphan_session",
-              taskId: originTaskId,
-              sessionId,
-              reason: "auto_launch_orphan_session_detected"
-            },
-            coordinatorMessage: `[System] Mesh session ${sessionId}${nodeId ? ` on node ${nodeId}` : ""} was auto-launched for task ${originTaskId}, but ${detail}. The session is idle with no work assigned and nothing reclaims it on its own. Reuse it for other queued work or stop it.`,
-            queuedAt: Date.now(),
-            ...readNonEmptyString(originTask?.sourceCoordinatorSessionId) ? { targetCoordinatorSessionId: readNonEmptyString(originTask.sourceCoordinatorSessionId) } : {},
-            ...localCoordinatorDaemonId() ? { targetCoordinatorDaemonId: localCoordinatorDaemonId() } : {}
-          });
-        } catch (e) {
-          LOG2.warn("MeshQueue", `AUTOLAUNCH-ORPHAN-SWEEP: failed to queue the coordinator notification for session ${sessionId}: ${e?.message || e}`);
-        }
-      }
-    }
-    function autoLaunchWriteWouldClobberWinner(meshId, taskId, args, awaitClaimWindowMs3) {
-      if (args.status === "completed" && readNonEmptyString(args.sessionId)) return false;
-      let existing;
-      try {
-        existing = getQueue(meshId).find((t) => t.id === taskId)?.autoLaunch;
-      } catch {
-        return false;
-      }
-      const heldSessionId = existing ? readNonEmptyString(existing.sessionId) : "";
-      if (!existing || existing.status !== "completed" || !heldSessionId) return false;
-      const heldAtMs = Date.parse(existing.updatedAt);
-      if (!Number.isFinite(heldAtMs) || Date.now() - heldAtMs >= awaitClaimWindowMs3) return false;
-      if (sessionIdsEquivalent(readNonEmptyString(args.sessionId), heldSessionId)) return false;
-      LOG2.info("MeshQueue", `AUTOLAUNCH-WINNER-CLOBBER: suppressed a '${args.status}' autoLaunch write for task ${taskId} (mesh ${meshId}) that would have overwritten the in-window launch record for session ${heldSessionId}; the field keeps pointing at the actually-launched session.`);
-      return true;
-    }
-    function awaitClaimWindowMs(cycles) {
-      return AUTO_LAUNCH_AWAIT_CLAIM_MS * Math.pow(2, Math.min(cycles, AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES));
-    }
-    function remoteSessionAppearsLive(meshId, sessionId) {
-      if (!sessionId) return false;
-      try {
-        return MeshRuntimeStore.getInstance().getRemoteIdleSessions(meshId).some((s2) => sessionIdsEquivalent(s2.sessionId, sessionId));
-      } catch {
-        return false;
-      }
-    }
-    function inWindowAutoLaunchSessionIdsForNode(meshId, nodeId) {
-      const nowMs = Date.now();
-      const out = [];
-      for (const task of getQueue(meshId, { status: ["pending"] })) {
-        const al = task.autoLaunch;
-        const sid = al ? readNonEmptyString(al.sessionId) : "";
-        if (!al || al.status !== "started" && al.status !== "completed" || !sid) continue;
-        if (!daemonIdsEquivalent(al.nodeId, nodeId)) continue;
-        const launchedAtMs = Date.parse(al.updatedAt);
-        const inBaseWindow = Number.isFinite(launchedAtMs) && nowMs - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS;
-        const inBackoff = autoLaunchAwaitClaimBackoff.has(`${meshId}::${task.id}`);
-        if (inBaseWindow || inBackoff) out.push(sid);
-      }
-      return out;
-    }
-    function driveExpiredAwaitClaim(components, meshId, task, ctx, assignQueueTask) {
-      const { sessionId, nodeId, providerType } = ctx;
-      const backoffKey = `${meshId}::${task.id}`;
-      const nowMs = Date.now();
-      const state = autoLaunchAwaitClaimBackoff.get(backoffKey) || { cycles: 0, nextAttemptAtMs: 0 };
-      if (state.nextAttemptAtMs && nowMs < state.nextAttemptAtMs) return "backoff";
-      const atCap = state.cycles >= AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES;
-      const live = remoteSessionAppearsLive(meshId, sessionId);
-      if ((live || atCap) && nodeId && providerType) {
-        try {
-          MeshRuntimeStore.getInstance().setRemoteIdleSession(meshId, nodeId, sessionId, providerType, nowMs + AUTO_LAUNCH_REMOTE_IDLE_TTL_MS);
-        } catch {
-        }
-        const assigned = assignQueueTask(components, meshId, nodeId, sessionId, providerType);
-        if (assigned) {
-          autoLaunchAwaitClaimBackoff.delete(backoffKey);
-          const isFallback = atCap && !live;
-          recordAutoLaunchEvent(meshId, {
-            phase: "completed",
-            taskId: task.id,
-            reason: isFallback ? "await_claim_direct_dispatch_fallback" : "await_claim_redriven",
-            nodeId,
-            sessionId
-          });
-          LOG2.info("MeshQueue", `Auto-launch await-claim ${isFallback ? "direct-dispatch fallback" : "re-drive"} claimed task ${task.id} into existing session ${sessionId} on node ${nodeId} (mesh ${meshId})`);
-          return isFallback ? "fallback" : "claimed";
-        }
-        if (atCap) {
-          autoLaunchAwaitClaimBackoff.delete(backoffKey);
-          return "respawn";
-        }
-      }
-      const cycles = Math.min(state.cycles + 1, AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES);
-      autoLaunchAwaitClaimBackoff.set(backoffKey, { cycles, nextAttemptAtMs: nowMs + awaitClaimWindowMs(cycles) });
-      recordAutoLaunchEvent(meshId, { phase: "skipped", taskId: task.id, reason: "awaiting_launched_session_claim_backoff", nodeId, sessionId });
-      return "backoff";
-    }
-    var AUTO_LAUNCH_AWAIT_CLAIM_MS;
-    var AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES;
-    var AUTO_LAUNCH_REMOTE_IDLE_TTL_MS;
-    var TERMINAL_SESSION_STATUSES;
-    var autoLaunchOrphanNotified;
-    var autoLaunchOrphanFirstSeenAtMs;
-    var AUTO_LAUNCH_ORPHAN_GRACE_MS;
-    var autoLaunchAwaitClaimBackoff;
-    var init_mesh_autolaunch_integrity = __esm2({
-      "src/mesh/mesh-autolaunch-integrity.ts"() {
-        "use strict";
-        init_config();
-        init_logger();
-        init_dist();
-        init_mesh_work_queue();
-        init_mesh_events_utils();
-        init_mesh_events_pending();
-        init_mesh_queue_observability();
-        init_mesh_scheduling_fitness();
-        init_mesh_runtime_store();
-        AUTO_LAUNCH_AWAIT_CLAIM_MS = 9e4;
-        AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES = 2;
-        AUTO_LAUNCH_REMOTE_IDLE_TTL_MS = 5 * 60 * 1e3;
-        TERMINAL_SESSION_STATUSES = ["stopped", "failed", "terminated", "exited", "closed"];
-        autoLaunchOrphanNotified = /* @__PURE__ */ new Set();
-        autoLaunchOrphanFirstSeenAtMs = /* @__PURE__ */ new Map();
-        AUTO_LAUNCH_ORPHAN_GRACE_MS = 3e4;
-        autoLaunchAwaitClaimBackoff = /* @__PURE__ */ new Map();
-      }
-    });
-    function classifiedDifficultiesForSlot(slot) {
-      const highest = slot.difficulty?.reduce((rank, value) => {
-        const candidate = CLASSIFIED_DIFFICULTIES.indexOf(value);
-        return Math.max(rank, candidate);
-      }, -1) ?? -1;
-      return highest < 0 ? [] : CLASSIFIED_DIFFICULTIES.slice(0, highest + 1);
-    }
-    function allowedClassifiedDifficultiesForSession(node, slots, providerType, model) {
-      if (normalizeNodeCapabilitySlots(node?.policy?.slots).length === 0) return void 0;
-      const providerSlots = slots.filter((slot) => slot.provider?.trim() === providerType);
-      const possibleSlots = model ? providerSlots.filter((slot) => isModelAllowedBySlot(model, slot)) : providerSlots;
-      if (possibleSlots.length === 0) return [];
-      const supported = possibleSlots.map((slot) => new Set(classifiedDifficultiesForSlot(slot)));
-      return CLASSIFIED_DIFFICULTIES.filter((difficulty) => model ? supported.some((grades) => grades.has(difficulty)) : supported.every((grades) => grades.has(difficulty)));
-    }
-    function taskMeetsSessionDifficultyFloor(task, allowed) {
-      if (!allowed || !isMeshTaskDifficulty(task.difficulty) || task.difficulty === "freeform") return true;
-      return allowed.includes(task.difficulty);
-    }
-    function readSessionModel(state) {
-      const controlModel = typeof state?.controlValues?.model === "string" ? state.controlValues.model.trim() : "";
-      if (controlModel) return controlModel;
-      const modelItem = Array.isArray(state?.summaryMetadata?.items) ? state.summaryMetadata.items.find((item) => item?.id === "model") : void 0;
-      const summaryModel = typeof modelItem?.shortValue === "string" && modelItem.shortValue.trim() ? modelItem.shortValue.trim() : typeof modelItem?.value === "string" ? modelItem.value.trim() : "";
-      return summaryModel || void 0;
-    }
-    function isDifficultyFloorWaitReason(reason) {
-      return typeof reason === "string" && (reason.startsWith(TASK_DIFFICULTY_FLOOR_REASON_PREFIX) || reason.startsWith(ALL_PROVIDERS_QUOTA_GATED_SKIP_REASON));
-    }
-    function handleDifficultyFloorSkip(args) {
-      let previousTask;
-      try {
-        previousTask = getQueue(args.meshId).find((task2) => task2.id === args.taskId);
-      } catch {
-      }
-      if (previousTask?.autoLaunch?.reason?.startsWith(TASK_DIFFICULTY_FLOOR_REPORTED_PREFIX)) return;
-      const continuing = previousTask?.autoLaunch?.status === "skipped" && isDifficultyFloorWaitReason(previousTask.autoLaunch.reason);
-      if (!continuing) {
-        recordTaskAutoLaunch(args.meshId, args.taskId, {
-          status: "skipped",
-          reason: args.reason,
-          nodeId: args.nodeId
-        });
-      }
-      const waitStartedAt = Date.parse(previousTask?.autoLaunch?.updatedAt || (/* @__PURE__ */ new Date()).toISOString());
-      const waitedMs = Number.isFinite(waitStartedAt) ? Date.now() - waitStartedAt : 0;
-      const reportKey = `${args.meshId}:${args.taskId}`;
-      if (waitedMs < DIFFICULTY_FLOOR_REPORT_AFTER_MS || difficultyFloorTimeoutReported.has(reportKey)) return;
-      const task = previousTask ?? getQueue(args.meshId).find((candidate) => candidate.id === args.taskId);
-      const difficulty = task?.difficulty || args.reason.split(":")[1] || "classified";
-      const coordinatorMessage = `[System] Queued task ${args.taskId} has waited ${Math.round(waitedMs / 6e4)} minutes because no available slot meets its ${difficulty} difficulty floor. It remains pending and was not downgraded. Ask the user whether to grant an explicit task-scoped downgrade; do not change a mesh-wide policy.`;
-      const queued = queuePendingMeshCoordinatorEvent({
-        event: "mesh:dispatch_blocked",
-        meshId: args.meshId,
-        nodeLabel: args.nodeId || args.meshId,
-        ...args.nodeId ? { nodeId: args.nodeId } : {},
-        metadataEvent: {
-          source: "mesh_queue_difficulty_floor_timeout",
-          taskId: args.taskId,
-          reason: "task_difficulty_floor_timeout",
-          difficulty,
-          waitedMs,
-          coordinatorMessage
-        },
-        coordinatorMessage,
-        queuedAt: Date.now(),
-        ...args.coordinatorDaemonId ? { targetCoordinatorDaemonId: args.coordinatorDaemonId } : {},
-        ...task?.sourceCoordinatorSessionId ? { targetCoordinatorSessionId: task.sourceCoordinatorSessionId } : {}
-      });
-      if (queued) {
-        if (difficultyFloorTimeoutReported.size >= DIFFICULTY_FLOOR_REPORT_DEDUP_MAX) {
-          const oldest = difficultyFloorTimeoutReported.values().next().value;
-          if (oldest) difficultyFloorTimeoutReported.delete(oldest);
-        }
-        difficultyFloorTimeoutReported.add(reportKey);
-        recordTaskAutoLaunch(args.meshId, args.taskId, {
-          status: "skipped",
-          reason: `${TASK_DIFFICULTY_FLOOR_REPORTED_PREFIX}${difficulty}`,
-          nodeId: args.nodeId
-        });
-      }
-    }
-    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 isIdleSessionState3(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) && isIdleSessionState3(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 liveSessionsForNode(components, meshId, nodeId) {
       try {
         const instances = components.instanceManager?.getByCategory?.("cli") || [];
@@ -81202,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") {
@@ -81213,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);
@@ -81755,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})`);
@@ -82075,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 });
@@ -82133,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,
@@ -82171,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);
@@ -82251,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}`);
           }
@@ -82292,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();
@@ -96335,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 || {} },
@@ -96380,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 || {} },
@@ -121734,6 +121788,100 @@ ${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_crypto6 = require("crypto");
     init_provider_cli_shared();
@@ -122189,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 } : {}
@@ -122730,7 +122878,7 @@ ${marker}`,
           } catch {
           }
         } else {
-          messages = this.readClaudeScreenAssistantMessages();
+          messages = this.readScreenAssistantMessages();
         }
         return {
           cliType: this.cliType,
@@ -122943,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 = "";
@@ -123353,7 +123524,7 @@ ${marker}`,
           } catch (e) {
           }
         } else {
-          messages = this.readClaudeScreenAssistantMessages();
+          messages = this.readScreenAssistantMessages();
         }
         const latestState = this.latestState;
         const latestModal = this.latestModal;
@@ -131552,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,
@@ -135003,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());
         });
@@ -147045,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;
@@ -147221,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: {
@@ -148373,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"]
           });
@@ -148888,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 || {} }
@@ -150267,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());