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

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-refine-gates.d.ts

@@ -11,6 +11,7 @@
  * keep working. `CommandRouterResult` is imported type-only from router.ts
  * (erased at compile time — no runtime import cycle).
  */
+import type { ChangedPackageClassification } from '../git/git-status.js';
 import type { WorktreeBootstrapState } from '../mesh/worktree-bootstrap-config.js';
 import type { CommandRouterResult } from '../commands/router.js';
 export type MeshCoordinatorConfigFormat = 'claude_mcp_json' | 'hermes_config_yaml';
@@ -53,6 +54,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';
 type MeshRefinePatchEquivalenceSummary = {
@@ -277,6 +291,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>>;
@@ -424,5 +445,13 @@ export declare function runMeshRefineValidationGate(mesh: any, workspace: string
     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>;
 export {};

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.487",
   "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.487",
+    "@adhdev/session-host-core": "0.9.82-rc.487",
     "@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/commands/router-refine.ts

@@ -17,6 +17,8 @@ import { handleMeshForwardEvent, queuePendingMeshCoordinatorEvent } from '../mes
 import { analyzeMeshRefineNodeChangeArea, orderMeshRefineBatchNodes } from '../mesh/mesh-refine-batch.js';
 import type { WorktreeBootstrapState } from '../mesh/worktree-bootstrap-config.js';
 import { DEFAULT_MESH_POLICY } from '../repo-mesh-types.js';
+import { classifyChangedPackages } from '../git/git-status.js';
+import type { ChangedPackageClassification } from '../git/git-status.js';
 import { readStringValue } from '../mesh/mesh-node-identity.js';
 import {
     alignRefinerySubmodulesAfterMerge,
@@ -312,7 +314,24 @@ export async function refineResolveRefsStage(self: DaemonCommandRouter,
             const { stdout: branchHeadStdout } = await execFileAsync('git', ['rev-parse', branch], { cwd: node.workspace, encoding: 'utf8' });
             const baseHead = baseHeadRaw;
             const branchHead = branchHeadStdout.trim();
-            recordMeshRefineStage(refineStages, 'resolve_refs', 'passed', resolveStarted, { branch, baseBranch, baseHead, branchHead, ...(fetchWarning ? { fetchWarning } : {}) });
+
+            // Coarse daemon-vs-web change-impact for baseHead..branchHead, computed
+            // against the worktree so the same policy (.adhdev/change-impact.*) as the
+            // stale-build detector applies. Threaded onto ctx so the validation gate
+            // can scope its command set: a web-only branch skips daemon-scoped commands.
+            // FAIL-OPEN: any classification error leaves changeImpact undefined → the
+            // gate runs the full command set (never skip on uncertainty).
+            let changeImpact: ChangedPackageClassification | undefined;
+            try {
+                changeImpact = await classifyChangedPackages(node.workspace, baseHead, branchHead);
+            } catch {
+                changeImpact = undefined;
+            }
+            recordMeshRefineStage(refineStages, 'resolve_refs', 'passed', resolveStarted, {
+                branch, baseBranch, baseHead, branchHead,
+                ...(changeImpact ? { changeImpact } : {}),
+                ...(fetchWarning ? { fetchWarning } : {}),
+            });
 
             return {
                 kind: 'continue',
@@ -330,6 +349,7 @@ export async function refineResolveRefsStage(self: DaemonCommandRouter,
                     baseBranch,
                     baseHead,
                     branchHead,
+                    changeImpact,
                     validationSummary: undefined as any,
                     patchEquivalence: undefined as any,
                     submoduleReachability: undefined as any,
@@ -346,6 +366,9 @@ export async function refineValidationStage(self: DaemonCommandRouter, ctx: Refi
             const { mesh, node, branch, baseBranch, refineStages } = ctx;
             const validationStarted = Date.now();
             const validationSummary = await runMeshRefineValidationGate(mesh, node.workspace, {
+                // (a) Scope the validation command set by coarse change-impact (resolved
+                // in resolve_refs). Undefined → gate runs the full command set (fail-open).
+                changeImpact: ctx.changeImpact,
                 // M2-2: consume the node's persisted bootstrap state; persist re-runs.
                 persistedBootstrapState: (node as any).worktreeBootstrap as WorktreeBootstrapState | undefined,
                 onBootstrapStateChange: (state) => {
@@ -369,7 +392,9 @@ export async function refineValidationStage(self: DaemonCommandRouter, ctx: Refi
                     : undefined;
                 const buildValidationFailedError = (): string => {
                     const base = validationSummary.failureCode === 'missing_dependencies'
-                        ? 'Refinery validation dependencies are missing; merge/refine was not attempted. Configure validation.bootstrapCommands if Refinery should bootstrap dependencies before validation.'
+                        ? 'Refinery validation dependencies are missing for a change-affected package; merge/refine was not attempted. '
+                            + 'To make this self-service, either (1) configure .adhdev/worktree_bootstrap.json (or validation.bootstrapCommands in .adhdev/refine.json) so Refinery installs deps before validation, '
+                            + 'or (2) converge the branch via the documented manual fast-forward-only bypass (rebase onto the fetched base, verify strict ancestry, then push ff-only) instead of the refine gate.'
                         : validationSummary.failureCode === 'dependency_bootstrap_failed'
                             ? 'Refinery dependency/bootstrap command failed; merge/refine was not attempted.'
                             : validationSummary.failureCode === 'spawn_resolution_failed'

package/src/git/git-status.ts

@@ -438,6 +438,54 @@ function isNonRuntimeRootFile(file: string, policy: ResolvedChangeImpactPolicy):
   return false;
 }
 
+/** Coarse change-impact verdict produced from a changed-file list. */
+export interface ChangedPackageClassification {
+  isDaemonAffecting: boolean;
+  affectedPackages: string[];
+}
+
+/**
+ * Pure bucketer: classify an already-collected changed-file list into the coarse
+ * daemon-vs-web verdict, per the resolved policy. Shared by classifyDaemonBuildChange
+ * (buildCommit..HEAD) and classifyChangedPackages (arbitrary ref range) so the
+ * daemon/web boundary logic lives in exactly one place. An empty list stays
+ * conservative (daemon-affecting) so an actionable warning is never suppressed.
+ */
+function classifyChangedFileList(
+  files: string[],
+  policy: ResolvedChangeImpactPolicy,
+): ChangedPackageClassification {
+  if (files.length === 0) {
+    // No file diff (e.g. only merge metadata) — nothing actionable, but stay
+    // conservative and treat as daemon-affecting so we don't suppress a real warning.
+    return { isDaemonAffecting: true, affectedPackages: [] };
+  }
+  const pkgs = new Set<string>();
+  // A non-package path that is NOT a recognized benign root file (marker/doc).
+  // Only these force daemon-affecting; benign markers/docs are ignored so a
+  // gitlink-moving root commit over a marker-only oss commit no longer over-warns.
+  let sawRuntimeAmbiguousNonPackage = false;
+  for (const file of files) {
+    const match = file.match(/(?:^|\/)packages\/([^/]+)\//);
+    if (!match) {
+      if (!isNonRuntimeRootFile(file, policy)) sawRuntimeAmbiguousNonPackage = true;
+      continue;
+    }
+    pkgs.add(match[1]);
+  }
+  const affectedPackages = [...pkgs].sort();
+  // Daemon-affecting if: any runtime-ambiguous non-package file changed, any
+  // unknown package changed, or any explicit daemon-runtime package changed.
+  // The daemon is unaffected only when every changed file is either a known
+  // web-only package or a recognized benign root file (and at least one such
+  // file changed) — i.e. nothing runtime-ambiguous remains. Unlisted/new packages
+  // therefore stay daemon-affecting (fail-safe default preserved).
+  const allBenign =
+    !sawRuntimeAmbiguousNonPackage &&
+    affectedPackages.every((p) => policy.webOnlyPackages.has(p) && !policy.daemonRuntimePackages.has(p));
+  return { isDaemonAffecting: !allBenign, affectedPackages };
+}
+
 /**
  * Determine whether the changes between buildCommit..HEAD touch any daemon-runtime
  * package, per the resolved policy. Returns isDaemonAffecting:true conservatively
@@ -449,47 +497,54 @@ async function classifyDaemonBuildChange(
   buildCommit: string,
   options: GitStatusOptions,
   policy: ResolvedChangeImpactPolicy,
-): Promise<{ isDaemonAffecting: boolean; affectedPackages: string[] }> {
+): Promise<ChangedPackageClassification> {
   try {
     const diff = await runGit(repoPath, ['diff', '--name-only', `${buildCommit}..HEAD`], options);
     const files = diff.stdout
       .split('\n')
       .map((line) => line.trim())
       .filter(Boolean);
-    if (files.length === 0) {
-      // No file diff (e.g. only merge metadata) — nothing actionable, but stay
-      // conservative and treat as daemon-affecting so we don't suppress a real warning.
-      return { isDaemonAffecting: true, affectedPackages: [] };
-    }
-    const pkgs = new Set<string>();
-    // A non-package path that is NOT a recognized benign root file (marker/doc).
-    // Only these force daemon-affecting; benign markers/docs are ignored so a
-    // gitlink-moving root commit over a marker-only oss commit no longer over-warns.
-    let sawRuntimeAmbiguousNonPackage = false;
-    for (const file of files) {
-      const match = file.match(/(?:^|\/)packages\/([^/]+)\//);
-      if (!match) {
-        if (!isNonRuntimeRootFile(file, policy)) sawRuntimeAmbiguousNonPackage = true;
-        continue;
-      }
-      pkgs.add(match[1]);
-    }
-    const affectedPackages = [...pkgs].sort();
-    // Daemon-affecting if: any runtime-ambiguous non-package file changed, any
-    // unknown package changed, or any explicit daemon-runtime package changed.
-    // The daemon is unaffected only when every changed file is either a known
-    // web-only package or a recognized benign root file (and at least one such
-    // file changed) — i.e. nothing runtime-ambiguous remains.
-    const allBenign =
-      !sawRuntimeAmbiguousNonPackage &&
-      affectedPackages.every((p) => policy.webOnlyPackages.has(p) && !policy.daemonRuntimePackages.has(p));
-    return { isDaemonAffecting: !allBenign, affectedPackages };
+    return classifyChangedFileList(files, policy);
   } catch {
     // diff probe failed → can't prove web-only; stay conservative.
     return { isDaemonAffecting: true, affectedPackages: [] };
   }
 }
 
+/**
+ * Ref-parameterized change-impact classification for a repo/worktree, reusing the
+ * exact daemon-vs-web bucketing that the stale-build detector uses — but over an
+ * arbitrary `fromRef..toRef` range (e.g. a refine base head → branch head) instead
+ * of the live daemon's build commit → HEAD, and WITHOUT any daemonBuildInfo caching.
+ *
+ * Policy is resolved the same way as getGitRepoStatus: an explicit
+ * `options.changeImpactConfig` wins; otherwise the repo's `.adhdev/change-impact.*`
+ * is auto-loaded; otherwise the built-in ADHDev default policy applies. The
+ * classification uses `git diff --name-only fromRef..toRef`.
+ *
+ * FAIL-OPEN on error: if the diff can't be collected (bad ref, not a repo), the
+ * caller should treat "no verdict" as "run everything" — so we throw rather than
+ * returning a misleading benign verdict. Callers wrap this in try/catch and leave
+ * changeImpact undefined on failure. Unclassified/new packages still default to
+ * isDaemonAffecting:true (never silently skipped).
+ */
+export async function classifyChangedPackages(
+  repoPath: string,
+  fromRef: string,
+  toRef: string,
+  options: GitStatusOptions = {},
+): Promise<ChangedPackageClassification> {
+  const repo = await resolveGitRepository(repoPath, options);
+  const { config } = resolveChangeImpactConfigForRepo(repo.repoRoot, options);
+  const policy = resolveChangeImpactPolicy(config);
+  const diff = await runGit(repoPath, ['diff', '--name-only', `${fromRef}..${toRef}`], options);
+  const files = diff.stdout
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean);
+  return classifyChangedFileList(files, policy);
+}
+
 /**
  * Resolve the Change Impact config to apply for this status read. Priority:
  *   - options.changeImpactConfig === null → force built-in default policy (no load).

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