@adhdev/daemon-core 0.9.82-rc.536 → 0.9.82-rc.538

package/src/mesh/mesh-work-queue.ts

@@ -9,7 +9,7 @@ import { appendLedgerEntry } from './mesh-ledger.js';
 import type { MeshLedgerKind } from './mesh-ledger.js';
 import { createSessionDelivery } from './mesh-delivery-policy.js';
 import { isTaskDispatchInFlight, endTaskDispatchInFlight } from './mesh-task-inflight.js';
-import { sessionIdsEquivalent, isMeshTaskDifficulty, type MeshTaskDifficulty } from '@adhdev/mesh-shared';
+import { sessionIdsEquivalent, isMeshTaskDifficulty, normalizeNodeCapabilitySlots, type MeshTaskDifficulty } from '@adhdev/mesh-shared';
 
 export type MeshTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed' | 'cancelled';
 export type MeshActiveTaskStatus = Extract<MeshTaskStatus, 'pending' | 'assigned'>;
@@ -692,6 +692,37 @@ function firstProviderPriority(policy: unknown): string | undefined {
     return raw.find(type => typeof type === 'string' && type.trim())?.trim();
 }
 
+/**
+ * Ordered, de-duplicated provider types a node can launch, resolved from
+ * `policy.slots` (the single source of truth — ORCHESTRATION_NODE_SLOTS.md) with a
+ * fallback to the legacy `policy.providerPriority`. Used to advertise a
+ * `provider=<type>` capability tag for EVERY provider the node supports, not just
+ * providerPriority[0], so required_tags: ["provider=cursor-cli"] is satisfiable on a
+ * node whose slots include cursor-cli even when it is not the first priority entry.
+ *
+ * Only provider NAMES are needed here, so slots are read via the dependency-light
+ * normalizeNodeCapabilitySlots rather than resolveNodeCapabilitySlots (which pulls in
+ * difficultyBrains) — keeping tag derivation free of scheduling-config imports.
+ */
+function readNodeProviderTypes(policy: unknown): string[] {
+    const record = policy && typeof policy === 'object' && !Array.isArray(policy)
+        ? policy as Record<string, unknown>
+        : {};
+    const seen = new Set<string>();
+    const out: string[] = [];
+    const push = (type: unknown) => {
+        const trimmed = typeof type === 'string' ? type.trim() : '';
+        if (!trimmed || seen.has(trimmed)) return;
+        seen.add(trimmed);
+        out.push(trimmed);
+    };
+    for (const slot of normalizeNodeCapabilitySlots(record.slots)) push(slot.provider);
+    if (Array.isArray(record.providerPriority)) {
+        for (const type of record.providerPriority) push(type);
+    }
+    return out;
+}
+
 function readNodeOverride(node: { userOverrides?: unknown } | undefined, key: 'platform' | 'arch'): string | null {
     const overrides = node?.userOverrides;
     if (!overrides || typeof overrides !== 'object' || Array.isArray(overrides)) return null;
@@ -715,9 +746,20 @@ export function buildMeshNodeCapabilityTags(
     node: { capabilities?: unknown; policy?: unknown; isLocalWorktree?: unknown; worktreeBranch?: unknown; userOverrides?: unknown; reportedPlatform?: unknown; reportedArch?: unknown } | undefined,
     providerType?: string,
 ): string[] {
-    const provider = typeof providerType === 'string' && providerType.trim()
+    // When an explicit providerType is pinned (per-provider tag set used by the
+    // queue slot matcher), advertise ONLY that provider's tag — so
+    // provider=codex-cli matches only when codex-cli is the launched provider.
+    // When no provider is pinned (the representative tag set consulted by
+    // nodeSatisfiesRequiredTags), advertise a provider= tag for EVERY provider the
+    // node can launch (all policy.slots, else providerPriority), so
+    // required_tags: ["provider=cursor-cli"] is satisfiable on a node whose slots
+    // include cursor-cli even when it is not the first priority entry.
+    const pinnedProvider = typeof providerType === 'string' && providerType.trim()
         ? providerType.trim()
-        : firstProviderPriority(node?.policy);
+        : undefined;
+    const providerTags = pinnedProvider
+        ? [pinnedProvider]
+        : readNodeProviderTypes(node?.policy);
     const worktreeBranch = typeof node?.worktreeBranch === 'string' && node.worktreeBranch.trim()
         ? node.worktreeBranch.trim()
         : null;
@@ -744,7 +786,7 @@ export function buildMeshNodeCapabilityTags(
         ...(Array.isArray(node?.capabilities) ? node.capabilities : []),
         `os=${os}`,
         `arch=${arch}`,
-        ...(provider ? [`provider=${provider}`] : []),
+        ...providerTags.map(p => `provider=${p}`),
         // Worktree nodes automatically expose a "worktree=<branch>" tag so that
         // mesh_enqueue_task with required_tags: ["worktree=<branch>"] routes
         // only to the matching worktree node.
@@ -1358,6 +1400,34 @@ export function requeueTask(
  */
 const MAX_STRANDED_RECLAIMS = 3;
 
+/**
+ * TASK-PROMPT-REDRIVE-AFTER-COMPLETE: the reclaim reasons the assigned-stranded watchdog
+ * uses when it RE-DRIVES a delivered-but-not-terminal task (returns it to 'pending' so the
+ * SAME prompt is re-dispatched). These are distinct from `assigned_stranded_dispatch_unconfirmed`
+ * (a dispatch that was NEVER handed off — nothing ran, so a late completion is impossible).
+ *
+ * A re-drive assumes the worker never finished. But for an autoLaunch/worktree worker the
+ * turn-lifecycle events (agent:generating_started/completed) do NOT reliably reach the
+ * coordinator ledger, so the deadline can elapse and re-drive fire while the worker's genuine
+ * completion is merely LATE (observed live: it lands 0.9s–98s AFTER the reclaim). The late
+ * completion must then SUPERSEDE the re-drive rather than be dropped — the completion handler's
+ * flip-miss safety net checks a row reclaimed for one of these reasons within
+ * {@link REDRIVE_SUPERSEDE_WINDOW_MS} of its `requeuedAt`.
+ */
+export const REDRIVE_RECLAIM_REASONS: ReadonlySet<string> = new Set([
+    'delivered_no_turn_deadline',
+    'reclaim_after_unknown_grace',
+    'delivered_not_consumed_redrive',
+]);
+
+/**
+ * How long after a re-drive reclaim's `requeuedAt` a late completion still supersedes the
+ * re-dispatch. Comfortably covers the observed 0.9s–98s completion-vs-reclaim race with margin,
+ * while staying far short of the time it would take a genuinely fresh re-dispatched turn to
+ * produce its OWN completion — so a real second turn is never mistaken for the superseded one.
+ */
+export const REDRIVE_SUPERSEDE_WINDOW_MS = 5 * 60_000;
+
 /**
  * Bug B: reclaim a task stuck in 'assigned' because its dispatch was never confirmed.
  *

package/src/providers/sdk/v1/builders/cli/detect-status.ts

@@ -227,6 +227,108 @@ function modalMatches(spec: ModalSpec, input: CliStatusInput): boolean {
   return false;
 }
 
+/**
+ * Index (line number) of the last line in `screenText` that carries a modal
+ * cue — question line, question variant, or a button-block label line — or -1
+ * if none. Used to detect a *stale* modal box: some CLIs (e.g. cursor-agent's
+ * "Workspace Trust Required" prompt) never clear their box rows after the user
+ * answers. The redraw that replaces the modal with the idle composer is shorter
+ * than the box, so the top modal rows linger in the terminal grid. Without a
+ * spatial check, the unscoped whole-screen `modalMatches` keeps firing
+ * `waiting_approval` forever and the session wedges in `starting` — the
+ * startup gate never releases because `detectStatus` never returns `idle`.
+ */
+function lastModalCueLine(spec: ModalSpec, screenText: string): number {
+  if (!screenText) return -1;
+  const lines = screenText.split('\n');
+  const question = compile(spec.questionPattern, spec.questionFlags ?? 'i');
+  const variants = (spec.questionVariants ?? []).map((v) => compile(v.regex, v.flags ?? 'i'));
+  const buttonFlags = spec.buttonFlags && spec.buttonFlags.includes('m')
+    ? spec.buttonFlags
+    : `${spec.buttonFlags ?? ''}m`;
+  const buttonRe = compile(spec.buttonPattern, buttonFlags);
+  let last = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    question.lastIndex = 0;
+    if (question.test(line)) { last = i; continue; }
+    if (variants.some((re) => { re.lastIndex = 0; return re.test(line); })) { last = i; continue; }
+    buttonRe.lastIndex = 0;
+    if (buttonRe.test(line)) { last = i; continue; }
+  }
+  return last;
+}
+
+/**
+ * True when the modal cue is *stale* — a leftover box the CLI failed to clear —
+ * because the live idle composer has repainted BELOW it.
+ *
+ * The discriminator is spatial, so a live modal (whose own selection cursor /
+ * button block can incidentally match a settled-prompt regex) is NOT mistaken
+ * for stale:
+ *
+ *   - A settled-prompt cue must match strictly BELOW the last modal cue line.
+ *   - AND at least one non-blank line between them is neither a modal cue nor
+ *     part of the settled-prompt match itself (the separator prose).
+ *
+ * A live modal renders its question + button block FLUSH against its own
+ * composer/selection cursor (no intervening prose). A stale box, by contrast,
+ * has the CLI's welcome banner / follow-up hint / mode footer repainted between
+ * the leftover box rows and the live composer. So the discriminator is: a
+ * settled-prompt cue matches strictly BELOW the last modal cue line AND at least
+ * one non-blank, non-modal line separates them. That separator is exactly the
+ * content a live modal never has between its buttons and its cursor, and it is
+ * robust to the terminal-snapshot append that can shuffle the tail window.
+ */
+function modalSupersededBySettledPrompt(
+  modalSpec: ModalSpec,
+  settledSpec: SettledPromptSpec | undefined,
+  settled: ReturnType<typeof compileSettledPromptMatchers> | null,
+  input: CliStatusInput,
+): boolean {
+  if (!settled || !settledSpec) return false;
+  if (settledSpec.scope === 'whole-screen') return false;
+  const screenText = input.screenText ?? '';
+  if (!screenText) return false;
+  const modalLine = lastModalCueLine(modalSpec, screenText);
+  if (modalLine < 0) return false;
+  const lines = screenText.split('\n');
+  const below = lines.slice(modalLine + 1);
+  if (below.length === 0) return false;
+  // A settled prompt (composer) must render somewhere below the modal box.
+  const belowText = below.join('\n');
+  if (!settled.prompt.test(belowText)) return false;
+  if (settled.footers.length > 0 && !settled.footers.every((f) => f.test(belowText))) return false;
+  // Require a real separator between the leftover box and the composer: a
+  // non-blank line that is neither a modal cue NOR part of the settled-prompt
+  // match itself. That separator is the CLI's welcome banner / follow-up hint /
+  // mode footer a stale box shows above the repainted composer. A live modal's
+  // selection cursor sits flush against its buttons with no such prose between
+  // them (and the cursor line, even if it matches the settled regex, is not a
+  // separator), so an active modal is never misread as stale.
+  const question = compile(modalSpec.questionPattern, modalSpec.questionFlags ?? 'i');
+  const variants = (modalSpec.questionVariants ?? []).map((v) => compile(v.regex, v.flags ?? 'i'));
+  const buttonFlags = modalSpec.buttonFlags && modalSpec.buttonFlags.includes('m')
+    ? modalSpec.buttonFlags
+    : `${modalSpec.buttonFlags ?? ''}m`;
+  const buttonRe = compile(modalSpec.buttonPattern, buttonFlags);
+  const isModalCueLine = (line: string): boolean => {
+    question.lastIndex = 0;
+    if (question.test(line)) return true;
+    if (variants.some((re) => { re.lastIndex = 0; return re.test(line); })) return true;
+    buttonRe.lastIndex = 0;
+    return buttonRe.test(line);
+  };
+  // A single-line settled regex would let a lone match count as its own line;
+  // test each below-line against the prompt regex on that line alone.
+  const settledPromptLineRe = compile(settledSpec.regex, (settledSpec.flags ?? 'm').includes('m') ? (settledSpec.flags ?? 'm') : `${settledSpec.flags ?? ''}m`);
+  const isSettledLine = (line: string): boolean => {
+    settledPromptLineRe.lastIndex = 0;
+    return settledPromptLineRe.test(line);
+  };
+  return below.some((line) => line.trim() !== '' && !isModalCueLine(line) && !isSettledLine(line));
+}
+
 // ─── Public builder ────────────────────────────────────────────────────
 
 const DEFAULT_ORDER: DispatchGroup[] = ['spinner', 'modal', 'settled-prompt'];
@@ -248,7 +350,12 @@ function evaluateGroup(
     }
     case 'modal': {
       if (!spec.modal) return null;
-      return modalMatches(spec.modal, input) ? 'waiting_approval' : null;
+      if (!modalMatches(spec.modal, input)) return null;
+      // A modal cue with the live composer repainted below it (in the settled
+      // prompt's own tail scope) is a stale box the CLI failed to clear — yield
+      // so settled-prompt/idle can win.
+      if (modalSupersededBySettledPrompt(spec.modal, spec.settledPrompt, compiled.settled, input)) return null;
+      return 'waiting_approval';
     }
     case 'settled-prompt': {
       if (!spec.settledPrompt || !compiled.settled) return null;

package/src/providers/sdk/v1/builders/cli/parse-approval.ts

@@ -83,7 +83,39 @@ function findQuestionLineIndex(
   lines: string[],
 ): { index: number; matchedSource: 'primary' | string } | null {
   const primary = compile(spec.questionPattern, spec.questionFlags ?? 'i');
-  // Search bottom-up to prefer the most recent modal.
+  // A question keyword frequently ALSO appears inside a button label:
+  // cursor-agent's Workspace-Trust modal renders `▶ [a] Trust this workspace`
+  // and its questionPattern matches the bare word `Trust`; the git-command
+  // prompt offers an `Approve`/`Allow`/`Run` button while the pattern lists
+  // `approve|Approve|Allow`. A bottom-up scan therefore lands on the BUTTON
+  // line (lower on screen) instead of the real prose question above it, and
+  // extractButtons (which starts at question.index + 1) then scopes the
+  // affirmative button OUT — leaving fewer than minButtons → parseApproval
+  // returns null → the approval never surfaces and the session wedges in
+  // `starting`/`generating`. Skip lines that are themselves button lines so
+  // the search resolves to the prose question, not a button label that merely
+  // shares a keyword. This is the general form of the kimi defect-C fix.
+  const buttonFlags = spec.buttonFlags && spec.buttonFlags.includes('m')
+    ? spec.buttonFlags
+    : `${spec.buttonFlags ?? ''}m`;
+  const buttonRe = compile(spec.buttonPattern, buttonFlags);
+  const isButtonLine = (line: string): boolean => {
+    buttonRe.lastIndex = 0;
+    return buttonRe.test(line);
+  };
+  // First pass: prefer a question line that is NOT itself a button line.
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    if (primary.test(lines[i]) && !isButtonLine(lines[i])) return { index: i, matchedSource: 'primary' };
+  }
+  for (const variant of spec.questionVariants ?? []) {
+    const re = compile(variant.regex, variant.flags ?? 'i');
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+      if (re.test(lines[i]) && !isButtonLine(lines[i])) return { index: i, matchedSource: variant.label ?? 'variant' };
+    }
+  }
+  // Fallback: no non-button question line found. Accept a button-line match so
+  // providers whose question genuinely renders on the button row (rare) still
+  // work — behaviour identical to the pre-fix scan.
   for (let i = lines.length - 1; i >= 0; i -= 1) {
     if (primary.test(lines[i])) return { index: i, matchedSource: 'primary' };
   }