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

package/dist/mesh/mesh-events-pending.d.ts

@@ -34,6 +34,18 @@ export interface PendingMeshCoordinatorEvent {
     dispatchedBy?: CoordinatorIdentity;
     /** Present only for unicast scope: the coordinator this event is addressed to. */
     intendedFor?: CoordinatorIdentity;
+    /**
+     * True when this event was stamped as a broadcast SOLELY because no owning
+     * coordinator identity was resolvable at emit time (self-fallback: dispatchedBy
+     * is THIS daemon's own machineId, not a real coordinator). Such a broadcast has
+     * no owner, so the MAGI-REPLICA-COMPLETION-EVENT-LEAK guard — which only exists
+     * to stop a NON-owner coordinator from consuming an OWNED terminal event — must
+     * not apply: an ownerless terminal broadcast is a genuine "deliver to any
+     * coordinator that drains on this machine" event and identity-matching its
+     * self-id dispatchedBy against the drainer would wrongly route it away.
+     * Absent (undefined/false) on a normally-owned event → the leak guard applies.
+     */
+    dispatchedBySelfFallback?: boolean;
 }
 /**
  * Optional emit-time hint passed to queuePendingMeshCoordinatorEvent so a call

package/dist/mesh/mesh-runtime-store.d.ts

@@ -239,6 +239,20 @@ export declare class MeshRuntimeStore {
      * watchdog's). Indexed by (mesh_id, task_id).
      */
     taskHasConfirmedDelivery(meshId: string, taskId: string): boolean;
+    /**
+     * 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: string, taskId: string): boolean;
     expireStaleSessionDeliveries(meshId: string): void;
     deleteSessionDeliveries(meshId: string): void;
     /**

package/dist/mesh/mesh-work-queue.d.ts

@@ -119,6 +119,13 @@ export interface MeshWorkQueueEntry {
      * that cannot honor the model still runs the task (never a fatal launch error).
      */
     model?: string;
+    /**
+     * BRAIN-ROUTING (thinking axis): standard reasoning level ('low'|'medium'|'high')
+     * for the session that executes this task. When the task auto-launches, this is
+     * passed to launch_cli as `initialThinkingLevel` (CLI → thinkingLaunchArgs; ACP →
+     * setConfigOption('thought_level')). Rides in payload JSON. Best-effort like model.
+     */
+    thinkingLevel?: string;
     /**
      * M1: why this task is held back (e.g. "dependency_failed:<taskId>").
      * Only set by the system on dependency failure under the 'block' policy;
@@ -241,6 +248,16 @@ export declare function enqueueTask(meshId: string, message: string, opts?: {
     consensusGroupId?: string;
     /** MAGI-KIND-PANEL: model override forwarded to the executing session's launch (initialModel). */
     model?: string;
+    /** BRAIN-ROUTING: standard thinking level forwarded to launch (initialThinkingLevel). */
+    thinkingLevel?: string;
+    /**
+     * BRAIN-ROUTING: task execution difficulty ('easy'|'medium'|'difficult'|
+     * 'freeform'). When set, the mesh's difficulty→brain preset fills in model /
+     * thinkingLevel that were not passed explicitly (an explicit model/thinkingLevel
+     * wins). Purely a convenience resolver — the stored task still carries the
+     * resolved model/thinkingLevel, so downstream launch is unchanged.
+     */
+    difficulty?: string;
     /** Explicit task id for batch/template flows (M5). Random UUID when omitted. */
     id?: string;
     /** (3) Originating coordinator session id (for session-anchored completion routing). */

package/dist/providers/cli-provider-instance.d.ts

@@ -155,12 +155,17 @@ export declare class CliProviderInstance implements ProviderInstance {
     private presentationMode;
     private providerSessionId?;
     private launchMode;
+    private initialThinkingLevel?;
     private readonly startedAt;
     private onProviderSessionResolved?;
     constructor(provider: ProviderModule, workingDir: string, cliArgs?: string[], instanceId?: string, transportFactory?: PtyTransportFactory, options?: {
         providerSessionId?: string;
         launchMode?: 'new' | 'resume' | 'manual';
         extraEnv?: Record<string, string>;
+        /** BRAIN-ROUTING: standard thinking level to apply post-launch via the
+         *  provider's thinkingControlId (runtime-control providers like hermes).
+         *  Providers using thinkingLaunchArgs get it at spawn instead and ignore this. */
+        initialThinkingLevel?: string;
         onProviderSessionResolved?: (info: {
             instanceId: string;
             providerType: string;
@@ -321,6 +326,15 @@ export declare class CliProviderInstance implements ProviderInstance {
      */
     private lastCompletionSummary;
     private enforceFreshSessionLaunchIfNeeded;
+    /**
+     * 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.
+     */
+    private applyInitialThinkingLevelViaControl;
     private completionHasFinalAssistantMessage;
     private recordPendingTranscriptProbe;
     /**

package/dist/providers/contracts.d.ts

@@ -499,6 +499,53 @@ export interface ProviderModule {
      * request never fails a launch). Absent → no launch-time model selection for CLI.
      */
     modelLaunchArgs?: string[];
+    /**
+     * BRAIN-ROUTING (model axis): suggested model values for this provider, surfaced
+     * as dropdown options in the new-session dialog (e.g. claude ['opus','sonnet',
+     * 'haiku']; codex ['gpt-5.5','gpt-5-codex']). Advisory only — the UI allows free
+     * text too, so the list going stale never blocks a model the provider accepts.
+     */
+    modelOptions?: string[];
+    /**
+     * BRAIN-ROUTING (thinking axis): template for expanding an `initialThinkingLevel`
+     * selection into launch args for a CLI provider, parallel to modelLaunchArgs.
+     * `{{level}}` is substituted with the provider-appropriate reasoning-effort value
+     * (already mapped from the standard low|medium|high level, see thinkingLevelMap).
+     * Examples: claude-cli `['--effort', '{{level}}']` → `--effort high`; codex-cli
+     * `['-c', 'model_reasoning_effort={{level}}']`. Applied at session launch when
+     * `initialThinkingLevel` is passed AND this provider is a plain CLI. A CLI provider
+     * with no template silently ignores the thinking level (best-effort; never fails a
+     * launch). ACP providers instead route thinking through setConfigOption('thought_level').
+     */
+    thinkingLaunchArgs?: string[];
+    /**
+     * BRAIN-ROUTING (thinking axis): optional per-provider mapping from the standard
+     * thinking levels (`low`|`medium`|`high`) to this provider's own reasoning-effort
+     * vocabulary, used to fill `{{level}}` in thinkingLaunchArgs. e.g. claude-cli might
+     * map `{ high: 'max' }`; codex-cli `{ high: 'xhigh' }`. A level absent from the map
+     * passes through unchanged (so `medium` → `medium` by default).
+     */
+    thinkingLevelMap?: Partial<Record<'low' | 'medium' | 'high', string>>;
+    /**
+     * BRAIN-ROUTING (thinking axis): the reasoning-effort values this provider actually
+     * accepts, surfaced as the thinking-level dropdown options in the new-session
+     * dialog (e.g. claude ['low','medium','high','max']; codex ['minimal','low',
+     * 'medium','high','xhigh']). Absent → the UI falls back to the standard
+     * low/medium/high. These are the provider's OWN vocabulary and are passed through
+     * verbatim as initialThinkingLevel (not remapped by thinkingLevelMap, which only
+     * translates the mesh's standard low/medium/high presets).
+     */
+    thinkingLevelOptions?: string[];
+    /**
+     * BRAIN-ROUTING (thinking axis, runtime-control providers): the `controls[].id`
+     * of a runtime reasoning-effort control to drive for the thinking level when the
+     * provider has no `thinkingLaunchArgs` (e.g. hermes-cli's `reasoning` select,
+     * which types `/reasoning <level>` into the PTY via its setScript). At launch,
+     * initialThinkingLevel (after thinkingLevelMap) is applied by invoking that
+     * control's setScript with `{ value: <level> }`. Ignored if the id doesn't match a
+     * control. Providers that use thinkingLaunchArgs don't need this.
+     */
+    thinkingControlId?: string;
     /** Delay before submitting typed CLI input (provider-specific TUI tuning) */
     sendDelayMs?: number;
     /** Submit key used after typing into CLI PTY (default: carriage return) */

package/dist/repo-mesh-types.d.ts

@@ -13,7 +13,7 @@
 import type { GitRepoStatus, GitCompactSummary } from './git/git-types.js';
 import type { MeshMissionSummary, MeshMissionSlimSummary } from './mesh/mesh-missions.js';
 import type { MeshMagiActivitySummary } from './mesh/mesh-magi-status.js';
-import type { MagiKindPanelMap } from '@adhdev/mesh-shared';
+import type { MagiKindPanelMap, DifficultyBrainMap } from '@adhdev/mesh-shared';
 export interface RepoMesh {
     id: string;
     name: string;
@@ -555,6 +555,15 @@ export interface LocalMeshConfig {
      * Optional; absent on pre-feature configs.
      */
     magiKindPanels?: MagiKindPanelMap;
+    /**
+     * BRAIN-ROUTING: per-task-difficulty brain presets (machine-local), sibling of
+     * magiKindPanels. Keyed by difficulty (easy / medium / difficult / freeform);
+     * each maps to a BrainSlot (provider? / model? / thinkingLevel?). The coordinator
+     * classifies a task's difficulty at enqueue; the matching preset fills in the
+     * task's model / thinking level (an explicit task value wins). Optional; a mesh
+     * with none seeded uses DEFAULT_DIFFICULTY_BRAINS on first read.
+     */
+    difficultyBrains?: DifficultyBrainMap;
 }
 export interface LocalMeshEntry {
     id: string;

package/dist/shared-types.d.ts

@@ -420,6 +420,10 @@ export interface AvailableProviderInfo {
     lastVerification?: MachineProviderCheckResult;
     /** Provider-declared Repo Mesh coordinator/MCP behavior. */
     meshCoordinator?: ProviderMeshCoordinatorConfig;
+    /** BRAIN-ROUTING: suggested model values for the new-session model dropdown. */
+    modelOptions?: string[];
+    /** BRAIN-ROUTING: reasoning-effort values for the new-session thinking dropdown. */
+    thinkingLevelOptions?: string[];
     /**
      * Provider trust classification — derived from the on-disk layer the
      * manifest came from and the shape of the manifest. Dashboards use

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.483",
+  "version": "0.9.82-rc.484",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -47,8 +47,8 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.483",
-    "@adhdev/session-host-core": "0.9.82-rc.483",
+    "@adhdev/mesh-shared": "0.9.82-rc.484",
+    "@adhdev/session-host-core": "0.9.82-rc.484",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/commands/cli-manager.ts

@@ -276,6 +276,10 @@ type CliStartOptions = {
     resumeSessionId?: string;
     settingsOverride?: Record<string, any>;
     extraEnv?: Record<string, string>;
+    /** BRAIN-ROUTING thinking axis: standard level ('low'|'medium'|'high') applied
+     *  at launch via the provider's thinkingLaunchArgs (CLI) or setConfigOption
+     *  ('thought_level', ACP). Best-effort — ignored by providers with no support. */
+    initialThinkingLevel?: string;
 };
 
 const DEFAULT_COORDINATOR_DELEGATED_ENV_UNSETS = [
@@ -420,10 +424,32 @@ function expandResumeArgs(template: string[] | undefined, sessionId: string): st
  * there is no template or no model (a model request without a template is a no-op —
  * see startSession, where the caller logs the skip). MAGI kind-panel model axis.
  */
-function expandModelLaunchArgs(template: string[] | undefined, model: string | undefined): string[] | undefined {
+export function expandModelLaunchArgs(template: string[] | undefined, model: string | undefined): string[] | undefined {
     const m = typeof model === 'string' ? model.trim() : '';
     if (!m || !Array.isArray(template) || template.length === 0) return undefined;
-    return template.map((part) => part === '{{model}}' ? m : part);
+    // Substitute {{model}} anywhere in a token, not only when it is the whole token,
+    // so templates like ['-c', 'model={{model}}'] (codex) expand as well as the
+    // standalone ['--model', '{{model}}'] (claude) form.
+    return template.map((part) => part.includes('{{model}}') ? part.split('{{model}}').join(m) : part);
+}
+
+/**
+ * Expand a provider's `thinkingLaunchArgs` template with the requested thinking
+ * level, parallel to expandModelLaunchArgs. The standard level ('low'|'medium'|
+ * 'high') is first mapped through the provider's `thinkingLevelMap` (a level absent
+ * from the map passes through unchanged), then substituted into every `{{level}}`
+ * token. Returns undefined when there is no template or no level (best-effort; a
+ * thinking request without a template is a no-op). BRAIN-ROUTING thinking axis.
+ */
+export function expandThinkingLaunchArgs(
+    template: string[] | undefined,
+    level: string | undefined,
+    levelMap: Partial<Record<string, string>> | undefined,
+): string[] | undefined {
+    const raw = typeof level === 'string' ? level.trim() : '';
+    if (!raw || !Array.isArray(template) || template.length === 0) return undefined;
+    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: string[], subcommands: string[]): string | undefined {
@@ -708,6 +734,9 @@ export class DaemonCliManager {
             providerSessionId?: string;
             launchMode?: CliLaunchMode;
             extraEnv?: Record<string, string>;
+            /** BRAIN-ROUTING: post-launch thinking level for runtime-control providers
+             *  (e.g. hermes reasoning). Passed through to the instance. */
+            initialThinkingLevel?: string;
             /**
              * On an attach (attachExisting=true), the real spawn time (ms epoch) of the
              * session-host runtime being restored — a PAST timestamp. Used to restore the
@@ -956,6 +985,19 @@ export class DaemonCliManager {
                 }
             }
 
+ // Brain routing thinking axis for ACP: route the standard level through the
+ // agent's thought_level config option. Best-effort — throws if the agent declares
+ // no thought_level category (see setConfigOption), so we swallow and warn.
+            if (options?.initialThinkingLevel) {
+                const lvl = options.initialThinkingLevel;
+                try {
+                    await acpInstance.setConfigOption('thought_level', lvl);
+                    console.log(colorize('green', `  🧠 Initial thinking level set: ${lvl}`));
+                } catch (e: any) {
+                    LOG.warn('CLI', `[ACP] Initial thinking level set failed (provider may not support thought_level): ${e?.message}`);
+                }
+            }
+
             this.persistRecentActivity({
                 kind: 'acp',
                 providerType: normalizedType,
@@ -1003,8 +1045,22 @@ export class DaemonCliManager {
             LOG.warn('CLI', `[${normalizedType}] initialModel='${initialModel}' requested but provider declares no modelLaunchArgs template — launching without model selection.`);
         }
 
+ // ─── Thinking axis (brain routing): expand initialThinkingLevel → launch args ───
+ // Parallel to the model axis: a plain CLI provider selects reasoning effort at spawn
+ // via the manifest's thinkingLaunchArgs template ('{{level}}' → the mapped level).
+ // Best-effort; a provider with no template (or no requested level) is a no-op. ACP
+ // providers route thinking through setConfigOption('thought_level') above.
+        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 — launching without thinking-level selection.`);
+        }
+
  // ─── Resolve launch options → provider session binding ───
-        const sessionBinding = resolveCliSessionBinding(provider, normalizedType, cliArgsWithModel, options?.resumeSessionId);
+        const sessionBinding = resolveCliSessionBinding(provider, normalizedType, cliArgsWithBrain, options?.resumeSessionId);
         const resolvedCliArgs = sessionBinding.cliArgs;
 
  // If InstanceManager exists, manage as CliProviderInstance unified
@@ -1024,6 +1080,10 @@ export class DaemonCliManager {
                     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',
@@ -1486,6 +1546,7 @@ export class DaemonCliManager {
                         resumeSessionId: args?.resumeSessionId,
                         settingsOverride,
                         extraEnv: delegatedLaunch ? delegatedLaunch.env : args?.env,
+                        ...(typeof args?.initialThinkingLevel === 'string' && args.initialThinkingLevel.trim() ? { initialThinkingLevel: args.initialThinkingLevel.trim() } : {}),
                     },
                 );
 

package/src/commands/med-family/mesh-crud.ts

@@ -457,6 +457,30 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
         }
     },
 
+    // ─── 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: MedFamilyContext, _args: any) => {
+        try {
+            const { getDifficultyBrains } = await import('../../config/mesh-config.js');
+            return { success: true, difficultyBrains: getDifficultyBrains() };
+        } catch (e: any) {
+            return { success: false, error: e.message };
+        }
+    },
+
+    difficulty_brains_set: async (_ctx: MedFamilyContext, args: any) => {
+        try {
+            const { setDifficultyBrains } = await import('../../config/mesh-config.js');
+            // normalizeDifficultyBrainMap (inside setDifficultyBrains) drops unknown
+            // keys and empty slots. An empty result clears the override → defaults.
+            const difficultyBrains = setDifficultyBrains(args?.difficultyBrains);
+            return { success: true, difficultyBrains };
+        } catch (e: any) {
+            return { success: false, error: e.message };
+        }
+    },
+
     add_mesh_node: async (ctx: MedFamilyContext, args: any) => {
         const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
         const workspace = typeof args?.workspace === 'string' ? args.workspace.trim() : '';

package/src/config/mesh-config.ts

@@ -22,7 +22,8 @@ import type {
     RepoMeshHostMetadata,
     RepoMeshDaemonRole,
 } from '../repo-mesh-types.js';
-import type { MagiKindPanelMap, MagiSlot, MagiTaskKind } from '@adhdev/mesh-shared';
+import type { MagiKindPanelMap, MagiSlot, MagiTaskKind, DifficultyBrainMap } from '@adhdev/mesh-shared';
+import { normalizeDifficultyBrainMap, DEFAULT_DIFFICULTY_BRAINS } from '@adhdev/mesh-shared';
 import { mergeAndNormalizePolicy } from '../repo-mesh-types.js';
 import { createDefaultMeshHostMetadata } from '../mesh/mesh-host-ownership.js';
 
@@ -743,3 +744,31 @@ export function removeMagiKindPanel(kind: string): boolean {
     saveMeshConfig(stored);
     return true;
 }
+
+// ─── Brain routing: per-difficulty brain presets (machine-local) ───
+
+/**
+ * The difficulty→brain presets, machine-local. When nothing is configured yet,
+ * returns the sensible DEFAULT_DIFFICULTY_BRAINS so the coordinator always has a
+ * usable mapping (the operator can override via setDifficultyBrains). Returns a
+ * normalized copy — never the stored reference.
+ */
+export function getDifficultyBrains(): DifficultyBrainMap {
+    const stored = loadMeshConfig().difficultyBrains;
+    const normalized = normalizeDifficultyBrainMap(stored);
+    return Object.keys(normalized).length > 0 ? normalized : { ...DEFAULT_DIFFICULTY_BRAINS };
+}
+
+/**
+ * Replace the difficulty→brain presets wholesale (the editor pushes the full map).
+ * Passing an empty/normalized-empty map clears the override, so getDifficultyBrains
+ * falls back to the defaults again. Returns the normalized, persisted map.
+ */
+export function setDifficultyBrains(map: unknown): DifficultyBrainMap {
+    const normalized = normalizeDifficultyBrainMap(map);
+    const stored = loadMeshConfig();
+    if (Object.keys(normalized).length > 0) stored.difficultyBrains = normalized;
+    else delete stored.difficultyBrains;
+    saveMeshConfig(stored);
+    return normalized;
+}

package/src/mesh/coordinator-prompt.ts

@@ -32,6 +32,8 @@ import type {
     RepoMeshNodeStatus,
 } from '../repo-mesh-types.js';
 import { mergeAndNormalizePolicy } from '../repo-mesh-types.js';
+import { getDifficultyBrains } from '../config/mesh-config.js';
+import { MESH_TASK_DIFFICULTIES } from '@adhdev/mesh-shared';
 
 /**
  * Cheap, locally-derived "what just happened" snapshot for the coordinator
@@ -279,6 +281,9 @@ Repository: \`${mesh.repoIdentity}\`${mesh.defaultBranch ? `\nDefault branch: \`
     // ── Policy ──
     sections.push(buildPolicySection(mergeAndNormalizePolicy(undefined, mesh.policy)));
 
+    // ── Brain presets (difficulty → model/thinking) ──
+    sections.push(buildBrainPresetsSection());
+
     // ── Tools ──
     sections.push(TOOLS_SECTION);
 
@@ -599,6 +604,36 @@ function truncateNote(text: string): string {
     return `${text.slice(0, OPERATING_NOTE_MAX_CHARS).trimEnd()}… [truncated]`;
 }
 
+/**
+ * Render the difficulty→brain presets so the coordinator knows what each
+ * `difficulty` value resolves to (which model / thinking level). Machine-local,
+ * read live at prompt-build time — seeded defaults when nothing is configured.
+ */
+function buildBrainPresetsSection(): string {
+    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 key of MESH_TASK_DIFFICULTIES) {
+        const slot = (brains as Record<string, { provider?: string; model?: string; thinkingLevel?: string } | undefined>)[key];
+        if (!slot || (!slot.provider && !slot.model && !slot.thinkingLevel)) {
+            lines.push(`- **${key}**: (no preset — 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(`- **${key}**: ${parts}`);
+    }
+    return lines.join('\n');
+}
+
 function buildPolicySection(policy: RepoMeshPolicy): string {
     const rules: string[] = [];
     if (policy.requirePreTaskCheckpoint) rules.push('- Create a git checkpoint **before** starting each task');
@@ -737,6 +772,7 @@ function buildRulesSection(coordinatorCliType?: string): string {
 - **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\` — 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 — 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 → \`hermes-cli\`, Claude/Claude Code → \`claude-cli\`, Codex → \`codex-cli\`, Gemini → \`gemini-cli\`, Antigravity → \`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–2 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 — 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).

package/src/mesh/mesh-events-pending.ts

@@ -75,6 +75,18 @@ export interface PendingMeshCoordinatorEvent {
     dispatchedBy?: CoordinatorIdentity;
     /** Present only for unicast scope: the coordinator this event is addressed to. */
     intendedFor?: CoordinatorIdentity;
+    /**
+     * True when this event was stamped as a broadcast SOLELY because no owning
+     * coordinator identity was resolvable at emit time (self-fallback: dispatchedBy
+     * is THIS daemon's own machineId, not a real coordinator). Such a broadcast has
+     * no owner, so the MAGI-REPLICA-COMPLETION-EVENT-LEAK guard — which only exists
+     * to stop a NON-owner coordinator from consuming an OWNED terminal event — must
+     * not apply: an ownerless terminal broadcast is a genuine "deliver to any
+     * coordinator that drains on this machine" event and identity-matching its
+     * self-id dispatchedBy against the drainer would wrongly route it away.
+     * Absent (undefined/false) on a normally-owned event → the leak guard applies.
+     */
+    dispatchedBySelfFallback?: boolean;
 }
 
 /**
@@ -419,7 +431,21 @@ function routeV2EventsForDrainer(
             // matching semantics as unicast (identityDeliversTo), so the true owner —
             // possibly addressed under a different daemon-id form — still receives it.
             if (validated.scope === 'broadcast' && isTerminalTaskEvent(validated.event)) {
-                if (identityDeliversTo(validated.dispatchedBy, drainer)) {
+                // An ownerless self-fallback broadcast (dispatchedBy is this daemon's
+                // own machineId because no coordinator identity existed at emit) has no
+                // coordinator owner — but it must still stay on ITS machine: a replica
+                // completion emitted on machine A must never fan out to a coordinator on
+                // machine B (the MAGI-REPLICA leak). So for a self-fallback event, match
+                // at the MACHINE (daemonId) level — deliver iff the drainer is on the
+                // same machine as the self-dispatcher — instead of the full
+                // identityDeliversTo (which also compares runId/session and would route
+                // the event away from a same-machine coordinator whose id form differs,
+                // the exact symptom for refine:* / agent:generating_completed reaching a
+                // stdio MCP coordinator). Non-self-fallback broadcasts keep the strict
+                // owner check.
+                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);
@@ -858,6 +884,13 @@ export function stampPendingEventV2(
     });
     if (!stamp) return event; // no coordinator identity at all (no self id) → stays a v1 event
 
+    // Mark an ownerless (self-fallback) broadcast so the drain-side leak guard can
+    // tell it apart from a genuinely owned broadcast terminal event. selfFallback is
+    // true only when no coordinator identity existed and we minted the stamp under
+    // this daemon's own machineId; a broadcast that stays broadcast for that reason
+    // has no owner to leak from and must reach whatever coordinator drains here.
+    const dispatchedBySelfFallback = selfFallback && stamp.scope === 'broadcast';
+
     return {
         ...event,
         protocolVersion: stamp.protocolVersion,
@@ -865,6 +898,7 @@ export function stampPendingEventV2(
         scope: stamp.scope,
         dispatchedBy: stamp.dispatchedBy,
         ...(stamp.intendedFor ? { intendedFor: stamp.intendedFor } : {}),
+        ...(dispatchedBySelfFallback ? { dispatchedBySelfFallback: true } : {}),
     };
 }
 

package/src/mesh/mesh-queue-assignment.ts

@@ -76,17 +76,34 @@ export function getMeshWithCache(components: DaemonComponents, meshId: string):
  *
  * Fix: union the local-config nodes with any inline-cache-ONLY nodes, so the claim
  * view matches the command (send_task) view. Base (non-worktree) nodes present in
- * local config stay config-authoritative — their entry is taken verbatim from
- * localMesh, so base node claim/matching is byte-for-byte unchanged. Only nodes
+ * local config stay config-authoritative — their STATIC fields are taken verbatim
+ * from localMesh, so base node claim/matching is byte-for-byte unchanged. Only nodes
  * that exist solely in the inline cache (the cloned worktree nodes) are appended.
  * Identity comparison uses the shared 3-form normalizer (id / nodeId / node_id),
  * identical to every other claim-path consumer — the matching logic is untouched,
  * only which nodes are visible.
+ *
+ * BOOTSTRAP-DEFER VIEW-CONSISTENCY (this fix): for a worktree node that IS registered
+ * in local config, the union previously took the config node verbatim and discarded the
+ * inline-cache entry entirely. But the inline cache holds the FRESHER runtime bootstrap
+ * state — markWorktreeBootstrapTerminalState stamps worktreeBootstrap.status='complete'
+ * synchronously into the inline cache, while local config lags behind the detached async
+ * persist chain (and on the coordinator may never receive it at all). A config-registered
+ * worktree node therefore read a permanently stale 'running' here, so
+ * shouldDeferDispatchForBootstrap deferred its claim forever. We now MERGE the inline
+ * cache's dynamic runtime bootstrap state onto the config node (config keeps its static
+ * fields; worktreeBootstrap is preferred from the inline cache when the inline entry
+ * carries a status) so the gate view sees the terminal stamp. Regression-safe: when the
+ * inline entry has no bootstrap status the config value is kept, and when bootstrap is
+ * genuinely still 'running' (no terminal stamp yet) the gate still defers — only a node
+ * whose inline stamp has actually reached a terminal state opens the gate.
  */
 function mergeInlineCacheOnlyNodes(localMesh: any, cachedMesh: any): any {
     const localNodes = Array.isArray(localMesh?.nodes) ? localMesh.nodes : [];
     const cachedNodes = Array.isArray(cachedMesh?.nodes) ? cachedMesh.nodes : [];
     if (!cachedNodes.length) return localMesh;
+    // Index inline-cache nodes by identity so we can (a) append cache-only nodes and
+    // (b) prefer the inline runtime bootstrap state on config-registered nodes.
     const cacheOnly = cachedNodes.filter((cachedNode: any) => {
         const cachedId = readMeshNodeId(cachedNode);
         // Unidentifiable cache entries can never be a claim/route target — skip them
@@ -94,8 +111,29 @@ function mergeInlineCacheOnlyNodes(localMesh: any, cachedMesh: any): any {
         if (!cachedId) return false;
         return !localNodes.some((localNode: any) => meshNodeIdMatches(localNode, cachedId));
     });
-    if (!cacheOnly.length) return localMesh;
-    return { ...localMesh, nodes: [...localNodes, ...cacheOnly] };
+    // Overlay the inline cache's fresher worktreeBootstrap state onto any config node
+    // that also exists in the inline cache. Only override when the inline entry actually
+    // carries a bootstrap status (an incomplete inline entry never masks a genuine config
+    // 'running'), mirroring the inline-first read the bootstrap gate does directly.
+    let overlaidLocalNodes: any[] = 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: any) => meshNodeIdMatches(cachedNode, localId));
+        const inlineBootstrapStatus = readNonEmptyString(inlineMatch?.worktreeBootstrap?.status);
+        if (!inlineMatch || !inlineBootstrapStatus) continue;
+        if (!overlaid) {
+            overlaidLocalNodes = [...localNodes];
+            overlaid = true;
+        }
+        // Keep the config node's static fields; prefer the inline cache's dynamic
+        // bootstrap runtime state (fresher terminal stamp).
+        overlaidLocalNodes[i] = { ...localNode, worktreeBootstrap: inlineMatch.worktreeBootstrap };
+    }
+    if (!cacheOnly.length && !overlaid) return localMesh;
+    return { ...localMesh, nodes: [...overlaidLocalNodes, ...cacheOnly] };
 }
 
 // ---------------------------------------------------------------------------
@@ -1880,6 +1918,8 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
                             // 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() } : {}),
+                            // BRAIN-ROUTING thinking axis: forward the task's thinking level (initialThinkingLevel).
+                            ...(typeof task.thinkingLevel === 'string' && task.thinkingLevel.trim() ? { initialThinkingLevel: task.thinkingLevel.trim() } : {}),
                         });
                     } catch (e: any) {
                         markAutoLaunch(meshId, task.id, { status: 'failed', reason: `remote_launch_dispatch_failed: ${e?.message || String(e)}`, nodeId, providerType: resolved.providerType });
@@ -1912,6 +1952,8 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
                     // 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() } : {}),
+                    // 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';