@adhdev/daemon-core 0.9.82-rc.483 → 0.9.82-rc.485

package/dist/index.mjs

@@ -404,10 +404,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "0862a3f10fa9de60a46591c0894a7209534db2e2" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "0862a3f1" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.483" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-08T04:27:00.139Z" : void 0);
+  const commit = readInjected(true ? "ddf2eb6eafcf949165edfda2c3cf7c77597fa6f8" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "ddf2eb6e" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.485" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-08T15:14:11.978Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -2765,12 +2765,45 @@ function summarizeGitShape(status) {
     submodules
   };
 }
-var DAEMON_ID_PREFIXES, MAGI_RAW_ANSWER_CAP, CANONICAL_MESH_TOOL_NAMES, CANONICAL_MESH_TOOL_COUNT;
+function isMeshTaskDifficulty(value) {
+  return typeof value === "string" && MESH_TASK_DIFFICULTIES.includes(value);
+}
+function normalizeThinkingLevel(value) {
+  const v = typeof value === "string" ? value.trim().toLowerCase() : "";
+  return v === "low" || v === "medium" || v === "high" ? v : void 0;
+}
+function normalizeBrainSlot(raw) {
+  const r = raw && typeof raw === "object" ? raw : {};
+  const provider = typeof r.provider === "string" ? r.provider.trim() : "";
+  const model = typeof r.model === "string" ? r.model.trim() : "";
+  const thinkingLevel = normalizeThinkingLevel(r.thinkingLevel);
+  return {
+    ...provider ? { provider } : {},
+    ...model ? { model } : {},
+    ...thinkingLevel ? { thinkingLevel } : {}
+  };
+}
+function normalizeDifficultyBrainMap(raw) {
+  const out = {};
+  if (!raw || typeof raw !== "object") return out;
+  for (const key2 of MESH_TASK_DIFFICULTIES) {
+    const slot = normalizeBrainSlot(raw[key2]);
+    if (slot.provider || slot.model || slot.thinkingLevel) out[key2] = slot;
+  }
+  return out;
+}
+var DAEMON_ID_PREFIXES, MAGI_RAW_ANSWER_CAP, MESH_TASK_DIFFICULTIES, DEFAULT_DIFFICULTY_BRAINS, CANONICAL_MESH_TOOL_NAMES, CANONICAL_MESH_TOOL_COUNT;
 var init_dist = __esm({
   "../mesh-shared/dist/index.mjs"() {
     "use strict";
     DAEMON_ID_PREFIXES = ["daemon_", "standalone_"];
     MAGI_RAW_ANSWER_CAP = 4e3;
+    MESH_TASK_DIFFICULTIES = ["easy", "medium", "difficult", "freeform"];
+    DEFAULT_DIFFICULTY_BRAINS = {
+      easy: { model: "haiku", thinkingLevel: "low" },
+      medium: { model: "sonnet", thinkingLevel: "medium" },
+      difficult: { model: "opus", thinkingLevel: "high" }
+    };
     CANONICAL_MESH_TOOL_NAMES = [
       "mesh_status",
       "mesh_list_nodes",
@@ -2911,6 +2944,7 @@ __export(mesh_config_exports, {
   createMesh: () => createMesh,
   createMeshHostPairingToken: () => createMeshHostPairingToken,
   deleteMesh: () => deleteMesh,
+  getDifficultyBrains: () => getDifficultyBrains,
   getMagiKindPanel: () => getMagiKindPanel,
   getMesh: () => getMesh,
   getMeshByRepo: () => getMeshByRepo,
@@ -2921,6 +2955,7 @@ __export(mesh_config_exports, {
   normalizeRepoIdentity: () => normalizeRepoIdentity,
   removeMagiKindPanel: () => removeMagiKindPanel,
   removeNode: () => removeNode,
+  setDifficultyBrains: () => setDifficultyBrains,
   setMagiKindPanel: () => setMagiKindPanel,
   tokenIdForManualPairing: () => tokenIdForManualPairing,
   updateMesh: () => updateMesh,
@@ -3399,12 +3434,26 @@ function removeMagiKindPanel(kind) {
   saveMeshConfig(stored);
   return true;
 }
+function getDifficultyBrains() {
+  const stored = loadMeshConfig().difficultyBrains;
+  const normalized = normalizeDifficultyBrainMap(stored);
+  return Object.keys(normalized).length > 0 ? normalized : { ...DEFAULT_DIFFICULTY_BRAINS };
+}
+function setDifficultyBrains(map) {
+  const normalized = normalizeDifficultyBrainMap(map);
+  const stored = loadMeshConfig();
+  if (Object.keys(normalized).length > 0) stored.difficultyBrains = normalized;
+  else delete stored.difficultyBrains;
+  saveMeshConfig(stored);
+  return normalized;
+}
 var mergeMeshPolicy, MAGI_KIND_PANEL_KINDS, MAX_MAGI_KIND_SLOTS;
 var init_mesh_config = __esm({
   "src/config/mesh-config.ts"() {
     "use strict";
     init_hash();
     init_config();
+    init_dist();
     init_repo_mesh_types();
     init_mesh_host_ownership();
     mergeMeshPolicy = mergeAndNormalizePolicy;
@@ -3504,6 +3553,7 @@ Default branch: \`${mesh.defaultBranch}\`` : ""}`);
     if (operatingNotes) sections.push(operatingNotes);
   }
   sections.push(buildPolicySection(mergeAndNormalizePolicy(void 0, mesh.policy)));
+  sections.push(buildBrainPresetsSection());
   sections.push(TOOLS_SECTION);
   sections.push(TOOL_EXPOSURE_PREFLIGHT_SECTION);
   sections.push(WORKFLOW_SECTION);
@@ -3692,6 +3742,34 @@ function truncateNote(text) {
   if (text.length <= OPERATING_NOTE_MAX_CHARS) return text;
   return `${text.slice(0, OPERATING_NOTE_MAX_CHARS).trimEnd()}\u2026 [truncated]`;
 }
+function buildBrainPresetsSection() {
+  let brains;
+  try {
+    brains = getDifficultyBrains();
+  } catch {
+    brains = {};
+  }
+  const lines = [
+    "## Brain presets",
+    "",
+    "When you pass `difficulty` on `mesh_enqueue_task`, it resolves to this model / thinking level (an explicit model/thinkingLevel on the task overrides it). Pick easy for trivial work to save tokens, difficult for hard reasoning.",
+    ""
+  ];
+  for (const key2 of MESH_TASK_DIFFICULTIES) {
+    const slot = brains[key2];
+    if (!slot || !slot.provider && !slot.model && !slot.thinkingLevel) {
+      lines.push(`- **${key2}**: (no preset \u2014 ordinary routing)`);
+      continue;
+    }
+    const parts = [
+      slot.provider ? `provider: \`${slot.provider}\`` : "",
+      slot.model ? `model: \`${slot.model}\`` : "",
+      slot.thinkingLevel ? `thinking: \`${slot.thinkingLevel}\`` : ""
+    ].filter(Boolean).join(" | ");
+    lines.push(`- **${key2}**: ${parts}`);
+  }
+  return lines.join("\n");
+}
 function buildPolicySection(policy) {
   const rules = [];
   if (policy.requirePreTaskCheckpoint) rules.push("- Create a git checkpoint **before** starting each task");
@@ -3720,6 +3798,7 @@ function buildRulesSection(coordinatorCliType) {
 - **Front-load task messages.** Include everything the agent needs (files, problem, expected fix) in \`mesh_enqueue_task\` / \`mesh_send_task\`. Append a structured result request at the end: ask the worker to conclude with a JSON block containing \`status\`, \`changedFiles\`, \`gitStatus\`, \`validationResults\`, \`errors\`, \`nextAction\`. The daemon parses this automatically; you can read it from \`mesh_task_history\`.
 - **Reuse idle sessions.** For follow-up, retry, commit/push, or cleanup on the same issue, send only the delta to the existing idle session. Start fresh only for independent work, provider mismatch, transcript contamination, or required worktree isolation.
 - **Worktree affinity.** A worktree is a durable per-branch workspace; keep all of a branch's code_change/fix/review work on its worktree node by targeting \`required_tags: ["worktree=<branch>"]\` or \`target_node_id\`. Get the id/branch from the \`mesh_clone_node\` result or a live \`mesh_status\` \u2014 the Configured Nodes snapshot won't list a worktree cloned after launch. Untargeted same-branch follow-ups drift to the base node. Only \`convergence\` (merge/push) runs on the base, never pinned to the worktree.
+- **Classify task difficulty to save tokens.** For each task you enqueue, judge its execution difficulty and pass \`difficulty\`: \`easy\` (extraction, renames, doc tweaks, trivial fixes), \`medium\` (ordinary feature/bugfix work), \`difficult\` (architecture, tricky debugging, multi-file refactors, subtle reasoning), or \`freeform\`. The mesh's per-difficulty brain preset then runs easy tasks on a cheaper model at low reasoning effort and hard tasks on a stronger model at high effort \u2014 real token savings on simple work. The current presets are shown in the "Brain presets" section below. You may still pass an explicit \`model\`/\`thinkingLevel\` to override the preset for one task.
 - **Respect explicit provider requests.** Map: Hermes \u2192 \`hermes-cli\`, Claude/Claude Code \u2192 \`claude-cli\`, Codex \u2192 \`codex-cli\`, Gemini \u2192 \`gemini-cli\`, Antigravity \u2192 \`antigravity-cli\`. Never substitute the coordinator's own runtime.
 - **Verify via git, not source.** Use \`mesh_git_status\` to confirm side effects. Treat agent summaries as self-reports, not verification.
 - **Limit parallelism.** Start with 1\u20132 tasks; scale only on success. Never duplicate a session because \`mesh_read_chat\` shows no final message while tool/terminal activity is ongoing. This caps *concurrent* load \u2014 it does not mean serialize independent work: when a new, independent request arrives and there is headroom under \`maxParallelTasks\`, dispatch it right away rather than waiting for an in-flight task or a user nudge (read-only diagnosis especially, since it has no merge cost).
@@ -3746,6 +3825,8 @@ var init_coordinator_prompt = __esm({
   "src/mesh/coordinator-prompt.ts"() {
     "use strict";
     init_repo_mesh_types();
+    init_mesh_config();
+    init_dist();
     PROMPT_SOFT_CAP_BYTES = 60 * 1024;
     OPERATING_NOTES_PROMPT_CAP = 20;
     OPERATING_NOTE_MAX_CHARS = 300;
@@ -5741,6 +5822,18 @@ function enqueueTask(meshId, message, opts) {
   const priority = normalizeMeshTaskPriority(opts?.priority);
   const notBefore = resolveNotBefore(opts?.notBefore);
   const maxRetries = typeof opts?.maxRetries === "number" && Number.isFinite(opts.maxRetries) && opts.maxRetries >= 0 ? Math.floor(opts.maxRetries) : void 0;
+  let effectiveModel = typeof opts?.model === "string" && opts.model.trim() ? opts.model.trim() : void 0;
+  let effectiveThinkingLevel = typeof opts?.thinkingLevel === "string" && opts.thinkingLevel.trim() ? opts.thinkingLevel.trim() : void 0;
+  if (isMeshTaskDifficulty(opts?.difficulty)) {
+    try {
+      const preset = getDifficultyBrains()[opts.difficulty];
+      if (preset) {
+        if (!effectiveModel && preset.model) effectiveModel = preset.model;
+        if (!effectiveThinkingLevel && preset.thinkingLevel) effectiveThinkingLevel = preset.thinkingLevel;
+      }
+    } catch {
+    }
+  }
   const result = withQueueLock(meshId, () => {
     if (MeshRuntimeStore.getInstance().findQueueEntryById(meshId, id)) {
       throw new Error(`duplicate_task_id: task '${id}' already exists in mesh '${meshId}'`);
@@ -5772,7 +5865,8 @@ function enqueueTask(meshId, message, opts) {
       ...maxRetries !== void 0 ? { maxRetries } : {},
       ...typeof opts?.missionId === "string" && opts.missionId.trim() ? { missionId: opts.missionId.trim() } : {},
       ...typeof opts?.consensusGroupId === "string" && opts.consensusGroupId.trim() ? { consensusGroupId: opts.consensusGroupId.trim() } : {},
-      ...typeof opts?.model === "string" && opts.model.trim() ? { model: opts.model.trim() } : {},
+      ...effectiveModel ? { model: effectiveModel } : {},
+      ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {},
       ...typeof opts?.sourceCoordinatorSessionId === "string" && opts.sourceCoordinatorSessionId.trim() ? { sourceCoordinatorSessionId: opts.sourceCoordinatorSessionId.trim() } : {},
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -7346,6 +7440,27 @@ var init_mesh_runtime_store = __esm({
         `).get(meshId, taskId);
         return !!row;
       }
+      /**
+       * DELIVERED-NOT-CONSUMED re-drive support: true when at least one delivery record for
+       * the task has reached a CONSUMED status ('acked' / 'completed'). Distinct from
+       * {@link taskHasConfirmedDelivery} ('delivered' | 'acked' | 'completed'): a delivery is
+       * flipped to 'delivered' the instant the transport hands the dispatch off, but only
+       * flipped to 'acked' when the worker's agent:generating_started event arrives (see the
+       * generating_started handler in mesh-event-forwarding) — i.e. when the session has
+       * actually begun the turn. That distinction is the cross-daemon consumption signal the
+       * short-grace re-drive uses: a row whose delivery is 'delivered' but never 'acked' was
+       * handed to a REMOTE worker that never started generating — the remote autoLaunch
+       * delivered≠consumed gap — even when the session's busy verdict is UNKNOWN (not locally
+       * observable). Indexed by (mesh_id, task_id).
+       */
+      taskDeliveryConsumed(meshId, taskId) {
+        const row = this.db.prepare(`
+            SELECT 1 FROM mesh_session_delivery
+            WHERE mesh_id = ? AND task_id = ? AND status IN ('acked','completed')
+            LIMIT 1
+        `).get(meshId, taskId);
+        return !!row;
+      }
       expireStaleSessionDeliveries(meshId) {
         const now = (/* @__PURE__ */ new Date()).toISOString();
         this.db.prepare(`
@@ -8438,7 +8553,8 @@ function routeV2EventsForDrainer(events, drainer, ctx) {
     }
     if (validated.scope !== "unicast") {
       if (validated.scope === "broadcast" && isTerminalTaskEvent(validated.event)) {
-        if (identityDeliversTo(validated.dispatchedBy, drainer)) {
+        const deliverSelfFallback = event.dispatchedBySelfFallback && daemonIdsEquivalent(validated.dispatchedBy.daemonId, drainer.daemonId);
+        if (deliverSelfFallback || identityDeliversTo(validated.dispatchedBy, drainer)) {
           ctx.batchSeen.add(eventId);
           bump("v2Delivered");
           kept.push(event);
@@ -8710,13 +8826,15 @@ function stampPendingEventV2(event, hint) {
     scope: hint?.scope ?? (selfFallback ? "broadcast" : void 0)
   });
   if (!stamp) return event;
+  const dispatchedBySelfFallback = selfFallback && stamp.scope === "broadcast";
   return {
     ...event,
     protocolVersion: stamp.protocolVersion,
     eventId: stamp.eventId,
     scope: stamp.scope,
     dispatchedBy: stamp.dispatchedBy,
-    ...stamp.intendedFor ? { intendedFor: stamp.intendedFor } : {}
+    ...stamp.intendedFor ? { intendedFor: stamp.intendedFor } : {},
+    ...dispatchedBySelfFallback ? { dispatchedBySelfFallback: true } : {}
   };
 }
 function readCoordinatorIdentityFromWire(raw) {
@@ -15240,6 +15358,24 @@ function getMeshWithCache(components, meshId) {
   if (!cachedMesh) return localMesh;
   return mergeInlineCacheOnlyNodes(localMesh, cachedMesh);
 }
+function bootstrapEpochMs(bootstrap) {
+  const raw = readNonEmptyString2(bootstrap?.startedAt) || readNonEmptyString2(bootstrap?.completedAt);
+  if (!raw) return 0;
+  const parsed = Date.parse(raw);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function inlineBootstrapIsFresher(inlineBootstrap, configBootstrap) {
+  const inlineStatus = readNonEmptyString2(inlineBootstrap?.status);
+  if (!inlineStatus) return false;
+  const configStatus = readNonEmptyString2(configBootstrap?.status);
+  const inlineTerminal = BOOTSTRAP_TERMINAL_STATUSES.has(inlineStatus);
+  const configTerminal = !!configStatus && BOOTSTRAP_TERMINAL_STATUSES.has(configStatus);
+  if (configTerminal) {
+    return inlineTerminal && inlineStatus !== configStatus && bootstrapEpochMs(inlineBootstrap) > bootstrapEpochMs(configBootstrap);
+  }
+  if (inlineTerminal) return true;
+  return bootstrapEpochMs(inlineBootstrap) > bootstrapEpochMs(configBootstrap);
+}
 function mergeInlineCacheOnlyNodes(localMesh, cachedMesh) {
   const localNodes = Array.isArray(localMesh?.nodes) ? localMesh.nodes : [];
   const cachedNodes = Array.isArray(cachedMesh?.nodes) ? cachedMesh.nodes : [];
@@ -15249,8 +15385,23 @@ function mergeInlineCacheOnlyNodes(localMesh, cachedMesh) {
     if (!cachedId) return false;
     return !localNodes.some((localNode) => meshNodeIdMatches(localNode, cachedId));
   });
-  if (!cacheOnly.length) return localMesh;
-  return { ...localMesh, nodes: [...localNodes, ...cacheOnly] };
+  let overlaidLocalNodes = localNodes;
+  let overlaid = false;
+  for (let i = 0; i < localNodes.length; i++) {
+    const localNode = localNodes[i];
+    const localId = readMeshNodeId(localNode);
+    if (!localId) continue;
+    const inlineMatch = cachedNodes.find((cachedNode) => meshNodeIdMatches(cachedNode, localId));
+    if (!inlineMatch) continue;
+    if (!inlineBootstrapIsFresher(inlineMatch.worktreeBootstrap, localNode.worktreeBootstrap)) continue;
+    if (!overlaid) {
+      overlaidLocalNodes = [...localNodes];
+      overlaid = true;
+    }
+    overlaidLocalNodes[i] = { ...localNode, worktreeBootstrap: inlineMatch.worktreeBootstrap };
+  }
+  if (!cacheOnly.length && !overlaid) return localMesh;
+  return { ...localMesh, nodes: [...overlaidLocalNodes, ...cacheOnly] };
 }
 function warnDispatchWarmupGetterMissingOnce(daemonId) {
   if (dispatchWarmupGetterMissingWarned.has(daemonId)) return;
@@ -16120,7 +16271,9 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
               settings: remoteSettings,
               // MAGI-KIND-PANEL model axis: forward the task's model override so the
               // remote worker session launches with it (initialModel). Best-effort.
-              ...typeof task.model === "string" && task.model.trim() ? { initialModel: task.model.trim() } : {}
+              ...typeof task.model === "string" && task.model.trim() ? { initialModel: task.model.trim() } : {},
+              // BRAIN-ROUTING thinking axis: forward the task's thinking level (initialThinkingLevel).
+              ...typeof task.thinkingLevel === "string" && task.thinkingLevel.trim() ? { initialThinkingLevel: task.thinkingLevel.trim() } : {}
             });
           } catch (e) {
             markAutoLaunch(meshId, task.id, { status: "failed", reason: `remote_launch_dispatch_failed: ${e?.message || String(e)}`, nodeId, providerType: resolved.providerType });
@@ -16149,7 +16302,9 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
           settings: launchSettings,
           // MAGI-KIND-PANEL model axis: local launch forwards the task's model
           // override as initialModel (CLI → modelLaunchArgs; ACP → setConfigOption).
-          ...typeof task.model === "string" && task.model.trim() ? { initialModel: task.model.trim() } : {}
+          ...typeof task.model === "string" && task.model.trim() ? { initialModel: task.model.trim() } : {},
+          // BRAIN-ROUTING thinking axis: forward the task's thinking level (initialThinkingLevel).
+          ...typeof task.thinkingLevel === "string" && task.thinkingLevel.trim() ? { initialThinkingLevel: task.thinkingLevel.trim() } : {}
         });
         if (!launchResult?.success) {
           const reason = launchResult?.error || "launch_cli_failed";
@@ -16387,7 +16542,7 @@ function runIdleMaintenanceThenAssignQueue(components, args) {
     });
   });
 }
-var IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, DISPATCH_CONFIRM_TIMEOUT_MS, DISPATCH_CONNECT_TIMEOUT_MS, dispatchWarmupGetterMissingWarned, LOCAL_LAUNCH_READY_TIMEOUT_MS, LOCAL_LAUNCH_READY_POLL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES, AUTO_LAUNCH_REMOTE_IDLE_TTL_MS, autoLaunchAwaitClaimBackoff, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX, ACTIONABLE_SKIP_REASON_PREFIXES, TRANSIENT_TARGET_NODE_BOOTSTRAP_PENDING_REASON, lastActionableSkipNotified;
+var IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, BOOTSTRAP_TERMINAL_STATUSES, DISPATCH_CONFIRM_TIMEOUT_MS, DISPATCH_CONNECT_TIMEOUT_MS, dispatchWarmupGetterMissingWarned, LOCAL_LAUNCH_READY_TIMEOUT_MS, LOCAL_LAUNCH_READY_POLL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES, AUTO_LAUNCH_REMOTE_IDLE_TTL_MS, autoLaunchAwaitClaimBackoff, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX, ACTIONABLE_SKIP_REASON_PREFIXES, TRANSIENT_TARGET_NODE_BOOTSTRAP_PENDING_REASON, lastActionableSkipNotified;
 var init_mesh_queue_assignment = __esm({
   "src/mesh/mesh-queue-assignment.ts"() {
     "use strict";
@@ -16414,6 +16569,7 @@ var init_mesh_queue_assignment = __esm({
     init_mesh_task_inflight();
     IDLE_AUTO_FAST_FORWARD_THROTTLE_MS = 30 * 60 * 1e3;
     idleAutoFastForwardLastAttempt = /* @__PURE__ */ new Map();
+    BOOTSTRAP_TERMINAL_STATUSES = /* @__PURE__ */ new Set(["complete", "failed"]);
     DISPATCH_CONFIRM_TIMEOUT_MS = 12e4;
     DISPATCH_CONNECT_TIMEOUT_MS = MESH_CONNECT_TIMEOUT_MS;
     dispatchWarmupGetterMissingWarned = /* @__PURE__ */ new Set();
@@ -18709,6 +18865,8 @@ function buildAvailableProviders(providerLoader) {
       ...sourceLayer ? { sourceLayer } : {},
       ...sourceName ? { sourceName } : {},
       ...provider.providerVersion ? { providerVersion: provider.providerVersion } : {},
+      ...Array.isArray(provider.modelOptions) && provider.modelOptions.length ? { modelOptions: provider.modelOptions } : {},
+      ...Array.isArray(provider.thinkingLevelOptions) && provider.thinkingLevelOptions.length ? { thinkingLevelOptions: provider.thinkingLevelOptions } : {},
       ...provider.binary ? { binary: provider.binary } : {},
       ...provider.status ? { status: provider.status } : {},
       ...provider.details ? { details: provider.details } : {},
@@ -21045,7 +21203,34 @@ function recoverStrandedAssignedDispatches(components, meshId, store) {
   for (const row of assigned) {
     const dispatchedAtMs = Date.parse(row.dispatchTimestamp ?? "");
     if (!Number.isFinite(dispatchedAtMs)) continue;
-    if (nowMs - dispatchedAtMs < ASSIGNED_STRANDED_DEADLINE_MS) continue;
+    const ageMs = nowMs - dispatchedAtMs;
+    if (ageMs >= ASSIGNED_DELIVERED_UNCONSUMED_REDRIVE_MS && ageMs < ASSIGNED_STRANDED_DEADLINE_MS && store.taskHasConfirmedDelivery(meshId, row.id) && !store.taskDeliveryConsumed(meshId, row.id)) {
+      const terminal2 = findTerminalLedgerEvidenceForTask({ meshId, taskId: row.id });
+      if (terminal2) {
+        const status = terminal2.kind === "task_completed" ? "completed" : "failed";
+        updateTaskStatus(meshId, row.id, status);
+        continue;
+      }
+      const verdict = row.assignedSessionId ? resolveSessionBusyVerdict(components, row.assignedSessionId) : "IDLE_CONFIRMED";
+      if (verdict !== "GENERATING") {
+        const redriven = reclaimStrandedAssignedTask(meshId, row.id, {
+          reason: "delivered_not_consumed_redrive",
+          ageMs
+        });
+        if (redriven) {
+          LOG.warn("MeshReconcile", `Re-drove delivered-but-unconsumed task ${row.id} on mesh ${meshId} (node=${row.assignedNodeId ?? "?"} session=${row.assignedSessionId ?? "?"}, delivered but no generating_started in ${Math.round(ageMs / 1e3)}s, verdict ${verdict} \u2192 ${redriven.status})`);
+          traceMeshEventDrop("assigned_delivered_not_consumed_redrive", {
+            taskId: row.id,
+            sessionId: row.assignedSessionId,
+            nodeId: row.assignedNodeId,
+            meshId,
+            event: "agent:generating_started"
+          }, `delivered_not_consumed ${Math.round(ageMs / 1e3)}s \u2192 ${redriven.status}`);
+          continue;
+        }
+      }
+    }
+    if (ageMs < ASSIGNED_STRANDED_DEADLINE_MS) continue;
     const terminal = findTerminalLedgerEvidenceForTask({
       meshId,
       taskId: row.id
@@ -21560,7 +21745,7 @@ function setupMeshReconcileLoop(components) {
     }
   };
 }
-var coordinatorModalParkState, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, DELIVERED_NO_TURN_DEADLINE_MS, RECLAIM_UNKNOWN_GRACE_TICKS, deliveredNoTurnUnknownStreak, ZOMBIE_ASSIGNED_MIN_AGE_MS, STRICT_SESSION_MATCH_TTL_MS, unresolvedForwardRejectionCounts, MAX_FORWARD_REJECTIONS, UNRESOLVED_FORWARD_NUDGE_DELAY_MS, unresolvedForwardNudgeTimer, unresolvedForwardNudgeRunning;
+var coordinatorModalParkState, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, DELIVERED_NO_TURN_DEADLINE_MS, ASSIGNED_DELIVERED_UNCONSUMED_REDRIVE_MS, RECLAIM_UNKNOWN_GRACE_TICKS, deliveredNoTurnUnknownStreak, ZOMBIE_ASSIGNED_MIN_AGE_MS, STRICT_SESSION_MATCH_TTL_MS, unresolvedForwardRejectionCounts, MAX_FORWARD_REJECTIONS, UNRESOLVED_FORWARD_NUDGE_DELAY_MS, unresolvedForwardNudgeTimer, unresolvedForwardNudgeRunning;
 var init_mesh_reconcile_loop = __esm({
   "src/mesh/mesh-reconcile-loop.ts"() {
     "use strict";
@@ -21590,6 +21775,7 @@ var init_mesh_reconcile_loop = __esm({
     heldEventLedgerRecorded = /* @__PURE__ */ new Set();
     ASSIGNED_STRANDED_DEADLINE_MS = 5 * 6e4;
     DELIVERED_NO_TURN_DEADLINE_MS = 15 * 6e4;
+    ASSIGNED_DELIVERED_UNCONSUMED_REDRIVE_MS = 25e3;
     RECLAIM_UNKNOWN_GRACE_TICKS = 3;
     deliveredNoTurnUnknownStreak = /* @__PURE__ */ new Map();
     ZOMBIE_ASSIGNED_MIN_AGE_MS = 30 * 60 * 1e3;
@@ -21865,6 +22051,35 @@ var init_provider_schema = __esm({
           items: { type: "string" },
           description: "Template for expanding an initialModel selection into launch args. '{{model}}' is substituted with the model string (e.g. ['--model', '{{model}}'] \u2192 --model opus). Applied at launch when a model is requested for this CLI provider (MAGI kind-panel model axis). Absent \u2192 no launch-time model selection."
         },
+        modelOptions: {
+          type: "array",
+          items: { type: "string" },
+          description: "Suggested model values shown as dropdown options in the new-session dialog (brain-routing model axis), e.g. ['opus','sonnet','haiku']. Advisory \u2014 the UI still accepts free text, so a stale list never blocks an accepted model."
+        },
+        thinkingLaunchArgs: {
+          type: "array",
+          items: { type: "string" },
+          description: "Template for expanding an initialThinkingLevel selection into launch args (brain-routing thinking axis, parallel to modelLaunchArgs). '{{level}}' is substituted with the provider-mapped reasoning-effort value (e.g. ['--effort', '{{level}}'] \u2192 --effort high; ['-c', 'model_reasoning_effort={{level}}']). Applied at launch when a thinking level is requested. Absent \u2192 no launch-time thinking selection."
+        },
+        thinkingLevelMap: {
+          type: "object",
+          properties: {
+            low: { type: "string" },
+            medium: { type: "string" },
+            high: { type: "string" }
+          },
+          additionalProperties: false,
+          description: "Optional map from the standard thinking levels (low/medium/high) to this provider's own reasoning-effort vocabulary, used to fill {{level}} in thinkingLaunchArgs. A level absent from the map passes through unchanged."
+        },
+        thinkingLevelOptions: {
+          type: "array",
+          items: { type: "string" },
+          description: "Reasoning-effort values this provider accepts, shown as the thinking-level dropdown in the new-session dialog (e.g. ['low','medium','high','max']). Absent \u2192 the UI falls back to standard low/medium/high. Provider's own vocabulary, passed through verbatim."
+        },
+        thinkingControlId: {
+          type: "string",
+          description: "For a provider with no thinkingLaunchArgs but a runtime reasoning-effort control (e.g. hermes 'reasoning'), the controls[].id to drive at launch for the thinking level. The control's setScript is invoked with { value: <mapped level> }."
+        },
         scriptCallBudgetMs: {
           type: "integer",
           minimum: 1,
@@ -25299,6 +25514,13 @@ var init_provider_cli_adapter = __esm({
       lastScreenSnapshot = "";
       lastScreenText = "";
       lastScreenSnapshotReadAt = Number.NEGATIVE_INFINITY;
+      // (FALSEIDLE Path-C) Count of CONSECUTIVE getStatus polls that observed a
+      // gate-eligible static-idle screen (detect=idle, no modal, quiet, empty
+      // partial buffer). For a mesh/autonomous worker we require several such
+      // polls in a row before confirming static-idle (see getStatus), so a
+      // single momentarily-silent point-sample of a still-live turn cannot flip
+      // it. Reset to 0 the instant any poll is ineligible.
+      staticIdlePollStreak = 0;
       // Server log forwarding
       serverConn = null;
       logBuffer = [];
@@ -25364,6 +25586,13 @@ var init_provider_cli_adapter = __esm({
       static MAX_ACCUMULATED_BUFFER = 262144;
       parsedStatusCache = null;
       static SCREEN_SNAPSHOT_MIN_INTERVAL_MS = 250;
+      // (FALSEIDLE Path-C) Consecutive gate-eligible getStatus polls a mesh/autonomous
+      // session must show before the poll-static-idle confirm fires. 2 = one extra
+      // status tick of hysteresis: enough to reject a single momentary-silence
+      // point-sample of a still-live turn, cheap enough not to materially delay a
+      // genuine boot-wedge release (the wedge screen is stably static, so it clears
+      // every consecutive poll and confirms on the 2nd).
+      static STATIC_IDLE_POLL_CONFIRM_COUNT = 2;
       providerResolutionMeta;
       getBufferState() {
         const build = (droppedChars, maxChars) => droppedChars > 0 ? { truncated: true, droppedChars, maxChars } : void 0;
@@ -25435,6 +25664,18 @@ ${lastSnapshot}`;
       getStatusActivityHoldMs() {
         return this.timeouts.statusActivityHold;
       }
+      // (FALSEIDLE Path-C) Whether this session is a mesh worker or coordinator's
+      // own autonomous session. Mirrors CliProviderInstance.isAutonomousMeshSession
+      // over the runtimeSettings the instance mirrors down via updateRuntimeSettings
+      // (meshNodeFor / meshActiveTaskId / meshNodeId / launchedByCoordinator =
+      // isMeshWorkerSession, plus meshCoordinatorFor for the coordinator's own turn).
+      // Such a session has no human at the keyboard to correct a premature idle, so
+      // the poll-static-idle confirm is debounced for it (multiple consecutive idle
+      // polls) rather than fired on a single point-sample.
+      isAutonomousMeshSession() {
+        const s2 = this.runtimeSettings;
+        return !!(s2?.meshNodeFor || s2?.meshActiveTaskId || s2?.meshNodeId || s2?.launchedByCoordinator || s2?.meshCoordinatorFor);
+      }
       // Resolved timeouts
       timeouts;
       // Provider approval key mapping
@@ -25822,14 +26063,27 @@ ${lastSnapshot}`;
         if (allowParse && this.engine.currentStatus === "generating" && !this.engine.currentTurnScope && !this.engine.activeModal) {
           const now = Date.now();
           const quietForMs = this.lastNonEmptyOutputAt ? now - this.lastNonEmptyOutputAt : Number.MAX_SAFE_INTEGER;
+          let eligible = false;
           if (quietForMs >= this.getStatusActivityHoldMs()) {
             const screenText = this.terminalScreen.getText();
             const pollDetect = this.runDetectStatus(screenText || this.recentOutputBuffer);
             const pollModal = this.runParseApproval(screenText) || this.runParseApproval(this.recentOutputBuffer);
-            if (pollDetect === "idle" && !pollModal) {
+            const partial = this.getPartialResponse();
+            const partialPending = typeof partial === "string" && partial.trim().length > 0;
+            eligible = pollDetect === "idle" && !pollModal && !partialPending;
+          }
+          if (eligible) {
+            const requiredStreak = this.isAutonomousMeshSession() ? _ProviderCliAdapter.STATIC_IDLE_POLL_CONFIRM_COUNT : 1;
+            this.staticIdlePollStreak += 1;
+            if (this.staticIdlePollStreak >= requiredStreak) {
               this.engine.confirmPollStaticIdle("poll_static_idle");
+              this.staticIdlePollStreak = 0;
             }
+          } else {
+            this.staticIdlePollStreak = 0;
           }
+        } else {
+          this.staticIdlePollStreak = 0;
         }
         let effectiveStatus = this.projectEffectiveStatus(startupModal);
         let effectiveModal = startupModal || this.engine.activeModal;
@@ -44548,6 +44802,7 @@ var CliProviderInstance = class _CliProviderInstance {
     this.presentationMode = "chat";
     this.providerSessionId = options?.providerSessionId;
     this.launchMode = options?.launchMode || "new";
+    this.initialThinkingLevel = options?.initialThinkingLevel;
     this.onProviderSessionResolved = options?.onProviderSessionResolved;
     this.adapter = createCliAdapter(provider, workingDir, cliArgs, options?.extraEnv || {}, transportFactory);
     if (this.providerSessionId) {
@@ -44769,6 +45024,7 @@ var CliProviderInstance = class _CliProviderInstance {
   presentationMode;
   providerSessionId;
   launchMode;
+  initialThinkingLevel;
   startedAt = Date.now();
   onProviderSessionResolved;
   refreshProviderDefinition(provider) {
@@ -44797,6 +45053,7 @@ var CliProviderInstance = class _CliProviderInstance {
     });
     await this.adapter.spawn();
     await this.enforceFreshSessionLaunchIfNeeded();
+    await this.applyInitialThinkingLevelViaControl();
     this.maybeAppendRuntimeRecoveryMessage(this.adapter.getRuntimeMetadata());
     if (this.providerSessionId && this.shouldHydrateExistingProviderHistory()) {
       this.restorePersistedHistoryFromCurrentSession();
@@ -45414,6 +45671,43 @@ var CliProviderInstance = class _CliProviderInstance {
     }
     this.applyProviderResponse(parsed.payload, { phase: "immediate" });
   }
+  /**
+   * BRAIN-ROUTING (runtime-control thinking axis): for a provider that selects
+   * reasoning effort via a runtime control instead of a launch arg (e.g. hermes
+   * `reasoning`), apply the requested initialThinkingLevel after spawn by invoking
+   * that control's setScript. The provider names the control via thinkingControlId.
+   * The standard level is mapped through thinkingLevelMap first (same as the
+   * launch-arg path). Best-effort: any failure logs and never blocks launch.
+   */
+  async applyInitialThinkingLevelViaControl() {
+    const level = typeof this.initialThinkingLevel === "string" ? this.initialThinkingLevel.trim() : "";
+    if (!level) return;
+    const controlId = this.provider.thinkingControlId;
+    if (!controlId) return;
+    const controls = Array.isArray(this.provider.controls) ? this.provider.controls : [];
+    const control = controls.find((c) => c && c.id === controlId);
+    if (!control || !control.setScript) return;
+    const map = this.provider.thinkingLevelMap;
+    const mapped = map && typeof map[level] === "string" && map[level].trim() ? map[level].trim() : level;
+    try {
+      await waitForCliAdapterReady(this.adapter);
+      const raw = await this.adapter.invokeScript(control.setScript, { value: mapped });
+      const parsed = parseCliScriptResult(raw);
+      if (!parsed.success) {
+        LOG.warn("CLI", `[${this.type}] thinking control '${controlId}' set to '${mapped}' failed: ${parsed.payload?.error || "unknown"}`);
+        return;
+      }
+      const cliCommand = getCliScriptCommand(parsed.payload);
+      if (cliCommand?.type === "send_message" && cliCommand.text) {
+        await this.adapter.sendMessage(cliCommand.text);
+      } else if (cliCommand?.type === "pty_write" && cliCommand.text) {
+        await this.adapter.writeRaw(cliCommand.text + "\r");
+      }
+      LOG.info("CLI", `[${this.type}] applied thinking level '${mapped}' via control '${controlId}'`);
+    } catch (e) {
+      LOG.warn("CLI", `[${this.type}] thinking control apply threw: ${e?.message || e}`);
+    }
+  }
   completionHasFinalAssistantMessage(messages, turnStartedAt) {
     const visibleMessages = (Array.isArray(messages) ? messages : []).filter((message) => isUserFacingChatMessage(message));
     const lastVisible = visibleMessages[visibleMessages.length - 1];
@@ -48525,7 +48819,13 @@ function expandResumeArgs(template, sessionId) {
 function expandModelLaunchArgs(template, model) {
   const m = typeof model === "string" ? model.trim() : "";
   if (!m || !Array.isArray(template) || template.length === 0) return void 0;
-  return template.map((part) => part === "{{model}}" ? m : part);
+  return template.map((part) => part.includes("{{model}}") ? part.split("{{model}}").join(m) : part);
+}
+function expandThinkingLaunchArgs(template, level, levelMap) {
+  const raw = typeof level === "string" ? level.trim() : "";
+  if (!raw || !Array.isArray(template) || template.length === 0) return void 0;
+  const mapped = levelMap && typeof levelMap[raw] === "string" && levelMap[raw].trim() ? levelMap[raw].trim() : raw;
+  return template.map((part) => part.includes("{{level}}") ? part.replace("{{level}}", mapped) : part);
 }
 function readSubcommandSessionId(args, subcommands) {
   const resumeIndex = args.findIndex((arg) => subcommands.includes(arg));
@@ -48909,6 +49209,15 @@ ${installInfo}`
           LOG.warn("CLI", `[ACP] Initial model set failed: ${e?.message}`);
         }
       }
+      if (options?.initialThinkingLevel) {
+        const lvl = options.initialThinkingLevel;
+        try {
+          await acpInstance.setConfigOption("thought_level", lvl);
+          console.log(colorize("green", `  \u{1F9E0} Initial thinking level set: ${lvl}`));
+        } catch (e) {
+          LOG.warn("CLI", `[ACP] Initial thinking level set failed (provider may not support thought_level): ${e?.message}`);
+        }
+      }
       this.persistRecentActivity({
         kind: "acp",
         providerType: normalizedType,
@@ -48944,7 +49253,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
     if (initialModel && !modelLaunchArgs) {
       LOG.warn("CLI", `[${normalizedType}] initialModel='${initialModel}' requested but provider declares no modelLaunchArgs template \u2014 launching without model selection.`);
     }
-    const sessionBinding = resolveCliSessionBinding(provider, normalizedType, cliArgsWithModel, options?.resumeSessionId);
+    const initialThinkingLevel = options?.initialThinkingLevel;
+    const thinkingLaunchArgs = expandThinkingLaunchArgs(provider?.thinkingLaunchArgs, initialThinkingLevel, provider?.thinkingLevelMap);
+    const cliArgsWithBrain = thinkingLaunchArgs ? [...thinkingLaunchArgs, ...cliArgsWithModel || []] : cliArgsWithModel;
+    if (initialThinkingLevel && !thinkingLaunchArgs) {
+      LOG.warn("CLI", `[${normalizedType}] initialThinkingLevel='${initialThinkingLevel}' requested but provider declares no thinkingLaunchArgs template \u2014 launching without thinking-level selection.`);
+    }
+    const sessionBinding = resolveCliSessionBinding(provider, normalizedType, cliArgsWithBrain, options?.resumeSessionId);
     const resolvedCliArgs = sessionBinding.cliArgs;
     const instanceManager = this.deps.getInstanceManager();
     if (provider && instanceManager) {
@@ -48962,6 +49277,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
           providerSessionId: sessionBinding.providerSessionId,
           launchMode: sessionBinding.launchMode,
           extraEnv: options?.extraEnv,
+          // BRAIN-ROUTING: for a provider with no thinkingLaunchArgs but a
+          // runtime reasoning control (hermes), apply the level post-launch.
+          // The launch-arg providers (claude/codex) already consumed it at spawn.
+          ...options?.initialThinkingLevel && !provider?.thinkingLaunchArgs ? { initialThinkingLevel: options.initialThinkingLevel } : {},
           onProviderSessionResolved: ({ providerSessionId, providerName, providerType, workspace }) => {
             this.persistRecentActivity({
               kind: "cli",
@@ -49309,7 +49628,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
           {
             resumeSessionId: args?.resumeSessionId,
             settingsOverride,
-            extraEnv: delegatedLaunch ? delegatedLaunch.env : args?.env
+            extraEnv: delegatedLaunch ? delegatedLaunch.env : args?.env,
+            ...typeof args?.initialThinkingLevel === "string" && args.initialThinkingLevel.trim() ? { initialThinkingLevel: args.initialThinkingLevel.trim() } : {}
           }
         );
         return {
@@ -49754,6 +50074,12 @@ var KNOWN_PROVIDER_FIELDS = /* @__PURE__ */ new Set([
   "providerVersion",
   "status",
   "details",
+  "modelLaunchArgs",
+  "modelOptions",
+  "thinkingLaunchArgs",
+  "thinkingLevelMap",
+  "thinkingLevelOptions",
+  "thinkingControlId",
   "sendDelayMs",
   "sendKey",
   "submitStrategy",
@@ -54467,6 +54793,26 @@ var meshCrudHandlers = {
       return { success: false, error: e.message };
     }
   },
+  // ─── Brain routing: per-difficulty brain presets (machine-local) ───
+  // getDifficultyBrains returns the seeded defaults when nothing is configured,
+  // so the editor always shows a usable mapping. set replaces the whole map.
+  difficulty_brains_get: async (_ctx, _args) => {
+    try {
+      const { getDifficultyBrains: getDifficultyBrains2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+      return { success: true, difficultyBrains: getDifficultyBrains2() };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  },
+  difficulty_brains_set: async (_ctx, args) => {
+    try {
+      const { setDifficultyBrains: setDifficultyBrains2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+      const difficultyBrains = setDifficultyBrains2(args?.difficultyBrains);
+      return { success: true, difficultyBrains };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  },
   add_mesh_node: async (ctx, args) => {
     const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
     const workspace = typeof args?.workspace === "string" ? args.workspace.trim() : "";