@adhdev/daemon-core 0.9.82-rc.537 → 0.9.82-rc.539

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/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' };
   }