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

package/dist/index.mjs

@@ -140,7 +140,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";
@@ -152,7 +153,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.
@@ -404,10 +409,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "a503a00d57fbcdc84cd252c6d5caee90cfae6706" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "a503a00d" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.484" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-08T13:24:54.463Z" : 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;
 }
@@ -2792,6 +2797,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"() {
@@ -2847,7 +2920,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;
   }
@@ -3799,6 +3874,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).
@@ -3876,7 +3952,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\`.`;
@@ -5824,6 +5902,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];
@@ -5867,6 +5946,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()
@@ -15358,6 +15438,24 @@ function getMeshWithCache(components, meshId) {
   if (!cachedMesh) return localMesh;
   return mergeInlineCacheOnlyNodes(localMesh, cachedMesh);
 }
+function bootstrapEpochMs(bootstrap) {
+  const raw = readNonEmptyString2(bootstrap?.startedAt) || readNonEmptyString2(bootstrap?.completedAt);
+  if (!raw) return 0;
+  const parsed = Date.parse(raw);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function inlineBootstrapIsFresher(inlineBootstrap, configBootstrap) {
+  const inlineStatus = readNonEmptyString2(inlineBootstrap?.status);
+  if (!inlineStatus) return false;
+  const configStatus = readNonEmptyString2(configBootstrap?.status);
+  const inlineTerminal = BOOTSTRAP_TERMINAL_STATUSES.has(inlineStatus);
+  const configTerminal = !!configStatus && BOOTSTRAP_TERMINAL_STATUSES.has(configStatus);
+  if (configTerminal) {
+    return inlineTerminal && inlineStatus !== configStatus && bootstrapEpochMs(inlineBootstrap) > bootstrapEpochMs(configBootstrap);
+  }
+  if (inlineTerminal) return true;
+  return bootstrapEpochMs(inlineBootstrap) > bootstrapEpochMs(configBootstrap);
+}
 function mergeInlineCacheOnlyNodes(localMesh, cachedMesh) {
   const localNodes = Array.isArray(localMesh?.nodes) ? localMesh.nodes : [];
   const cachedNodes = Array.isArray(cachedMesh?.nodes) ? cachedMesh.nodes : [];
@@ -15374,8 +15472,8 @@ function mergeInlineCacheOnlyNodes(localMesh, cachedMesh) {
     const localId = readMeshNodeId(localNode);
     if (!localId) continue;
     const inlineMatch = cachedNodes.find((cachedNode) => meshNodeIdMatches(cachedNode, localId));
-    const inlineBootstrapStatus = readNonEmptyString2(inlineMatch?.worktreeBootstrap?.status);
-    if (!inlineMatch || !inlineBootstrapStatus) continue;
+    if (!inlineMatch) continue;
+    if (!inlineBootstrapIsFresher(inlineMatch.worktreeBootstrap, localNode.worktreeBootstrap)) continue;
     if (!overlaid) {
       overlaidLocalNodes = [...localNodes];
       overlaid = true;
@@ -15847,8 +15945,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) => ({
@@ -15862,10 +15968,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") {
@@ -16009,13 +16173,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`);
@@ -16040,7 +16206,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}` };
@@ -16168,7 +16340,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);
@@ -16215,11 +16389,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 });
@@ -16253,9 +16429,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 });
@@ -16282,11 +16459,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";
@@ -16421,7 +16598,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;
         }
@@ -16524,7 +16701,7 @@ function runIdleMaintenanceThenAssignQueue(components, args) {
     });
   });
 }
-var IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, DISPATCH_CONFIRM_TIMEOUT_MS, DISPATCH_CONNECT_TIMEOUT_MS, dispatchWarmupGetterMissingWarned, LOCAL_LAUNCH_READY_TIMEOUT_MS, LOCAL_LAUNCH_READY_POLL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES, AUTO_LAUNCH_REMOTE_IDLE_TTL_MS, autoLaunchAwaitClaimBackoff, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX, ACTIONABLE_SKIP_REASON_PREFIXES, TRANSIENT_TARGET_NODE_BOOTSTRAP_PENDING_REASON, lastActionableSkipNotified;
+var IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, BOOTSTRAP_TERMINAL_STATUSES, DISPATCH_CONFIRM_TIMEOUT_MS, DISPATCH_CONNECT_TIMEOUT_MS, dispatchWarmupGetterMissingWarned, LOCAL_LAUNCH_READY_TIMEOUT_MS, LOCAL_LAUNCH_READY_POLL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES, AUTO_LAUNCH_REMOTE_IDLE_TTL_MS, autoLaunchAwaitClaimBackoff, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX, ACTIONABLE_SKIP_REASON_PREFIXES, TRANSIENT_TARGET_NODE_BOOTSTRAP_PENDING_REASON, lastActionableSkipNotified;
 var init_mesh_queue_assignment = __esm({
   "src/mesh/mesh-queue-assignment.ts"() {
     "use strict";
@@ -16551,6 +16728,7 @@ var init_mesh_queue_assignment = __esm({
     init_mesh_task_inflight();
     IDLE_AUTO_FAST_FORWARD_THROTTLE_MS = 30 * 60 * 1e3;
     idleAutoFastForwardLastAttempt = /* @__PURE__ */ new Map();
+    BOOTSTRAP_TERMINAL_STATUSES = /* @__PURE__ */ new Set(["complete", "failed"]);
     DISPATCH_CONFIRM_TIMEOUT_MS = 12e4;
     DISPATCH_CONNECT_TIMEOUT_MS = MESH_CONNECT_TIMEOUT_MS;
     dispatchWarmupGetterMissingWarned = /* @__PURE__ */ new Set();
@@ -18414,6 +18592,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;
@@ -18619,7 +18813,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) {
@@ -18660,7 +18855,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 = {}) {
@@ -25495,6 +25691,13 @@ var init_provider_cli_adapter = __esm({
       lastScreenSnapshot = "";
       lastScreenText = "";
       lastScreenSnapshotReadAt = Number.NEGATIVE_INFINITY;
+      // (FALSEIDLE Path-C) Count of CONSECUTIVE getStatus polls that observed a
+      // gate-eligible static-idle screen (detect=idle, no modal, quiet, empty
+      // partial buffer). For a mesh/autonomous worker we require several such
+      // polls in a row before confirming static-idle (see getStatus), so a
+      // single momentarily-silent point-sample of a still-live turn cannot flip
+      // it. Reset to 0 the instant any poll is ineligible.
+      staticIdlePollStreak = 0;
       // Server log forwarding
       serverConn = null;
       logBuffer = [];
@@ -25560,6 +25763,13 @@ var init_provider_cli_adapter = __esm({
       static MAX_ACCUMULATED_BUFFER = 262144;
       parsedStatusCache = null;
       static SCREEN_SNAPSHOT_MIN_INTERVAL_MS = 250;
+      // (FALSEIDLE Path-C) Consecutive gate-eligible getStatus polls a mesh/autonomous
+      // session must show before the poll-static-idle confirm fires. 2 = one extra
+      // status tick of hysteresis: enough to reject a single momentary-silence
+      // point-sample of a still-live turn, cheap enough not to materially delay a
+      // genuine boot-wedge release (the wedge screen is stably static, so it clears
+      // every consecutive poll and confirms on the 2nd).
+      static STATIC_IDLE_POLL_CONFIRM_COUNT = 2;
       providerResolutionMeta;
       getBufferState() {
         const build = (droppedChars, maxChars) => droppedChars > 0 ? { truncated: true, droppedChars, maxChars } : void 0;
@@ -25631,6 +25841,18 @@ ${lastSnapshot}`;
       getStatusActivityHoldMs() {
         return this.timeouts.statusActivityHold;
       }
+      // (FALSEIDLE Path-C) Whether this session is a mesh worker or coordinator's
+      // own autonomous session. Mirrors CliProviderInstance.isAutonomousMeshSession
+      // over the runtimeSettings the instance mirrors down via updateRuntimeSettings
+      // (meshNodeFor / meshActiveTaskId / meshNodeId / launchedByCoordinator =
+      // isMeshWorkerSession, plus meshCoordinatorFor for the coordinator's own turn).
+      // Such a session has no human at the keyboard to correct a premature idle, so
+      // the poll-static-idle confirm is debounced for it (multiple consecutive idle
+      // polls) rather than fired on a single point-sample.
+      isAutonomousMeshSession() {
+        const s2 = this.runtimeSettings;
+        return !!(s2?.meshNodeFor || s2?.meshActiveTaskId || s2?.meshNodeId || s2?.launchedByCoordinator || s2?.meshCoordinatorFor);
+      }
       // Resolved timeouts
       timeouts;
       // Provider approval key mapping
@@ -26018,14 +26240,27 @@ ${lastSnapshot}`;
         if (allowParse && this.engine.currentStatus === "generating" && !this.engine.currentTurnScope && !this.engine.activeModal) {
           const now = Date.now();
           const quietForMs = this.lastNonEmptyOutputAt ? now - this.lastNonEmptyOutputAt : Number.MAX_SAFE_INTEGER;
+          let eligible = false;
           if (quietForMs >= this.getStatusActivityHoldMs()) {
             const screenText = this.terminalScreen.getText();
             const pollDetect = this.runDetectStatus(screenText || this.recentOutputBuffer);
             const pollModal = this.runParseApproval(screenText) || this.runParseApproval(this.recentOutputBuffer);
-            if (pollDetect === "idle" && !pollModal) {
+            const partial = this.getPartialResponse();
+            const partialPending = typeof partial === "string" && partial.trim().length > 0;
+            eligible = pollDetect === "idle" && !pollModal && !partialPending;
+          }
+          if (eligible) {
+            const requiredStreak = this.isAutonomousMeshSession() ? _ProviderCliAdapter.STATIC_IDLE_POLL_CONFIRM_COUNT : 1;
+            this.staticIdlePollStreak += 1;
+            if (this.staticIdlePollStreak >= requiredStreak) {
               this.engine.confirmPollStaticIdle("poll_static_idle");
+              this.staticIdlePollStreak = 0;
             }
+          } else {
+            this.staticIdlePollStreak = 0;
           }
+        } else {
+          this.staticIdlePollStreak = 0;
         }
         let effectiveStatus = this.projectEffectiveStatus(startupModal);
         let effectiveModal = startupModal || this.engine.activeModal;
@@ -39020,11 +39255,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 {
         }
@@ -49813,6 +50052,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);
@@ -56074,6 +56338,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));
@@ -56344,7 +56610,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;
@@ -56529,7 +56797,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;
@@ -56888,6 +57158,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
@@ -69761,6 +70036,7 @@ export {
   appendRemoteLedgerEntries,
   assertNoDependencyCycle,
   buildAssistantChatMessage,
+  buildAvailableProviders,
   buildChatMessage,
   buildChatMessageSignature,
   buildChatTailDeliverySignature,