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

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

@@ -51,6 +51,10 @@ export declare function __resolveSchedulingStrategyForTests(mesh: any): RepoMesh
  *  scheduling pipeline can be unit-tested without standing up live CLI sessions. */
 export declare function __orderEligibleNodesForTests(meshId: string, strategy: RepoMeshSchedulingStrategy, nodes: RankableNode[], opts?: {
     bumpCursor?: boolean;
+    task?: {
+        difficulty?: string;
+        requiredTags?: string[];
+    };
 }): RankableNode[];
 /** One idle session eligible to claim a queued task, together with the resolved
  *  mesh node record it belongs to. Local candidates come from live CLI instances,

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

@@ -126,6 +126,15 @@ export interface MeshWorkQueueEntry {
      * setConfigOption('thought_level')). Rides in payload JSON. Best-effort like model.
      */
     thinkingLevel?: string;
+    /**
+     * SLOT-ROUTING (ORCHESTRATION_NODE_SLOTS.md): the coordinator's difficulty
+     * classification for this task ('easy'|'medium'|'difficult'|'freeform'),
+     * PERSISTED on the entry so the scheduler can match it against node capability
+     * slots at assignment time. Previously an enqueue-only option consumed to
+     * resolve model/thinkingLevel and then discarded; keeping it lets task→node
+     * fitness matching run. Absent on tasks enqueued without a difficulty.
+     */
+    difficulty?: 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;

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, DifficultyBrainMap } from '@adhdev/mesh-shared';
+import type { MagiKindPanelMap, DifficultyBrainMap, NodeCapabilitySlot } from '@adhdev/mesh-shared';
 export interface RepoMesh {
     id: string;
     name: string;
@@ -114,7 +114,7 @@ export type RepoMeshMagiSessionCleanupMode = 'preserve' | 'stop_and_delete';
  * Distribution is explicit opt-in: a strategy other than 'first_eligible' must be
  * configured for any load-spreading to occur.
  */
-export type RepoMeshSchedulingStrategy = 'first_eligible' | 'least_loaded' | 'round_robin' | 'priority_only';
+export type RepoMeshSchedulingStrategy = 'first_eligible' | 'least_loaded' | 'round_robin' | 'priority_only' | 'fitness';
 export declare const MESH_SCHEDULING_STRATEGIES: RepoMeshSchedulingStrategy[];
 export declare const DEFAULT_MESH_SCHEDULING_STRATEGY: RepoMeshSchedulingStrategy;
 /**
@@ -310,8 +310,22 @@ export interface RepoMeshNodePolicy {
      * enforced as an additional, stricter-wins constraint on top of the global
      * maxParallelTasks/taskMode caps. Missing/empty: the node behaves exactly as
      * before (global caps only). Routing is governed solely by required_tags.
+     *
+     * SUPERSEDED by `slots` (ORCHESTRATION_NODE_SLOTS.md). Kept for back-compat:
+     * when `slots` is absent, providerRoles + providerPriority + the machine-global
+     * difficultyBrains are auto-derived into slots via deriveSlotsFromLegacy.
      */
     providerRoles?: RepoMeshProviderRole[];
+    /**
+     * Node capability slots (ORCHESTRATION_NODE_SLOTS.md) — the ordered "Preferred
+     * AI tools" profile that is the single source of truth for task routing, MAGI
+     * fan-out, and orchestrator-proposed edits. Each slot bundles provider + model
+     * + thinkingLevel + difficulty range + capability tags + per-slot maxParallel.
+     * Order = preference. When absent, the scheduler derives slots from the legacy
+     * providerPriority/providerRoles/difficultyBrains (deriveSlotsFromLegacy) so
+     * existing nodes keep working without reconfiguration.
+     */
+    slots?: NodeCapabilitySlot[];
     /**
      * Per-node override for RepoMeshPolicy.delegatedWorkerAutoApprove. When set, takes
      * precedence over the mesh-level policy for worker sessions launched onto this node.
@@ -858,6 +872,8 @@ export interface RepoMeshNodeStatus {
     activeSessions: string[];
     activeSessionDetails?: RepoMeshSessionStatus[];
     providerPriority?: string[];
+    /** Explicitly-configured node capability slots (ORCHESTRATION_NODE_SLOTS.md). */
+    slots?: NodeCapabilitySlot[];
     launchReady?: boolean;
     /** True when the node is clean, ahead=0, behind>0, and safe for fast-forward consideration. */
     autoFastForwardEligible?: boolean;

package/dist/shared-types.d.ts

@@ -287,6 +287,13 @@ export interface SessionEntry {
     completionMarker?: string;
     seenCompletionMarker?: string;
     surfaceHidden?: boolean;
+    /**
+     * User (or coordinator-policy) muted: suppress attention side-effects
+     * (notifications, toasts, completion audio) for this session WITHOUT removing
+     * it from the inbox list. Distinct from surfaceHidden (which collapses it from
+     * the list). Daemon-owned, in-memory; rides the status snapshot.
+     */
+    muted?: boolean;
     settings?: Record<string, any>;
     /**
      * True owning-daemon id for a session a coordinator synthesises into its own
@@ -361,6 +368,7 @@ export interface CompactSessionEntry {
     completionMarker?: string;
     seenCompletionMarker?: string;
     surfaceHidden?: boolean;
+    muted?: boolean;
     controlValues?: Record<string, string | number | boolean>;
     providerControls?: ProviderControlSchema[];
     summaryMetadata?: ProviderSummaryMetadata;

package/dist/status/snapshot.d.ts

@@ -64,6 +64,7 @@ export interface RecentReadDebugSnapshot {
     messageUpdatedAt: number;
 }
 export declare function shouldEmitRecentReadDebugLog(cache: Map<string, string>, snapshot: RecentReadDebugSnapshot): boolean;
+export declare function buildAvailableProviders(providerLoader: StatusSnapshotOptions['providerLoader']): AvailableProviderInfo[];
 export declare function buildMachineInfo(profile?: 'full' | 'live' | 'metadata'): MachineInfo;
 /**
  * Resolve the last user-visible (non-system) message for a session as a preview.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.484",
+  "version": "0.9.82-rc.486",
   "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.484",
-    "@adhdev/session-host-core": "0.9.82-rc.484",
+    "@adhdev/mesh-shared": "0.9.82-rc.486",
+    "@adhdev/session-host-core": "0.9.82-rc.486",
     "@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/handler.ts

@@ -1080,7 +1080,14 @@ export class DaemonCommandHandler implements CommandHelpers {
         if (!fs.existsSync(installRoot)) return { success: true, providers: [] };
 
         const CATEGORIES = ['cli', 'ide', 'extension', 'acp'] as const;
-        const items: Array<{ type: string; category: string; version: string; path: string }> = [];
+        const items: Array<{
+            type: string;
+            category: string;
+            version: string;
+            path: string;
+            modelOptions?: string[];
+            thinkingLevelOptions?: string[];
+        }> = [];
 
         for (const category of CATEGORIES) {
             const categoryDir = path.join(installRoot, category);
@@ -1095,11 +1102,24 @@ export class DaemonCommandHandler implements CommandHelpers {
                 if (!manifestPath) continue;
                 try {
                     const m = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+                    // Surface the manifest's advisory model / thinking-level lists so
+                    // consumers of this endpoint (standalone New-session dialog, mesh
+                    // node slot editor) get the same provider-specific dropdowns the
+                    // status-snapshot path already carries — otherwise every provider
+                    // (codex included) falls back to a free-text Model field.
+                    const modelOptions = Array.isArray(m.modelOptions)
+                        ? m.modelOptions.filter((x: unknown): x is string => typeof x === 'string' && !!x.trim())
+                        : [];
+                    const thinkingLevelOptions = Array.isArray(m.thinkingLevelOptions)
+                        ? m.thinkingLevelOptions.filter((x: unknown): x is string => typeof x === 'string' && !!x.trim())
+                        : [];
                     items.push({
                         type,
                         category,
                         version: typeof m.providerVersion === 'string' ? m.providerVersion : '0.0.0',
                         path: manifestPath,
+                        ...(modelOptions.length ? { modelOptions } : {}),
+                        ...(thinkingLevelOptions.length ? { thinkingLevelOptions } : {}),
                     });
                 } catch {
                     // Corrupt manifest — skip but don't fail the whole listing.

package/src/commands/high-family/mesh-coordinator-launch.ts

@@ -48,6 +48,18 @@ export const meshCoordinatorLaunchHandlers: Record<string, HighFamilyHandler> =
                 const extraSystemPrompt = typeof args?.extraSystemPrompt === 'string'
                     ? args.extraSystemPrompt.trim()
                     : '';
+                // Optional per-launch model / thinking-level override for the
+                // coordinator session. Passed straight through to launch_cli,
+                // which applies them best-effort for providers that support it
+                // (claude --effort, codex model_reasoning_effort). Blank / absent
+                // => provider default. This is a launch-time override only; it is
+                // NOT persisted to the mesh coordinator config.
+                const initialModel = typeof args?.initialModel === 'string' && args.initialModel.trim()
+                    ? args.initialModel.trim()
+                    : null;
+                const initialThinkingLevel = typeof args?.initialThinkingLevel === 'string' && args.initialThinkingLevel.trim()
+                    ? args.initialThinkingLevel.trim()
+                    : null;
                 if (!meshId) return { success: false, error: 'meshId required' };
 
                 try {
@@ -390,6 +402,8 @@ export const meshCoordinatorLaunchHandlers: Record<string, HighFamilyHandler> =
                             cliArgs: cliCmdArgs.length > 0 ? cliCmdArgs : undefined,
                             env: Object.keys(cliCmdEnv).length > 0 ? cliCmdEnv : undefined,
                             settings: { meshCoordinatorFor: meshId },
+                            ...(initialModel ? { initialModel } : {}),
+                            ...(initialThinkingLevel ? { initialThinkingLevel } : {}),
                         });
 
                         // R48 inject-then-remove. Spawn was just kicked off above; agy and
@@ -609,7 +623,9 @@ export const meshCoordinatorLaunchHandlers: Record<string, HighFamilyHandler> =
                         env: Object.keys(launchEnv).length > 0 ? launchEnv : undefined,
                         settings: {
                             meshCoordinatorFor: meshId
-                        }
+                        },
+                        ...(initialModel ? { initialModel } : {}),
+                        ...(initialThinkingLevel ? { initialThinkingLevel } : {}),
                     });
 
                     // R48 inject-then-remove. See the cli_command branch for context;

package/src/commands/high-family/mesh-status.ts

@@ -18,6 +18,7 @@ import { getGitRepoStatus } from '../../git/git-status.js';
 import {
     normalizeMeshNodeId,
     daemonIdsEquivalent,
+    normalizeNodeCapabilitySlots,
 } from '@adhdev/mesh-shared';
 import {
     getPendingMeshCoordinatorEvents,
@@ -357,6 +358,13 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                                 ? { daemonBuildVersion: node.reportedDaemonBuildVersion }
                                 : {}),
                             providerPriority,
+                            // ORCHESTRATION_NODE_SLOTS.md: surface the node's capability
+                            // slots so the dashboard slot editor can read them. Only
+                            // emitted when explicitly configured (derived-from-legacy
+                            // slots stay implicit — the editor shows the legacy fields).
+                            ...(Array.isArray((node.policy as any)?.slots) && (node.policy as any).slots.length
+                                ? { slots: normalizeNodeCapabilitySlots((node.policy as any).slots) }
+                                : {}),
                             activeSessions: [],
                             activeSessionDetails: [],
                             launchReady: false,

package/src/commands/med-family/cli-agent.ts

@@ -64,6 +64,35 @@ export const cliAgentHandlers: Record<string, MedFamilyHandler> = {
         return ctx.deps.cliManager.handleCliCommand('record_provider_pty', args);
     },
 
+    // Daemon-owned per-session user Mute/Hide. Replaces the old browser-local
+    // localStorage layer: the user's manual hide/mute for a conversation is stored
+    // in-memory on the live session's settings (userHidden / userMuted) and rides
+    // the SAME status snapshot pipeline as the coordinator-policy surfaceHidden
+    // flag, so every client of this daemon sees the same state. In-memory only —
+    // resets on daemon restart (coordinator-spawned sessions re-derive their hidden
+    // default from mesh policy on relaunch). Passing null/undefined for a field
+    // leaves it unchanged; pass an explicit boolean to set, or false to clear an
+    // earlier hide/mute (e.g. unmute a coordinator-spawned worker overrides the
+    // policy default until restart).
+    set_conversation_prefs: async (ctx: MedFamilyContext, args: any) => {
+        const sessionId = readStringValue(args?.sessionId, (args as any)?.targetSessionId, (args as any)?.instanceId);
+        if (!sessionId) return { success: false, error: 'sessionId required' };
+        const inst = ctx.deps.instanceManager.getInstance(sessionId);
+        if (!inst || typeof inst.updateSettings !== 'function') {
+            return { success: false, error: 'Session not found or does not support preferences' };
+        }
+        const patch: Record<string, unknown> = {};
+        if (typeof args?.hidden === 'boolean') patch.userHidden = args.hidden;
+        if (typeof args?.muted === 'boolean') patch.userMuted = args.muted;
+        if (!Object.keys(patch).length) return { success: false, error: 'Nothing to update (hidden and/or muted required)' };
+        inst.updateSettings(patch);
+        // Push a fresh status snapshot so all clients see the updated
+        // surfaceHidden/muted immediately (cloud path). The standalone server has a
+        // parallel broadcast gate keyed on the command name (see daemon-standalone).
+        ctx.deps.onStatusChange?.();
+        return { success: true, sessionId, ...patch };
+    },
+
     agent_command: async (ctx: MedFamilyContext, args: any) => {
         // Relay-safety stamp: a dispatch carrying meshContext.coordinatorDaemonId
         // (mesh_send_task / queue assignment over P2P) is the worker daemon's chance

package/src/index.ts

@@ -381,7 +381,7 @@ export type {
 // ── Status ──
 export { DaemonStatusReporter } from './status/reporter.js';
 export { buildSessionEntries, findCdpManager, hasCdpManager, isCdpConnected } from './status/builders.js';
-export { buildStatusSnapshot, buildMachineInfo, getLastDisplayMessage } from './status/snapshot.js';
+export { buildStatusSnapshot, buildMachineInfo, buildAvailableProviders, getLastDisplayMessage } from './status/snapshot.js';
 export { getDaemonBuildInfo } from './build-info.js';
 export type { DaemonBuildInfo } from './build-info.js';
 export { normalizeManagedStatus, isManagedStatusWorking, isManagedStatusWaiting, normalizeActiveChatData } from './status/normalize.js';

package/src/mesh/coordinator-prompt.ts

@@ -702,7 +702,9 @@ const TOOLS_SECTION = `## Available Tools
 | \`mesh_magi_review\` | Cross-verify a read-only investigation across a standing panel of independent mesh agents (different machines/providers) instead of a single worker |
 | \`mesh_magi_collect\` | Collect + synthesize a previously dispatched MAGI fan-out by its consensus group id (async companion to mesh_magi_review wait:false) |
 | \`mesh_magi_kind_panel_set\` | Bind a task_kind → MAGI kind-panel slots (the SOLE MAGI panel-resolution surface; machine-local, wholesale replacement — approve current-vs-new first) |
-| \`mesh_magi_kind_panel_list\` | List configured task_kind → MAGI kind-panel slot bindings (machine-local, read-only) |`;
+| \`mesh_magi_kind_panel_list\` | List configured task_kind → MAGI kind-panel slot bindings (machine-local, read-only) |
+| \`mesh_node_slots_list\` | List a node's capability slots (its AI-tool profile: provider/model/thinking + difficulty range + capability tags), read-only |
+| \`mesh_node_slots_set\` | PROPOSE (dry-run) or APPLY a node's capability slots — how you autonomously retune a node's tool profile; WHOLESALE replacement, present current-vs-proposed and get user approval before write=true |`;
 
 const TOOL_EXPOSURE_PREFLIGHT_SECTION = `## Tool Exposure Preflight
 
@@ -773,6 +775,7 @@ function buildRulesSection(coordinatorCliType?: string): string {
 - **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.
+- **Retune node profiles when routing is a poor fit — but only with approval.** A node's capability slots (its provider/model/thinking + difficulty range + capability tags, seen via \`mesh_node_slots_list\`) are what task→node fitness routing matches against. If you notice a persistent mismatch — e.g. every \`difficult\` task lands on a node whose only slot is a cheap model, or a capability a node clearly has isn't declared — you MAY propose a slot change with \`mesh_node_slots_set\` (write=false). That returns current-vs-proposed; present that diff to the user with a one-line reason and apply (write=true) ONLY after they approve. It is a WHOLESALE replacement of the node's slots, so include the slots you want to keep. Never rewrite a node's profile silently or without a clear routing reason.
 - **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).