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

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;

package/src/status/builders.ts

@@ -34,6 +34,47 @@ import {
 } from '../providers/open-panel-support.js';
 import { TEXT_ONLY_MESSAGE_INPUT_SUPPORT } from '../providers/provider-input-support.js';
 
+/**
+ * A coordinator-spawned worker session that mesh policy launched hidden. This is
+ * the daemon-side equivalent of the web `shouldAutoHideMeshConversation` predicate:
+ * these sessions should default to muted+hidden in the user dashboard (the user
+ * interacts through the ONE coordinator session, not each worker), while the
+ * coordinator↔worker mesh data/completion path (mesh-event-forwarding) is
+ * unaffected.
+ */
+function isCoordinatorSpawnedHiddenWorker(settings: Record<string, any> | undefined): boolean {
+    if (!settings) return false;
+    return settings.launchedByCoordinator === true
+        && typeof settings.meshNodeFor === 'string'
+        && settings.meshNodeFor.trim().length > 0
+        && settings.spawnedSessionVisibility === 'hidden';
+}
+
+/**
+ * A session is surface-hidden (collapsed from the user's inbox/notifications) when
+ * mesh policy spawned it hidden, OR when a coordinator-spawned worker defaults
+ * hidden, OR when the user manually hid it (userHidden). userHidden === false is an
+ * explicit un-hide that overrides the policy/worker default until daemon restart.
+ */
+function resolveSurfaceHidden(settings: Record<string, any> | undefined): boolean {
+    if (!settings) return false;
+    if (settings.userHidden === true) return true;
+    if (settings.userHidden === false) return false;
+    return settings.spawnedSessionVisibility === 'hidden' || isCoordinatorSpawnedHiddenWorker(settings);
+}
+
+/**
+ * A session is muted (attention side-effects suppressed, but still shown in the
+ * list) when the user muted it, OR a coordinator-spawned worker defaults muted.
+ * userMuted === false is an explicit un-mute overriding the worker default.
+ */
+function resolveMuted(settings: Record<string, any> | undefined): boolean {
+    if (!settings) return false;
+    if (settings.userMuted === true) return true;
+    if (settings.userMuted === false) return false;
+    return isCoordinatorSpawnedHiddenWorker(settings);
+}
+
 export type SessionEntryProfile = 'full' | 'live' | 'metadata';
 
 export interface SessionEntryBuildOptions {
@@ -342,7 +383,8 @@ function buildCliSession(state: CliProviderState, options: SessionEntryBuildOpti
         settings: state.settings,
         ...(coordinator && { coordinator }),
         ...(meshQueueStats && { meshQueueStats }),
-        ...(state.settings?.spawnedSessionVisibility === 'hidden' && { surfaceHidden: true }),
+        ...(resolveSurfaceHidden(state.settings) && { surfaceHidden: true }),
+        ...(resolveMuted(state.settings) && { muted: true }),
     };
 }
 
@@ -384,7 +426,8 @@ function buildAcpSession(state: AcpProviderState, options: SessionEntryBuildOpti
         settings: state.settings,
         ...(coordinator && { coordinator }),
         ...(meshQueueStats && { meshQueueStats }),
-        ...(state.settings?.spawnedSessionVisibility === 'hidden' && { surfaceHidden: true }),
+        ...(resolveSurfaceHidden(state.settings) && { surfaceHidden: true }),
+        ...(resolveMuted(state.settings) && { muted: true }),
     };
 }
 

package/src/status/snapshot.ts

@@ -130,7 +130,7 @@ function buildDetectedIdeInfos(
         }));
 }
 
-function buildAvailableProviders(
+export function buildAvailableProviders(
     providerLoader: StatusSnapshotOptions['providerLoader'],
 ): AvailableProviderInfo[] {
     const providers: Array<{