@adhdev/daemon-core 0.9.82-rc.485 → 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.485",
+  "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.485",
-    "@adhdev/session-host-core": "0.9.82-rc.485",
+    "@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/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).

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

@@ -2,7 +2,7 @@ import { existsSync } from 'fs';
 import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
 import { MESH_CONNECT_TIMEOUT_MS } from '../runtime-defaults.js';
 import { loadConfig } from '../config/config.js';
-import { getMesh } from '../config/mesh-config.js';
+import { getMesh, getDifficultyBrains } from '../config/mesh-config.js';
 import { detectCLI } from '../detection/cli-detector.js';
 import { LOG } from '../logging/logger.js';
 import { appendLedgerEntry } from './mesh-ledger.js';
@@ -15,7 +15,7 @@ import { traceMeshEventDrop } from './mesh-event-trace.js';
 import { awaitWithWarmupDeadline, resolveWarmupDeadlineOpts } from './mesh-warmup-deadline.js';
 import { resolveDelegatedWorkerAutoApprove, resolveProviderMaxParallel, resolveNodeSchedulingPriority, normalizeMeshSchedulingStrategy, resolveMaxParallelTasks, resolveMaxReadonlyParallelTasks } from '../repo-mesh-types.js';
 import type { RepoMeshSchedulingStrategy } from '../repo-mesh-types.js';
-import { normalizeMeshNodeId, meshNodeIdMatches, daemonIdsEquivalent, canonicalDaemonId, normalizeMeshWorkspaceForCompare, meshWorkspacesEquivalent, sessionIdsEquivalent, type MeshNodeIdentified } from '@adhdev/mesh-shared';
+import { normalizeMeshNodeId, meshNodeIdMatches, daemonIdsEquivalent, canonicalDaemonId, normalizeMeshWorkspaceForCompare, meshWorkspacesEquivalent, sessionIdsEquivalent, deriveSlotsFromLegacy, normalizeNodeCapabilitySlots, isMeshTaskDifficulty, type MeshNodeIdentified, type NodeCapabilitySlot, type MeshTaskDifficulty } from '@adhdev/mesh-shared';
 import { findTerminalLedgerEvidenceForTask, hasUnterminalDirectDispatchLedgerEntry } from './mesh-events-stale.js';
 import { readNonEmptyString } from './mesh-events-utils.js';
 import { readMeshNodeDaemonId } from './mesh-node-identity.js';
@@ -1141,17 +1141,36 @@ function nodeActiveLoad(meshId: string, nodeId: string): number {
     return MeshRuntimeStore.getInstance().nodeActiveAssignmentCount(meshId, nodeId);
 }
 
+/** True when any node in the mesh has an EXPLICIT capability-slot list configured
+ *  (policy.slots). Legacy-derived slots don't count — only an operator (or the
+ *  orchestrator, with approval) authoring slots signals intent to route by fitness. */
+function meshHasExplicitSlots(mesh: any): boolean {
+    const nodes = Array.isArray(mesh?.nodes) ? mesh.nodes : [];
+    return nodes.some((n: any) => normalizeNodeCapabilitySlots(n?.policy?.slots).length > 0);
+}
+
 /**
  * The mesh-wide scheduling strategy, read from the MACHINE-LOCAL stored mesh
  * policy. Resolution order:
- *   1. the stored mesh policy schedulingStrategy raw 4-union, then
- *   2. 'first_eligible' (strict no-change default).
- * Policy is machine-local only — there is no repo-file (`.adhdev/mesh.json`)
- * overlay. Only governs the final tie-break; eligibility, capacity, and priority
- * gates apply identically to every strategy.
+ *   1. an EXPLICITLY stored schedulingStrategy (operator picked a mode) wins, else
+ *   2. 'fitness' AUTO when the mesh has any node with explicit capability slots —
+ *      configuring slots is itself the signal to route tasks by task→slot fitness
+ *      (difficulty/capability), no separate strategy toggle required, else
+ *   3. 'first_eligible' (strict no-change default for slot-less meshes).
+ *
+ * Persistence economy drops schedulingStrategy from policy when it equals the
+ * first_eligible default (repo-mesh-types normalizeMeshPolicy), so an ABSENT value
+ * means "unset" — safe to auto-upgrade — while a PRESENT value means the operator
+ * chose it and we never override. Policy is machine-local only; this only governs
+ * the final tie-break — eligibility, capacity, and priority gates are unchanged.
  */
 function resolveSchedulingStrategy(mesh: any): RepoMeshSchedulingStrategy {
-    return normalizeMeshSchedulingStrategy(mesh?.policy?.schedulingStrategy);
+    const raw = mesh?.policy?.schedulingStrategy;
+    if (typeof raw === 'string' && raw.trim()) {
+        return normalizeMeshSchedulingStrategy(raw);
+    }
+    // Unset → auto-fitness when slots exist, else the historical default.
+    return meshHasExplicitSlots(mesh) ? 'fitness' : normalizeMeshSchedulingStrategy(undefined);
 }
 
 /**
@@ -1193,7 +1212,7 @@ export function __orderEligibleNodesForTests(
     meshId: string,
     strategy: RepoMeshSchedulingStrategy,
     nodes: RankableNode[],
-    opts?: { bumpCursor?: boolean },
+    opts?: { bumpCursor?: boolean; task?: { difficulty?: string; requiredTags?: string[] } },
 ): RankableNode[] {
     return orderEligibleNodes(meshId, strategy, nodes, opts);
 }
@@ -1249,16 +1268,107 @@ export function __buildSchedulingPoolForTests(
     return buildSchedulingPool(localCandidates, remoteCandidates);
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Node capability slots — task→node/slot fitness (ORCHESTRATION_NODE_SLOTS.md)
+//
+// A node's capability slots are the single source of truth for routing. When a
+// node has explicit `policy.slots` we use them; otherwise we derive slots from the
+// legacy providerPriority/providerRoles + the machine-global difficultyBrains so
+// existing nodes keep working (back-compat). The fitness scorer ranks a node for a
+// specific task by how well its best slot matches the task's difficulty and
+// required tags — with graceful fallback so a task is never blocked by a missing
+// exact match.
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** The task shape the fitness scorer reads (a subset of MeshWorkQueueEntry). */
+interface FitnessTask {
+    difficulty?: string;
+    requiredTags?: string[];
+}
+
+/** Resolve a node's capability slots: explicit policy.slots, else derived from legacy. */
+function resolveNodeCapabilitySlots(node: any): NodeCapabilitySlot[] {
+    const explicit = normalizeNodeCapabilitySlots(node?.policy?.slots);
+    if (explicit.length) return explicit;
+    let difficultyBrains: any;
+    try { difficultyBrains = getDifficultyBrains(); } catch { difficultyBrains = undefined; }
+    return deriveSlotsFromLegacy({
+        providerPriority: normalizeProviderPriority(node?.policy),
+        providerRoles: Array.isArray(node?.policy?.providerRoles) ? node.policy.providerRoles : undefined,
+        difficultyBrains,
+    });
+}
+
+/**
+ * Score how well one slot fits a task. Higher = better. A slot whose difficulty
+ * range contains the task's difficulty scores highest; a general-purpose slot
+ * (no declared difficulty) is a valid fallback; a slot whose capability tags cover
+ * the task's requiredTags gets a capability bonus. Never negative — the worst a
+ * slot does is score 0 (still selectable as a last-resort fallback).
+ */
+function scoreSlotForTask(slot: NodeCapabilitySlot, task: FitnessTask): number {
+    let score = 1; // base: any slot can run the task (fallback floor)
+    const diff = isMeshTaskDifficulty(task.difficulty) ? task.difficulty as MeshTaskDifficulty : undefined;
+    if (diff) {
+        if (slot.difficulty?.length) {
+            score += slot.difficulty.includes(diff) ? 100 : 0; // exact difficulty match dominates
+        } else {
+            score += 20; // general-purpose slot: decent fallback for any difficulty
+        }
+    }
+    const req = task.requiredTags?.filter(t => !!t) ?? [];
+    if (req.length) {
+        const cap = new Set(slot.capability ?? []);
+        const covered = req.every(t => cap.has(t));
+        score += covered ? 30 : 0; // capability coverage bonus (hard filter is applied elsewhere)
+    }
+    return score;
+}
+
+/** Best (slot, score) for a task on a node, or null when the node has no slots. */
+function bestSlotForTask(node: any, task: FitnessTask): { slot: NodeCapabilitySlot; score: number } | null {
+    const slots = resolveNodeCapabilitySlots(node);
+    if (!slots.length) return null;
+    let best: { slot: NodeCapabilitySlot; score: number } | null = null;
+    for (const slot of slots) {
+        const score = scoreSlotForTask(slot, task);
+        if (!best || score > best.score) best = { slot, score };
+    }
+    return best;
+}
+
+/** Node-level fitness for a task = its best slot's score (0 when the node has no slots). */
+function nodeFitnessForTask(node: any, task: FitnessTask): number {
+    return bestSlotForTask(node, task)?.score ?? 0;
+}
+
 function orderEligibleNodes(
     meshId: string,
     strategy: RepoMeshSchedulingStrategy,
     nodes: RankableNode[],
-    opts?: { bumpCursor?: boolean },
+    opts?: { bumpCursor?: boolean; task?: FitnessTask },
 ): RankableNode[] {
     if (strategy === 'first_eligible' || nodes.length <= 1) {
         return nodes;
     }
 
+    // Fitness strategy: rank by task→slot fit first (when a task is in scope —
+    // auto-launch drains per-task), then fall through to priority/load/rotation for
+    // ties. Without a task (idle-session drain ranks task-independently) fitness is
+    // inert and this behaves like least_loaded.
+    if (strategy === 'fitness' && opts?.task) {
+        const task = opts.task;
+        return [...nodes].sort((a, b) => {
+            const fitDelta = nodeFitnessForTask(b.node, task) - nodeFitnessForTask(a.node, task);
+            if (fitDelta !== 0) return fitDelta; // higher fitness first
+            const prioDelta = resolveNodeSchedulingPriority(b.node?.policy) - resolveNodeSchedulingPriority(a.node?.policy);
+            if (prioDelta !== 0) return prioDelta;
+            const loadDelta = nodeActiveLoad(meshId, a.nodeId) - nodeActiveLoad(meshId, b.nodeId);
+            if (loadDelta !== 0) return loadDelta;
+            return a.index - b.index;
+        });
+    }
+
     const priorityOf = (n: { node: any }) => resolveNodeSchedulingPriority(n.node?.policy);
 
     // Round-robin rotation offset: rotate the deterministic input order by a
@@ -1542,19 +1652,29 @@ async function resolveUsableProvider(
     nodeId: string,
     node: any,
     requiredTags?: string[],
-): Promise<{ providerType?: string; reason?: string }> {
-    const providerPriority = normalizeProviderPriority(node?.policy);
-    if (!providerPriority.length) return { reason: 'missing_provider_priority' };
+    task?: FitnessTask,
+): Promise<{ providerType?: string; model?: string; thinkingLevel?: string; reason?: string }> {
     const providerLoader = components.providerLoader;
     if (!providerLoader) return { reason: 'provider_loader_unavailable' };
 
+    // Slot-based order (ORCHESTRATION_NODE_SLOTS.md): rank the node's capability
+    // slots by task→slot fitness (difficulty/requiredTags) so the best-fit slot's
+    // provider is tried first, and its model/thinkingLevel ride along. Falls back
+    // to the legacy providerPriority-derived slots when no explicit slots exist.
+    const slots = resolveNodeCapabilitySlots(node);
+    if (!slots.length) return { reason: 'missing_provider_priority' };
+    const orderedSlots = task
+        ? [...slots].sort((a, b) => scoreSlotForTask(b, task) - scoreSlotForTask(a, task))
+        : slots;
+
     const failed: string[] = [];
-    for (const requestedType of providerPriority) {
+    for (const slot of orderedSlots) {
+        const requestedType = slot.provider;
         const normalizedType = typeof providerLoader.resolveAlias === 'function'
             ? providerLoader.resolveAlias(requestedType)
             : requestedType;
         // Skip providers that can't satisfy the task's requiredTags (e.g. provider=hermes-cli
-        // means only hermes-cli qualifies, not any other type in providerPriority).
+        // means only hermes-cli qualifies, not any other slot's provider).
         if (requiredTags?.length && !nodeSatisfiesRequiredTags(requiredTags, buildMeshNodeCapabilityTags(node, normalizedType))) {
             failed.push(`${requestedType}: required_tags_mismatch`);
             continue;
@@ -1578,7 +1698,13 @@ async function resolveUsableProvider(
             }], false);
         }
         (components as any).onStatusChange?.();
-        if (detected) return { providerType: normalizedType };
+        if (detected) {
+            return {
+                providerType: normalizedType,
+                ...(slot.model ? { model: slot.model } : {}),
+                ...(slot.thinkingLevel ? { thinkingLevel: slot.thinkingLevel } : {}),
+            };
+        }
         failed.push(`${requestedType}: not detected`);
     }
     return { reason: `provider_priority_unusable: ${failed.join('; ') || nodeId}` };
@@ -1850,7 +1976,9 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
                 candidateNodes
                     .map((node: any, index: number) => ({ nodeId: readMeshNodeId(node), node, index }))
                     .filter((c: RankableNode) => c.nodeId),
-                { bumpCursor: true },
+                // Auto-launch drains one task at a time, so the task IS in scope here —
+                // pass it through for the 'fitness' strategy's task→slot ranking.
+                { bumpCursor: true, task: { difficulty: (task as any).difficulty, requiredTags: task.requiredTags } },
             ).map((c: RankableNode) => c.node);
 
         for (const node of orderedCandidateNodes) {
@@ -1914,11 +2042,16 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
 
             autoLaunchInProgress.add(launchKey);
             try {
-                const resolved = await resolveUsableProvider(components, nodeId, node, task.requiredTags);
+                const resolved = await resolveUsableProvider(components, nodeId, node, task.requiredTags, { difficulty: (task as any).difficulty, requiredTags: task.requiredTags });
                 if (!resolved.providerType) {
                     markAutoLaunch(meshId, task.id, { status: 'skipped', reason: resolved.reason || 'provider_unusable', nodeId });
                     continue;
                 }
+                // Slot-derived model/thinking: an explicit task.model/thinkingLevel
+                // (resolved from the enqueue-time brain) still wins; the matched
+                // slot fills only what the task left blank (ORCHESTRATION_NODE_SLOTS.md).
+                const effectiveModel = (typeof task.model === 'string' && task.model.trim()) ? task.model.trim() : resolved.model;
+                const effectiveThinkingLevel = (typeof task.thinkingLevel === 'string' && task.thinkingLevel.trim()) ? task.thinkingLevel.trim() : resolved.thinkingLevel;
 
                 // Don't spawn a session for a (node, provider) already at its declared
                 // maxParallel cap — it would launch only to fail the claim. The claim
@@ -1967,9 +2100,10 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
                             settings: remoteSettings,
                             // MAGI-KIND-PANEL model axis: forward the task's model override so the
                             // remote worker session launches with it (initialModel). Best-effort.
-                            ...(typeof task.model === 'string' && task.model.trim() ? { initialModel: task.model.trim() } : {}),
-                            // BRAIN-ROUTING thinking axis: forward the task's thinking level (initialThinkingLevel).
-                            ...(typeof task.thinkingLevel === 'string' && task.thinkingLevel.trim() ? { initialThinkingLevel: task.thinkingLevel.trim() } : {}),
+                            // Slot-aware: task override wins, else the matched slot's model.
+                            ...(effectiveModel ? { initialModel: effectiveModel } : {}),
+                            // BRAIN-ROUTING thinking axis: forward the effective thinking level (initialThinkingLevel).
+                            ...(effectiveThinkingLevel ? { initialThinkingLevel: effectiveThinkingLevel } : {}),
                         });
                     } catch (e: any) {
                         markAutoLaunch(meshId, task.id, { status: 'failed', reason: `remote_launch_dispatch_failed: ${e?.message || String(e)}`, nodeId, providerType: resolved.providerType });
@@ -1999,11 +2133,11 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
                     cliType: resolved.providerType,
                     dir: node.workspace,
                     settings: launchSettings,
-                    // MAGI-KIND-PANEL model axis: local launch forwards the task's model
-                    // override as initialModel (CLI → modelLaunchArgs; ACP → setConfigOption).
-                    ...(typeof task.model === 'string' && task.model.trim() ? { initialModel: task.model.trim() } : {}),
-                    // BRAIN-ROUTING thinking axis: forward the task's thinking level (initialThinkingLevel).
-                    ...(typeof task.thinkingLevel === 'string' && task.thinkingLevel.trim() ? { initialThinkingLevel: task.thinkingLevel.trim() } : {}),
+                    // MAGI-KIND-PANEL model axis: local launch forwards the effective model
+                    // (task override, else matched slot) as initialModel (CLI → modelLaunchArgs; ACP → setConfigOption).
+                    ...(effectiveModel ? { initialModel: effectiveModel } : {}),
+                    // BRAIN-ROUTING thinking axis: forward the effective thinking level (initialThinkingLevel).
+                    ...(effectiveThinkingLevel ? { initialThinkingLevel: effectiveThinkingLevel } : {}),
                 });
                 if (!launchResult?.success) {
                     const reason = launchResult?.error || 'launch_cli_failed';
@@ -2211,7 +2345,10 @@ export async function triggerMeshQueue(components: DaemonComponents, meshId: str
                 const aPrio = resolveNodeSchedulingPriority(a.node?.policy);
                 const bPrio = resolveNodeSchedulingPriority(b.node?.policy);
                 if (aPrio !== bPrio) return bPrio - aPrio;
-                if (strategy === 'least_loaded' || strategy === 'round_robin') {
+                // The idle-session drain ranks task-independently (a session pulls
+                // whatever task matches), so 'fitness' here reduces to load-aware
+                // ordering — the same tiebreak as least_loaded/round_robin.
+                if (strategy === 'least_loaded' || strategy === 'round_robin' || strategy === 'fitness') {
                     const loadDelta = nodeActiveLoad(meshId, a.nodeId) - nodeActiveLoad(meshId, b.nodeId);
                     if (loadDelta !== 0) return loadDelta;
                 }