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

package/dist/mesh/mesh-completion-synthesis.d.ts

@@ -2,3 +2,17 @@ import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
 import type { LocalMeshEntry } from '../repo-mesh-types.js';
 export declare function reconcileUnterminatedDirectDispatches(components: DaemonComponents, mesh: LocalMeshEntry, selfIds: string[], localDaemonId: string | undefined): Promise<void>;
 export declare function autoPruneStaleDirectDispatches(components: DaemonComponents, mesh: LocalMeshEntry, selfIds: string[], localDaemonId: string | undefined, minAgeMs: number): Promise<void>;
+export declare function pollAssignedTaskTerminalEvidence(components: DaemonComponents, mesh: {
+    id: string;
+    nodes?: Array<{
+        id: string;
+        daemonId?: string;
+        workspace?: string;
+    }>;
+}, row: {
+    id: string;
+    assignedSessionId?: string;
+    assignedNodeId?: string;
+    assignedProviderType?: string;
+    dispatchTimestamp?: string;
+}): Promise<'completed' | null>;

package/dist/mesh/mesh-work-queue.d.ts

@@ -374,6 +374,28 @@ export declare function requeueTask(meshId: string, taskId: string, opts?: {
     /** Per-task retry cap override. Falls back to mesh policy maxTaskRetries (default 1). */
     maxRetries?: number;
 } & MeshQueueMutationOptions): MeshWorkQueueEntry | null;
+/**
+ * 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 declare const REDRIVE_RECLAIM_REASONS: ReadonlySet<string>;
+/**
+ * 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 declare const REDRIVE_SUPERSEDE_WINDOW_MS: number;
 /**
  * Bug B: reclaim a task stuck in 'assigned' because its dispatch was never confirmed.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.536",
+  "version": "0.9.82-rc.538",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -47,8 +47,8 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.536",
-    "@adhdev/session-host-core": "0.9.82-rc.536",
+    "@adhdev/mesh-shared": "0.9.82-rc.538",
+    "@adhdev/session-host-core": "0.9.82-rc.538",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/cli-adapters/cli-state-engine.ts

@@ -175,6 +175,7 @@ export class CliStateEngine {
      * paint and made the engine type "1" repeatedly into the prompt.
      */
     modalLostAt = 0;
+    private modalLostRecheckTimer: NodeJS.Timeout | null = null;
     private approvalExitTimeout: NodeJS.Timeout | null = null;
 
     // ── Response tracking ────────────────────────────
@@ -243,6 +244,12 @@ export class CliStateEngine {
     setStatus(status: CliSessionStatus['status'], trigger?: string): void {
         const prev = this.currentStatus;
         if (prev === status) return;
+        // Leaving waiting_approval — cancel any pending modal-lost recheck; it
+        // only exists to wake a quiescent PTY still pinned to waiting_approval.
+        if (prev === 'waiting_approval' && this.modalLostRecheckTimer) {
+            clearTimeout(this.modalLostRecheckTimer);
+            this.modalLostRecheckTimer = null;
+        }
         this.currentStatus = status;
         this.statusHistory.push({ status, at: Date.now(), trigger });
         if (this.statusHistory.length > 50) this.statusHistory.shift();
@@ -456,6 +463,7 @@ export class CliStateEngine {
         if (this.settleTimer) { clearTimeout(this.settleTimer); this.settleTimer = null; }
         if (this.idleTimeout) { clearTimeout(this.idleTimeout); this.idleTimeout = null; }
         if (this.approvalExitTimeout) { clearTimeout(this.approvalExitTimeout); this.approvalExitTimeout = null; }
+        if (this.modalLostRecheckTimer) { clearTimeout(this.modalLostRecheckTimer); this.modalLostRecheckTimer = null; }
         if (this.finishRetryTimer) { clearTimeout(this.finishRetryTimer); this.finishRetryTimer = null; }
         if (this.pendingScriptStatusTimer) { clearTimeout(this.pendingScriptStatusTimer); this.pendingScriptStatusTimer = null; }
         if (this.providerErrorRetryTimer) { clearTimeout(this.providerErrorRetryTimer); this.providerErrorRetryTimer = null; }
@@ -822,7 +830,23 @@ export class CliStateEngine {
                 // signature each time, which typed the approval key
                 // ("1") into the prompt repeatedly. Wait for the modal to
                 // stay gone for `approvalCooldown` before clearing.
-                if (this.currentStatus === 'waiting_approval' && this.activeModal) {
+                //
+                // (fix: kimi approve-resolve-stuck) The recovery used to require
+                // `this.activeModal` to be non-null. But a provider can be pinned
+                // to `waiting_approval` with `activeModal === null`: kimi's
+                // questionPattern (`run.*command`) false-positive-matches the
+                // user's echoed prompt ("✨ Run the shell command: …"), so
+                // detectStatus reports `waiting_approval` from the question cue
+                // alone while parseApproval extracts zero buttons (→ null modal,
+                // never captured). After the real approval resolves and kimi goes
+                // quiet, no further PTY output arrives, so this is the LAST
+                // settled evaluation — with the old `&& this.activeModal` guard it
+                // bare-returned and the FSM latched `waiting_approval` forever
+                // (the approval appears never to resolve). Recover whenever we are
+                // pinned to waiting_approval with no actionable modal, captured or
+                // not, and arm a re-check so a quiescent PTY still gets one more
+                // evaluation pass to reach the hysteresis deadline.
+                if (this.currentStatus === 'waiting_approval') {
                     const lostAt = this.modalLostAt || Date.now();
                     if (!this.modalLostAt) this.modalLostAt = lostAt;
                     if (Date.now() - lostAt >= this.timeouts.approvalCooldown) {
@@ -830,6 +854,12 @@ export class CliStateEngine {
                         this.modalLostAt = 0;
                         this.setStatus('generating', 'approval_lost_modal');
                         this.callbacks.onStatusChange();
+                    } else {
+                        // Not yet past the hysteresis window. The PTY may be
+                        // quiescent (kimi emits nothing once idle), so schedule an
+                        // explicit re-evaluation — otherwise no settle tick ever
+                        // fires again and the recovery above is never reached.
+                        this.armModalLostRecheck();
                     }
                 }
                 return;
@@ -1151,6 +1181,26 @@ export class CliStateEngine {
 
     // ─── Helpers ────────────────────────────────────────────────────────────
 
+    /**
+     * Schedule one more settled evaluation while pinned to `waiting_approval`
+     * with no actionable modal. The settled FSM normally only re-runs on new
+     * PTY output; a provider whose modal cue lingers in a form detectStatus
+     * still matches (e.g. kimi's questionPattern hitting the user echo) but
+     * whose PTY has gone quiet would never get another evaluation, latching
+     * `waiting_approval` forever. This timer guarantees the modal-lost recovery
+     * in `applyWaitingApproval` is reached even against a silent PTY. It is a
+     * no-op once the FSM leaves `waiting_approval` (the re-evaluation itself
+     * takes the recovery branch and clears the state).
+     */
+    private armModalLostRecheck(): void {
+        if (this.modalLostRecheckTimer) return;
+        this.modalLostRecheckTimer = setTimeout(() => {
+            this.modalLostRecheckTimer = null;
+            if (this.currentStatus !== 'waiting_approval') return;
+            this.evaluateSettled(this.transport.getSnapshot());
+        }, this.timeouts.approvalCooldown);
+    }
+
     private armApprovalExitTimeout(): void {
         if (this.approvalExitTimeout) clearTimeout(this.approvalExitTimeout);
         this.approvalExitTimeout = setTimeout(() => {

package/src/cli-adapters/provider-cli-adapter.ts

@@ -356,6 +356,13 @@ export class ProviderCliAdapter implements CliAdapter {
         const currentScreenLooksIdle = /(?:^|\n|\r)\s*[❯›>]\s*(?:Try\s+["“][^\n\r"”]+["”])?\s*(?:\n|\r|$)/.test(screenText)
             && !activeScreenPattern.test(screenText);
         if (staleSnapshotLooksActive && currentScreenLooksIdle) return screenText;
+        // When the current frame already resolves to a settled/idle prompt via the
+        // provider's own detector, do NOT graft an older snapshot onto it: the
+        // older frame can carry a dead modal box (e.g. cursor-agent's leftover
+        // "Workspace Trust Required" rows) that re-fires `waiting_approval` at the
+        // appended tail and wedges the turn in `generating`. A truly idle current
+        // screen needs no historical supplement.
+        if (this.runDetectStatus(screenText) === 'idle') return screenText;
         if (currentSnapshot.length >= lastSnapshot.length) return screenText;
         // Terminal screen reads can miss a just-rendered completed Hermes box while
         // the normalized snapshot captured during output still has it. Feed both

package/src/commands/chat-commands-read.ts

@@ -745,8 +745,90 @@ function decideCliReadChatSource(args: {
     const supportsNative = supportsCliNativeTranscript(args.providerType, args.provider);
     const observation = buildObservationForCli(args, supportsNative);
     const sessionKey = chatSourceSessionKey(args.providerType, args.sessionId);
+
+    // STICKY-NATIVE: once a session's transcript is bound to native-history via
+    // a TRUSTED EXACT provider-session identity (the on-disk uuid == this
+    // session's own transcript file, not a recency/mtime guess), a single read
+    // that momentarily fails to reproduce the full native slice is a TRANSIENT
+    // gap, NOT evidence native regressed or vanished. Concretely, cursor-agent
+    // rewrites its JSONL tail mid-turn — the file is briefly empty, or exposes a
+    // SHRUNK slice (old assistant row dropped while the new turn is streamed) —
+    // so a per-read observation sees either `native_unavailable/empty` or a
+    // `native_regressed_shrunk`. Either one flips a NativeLocked machine to
+    // `pty-parser` for that read (and, after enough misses, permanently to
+    // PtyOnly). That is exactly the reported symptom: cursor chat provenance
+    // "flips back and forth between PTY and native-history".
+    //
+    // Fix: for a session that (a) resolved via a trusted EXACT identity and
+    // (b) is already committed to native (NativeLocked/Recovering), speculatively
+    // observe, and if the machine WOULD flip to pty-parser, roll the machine
+    // state back and HOLD native-history as authoritative for this read. Exact
+    // identity means the read is provably against THIS session's own transcript
+    // file, so a transient gap on it can only be a mid-write artifact — never a
+    // genuine session switch or data loss (cursor's file is cumulative). A
+    // workspace-heuristic (non-exact) read is never eligible, so a real session
+    // switch still flips normally.
+    const priorSnapshot = CHAT_SOURCE_REGISTRY.snapshotRecord(sessionKey);
+    const priorState = priorSnapshot?.state ?? CHAT_SOURCE_REGISTRY.getState(sessionKey);
+    const eligibleForStickyHold = args.trustedExactNativeIdentity === true
+        && (priorState.name === 'NativeLocked' || priorState.name === 'Recovering');
+
     let decision = CHAT_SOURCE_REGISTRY.observe(sessionKey, observation);
 
+    if (eligibleForStickyHold && decision.selected === 'pty-parser') {
+        // The machine flipped a native-committed, exact-identity session to PTY
+        // on this read. Treat it as a transient native gap: undo the observe and
+        // report native-history held. We surface whatever native rows this read
+        // DID map (empty on a true gap, a shrunk slice on a mid-write rewrite);
+        // the streaming/tail delivery layer already suppresses an empty tail from
+        // clobbering the last real tail, so holding native with a thin slice is
+        // strictly safer than emitting PTY under a native-authority session.
+        CHAT_SOURCE_REGISTRY.restoreRecord(sessionKey, priorSnapshot);
+        const heldNativeMessages: ChatMessage[] = observation.kind === 'native_present'
+            ? extractNativeMessagesFromResult(args.providerType, args.nativeHistoryResult)
+            : [];
+        const messageSource = buildCliMessageSourceProvenance({
+            selected: 'native-history',
+            provider: args.providerType,
+            nativeHandle: typeof args.nativeHistoryResult?.providerSessionId === 'string'
+                ? args.nativeHistoryResult.providerSessionId
+                : undefined,
+            sessionWorkspace: args.sessionWorkspace,
+            intendedWorkspace: args.intendedWorkspace,
+            transcriptWorkspace: undefined,
+            fallbackReason: 'native_history_transient_gap_held',
+            nativeSource: 'provider-native',
+            sourcePath: typeof args.nativeHistoryResult?.sourcePath === 'string' ? args.nativeHistoryResult.sourcePath : undefined,
+            sourceMtimeMs: typeof args.nativeHistoryResult?.sourceMtimeMs === 'number' ? args.nativeHistoryResult.sourceMtimeMs : undefined,
+            nativeHistoryCoverage: undefined,
+            partialReason: undefined,
+            unavailableReason: observation.kind === 'native_unavailable' ? observation.reason : undefined,
+            nativeMessages: heldNativeMessages,
+            ptyMessages: args.ptyMessages,
+            returnedMessages: heldNativeMessages,
+            safeMapping: args.safeMapping,
+            freshEnough: true,
+            ptyStatusApprovalOnly: true,
+        });
+        return {
+            decision: {
+                selected: 'native-history',
+                nextState: priorState,
+                transition: {
+                    fromState: priorState.name,
+                    toState: priorState.name,
+                    event: 'NoOp',
+                    cause: decision.transition.cause,
+                    at: Date.now(),
+                },
+                lockState: { locked: priorState.name === 'NativeLocked' },
+            },
+            messageSource,
+            nativeMessages: heldNativeMessages,
+            nativeSelected: true,
+        };
+    }
+
     // A restored runtime can briefly expose different native slices while the
     // provider transcript settles (for example, startup/system rows may be
     // filtered after the first read). The source machine correctly treats a
@@ -1335,13 +1417,27 @@ function readCliProviderNativeHistory(agentStr: string, args: {
     const pinnedProviderSessionId = typeof args.pinnedProviderSessionId === 'string'
         ? args.pinnedProviderSessionId.trim()
         : '';
-    // Pin reuse (PRIMARY): a later read whose live binding is gone
-    // (historySessionId empty, no live spawnedAtMs) can still resolve to the
-    // session it was last bound to. Read THAT session directly by threading the
-    // pin through as historySessionId — same code path an explicit session read
-    // takes — instead of fail-closing. Never overrides a caller-supplied
-    // historySessionId; only kicks in when there is none.
-    const effectiveHistorySessionId = args.historySessionId || (!canBindFromLiveSession ? pinnedProviderSessionId : '');
+    // Pin reuse (PRIMARY): a read with no caller-supplied historySessionId can
+    // still resolve to the session it was last bound to. Read THAT session
+    // directly by threading the pin through as historySessionId — same code path
+    // an explicit session read takes — instead of relying on the live spawn/cwd/
+    // mtime heuristic. Never overrides a caller-supplied historySessionId; only
+    // kicks in when there is none.
+    //
+    // The pin is preferred EVEN FOR A LIVE SESSION (canBindFromLiveSession).
+    // The pin is keyed on this session's own mesh id (getBoundProviderSessionIdPin
+    // (targetSessionId)) and holds the provider-native uuid proven in a prior
+    // read, so it can only ever resolve to THIS session's own transcript — it
+    // cannot alias a concurrent session sharing the cwd. Bypassing the pin while
+    // a session is live (the old behaviour) forced the FIRST read of every new
+    // turn back onto the spawn/mtime heuristic: cursor's native tail is briefly
+    // stale (previous turn) versus the just-echoed PTY user line, so the
+    // workspace-overlap safe-mapping gate fails and the read flips to PTY
+    // (native_history_not_safely_mapped) before native re-locks. Preferring the
+    // pin makes that first read an EXACT-identity lookup (trustedExactNativeIdentity
+    // = true), which reads the correct cumulative file AND lets the STICKY-NATIVE
+    // hold cover the turn boundary. This is the pin-bypass class fix.
+    const effectiveHistorySessionId = args.historySessionId || pinnedProviderSessionId || '';
     // Last-resort workspace-latest (b): only when nothing above resolved a
     // session id AND no pin exists AND the caller opted in with a workspace.
     // Strictly behind pin reuse — pinnedProviderSessionId being set disables it.

package/src/mesh/mesh-completion-synthesis.ts

@@ -414,3 +414,88 @@ export async function autoPruneStaleDirectDispatches(
         LOG.info('MeshReconcile', `Auto-pruned ${result.prunedCount} orphaned direct dispatch record(s) for mesh ${mesh.id}`);
     }
 }
+
+// TASK-PROMPT-REDRIVE-AFTER-COMPLETE (Fix A-i). Single-shot transcript poll for a CLAIM-PATH
+// (queue-assigned) row that PHASE 2.5's long delivered-no-turn deadline is about to RE-DRIVE.
+//
+// PHASE 4 (reconcileUnterminatedDirectDispatches) recovers a lost completion by re-reading the
+// worker transcript, but it is bound to DIRECT-dispatch ledger rows — it never touches a
+// claim-path queue row. So the F3 long-deadline reclaim reaches its 15-min deadline with an empty
+// ledger for an autoLaunch/worktree worker whose generating_started/completed events never
+// propagated, and re-drives a task the worker actually FINISHED (the owner's symptom). This poll
+// gives that reclaim the SAME transcript evidence PHASE 4 uses, for the queue row: if the worker
+// session is idle with a final assistant summary dated at/after this task's dispatch, the task is
+// done — return its terminal outcome so the caller short-circuits to that status instead of
+// reclaiming. Unlike PHASE 4 there is no acked-hold/grace machinery: the caller only invokes this
+// AFTER the full 15-min deadline, so a single idle-with-final-assistant read is decisive.
+//
+// Conservative: a non-idle read, a read failure, no final summary, or a summary provably BEFORE
+// dispatch all yield null (fall through to the caller's normal reclaim decision) — the poll can
+// only PREVENT a wrong re-drive, never invent a completion.
+export async function pollAssignedTaskTerminalEvidence(
+    components: DaemonComponents,
+    mesh: { id: string; nodes?: Array<{ id: string; daemonId?: string; workspace?: string }> },
+    row: { id: string; assignedSessionId?: string; assignedNodeId?: string; assignedProviderType?: string; dispatchTimestamp?: string },
+): Promise<'completed' | null> {
+    const sessionId = readNonEmptyString(row.assignedSessionId);
+    const nodeId = readNonEmptyString(row.assignedNodeId);
+    if (!sessionId || !nodeId) return null; // no worker to read
+
+    const node = (mesh.nodes ?? []).find(n => n.id === nodeId);
+    const nodeDaemonId = readNonEmptyString(node?.daemonId);
+    const localDaemonId = readNonEmptyString((components as { statusInstanceId?: string }).statusInstanceId);
+    const isLocalNode = !nodeDaemonId
+        || daemonIdsEquivalent(nodeDaemonId, localDaemonId)
+        || !!components.instanceManager.getInstance(sessionId);
+
+    const providerType = readNonEmptyString(row.assignedProviderType);
+    const readArgs: Record<string, unknown> = {
+        sessionId,
+        targetSessionId: sessionId,
+        tailLimit: 10,
+        ...(node?.workspace ? { workspace: node.workspace } : {}),
+        ...(providerType ? { agentType: providerType, providerType } : {}),
+    };
+
+    let payload: Record<string, unknown> | null = null;
+    try {
+        if (isLocalNode) {
+            const result = await components.commandHandler?.handle('read_chat', readArgs);
+            if (result && (result as { success?: boolean }).success === false) return null;
+            payload = unwrapReadChatPayload(result);
+        } else if (components.dispatchMeshCommand) {
+            const result = await components.dispatchMeshCommand(nodeDaemonId, 'read_chat', readArgs);
+            payload = unwrapReadChatPayload(result);
+            if (payload && (payload as { success?: boolean }).success === false) return null;
+        } else {
+            return null; // remote node, no P2P transport — can't read this tick
+        }
+    } catch {
+        return null; // transport error / session gone → inconclusive, let the caller decide
+    }
+    if (!payload) return null;
+
+    // Only a settled-idle session is a turn-end; a generating/waiting session is mid-turn and
+    // must NEVER be short-circuited to completed.
+    if (readChatPayloadStatus(payload) !== 'idle') return null;
+
+    const messages = Array.isArray(payload.messages) ? payload.messages as ChatMessage[] : [];
+    const evidence = extractFinalAssistantSummaryEvidence(messages);
+    if (!evidence.finalSummary) return null; // idle but no assistant result yet → not a turn-end
+
+    // Stale-summary guard (same bar as PHASE 4): a reused session's transcript tail may hold a
+    // PRIOR task's summary. Require the final assistant message to be dated at/after THIS task's
+    // dispatch. When either timestamp is unusable, do NOT short-circuit — fall through so we never
+    // synthesize a completion off a possibly-stale tail (the reclaim path is the safe default).
+    const dispatchedAtMs = Date.parse(readNonEmptyString(row.dispatchTimestamp));
+    const transcriptAtMs = Date.parse(evidence.transcriptMessageAt ?? '');
+    if (!(Number.isFinite(dispatchedAtMs) && Number.isFinite(transcriptAtMs) && transcriptAtMs >= dispatchedAtMs)) {
+        return null;
+    }
+
+    // Idle + a final assistant message dated after dispatch = the worker finished this turn. We
+    // cannot distinguish a self-reported failure from the plain transcript tail here (that lives
+    // in buildTaskCompletionEvidence's structured-result path), and the alternative — re-driving a
+    // finished worker — is strictly worse, so a proven turn-end short-circuits to 'completed'.
+    return 'completed';
+}

package/src/mesh/mesh-event-forwarding.ts

@@ -4,7 +4,8 @@ import { getMesh, getMeshByRepo, listMeshes } from '../config/mesh-config.js';
 import { LOG } from '../logging/logger.js';
 import { appendLedgerEntry, buildTaskCompletionEvidence, getSessionRecoveryContext, isIntentionalCleanupStopEntry, readLedgerEntries } from './mesh-ledger.js';
 import type { SessionRecoveryContext } from './mesh-ledger.js';
-import { updateSessionTaskStatus, enqueueTask, updateDirectDispatchStatus, cleanupTerminalDirectDispatches, getActiveDirectDispatches, hasPendingDependents, getQueue } from './mesh-work-queue.js';
+import { updateSessionTaskStatus, updateTaskStatus, enqueueTask, updateDirectDispatchStatus, cleanupTerminalDirectDispatches, getActiveDirectDispatches, hasPendingDependents, getQueue, REDRIVE_RECLAIM_REASONS, REDRIVE_SUPERSEDE_WINDOW_MS } from './mesh-work-queue.js';
+import type { MeshWorkQueueEntry } from './mesh-work-queue.js';
 import { markSessionDeliveriesTerminal, updateSessionDeliveryStatus, consumeSessionDelivery } from './mesh-delivery-policy.js';
 import { MeshRuntimeStore, pruneMeshRuntimeRetention } from './mesh-runtime-store.js';
 import { maybeInjectIdleActiveMissionReminder } from './mesh-idle-reminder.js';
@@ -810,6 +811,93 @@ function stopStaleMeshWorker(
     }
 }
 
+/**
+ * TASK-PROMPT-REDRIVE-AFTER-COMPLETE (Fix C): a genuine completion echoed a taskId whose queue
+ * row is NOT 'assigned' anymore — because the assigned-stranded watchdog RE-DROVE it (long
+ * delivered-no-turn deadline / unknown-grace) while this very completion was still in flight.
+ * For an autoLaunch/worktree worker the turn-lifecycle events don't reliably reach the
+ * coordinator ledger, so the deadline fires before the completion propagates (observed live at
+ * 0.9s–98s late). The re-drive re-injects the SAME prompt into the already-finished worker (the
+ * owner's symptom). This late completion PROVES the original turn finished, so it SUPERSEDES the
+ * re-drive: flip the row terminal and stop any duplicate re-dispatch.
+ *
+ * Bounded to a row reclaimed for a RE-DRIVE reason within {@link REDRIVE_SUPERSEDE_WINDOW_MS} of
+ * its `requeuedAt` — outside that window a `pending` row is an unrelated retry (or a fresh
+ * re-dispatched turn whose own completion this is not), and is left untouched. Returns true when
+ * it superseded the re-drive (row flipped terminal), false to fall through to normal handling.
+ */
+function supersedeRedriveReclaimForLateCompletion(
+    components: DaemonComponents,
+    meshId: string,
+    row: MeshWorkQueueEntry,
+    completingSessionId: string,
+    outcome: 'completed' | 'failed',
+    args: { nodeId?: string; event: string; metadataEvent: Record<string, unknown> },
+): boolean {
+    // Only a re-drive reclaim is superseded. A row reclaimed as never-delivered
+    // (assigned_stranded_dispatch_unconfirmed) never ran, so a completion for it is not a
+    // late race — leave it to the normal path. A row already terminal is a no-op.
+    if (!row.requeueReason || !REDRIVE_RECLAIM_REASONS.has(row.requeueReason)) return false;
+    if (row.status === 'completed' || row.status === 'failed' || row.status === 'cancelled') return false;
+    const requeuedAtMs = Date.parse(row.requeuedAt ?? '');
+    if (!Number.isFinite(requeuedAtMs)) return false;
+    if (Date.now() - requeuedAtMs > REDRIVE_SUPERSEDE_WINDOW_MS) return false;
+
+    // The re-drive may have already re-dispatched the SAME prompt onto a FRESH session (row is
+    // 'assigned' again to a different session). That duplicate is executing work the original
+    // worker already finished — stop it so the prompt is not run twice. (When the row is still
+    // 'pending' there is no duplicate yet; flipping it terminal below prevents PHASE 3 from ever
+    // re-dispatching it.)
+    const reDispatchedSessionId = row.assignedSessionId;
+    if (
+        row.status === 'assigned'
+        && reDispatchedSessionId
+        && !sessionIdsEquivalent(reDispatchedSessionId, completingSessionId)
+    ) {
+        stopStaleMeshWorker(components, {
+            meshId,
+            sessionId: reDispatchedSessionId,
+            nodeId: row.assignedNodeId,
+            providerType: row.assignedProviderType,
+        });
+    }
+
+    // Flip the row terminal by its exact id (immune to the cleared session ownership) and record
+    // the terminal ledger evidence, so the reconcile watchdog's terminal-ledger branch also sees
+    // it and no further reclaim fires.
+    endTaskDispatchInFlight(meshId, row.id);
+    updateTaskStatus(meshId, row.id, outcome === 'completed' ? 'completed' : 'failed');
+    if (!findTerminalLedgerEvidenceForTask({ meshId, taskId: row.id })) {
+        try {
+            appendLedgerEntry(meshId, {
+                kind: outcome === 'completed' ? 'task_completed' : 'task_failed',
+                sessionId: completingSessionId,
+                nodeId: readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || undefined,
+                providerType: readNonEmptyString(args.metadataEvent.providerType) || undefined,
+                payload: {
+                    taskId: row.id,
+                    event: args.event,
+                    source: 'redrive_late_completion_supersede',
+                    reclaimReason: row.requeueReason,
+                    reclaimAgeMs: Date.now() - requeuedAtMs,
+                    finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || undefined,
+                },
+            });
+        } catch { /* best-effort ledger write */ }
+    }
+    LOG.warn('MeshQueue', `Late completion superseded re-drive for task ${row.id} on mesh ${meshId} `
+        + `(reclaimed '${row.requeueReason}' ${Math.round((Date.now() - requeuedAtMs) / 1000)}s ago; completing session ${completingSessionId}) `
+        + `→ flipped ${outcome}${(row.status === 'assigned' && reDispatchedSessionId && !sessionIdsEquivalent(reDispatchedSessionId, completingSessionId)) ? `, stopped duplicate re-dispatch on ${reDispatchedSessionId}` : ''}`);
+    traceMeshEventDrop('redrive_late_completion_supersede', {
+        taskId: row.id,
+        sessionId: completingSessionId,
+        nodeId: row.assignedNodeId ?? args.nodeId,
+        meshId,
+        event: args.event,
+    }, `${row.requeueReason} ${Math.round((Date.now() - requeuedAtMs) / 1000)}s → ${outcome}`);
+    return true;
+}
+
 function injectMeshSystemMessage(components: DaemonComponents, args: {
     meshId: string;
     sourceInstanceId?: string;
@@ -1022,6 +1110,13 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
                             },
                         });
                     }
+                } else if (strandedRow && supersedeRedriveReclaimForLateCompletion(components, args.meshId, strandedRow, sessionId, outcome, args)) {
+                    // TASK-PROMPT-REDRIVE-AFTER-COMPLETE (Fix C, late-completion supersede): the row
+                    // is NOT 'assigned' — it was re-driven (reclaimed → 'pending', or already
+                    // re-dispatched to a fresh session) because the long delivered-no-turn deadline
+                    // fired before this genuine completion propagated. The completion proves the
+                    // ORIGINAL worker finished, so it SUPERSEDES the re-drive: the helper flipped the
+                    // row terminal and stopped any duplicate re-dispatch (handled inside).
                 }
             } catch { /* best-effort safety net — never fail the completion path */ }
         }

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

@@ -1967,10 +1967,14 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
                 // a launch that can never claim. Mirrors claimNextQueueTask's convergence gate.
                 if (task.taskMode === 'convergence' && node?.isLocalWorktree === true) return false;
                 // Skip nodes that can never satisfy requiredTags regardless of which provider
-                // from providerPriority is selected. A node satisfies tags if at least one
-                // provider in its priority list would produce matching capability tags.
+                // is selected. A node satisfies tags if at least one provider it can launch
+                // would produce matching capability tags. Enumerate providers from the node's
+                // capability slots (the single source of truth — a provider that lives only in
+                // slots, e.g. cursor-cli, is otherwise invisible to providerPriority-keyed
+                // enumeration), falling back to the legacy providerPriority.
                 if (task.requiredTags?.length) {
-                    const priorities = normalizeProviderPriority(node?.policy);
+                    const slotProviders = resolveNodeCapabilitySlots(node).map(s => s.provider).filter(Boolean);
+                    const priorities = slotProviders.length ? slotProviders : normalizeProviderPriority(node?.policy);
                     const providerCandidates = priorities.length ? priorities : [undefined as unknown as string];
                     return providerCandidates.some(p =>
                         nodeSatisfiesRequiredTags(task.requiredTags, buildMeshNodeCapabilityTags(node, p))

package/src/mesh/mesh-reconcile-loop.ts

@@ -79,6 +79,7 @@ import { pullRemoteNodeQueues } from './mesh-remote-event-pull.js';
 import {
     reconcileUnterminatedDirectDispatches,
     autoPruneStaleDirectDispatches,
+    pollAssignedTaskTerminalEvidence,
 } from './mesh-completion-synthesis.js';
 
 // Re-export the extracted public API so existing importers (mesh-events.ts barrel;
@@ -737,7 +738,12 @@ export function __resetReclaimUnknownStreakForTests(): void {
 // never reclaimed here. And the deadline is generous so a slow-but-live dispatch still in
 // its normal confirm window is never reclaimed early. Reclaimed rows return to 'pending'
 // with ownership cleared, so the PHASE 3 trigger below re-dispatches them this same tick.
-function recoverStrandedAssignedDispatches(components: DaemonComponents, meshId: string, store: MeshRuntimeStore): void {
+async function recoverStrandedAssignedDispatches(
+    components: DaemonComponents,
+    mesh: { id: string; nodes?: Array<{ id: string; daemonId?: string; workspace?: string }> },
+    store: MeshRuntimeStore,
+): Promise<void> {
+    const meshId = mesh.id;
     const assigned = getQueue(meshId, { status: ['assigned'] });
     if (!assigned.length) return;
     const nowMs = Date.now();
@@ -910,6 +916,51 @@ function recoverStrandedAssignedDispatches(components: DaemonComponents, meshId:
                 }
                 reclaimReason = 'reclaim_after_unknown_grace';
             }
+            // TASK-PROMPT-REDRIVE-AFTER-COMPLETE (Fix A-i): before re-driving, poll the worker
+            // transcript for terminal evidence — the SAME check PHASE 4 does for direct dispatches,
+            // now for this claim-path queue row. An autoLaunch/worktree worker's
+            // generating_started/completed events don't reliably reach the coordinator ledger, so
+            // the ledger check above (findTerminalLedgerEvidenceForTask) can be empty at the 15-min
+            // deadline for a task the worker actually FINISHED — and re-driving then re-injects the
+            // same prompt into the already-idle worker (the owner's symptom). If the worker is idle
+            // with a final assistant summary dated after dispatch, the task is done: flip it
+            // 'completed' instead of reclaiming. Conservative by construction (mid-turn / no
+            // summary / stale summary / unreadable → null → fall through to the reclaim below), so
+            // this can only PREVENT a wrong re-drive, never invent a completion. Runs only at the
+            // deadline (rare), so the extra read is not a hot-path cost.
+            const terminalEvidence = await pollAssignedTaskTerminalEvidence(components, mesh, row);
+            if (terminalEvidence) {
+                deliveredNoTurnUnknownStreak.delete(streakKey);
+                // updateTaskStatus ends the single-flight dispatch window on any transition off
+                // 'assigned', so a later requeue/re-dispatch is never blocked by a stale mark.
+                updateTaskStatus(meshId, row.id, terminalEvidence);
+                if (!findTerminalLedgerEvidenceForTask({ meshId, taskId: row.id })) {
+                    try {
+                        appendLedgerEntry(meshId, {
+                            kind: terminalEvidence === 'completed' ? 'task_completed' : 'task_failed',
+                            nodeId: row.assignedNodeId,
+                            sessionId: row.assignedSessionId,
+                            providerType: row.assignedProviderType,
+                            payload: {
+                                taskId: row.id,
+                                event: 'agent:generating_completed',
+                                source: 'redrive_deadline_transcript_evidence',
+                            },
+                        });
+                    } catch { /* best-effort ledger write */ }
+                }
+                LOG.warn('MeshReconcile', `Skipped delivered-no-turn re-drive for task ${row.id} on mesh ${meshId} `
+                    + `(node=${row.assignedNodeId ?? '?'} session=${row.assignedSessionId ?? '?'}): worker transcript is idle with a `
+                    + `final assistant message after dispatch — the completion event was lost/late, task is ${terminalEvidence}, NOT re-driving`);
+                traceMeshEventDrop('redrive_deadline_transcript_completed', {
+                    taskId: row.id,
+                    sessionId: row.assignedSessionId,
+                    nodeId: row.assignedNodeId,
+                    meshId,
+                    event: 'agent:generating_completed',
+                }, `${reclaimReason} → transcript ${terminalEvidence}`);
+                continue;
+            }
             const reclaimedLost = reclaimStrandedAssignedTask(meshId, row.id, {
                 reason: reclaimReason,
                 ageMs: nowMs - dispatchedAtMs,
@@ -1108,7 +1159,7 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
             const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
             if (!daemonHostsMesh(mesh, selfIds)) continue;
             try {
-                recoverStrandedAssignedDispatches(components, mesh.id, store);
+                await recoverStrandedAssignedDispatches(components, mesh, store);
             } catch (e: any) {
                 LOG.warn('MeshReconcile', `Assigned-stranded watchdog failed for mesh ${mesh.id}: ${e?.message || e}`);
             }