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

package/dist/mesh/contracts.d.ts

@@ -161,7 +161,12 @@ export declare function assertPendingMeshCoordinatorEventV2(raw: unknown, path?:
  * Decide whether a v2 pending event should be delivered to the given drainer.
  * Centralised so every drain implementation uses the same rule.
  *
- *   - 'broadcast': always delivered.
+ *   - 'broadcast': always delivered. NOTE: a terminal task event that reached the
+ *     queue as broadcast is an ownership leak (it belongs to its dispatching
+ *     coordinator). This pure helper does not have the drain-window
+ *     daemon-form/session matching semantics, so the terminal+broadcast
+ *     dispatchedBy filter is applied one layer up in the drainer (see
+ *     mesh-events-pending routeV2EventsForDrainer) where those semantics live.
  *   - 'system': never delivered to coordinators (system handler only).
  *   - 'unicast': delivered iff intendedFor matches drainer identity.
  *
@@ -170,6 +175,15 @@ export declare function assertPendingMeshCoordinatorEventV2(raw: unknown, path?:
  * are quarantined to a dedicated drain endpoint instead.
  */
 export declare function shouldDeliverPendingEventToCoordinator(event: PendingMeshCoordinatorEventV2, drainer: CoordinatorIdentity): boolean;
+/**
+ * True for a terminal task event (completion / stop / refine outcome). A terminal
+ * event belongs to exactly the coordinator that dispatched the task, so it must
+ * never fan out to sibling coordinators that did not dispatch it. Used by the
+ * emit-side stamp (to avoid downgrading an unaddressed terminal event to full
+ * broadcast) and by the drain-side filter (defense-in-depth for any terminal
+ * event that already reached the queue as broadcast).
+ */
+export declare function isTerminalTaskEvent(eventName: string): boolean;
 /**
  * Default the v2 scope for an event by its producer event name (design decision
  * §3). Terminal task events and coordinator-addressed alerts → unicast (routed
@@ -219,9 +233,18 @@ export declare function coordinatorIdentityFromEmitFields(fields: {
  * returns undefined: the event stays a v1 (unstamped) event and is broadcast-
  * treated during rollout, exactly as before — no regression, no fabricated
  * identity. When the resolved scope is 'unicast' but no `intendedFor` is
- * available, the scope is downgraded to 'broadcast' so the stamp never violates
- * the "unicast requires intendedFor" contract (a terminal event that cannot be
- * addressed to its originator is safest delivered broadly, not dropped).
+ * available, the fallback depends on the event class:
+ *
+ *   - Terminal task events (completion / stop / refine outcome) MUST NOT be
+ *     broadcast to every coordinator — a completion belongs to the coordinator
+ *     that dispatched the task, and broadcasting it makes non-owner coordinators
+ *     (e.g. sibling MAGI coordinators that never dispatched this replica's task)
+ *     act on a completion that is not theirs (MAGI-REPLICA-COMPLETION-EVENT-LEAK).
+ *     For these we address the event to `dispatchedBy` (the dispatching
+ *     coordinator) and KEEP it unicast, so the stamp stays contract-valid and the
+ *     event reaches only its originating coordinator.
+ *   - Any other unicast event with no addressable target falls back to broadcast
+ *     (contract-valid, still delivered, never dropped) — unchanged.
  */
 export declare function buildPendingEventEmitStamp(opts: {
     eventName: string;

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;
@@ -372,7 +372,7 @@ export declare function magiAutoLaunchedSessionCleanupDecision(args: {
 };
 /** Min/max bounds for the global write-task parallel cap. */
 export declare const MESH_MAX_PARALLEL_TASKS_MIN = 1;
-export declare const MESH_MAX_PARALLEL_TASKS_MAX = 8;
+export declare const MESH_MAX_PARALLEL_TASKS_MAX = 64;
 /**
  * Default multiplier applied to the write cap to derive the read-only diagnosis
  * cap. Read-only (live_debug_readonly) tasks carry no isolation/merge cost so they
@@ -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.482",
+  "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.482",
-    "@adhdev/session-host-core": "0.9.82-rc.482",
+    "@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/low-family/coordinator-prompt.ts

@@ -8,6 +8,59 @@
 import type { LowFamilyContext, LowFamilyHandler } from './types.js';
 
 export const coordinatorPromptHandlers: Record<string, LowFamilyHandler> = {
+    /**
+     * 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: LowFamilyContext, args: any) => {
+        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 {
+            // Prefer the router-bound resolver (inline cache aware); fall back to
+            // local config when a bare context is used (e.g. unit tests).
+            let mesh: any = null;
+            if (ctx.getMeshForCommand) {
+                const resolved = await ctx.getMeshForCommand(meshId);
+                mesh = resolved?.mesh ?? null;
+            }
+            if (!mesh) {
+                const { getMesh } = await import('../../config/mesh-config.js');
+                mesh = getMesh(meshId);
+            }
+            if (!mesh) return { success: false, error: `mesh not found: ${meshId}` };
+
+            // Apply the on-disk repo-mesh config overlay exactly as launch does,
+            // so policy/nodes reflect the effective mesh.
+            let effectiveMesh = mesh;
+            try {
+                const { loadRepoMeshJsonConfig, applyRepoMeshConfig } = await import('../../config/mesh-json-config.js');
+                const workspace = typeof mesh?.workspace === 'string' ? mesh.workspace : undefined;
+                if (workspace) {
+                    const loaded = loadRepoMeshJsonConfig(workspace);
+                    if (loaded?.sourceType !== 'invalid') {
+                        effectiveMesh = applyRepoMeshConfig(mesh, loaded?.config);
+                    }
+                }
+            } catch { /* overlay is best-effort — fall back to the raw mesh */ }
+
+            const { buildCoordinatorSystemPrompt } = await import('../../mesh/coordinator-prompt.js');
+            const prompt = buildCoordinatorSystemPrompt({ mesh: effectiveMesh, coordinatorCliType: cliType });
+            return { success: true, prompt, cliType, meshId, bytes: Buffer.byteLength(prompt, 'utf8') };
+        } catch (error: any) {
+            return { success: false, error: error?.message || String(error) };
+        }
+    },
+
     list_coordinator_prompts: async (_ctx: LowFamilyContext, _args: any) => {
         const fs = await import('node:fs');
         const path = await import('node:path');

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() : '';
@@ -480,6 +504,9 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
             const daemonId = typeof args?.daemonId === 'string' && args.daemonId.trim() ? args.daemonId.trim() : undefined;
             const machineId = typeof args?.machineId === 'string' && args.machineId.trim() ? args.machineId.trim() : undefined;
             const repoRoot = typeof args?.repoRoot === 'string' && args.repoRoot.trim() ? args.repoRoot.trim() : undefined;
+            const capabilities = Array.isArray(args?.capabilities)
+                ? args.capabilities.map((t: any) => typeof t === 'string' ? t.trim() : '').filter(Boolean)
+                : undefined;
             const node = addNode(meshId, {
                 workspace,
                 ...(repoRoot ? { repoRoot } : {}),
@@ -487,6 +514,7 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
                 ...(machineId ? { machineId } : {}),
                 ...(policy ? { policy } : {}),
                 ...(role ? { role } : {}),
+                ...(capabilities && capabilities.length ? { capabilities } : {}),
             });
             if (!node) return { success: false, error: 'Mesh not found' };
             // mesh_status hands back a coordinator-memory aggregate
@@ -543,6 +571,13 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
             } else if (args?.systemPrompt === null) {
                 patch.systemPrompt = undefined;
             }
+            // Operator custom capability tags. An explicit (possibly empty) array
+            // replaces them; omitting the arg leaves existing tags untouched.
+            if (Array.isArray(args?.capabilities)) {
+                patch.capabilities = args.capabilities
+                    .map((t: any) => typeof t === 'string' ? t.trim() : '')
+                    .filter(Boolean);
+            }
             const node = updateNode(meshId, nodeId, patch as any);
             if (!node) return { success: false, error: 'Mesh node not found' };
             // Provider priority / systemPrompt changes don't touch

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';
 
@@ -570,6 +571,11 @@ export function updateNode(
     opts: {
         userOverrides?: Partial<RepoMeshNodeCapabilities>;
         policy?: RepoMeshNodePolicy;
+        /** Operator-defined custom capability tags used by mesh queue matching.
+         *  Passing an array replaces the node's custom tags (empty/whitespace
+         *  entries dropped, deduped); an empty result clears them. Omit to leave
+         *  the existing tags untouched. */
+        capabilities?: string[];
         worktreeBootstrap?: LocalMeshNodeEntry['worktreeBootstrap'];
         /** Per-node instruction surfaced in the coordinator prompt. Pass an
          *  empty string or undefined to clear it. */
@@ -610,6 +616,13 @@ export function updateNode(
         node.reportedDaemonBuildVersion = opts.reportedDaemonBuildVersion.trim();
     }
     if (opts.policy) node.policy = { ...node.policy, ...opts.policy };
+    if (Object.prototype.hasOwnProperty.call(opts, 'capabilities')) {
+        // Explicit replace: normalize (trim/dedup/drop-empties); an empty result
+        // clears the tags entirely so the field never persists as [].
+        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')) {
         // Honor explicit clears: { systemPrompt: undefined } drops the field.
@@ -731,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;
+}