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

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;
                 }

package/src/mesh/mesh-refine-gates.ts

@@ -13,6 +13,7 @@
  */
 
 import { getGitRepoStatus } from '../git/git-status.js';
+import type { ChangedPackageClassification } from '../git/git-status.js';
 import * as yaml from 'js-yaml';
 import { loadMeshRefineConfig, resolveMeshRefineValidationPlan } from '../mesh/refine-config.js';
 import type { MeshRefineValidationCommandPlan } from '../mesh/refine-config.js';
@@ -74,6 +75,19 @@ type MeshRefineValidationSummary = {
     };
     /** M2-2: deprecation notices from the refine config (e.g. bootstrapCommands). */
     deprecationWarnings?: string[];
+    /**
+     * Coarse daemon-vs-web change-impact used to scope the validation command set.
+     * When `isDaemonAffecting === false`, daemon-scoped commands are recorded in
+     * `commandsRun` with `skipped: true, skipReason: 'unaffected_daemon_scope'`
+     * rather than executed; web + typecheck commands always run. Absent when no
+     * change-impact was threaded in (legacy: full command set runs).
+     */
+    changeImpact?: {
+        isDaemonAffecting: boolean;
+        affectedPackages: string[];
+        /** displayCommands skipped because the daemon scope is unaffected. */
+        skippedDaemonCommands?: string[];
+    };
 };
 
 type MeshRefineStageStatus = 'passed' | 'failed' | 'skipped';
@@ -343,6 +357,13 @@ export interface RefineContext {
     baseBranch: string;
     baseHead: string;
     branchHead: string;
+    /**
+     * Coarse daemon-vs-web change-impact for baseHead..branchHead, resolved in the
+     * resolve_refs stage and threaded into the validation gate to scope its command
+     * set. `undefined` means "could not classify" → the gate fails open and runs ALL
+     * commands (never skip on uncertainty).
+     */
+    changeImpact?: ChangedPackageClassification;
     validationSummary: Awaited<ReturnType<typeof runMeshRefineValidationGate>>;
     patchEquivalence: Awaited<ReturnType<typeof runMeshRefinePatchEquivalenceGate>>;
     submoduleReachability: Awaited<ReturnType<typeof runMeshRefineSubmoduleReachabilityGate>>;
@@ -1477,6 +1498,14 @@ export async function runMeshRefineValidationGate(
         persistedBootstrapState?: WorktreeBootstrapState | null;
         /** M2-2: called after an inherit-mode bootstrap run so the caller can persist the new state. */
         onBootstrapStateChange?: (state: WorktreeBootstrapState) => void;
+        /**
+         * Coarse daemon-vs-web change-impact for the branch (resolve_refs computes it
+         * over baseHead..branchHead). When provided and `isDaemonAffecting === false`,
+         * daemon-scoped validation commands are skipped (web + typecheck still run).
+         * When omitted or `isDaemonAffecting === true`, the full command set runs —
+         * fail-open to full validation on any uncertainty.
+         */
+        changeImpact?: ChangedPackageClassification;
     },
 ): Promise<MeshRefineValidationSummary> {
     const { execFile } = await import('node:child_process');
@@ -1574,6 +1603,63 @@ export async function runMeshRefineValidationGate(
         return ['package-lock.json', 'npm-shrinkwrap.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lockb', 'bun.lock']
             .some(lock => fs.existsSync(pathJoin(cwd, lock)));
     };
+    // A validation command needs installed node_modules to run. Only these can hit
+    // the missing-deps hard-block; non-package-manager commands (e.g. a plain
+    // `node scripts/check-vendor-drift.mjs`) need no deps and must never be aborted
+    // by a preceding command's missing-deps.
+    const needsNodeModules = (candidate: MeshRefineValidationCommand, cwd: string): boolean =>
+        isPackageManagerValidation(candidate) && dependenciesLikelyMissing(cwd);
+
+    // (a) Coarse change-impact scoping. When the branch is web-only
+    // (changeImpact.isDaemonAffecting === false), daemon-scoped validation commands
+    // are pointless — and often un-runnable in a web-only worktree that never
+    // bootstrapped daemon deps. Identify daemon-scoped commands ONLY by the coarse
+    // daemon-vs-web bucket: a command whose script/args reference a daemon package
+    // (daemon-core / daemon-cloud) or the vendor-drift check. web-side commands
+    // (test:web-core / test:web-cloud) and `typecheck` ALWAYS run — the daemon/web
+    // boundary is the human-curated safe line; we deliberately do NOT do fine
+    // per-package skipping (web-cloud consumes web-core, so it must still run).
+    const isDaemonScopedCommand = (candidate: MeshRefineValidationCommand): boolean => {
+        const haystack = [candidate.command, ...(candidate.args || []), candidate.displayCommand || '']
+            .join(' ')
+            .toLowerCase();
+        // Never treat a typecheck or an explicit web-side command as daemon-scoped.
+        if (candidate.category === 'typecheck') return false;
+        if (/\btypecheck\b/.test(haystack)) return false;
+        if (/\bweb-core\b|\bweb-cloud\b|\bweb-standalone\b|\btest:web\b/.test(haystack)) return false;
+        // Daemon-scoped signals: a daemon package name, a daemon test script, or the
+        // vendor-drift check (which validates the daemon vendor bundle).
+        return /\bdaemon-core\b|\bdaemon-cloud\b|\btest:daemon\b|check-vendor-drift/.test(haystack);
+    };
+
+    const scopeUnaffectedDaemon = opts?.changeImpact?.isDaemonAffecting === false;
+    const skippedDaemonCommands: string[] = [];
+    const commandsToRun: MeshRefineValidationCommand[] = [];
+    for (const candidate of selection.commands) {
+        if (scopeUnaffectedDaemon && isDaemonScopedCommand(candidate)) {
+            skippedDaemonCommands.push(candidate.displayCommand);
+            // Record the skip so it's visible in the summary, never silently dropped.
+            summary.commandsRun.push({
+                command: candidate.command,
+                args: candidate.args,
+                displayCommand: candidate.displayCommand,
+                category: candidate.category,
+                source: candidate.source,
+                passed: true,
+                skipped: true,
+                skipReason: 'unaffected_daemon_scope',
+            });
+            continue;
+        }
+        commandsToRun.push(candidate);
+    }
+    if (opts?.changeImpact) {
+        summary.changeImpact = {
+            isDaemonAffecting: opts.changeImpact.isDaemonAffecting,
+            affectedPackages: opts.changeImpact.affectedPackages,
+            ...(skippedDaemonCommands.length ? { skippedDaemonCommands } : {}),
+        };
+    }
 
     if (runLegacyBootstrapCommands) {
         summary.bootstrap = { stage: 'legacy' };
@@ -1619,23 +1705,31 @@ export async function runMeshRefineValidationGate(
         }
     }
 
-    for (const candidate of selection.commands) {
+    // (b) Track a genuine missing-deps block for an AFFECTED command. Instead of
+    // aborting the whole gate at the first missing-deps hit (which also killed
+    // trailing no-dep commands like check-vendor-drift.mjs), we mark the blocked
+    // command and CONTINUE evaluating the rest: commands whose deps are present, or
+    // which need no deps at all, still run. missing_dependencies only becomes the
+    // gate failure if at least one command that truly needed deps could not run.
+    let missingDepsBlocked = false;
+    for (const candidate of commandsToRun) {
         const startedAt = Date.now();
         const cwd = candidate.cwd ? pathResolve(workspace, candidate.cwd) : workspace;
         const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
         const bootstrapProvidedDependencies = summary.bootstrap?.stage === 'cached' || summary.bootstrap?.stage === 'ran' || summary.bootstrap?.stage === 'legacy';
-        if (!bootstrapProvidedDependencies && isPackageManagerValidation(candidate) && dependenciesLikelyMissing(cwd)) {
+        if (!bootstrapProvidedDependencies && needsNodeModules(candidate, cwd)) {
+            // This command genuinely needs node_modules that are absent. Mark it
+            // blocked, but do NOT abort — a following no-dep command (or one in a
+            // different cwd that DOES have deps) must still get its chance to run.
             summary.commandsRun.push(commandRecord(candidate, cwd, startedAt, {
-                stderr: 'Dependencies appear to be missing: package.json and a lockfile are present, but node_modules is absent. Configure validation.bootstrapCommands in repo mesh/refine config if Refinery should install/bootstrap before validation.',
+                stderr: 'Dependencies appear to be missing: package.json and a lockfile are present, but node_modules is absent. Configure validation.bootstrapCommands (or .adhdev/worktree_bootstrap.json) in repo mesh/refine config if Refinery should install/bootstrap before validation.',
             }, false, {
                 exitCode: null,
                 skipped: true,
                 failureKind: 'missing_dependencies',
             }));
-            summary.status = 'failed';
-            summary.failureKind = 'missing_dependencies';
-            summary.failureCode = 'missing_dependencies';
-            return summary;
+            missingDepsBlocked = true;
+            continue;
         }
         // See the bootstrap loop above: resolve the win32 .cmd shim to an
         // absolute path before handing it to the spawn boundary.
@@ -1681,6 +1775,18 @@ export async function runMeshRefineValidationGate(
         }
     }
 
+    // (b) A command that genuinely needed deps could not run. Surface it as the
+    // gate failure now (after letting no-dep / deps-present commands run), so the
+    // caller can classify it blocked_review and emit a self-service hint. Every
+    // daemon-scoped command in a web-only branch was already filtered above, so a
+    // missing-deps block here is a real affected-command block.
+    if (missingDepsBlocked) {
+        summary.status = 'failed';
+        summary.failureKind = 'missing_dependencies';
+        summary.failureCode = 'missing_dependencies';
+        return summary;
+    }
+
     summary.status = 'passed';
     return summary;
 }

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

@@ -591,6 +591,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;
@@ -904,6 +913,10 @@ export function enqueueTask(
     // an unconfigured preset just leaves the explicit values (or none) in place.
     let effectiveModel = typeof opts?.model === 'string' && opts.model.trim() ? opts.model.trim() : undefined;
     let effectiveThinkingLevel = typeof opts?.thinkingLevel === 'string' && opts.thinkingLevel.trim() ? opts.thinkingLevel.trim() : undefined;
+    // SLOT-ROUTING: persist the difficulty class on the entry so the scheduler can
+    // match it against node capability slots at assignment time (not just resolve
+    // model/thinking here). Absent/invalid → undefined (task carries no difficulty).
+    const taskDifficulty = isMeshTaskDifficulty(opts?.difficulty) ? (opts!.difficulty as MeshTaskDifficulty) : undefined;
     if (isMeshTaskDifficulty(opts?.difficulty)) {
         try {
             const preset = getDifficultyBrains()[opts!.difficulty as MeshTaskDifficulty];
@@ -951,6 +964,7 @@ export function enqueueTask(
             ...(typeof opts?.consensusGroupId === 'string' && opts.consensusGroupId.trim() ? { consensusGroupId: opts.consensusGroupId.trim() } : {}),
             ...(effectiveModel ? { model: effectiveModel } : {}),
             ...(effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {}),
+            ...(taskDifficulty ? { difficulty: taskDifficulty } : {}),
             ...(typeof opts?.sourceCoordinatorSessionId === 'string' && opts.sourceCoordinatorSessionId.trim()
                 ? { sourceCoordinatorSessionId: opts.sourceCoordinatorSessionId.trim() }
                 : {}),

package/src/repo-mesh-types.ts

@@ -14,7 +14,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';
 
 // ─── Core Mesh Types ────────────────────────────
 
@@ -139,13 +139,18 @@ export type RepoMeshSchedulingStrategy =
     | 'first_eligible'
     | 'least_loaded'
     | 'round_robin'
-    | 'priority_only';
+    | 'priority_only'
+    // ORCHESTRATION_NODE_SLOTS.md: rank nodes by task→capability-slot fitness
+    // (task difficulty/requiredTags vs the node's slots), then priority/load/order.
+    // Falls back to load ordering when no task is in scope (idle-session drain).
+    | 'fitness';
 
 export const MESH_SCHEDULING_STRATEGIES: RepoMeshSchedulingStrategy[] = [
     'first_eligible',
     'least_loaded',
     'round_robin',
     'priority_only',
+    'fitness',
 ];
 
 export const DEFAULT_MESH_SCHEDULING_STRATEGY: RepoMeshSchedulingStrategy = 'first_eligible';
@@ -403,8 +408,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.
@@ -440,7 +459,11 @@ export const DEFAULT_MESH_POLICY: RepoMeshPolicy = {
     allowAutoPublishSubmoduleMainCommits: false,
     requireApprovalForDestructiveGit: true,
     dirtyWorkspaceBehavior: 'warn',
-    maxParallelTasks: 2,
+    // Mesh-wide task cap is effectively unlimited by default: the real concurrency
+    // limits live per node / per capability slot (ORCHESTRATION_NODE_SLOTS.md), so a
+    // global ceiling is rarely meaningful. The UI hides this control; set it via the
+    // API only to impose a deliberate mesh-wide cap.
+    maxParallelTasks: 200,
     // Coordinator-spawned worker sessions default to hidden so the dashboard is not
     // flooded with mesh noise tabs/notifications. Users can still surface or unmute
     // any specific session manually; that override is preserved per-device.
@@ -1143,6 +1166,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/src/shared-types.ts

@@ -416,6 +416,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
@@ -488,6 +495,7 @@ export interface CompactSessionEntry {
     completionMarker?: string;
     seenCompletionMarker?: string;
     surfaceHidden?: boolean;
+    muted?: boolean;
     controlValues?: Record<string, string | number | boolean>;
     providerControls?: ProviderControlSchema[];
     summaryMetadata?: ProviderSummaryMetadata;