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

package/dist/config/mesh-config.d.ts

@@ -7,6 +7,18 @@
  */
 import type { LocalMeshEntry, LocalMeshNodeEntry, RepoMeshPolicy, RepoMeshNodePolicy, RepoMeshNodeCapabilities, RepoMeshCoordinatorConfig, RepoMeshHostMetadata, RepoMeshDaemonRole } from '../repo-mesh-types.js';
 import type { MagiKindPanelMap, MagiSlot, DifficultyBrainMap } from '@adhdev/mesh-shared';
+/**
+ * Migrate a node policy's legacy `providerRoles` cap onto `slots[].maxParallel`,
+ * in place, then delete the `providerRoles` field. Defensive against malformed
+ * entries. Returns true when the policy was mutated.
+ *
+ * Behavior-preserving: the resulting slots carry the same per-(node, provider)
+ * cap the queue previously enforced from providerRoles. When the node had no
+ * explicit slots, slots are derived from the legacy providerPriority (folding the
+ * caps in via deriveSlotsFromLegacy-equivalent logic); when it did, each cap is
+ * merged into the first matching-provider slot lacking a maxParallel.
+ */
+export declare function migrateProviderRolesToSlots(policy: unknown): boolean;
 export declare function normalizeCapabilityTags(value: unknown): string[] | undefined;
 /**
  * Normalize a Git remote URL into a stable identity string.

package/dist/index.js

@@ -122,20 +122,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({
@@ -417,10 +417,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "3c72ac19ec9253071d614cd2410dc9f8d555eb26" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "3c72ac19" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.508" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-12T23:18:59.856Z" : 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;
 }
@@ -2848,12 +2848,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 = [];
@@ -2875,13 +2869,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 } : {}
     };
   });
 }
@@ -3049,6 +3041,7 @@ __export(mesh_config_exports, {
   listMagiKindPanels: () => listMagiKindPanels,
   listMeshes: () => listMeshes,
   markMeshHostPairingJoined: () => markMeshHostPairingJoined,
+  migrateProviderRolesToSlots: () => migrateProviderRolesToSlots,
   normalizeCapabilityTags: () => normalizeCapabilityTags,
   normalizeMagiSlots: () => normalizeMagiSlots,
   normalizeRepoIdentity: () => normalizeRepoIdentity,
@@ -3087,23 +3080,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;
@@ -3561,6 +3582,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, {
@@ -3744,13 +3798,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 : [];
@@ -3962,6 +4023,7 @@ var init_coordinator_prompt = __esm({
     path8 = __toESM(require("path"));
     init_repo_mesh_types();
     init_mesh_config();
+    init_mesh_node_slots();
     init_dist();
     PROMPT_SOFT_CAP_BYTES = 60 * 1024;
     OPERATING_NOTES_PROMPT_CAP = 20;
@@ -7163,8 +7225,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.
@@ -12914,15 +12976,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({
@@ -12963,6 +13032,7 @@ var init_mesh_scheduling_runtime = __esm({
     "use strict";
     init_repo_mesh_types();
     init_dist();
+    init_mesh_node_slots();
     init_mesh_work_queue();
   }
 });
@@ -15777,7 +15847,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,
@@ -16035,7 +16105,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();
@@ -16149,21 +16219,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;
@@ -16290,6 +16345,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();
@@ -16494,7 +16550,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))
@@ -16581,7 +16637,7 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
         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(node?.policy, resolved.providerType);
+        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;
@@ -16905,6 +16961,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();
@@ -45761,6 +45818,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;
@@ -46003,6 +46061,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
@@ -46106,6 +46197,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
@@ -46247,7 +46346,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;
     }
@@ -47111,6 +47210,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") {
@@ -47142,6 +47244,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
@@ -47563,6 +47678,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 = "";
@@ -47792,7 +47954,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 : ""
@@ -56081,7 +56243,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);
@@ -56090,6 +56252,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;
@@ -56118,7 +56281,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);
@@ -56131,12 +56294,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();
@@ -56408,8 +56569,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,
@@ -56417,7 +56581,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
@@ -56425,6 +56589,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,
@@ -56434,7 +56600,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);