@adhdev/daemon-core 0.9.82-rc.508 → 0.9.82-rc.509

package/dist/mesh/mesh-node-slots.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Node capability-slot resolution — the single source of truth for a node's
+ * effective slots (ORCHESTRATION_NODE_SLOTS.md). Every layer that needs a node's
+ * slots (queue claim/launch caps, scheduling-runtime status projection, coordinator
+ * prompt) resolves them here so the "explicit policy.slots, else legacy-derived"
+ * rule is applied identically everywhere.
+ *
+ * Kept as a tiny standalone module (rather than living in mesh-queue-assignment)
+ * so importing slot resolution does not drag in the whole assignment engine and to
+ * avoid an import cycle between the status builder and the assignment engine.
+ */
+import { type NodeCapabilitySlot } from '@adhdev/mesh-shared';
+/** Ordered, de-duplicated providerPriority from a node policy (defensive). */
+export declare function normalizeProviderPriority(policy: unknown): string[];
+/**
+ * Resolve a node's capability slots: explicit `policy.slots` when present, else
+ * derived from the legacy `providerPriority` + machine-global difficultyBrains.
+ * (The former per-provider `providerRoles` cap has been removed; a persisted
+ * meshes.json is migrated to slots on load, so by the time a node reaches routing
+ * its cap already lives on `slots[].maxParallel`.)
+ */
+export declare function resolveNodeCapabilitySlots(node: any): NodeCapabilitySlot[];

package/dist/mesh/mesh-runtime-store.d.ts

@@ -90,8 +90,8 @@ export declare class MeshRuntimeStore {
     /**
      * Count active (status='assigned') tasks on a (node, provider) combination,
      * matched by the assignedProviderType stamped on the payload at claim time.
-     * Drives the per-(node, provider) maxParallel cap (RepoMeshNodePolicy
-     * providerRoles). The active-assignment set for a single node is tiny, so
+     * Drives the per-(node, provider) maxParallel cap (summed across a provider's
+     * slots[].maxParallel). The active-assignment set for a single node is tiny, so
      * parsing payloads here is cheap and avoids a schema migration. Pre-cap legacy
      * rows (no provider stamp) and other providers on the same node do not consume
      * this provider's budget, so the cap is fully backward compatible.

package/dist/mesh/mesh-scheduling-runtime.d.ts

@@ -19,7 +19,11 @@ export interface MeshNodeSchedulingRuntime {
     schedulingPriority: number;
     /** Per-node concurrent-session cap, when configured. */
     maxConcurrentSessions?: number;
-    /** Per-(node, provider) caps + consumption, when providerRoles declares any. */
+    /**
+     * Per-(node, provider) caps + consumption, when the node's slots declare a
+     * maxParallel for any provider. (Field name kept for dashboard back-compat;
+     * the cap source is now slots[].maxParallel, not the removed providerRoles.)
+     */
     providerRoles?: MeshNodeProviderSchedulingRuntime[];
     /**
      * True when the node currently cannot claim a NEW write (non-readonly) task —

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

@@ -147,8 +147,8 @@ export interface MeshWorkQueueEntry {
     assignedSessionId?: string;
     /**
      * Provider type of the session that claimed the task. Recorded so the queue
-     * can enforce per-(node, provider) maxParallel caps (RepoMeshNodePolicy
-     * providerRoles) by counting active assignments grouped by node + provider.
+     * can enforce per-(node, provider) maxParallel caps (summed slots[].maxParallel)
+     * by counting active assignments grouped by node + provider.
      */
     assignedProviderType?: string;
     /** Human/operator reason for terminal cancellation. */
@@ -323,7 +323,7 @@ export declare function getMeshQueueRevision(meshId: string): string;
  *
  * `opts.providerType` is stamped onto the claimed entry (assignedProviderType) so
  * per-(node, provider) caps can be counted. `opts.providerMaxParallel`, when set,
- * is the enforced per-(node, provider) cap from RepoMeshNodePolicy.providerRoles:
+ * is the enforced per-(node, provider) cap (summed slots[].maxParallel):
  * a task is not assigned to this (node, provider) once it already has that many
  * active assignments. This composes with the global/taskMode caps (stricter wins).
  */

package/dist/providers/cli-provider-instance-types.d.ts

@@ -38,6 +38,7 @@ export type ExternalTranscriptProbe = {
 export declare const COMPLETED_FINALIZATION_RETRY_MS = 1000;
 export declare const COMPLETED_FINALIZATION_MAX_WAIT_MS = 30000;
 export declare const NATIVE_HISTORY_MESH_IDLE_SETTLE_MS = 4000;
+export declare const PTY_PARSED_FINAL_ASSISTANT_QUIET_DWELL_MS = 1200;
 export declare const BACKGROUND_TASK_HOLD_MAX_MS: number;
 export declare const USER_INPUT_ACK_DEDUP_WINDOW_MS = 60000;
 export declare const STARTUP_GRACE_IDLE_COLLAPSE_WINDOW_MS = 12000;

package/dist/providers/cli-provider-instance.d.ts

@@ -114,6 +114,39 @@ export declare class CliProviderInstance implements ProviderInstance {
      * the nudge was NOT deferred) and leaked to the coordinator.
      */
     private static readonly AUTO_APPROVE_MASK_STALL_MS;
+    /**
+     * AUTOAPPROVE-FLAP-INBOX-MISSING: sticky-approval overlay window. Same time-tick
+     * hold idea as the FALSE-IDLE completion gate — an approval signal that was
+     * DOMINANT within this recent window is re-presented across a momentary busy blip
+     * instead of collapsing.
+     *
+     * RCA (live 2026-07-13): a claude-cli worker sitting at a Bash approval modal
+     * ("Do you want to proceed? ❯1.Yes") flaps waiting_approval↔busy on a ~2-3s period.
+     * The spec `approval→busy` transition fires whenever the footer/modal approval
+     * markers momentarily drop out of their parsed sections while the PRIOR command's
+     * residual spinner text ("✳ Checking vendor drift…") still matches the busy regex.
+     * On the busy frame the adapter reports status='generating', activeModal=null. That
+     * corrupts THREE consumers at once: (1) mesh_active_work samples 'generating' →
+     * collectPendingApprovals never sees 'awaiting_approval' → mesh_list_pending_approvals
+     * count:0 (inbox miss); (2) the auto-approve settle gate is torn down each busy phase
+     * so the 600ms settle never accrues → auto-approve never fires; (3) a mesh_approve
+     * landing on a busy frame hits "Not in approval state". The existing FLAP machinery
+     * (AUTO_APPROVE_FLAP_CONTINUITY_MS) only keeps the settle gate warm while status is
+     * STILL waiting_approval (buttons scrolled out) — it does nothing once the FSM fully
+     * commits to 'busy', and it never stabilises the status the inbox samples.
+     *
+     * Fix: when the raw adapter status flaps to generating/busy/idle but a
+     * waiting_approval WITH a concrete modal was observed within this window, overlay
+     * the cached modal and report status='waiting_approval'. This stabilized status
+     * feeds getState (→ inbox), detectStatusTransition (→ event emission), and
+     * maybeAutoApproveStatus (→ settle gate) uniformly, so the approval both registers
+     * in the inbox and settles for auto-approve across the flap. Bounded (a genuine
+     * resume that never returns to approval unmasks after this window) and scoped at the
+     * call site to autonomous mesh sessions. 4000ms bridges the observed ~2-3s flap with
+     * margin while staying well under AUTO_APPROVE_MASK_STALL_MS (a truly stalled/absent
+     * approval still surfaces).
+     */
+    private static readonly APPROVAL_STICKY_FLAP_MS;
     /**
      * FALSE-IDLE (inter-approval quiet valley): grace window after an auto-approve
      * (or mesh_approve) RESOLVES a modal during which a subsequent generating→idle
@@ -159,6 +192,9 @@ export declare class CliProviderInstance implements ProviderInstance {
     private autoApproveSettleTimer;
     private autoApproveInactiveSince;
     private autoApproveLastModalSeenAt;
+    private approvalStickyLastConcreteAt;
+    private approvalStickyModal;
+    private approvalStickyEntrySeq;
     private autoApproveMaskSince;
     private stalledApprovalNudgeEpisode;
     private readonly manualAttendance;
@@ -487,6 +523,24 @@ export declare class CliProviderInstance implements ProviderInstance {
      * the emitted event, exactly as each inline builder produced before.
      */
     private emitGeneratingCompleted;
+    /**
+     * AUTOAPPROVE-FLAP-INBOX-MISSING sticky-approval overlay. Returns the adapterStatus a
+     * flap-prone claude-cli approval SHOULD present this frame — either the raw status
+     * unchanged, or, when the raw status has momentarily flapped OFF a recently-dominant
+     * concrete approval, a synthetic `waiting_approval` re-presenting the cached modal.
+     *
+     * Records the concrete approval whenever the raw status is waiting_approval WITH
+     * buttons. On a subsequent non-approval frame (the spec `approval→busy` flap), if that
+     * concrete approval was seen within APPROVAL_STICKY_FLAP_MS AND the engine has NOT
+     * resolved a modal since (lastApprovalResolvedAt not advanced past the sticky start),
+     * overlay the cached modal + waiting_approval so the inbox / auto-approve / mesh_approve
+     * all see the stable approval. A genuine resolution (auto-approve or mesh_approve fires
+     * resolveModal → lastApprovalResolvedAt advances) clears the sticky immediately, so a
+     * legitimate post-approval resume is NEVER masked as a lingering approval. Bounded by the
+     * window, and scoped to autonomous mesh sessions (a foreground/attended or non-mesh
+     * session, where a human answers the prompt, is returned untouched).
+     */
+    private stabilizeFlappingApprovalStatus;
     private maybeAutoApproveStatus;
     /**
      * Re-drive the auto-approve check after the settle quiet window elapses.

package/dist/repo-mesh-types.d.ts

@@ -291,16 +291,15 @@ export interface RepoMeshRelatedRepo {
  * must satisfy both. Omitting `maxParallel` means this provider is bounded only
  * by the global/taskMode caps (full backward compatibility).
  *
- * Routing is governed exclusively by required_tags (see nodeSatisfiesRequiredTags);
- * this entry carries no routing role. To route work to a specific node, advertise an
- * ordinary capability tag on the node and require it on the task.
+ * Routing is governed exclusively by required_tags (see nodeSatisfiesRequiredTags).
+ * To route work to a specific node, advertise an ordinary capability tag on the
+ * node and require it on the task.
+ *
+ * NOTE: the per-(node, provider) parallelism cap now lives on `slots[].maxParallel`
+ * (see NodeCapabilitySlot). The former `providerRoles` field has been removed; a
+ * persisted meshes.json that still carries it is migrated to `slots` on load
+ * (see migrateLoadedMeshConfig).
  */
-export interface RepoMeshProviderRole {
-    /** Provider type this entry governs (e.g. 'claude-cli', 'codex-cli'). */
-    providerType: string;
-    /** Max concurrent active tasks for this (node, provider). Omit = no per-provider cap. */
-    maxParallel?: number;
-}
 export interface RepoMeshNodePolicy {
     readOnly?: boolean;
     canPush?: boolean;
@@ -315,26 +314,14 @@ export interface RepoMeshNodePolicy {
     schedulingPriority?: number;
     /** Ordered provider preference used when mesh_launch_session omits an explicit type. */
     providerPriority?: string[];
-    /**
-     * Per-(node, provider) parallelism declarations. Each entry binds a
-     * providerType on THIS node to an optional maxParallel cap. maxParallel is
-     * 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.
+     * providerPriority/difficultyBrains (deriveSlotsFromLegacy) so existing nodes
+     * keep working without reconfiguration.
      */
     slots?: NodeCapabilitySlot[];
     /**
@@ -448,13 +435,22 @@ export declare function mergeAndNormalizePolicy(base: RepoMeshPolicy | undefined
  */
 export declare function resolveDelegatedWorkerAutoApprove(meshPolicy?: Pick<RepoMeshPolicy, 'delegatedWorkerAutoApprove'> | null, nodePolicy?: Pick<RepoMeshNodePolicy, 'delegatedWorkerAutoApprove'> | null): boolean;
 /**
- * Resolve the enforced per-(node, provider) maxParallel cap, or undefined when
- * no finite, non-negative cap is declared for this provider. Used by the queue
- * claim path as a stricter-wins constraint layered on top of the global caps.
- * Case-insensitive, trimmed match on providerType. Defensive against malformed
- * config — non-object entries and blank providerTypes are skipped rather than throwing.
+ * Resolve the enforced per-(node, provider) maxParallel cap from a node's resolved
+ * capability slots, or undefined when no matching slot declares a finite cap. Used
+ * by the queue claim path as a stricter-wins constraint layered on top of the global
+ * caps. Case-insensitive, trimmed match on the slot's provider.
+ *
+ * When a node declares multiple slots for the same provider (e.g. distinct
+ * difficulty ranges), their caps SUM into a single per-(node, provider) pool — the
+ * provider can run up to the total across all its slots. Legacy-derived slots (via
+ * deriveSlotsFromLegacy) produce one slot per provider, so the sum equals that
+ * single slot's cap and behavior is preserved exactly.
+ *
+ * Callers pass the already-resolved slots (explicit policy.slots, else legacy-
+ * derived) — this keeps the resolver free of the difficultyBrains dependency and
+ * usable from any layer.
  */
-export declare function resolveProviderMaxParallel(nodePolicy: Pick<RepoMeshNodePolicy, 'providerRoles'> | null | undefined, providerType: string | null | undefined): number | undefined;
+export declare function resolveProviderMaxParallel(slots: NodeCapabilitySlot[] | null | undefined, providerType: string | null | undefined): number | undefined;
 export interface RepoMeshNodeCapabilities {
     /** Node's OS, raw NodeJS.Platform value ("darwin"/"win32"/"linux"). For
      *  remote member nodes this is stamped by the member daemon at join time
@@ -700,6 +696,11 @@ export interface RepoMeshNodeSchedulingStatus {
     load: number;
     schedulingPriority?: number;
     maxConcurrentSessions?: number;
+    /**
+     * Per-(node, provider) caps + consumption. Field name kept for dashboard
+     * back-compat; the cap source is now slots[].maxParallel (the removed
+     * policy.providerRoles no longer exists).
+     */
     providerRoles?: RepoMeshNodeProviderSchedulingStatus[];
     capReached: boolean;
     capReasons?: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.508",
+  "version": "0.9.82-rc.509",
   "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.508",
-    "@adhdev/session-host-core": "0.9.82-rc.508",
+    "@adhdev/mesh-shared": "0.9.82-rc.509",
+    "@adhdev/session-host-core": "0.9.82-rc.509",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/commands/med-family/mesh-crud.ts

@@ -489,17 +489,20 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
         const ownerFailure = await ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, 'node addition');
         if (ownerFailure) return ownerFailure;
         try {
-            const { addNode } = await import('../../config/mesh-config.js');
+            const { addNode, migrateProviderRolesToSlots } = await import('../../config/mesh-config.js');
             const providerPriority = Array.isArray(args?.providerPriority)
                 ? args.providerPriority.map((type: any) => typeof type === 'string' ? type.trim() : '').filter(Boolean)
                 : [];
             const readOnly = args?.readOnly === true;
+            // Back-compat: an incoming `providerRoles` arg (legacy callers) is folded
+            // into `slots[].maxParallel` — the field itself is no longer persisted.
             const providerRoles = normalizeProviderRoles(args?.providerRoles);
-            const policy = {
+            const policy: Record<string, unknown> = {
                 ...(readOnly ? { readOnly: true } : {}),
                 ...(providerPriority.length ? { providerPriority } : {}),
                 ...(providerRoles.length ? { providerRoles } : {}),
             };
+            if (providerRoles.length) migrateProviderRolesToSlots(policy);
             const role = normalizeMeshDaemonRole(args?.role);
             const daemonId = typeof args?.daemonId === 'string' && args.daemonId.trim() ? args.daemonId.trim() : undefined;
             const machineId = typeof args?.machineId === 'string' && args.machineId.trim() ? args.machineId.trim() : undefined;
@@ -537,7 +540,7 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
         const ownerFailure = await ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, 'node update');
         if (ownerFailure) return ownerFailure;
         try {
-            const { updateNode, normalizeCapabilityTags } = await import('../../config/mesh-config.js');
+            const { updateNode, normalizeCapabilityTags, migrateProviderRolesToSlots } = await import('../../config/mesh-config.js');
             const policy = args?.policy && typeof args.policy === 'object' && !Array.isArray(args.policy)
                 ? { ...(args.policy as Record<string, unknown>) }
                 : {};
@@ -552,18 +555,17 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
                     delete (policy as any).providerPriority;
                 }
             }
-            // providerRoles: per-(node, provider) role label + maxParallel cap.
-            // Passing an explicit (possibly empty) array clears/replaces the
-            // declarations; omitting the arg leaves any value already on policy
-            // untouched (a full policy object passed by the caller still carries it).
+            // Back-compat: a legacy `providerRoles` arg is folded into
+            // `slots[].maxParallel` — the per-(node, provider) cap now lives on slots.
+            // The field itself is never persisted (migrateProviderRolesToSlots deletes
+            // it). A full policy object passed by the caller that still carries
+            // providerRoles is likewise migrated.
             if (Array.isArray(args?.providerRoles)) {
                 const providerRoles = normalizeProviderRoles(args.providerRoles);
-                if (providerRoles.length) {
-                    (policy as any).providerRoles = providerRoles;
-                } else {
-                    delete (policy as any).providerRoles;
-                }
+                if (providerRoles.length) (policy as any).providerRoles = providerRoles;
+                else delete (policy as any).providerRoles;
             }
+            migrateProviderRolesToSlots(policy);
             const patch: Record<string, unknown> = { policy: policy as any };
             if (typeof args?.systemPrompt === 'string') {
                 const trimmed = (args.systemPrompt as string).trim();
@@ -1011,8 +1013,14 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
             }
 
             let node: any;
+            const { migrateProviderRolesToSlots } = await import('../../config/mesh-config.js');
             if (meshRecord.inline) {
                 const { randomUUID } = await import('crypto');
+                const clonedPolicy: Record<string, unknown> = { ...(sourceNode.policy || {}) };
+                // Defensive: a source policy that still carries the removed legacy
+                // providerRoles (e.g. an inline node not yet load-migrated) has its cap
+                // folded into slots so the clone never re-seeds providerRoles.
+                migrateProviderRolesToSlots(clonedPolicy);
                 node = {
                     id: `node_${randomUUID().replace(/-/g, '')}`,
                     workspace: result.worktreePath,
@@ -1020,7 +1028,7 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
                     daemonId: sourceNode.daemonId,
                     machineId: sourceNode.machineId ?? (sourceNode as any).machine_id,
                     userOverrides: { ...(sourceNode.userOverrides || {}) },
-                    policy: { ...(sourceNode.policy || {}) },
+                    policy: clonedPolicy as any,
                     isLocalWorktree: true,
                     worktreeBranch: result.branch,
                     clonedFromNodeId: sourceNodeId,
@@ -1028,6 +1036,8 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
                 ctx.updateInlineMeshNode(meshId, mesh, node);
             } else {
                 const { addNode } = await import('../../config/mesh-config.js');
+                const clonedPolicy: Record<string, unknown> = { ...(sourceNode.policy || {}) };
+                migrateProviderRolesToSlots(clonedPolicy);
                 node = addNode(meshId, {
                     workspace: result.worktreePath,
                     repoRoot: result.worktreePath,
@@ -1037,7 +1047,7 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
                     isLocalWorktree: true,
                     worktreeBranch: result.branch,
                     clonedFromNodeId: sourceNodeId,
-                    policy: { ...(sourceNode.policy || {}) },
+                    policy: clonedPolicy as any,
                 });
                 if (!node) return { success: false, error: 'Failed to register worktree node' };
                 // Also reconcile the freshly-registered node into any warmed inline

package/src/config/mesh-config.ts

@@ -22,8 +22,8 @@ import type {
     RepoMeshHostMetadata,
     RepoMeshDaemonRole,
 } from '../repo-mesh-types.js';
-import type { MagiKindPanelMap, MagiSlot, MagiTaskKind, DifficultyBrainMap } from '@adhdev/mesh-shared';
-import { normalizeDifficultyBrainMap, DEFAULT_DIFFICULTY_BRAINS } from '@adhdev/mesh-shared';
+import type { MagiKindPanelMap, MagiSlot, MagiTaskKind, DifficultyBrainMap, NodeCapabilitySlot } from '@adhdev/mesh-shared';
+import { normalizeDifficultyBrainMap, DEFAULT_DIFFICULTY_BRAINS, normalizeNodeCapabilitySlots, deriveSlotsFromLegacy } from '@adhdev/mesh-shared';
 import { mergeAndNormalizePolicy } from '../repo-mesh-types.js';
 import { createDefaultMeshHostMetadata } from '../mesh/mesh-host-ownership.js';
 
@@ -63,12 +63,14 @@ function loadMeshConfig(): LocalMeshConfig {
  * outlived the feature that wrote it so the persisted config converges on the
  * current schema the next time it is saved.
  *
- * Currently: drops the dead `role` field from each node policy's providerRoles
- * entries. providerRoles is retained for its `maxParallel` per-(node, provider)
- * cap, but the routing `role` was removed (routing is governed solely by
- * required_tags). A meshes.json written before the removal still carries
- * `role: "validator"` etc.; this drops it on load so mesh_status / mesh_list_nodes
- * never surface the dead field and the next saveMeshConfig() persists it gone.
+ * Currently: migrates the removed `providerRoles` per-(node, provider) cap onto
+ * `slots[].maxParallel`. A meshes.json written before the removal carries
+ * `providerRoles: [{ providerType, maxParallel }]` (possibly alongside a dead
+ * `role` field). On load we fold each cap into the node's slots — into an existing
+ * matching-provider slot that has no cap, else by deriving slots from the legacy
+ * providerPriority/providerRoles when the node had no explicit slots — then delete
+ * `providerRoles` so mesh_status / mesh_list_nodes never surface the removed field
+ * and the next saveMeshConfig() persists it gone.
  *
  * Returns true when the config was mutated (caller may persist eagerly).
  */
@@ -77,31 +79,76 @@ function migrateLoadedMeshConfig(config: LocalMeshConfig): boolean {
     for (const mesh of config.meshes) {
         if (!mesh || !Array.isArray(mesh.nodes)) continue;
         for (const node of mesh.nodes) {
-            if (stripDeadRoleFromProviderRoles(node?.policy)) changed = true;
+            if (migrateProviderRolesToSlots(node?.policy)) changed = true;
         }
     }
     return changed;
 }
 
 /**
- * Drop the legacy `role` field from each providerRoles entry of a node policy,
- * in place. Keeps providerType + maxParallel (the still-meaningful per-(node,
- * provider) cap). Defensive against malformed entries — non-object items are
- * left untouched. Returns true when at least one `role` field was removed.
+ * Migrate a node policy's legacy `providerRoles` cap onto `slots[].maxParallel`,
+ * in place, then delete the `providerRoles` field. Defensive against malformed
+ * entries. Returns true when the policy was mutated.
+ *
+ * Behavior-preserving: the resulting slots carry the same per-(node, provider)
+ * cap the queue previously enforced from providerRoles. When the node had no
+ * explicit slots, slots are derived from the legacy providerPriority (folding the
+ * caps in via deriveSlotsFromLegacy-equivalent logic); when it did, each cap is
+ * merged into the first matching-provider slot lacking a maxParallel.
  */
-function stripDeadRoleFromProviderRoles(policy: unknown): boolean {
-    if (!policy || typeof policy !== 'object') return false;
-    const roles = (policy as { providerRoles?: unknown }).providerRoles;
-    if (!Array.isArray(roles)) return false;
-    let changed = false;
-    for (const entry of roles) {
-        if (entry && typeof entry === 'object' && !Array.isArray(entry)
-            && Object.prototype.hasOwnProperty.call(entry, 'role')) {
-            delete (entry as Record<string, unknown>).role;
-            changed = true;
+export function migrateProviderRolesToSlots(policy: unknown): boolean {
+    if (!policy || typeof policy !== 'object' || Array.isArray(policy)) return false;
+    const p = policy as Record<string, unknown>;
+    const rawRoles = p.providerRoles;
+    if (!Array.isArray(rawRoles)) return false;
+
+    // Extract provider → cap from the legacy roles (case-insensitive key, last wins).
+    const roleCap = new Map<string, { provider: string; cap: number }>();
+    for (const entry of rawRoles) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) continue;
+        const rec = entry as Record<string, unknown>;
+        const provider = typeof rec.providerType === 'string' ? rec.providerType.trim() : '';
+        if (!provider) continue;
+        const cap = Number(rec.maxParallel);
+        if (!Number.isFinite(cap) || cap < 0) continue;
+        roleCap.set(provider.toLowerCase(), { provider, cap: Math.floor(cap) });
+    }
+
+    const explicitSlots = Array.isArray(p.slots)
+        ? normalizeNodeCapabilitySlots(p.slots)
+        : [];
+
+    if (explicitSlots.length) {
+        // Merge each cap into the first matching-provider slot that has no cap yet.
+        for (const { provider, cap } of roleCap.values()) {
+            const target = explicitSlots.find(s =>
+                s.provider.trim().toLowerCase() === provider.toLowerCase()
+                && s.maxParallel === undefined);
+            if (target) target.maxParallel = cap;
         }
+        p.slots = explicitSlots;
+    } else if (roleCap.size) {
+        // No explicit slots: derive from legacy providerPriority, then fold caps in.
+        // Falls back to a provider-per-role slot list when providerPriority is empty
+        // so the cap is never silently dropped.
+        let difficultyBrains: DifficultyBrainMap | undefined;
+        try { difficultyBrains = getDifficultyBrains(); } catch { difficultyBrains = undefined; }
+        const priority = Array.isArray(p.providerPriority)
+            ? (p.providerPriority as unknown[]).map(t => typeof t === 'string' ? t.trim() : '').filter(Boolean)
+            : [];
+        const derived = deriveSlotsFromLegacy({ providerPriority: priority, difficultyBrains });
+        const slots: NodeCapabilitySlot[] = derived.length
+            ? derived
+            : [...roleCap.values()].map(r => ({ provider: r.provider }));
+        for (const slot of slots) {
+            const match = roleCap.get(slot.provider.trim().toLowerCase());
+            if (match && slot.maxParallel === undefined) slot.maxParallel = match.cap;
+        }
+        p.slots = slots;
     }
-    return changed;
+
+    delete p.providerRoles;
+    return true;
 }
 
 export function normalizeCapabilityTags(value: unknown): string[] | undefined {

package/src/mesh/coordinator-prompt.ts

@@ -31,8 +31,9 @@ import type {
     RepoMeshStatus,
     RepoMeshNodeStatus,
 } from '../repo-mesh-types.js';
-import { mergeAndNormalizePolicy } from '../repo-mesh-types.js';
+import { mergeAndNormalizePolicy, resolveProviderMaxParallel } from '../repo-mesh-types.js';
 import { getDifficultyBrains } from '../config/mesh-config.js';
+import { resolveNodeCapabilitySlots } from './mesh-node-slots.js';
 import { MESH_TASK_DIFFICULTIES } from '@adhdev/mesh-shared';
 import type { MagiKindPanelMap, MagiSlot, MagiTaskKind } from '@adhdev/mesh-shared';
 
@@ -459,19 +460,23 @@ function buildNodeConfigSection(mesh: LocalMeshEntry): string {
         const explicitMachineLabel = typeof (n as any).machineLabel === 'string' ? (n as any).machineLabel : '';
         const explicitLabel = explicitMachineLabel ? ` label: **${explicitMachineLabel}** |` : '';
         const providerPriority = n.policy?.providerPriority?.length ? ` | providers: ${n.policy.providerPriority.join(', ')}` : '';
-        // Per-(node, provider) maxParallel cap. Only maxParallel is enforced by the
-        // queue; routing is governed by required_tags, not provider roles.
-        const providerRoles = Array.isArray(n.policy?.providerRoles)
-            ? (n.policy!.providerRoles as Array<{ providerType?: unknown; maxParallel?: unknown }>)
-                .map(r => {
-                    const type = typeof r?.providerType === 'string' ? r.providerType.trim() : '';
-                    if (!type) return '';
-                    const cap = Number.isFinite(Number(r?.maxParallel)) ? ` (max ${Math.floor(Number(r.maxParallel))})` : '';
-                    return `${type}${cap}`;
-                })
-                .filter(Boolean)
-            : [];
-        const providerRolesSuffix = providerRoles.length ? ` | caps: ${providerRoles.join(', ')}` : '';
+        // Per-(node, provider) maxParallel cap, derived from the node's slots (the
+        // cap summed across a provider's slots). Only maxParallel is enforced by the
+        // queue; routing is governed by required_tags, not slot order.
+        const nodeSlots = resolveNodeCapabilitySlots(n);
+        const seenCapProvider = new Set<string>();
+        const providerCaps: string[] = [];
+        for (const slot of nodeSlots) {
+            const type = typeof slot?.provider === 'string' ? slot.provider.trim() : '';
+            if (!type) continue;
+            const key = type.toLowerCase();
+            if (seenCapProvider.has(key)) continue;
+            seenCapProvider.add(key);
+            const cap = resolveProviderMaxParallel(nodeSlots, type);
+            if (cap === undefined) continue;
+            providerCaps.push(`${type} (max ${cap})`);
+        }
+        const providerRolesSuffix = providerCaps.length ? ` | caps: ${providerCaps.join(', ')}` : '';
         lines.push(`- ${explicitLabel} nodeId: \`${n.id}\` | workspace: \`${n.workspace}\`${n.daemonId ? ` | daemon: \`${n.daemonId}\`` : ''}${providerPriority}${providerRolesSuffix}${suffix}`);
         // Routing tags: what this node advertises for mesh_enqueue_task required_tags.
         // Surfaced so the coordinator can route by-capability (e.g. enqueue a Windows

package/src/mesh/mesh-node-slots.ts

@@ -0,0 +1,52 @@
+/**
+ * Node capability-slot resolution — the single source of truth for a node's
+ * effective slots (ORCHESTRATION_NODE_SLOTS.md). Every layer that needs a node's
+ * slots (queue claim/launch caps, scheduling-runtime status projection, coordinator
+ * prompt) resolves them here so the "explicit policy.slots, else legacy-derived"
+ * rule is applied identically everywhere.
+ *
+ * Kept as a tiny standalone module (rather than living in mesh-queue-assignment)
+ * so importing slot resolution does not drag in the whole assignment engine and to
+ * avoid an import cycle between the status builder and the assignment engine.
+ */
+import {
+    deriveSlotsFromLegacy,
+    normalizeNodeCapabilitySlots,
+    type NodeCapabilitySlot,
+} from '@adhdev/mesh-shared';
+import { getDifficultyBrains } from '../config/mesh-config.js';
+
+/** Ordered, de-duplicated providerPriority from a node policy (defensive). */
+export function normalizeProviderPriority(policy: unknown): string[] {
+    const raw = policy && typeof policy === 'object' && !Array.isArray(policy)
+        ? (policy as Record<string, unknown>).providerPriority
+        : undefined;
+    if (!Array.isArray(raw)) return [];
+    const seen = new Set<string>();
+    return raw
+        .map(type => typeof type === 'string' ? type.trim() : '')
+        .filter(Boolean)
+        .filter(type => {
+            if (seen.has(type)) return false;
+            seen.add(type);
+            return true;
+        });
+}
+
+/**
+ * Resolve a node's capability slots: explicit `policy.slots` when present, else
+ * derived from the legacy `providerPriority` + machine-global difficultyBrains.
+ * (The former per-provider `providerRoles` cap has been removed; a persisted
+ * meshes.json is migrated to slots on load, so by the time a node reaches routing
+ * its cap already lives on `slots[].maxParallel`.)
+ */
+export 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),
+        difficultyBrains,
+    });
+}