@adhdev/daemon-core 0.9.82-rc.482 → 0.9.82-rc.484

package/dist/index.js

@@ -188,7 +188,7 @@ var init_repo_mesh_types = __esm({
       "checkpoint_then_continue"
     ]);
     MESH_MAX_PARALLEL_TASKS_MIN = 1;
-    MESH_MAX_PARALLEL_TASKS_MAX = 8;
+    MESH_MAX_PARALLEL_TASKS_MAX = 64;
     DEFAULT_MESH_READONLY_MULTIPLIER = 2;
   }
 });
@@ -409,10 +409,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "5c311ee659d4fe9b1638a1bb325b681ef6ecc24e" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "5c311ee6" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.482" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-08T00:15:56.441Z" : void 0);
+  const commit = readInjected(true ? "a503a00d57fbcdc84cd252c6d5caee90cfae6706" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "a503a00d" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.484" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-08T13:24:54.463Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -2771,12 +2771,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",
@@ -2917,6 +2950,7 @@ __export(mesh_config_exports, {
   createMesh: () => createMesh,
   createMeshHostPairingToken: () => createMeshHostPairingToken,
   deleteMesh: () => deleteMesh,
+  getDifficultyBrains: () => getDifficultyBrains,
   getMagiKindPanel: () => getMagiKindPanel,
   getMesh: () => getMesh,
   getMeshByRepo: () => getMeshByRepo,
@@ -2927,6 +2961,7 @@ __export(mesh_config_exports, {
   normalizeRepoIdentity: () => normalizeRepoIdentity,
   removeMagiKindPanel: () => removeMagiKindPanel,
   removeNode: () => removeNode,
+  setDifficultyBrains: () => setDifficultyBrains,
   setMagiKindPanel: () => setMagiKindPanel,
   tokenIdForManualPairing: () => tokenIdForManualPairing,
   updateMesh: () => updateMesh,
@@ -3309,6 +3344,11 @@ function updateNode(meshId, nodeId, opts) {
     node.reportedDaemonBuildVersion = opts.reportedDaemonBuildVersion.trim();
   }
   if (opts.policy) node.policy = { ...node.policy, ...opts.policy };
+  if (Object.prototype.hasOwnProperty.call(opts, "capabilities")) {
+    const tags = normalizeCapabilityTags(opts.capabilities);
+    if (tags && tags.length) node.capabilities = tags;
+    else delete node.capabilities;
+  }
   if (opts.worktreeBootstrap) node.worktreeBootstrap = opts.worktreeBootstrap;
   if (Object.prototype.hasOwnProperty.call(opts, "systemPrompt")) {
     if (opts.systemPrompt && opts.systemPrompt.trim()) {
@@ -3397,6 +3437,19 @@ 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 import_fs3, import_path3, import_crypto3, mergeMeshPolicy, MAGI_KIND_PANEL_KINDS, MAX_MAGI_KIND_SLOTS;
 var init_mesh_config = __esm({
   "src/config/mesh-config.ts"() {
@@ -3406,6 +3459,7 @@ var init_mesh_config = __esm({
     import_crypto3 = require("crypto");
     init_hash();
     init_config();
+    init_dist();
     init_repo_mesh_types();
     init_mesh_host_ownership();
     mergeMeshPolicy = mergeAndNormalizePolicy;
@@ -3502,6 +3556,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);
@@ -3601,6 +3656,21 @@ function buildNodeConfigSection(mesh) {
     }).filter(Boolean) : [];
     const providerRolesSuffix = providerRoles.length ? ` | caps: ${providerRoles.join(", ")}` : "";
     lines.push(`- ${explicitLabel} nodeId: \`${n.id}\` | workspace: \`${n.workspace}\`${n.daemonId ? ` | daemon: \`${n.daemonId}\`` : ""}${providerPriority}${providerRolesSuffix}${suffix}`);
+    const routingTags = [];
+    const custom = Array.isArray(n.capabilities) ? n.capabilities : [];
+    for (const t of custom) {
+      const s2 = typeof t === "string" ? t.trim() : "";
+      if (s2) routingTags.push(s2);
+    }
+    const tagOs = (n.userOverrides?.platform || n.reportedPlatform || "").toString().trim();
+    const tagArch = (n.userOverrides?.arch || n.reportedArch || "").toString().trim();
+    if (tagOs) routingTags.push(`os=${tagOs}`);
+    if (tagArch) routingTags.push(`arch=${tagArch}`);
+    const wtBranch = typeof n.worktreeBranch === "string" ? n.worktreeBranch.trim() : "";
+    if (n.isLocalWorktree && wtBranch) routingTags.push(`worktree=${wtBranch}`);
+    if (routingTags.length) {
+      lines.push(`  \u{1F3F7}\uFE0F routing tags: ${routingTags.map((t) => `\`${t}\``).join(", ")}`);
+    }
     const nodePrompt = typeof n.systemPrompt === "string" ? n.systemPrompt.trim() : "";
     if (nodePrompt) {
       lines.push(`  \u{1F4CC} Node instruction: ${indentFollowing(nodePrompt, "     ")}`);
@@ -3675,6 +3745,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");
@@ -3702,6 +3800,8 @@ function buildRulesSection(coordinatorCliType) {
 - **Route, don't implement.** Delegate all code reading, analysis, and execution to node agents. Never read source files or run commands in the coordinator \u2014 keep context lean.
 - **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).
@@ -3731,6 +3831,8 @@ var init_coordinator_prompt = __esm({
     os2 = __toESM(require("os"));
     path8 = __toESM(require("path"));
     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;
@@ -3791,6 +3893,7 @@ Before doing any coordinator work, confirm that the actual callable tool list in
 3. **Queue / Delegate** \u2014 The Mesh uses an autonomous pull-based Work Queue:
    a. **General Tasks**: Enqueue tasks using \`mesh_enqueue_task\`. Idle node agents will automatically pull tasks from the queue and begin working.
    b. **Node Preparation**: Reuse an existing idle session on the correct node/provider before launching a new chat/session. Call \`mesh_launch_session\` only when no suitable session exists, when the user explicitly asks for a fresh provider/session, or when branch/worktree isolation requires it. If you need branch isolation for parallel work, call \`mesh_clone_node\` to create a worktree node first.
+   b1. **Keep a branch's work on its worktree (worktree affinity).** A worktree node is a durable per-branch workspace, not a one-task throwaway \u2014 implement, review, and fix for the same branch all belong on the SAME worktree, and it lives until its work is converged (merged/pushed) and it is cleaned up. So once you clone a worktree for a branch, route every subsequent \`code_change\`/\`validation\`/fix task for that branch back to that same node: pass \`required_tags: ["worktree=<branch>"]\` or \`target_node_id: <that worktree node's id>\`. **Where to get the node id / tag:** the \`mesh_clone_node\` result returns the new node's \`id\` and \`worktreeBranch\` directly \u2014 use them immediately. The Configured Nodes list in this prompt is a launch-time snapshot and will NOT list a worktree you cloned after this session started, so do not rely on it for freshly-cloned worktrees; take the id/branch from the \`mesh_clone_node\` result, or call \`mesh_status\` to re-list the live nodes (each worktree there advertises its \`worktree=<branch>\` tag). Do NOT leave same-branch follow-ups untargeted \u2014 an untargeted task is claimed by whichever node polls first (usually the base machine node), which strands the work off the branch's worktree. The ONE exception is a \`convergence\` task (merge/push): that is base-only and must NOT be pinned to the worktree.
    c. **Targeted Tasks**: Use \`mesh_send_task\` only when you need to bypass the queue and force a specific node to execute a task immediately.
    d. For the first dispatch of a new task, provide a **complete, self-contained** instruction that includes all context the agent needs (file paths, line numbers, what to change, why). Do not send partial instructions expecting future follow-up.
    e. For a continuation of the same issue in an existing session, send a concise **delta instruction**: current verified state, the exact failed/blocked step, the newly approved action, and final reporting requirements. Do not resend the full original task or open a new chat solely to continue the same work; that wastes coordinator and worker context.
@@ -4241,6 +4344,9 @@ function shouldDeliverPendingEventToCoordinator(event, drainer) {
   if (!event.intendedFor) return false;
   return coordinatorIdentityEquals(event.intendedFor, drainer);
 }
+function isTerminalTaskEvent(eventName) {
+  return TERMINAL_TASK_EVENTS.has(eventName);
+}
 function defaultScopeForEvent(eventName) {
   if (TERMINAL_TASK_EVENTS.has(eventName) || COORDINATOR_ALERT_EVENTS.has(eventName)) return "unicast";
   return "broadcast";
@@ -4257,7 +4363,11 @@ function buildPendingEventEmitStamp(opts) {
   let scope = opts.scope ?? defaultScopeForEvent(opts.eventName);
   let intendedFor = opts.intendedFor;
   if (scope === "unicast" && !intendedFor) {
-    scope = "broadcast";
+    if (isTerminalTaskEvent(opts.eventName)) {
+      intendedFor = opts.dispatchedBy;
+    } else {
+      scope = "broadcast";
+    }
   }
   if (scope !== "unicast") intendedFor = void 0;
   return {
@@ -5718,6 +5828,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}'`);
@@ -5749,7 +5871,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()
@@ -7324,6 +7447,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(`
@@ -8412,6 +8556,17 @@ function routeV2EventsForDrainer(events, drainer, ctx) {
       continue;
     }
     if (validated.scope !== "unicast") {
+      if (validated.scope === "broadcast" && isTerminalTaskEvent(validated.event)) {
+        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);
+        } else {
+          bump("v2RoutedAway");
+        }
+        continue;
+      }
       if (shouldDeliverPendingEventToCoordinator(validated, drainer)) {
         ctx.batchSeen.add(eventId);
         bump("v2Delivered");
@@ -8675,13 +8830,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) {
@@ -15207,8 +15364,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));
+    const inlineBootstrapStatus = readNonEmptyString2(inlineMatch?.worktreeBootstrap?.status);
+    if (!inlineMatch || !inlineBootstrapStatus) 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;
@@ -16078,7 +16250,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 });
@@ -16107,7 +16281,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";
@@ -18667,6 +18843,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 } : {},
@@ -21004,7 +21182,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
@@ -21519,7 +21724,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";
@@ -21549,6 +21754,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;
@@ -21824,6 +22030,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,
@@ -40179,6 +40414,53 @@ var statusMetaHandlers = {
 
 // src/commands/low-family/coordinator-prompt.ts
 var coordinatorPromptHandlers = {
+  /**
+   * Render the coordinator system prompt for a mesh + CLI type, so the
+   * dashboard can show the operator exactly what a coordinator session
+   * receives by default. This resolves the mesh, applies its repo-mesh
+   * config, and runs the SAME buildCoordinatorSystemPrompt the launch path
+   * uses — minus the runtime-only best-effort sections (mission / recent
+   * activity / operating notes), which are launch-scope and not part of the
+   * static "default base" an operator is trying to preview here.
+   *
+   * It respects mesh-level and user-file override/append layering, so the
+   * preview reflects the effective prompt: with no overrides configured it
+   * shows the pure daemon default; with an override set it shows that.
+   */
+  coordinator_prompt_preview: async (ctx, args) => {
+    const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+    const cliType = typeof args?.cliType === "string" && args.cliType.trim() ? args.cliType.trim() : "claude-cli";
+    if (!meshId) return { success: false, error: "meshId required" };
+    try {
+      let mesh = null;
+      if (ctx.getMeshForCommand) {
+        const resolved = await ctx.getMeshForCommand(meshId);
+        mesh = resolved?.mesh ?? null;
+      }
+      if (!mesh) {
+        const { getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+        mesh = getMesh2(meshId);
+      }
+      if (!mesh) return { success: false, error: `mesh not found: ${meshId}` };
+      let effectiveMesh = mesh;
+      try {
+        const { loadRepoMeshJsonConfig: loadRepoMeshJsonConfig2, applyRepoMeshConfig: applyRepoMeshConfig2 } = await Promise.resolve().then(() => (init_mesh_json_config(), mesh_json_config_exports));
+        const workspace = typeof mesh?.workspace === "string" ? mesh.workspace : void 0;
+        if (workspace) {
+          const loaded = loadRepoMeshJsonConfig2(workspace);
+          if (loaded?.sourceType !== "invalid") {
+            effectiveMesh = applyRepoMeshConfig2(mesh, loaded?.config);
+          }
+        }
+      } catch {
+      }
+      const { buildCoordinatorSystemPrompt: buildCoordinatorSystemPrompt2 } = await Promise.resolve().then(() => (init_coordinator_prompt(), coordinator_prompt_exports));
+      const prompt = buildCoordinatorSystemPrompt2({ mesh: effectiveMesh, coordinatorCliType: cliType });
+      return { success: true, prompt, cliType, meshId, bytes: Buffer.byteLength(prompt, "utf8") };
+    } catch (error) {
+      return { success: false, error: error?.message || String(error) };
+    }
+  },
   list_coordinator_prompts: async (_ctx, _args) => {
     const fs41 = await import("fs");
     const path45 = await import("path");
@@ -44881,6 +45163,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) {
@@ -45102,6 +45385,7 @@ var CliProviderInstance = class _CliProviderInstance {
   presentationMode;
   providerSessionId;
   launchMode;
+  initialThinkingLevel;
   startedAt = Date.now();
   onProviderSessionResolved;
   refreshProviderDefinition(provider) {
@@ -45130,6 +45414,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();
@@ -45747,6 +46032,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];
@@ -48853,7 +49175,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));
@@ -49237,6 +49565,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,
@@ -49272,7 +49609,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) {
@@ -49290,6 +49633,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",
@@ -49637,7 +49984,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 {
@@ -50082,6 +50430,12 @@ var KNOWN_PROVIDER_FIELDS = /* @__PURE__ */ new Set([
   "providerVersion",
   "status",
   "details",
+  "modelLaunchArgs",
+  "modelOptions",
+  "thinkingLaunchArgs",
+  "thinkingLevelMap",
+  "thinkingLevelOptions",
+  "thinkingControlId",
   "sendDelayMs",
   "sendKey",
   "submitStrategy",
@@ -54795,6 +55149,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() : "";
@@ -54816,13 +55190,15 @@ var meshCrudHandlers = {
       const daemonId = typeof args?.daemonId === "string" && args.daemonId.trim() ? args.daemonId.trim() : void 0;
       const machineId = typeof args?.machineId === "string" && args.machineId.trim() ? args.machineId.trim() : void 0;
       const repoRoot = typeof args?.repoRoot === "string" && args.repoRoot.trim() ? args.repoRoot.trim() : void 0;
+      const capabilities = Array.isArray(args?.capabilities) ? args.capabilities.map((t) => typeof t === "string" ? t.trim() : "").filter(Boolean) : void 0;
       const node = addNode2(meshId, {
         workspace,
         ...repoRoot ? { repoRoot } : {},
         ...daemonId ? { daemonId } : {},
         ...machineId ? { machineId } : {},
         ...policy ? { policy } : {},
-        ...role ? { role } : {}
+        ...role ? { role } : {},
+        ...capabilities && capabilities.length ? { capabilities } : {}
       });
       if (!node) return { success: false, error: "Mesh not found" };
       ctx.invalidateAggregateMeshStatus(meshId);
@@ -54864,6 +55240,9 @@ var meshCrudHandlers = {
       } else if (args?.systemPrompt === null) {
         patch.systemPrompt = void 0;
       }
+      if (Array.isArray(args?.capabilities)) {
+        patch.capabilities = args.capabilities.map((t) => typeof t === "string" ? t.trim() : "").filter(Boolean);
+      }
       const node = updateNode2(meshId, nodeId, patch);
       if (!node) return { success: false, error: "Mesh node not found" };
       ctx.invalidateAggregateMeshStatus(meshId);