@adhdev/daemon-core 0.9.82-rc.310 → 0.9.82-rc.311

package/dist/index.mjs

@@ -26,6 +26,18 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/repo-mesh-types.ts
+function normalizeMeshSchedulingStrategy(value) {
+  if (typeof value !== "string") return DEFAULT_MESH_SCHEDULING_STRATEGY;
+  const trimmed = value.trim();
+  return MESH_SCHEDULING_STRATEGIES.includes(trimmed) ? trimmed : DEFAULT_MESH_SCHEDULING_STRATEGY;
+}
+function resolveNodeSchedulingPriority(nodePolicy) {
+  const raw = Number(nodePolicy?.schedulingPriority);
+  return Number.isFinite(raw) ? raw : 0;
+}
+function resolveAutoConvergeCodeChange(policy) {
+  return policy?.autoConvergeCodeChange === true;
+}
 function resolveDelegatedWorkerAutoApprove(meshPolicy, nodePolicy) {
   if (typeof nodePolicy?.delegatedWorkerAutoApprove === "boolean") {
     return nodePolicy.delegatedWorkerAutoApprove;
@@ -53,10 +65,19 @@ function resolveProviderMaxParallel(nodePolicy, providerType) {
   if (!Number.isFinite(raw) || raw < 0) return void 0;
   return Math.floor(raw);
 }
-var DEFAULT_MESH_POLICY;
+var MESH_SCHEDULING_STRATEGIES, DEFAULT_MESH_SCHEDULING_STRATEGY, MESH_CONVERGE_REFINE_TAG, MESH_CONVERGE_FAST_FORWARD_TAG, DEFAULT_MESH_POLICY;
 var init_repo_mesh_types = __esm({
   "src/repo-mesh-types.ts"() {
     "use strict";
+    MESH_SCHEDULING_STRATEGIES = [
+      "first_eligible",
+      "least_loaded",
+      "round_robin",
+      "priority_only"
+    ];
+    DEFAULT_MESH_SCHEDULING_STRATEGY = "first_eligible";
+    MESH_CONVERGE_REFINE_TAG = "converge=refine";
+    MESH_CONVERGE_FAST_FORWARD_TAG = "converge=fast_forward";
     DEFAULT_MESH_POLICY = {
       requirePreTaskCheckpoint: false,
       requirePostTaskCheckpoint: true,
@@ -290,10 +311,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "33fe83f72a43bccb1b4bec7744ee5c6d8c11a325" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "33fe83f7" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.310" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-17T09:34:54.806Z" : void 0);
+  const commit = readInjected(true ? "3902f3d63eabe7b9e34d0e849dc0fed2fd66c026" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "3902f3d6" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.311" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-17T12:17:11.243Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -1543,6 +1564,17 @@ function mergeMeshPolicy(base, patch) {
   if (!SPAWNED_SESSION_VISIBILITY_MODES.has(String(policy.spawnedSessionVisibility))) {
     policy.spawnedSessionVisibility = "visible";
   }
+  const normalizedStrategy = normalizeMeshSchedulingStrategy(policy.schedulingStrategy);
+  if (normalizedStrategy === "first_eligible") {
+    delete policy.schedulingStrategy;
+  } else {
+    policy.schedulingStrategy = normalizedStrategy;
+  }
+  if (policy.autoConvergeCodeChange === true) {
+    policy.autoConvergeCodeChange = true;
+  } else {
+    delete policy.autoConvergeCodeChange;
+  }
   return policy;
 }
 function normalizeAutoFastForwardPolicy(value) {
@@ -2833,6 +2865,7 @@ __export(mesh_work_queue_exports, {
   recordMeshToolCall: () => recordMeshToolCall,
   recordTaskAutoLaunch: () => recordTaskAutoLaunch,
   requeueTask: () => requeueTask,
+  resolveConvergeRequiredTags: () => resolveConvergeRequiredTags,
   updateDirectDispatchStatus: () => updateDirectDispatchStatus,
   updateSessionTaskStatus: () => updateSessionTaskStatus,
   updateTaskStatus: () => updateTaskStatus,
@@ -2907,6 +2940,21 @@ function firstProviderPriority(policy) {
   if (!Array.isArray(raw)) return void 0;
   return raw.find((type) => typeof type === "string" && type.trim())?.trim();
 }
+function roleCapabilityTags(policy, providerType) {
+  const roles = policy && typeof policy === "object" && !Array.isArray(policy) ? policy.providerRoles : void 0;
+  if (!Array.isArray(roles)) return [];
+  const wantedProvider = typeof providerType === "string" && providerType.trim() ? providerType.trim().toLowerCase() : "";
+  const out = [];
+  for (const entry of roles) {
+    if (!entry || typeof entry !== "object") continue;
+    const type = typeof entry.providerType === "string" ? entry.providerType.trim().toLowerCase() : "";
+    const role = typeof entry.role === "string" ? entry.role.trim().toLowerCase() : "";
+    if (!role) continue;
+    if (wantedProvider && type && type !== wantedProvider) continue;
+    out.push(`role=${role}`);
+  }
+  return out;
+}
 function buildMeshNodeCapabilityTags(node, providerType) {
   const provider = typeof providerType === "string" && providerType.trim() ? providerType.trim() : firstProviderPriority(node?.policy);
   const worktreeBranch = typeof node?.worktreeBranch === "string" && node.worktreeBranch.trim() ? node.worktreeBranch.trim() : null;
@@ -2918,7 +2966,25 @@ function buildMeshNodeCapabilityTags(node, providerType) {
     // Worktree nodes automatically expose a "worktree=<branch>" tag so that
     // mesh_enqueue_task with required_tags: ["worktree=<branch>"] routes
     // only to the matching worktree node.
-    ...node?.isLocalWorktree === true && worktreeBranch ? [`worktree=${worktreeBranch}`] : []
+    ...node?.isLocalWorktree === true && worktreeBranch ? [`worktree=${worktreeBranch}`] : [],
+    // Convergence routing: advertise how this node can land its work onto base.
+    //   - converge=refine: local worktree nodes (on ANY machine — refine_mesh_node
+    //     now forwards to the owning daemon) can run the Refinery merge → push →
+    //     cleanup against their own checkout, so they accept code_change tasks.
+    //   - converge=fast_forward: non-worktree nodes (the machine itself) can only
+    //     ff/push an already-converged branch; they are NOT a destination for
+    //     code_change work (a worktree is created first, and that worktree node
+    //     receives the task instead). Reuses the ordinary required-tags filter —
+    //     the load-balancing scheduler auto-injects converge=refine for code_change
+    //     so such work is hard-filtered onto refine-capable nodes.
+    ...node?.isLocalWorktree === true ? ["converge=refine"] : ["converge=fast_forward"],
+    // Role-based routing: advertise role=<x> for each (node, provider) role
+    // declared in policy.providerRoles. Narrowed to the selected provider when
+    // one is given so the chosen provider must match a task's required role;
+    // when no provider is selected, all declared roles are advertised for the
+    // node-level eligibility scan. Reuses the ordinary required-tags filter —
+    // no separate role field/gate.
+    ...roleCapabilityTags(node?.policy, providerType)
   ]);
 }
 function nodeSatisfiesRequiredTags(requiredTags, capabilityTags) {
@@ -2927,6 +2993,18 @@ function nodeSatisfiesRequiredTags(requiredTags, capabilityTags) {
   const available = new Set(normalizeMeshCapabilityTags(capabilityTags));
   return required.every((tag) => available.has(tag));
 }
+function resolveConvergeRequiredTags(meshId, taskMode, explicitRequiredTags, opts) {
+  if (taskMode !== "code_change") return explicitRequiredTags;
+  if (typeof opts?.targetNodeId === "string" && opts.targetNodeId.trim()) return explicitRequiredTags;
+  let optedIn = false;
+  try {
+    optedIn = resolveAutoConvergeCodeChange(getMesh(meshId)?.policy);
+  } catch {
+    optedIn = false;
+  }
+  if (!optedIn) return explicitRequiredTags;
+  return normalizeMeshCapabilityTags([...explicitRequiredTags, MESH_CONVERGE_REFINE_TAG]);
+}
 function withQueueLock(_meshId, fn) {
   return MeshRuntimeStore.getInstance().transaction(fn);
 }
@@ -2985,7 +3063,15 @@ function enqueueTask(meshId, message, opts) {
       taskMode: modeValidation.taskMode,
       targetNodeId: opts?.targetNodeId,
       targetSessionId: opts?.targetSessionId,
-      requiredTags: normalizeMeshCapabilityTags(opts?.requiredTags),
+      // Convergence routing (opt-in): auto-inject converge=refine for code_change
+      // tasks so they hard-filter onto refine-capable worktree nodes. No-op unless
+      // the mesh opts in; explicit target_node_id / required_tags are preserved.
+      requiredTags: resolveConvergeRequiredTags(
+        meshId,
+        modeValidation.taskMode,
+        normalizeMeshCapabilityTags(opts?.requiredTags),
+        { targetNodeId: opts?.targetNodeId }
+      ),
       ...dependsOn.length > 0 ? { dependsOn } : {},
       ...typeof opts?.missionId === "string" && opts.missionId.trim() ? { missionId: opts.missionId.trim() } : {},
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3245,6 +3331,7 @@ var init_mesh_work_queue = __esm({
   "src/mesh/mesh-work-queue.ts"() {
     "use strict";
     init_mesh_host_ownership();
+    init_repo_mesh_types();
     init_mesh_runtime_store();
     init_mesh_config();
     ACTIVE_MESH_QUEUE_STATUSES = ["pending", "assigned"];
@@ -3538,6 +3625,17 @@ var init_mesh_runtime_store = __esm({
 
             CREATE INDEX IF NOT EXISTS idx_mesh_missions_mesh_status
                 ON mesh_missions(mesh_id, status, updated_at);
+
+            -- Load-balancing scheduler: per-mesh round-robin rotation cursor. When
+            -- the schedulingStrategy is 'round_robin', several eligible nodes tied at
+            -- the least load are rotated by this cursor so the tie-break winner cycles
+            -- across scheduling passes instead of always favouring the same array-order
+            -- node. Persisted (not a module Map) so rotation survives daemon restarts
+            -- and stays a single source of truth across scheduling entry points.
+            CREATE TABLE IF NOT EXISTS mesh_scheduler_cursor (
+                mesh_id TEXT PRIMARY KEY,
+                cursor INTEGER NOT NULL DEFAULT 0
+            );
         `);
       }
       hasCompletionFingerprint(fingerprint) {
@@ -3715,6 +3813,44 @@ var init_mesh_runtime_store = __esm({
         `).get(meshId, nodeId);
         return row !== void 0;
       }
+      /**
+       * Count active (status='assigned') tasks on a node, regardless of provider or
+       * task mode. This is the load metric for least-loaded / round-robin ranking:
+       * the scheduler prefers the node with the fewest active assignments so
+       * untargeted work spreads instead of piling onto whichever node asks first.
+       */
+      nodeActiveAssignmentCount(meshId, nodeId) {
+        const row = this.db.prepare(`
+            SELECT COUNT(*) as count FROM mesh_queue
+            WHERE mesh_id = ? AND status = 'assigned' AND assigned_node_id = ?
+        `).get(meshId, nodeId);
+        return row?.count ?? 0;
+      }
+      /**
+       * Read the current per-mesh round-robin cursor (0 when unset). Used to rotate
+       * the tie-break winner among nodes tied at the least load.
+       */
+      getSchedulerCursor(meshId) {
+        const row = this.db.prepare(
+          "SELECT cursor FROM mesh_scheduler_cursor WHERE mesh_id = ?"
+        ).get(meshId);
+        return row?.cursor ?? 0;
+      }
+      /**
+       * Atomically advance the per-mesh round-robin cursor by one and return the
+       * value that was current BEFORE the bump (the value the caller should rotate
+       * by for this pass). UPSERT keeps it lock-free across concurrent passes.
+       */
+      bumpSchedulerCursor(meshId) {
+        return this.transaction(() => {
+          const current = this.getSchedulerCursor(meshId);
+          this.db.prepare(`
+                INSERT INTO mesh_scheduler_cursor (mesh_id, cursor) VALUES (?, ?)
+                ON CONFLICT(mesh_id) DO UPDATE SET cursor = excluded.cursor
+            `).run(meshId, current + 1);
+          return current;
+        });
+      }
       /**
        * Count active (status='assigned') tasks on a (node, provider) combination,
        * matched by the assignedProviderType stamped on the payload at claim time.
@@ -8286,6 +8422,33 @@ function activeReadonlyAssignedCount(meshId) {
 function nodeHasActiveAssignment(meshId, nodeId) {
   return getQueue(meshId, { status: ["assigned"] }).some((task) => task.assignedNodeId === nodeId);
 }
+function nodeActiveLoad(meshId, nodeId) {
+  return MeshRuntimeStore.getInstance().nodeActiveAssignmentCount(meshId, nodeId);
+}
+function resolveSchedulingStrategy(mesh) {
+  return normalizeMeshSchedulingStrategy(mesh?.policy?.schedulingStrategy);
+}
+function orderEligibleNodes(meshId, strategy, nodes, opts) {
+  if (strategy === "first_eligible" || nodes.length <= 1) {
+    return nodes;
+  }
+  const priorityOf = (n) => resolveNodeSchedulingPriority(n.node?.policy);
+  let rotation = 0;
+  if (strategy === "round_robin") {
+    const cursor = opts?.bumpCursor ? MeshRuntimeStore.getInstance().bumpSchedulerCursor(meshId) : MeshRuntimeStore.getInstance().getSchedulerCursor(meshId);
+    rotation = (cursor % nodes.length + nodes.length) % nodes.length;
+  }
+  const rotationRank = (index) => (index - rotation + nodes.length) % nodes.length;
+  return [...nodes].sort((a, b) => {
+    const prioDelta = priorityOf(b) - priorityOf(a);
+    if (prioDelta !== 0) return prioDelta;
+    if (strategy === "least_loaded" || strategy === "round_robin") {
+      const loadDelta = nodeActiveLoad(meshId, a.nodeId) - nodeActiveLoad(meshId, b.nodeId);
+      if (loadDelta !== 0) return loadDelta;
+    }
+    return rotationRank(a.index) - rotationRank(b.index);
+  });
+}
 function activeProviderAssignedCount(meshId, nodeId, providerType) {
   return getQueue(meshId, { status: ["assigned"] }).filter((task) => task.assignedNodeId === nodeId && task.assignedProviderType === providerType).length;
 }
@@ -8422,7 +8585,14 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
       markAutoLaunch(meshId, task.id, { status: "skipped", reason: "no_node_satisfies_required_tags", nodeId: task.targetNodeId });
       continue;
     }
-    for (const node of candidateNodes) {
+    const strategy = resolveSchedulingStrategy(mesh);
+    const orderedCandidateNodes = strategy === "first_eligible" ? candidateNodes : orderEligibleNodes(
+      meshId,
+      strategy,
+      candidateNodes.map((node, index) => ({ nodeId: readMeshNodeId(node), node, index })).filter((c) => c.nodeId),
+      { bumpCursor: true }
+    ).map((c) => c.node);
+    for (const node of orderedCandidateNodes) {
       const nodeId = readMeshNodeId(node);
       if (!nodeId) continue;
       const launchKey = `${meshId}:${nodeId}`;
@@ -8549,6 +8719,8 @@ async function triggerMeshQueue(components, meshId) {
       noIdleMeshSessionAvailable: true
     };
   }
+  const strategy = resolveSchedulingStrategy(mesh);
+  const localCandidates = [];
   const cliInstances = components.instanceManager.getByCategory("cli");
   for (const inst of cliInstances) {
     const state = inst.getState();
@@ -8571,7 +8743,7 @@ async function triggerMeshQueue(components, meshId) {
     const providerType = state.type || readNonEmptyString2(settings.providerType);
     if (providerType) {
       localIdleSessionsChecked += 1;
-      tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType);
+      localCandidates.push({ nodeId, sessionId, providerType, origin: "local", node: mesh.nodes.find((n) => readMeshNodeId(n) === nodeId) });
     } else {
       skippedSessions.push({
         nodeId,
@@ -8585,18 +8757,49 @@ async function triggerMeshQueue(components, meshId) {
     remoteSessions = MeshRuntimeStore.getInstance().getRemoteIdleSessions();
   } catch {
   }
+  const remoteCandidates = [];
   for (const idle of remoteSessions) {
     const node = mesh.nodes.find((n) => n.id === idle.nodeId);
     if (node) {
       remoteIdleSessionsChecked += 1;
-      const assigned = tryAssignQueueTask(components, meshId, idle.nodeId, idle.sessionId, idle.providerType);
-      if (assigned) {
-        try {
-          MeshRuntimeStore.getInstance().deleteRemoteIdleSession(idle.nodeId, idle.sessionId);
-        } catch {
-        }
+      remoteCandidates.push({ nodeId: idle.nodeId, sessionId: idle.sessionId, providerType: idle.providerType, origin: "remote", node });
+    }
+  }
+  const assignIdleCandidate = (candidate) => {
+    const assigned = tryAssignQueueTask(components, meshId, candidate.nodeId, candidate.sessionId, candidate.providerType);
+    if (assigned && candidate.origin === "remote") {
+      try {
+        MeshRuntimeStore.getInstance().deleteRemoteIdleSession(candidate.nodeId, candidate.sessionId);
+      } catch {
       }
     }
+  };
+  if (strategy === "first_eligible") {
+    for (const candidate of localCandidates) assignIdleCandidate(candidate);
+    for (const candidate of remoteCandidates) assignIdleCandidate(candidate);
+  } else {
+    const pool = [...localCandidates, ...remoteCandidates];
+    const baseIndex = /* @__PURE__ */ new Map();
+    pool.forEach((c, i) => {
+      if (!baseIndex.has(c.nodeId)) baseIndex.set(c.nodeId, i);
+    });
+    const uniqueNodes = [...new Set(pool.map((c) => c.nodeId))].map((nodeId, index) => ({ nodeId, node: pool.find((c) => c.nodeId === nodeId)?.node, index }));
+    const ranked = orderEligibleNodes(meshId, strategy, uniqueNodes, { bumpCursor: true });
+    const rankIndex = new Map(ranked.map((r, i) => [r.nodeId, i]));
+    const remaining = [...pool];
+    while (remaining.length > 0) {
+      remaining.sort((a, b) => {
+        const aPrio = resolveNodeSchedulingPriority(a.node?.policy);
+        const bPrio = resolveNodeSchedulingPriority(b.node?.policy);
+        if (aPrio !== bPrio) return bPrio - aPrio;
+        if (strategy === "least_loaded" || strategy === "round_robin") {
+          const loadDelta = nodeActiveLoad(meshId, a.nodeId) - nodeActiveLoad(meshId, b.nodeId);
+          if (loadDelta !== 0) return loadDelta;
+        }
+        return (rankIndex.get(a.nodeId) ?? 0) - (rankIndex.get(b.nodeId) ?? 0);
+      });
+      assignIdleCandidate(remaining.shift());
+    }
   }
   autoLaunchStarted = await maybeAutoLaunchOneQueueSession(components, meshId, mesh);
   const afterQueue = getQueue(meshId);
@@ -11972,7 +12175,7 @@ var init_cli_state_engine = __esm({
       scheduleSettle() {
         if (this.settleTimer) clearTimeout(this.settleTimer);
         const epoch = this.responseEpoch;
-        const delay = Math.max(
+        const delay2 = Math.max(
           this.timeouts.outputSettle,
           this.submitPendingUntil > Date.now() ? this.submitPendingUntil - Date.now() + this.timeouts.outputSettle : 0
         );
@@ -11980,7 +12183,7 @@ var init_cli_state_engine = __esm({
           this.settleTimer = null;
           if (epoch !== this.responseEpoch) return;
           this.evaluateSettled(this.transport.getSnapshot());
-        }, delay);
+        }, delay2);
       }
       /** Called from sendMessage in transport once a turn scope is established. */
       onTurnStarted(turnScope) {
@@ -17795,9 +17998,9 @@ function readString6(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
 function summarizeMessage(message) {
-  const oneLine = message.replace(/\s+/g, " ").trim();
-  const title = oneLine.length > 96 ? `${oneLine.slice(0, 93)}...` : oneLine;
-  return { title: title || "(untitled task)", summary: oneLine };
+  const oneLine2 = message.replace(/\s+/g, " ").trim();
+  const title = oneLine2.length > 96 ? `${oneLine2.slice(0, 93)}...` : oneLine2;
+  return { title: title || "(untitled task)", summary: oneLine2 };
 }
 function elapsedSince(value, now) {
   const started = value ? new Date(value).getTime() : Number.NaN;
@@ -20903,6 +21106,11 @@ function collapseReplayAssistantTurns(messages, historyBehavior) {
       continue;
     }
     if (message.role === "assistant") {
+      const isActivity = message.kind === "tool" || message.kind === "terminal" || message.kind === "thought";
+      if (isActivity) {
+        collapsed.push(message);
+        continue;
+      }
       if (sawAssistantSinceLastUser) continue;
       sawAssistantSinceLastUser = true;
       collapsed.push(message);
@@ -26046,7 +26254,8 @@ function buildReadChatCommandResult(payload, args, h) {
   const sessionIdHint = typeof args?.targetSessionId === "string" ? args.targetSessionId : typeof args?.sessionId === "string" ? args.sessionId : "";
   const providerHint = typeof args?.cliType === "string" ? args.cliType : typeof args?.providerType === "string" ? args.providerType : typeof args?.agentType === "string" ? args.agentType : "";
   const filteredMessages = h ? maybeHideCoordinatorPromptMessage(h, providerHint, sessionIdHint, messages) : messages;
-  const visibleMessages = filterUserFacingChatMessages(filteredMessages);
+  const includeActivity = args?.includeActivity === true || args?.includeActivity === "true";
+  const visibleMessages = includeActivity ? filteredMessages.filter((m) => isUserFacingChatMessage(m) || isActivityChatMessage(m)) : filterUserFacingChatMessages(filteredMessages);
   const sync = buildFullTail(visibleMessages, normalizeReadChatTailLimit(args));
   const hiddenMsgCount = Math.max(0, messages.length - visibleMessages.length);
   const preservedPayloadFields = Object.fromEntries(Object.entries(payload).filter(([key]) => shouldPreserveReadChatPayloadField(key)));
@@ -28415,6 +28624,9 @@ function normalizeProviderScriptArgs(args, scriptName) {
 }
 function buildControlScriptResult(scriptName, payload) {
   if (!payload || typeof payload !== "object") return {};
+  if (payload.controlResult && typeof payload.controlResult === "object") {
+    return { controlResult: payload.controlResult };
+  }
   const legacyListPayload = (() => {
     if (Array.isArray(payload.options)) return payload;
     if (/^listmodels$/i.test(scriptName) && Array.isArray(payload.models)) {
@@ -30265,12 +30477,12 @@ var FsmDriver = class {
   scheduleSpawnPrime() {
     const seqs = this.spec.send_on_spawn;
     if (!Array.isArray(seqs) || seqs.length === 0) return;
-    const delay = Math.max(0, this.spec.send_on_spawn_delay_ms ?? 250);
+    const delay2 = Math.max(0, this.spec.send_on_spawn_delay_ms ?? 250);
     setTimeout(() => {
       for (const seq of seqs) {
         if (typeof seq === "string" && seq.length > 0) this.adapter.send_keys(seq);
       }
-    }, delay);
+    }, delay2);
   }
   dispatch(cmd) {
     switch (cmd.kind) {
@@ -30636,11 +30848,11 @@ var FsmDriver = class {
       const armed = this.delegateTimers.has(d.id);
       const shouldFire = d.when_state === currentStateId;
       if (shouldFire && !armed) {
-        const delay = d.after_duration_ms ?? 0;
+        const delay2 = d.after_duration_ms ?? 0;
         const t = setTimeout(() => {
           this.fireDelegate(d);
           this.delegateTimers.delete(d.id);
-        }, delay);
+        }, delay2);
         this.delegateTimers.set(d.id, t);
       } else if (!shouldFire && armed) {
         clearTimeout(this.delegateTimers.get(d.id));
@@ -30694,7 +30906,15 @@ var FsmDriver = class {
         this.adapter.send_keys(a.keys);
         return;
       case "open_picker":
-        this.adapter.send_keys(a.trigger_keys);
+        {
+          const m = /^([\s\S]*?)([\r\n]+)$/.exec(a.trigger_keys);
+          if (m && m[1]) {
+            this.adapter.send_keys(m[1]);
+            setTimeout(() => this.adapter.send_keys(m[2]), 200);
+          } else {
+            this.adapter.send_keys(a.trigger_keys);
+          }
+        }
         this.pickerInProgress = { control_id: ctl.id, spec: ctl };
         return;
       case "attach_image": {
@@ -30879,8 +31099,7 @@ function executeJsonl(src, input) {
   for (let i = 0; i < lines.length; i += 1) {
     const rec = lines[i];
     if (filter && !filter(rec)) continue;
-    const msg = projectMessage(rec, src.message_map, i, lines.length, mtime);
-    if (msg) {
+    for (const msg of projectMessages(rec, src.message_map, i, lines.length, mtime)) {
       if (transcriptWorkspace) msg.workspace = transcriptWorkspace;
       messages.push(msg);
     }
@@ -30960,8 +31179,9 @@ function executeSqlite(src, input) {
     const mtime = safeMtimeMs(resolved);
     const messages = [];
     for (let i = 0; i < messageRows.length; i += 1) {
-      const msg = projectMessage(messageRows[i], src.message_map, i, messageRows.length, mtime);
-      if (msg) messages.push(msg);
+      for (const msg of projectMessages(messageRows[i], src.message_map, i, messageRows.length, mtime)) {
+        messages.push(msg);
+      }
     }
     if (messages.length === 0) return null;
     return {
@@ -31359,11 +31579,42 @@ function jsonPathGet(record, expr) {
   }
   return cur;
 }
-function projectMessage(record, map, index, total, sourceMtimeMs) {
+function projectMessages(record, map, index, total, sourceMtimeMs) {
   const roleRaw = jsonPathGet(record, map.role);
-  const contentRaw = jsonPathGet(record, map.content);
   const role = normalizeRole(roleRaw);
-  let content = stringifyContent(contentRaw);
+  let receivedAt = sourceMtimeMs - (total - 1 - index) * 1e3;
+  if (map.timestamp_ms) {
+    const tsRaw = jsonPathGet(record, map.timestamp_ms);
+    const parsed = parseTimestamp(tsRaw);
+    if (parsed != null) receivedAt = parsed;
+  }
+  const kindRaw = map.kind ? jsonPathGet(record, map.kind) : void 0;
+  const kind = typeof kindRaw === "string" && kindRaw ? kindRaw : "standard";
+  const out = [];
+  if (map.tools) {
+    const recordTool = projectToolBlock(record, role, map.tools);
+    if (recordTool) {
+      out.push({ ...recordTool, receivedAt });
+      return out;
+    }
+  }
+  const contentRaw = jsonPathGet(record, map.content);
+  const content = cleanContent(stringifyContent(contentRaw), map);
+  if (content) out.push({ role, content, receivedAt, kind });
+  if (map.tools && Array.isArray(contentRaw)) {
+    let nudge = 1;
+    for (const block2 of contentRaw) {
+      const tool = projectToolBlock(block2, role, map.tools);
+      if (tool) {
+        out.push({ ...tool, receivedAt: receivedAt + nudge });
+        nudge += 1;
+      }
+    }
+  }
+  return out;
+}
+function cleanContent(input, map) {
+  let content = input;
   if (content && map.content_strip) {
     for (const tag of map.content_strip) {
       const safeTag = tag.replace(/[.+^${}()|[\]\\]/g, "\\$&");
@@ -31379,17 +31630,33 @@ function projectMessage(record, map, index, total, sourceMtimeMs) {
       content = content.replace(open, "").replace(close, "");
     }
   }
-  if (content) content = content.trim();
-  if (!content) return null;
-  let receivedAt = sourceMtimeMs - (total - 1 - index) * 1e3;
-  if (map.timestamp_ms) {
-    const tsRaw = jsonPathGet(record, map.timestamp_ms);
-    const parsed = parseTimestamp(tsRaw);
-    if (parsed != null) receivedAt = parsed;
+  return content ? content.trim() : "";
+}
+var DEFAULT_TOOL_CALL_TYPES = ["tool_use", "function_call", "custom_tool_call"];
+var DEFAULT_TOOL_RESULT_TYPES = ["tool_result", "function_call_output", "custom_tool_call_output"];
+function projectToolBlock(block2, role, tmap) {
+  void role;
+  if (block2 == null || typeof block2 !== "object") return null;
+  const typeVal = String(jsonPathGet(block2, tmap.block_type || "$.type") ?? "");
+  if (!typeVal) return null;
+  const callTypes = tmap.call_types ?? DEFAULT_TOOL_CALL_TYPES;
+  const resultTypes = tmap.result_types ?? DEFAULT_TOOL_RESULT_TYPES;
+  if (callTypes.includes(typeVal)) {
+    const name = String(jsonPathGet(block2, tmap.call_name || "$.name") ?? "tool").trim() || "tool";
+    const args = oneLine(stringifyContent(jsonPathGet(block2, tmap.call_args || "$.input")), 240);
+    const content = args ? `\u2197 ${name}: ${args}` : `\u2197 ${name}`;
+    return { role: "assistant", content, receivedAt: 0, kind: "tool" };
+  }
+  if (resultTypes.includes(typeVal)) {
+    const result = oneLine(stringifyContent(jsonPathGet(block2, tmap.result_content || "$.content")), 600);
+    if (!result) return null;
+    return { role: "assistant", content: `\u2198 ${result}`, receivedAt: 0, kind: "tool" };
   }
-  const kindRaw = map.kind ? jsonPathGet(record, map.kind) : void 0;
-  const kind = typeof kindRaw === "string" && kindRaw ? kindRaw : "standard";
-  return { role, content, receivedAt, kind };
+  return null;
+}
+function oneLine(s, max) {
+  const flat = s.replace(/\s+/g, " ").trim();
+  return flat.length > max ? flat.slice(0, max - 1) + "\u2026" : flat;
 }
 function parseTimestamp(v) {
   if (v == null) return null;
@@ -31530,6 +31797,9 @@ import * as fs13 from "fs";
 function stripAnsi3(text) {
   return String(text || "").replace(/\x1B\][^\x07]*(?:\x07|\x1B\\)/g, "").replace(/\x1B[P^_X][\s\S]*?(?:\x07|\x1B\\)/g, "").replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
 }
+function delay(ms) {
+  return new Promise((resolve24) => setTimeout(resolve24, ms));
+}
 var SpecCliAdapter = class _SpecCliAdapter {
   cliType;
   cliName;
@@ -31751,9 +32021,15 @@ var SpecCliAdapter = class _SpecCliAdapter {
    * drives the dispatch:
    *
    *   send_keys     → click_control                   (e.g. stop)
-   *   open_picker   → click_control then resolve when extract_choices
-   *                   surface; choice index comes from args.choiceIndex
-   *                   or args.choice (string label match), defaulting to 0
+   *   open_picker   → two roles, driven by the screen, not a hardcoded list:
+   *                   - LIST  (no choice arg): open the picker, wait for it
+   *                     to render, parse the on-screen options via
+   *                     `extract_choices`, and return them as
+   *                     `controlResult.options` (+ `currentValue`). This is
+   *                     how the dashboard's Model/Mode controls learn what is
+   *                     actually selectable in this CLI right now.
+   *                   - SELECT (args.choiceIndex / args.choiceLabel): drive
+   *                     the picker to that option using `submit_key`.
    *   attach_image  → attach_image dispatch; expects args.blob (data url
    *                   or base64) and args.mime
    *
@@ -31778,11 +32054,128 @@ var SpecCliAdapter = class _SpecCliAdapter {
       this.driver.dispatch({ kind: "attach_image", blob, mime });
       return Promise.resolve({ ok: true, effects: [{ type: "attached_image", controlId: ctl.id }] });
     }
+    if (action.type === "open_picker") {
+      const choiceIndex = typeof flat.choiceIndex === "number" ? flat.choiceIndex : typeof flat.choiceIndex === "string" && flat.choiceIndex.trim() ? Number(flat.choiceIndex) : void 0;
+      const choiceLabel = typeof flat.choiceLabel === "string" ? flat.choiceLabel : typeof flat.choice === "string" ? flat.choice : void 0;
+      if (typeof choiceIndex === "number" && Number.isFinite(choiceIndex) || choiceLabel && choiceLabel.trim()) {
+        return this.selectPickerChoice(ctl, action, choiceIndex, choiceLabel);
+      }
+      return this.openPickerAndListChoices(ctl, action);
+    }
     this.driver.dispatch({ kind: "click_control", control_id: ctl.id, payload: flat });
-    const effects = [];
-    if (action.type === "open_picker") effects.push({ type: "opened_picker", controlId: ctl.id });
-    else if (action.type === "send_keys") effects.push({ type: "sent_keys", controlId: ctl.id });
-    return Promise.resolve({ ok: true, effects });
+    return Promise.resolve({ ok: true, effects: [{ type: "sent_keys", controlId: ctl.id }] });
+  }
+  /**
+   * Open an `open_picker` control and return the options the CLI is showing,
+   * parsed live from the screen via `extract_choices`. Nothing is selected —
+   * the picker is left open so a follow-up SELECT invoke can commit a choice.
+   */
+  async openPickerAndListChoices(ctl, action) {
+    this.driver.dispatch({ kind: "click_control", control_id: ctl.id });
+    const ready = await this.waitForPickerRendered(action);
+    const options = this.extractPickerChoices(action);
+    const currentValue = options.find((o) => o.current)?.label;
+    return {
+      ok: true,
+      effects: [{ type: "opened_picker", controlId: ctl.id }],
+      controlResult: {
+        options: options.map((o) => ({ value: o.label, label: o.label, current: o.current })),
+        ...currentValue ? { currentValue } : {},
+        source: "screen-parse",
+        ...ready ? {} : { warning: "picker_render_timeout" }
+      }
+    };
+  }
+  /**
+   * Drive an already-listable picker to a specific option. The option can be
+   * named (choiceLabel — matched against the parsed on-screen labels) or
+   * positional (choiceIndex — the on-screen number). The actual keystrokes
+   * come from the spec's `submit_key` with `{index}` substituted, so the spec
+   * — not this code — decides how a selection is keyed for each CLI.
+   */
+  async selectPickerChoice(ctl, action, choiceIndex, choiceLabel) {
+    this.driver.dispatch({ kind: "click_control", control_id: ctl.id });
+    await this.waitForPickerRendered(action);
+    const options = this.extractPickerChoices(action);
+    let index = choiceIndex;
+    if ((index == null || !Number.isFinite(index)) && choiceLabel) {
+      const needle = choiceLabel.trim().toLowerCase();
+      const match = options.find((o) => o.label.toLowerCase().includes(needle));
+      if (!match) {
+        return { ok: false, error: `choice not found on screen: ${choiceLabel}`, controlResult: { options: options.map((o) => ({ value: o.label, label: o.label })) } };
+      }
+      index = match.index;
+    }
+    if (index == null || !Number.isFinite(index)) {
+      return { ok: false, error: "choiceIndex or choiceLabel required to select" };
+    }
+    const keys = (action.submit_key || "{index}\r").replace(/\{index\}/g, String(index));
+    this.driver.dispatch({ kind: "pty_write", data: keys });
+    const selected = options.find((o) => o.index === index);
+    return {
+      ok: true,
+      effects: [{ type: "selected_choice", controlId: ctl.id }],
+      controlResult: {
+        ok: true,
+        ...selected ? { currentValue: selected.label } : {},
+        selectedIndex: index
+      }
+    };
+  }
+  /** Poll the live screen until the picker's `wait_for` condition matches,
+   *  up to a short budget. Returns true if it rendered, false on timeout. */
+  async waitForPickerRendered(action) {
+    const wf = action.wait_for;
+    if (!wf?.regex) {
+      await delay(250);
+      return true;
+    }
+    const re = new RegExp(wf.regex, wf.flags ?? "i");
+    const deadline = Date.now() + 2500;
+    while (Date.now() < deadline) {
+      await delay(120);
+      const hay = this.readScreenSectionText(wf.section);
+      if (re.test(hay)) return true;
+    }
+    return false;
+  }
+  /** Parse the picker's `extract_choices` pattern against the live screen.
+   *  Each match yields { index, label, current }. `current` is true for the
+   *  line the CLI marks with its cursor glyph (❯ ›). Purely screen-driven —
+   *  no model/mode names are baked in. */
+  extractPickerChoices(action) {
+    const ec = action.extract_choices;
+    if (!ec?.pattern) return [];
+    const text = this.readScreenSectionText(ec.section);
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const rawLine of text.split("\n")) {
+      const line = rawLine.replace(/\r$/, "");
+      const m = new RegExp(ec.pattern, ec.flags ?? "").exec(line);
+      if (!m) continue;
+      const idx = Number(m[1]);
+      if (!Number.isFinite(idx) || seen.has(idx)) continue;
+      const label = (m[2] ?? "").replace(/\s+/g, " ").trim();
+      if (!label) continue;
+      const current = /^\s*[❯›>]/.test(line) || /[✔✓●]\s*$/.test(label);
+      seen.add(idx);
+      out.push({ index: idx, label, current });
+    }
+    return out;
+  }
+  /** Live text of a named screen section (or the whole screen when no
+   *  section is named), resolved from the driver's current sections. */
+  readScreenSectionText(sectionId) {
+    try {
+      const sections = this.driver.getSections();
+      if (sectionId && sections) {
+        const hit = sections.find((s) => s.id === sectionId);
+        if (hit) return hit.text;
+      }
+      return this.driver.getScreen();
+    } catch {
+      return "";
+    }
   }
   getDebugSnapshot() {
     let screen = "";
@@ -42003,6 +42396,43 @@ function readMeshTimeoutEnvMs(name, defaultMs) {
 }
 var MESH_DIRECT_PROBE_TIMEOUT_MS = readMeshTimeoutEnvMs("MESH_DIRECT_PROBE_TIMEOUT_MS", 25e3);
 var MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS = readMeshTimeoutEnvMs("MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS", 25e3);
+var MESH_DIRECT_PROBE_REUSE_MS = readMeshTimeoutEnvMs("MESH_DIRECT_PROBE_REUSE_MS", 12e3);
+var MeshGitProbeCache = class {
+  constructor(reuseMs, now = Date.now) {
+    this.reuseMs = reuseMs;
+    this.now = now;
+  }
+  inflight = /* @__PURE__ */ new Map();
+  recent = /* @__PURE__ */ new Map();
+  key(daemonId, workspace) {
+    return `${daemonId}::${workspace}`;
+  }
+  /**
+   * Run `probe` for this peer, but reuse a fresh recent result or an in-flight
+   * probe for the same key when one is available. `probe` is only invoked when
+   * neither gate is satisfied.
+   */
+  async probe(daemonId, workspace, probe) {
+    const key = this.key(daemonId, workspace);
+    const cached2 = this.recent.get(key);
+    if (cached2 && this.now() - cached2.at < this.reuseMs) {
+      return cached2.value;
+    }
+    const existing = this.inflight.get(key);
+    if (existing) return existing;
+    const pending = (async () => {
+      const result = await probe();
+      if (result) this.recent.set(key, { at: this.now(), value: result });
+      return result;
+    })();
+    this.inflight.set(key, pending);
+    try {
+      return await pending;
+    } finally {
+      if (this.inflight.get(key) === pending) this.inflight.delete(key);
+    }
+  }
+};
 async function probeRemoteMeshGitStatus(args) {
   if (!args.dispatchMeshCommand) return null;
   const remoteResult = await Promise.race([
@@ -42096,7 +42526,7 @@ async function hydrateInlineMeshDirectTruth(args) {
       continue;
     }
     peerAttemptedCount += 1;
-    const remoteGit = await probeRemoteMeshGitStatusWithRetry({
+    const runProbe = () => probeRemoteMeshGitStatusWithRetry({
       dispatchMeshCommand: args.dispatchMeshCommand,
       daemonId,
       workspace,
@@ -42104,6 +42534,7 @@ async function hydrateInlineMeshDirectTruth(args) {
       retryTimeoutMs: MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS,
       getConnection: args.getMeshPeerConnectionStatus
     });
+    const remoteGit = args.probeCache ? await args.probeCache.probe(daemonId, workspace, runProbe) : await runProbe();
     if (remoteGit) {
       recordInlineMeshDirectGitTruth(node, remoteGit, "selected_coordinator_mesh_p2p_git");
       peerConfirmedCount += 1;
@@ -43426,6 +43857,10 @@ var DaemonCommandRouter = class {
   inlineMeshCache = /* @__PURE__ */ new Map();
   /** Coordinator-owned whole-mesh aggregate status snapshots. Browser callers read this by default. */
   aggregateMeshStatusCache = /* @__PURE__ */ new Map();
+  /** Shared per-peer git_status probe dedup + recently-probed reuse gate.
+   *  Spans separate mesh_status/get_mesh calls so the dashboard auto-retry
+   *  loop cannot storm a slow peer with back-to-back refreshUpstream probes. */
+  meshGitProbeCache = new MeshGitProbeCache(MESH_DIRECT_PROBE_REUSE_MS);
   /** In-memory async Refinery jobs keyed by meshId:nodeId to reject/return duplicate in-flight requests. */
   runningRefineJobs = /* @__PURE__ */ new Map();
   /** Terminal async Refinery jobs preserve a clear answer after the worktree node has been removed. */
@@ -46328,7 +46763,8 @@ ${hintLines.join("\n")}` : "",
           getMeshPeerConnectionStatus: this.deps.getMeshPeerConnectionStatus,
           statusInstanceId: this.deps.statusInstanceId,
           localMachineId: loadConfig().machineId || "",
-          probeRemotePeers
+          probeRemotePeers,
+          probeCache: this.meshGitProbeCache
         });
         const directTruthSatisfied = meshRecord.source !== "inline_bootstrap" || directTruth.directEvidenceCount > 0;
         const sourceOfTruth = {
@@ -46932,6 +47368,22 @@ ${hintLines.join("\n")}` : "",
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
         if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
+        {
+          const meshRecordForForward = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+          const forwardNode = meshRecordForForward?.mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
+          const nodeDaemonId = typeof forwardNode?.daemonId === "string" ? forwardNode.daemonId.trim() : void 0;
+          const selfDaemonId = this.deps.statusInstanceId;
+          const isRemote = nodeDaemonId && selfDaemonId && nodeDaemonId !== selfDaemonId;
+          if (isRemote && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
+            const callerCoordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : void 0;
+            const forwarded = await this.deps.dispatchMeshCommand(nodeDaemonId, "refine_mesh_node", {
+              ...typeof args === "object" && args !== null ? args : {},
+              coordinatorDaemonId: callerCoordinatorDaemonId || selfDaemonId,
+              _meshDirectDispatch: true
+            });
+            return forwarded ?? { success: false, error: "no response from remote node" };
+          }
+        }
         const isDryRun = args?.dryRun !== false && args?.execute !== true;
         if (isDryRun) {
           const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
@@ -47904,6 +48356,7 @@ ${ptyResult.output.slice(-2e3)}`);
           const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
           const localMachineId = loadConfig().machineId || "";
           const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
+          const meshGitProbeCache = this.meshGitProbeCache;
           const directTruth = requireDirectPeerTruth ? await hydrateInlineMeshDirectTruth({
             mesh,
             meshSource: meshRecord.source,
@@ -47914,7 +48367,8 @@ ${ptyResult.output.slice(-2e3)}`);
             // Standing-state model: only an explicit refresh fans
             // out a blocking peer git probe. Default loads return
             // held truth so one slow peer can't block the graph.
-            probeRemotePeers: refreshRequested
+            probeRemotePeers: refreshRequested,
+            probeCache: meshGitProbeCache
           }) : {
             directEvidenceCount: 0,
             localConfirmedCount: 0,
@@ -48075,7 +48529,7 @@ ${ptyResult.output.slice(-2e3)}`);
                   }
                   remoteProbeApplied = true;
                 } else if (refreshRequested && !isSelfNode && daemonId && this.deps.dispatchMeshCommand && !directTruthUnavailableNodeIds.has(nodeId)) {
-                  const remoteGit = await probeRemoteMeshGitStatusWithRetry({
+                  const runNodeProbe = () => probeRemoteMeshGitStatusWithRetry({
                     dispatchMeshCommand: this.deps.dispatchMeshCommand,
                     daemonId,
                     workspace,
@@ -48086,6 +48540,7 @@ ${ptyResult.output.slice(-2e3)}`);
                       status.connection = connection;
                     }
                   });
+                  const remoteGit = await meshGitProbeCache.probe(daemonId, workspace, runNodeProbe);
                   if (remoteGit) {
                     status.git = remoteGit;
                     status.health = remoteGit.isGitRepo ? deriveMeshNodeHealthFromGit(remoteGit) : "degraded";
@@ -56909,6 +57364,7 @@ export {
   DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS,
   DEFAULT_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS,
   DEFAULT_MESH_POLICY,
+  DEFAULT_MESH_SCHEDULING_STRATEGY,
   DEFAULT_SESSION_HOST_APP_NAME,
   DEFAULT_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS,
   DEFAULT_SESSION_HOST_READY_TIMEOUT_MS,
@@ -56934,9 +57390,12 @@ export {
   InMemoryGitSnapshotStore,
   LOG,
   MAX_LEDGER_SLICE_LIMIT,
+  MESH_CONVERGE_FAST_FORWARD_TAG,
+  MESH_CONVERGE_REFINE_TAG,
   MESH_MISSION_STATUSES,
   MESH_REFINE_CONFIG_LOCATIONS,
   MESH_REFINE_CONFIG_SCHEMA,
+  MESH_SCHEDULING_STRATEGIES,
   MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS,
   MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA,
   MIN_GIT_WORKSPACE_POLL_INTERVAL_MS,
@@ -57137,6 +57596,7 @@ export {
   normalizeManagedStatus,
   normalizeMeshCapabilityTags,
   normalizeMeshDaemonRole,
+  normalizeMeshSchedulingStrategy,
   normalizeMeshTaskMode,
   normalizeMeshWorkerResult,
   normalizeMessageParts,
@@ -57174,7 +57634,9 @@ export {
   resetConfig,
   resetDebugRuntimeConfig,
   resetState,
+  resolveAutoConvergeCodeChange,
   resolveChatMessageKind,
+  resolveConvergeRequiredTags,
   resolveCurrentGlobalInstallSurface,
   resolveDebugRuntimeConfig,
   resolveDelegatedWorkerAutoApprove,
@@ -57182,6 +57644,7 @@ export {
   resolveGitRepository,
   resolveMeshHostStatus,
   resolveMeshRefineValidationPlan,
+  resolveNodeSchedulingPriority,
   resolveSessionHostAppName,
   resolveSessionHostAppNameResolution,
   resolveWorktreePath,