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

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.485",
   "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.485",
+    "@adhdev/session-host-core": "0.9.82-rc.485",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/cli-adapters/provider-cli-adapter.ts

@@ -208,6 +208,13 @@ export class ProviderCliAdapter implements CliAdapter {
     private lastScreenSnapshot = '';
     private lastScreenText = '';
     private 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.
+    private staticIdlePollStreak = 0;
 
  // Server log forwarding
     private serverConn: any = null;
@@ -287,6 +294,13 @@ export class ProviderCliAdapter implements CliAdapter {
         result: any;
     } | null = null;
     private static readonly 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).
+    private static readonly STATIC_IDLE_POLL_CONFIRM_COUNT = 2;
 
     private readonly providerResolutionMeta: ProviderResolutionMeta;
 
@@ -394,6 +408,20 @@ export class ProviderCliAdapter implements CliAdapter {
         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.
+    private isAutonomousMeshSession(): boolean {
+        const s = this.runtimeSettings;
+        return !!(s?.meshNodeFor || s?.meshActiveTaskId || s?.meshNodeId
+            || s?.launchedByCoordinator || s?.meshCoordinatorFor);
+    }
+
  // Resolved timeouts
     private readonly timeouts: Required<NonNullable<CliProviderModule['timeouts']>>;
 
@@ -956,15 +984,56 @@ export class ProviderCliAdapter implements CliAdapter {
             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) {
+                // (FALSEIDLE Path-C) Final-assistant / pending-response discriminator.
+                // Paths A and B refuse to finalize a turn whose partial-response buffer
+                // is still non-empty (getCompletedFinalizationBlock 'partial_response_pending'
+                // / completionFinalAssistantEvidence turnClosed at cli-provider-instance.ts).
+                // Path C (this poll) previously OMITTED it, so a genuinely-live but
+                // momentarily-silent turn — silent thinking, a backgrounded/long tool child,
+                // the gap between two assistant bubbles — whose currentTurnScope anchor was
+                // lost still satisfied the weaker gate and flipped to idle prematurely.
+                // Require an EMPTY partial buffer here too. getPartialResponse() returns the
+                // accumulated assistant stream while isWaitingForResponse (which
+                // applyGenerating leaves set on the boot-banner wedge too), so this does NOT
+                // reintroduce the D4b wedge: the attach/boot-banner seeds only the static
+                // ready screen — no assistant turn ever streamed — so its partial buffer is
+                // empty and the gate still releases it. A mid-turn quiet gap holds a
+                // non-empty buffer and is deferred.
+                const partial = this.getPartialResponse();
+                const partialPending = typeof partial === 'string' && partial.trim().length > 0;
+                eligible = pollDetect === 'idle' && !pollModal && !partialPending;
+            }
+            if (eligible) {
+                // (FALSEIDLE Path-C) Debounce for autonomous mesh sessions. A worker /
+                // coordinator has no human to correct a premature idle, and a single
+                // runDetectStatus point-sample can land in a live turn's momentary silence.
+                // Require STATIC_IDLE_POLL_CONFIRM_COUNT consecutive eligible polls before
+                // confirming, so the FSM must observe a sustained static-idle screen — a
+                // turn that resumes (fresh output, or a re-armed turn scope) resets the
+                // streak. The status poll runs on the 30s-idle / 5s-generating heartbeat and
+                // this getStatus gate is re-hit each dashboard status tick, so 2 confirms is
+                // ~one extra tick of hysteresis — enough to reject a one-sample silence gap
+                // without materially delaying a genuine boot-wedge release. Foreground /
+                // attended sessions keep the single-poll confirm (a human is watching Send).
+                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;

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).