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

package/dist/index.mjs

@@ -117,20 +117,20 @@ function resolveDelegatedWorkerAutoApprove(meshPolicy, nodePolicy) {
   }
   return true;
 }
-function resolveProviderMaxParallel(nodePolicy, providerType) {
+function resolveProviderMaxParallel(slots, providerType) {
   const wanted = typeof providerType === "string" ? providerType.trim().toLowerCase() : "";
   if (!wanted) return void 0;
-  const roles = nodePolicy?.providerRoles;
-  if (!Array.isArray(roles)) return void 0;
-  for (const entry of roles) {
-    if (!entry || typeof entry !== "object") continue;
-    const type = typeof entry.providerType === "string" ? entry.providerType.trim().toLowerCase() : "";
+  if (!Array.isArray(slots)) return void 0;
+  let total;
+  for (const slot of slots) {
+    if (!slot || typeof slot !== "object") continue;
+    const type = typeof slot.provider === "string" ? slot.provider.trim().toLowerCase() : "";
     if (!type || type !== wanted) continue;
-    const raw = Number(entry.maxParallel);
-    if (!Number.isFinite(raw) || raw < 0) return void 0;
-    return Math.floor(raw);
+    const raw = Number(slot.maxParallel);
+    if (!Number.isFinite(raw) || raw < 0) continue;
+    total = (total ?? 0) + Math.floor(raw);
   }
-  return void 0;
+  return total;
 }
 var MESH_SCHEDULING_STRATEGIES, DEFAULT_MESH_SCHEDULING_STRATEGY, MESH_CONVERGE_REFINE_TAG, MESH_CONVERGE_FAST_FORWARD_TAG, DEFAULT_MESH_POLICY, SESSION_CLEANUP_MODES, SPAWNED_SESSION_VISIBILITY_MODES, DIRTY_WORKSPACE_BEHAVIORS, MESH_MAX_PARALLEL_TASKS_MIN, MESH_MAX_PARALLEL_TASKS_MAX, DEFAULT_MESH_READONLY_MULTIPLIER;
 var init_repo_mesh_types = __esm({
@@ -412,10 +412,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "c79248529d56e594be601fcea3db3f9be709d4c9" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "c7924852" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.507" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-12T16:37:57.223Z" : void 0);
+  const commit = readInjected(true ? "8ebe4d4bcdc658e11253a51a28237d392aa4d978" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "8ebe4d4b" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.509" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-13T02:51:57.282Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -2842,12 +2842,6 @@ function normalizeNodeCapabilitySlots(raw) {
 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 = [];
@@ -2869,13 +2863,11 @@ function deriveSlotsFromLegacy(input) {
     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 } : {}
+      ...difficulty.length ? { difficulty } : {}
     };
   });
 }
@@ -3043,6 +3035,7 @@ __export(mesh_config_exports, {
   listMagiKindPanels: () => listMagiKindPanels,
   listMeshes: () => listMeshes,
   markMeshHostPairingJoined: () => markMeshHostPairingJoined,
+  migrateProviderRolesToSlots: () => migrateProviderRolesToSlots,
   normalizeCapabilityTags: () => normalizeCapabilityTags,
   normalizeMagiSlots: () => normalizeMagiSlots,
   normalizeRepoIdentity: () => normalizeRepoIdentity,
@@ -3084,23 +3077,51 @@ function migrateLoadedMeshConfig(config) {
   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;
 }
-function stripDeadRoleFromProviderRoles(policy) {
-  if (!policy || typeof policy !== "object") return false;
-  const roles = policy.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.role;
-      changed = true;
+function migrateProviderRolesToSlots(policy) {
+  if (!policy || typeof policy !== "object" || Array.isArray(policy)) return false;
+  const p = policy;
+  const rawRoles = p.providerRoles;
+  if (!Array.isArray(rawRoles)) return false;
+  const roleCap = /* @__PURE__ */ new Map();
+  for (const entry of rawRoles) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+    const rec = entry;
+    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) {
+    for (const { provider, cap } of roleCap.values()) {
+      const target = explicitSlots.find((s2) => s2.provider.trim().toLowerCase() === provider.toLowerCase() && s2.maxParallel === void 0);
+      if (target) target.maxParallel = cap;
+    }
+    p.slots = explicitSlots;
+  } else if (roleCap.size) {
+    let difficultyBrains;
+    try {
+      difficultyBrains = getDifficultyBrains();
+    } catch {
+      difficultyBrains = void 0;
+    }
+    const priority = Array.isArray(p.providerPriority) ? p.providerPriority.map((t) => typeof t === "string" ? t.trim() : "").filter(Boolean) : [];
+    const derived = deriveSlotsFromLegacy({ providerPriority: priority, difficultyBrains });
+    const slots = 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 === void 0) slot.maxParallel = match.cap;
     }
+    p.slots = slots;
   }
-  return changed;
+  delete p.providerRoles;
+  return true;
 }
 function normalizeCapabilityTags(value) {
   if (!Array.isArray(value)) return void 0;
@@ -3555,6 +3576,39 @@ var init_mesh_config = __esm({
   }
 });
 
+// src/mesh/mesh-node-slots.ts
+function normalizeProviderPriority(policy) {
+  const raw = policy && typeof policy === "object" && !Array.isArray(policy) ? policy.providerPriority : void 0;
+  if (!Array.isArray(raw)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  return raw.map((type) => typeof type === "string" ? type.trim() : "").filter(Boolean).filter((type) => {
+    if (seen.has(type)) return false;
+    seen.add(type);
+    return true;
+  });
+}
+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),
+    difficultyBrains
+  });
+}
+var init_mesh_node_slots = __esm({
+  "src/mesh/mesh-node-slots.ts"() {
+    "use strict";
+    init_dist();
+    init_mesh_config();
+  }
+});
+
 // src/mesh/coordinator-prompt.ts
 var coordinator_prompt_exports = {};
 __export(coordinator_prompt_exports, {
@@ -3741,13 +3795,20 @@ function buildNodeConfigSection(mesh) {
     const explicitMachineLabel = typeof n.machineLabel === "string" ? n.machineLabel : "";
     const explicitLabel = explicitMachineLabel ? ` label: **${explicitMachineLabel}** |` : "";
     const providerPriority = n.policy?.providerPriority?.length ? ` | providers: ${n.policy.providerPriority.join(", ")}` : "";
-    const providerRoles = Array.isArray(n.policy?.providerRoles) ? n.policy.providerRoles.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(", ")}` : "";
+    const nodeSlots = resolveNodeCapabilitySlots(n);
+    const seenCapProvider = /* @__PURE__ */ new Set();
+    const providerCaps = [];
+    for (const slot of nodeSlots) {
+      const type = typeof slot?.provider === "string" ? slot.provider.trim() : "";
+      if (!type) continue;
+      const key2 = type.toLowerCase();
+      if (seenCapProvider.has(key2)) continue;
+      seenCapProvider.add(key2);
+      const cap = resolveProviderMaxParallel(nodeSlots, type);
+      if (cap === void 0) 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}`);
     const routingTags = [];
     const custom = Array.isArray(n.capabilities) ? n.capabilities : [];
@@ -3922,7 +3983,7 @@ function buildRulesSection(coordinatorCliType) {
 
 - **Route, don't implement.** Delegate all code reading, analysis, and execution to node agents. Never read source files or run commands in the coordinator \u2014 keep context lean.
 - **Front-load task messages.** Include everything the agent needs (files, problem, expected fix) in \`mesh_enqueue_task\` / \`mesh_send_task\`. Append a structured result request at the end: ask the worker to conclude with a JSON block containing \`status\`, \`changedFiles\`, \`gitStatus\`, \`validationResults\`, \`errors\`, \`nextAction\`. The daemon parses this automatically; you can read it from \`mesh_task_history\`.
-- **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.
+- **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 a fresh session only when: (a) branch/worktree isolation is required, (b) the existing session had a dispatch failure or provider mismatch, (c) the transcript/runtime is contaminated or interrupted, or (d) the user explicitly asks for a different provider/session. Continuation of the same issue in an already-idle session is allowed and preferred \u2014 this rule blocks concurrent unrelated work interleaved into a live (still-generating) session, not sequential same-issue follow-ups.
 - **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.
@@ -3930,12 +3991,15 @@ function buildRulesSection(coordinatorCliType) {
 - **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).
 - **Check history first.** Call \`mesh_task_history\` at session start to avoid duplicate work and inform recovery. On failure, read task history before retrying.
+- **Don't reopen already-done work after a resume.** Before reopening a reported issue after context compaction or session resume, check current git state and recent session context. If another session has already completed the work, continue from the existing diff/commit instead of starting a duplicate investigation.
 - **Sequence shared-base-moving merges.** Parallel dispatch is encouraged, but merging one worktree can advance another in-flight worktree's base \u2014 especially a shared submodule pointer \u2014 turning a clean fast-forward into a diverged rebase (patch-equivalence correctly blocks this). Before merging an in-flight worktree while siblings are also in flight, land in an intentional order, re-clone long-running worktrees from the advanced base, or expect to manually rebase + ff-only the laggards; merging an independent fix mid-flight can strand siblings into a rebase.
 - **Converge branches.** After worktree tasks: refine/fast-forward, or classify as \`pushed_feature_branch_needs_merge\` / \`blocked_review\` / \`cleanup_candidate\` / \`not_mergeable\`. Clean up with \`mesh_remove_node\`.
 - **Refinery is config-driven.** \`mesh_refine_node\` must run validation from \`.adhdev/refine.{json,yaml,yml}\` or \`repo-mesh.refine.*\`. Heuristics are scaffolding only.
 - **Submodule reachability = publish-needed.** \`submodule_reachability_failed\` \u2192 classify as \`blocked_review\`, request user approval to push to submodule main, then rerun \`mesh_refine_node\`.
 - **Honor per-node instructions.** When a node carries a \u{1F4CC} Node instruction in the nodes section, include the relevant parts of that instruction in the task message you send to that node. Don't paraphrase the instruction into your own words \u2014 quote it verbatim so the worker agent sees exactly what the user wrote.
 - **Mission status does not update itself.** When a mission's tasks are all done or the work is abandoned, explicitly call \`mesh_mission_upsert\` to set status \`completed\` or \`abandoned\`. Never leave a finished mission in \`active\`. All-cancelled tasks with no further work \u2192 \`abandoned\`.
+- **Don't spawn a nested coordinator for simple inspection.** Do not spawn a nested coordinator-like agent for simple inspection tasks. If delegation is required, use explicit provider selection and a fully self-contained, bounded task instruction.
+- **Keep internal traffic out of the transcript.** Internal tool calls, status events, control messages, and debug output must not appear as ordinary user-visible chat transcript content unless explicitly marked user-facing by the producing agent.
 - **Never fabricate tool results.** Always call the actual tool.
 - **Keep the user informed.** One or two sentences after each delegation round.${coordinatorNote}
 
@@ -3953,6 +4017,7 @@ var init_coordinator_prompt = __esm({
     "use strict";
     init_repo_mesh_types();
     init_mesh_config();
+    init_mesh_node_slots();
     init_dist();
     PROMPT_SOFT_CAP_BYTES = 60 * 1024;
     OPERATING_NOTES_PROMPT_CAP = 20;
@@ -4037,7 +4102,9 @@ Follow these recovery rules:
 1. **If "Retry recommended"**: Check \`mesh_view_queue\` first \u2014 the daemon may have auto-requeued. If not, re-launch the session on the same node (\`mesh_launch_session\`), then resend the original task (\`mesh_send_task\`). The system message includes the original task text.
 2. **If "Max retries exceeded"**: Do NOT retry on the same node. Either reassign the task to a different node, or inform the user that the task requires manual intervention.
 3. **If no recovery context**: The stop may be intentional (normal completion). Use \`mesh_read_chat\` once to verify, then move on.
-4. **Always record what happened**: After handling a failure, briefly note the outcome in your report to the user.`;
+4. **Always record what happened**: After handling a failure, briefly note the outcome in your report to the user.
+5. **Stuck-but-done vs actually-stuck**: If a delegated session appears stuck but has already produced a verified final summary or diff, stop polling noisy tool/terminal transcript bubbles. Verify with \`mesh_git_status\` or a checkpoint and proceed to landing.
+6. **Refinery falsely blocks a verified-clean branch \u2014 manual fast-forward convergence**: When \`mesh_refine_node\` falsely blocks a verified-clean branch (stale preflight, or the submodule-gitlink trivial-fast-forward misjudgment), bypass the refine tool and converge by strict fast-forward \u2014 (1) rebase the submodule commit onto the submodule \`origin/main\`, (2) push the submodule ff-only (verify \`git merge-base --is-ancestor\` first), (3) rebase the root branch and re-bump the submodule pointer so the root diff stays non-empty, (4) push the root ff-only. NEVER force-push or reset; abort and report on any non-fast-forward.`;
     ONBOARDING_SECTION = `## Onboarding / Reinit
 
 When the user asks to **set up / configure / onboard** this repo for Repo Mesh (or to **re-init / reconfigure** an already-onboarded repo), run ONE guided, approval-gated conversation. You draft, the user approves, the daemon writes. Never auto-write a heuristic suggestion without an explicit user approval turn.
@@ -7151,8 +7218,8 @@ var init_mesh_runtime_store = __esm({
       /**
        * 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.
@@ -12902,15 +12969,22 @@ function buildMeshSchedulingRuntime(mesh, queue) {
     if (globalWriteCapReached) capReasons.push("global_max_parallel_tasks_reached");
     if ((writeAssignedByNode.get(nodeId) ?? 0) > 0) capReasons.push("node_has_active_assignment");
     let providerRoles;
-    const declaredRoles = Array.isArray(policy?.providerRoles) ? policy.providerRoles : [];
-    if (declaredRoles.length) {
+    const slots = resolveNodeCapabilitySlots(rawNode);
+    const cappedProviders = [];
+    const seenProvider = /* @__PURE__ */ new Set();
+    for (const slot of slots) {
+      const providerType = typeof slot?.provider === "string" ? slot.provider.trim() : "";
+      if (!providerType) continue;
+      const key2 = providerType.toLowerCase();
+      if (seenProvider.has(key2)) continue;
+      seenProvider.add(key2);
+      if (resolveProviderMaxParallel(slots, providerType) !== void 0) cappedProviders.push(providerType);
+    }
+    if (cappedProviders.length) {
       const byProvider = providerCountByNode.get(nodeId);
       providerRoles = [];
-      for (const role of declaredRoles) {
-        if (!role || typeof role !== "object") continue;
-        const providerType = typeof role.providerType === "string" ? role.providerType.trim() : "";
-        if (!providerType) continue;
-        const maxParallel = resolveProviderMaxParallel(policy, providerType);
+      for (const providerType of cappedProviders) {
+        const maxParallel = resolveProviderMaxParallel(slots, providerType);
         const activeAssigned = byProvider?.get(providerType) ?? 0;
         const capReached = maxParallel !== void 0 && activeAssigned >= maxParallel;
         providerRoles.push({
@@ -12951,6 +13025,7 @@ var init_mesh_scheduling_runtime = __esm({
     "use strict";
     init_repo_mesh_types();
     init_dist();
+    init_mesh_node_slots();
     init_mesh_work_queue();
   }
 });
@@ -15570,6 +15645,32 @@ var init_mesh_clone_grace = __esm({
   }
 });
 
+// src/mesh/model-provider-compat.ts
+function isAnthropicProvider(providerType) {
+  const p = typeof providerType === "string" ? providerType.trim().toLowerCase() : "";
+  return p.length > 0 && ANTHROPIC_PROVIDER_TYPES.has(p);
+}
+function isAnthropicModel(model) {
+  const m = typeof model === "string" ? model.trim().toLowerCase() : "";
+  if (!m) return false;
+  if (m.startsWith("claude") || m.startsWith("anthropic")) return true;
+  return /^(opus|sonnet|haiku)(\b|[-_])/.test(m);
+}
+function isModelCompatibleWithProvider(model, providerType) {
+  if (!isAnthropicModel(model)) return true;
+  if (isAnthropicProvider(providerType)) return true;
+  return false;
+}
+var ANTHROPIC_PROVIDER_TYPES;
+var init_model_provider_compat = __esm({
+  "src/mesh/model-provider-compat.ts"() {
+    "use strict";
+    ANTHROPIC_PROVIDER_TYPES = /* @__PURE__ */ new Set([
+      "claude-cli"
+    ]);
+  }
+});
+
 // src/mesh/mesh-queue-assignment.ts
 import { existsSync as existsSync18 } from "fs";
 function localCoordinatorDaemonId() {
@@ -15749,7 +15850,7 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
     return false;
   }
   const capabilityTags = buildMeshNodeCapabilityTags(node, providerType);
-  const providerMaxParallel = resolveProviderMaxParallel(node?.policy, providerType);
+  const providerMaxParallel = resolveProviderMaxParallel(resolveNodeCapabilitySlots(node), providerType);
   const nodeIsWorktree = node?.isLocalWorktree === true;
   const task = claimNextTask(meshId, nodeId, sessionId, capabilityTags, {
     providerType,
@@ -16007,7 +16108,7 @@ function sweepExpiredCooldowns() {
     if (now >= until) autoLaunchCooldownUntil.delete(key2);
   }
 }
-function normalizeProviderPriority(policy) {
+function normalizeProviderPriority2(policy) {
   const raw = policy && typeof policy === "object" && !Array.isArray(policy) ? policy.providerPriority : void 0;
   if (!Array.isArray(raw)) return [];
   const seen = /* @__PURE__ */ new Set();
@@ -16121,21 +16222,6 @@ 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;
@@ -16262,6 +16348,7 @@ function nodeHasLiveSessionPendingClaim(components, meshId, nodeId) {
     const state = inst.getState();
     const settings = state.settings || {};
     if (readNonEmptyString2(settings.meshNodeFor) !== meshId) return false;
+    if (readNonEmptyString2(settings.meshCoordinatorFor) === meshId) return false;
     const instNodeId = readNonEmptyString2(settings.meshNodeId) || readNonEmptyString2(settings.nodeId);
     if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
     const status = readNonEmptyString2(state.status).toLowerCase();
@@ -16466,7 +16553,7 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
       if (task.targetNodeId && !meshNodeIdMatches(node, task.targetNodeId)) return false;
       if (task.taskMode === "convergence" && node?.isLocalWorktree === true) return false;
       if (task.requiredTags?.length) {
-        const priorities = normalizeProviderPriority(node?.policy);
+        const priorities = normalizeProviderPriority2(node?.policy);
         const providerCandidates = priorities.length ? priorities : [void 0];
         return providerCandidates.some(
           (p) => nodeSatisfiesRequiredTags(task.requiredTags, buildMeshNodeCapabilityTags(node, p))
@@ -16547,9 +16634,13 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
           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 rawEffectiveModel = 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);
+        const effectiveModel = isModelCompatibleWithProvider(rawEffectiveModel, resolved.providerType) ? rawEffectiveModel : void 0;
+        if (rawEffectiveModel && effectiveModel === void 0) {
+          LOG.info("MeshQueue", `CODEX-400 GUARD: dropped incompatible launch model '${rawEffectiveModel}' for non-Anthropic provider '${resolved.providerType}' on node ${nodeId} (task ${task.id}); provider will use its own default model`);
+        }
+        const providerCap = resolveProviderMaxParallel(resolveNodeCapabilitySlots(node), 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 });
           continue;
@@ -16872,6 +16963,7 @@ var init_mesh_queue_assignment = __esm({
     init_mesh_warmup_deadline();
     init_repo_mesh_types();
     init_dist();
+    init_mesh_node_slots();
     init_mesh_events_stale();
     init_mesh_events_utils();
     init_mesh_node_identity();
@@ -16879,6 +16971,7 @@ var init_mesh_queue_assignment = __esm({
     init_worktree_bootstrap_config();
     init_mesh_clone_grace();
     init_mesh_task_inflight();
+    init_model_provider_compat();
     IDLE_AUTO_FAST_FORWARD_THROTTLE_MS = 30 * 60 * 1e3;
     idleAutoFastForwardLastAttempt = /* @__PURE__ */ new Map();
     BOOTSTRAP_TERMINAL_STATUSES = /* @__PURE__ */ new Set(["complete", "failed"]);
@@ -45300,6 +45393,7 @@ var STATUS_HYDRATION_TAIL_LIMIT = 200;
 var COMPLETED_FINALIZATION_RETRY_MS = 1e3;
 var COMPLETED_FINALIZATION_MAX_WAIT_MS = 3e4;
 var NATIVE_HISTORY_MESH_IDLE_SETTLE_MS = 4e3;
+var PTY_PARSED_FINAL_ASSISTANT_QUIET_DWELL_MS = 1200;
 var BACKGROUND_TASK_HOLD_MAX_MS = 5 * 6e4;
 var USER_INPUT_ACK_DEDUP_WINDOW_MS = 6e4;
 var STARTUP_GRACE_IDLE_COLLAPSE_WINDOW_MS = 12e3;
@@ -45542,6 +45636,39 @@ var CliProviderInstance = class _CliProviderInstance {
    * the nudge was NOT deferred) and leaked to the coordinator.
    */
   static AUTO_APPROVE_MASK_STALL_MS = 10500;
+  /**
+   * 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).
+   */
+  static APPROVAL_STICKY_FLAP_MS = 4e3;
   /**
    * FALSE-IDLE (inter-approval quiet valley): grace window after an auto-approve
    * (or mesh_approve) RESOLVES a modal during which a subsequent generating→idle
@@ -45645,6 +45772,14 @@ var CliProviderInstance = class _CliProviderInstance {
   // signature) while a genuinely closed modal — buttons empty continuously past
   // the continuity window — is still recognised and resets the gate.
   autoApproveLastModalSeenAt = 0;
+  // AUTOAPPROVE-FLAP-INBOX-MISSING sticky-approval overlay (see APPROVAL_STICKY_FLAP_MS).
+  // The wall-clock of the last frame where the RAW adapter reported waiting_approval with
+  // a CONCRETE modal (buttons present), the cached modal to re-present across a busy blip,
+  // and the approvalEntrySeq at that frame (so a stabilized frame carries the right seq to
+  // the emission-dedup fingerprint). All zero/null when no recent concrete approval.
+  approvalStickyLastConcreteAt = 0;
+  approvalStickyModal = null;
+  approvalStickyEntrySeq = 0;
   // STATUS-MISMATCH: wall-clock when the CURRENT auto-approve episode (waiting_approval
   // + shouldAutoApprove) first began wanting to mask. Unlike pendingAutoApprovalSince it
   // is NOT reset when the modal signature changes (a still-streaming/flapping prompt) and
@@ -45786,7 +45921,7 @@ var CliProviderInstance = class _CliProviderInstance {
     }
   }
   getState() {
-    const adapterStatus = this.adapter.getStatus();
+    const adapterStatus = this.stabilizeFlappingApprovalStatus(this.adapter.getStatus());
     if (Object.prototype.hasOwnProperty.call(adapterStatus, "activeInteractivePrompt")) {
       this.activeInteractivePrompt = adapterStatus.activeInteractivePrompt ?? null;
     }
@@ -46650,6 +46785,9 @@ var CliProviderInstance = class _CliProviderInstance {
             return null;
           }
           if (this.type === "antigravity-cli") {
+            if (allowMissingAssistantTimeout) {
+              return { reason: "missing_final_assistant", terminal: false, holdForTranscript: true };
+            }
             return null;
           }
           if (allowMissingAssistantTimeout && pending.previousStatus === "waiting_approval") {
@@ -46681,6 +46819,19 @@ var CliProviderInstance = class _CliProviderInstance {
       }
     } catch {
     }
+    if (allowMissingAssistantTimeout && !adapterOwnsMessagesElsewhere && finalAssistantEvidence.source === "parsed") {
+      try {
+        const outStatus = this.adapter.getStatus({ allowParse: false });
+        const lastOutputAt = typeof outStatus?.lastOutputAt === "number" && Number.isFinite(outStatus.lastOutputAt) ? outStatus.lastOutputAt : void 0;
+        if (typeof lastOutputAt === "number") {
+          const quietMs = Date.now() - lastOutputAt;
+          if (quietMs < PTY_PARSED_FINAL_ASSISTANT_QUIET_DWELL_MS) {
+            return { reason: "parsed_final_assistant_quiet_dwell", terminal: false };
+          }
+        }
+      } catch {
+      }
+    }
     return null;
   }
   // (FALSEIDLE-a) Positive, structural proof that the latest approval entry was resolved
@@ -47102,6 +47253,53 @@ var CliProviderInstance = class _CliProviderInstance {
       ...opts.completionDiagnostic !== void 0 ? { completionDiagnostic: opts.completionDiagnostic } : {}
     });
   }
+  /**
+   * 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).
+   */
+  stabilizeFlappingApprovalStatus(adapterStatus, now = Date.now()) {
+    if (!this.isAutonomousMeshSession() || !this.shouldAutoApprove()) return adapterStatus;
+    const rawStatus = adapterStatus?.status;
+    const resolvedAt = typeof this.adapter?.lastApprovalResolvedAt === "number" ? this.adapter.lastApprovalResolvedAt : 0;
+    if (rawStatus === "waiting_approval") {
+      if (hasNonEmptyCliModalButtons(adapterStatus?.activeModal)) {
+        this.approvalStickyLastConcreteAt = now;
+        this.approvalStickyModal = adapterStatus.activeModal;
+        this.approvalStickyEntrySeq = typeof adapterStatus?.approvalEntrySeq === "number" ? adapterStatus.approvalEntrySeq : this.approvalStickyEntrySeq;
+      }
+      return adapterStatus;
+    }
+    if (this.approvalStickyLastConcreteAt > 0 && this.approvalStickyModal) {
+      const withinWindow = now - this.approvalStickyLastConcreteAt < _CliProviderInstance.APPROVAL_STICKY_FLAP_MS;
+      const resolvedSinceAnchor = resolvedAt >= this.approvalStickyLastConcreteAt;
+      if (withinWindow && !resolvedSinceAnchor) {
+        return {
+          ...adapterStatus,
+          status: "waiting_approval",
+          activeModal: this.approvalStickyModal,
+          ...this.approvalStickyEntrySeq ? { approvalEntrySeq: this.approvalStickyEntrySeq } : {},
+          approvalStickyOverlay: true
+        };
+      }
+      this.approvalStickyLastConcreteAt = 0;
+      this.approvalStickyModal = null;
+      this.approvalStickyEntrySeq = 0;
+    }
+    return adapterStatus;
+  }
   maybeAutoApproveStatus(adapterStatus, now = Date.now()) {
     if (adapterStatus?.status === "waiting_approval" && this.shouldAutoApprove() && this.manualAttendance.isAttended(now)) {
       this.lastAutoApprovalSignature = "";
@@ -47331,7 +47529,7 @@ ${buttons.join("\n")}`;
   }
   detectStatusTransition() {
     const now = Date.now();
-    const adapterStatus = this.adapter.getStatus({ allowParse: false });
+    const adapterStatus = this.stabilizeFlappingApprovalStatus(this.adapter.getStatus({ allowParse: false }), now);
     const adapterProviderSessionId = normalizeProviderSessionId(
       this.provider,
       typeof adapterStatus?.providerSessionId === "string" ? adapterStatus.providerSessionId : ""
@@ -55625,7 +55823,7 @@ var meshCrudHandlers = {
     const ownerFailure = await ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "node addition");
     if (ownerFailure) return ownerFailure;
     try {
-      const { addNode: addNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+      const { addNode: addNode2, migrateProviderRolesToSlots: migrateProviderRolesToSlots2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
       const providerPriority = Array.isArray(args?.providerPriority) ? args.providerPriority.map((type) => typeof type === "string" ? type.trim() : "").filter(Boolean) : [];
       const readOnly = args?.readOnly === true;
       const providerRoles = normalizeProviderRoles(args?.providerRoles);
@@ -55634,6 +55832,7 @@ var meshCrudHandlers = {
         ...providerPriority.length ? { providerPriority } : {},
         ...providerRoles.length ? { providerRoles } : {}
       };
+      if (providerRoles.length) migrateProviderRolesToSlots2(policy);
       const role = normalizeMeshDaemonRole(args?.role);
       const daemonId = typeof args?.daemonId === "string" && args.daemonId.trim() ? args.daemonId.trim() : void 0;
       const machineId = typeof args?.machineId === "string" && args.machineId.trim() ? args.machineId.trim() : void 0;
@@ -55662,7 +55861,7 @@ var meshCrudHandlers = {
     const ownerFailure = await ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "node update");
     if (ownerFailure) return ownerFailure;
     try {
-      const { updateNode: updateNode2, normalizeCapabilityTags: normalizeCapabilityTags2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+      const { updateNode: updateNode2, normalizeCapabilityTags: normalizeCapabilityTags2, migrateProviderRolesToSlots: migrateProviderRolesToSlots2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
       const policy = args?.policy && typeof args.policy === "object" && !Array.isArray(args.policy) ? { ...args.policy } : {};
       if (Array.isArray(args?.providerPriority)) {
         const providerPriority = args.providerPriority.map((type) => typeof type === "string" ? type.trim() : "").filter(Boolean);
@@ -55675,12 +55874,10 @@ var meshCrudHandlers = {
       }
       if (Array.isArray(args?.providerRoles)) {
         const providerRoles = normalizeProviderRoles(args.providerRoles);
-        if (providerRoles.length) {
-          policy.providerRoles = providerRoles;
-        } else {
-          delete policy.providerRoles;
-        }
+        if (providerRoles.length) policy.providerRoles = providerRoles;
+        else delete policy.providerRoles;
       }
+      migrateProviderRolesToSlots2(policy);
       const patch = { policy };
       if (typeof args?.systemPrompt === "string") {
         const trimmed = args.systemPrompt.trim();
@@ -55952,8 +56149,11 @@ var meshCrudHandlers = {
         console.log(`[mesh] clone_mesh_node base sync: ${result.baseSync.action} (startRef=${result.baseSync.startRef})`);
       }
       let node;
+      const { migrateProviderRolesToSlots: migrateProviderRolesToSlots2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
       if (meshRecord.inline) {
         const { randomUUID: randomUUID15 } = await import("crypto");
+        const clonedPolicy = { ...sourceNode.policy || {} };
+        migrateProviderRolesToSlots2(clonedPolicy);
         node = {
           id: `node_${randomUUID15().replace(/-/g, "")}`,
           workspace: result.worktreePath,
@@ -55961,7 +56161,7 @@ var meshCrudHandlers = {
           daemonId: sourceNode.daemonId,
           machineId: sourceNode.machineId ?? sourceNode.machine_id,
           userOverrides: { ...sourceNode.userOverrides || {} },
-          policy: { ...sourceNode.policy || {} },
+          policy: clonedPolicy,
           isLocalWorktree: true,
           worktreeBranch: result.branch,
           clonedFromNodeId: sourceNodeId
@@ -55969,6 +56169,8 @@ var meshCrudHandlers = {
         ctx.updateInlineMeshNode(meshId, mesh, node);
       } else {
         const { addNode: addNode2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+        const clonedPolicy = { ...sourceNode.policy || {} };
+        migrateProviderRolesToSlots2(clonedPolicy);
         node = addNode2(meshId, {
           workspace: result.worktreePath,
           repoRoot: result.worktreePath,
@@ -55978,7 +56180,7 @@ var meshCrudHandlers = {
           isLocalWorktree: true,
           worktreeBranch: result.branch,
           clonedFromNodeId: sourceNodeId,
-          policy: { ...sourceNode.policy || {} }
+          policy: clonedPolicy
         });
         if (!node) return { success: false, error: "Failed to register worktree node" };
         const inlineForReconcile = ctx.getCachedInlineMesh(meshId);