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

package/dist/index.d.ts

@@ -102,7 +102,7 @@ export { maybeRunDaemonUpgradeHelperFromEnv, spawnDetachedDaemonUpgradeHelper, r
 export type { DaemonUpgradeHelperPayload, CurrentGlobalInstallSurface, PinnedGlobalInstallCommand, NpmExecOptions, } from './commands/upgrade-helper.js';
 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/dist/index.js

@@ -145,7 +145,8 @@ var init_repo_mesh_types = __esm({
       "first_eligible",
       "least_loaded",
       "round_robin",
-      "priority_only"
+      "priority_only",
+      "fitness"
     ];
     DEFAULT_MESH_SCHEDULING_STRATEGY = "first_eligible";
     MESH_CONVERGE_REFINE_TAG = "converge=refine";
@@ -157,7 +158,11 @@ var init_repo_mesh_types = __esm({
       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.
@@ -409,10 +414,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "ddf2eb6eafcf949165edfda2c3cf7c77597fa6f8" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "ddf2eb6e" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.485" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-08T15:14:11.978Z" : void 0);
+  const commit = readInjected(true ? "cae0f42043ded25e4d3bed93d9f658035c09e007" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "cae0f420" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.486" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-09T23:19:53.642Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -2798,6 +2803,74 @@ function normalizeDifficultyBrainMap(raw) {
   }
   return out;
 }
+function normalizeNodeCapabilitySlot(raw) {
+  const r = raw && typeof raw === "object" ? raw : {};
+  const provider = typeof r.provider === "string" ? r.provider.trim() : "";
+  if (!provider) return null;
+  const model = typeof r.model === "string" ? r.model.trim() : "";
+  const thinkingLevel = typeof r.thinkingLevel === "string" ? r.thinkingLevel.trim() : "";
+  const difficulty = Array.isArray(r.difficulty) ? r.difficulty.filter(isMeshTaskDifficulty) : [];
+  const capability = Array.isArray(r.capability) ? r.capability.filter((t) => typeof t === "string" && !!t.trim()).map((t) => t.trim()) : [];
+  const maxParallelNum = Number(r.maxParallel);
+  const maxParallel = Number.isFinite(maxParallelNum) && maxParallelNum > 0 ? Math.floor(maxParallelNum) : void 0;
+  return {
+    provider,
+    ...model ? { model } : {},
+    ...thinkingLevel ? { thinkingLevel } : {},
+    ...difficulty.length ? { difficulty } : {},
+    ...capability.length ? { capability } : {},
+    ...maxParallel !== void 0 ? { maxParallel } : {}
+  };
+}
+function normalizeNodeCapabilitySlots(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const entry of raw) {
+    const slot = normalizeNodeCapabilitySlot(entry);
+    if (slot) out.push(slot);
+  }
+  return out;
+}
+function deriveSlotsFromLegacy(input) {
+  const priority = Array.isArray(input.providerPriority) ? input.providerPriority.filter((p) => typeof p === "string" && !!p.trim()).map((p) => p.trim()) : [];
+  if (priority.length === 0) return [];
+  const roleCap = /* @__PURE__ */ new Map();
+  for (const role of input.providerRoles || []) {
+    if (role && typeof role.providerType === "string" && Number.isFinite(role.maxParallel)) {
+      roleCap.set(role.providerType.trim(), Math.floor(Number(role.maxParallel)));
+    }
+  }
+  const brains = input.difficultyBrains || {};
+  const byProvider = /* @__PURE__ */ new Map();
+  const shared = [];
+  for (const diff of MESH_TASK_DIFFICULTIES) {
+    const b = brains[diff];
+    if (!b) continue;
+    const entry = { difficulty: diff, model: b.model, thinkingLevel: b.thinkingLevel };
+    if (b.provider) {
+      const list = byProvider.get(b.provider) ?? [];
+      list.push(entry);
+      byProvider.set(b.provider, list);
+    } else {
+      shared.push(entry);
+    }
+  }
+  return priority.map((provider) => {
+    const specific = byProvider.get(provider) || [];
+    const applied = specific.length ? specific : shared;
+    const difficulty = applied.map((a) => a.difficulty);
+    const model = applied.find((a) => a.model)?.model;
+    const thinkingLevel = applied.find((a) => a.thinkingLevel)?.thinkingLevel;
+    const maxParallel = roleCap.get(provider);
+    return {
+      provider,
+      ...model ? { model } : {},
+      ...thinkingLevel ? { thinkingLevel } : {},
+      ...difficulty.length ? { difficulty } : {},
+      ...maxParallel !== void 0 ? { maxParallel } : {}
+    };
+  });
+}
 var DAEMON_ID_PREFIXES, MAGI_RAW_ANSWER_CAP, MESH_TASK_DIFFICULTIES, DEFAULT_DIFFICULTY_BRAINS, CANONICAL_MESH_TOOL_NAMES, CANONICAL_MESH_TOOL_COUNT;
 var init_dist = __esm({
   "../mesh-shared/dist/index.mjs"() {
@@ -2853,7 +2926,9 @@ var init_dist = __esm({
       "mesh_magi_review",
       "mesh_magi_collect",
       "mesh_magi_kind_panel_set",
-      "mesh_magi_kind_panel_list"
+      "mesh_magi_kind_panel_list",
+      "mesh_node_slots_set",
+      "mesh_node_slots_list"
     ];
     CANONICAL_MESH_TOOL_COUNT = CANONICAL_MESH_TOOL_NAMES.length;
   }
@@ -3802,6 +3877,7 @@ function buildRulesSection(coordinatorCliType) {
 - **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\` \u2014 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 \u2014 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 \u2014 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\u2192node fitness routing matches against. If you notice a persistent mismatch \u2014 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 \u2014 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 \u2192 \`hermes-cli\`, Claude/Claude Code \u2192 \`claude-cli\`, Codex \u2192 \`codex-cli\`, Gemini \u2192 \`gemini-cli\`, Antigravity \u2192 \`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\u20132 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 \u2014 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).
@@ -3882,7 +3958,9 @@ var init_coordinator_prompt = __esm({
 | \`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 \u2192 MAGI kind-panel slots (the SOLE MAGI panel-resolution surface; machine-local, wholesale replacement \u2014 approve current-vs-new first) |
-| \`mesh_magi_kind_panel_list\` | List configured task_kind \u2192 MAGI kind-panel slot bindings (machine-local, read-only) |`;
+| \`mesh_magi_kind_panel_list\` | List configured task_kind \u2192 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 \u2014 how you autonomously retune a node's tool profile; WHOLESALE replacement, present current-vs-proposed and get user approval before write=true |`;
     TOOL_EXPOSURE_PREFLIGHT_SECTION = `## Tool Exposure Preflight
 
 Before doing any coordinator work, confirm that the actual callable tool list includes \`mesh_status\` and the other \`mesh_*\` tools from the table above. If this Repo Mesh coordinator prompt is present but the callable \`mesh_*\` tools are missing, the MCP server/tool manifest is stale or not injected yet. Do not substitute terminal/file/git tools, do not inspect or edit the repository directly, and do not continue as a non-mesh local coding agent. Stop immediately and tell the user to run \`/reload-mcp\` or start a fresh coordinator session so ADHDev can reconnect \`adhdev-mesh\`.`;
@@ -5830,6 +5908,7 @@ function enqueueTask(meshId, message, opts) {
   const maxRetries = typeof opts?.maxRetries === "number" && Number.isFinite(opts.maxRetries) && opts.maxRetries >= 0 ? Math.floor(opts.maxRetries) : void 0;
   let effectiveModel = typeof opts?.model === "string" && opts.model.trim() ? opts.model.trim() : void 0;
   let effectiveThinkingLevel = typeof opts?.thinkingLevel === "string" && opts.thinkingLevel.trim() ? opts.thinkingLevel.trim() : void 0;
+  const taskDifficulty = isMeshTaskDifficulty(opts?.difficulty) ? opts.difficulty : void 0;
   if (isMeshTaskDifficulty(opts?.difficulty)) {
     try {
       const preset = getDifficultyBrains()[opts.difficulty];
@@ -5873,6 +5952,7 @@ function enqueueTask(meshId, message, opts) {
       ...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() } : {},
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -15862,8 +15942,16 @@ function nodeHasActiveAssignment(meshId, nodeId) {
 function nodeActiveLoad(meshId, nodeId) {
   return MeshRuntimeStore.getInstance().nodeActiveAssignmentCount(meshId, nodeId);
 }
+function meshHasExplicitSlots(mesh) {
+  const nodes = Array.isArray(mesh?.nodes) ? mesh.nodes : [];
+  return nodes.some((n) => normalizeNodeCapabilitySlots(n?.policy?.slots).length > 0);
+}
 function resolveSchedulingStrategy(mesh) {
-  return normalizeMeshSchedulingStrategy(mesh?.policy?.schedulingStrategy);
+  const raw = mesh?.policy?.schedulingStrategy;
+  if (typeof raw === "string" && raw.trim()) {
+    return normalizeMeshSchedulingStrategy(raw);
+  }
+  return meshHasExplicitSlots(mesh) ? "fitness" : normalizeMeshSchedulingStrategy(void 0);
 }
 function buildSchedulingPool(localCandidates, remoteCandidates) {
   const pool = [...localCandidates, ...remoteCandidates].map((c) => ({
@@ -15877,10 +15965,68 @@ function buildSchedulingPool(localCandidates, remoteCandidates) {
   }));
   return { pool, uniqueNodes };
 }
+function resolveNodeCapabilitySlots(node) {
+  const explicit = normalizeNodeCapabilitySlots(node?.policy?.slots);
+  if (explicit.length) return explicit;
+  let difficultyBrains;
+  try {
+    difficultyBrains = getDifficultyBrains();
+  } catch {
+    difficultyBrains = void 0;
+  }
+  return deriveSlotsFromLegacy({
+    providerPriority: normalizeProviderPriority(node?.policy),
+    providerRoles: Array.isArray(node?.policy?.providerRoles) ? node.policy.providerRoles : void 0,
+    difficultyBrains
+  });
+}
+function scoreSlotForTask(slot, task) {
+  let score = 1;
+  const diff = isMeshTaskDifficulty(task.difficulty) ? task.difficulty : void 0;
+  if (diff) {
+    if (slot.difficulty?.length) {
+      score += slot.difficulty.includes(diff) ? 100 : 0;
+    } else {
+      score += 20;
+    }
+  }
+  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;
+  }
+  return score;
+}
+function bestSlotForTask(node, task) {
+  const slots = resolveNodeCapabilitySlots(node);
+  if (!slots.length) return null;
+  let best = null;
+  for (const slot of slots) {
+    const score = scoreSlotForTask(slot, task);
+    if (!best || score > best.score) best = { slot, score };
+  }
+  return best;
+}
+function nodeFitnessForTask(node, task) {
+  return bestSlotForTask(node, task)?.score ?? 0;
+}
 function orderEligibleNodes(meshId, strategy, nodes, opts) {
   if (strategy === "first_eligible" || nodes.length <= 1) {
     return nodes;
   }
+  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;
+      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) => resolveNodeSchedulingPriority(n.node?.policy);
   let rotation = 0;
   if (strategy === "least_loaded" || strategy === "round_robin") {
@@ -16024,13 +16170,15 @@ function markAutoLaunch(meshId, taskId, args) {
     retractActionableSkipIfPreviouslyNotified(meshId, taskId);
   }
 }
-async function resolveUsableProvider(components, nodeId, node, requiredTags) {
-  const providerPriority = normalizeProviderPriority(node?.policy);
-  if (!providerPriority.length) return { reason: "missing_provider_priority" };
+async function resolveUsableProvider(components, nodeId, node, requiredTags, task) {
   const providerLoader = components.providerLoader;
   if (!providerLoader) return { reason: "provider_loader_unavailable" };
+  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 = [];
-  for (const requestedType of providerPriority) {
+  for (const slot of orderedSlots) {
+    const requestedType = slot.provider;
     const normalizedType = typeof providerLoader.resolveAlias === "function" ? providerLoader.resolveAlias(requestedType) : requestedType;
     if (requiredTags?.length && !nodeSatisfiesRequiredTags(requiredTags, buildMeshNodeCapabilityTags(node, normalizedType))) {
       failed.push(`${requestedType}: required_tags_mismatch`);
@@ -16055,7 +16203,13 @@ async function resolveUsableProvider(components, nodeId, node, requiredTags) {
       }], false);
     }
     components.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}` };
@@ -16183,7 +16337,9 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
       meshId,
       strategy,
       candidateNodes.map((node, index) => ({ nodeId: readMeshNodeId(node), node, index })).filter((c) => 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.difficulty, requiredTags: task.requiredTags } }
     ).map((c) => c.node);
     for (const node of orderedCandidateNodes) {
       const nodeId = readMeshNodeId(node);
@@ -16230,11 +16386,13 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, 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.difficulty, requiredTags: task.requiredTags });
         if (!resolved.providerType) {
           markAutoLaunch(meshId, task.id, { status: "skipped", reason: resolved.reason || "provider_unusable", nodeId });
           continue;
         }
+        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;
         const providerCap = resolveProviderMaxParallel(node?.policy, resolved.providerType);
         if (providerCap !== void 0 && activeProviderAssignedCount(meshId, nodeId, resolved.providerType) >= providerCap) {
           markAutoLaunch(meshId, task.id, { status: "skipped", reason: "max_provider_parallel_reached", nodeId, providerType: resolved.providerType });
@@ -16268,9 +16426,10 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, 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) {
             markAutoLaunch(meshId, task.id, { status: "failed", reason: `remote_launch_dispatch_failed: ${e?.message || String(e)}`, nodeId, providerType: resolved.providerType });
@@ -16297,11 +16456,11 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, 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";
@@ -16436,7 +16595,7 @@ async function triggerMeshQueue(components, meshId) {
         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") {
+        if (strategy === "least_loaded" || strategy === "round_robin" || strategy === "fitness") {
           const loadDelta = nodeActiveLoad(meshId, a.nodeId) - nodeActiveLoad(meshId, b.nodeId);
           if (loadDelta !== 0) return loadDelta;
         }
@@ -18431,6 +18590,22 @@ var init_provider_input_support = __esm({
 });
 
 // src/status/builders.ts
+function isCoordinatorSpawnedHiddenWorker(settings) {
+  if (!settings) return false;
+  return settings.launchedByCoordinator === true && typeof settings.meshNodeFor === "string" && settings.meshNodeFor.trim().length > 0 && settings.spawnedSessionVisibility === "hidden";
+}
+function resolveSurfaceHidden(settings) {
+  if (!settings) return false;
+  if (settings.userHidden === true) return true;
+  if (settings.userHidden === false) return false;
+  return settings.spawnedSessionVisibility === "hidden" || isCoordinatorSpawnedHiddenWorker(settings);
+}
+function resolveMuted(settings) {
+  if (!settings) return false;
+  if (settings.userMuted === true) return true;
+  if (settings.userMuted === false) return false;
+  return isCoordinatorSpawnedHiddenWorker(settings);
+}
 function getActiveChatOptions(profile) {
   if (profile === "full") return {};
   return LIVE_STATUS_ACTIVE_CHAT_OPTIONS;
@@ -18636,7 +18811,8 @@ function buildCliSession(state, options) {
     settings: state.settings,
     ...coordinator && { coordinator },
     ...meshQueueStats && { meshQueueStats },
-    ...state.settings?.spawnedSessionVisibility === "hidden" && { surfaceHidden: true }
+    ...resolveSurfaceHidden(state.settings) && { surfaceHidden: true },
+    ...resolveMuted(state.settings) && { muted: true }
   };
 }
 function buildAcpSession(state, options) {
@@ -18677,7 +18853,8 @@ function buildAcpSession(state, options) {
     settings: state.settings,
     ...coordinator && { coordinator },
     ...meshQueueStats && { meshQueueStats },
-    ...state.settings?.spawnedSessionVisibility === "hidden" && { surfaceHidden: true }
+    ...resolveSurfaceHidden(state.settings) && { surfaceHidden: true },
+    ...resolveMuted(state.settings) && { muted: true }
   };
 }
 function buildSessionEntries(allStates, cdpManagers, options = {}) {
@@ -27639,6 +27816,7 @@ __export(index_exports, {
   appendRemoteLedgerEntries: () => appendRemoteLedgerEntries,
   assertNoDependencyCycle: () => assertNoDependencyCycle,
   buildAssistantChatMessage: () => buildAssistantChatMessage,
+  buildAvailableProviders: () => buildAvailableProviders,
   buildChatMessage: () => buildChatMessage,
   buildChatMessageSignature: () => buildChatMessageSignature,
   buildChatTailDeliverySignature: () => buildChatTailDeliverySignature,
@@ -39497,11 +39675,15 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         if (!manifestPath) continue;
         try {
           const m = JSON.parse(fs41.readFileSync(manifestPath, "utf-8"));
+          const modelOptions = Array.isArray(m.modelOptions) ? m.modelOptions.filter((x) => typeof x === "string" && !!x.trim()) : [];
+          const thinkingLevelOptions = Array.isArray(m.thinkingLevelOptions) ? m.thinkingLevelOptions.filter((x) => typeof x === "string" && !!x.trim()) : [];
           items.push({
             type,
             category,
             version: typeof m.providerVersion === "string" ? m.providerVersion : "0.0.0",
-            path: manifestPath
+            path: manifestPath,
+            ...modelOptions.length ? { modelOptions } : {},
+            ...thinkingLevelOptions.length ? { thinkingLevelOptions } : {}
           });
         } catch {
         }
@@ -50285,6 +50467,31 @@ var cliAgentHandlers = {
   record_provider_pty: async (ctx, args) => {
     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, args) => {
+    const sessionId = readStringValue(args?.sessionId, args?.targetSessionId, args?.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 = {};
+    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);
+    ctx.deps.onStatusChange?.();
+    return { success: true, sessionId, ...patch };
+  },
   agent_command: async (ctx, args) => {
     {
       const dispatchSessionId = readStringValue(args?.targetSessionId, args?.sessionId, args?.instanceId);
@@ -56546,6 +56753,8 @@ var meshCoordinatorLaunchHandlers = {
     const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
     let cliType = typeof args?.cliType === "string" ? args.cliType.trim() : "";
     const extraSystemPrompt = typeof args?.extraSystemPrompt === "string" ? args.extraSystemPrompt.trim() : "";
+    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 {
       const { buildCoordinatorSystemPrompt: buildCoordinatorSystemPrompt2 } = await Promise.resolve().then(() => (init_coordinator_prompt(), coordinator_prompt_exports));
@@ -56816,7 +57025,9 @@ ${ptyResult.output.slice(-2e3)}`);
           dir: workspace,
           cliArgs: cliCmdArgs.length > 0 ? cliCmdArgs : void 0,
           env: Object.keys(cliCmdEnv).length > 0 ? cliCmdEnv : void 0,
-          settings: { meshCoordinatorFor: meshId }
+          settings: { meshCoordinatorFor: meshId },
+          ...initialModel ? { initialModel } : {},
+          ...initialThinkingLevel ? { initialThinkingLevel } : {}
         });
         if (cliCmdLaunch?.success && cliCmdContextFilePath) {
           const stripPath = cliCmdContextFilePath;
@@ -57001,7 +57212,9 @@ ${ptyResult.output.slice(-2e3)}`);
         env: Object.keys(launchEnv).length > 0 ? launchEnv : void 0,
         settings: {
           meshCoordinatorFor: meshId
-        }
+        },
+        ...initialModel ? { initialModel } : {},
+        ...initialThinkingLevel ? { initialThinkingLevel } : {}
       });
       if (launchResult?.success && autoImportContextFilePath) {
         const stripPath = autoImportContextFilePath;
@@ -57360,6 +57573,11 @@ var meshStatusHandlers = {
           ...node.reportedProviderVersions && typeof node.reportedProviderVersions === "object" ? { providerVersions: node.reportedProviderVersions } : {},
           ...typeof node.reportedDaemonBuildVersion === "string" && node.reportedDaemonBuildVersion ? { 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?.slots) && node.policy.slots.length ? { slots: normalizeNodeCapabilitySlots(node.policy.slots) } : {},
           activeSessions: [],
           activeSessionDetails: [],
           launchReady: false
@@ -70224,6 +70442,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   appendRemoteLedgerEntries,
   assertNoDependencyCycle,
   buildAssistantChatMessage,
+  buildAvailableProviders,
   buildChatMessage,
   buildChatMessageSignature,
   buildChatTailDeliverySignature,