@adhdev/daemon-core 0.9.82-rc.454 → 0.9.82-rc.456

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

@@ -223,9 +223,18 @@ function buildLedgerDirectDispatchRecord(
     ctx: { terminals: MeshLedgerEntry[]; nodes: any[] | undefined; now: number },
 ): { record: MeshActiveWorkRecord; terminalRow: boolean } {
     const taskId = directDispatchTaskId(dispatch);
-    const terminal = ctx.terminals
+    const matching = ctx.terminals
         .filter(entry => new Date(entry.timestamp).getTime() >= new Date(dispatch.timestamp).getTime())
-        .find(entry => terminalMatchesDispatch(entry, dispatch, taskId));
+        .filter(entry => terminalMatchesDispatch(entry, dispatch, taskId));
+    // APPROVAL-Q1-REALTIME (stale level state): prefer a REAL terminal (task_completed /
+    // task_failed) over an earlier task_approval_needed for the same dispatch. An approval
+    // that was subsequently resolved — the worker went on to complete or fail — must NOT keep
+    // the node pinned to awaiting_approval, which would falsely tell the coordinator (via
+    // mesh_status/read_chat) the worker is still blocked (the UX inversion this fix avoids).
+    // Among real terminals the earliest still wins (unchanged); approval-needed is selected
+    // only when no real terminal followed it. `terminals` is sorted ascending, so `.find`
+    // returns the earliest real terminal.
+    const terminal = matching.find(entry => entry.kind !== 'task_approval_needed') || matching[0];
     const terminalStatus = terminal ? statusFromTerminal(terminal) : undefined;
     const live = sessionStatusFromNodes(ctx.nodes, dispatch.nodeId, dispatch.sessionId);
     const status = terminalStatus || live.status || 'assigned';

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

@@ -49,3 +49,25 @@ export const MESH_FORCE_INJECT_EVENTS: ReadonlySet<string> = new Set([
 export function shouldForceInjectMeshEvent(eventName: unknown): boolean {
     return typeof eventName === 'string' && MESH_FORCE_INJECT_EVENTS.has(eventName);
 }
+
+// APPROVAL-Q1-REALTIME. Approval-kind coordinator events: a worker is blocked on an
+// approval prompt and needs the coordinator to act (mesh_approve). Approval is treated
+// differently from a completion in the reconcile loop's no-idle hold, and the reason is
+// WHERE each event's authoritative state lives:
+//   - A completion's payload (finalSummary / worker result) exists ONLY in the pending
+//     event, so a drain-without-inject loses it forever → it MUST ride the idle-edge hold
+//     until it can land in the coordinator as a real turn.
+//   - An approval's authoritative state is recorded at LEVEL in the ledger the moment the
+//     event is processed (task_approval_needed → mesh_status awaiting_approval, see
+//     onMeshCoordinatorEventForwarded + mesh-active-work). The pending approval event is
+//     therefore only a real-time NUDGE, not the source of truth: it can be delivered to a
+//     busy coordinator's inbox (and dropped) without data loss, because the level state
+//     re-derives it. That is why approval is exempt from the idle-edge hold completions
+//     require, and why a stale/resolved approval nudge can simply be dropped.
+export const MESH_APPROVAL_EVENTS: ReadonlySet<string> = new Set([
+    'agent:waiting_approval',
+]);
+
+export function isMeshApprovalEvent(eventName: unknown): boolean {
+    return typeof eventName === 'string' && MESH_APPROVAL_EVENTS.has(eventName);
+}

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

@@ -18,10 +18,12 @@ import { resolveDelegatedWorkerAutoApprove } from '../repo-mesh-types.js';
 import { meshNodeIdMatches, daemonIdsEquivalent, expandDaemonIdForms, sessionIdsEquivalent, type MeshNodeIdentified } from '@adhdev/mesh-shared';
 import {
     findRecentTerminalLedgerEvidence,
+    findTerminalLedgerEvidenceForTask,
     hasDispatchAfterTerminal,
     hasUnterminalDirectDispatchLedgerEntry,
     buildNoProgressCompletionReconciliation,
 } from './mesh-events-stale.js';
+import { endTaskDispatchInFlight } from './mesh-task-inflight.js';
 import {
     buildMeshSystemMessage,
     readNonEmptyString,
@@ -833,6 +835,40 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             updateDirectDispatchStatus(args.meshId, sessionId, outcome, eventTaskId);
         }
         markSessionDeliveriesTerminal(args.meshId, sessionId, outcome);
+        // COMPLETION-PROPAGATION F2 (double safety net): the flip found no matching assigned
+        // row (task === null) but the completion echoed a taskId AND a queue row for that id is
+        // STILL 'assigned'. This is the stranded flip-miss case F1's equivalence match is meant
+        // to reconcile — NOT a direct dispatch (which legitimately has no queue row and is
+        // covered by updateDirectDispatchStatus above). Record a terminal ledger entry keyed by
+        // the echoed taskId and release the single-flight lock, so the reconcile PHASE 2.5
+        // terminal-ledger branch (findTerminalLedgerEvidenceForTask by row.id) has a taskId-based
+        // path to flip the stranded row terminal even if the direct SQL flip could not resolve
+        // it, and a subsequent reclaim/requeue is not blocked by a stale in-flight mark. Gated
+        // to GENUINE terminals (a weak / false-idle completion is left for the transcript
+        // reconcile, matching the leaveDirectDispatchActive philosophy above).
+        const genuineTerminal = outcome === 'failed' || !isWeakCompletionEvidence(args.metadataEvent);
+        if (!task && eventTaskId && genuineTerminal) {
+            try {
+                const strandedRow = MeshRuntimeStore.getInstance().findQueueEntryById(args.meshId, eventTaskId);
+                if (strandedRow && strandedRow.status === 'assigned') {
+                    endTaskDispatchInFlight(args.meshId, eventTaskId);
+                    if (!findTerminalLedgerEvidenceForTask({ meshId: args.meshId, taskId: eventTaskId })) {
+                        appendLedgerEntry(args.meshId, {
+                            kind: outcome === 'completed' ? 'task_completed' : 'task_failed',
+                            sessionId,
+                            nodeId: readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || undefined,
+                            providerType: readNonEmptyString(args.metadataEvent.providerType) || undefined,
+                            payload: {
+                                taskId: eventTaskId,
+                                event: args.event,
+                                source: 'flip_miss_safety_net',
+                                finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || undefined,
+                            },
+                        });
+                    }
+                }
+            } catch { /* best-effort safety net — never fail the completion path */ }
+        }
         setImmediate(() => cleanupTerminalDirectDispatches());
         return task ? { id: task.id } : null;
     }

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

@@ -19,7 +19,7 @@ import { normalizeMeshNodeId, meshNodeIdMatches, daemonIdsEquivalent, canonicalD
 import { findTerminalLedgerEvidenceForTask, hasUnterminalDirectDispatchLedgerEntry } from './mesh-events-stale.js';
 import { readNonEmptyString } from './mesh-events-utils.js';
 import { queuePendingMeshCoordinatorEvent, retractPendingDispatchBlockedEvent } from './mesh-events-pending.js';
-import { isWorktreeBootstrapStaleRunning } from './worktree-bootstrap-config.js';
+import { isWorktreeBootstrapStaleRunning, shouldDeferDispatchForBootstrap } from './worktree-bootstrap-config.js';
 import { isWithinCloneBootstrapGrace } from './mesh-clone-grace.js';
 import { beginTaskDispatchInFlight, endTaskDispatchInFlight } from './mesh-task-inflight.js';
 
@@ -318,13 +318,32 @@ export function tryAssignQueueTask(
     // 3-form normalizer the defer guard uses), never a raw === — canon-identity regression guard.
     // Conservative: any non-'running' status (idle/complete/failed/absent/unknown) does NOT gate,
     // so a base node and a fully-bootstrapped worktree keep prior behavior exactly.
-    if ((node as { worktreeBootstrap?: { status?: string } } | undefined)?.worktreeBootstrap?.status === 'running') {
-        // Fix (3) safety net: a 'running' bootstrap that is far older than any real bootstrap AND
-        // whose worktree is git-clean is almost certainly one whose terminal-state stamp never
-        // reached this daemon — downgrade it so a dispatch is allowed instead of stranded forever.
-        // The conservative threshold + git-clean co-requirement prevents downgrading a genuinely
-        // in-progress bootstrap (which would re-introduce the half-built-worktree dispatch).
-        if (isWorktreeBootstrapStaleRunning(node)) {
+    // COMPLETION-PROPAGATION F7 (C2 SSOT): resolve the node's bootstrap status from the router's
+    // synchronous inline cache FIRST — the authoritative source markWorktreeBootstrapTerminalState
+    // stamps synchronously — falling back to the merged claim view only when the inline node carries
+    // no bootstrap status. getMeshWithCache takes a config-REGISTERED node verbatim from local
+    // config, whose bootstrap status lags the inline stamp (the detached async persist chain), so a
+    // config-registered worktree node could read a stale 'running' here and defer a claim whose
+    // bootstrap is already complete. Reading the inline node removes that stale-'running' defer,
+    // symmetric with the remote dispatch guard (cli-agent.ts F6). Conservative: only override with
+    // the inline node when it actually carries a status (an incomplete inline entry never masks a
+    // genuine config 'running').
+    const inlineBootstrapNode = (() => {
+        try {
+            const inlineMesh = components.router?.getCachedInlineMesh?.(meshId);
+            const inlineNode = Array.isArray(inlineMesh?.nodes)
+                ? inlineMesh.nodes.find((n: any) => meshNodeIdMatches(n, nodeId))
+                : undefined;
+            return readNonEmptyString(inlineNode?.worktreeBootstrap?.status) ? inlineNode : undefined;
+        } catch { return undefined; }
+    })();
+    const bootstrapGateNode = inlineBootstrapNode ?? node;
+    if ((bootstrapGateNode as { worktreeBootstrap?: { status?: string } } | undefined)?.worktreeBootstrap?.status === 'running') {
+        // Fix (3) safety net + F7: shouldDeferDispatchForBootstrap returns false when the 'running'
+        // state is stale (older than the backstop AND git-clean) — treat that as silently complete
+        // and allow the claim; otherwise defer (leave the task pending) so the claim re-fires once
+        // bootstrap reaches a terminal state and never dispatches into a half-built worktree.
+        if (!shouldDeferDispatchForBootstrap(bootstrapGateNode as any)) {
             LOG.warn('MeshQueue', `Worktree node ${nodeId} (${sessionId}) bootstrap stuck 'running' beyond the stale backstop and its worktree is git-clean — treating bootstrap as silently complete and allowing the claim (the terminal-state stamp likely never reached this daemon's mesh view)`);
         } else {
             LOG.info('MeshQueue', `Gating queue claim for worktree node ${nodeId} (${sessionId}): worktree bootstrap still running — task left pending; claim re-fires once bootstrap reaches a terminal state (guards against dispatching into a half-built worktree → empty session)`);
@@ -521,9 +540,17 @@ export function tryAssignQueueTask(
                 launchedByCoordinator: true,
                 autoApprove: resolveDelegatedWorkerAutoApprove(mesh?.policy, node?.policy),
                 ...(localDaemonId ? { meshCoordinatorDaemonId: localDaemonId } : {}),
-                // (3) Stamp the originating coordinator session for session-anchored routing
-                // of this co-located worker's completion. Absent → daemon-level fallback.
-                ...(localSourceCoordinatorSessionId ? { meshCoordinatorSessionId: localSourceCoordinatorSessionId } : {}),
+                // COMPLETION-PROPAGATION F5: (re)stamp the coordinator SESSION anchor from THIS
+                // task's sourceCoordinatorSessionId with PRIORITY — a manually-launched (or reused)
+                // session may already carry a stale anchor from mesh_launch_session or a prior task,
+                // and a stale session anchor makes the completion unicast to the wrong/absent
+                // coordinator session (targetCoordinatorSessionId), stranding it. When this task
+                // carries a source, overwrite; when it carries NONE, CLEAR the anchor to undefined
+                // (updateSettings merges, so an explicit undefined overrides) so the completion
+                // cannot be misrouted by a stale unicast anchor and instead BROADCASTS — the real
+                // coordinator (which drains its own pending queue) then picks it up. Daemon-level
+                // routing (meshCoordinatorDaemonId above) is unaffected.
+                meshCoordinatorSessionId: localSourceCoordinatorSessionId || undefined,
             });
         }
     } catch { /* best-effort — dispatch still proceeds */ }

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

@@ -50,6 +50,7 @@ import type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import { appendLedgerEntry } from './mesh-ledger.js';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
 import { handleMeshForwardEvent, shouldForceInjectMeshEvent, triggerMeshQueue, resolveForwardEventMeshId } from './mesh-events-coordinator.js';
+import { isMeshApprovalEvent, MESH_APPROVAL_EVENTS } from './mesh-event-classify.js';
 import {
     peekUnresolvedDelegateForwards,
     ackUnresolvedDelegateForward,
@@ -59,7 +60,9 @@ import { readNonEmptyString, readMeshCompletionSummary, buildMeshSystemMessage }
 import { traceMeshEventStage, traceMeshEventDrop } from './mesh-event-trace.js';
 import { expandDaemonIdForms, daemonIdsEquivalent, sessionIdsEquivalent } from '@adhdev/mesh-shared';
 import { getActiveDirectDispatches, getQueue, reclaimStrandedAssignedTask, updateTaskStatus } from './mesh-work-queue.js';
+import { isSessionActivelyGenerating } from './mesh-queue-assignment.js';
 import { readLedgerEntries } from './mesh-ledger.js';
+import type { MeshLedgerEntry } from './mesh-ledger.js';
 import { pruneStaleDirectDispatches } from './mesh-active-work.js';
 import { findTerminalLedgerEvidenceForTask, reconcileDirectDispatchCompletionFromTranscript } from './mesh-events-stale.js';
 import { extractFinalAssistantSummaryEvidence } from '../providers/chat-message-normalization.js';
@@ -569,6 +572,7 @@ export function shouldHoldPendingDrainForBusyLocalCoordinator(
 function injectPendingIntoCoordinator(
     coordinator: LiveCoordinator['instance'],
     pending: PendingMeshCoordinatorEvent,
+    opts?: { forceOverride?: boolean },
 ): void {
     if (!coordinator) return;
     // NOTIF-DROP-SYNTH-NO-MESSAGE (defence-in-depth): a queued event with no coordinatorMessage
@@ -594,7 +598,11 @@ function injectPendingIntoCoordinator(
         if (!coordinatorMessage) return; // builder produced nothing — nothing to surface
         LOG.warn('MeshReconcile', `Lazily synthesized missing coordinatorMessage for ${pending.event} (mesh ${pending.meshId}) at inject time — a queued terminal event arrived message-less`);
     }
-    const force = shouldForceInjectMeshEvent(pending.event);
+    // forceOverride lets the APPROVAL-Q1-REALTIME nudge path deliver into a busy
+    // coordinator WITHOUT a raw PTY force-write (force-inject-into-generating stays
+    // intentionally removed): a non-force send_message enters the adapter's
+    // pendingOutboundQueue and is surfaced at the coordinator's next turn boundary.
+    const force = opts?.forceOverride ?? shouldForceInjectMeshEvent(pending.event);
     // EVTTRACE: event surfaced to the coordinator (injected into its live CLI session).
     // This is the terminal happy-path stage. Observation only.
     traceMeshEventStage('surfaced', {
@@ -775,6 +783,112 @@ function drainAndInjectIntoTargets(
     return pendingEvents.length;
 }
 
+// APPROVAL-Q1-REALTIME stale guard. An approval nudge is RESOLVED once a real terminal
+// ledger entry (task_completed / task_failed) for the same node/session landed at or
+// after the nudge was queued — the worker either finished or died, so it is no longer
+// waiting on that approval. Delivering the nudge then would falsely tell the coordinator
+// the worker is still blocked (the exact UX inversion this fix must avoid), so a resolved
+// nudge is dropped rather than delivered. Ledger-based so the check is daemon-local and
+// deterministic (no dependence on a possibly-remote worker instance's live state).
+function isApprovalNudgeResolved(meshId: string, pending: PendingMeshCoordinatorEvent): boolean {
+    const metadataEvent = (pending.metadataEvent && typeof pending.metadataEvent === 'object')
+        ? pending.metadataEvent as Record<string, unknown>
+        : {};
+    const nodeId = readNonEmptyString(pending.nodeId) || readNonEmptyString(metadataEvent.meshNodeId);
+    const sessionId = readNonEmptyString(metadataEvent.targetSessionId) || readNonEmptyString(metadataEvent.sessionId);
+    if (!nodeId && !sessionId) return false; // nothing to correlate a terminal against
+    const queuedAt = typeof pending.queuedAt === 'number' && Number.isFinite(pending.queuedAt) ? pending.queuedAt : 0;
+    let entries: MeshLedgerEntry[];
+    try {
+        entries = readLedgerEntries(meshId);
+    } catch {
+        return false; // best-effort — a read failure never blocks delivery
+    }
+    return entries.some(e => {
+        if (e.kind !== 'task_completed' && e.kind !== 'task_failed') return false;
+        if (queuedAt > 0) {
+            const t = new Date(e.timestamp).getTime();
+            if (Number.isFinite(t) && t < queuedAt) return false; // terminal predates the nudge
+        }
+        const nodeMatch = !!nodeId && !!e.nodeId && daemonIdsEquivalent(e.nodeId, nodeId);
+        const sessionMatch = !!sessionId && !!e.sessionId && sessionIdsEquivalent(e.sessionId, sessionId);
+        return nodeMatch || sessionMatch;
+    });
+}
+
+// APPROVAL-Q1-REALTIME. Deliver queued approval nudges to a mesh's coordinators every
+// reconcile tick, EVEN when the only coordinators are busy (generating / modal-parked)
+// and there is no idle drain target. This is the crux of the fix: a completion rides the
+// idle-edge hold below (its payload lives only in the pending event), but an approval is
+// LEVEL-backed (task_approval_needed ledger → mesh_status awaiting_approval) so it must
+// NOT wait for an idle edge — during orchestration a coordinator can stay `generating`
+// awaiting the very worker that is blocked on the approval, so the idle edge (the flush
+// point) may never come, and the coordinator's mesh_approve arrives only after a human
+// resolves it ('Not in approval state'). We drain ONLY approval events (leaving every
+// other event for the unchanged hold), drop any already-resolved (stale) nudge, and
+// deliver the rest into each coordinator's inbox WITHOUT a raw PTY force-write (non-force
+// send_message → adapter pendingOutboundQueue → surfaced at the coordinator's next turn
+// boundary). Dropping the pending copy after delivery is safe and prevents re-nudging
+// every 4s — the level ledger state remains the durable, re-derivable source of truth.
+// Returns the number of nudges delivered (0 when none were queued/deliverable).
+function drainAndDeliverApprovalNudges(
+    meshId: string,
+    drainDaemonIds: string[],
+    localDaemonId: string | undefined,
+    meshCoordinators: LiveCoordinator[],
+): number {
+    // O(1) guard: only touch the queue when an approval event is actually present.
+    let peeked: readonly PendingMeshCoordinatorEvent[];
+    try {
+        peeked = getPendingMeshCoordinatorEvents(meshId, drainDaemonIds.length > 0 ? drainDaemonIds : undefined);
+    } catch {
+        return 0;
+    }
+    if (!peeked.some(e => isMeshApprovalEvent(e.event))) return 0;
+
+    let drained: PendingMeshCoordinatorEvent[];
+    try {
+        drained = drainPendingMeshCoordinatorEvents(
+            meshId,
+            drainDaemonIds.length > 0 ? drainDaemonIds : localDaemonId,
+            { onlyEvents: MESH_APPROVAL_EVENTS },
+        );
+    } catch (e: any) {
+        LOG.warn('MeshReconcile', `Approval-nudge drain failed for mesh ${meshId}: ${e?.message || e}`);
+        return 0;
+    }
+
+    let delivered = 0;
+    for (const pending of drained) {
+        if (isApprovalNudgeResolved(meshId, pending)) {
+            // Stale: already resolved. Drop without delivery — re-surfacing it would
+            // mislead the coordinator into believing the worker is still awaiting approval.
+            traceMeshEventDrop('approval_nudge_stale_resolved', {
+                taskId: readNonEmptyString((pending.metadataEvent as Record<string, unknown>)?.taskId),
+                sessionId: readNonEmptyString((pending.metadataEvent as Record<string, unknown>)?.targetSessionId) ?? pending.targetCoordinatorSessionId,
+                nodeId: pending.nodeId,
+                meshId,
+                event: pending.event,
+            }, 'approval already resolved (terminal ledger entry present)');
+            LOG.info('MeshReconcile', `Dropped stale approval nudge for mesh ${meshId} (${pending.nodeLabel}) — approval already resolved`);
+            continue;
+        }
+        // Strict session routing (multi-coordinator): deliver only to the originating
+        // coordinator session when the nudge names one; otherwise broadcast to every
+        // coordinator for this mesh. Absent a live matching coordinator we drop the nudge —
+        // the level state (awaiting_approval) still surfaces via mesh_status, so nothing is lost.
+        const wantSession = readNonEmptyString(pending.targetCoordinatorSessionId);
+        const targets = wantSession
+            ? meshCoordinators.filter(c => sessionIdsEquivalent(c.sessionId, wantSession))
+            : meshCoordinators;
+        if (targets.length === 0) continue;
+        for (const c of targets) injectPendingIntoCoordinator(c.instance, pending, { forceOverride: false });
+        delivered++;
+        LOG.info('MeshReconcile', `Delivered approval nudge (level) for mesh ${meshId} (${pending.nodeLabel}) → ${targets.length} coordinator(s) without waiting for an idle edge`);
+    }
+    return delivered;
+}
+
 // One reconcile tick. Two independent phases:
 //
 //   PHASE 1 — Remote queue pull (the fix for remote worktree completions never
@@ -802,6 +916,16 @@ function drainAndInjectIntoTargets(
 // lost to a daemon restart between claim and confirm).
 const ASSIGNED_STRANDED_DEADLINE_MS = 5 * 60_000;
 
+// COMPLETION-PROPAGATION F3: how long a row may sit 'assigned' with a CONFIRMED delivery
+// (delivered/acked) but no terminal completion before the watchdog reclaims it as a
+// delivered-but-lost completion. Distinct from — and deliberately larger than —
+// ASSIGNED_STRANDED_DEADLINE_MS: a confirmed-delivered dispatch was genuinely handed to a
+// worker, so the deadline must comfortably exceed any realistic single worker turn (a large
+// generation) before we treat the missing completion as lost and re-open the task. Paired with
+// the non-generating + no-terminal-ledger guards below so a worker still mid-turn is never
+// reclaimed out from under itself.
+const DELIVERED_NO_TURN_DEADLINE_MS = 15 * 60_000;
+
 // PHASE 2.5 — assigned-stranded dispatch watchdog (Bug B). claimNextTask atomically
 // flips a row to 'assigned' BEFORE the fire-and-forget dispatch runs. If that dispatch
 // neither rejects (→ no .catch requeue) nor is confirmed delivered — a relay that hangs
@@ -814,7 +938,7 @@ const ASSIGNED_STRANDED_DEADLINE_MS = 5 * 60_000;
 // 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(meshId: string, store: MeshRuntimeStore): void {
+function recoverStrandedAssignedDispatches(components: DaemonComponents, meshId: string, store: MeshRuntimeStore): void {
     const assigned = getQueue(meshId, { status: ['assigned'] });
     if (!assigned.length) return;
     const nowMs = Date.now();
@@ -839,7 +963,37 @@ function recoverStrandedAssignedDispatches(meshId: string, store: MeshRuntimeSto
             }, terminal.kind);
             continue;
         }
-        if (store.taskHasConfirmedDelivery(meshId, row.id)) continue;          // dispatched → PHASE 4's job
+        if (store.taskHasConfirmedDelivery(meshId, row.id)) {
+            // COMPLETION-PROPAGATION F3 (delivered-but-lost completion): the dispatch WAS
+            // confirmed handed to a worker (delivered/acked) but no terminal completion ever
+            // landed and none is in the ledger (checked just above). Normally this is PHASE 4's
+            // job, but PHASE 4 only covers direct-dispatch rows / a live re-read; a claim-path
+            // queue row whose completion event was lost (the manual-launch flip-miss signature)
+            // sits 'assigned' forever. Reclaim it — but ONLY once the session is idle/dead (its
+            // live local instance is not actively generating; a remote/absent instance reports
+            // non-generating too) AND a generous delivered-no-turn deadline has elapsed, so a
+            // worker genuinely mid-turn is never torn off its task. reclaimStrandedAssignedTask
+            // ends the single-flight window (F4), so a subsequent re-dispatch/requeue is unblocked.
+            if (nowMs - dispatchedAtMs < DELIVERED_NO_TURN_DEADLINE_MS) continue;   // still within turn budget
+            if (row.assignedSessionId && isSessionActivelyGenerating(components, row.assignedSessionId)) continue;  // worker still working
+            const reclaimedLost = reclaimStrandedAssignedTask(meshId, row.id, {
+                reason: 'delivered_no_turn_deadline',
+                ageMs: nowMs - dispatchedAtMs,
+            });
+            if (reclaimedLost) {
+                LOG.warn('MeshReconcile', `Reclaimed delivered-but-lost task ${row.id} on mesh ${meshId} `
+                    + `(node=${row.assignedNodeId ?? '?'} session=${row.assignedSessionId ?? '?'}, delivered but no `
+                    + `completion in ${Math.round((nowMs - dispatchedAtMs) / 1000)}s, session non-generating → ${reclaimedLost.status})`);
+                traceMeshEventDrop('assigned_stranded_delivered_no_turn', {
+                    taskId: row.id,
+                    sessionId: row.assignedSessionId,
+                    nodeId: row.assignedNodeId,
+                    meshId,
+                    event: 'agent:generating_completed',
+                }, `delivered ${Math.round((nowMs - dispatchedAtMs) / 1000)}s → ${reclaimedLost.status}`);
+            }
+            continue;
+        }
         const reclaimed = reclaimStrandedAssignedTask(meshId, row.id, {
             reason: 'assigned_stranded_dispatch_unconfirmed',
             ageMs: nowMs - dispatchedAtMs,
@@ -914,7 +1068,7 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
             const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
             if (!daemonHostsMesh(mesh, selfIds)) continue;
             try {
-                recoverStrandedAssignedDispatches(mesh.id, store);
+                recoverStrandedAssignedDispatches(components, mesh.id, store);
             } catch (e: any) {
                 LOG.warn('MeshReconcile', `Assigned-stranded watchdog failed for mesh ${mesh.id}: ${e?.message || e}`);
             }
@@ -1075,6 +1229,22 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
         // worker summary is recoverable even if the coordinator never returns or the pending
         // file is later trimmed.
         if (targetCoordinators.length === 0) {
+            // ── APPROVAL-Q1-REALTIME: level-deliver approval nudges BEFORE the hold ──
+            // Approval events are LEVEL-backed (task_approval_needed ledger →
+            // mesh_status awaiting_approval), so they must not be edge-held like a
+            // completion (whose payload lives only in the pending event). Drain and
+            // deliver them to the busy coordinator's inbox (non-force, next-turn-boundary)
+            // this tick, dropping any already-resolved (stale) nudge — and leave ONLY the
+            // completion/other events in the queue for the existing hold semantics below
+            // (their behaviour is unchanged: shouldForceInjectMeshEvent no longer sees the
+            // approval rows because this drained them). MUST run first so the modal-park
+            // orphan-escape and the generating-hold audit only ever see non-approval events.
+            drainAndDeliverApprovalNudges(meshId, drainDaemonIds, localDaemonId, meshCoordinators);
+            // If approval nudges were the only queued events, nothing remains to hold — skip
+            // the hold branches (and their "holding pending event(s)" log) entirely.
+            if (store) {
+                try { if (store.pendingEventCount(meshId) === 0) continue; } catch { /* fall through */ }
+            }
             if (modalParkedCoordinators.length > 0) {
                 // ── orphan escape (MUST precede the blanket modal-park hold) ──────────
                 // A modal-parked coordinator with no idle/generating sibling otherwise

package/src/mesh/mesh-runtime-store.ts

@@ -883,25 +883,39 @@ export class MeshRuntimeStore {
     ): MeshWorkQueueEntry | null {
         this.ensureLegacyQueueMigrated(meshId);
 
-        // 1. Exact taskId match — robust against clock skew and stale rows.
+        // WRITE/READ PREDICATE SYMMETRY (COMPLETION-PROPAGATION F1): the claim path writes
+        // assigned_session_id RAW (claimNextTask), and the sibling gates that decide whether a
+        // session already holds work (sessionHasActiveAssignment) and which pending row a
+        // session may claim (targetMatches) compare it through sessionIdsEquivalent — the
+        // canonical single-form predicate that TRIMS both sides. A raw SQL `assigned_session_id
+        // = ?` here is asymmetric with that write/sibling predicate: a completion whose
+        // resolveEventSessionId-reinterpreted sessionId is equivalent-but-not-byte-identical to
+        // the stored column (e.g. a whitespace/serialization skew from a manually-launched
+        // session) silently fetched zero rows and stranded the finished task as `assigned`
+        // forever (the mesh-work-queue :1251 "N assigned row(s) exist" warning is that exact
+        // signature). Fetch every `assigned` row for the mesh and filter session membership in
+        // JS with sessionIdsEquivalent, mirroring the node-id IN(...)+JS-revalidate pattern the
+        // claim SELECT uses (claimNextTask :720-736 / targetMatches :797-811).
+        const allRows = this.db.prepare(
+            `SELECT payload FROM mesh_queue WHERE mesh_id = ? AND status = 'assigned'`
+        ).all(meshId) as Array<{ payload: string }>;
+        const sessionEntries = allRows
+            .map(r => { try { return JSON.parse(r.payload) as MeshWorkQueueEntry; } catch { return null; } })
+            .filter((e): e is MeshWorkQueueEntry => e !== null)
+            .filter(e => sessionIdsEquivalent(e.assignedSessionId, sessionId));
+
+        // 1. Exact taskId match — robust against clock skew and stale rows. Scoped to the
+        // session-equivalent set (as the raw `AND assigned_session_id = ? AND id = ?` was),
+        // now via the trimming equivalence predicate.
         if (taskId) {
-            const row = this.db.prepare(
-                `SELECT payload FROM mesh_queue WHERE mesh_id = ? AND assigned_session_id = ? AND status = 'assigned' AND id = ? LIMIT 1`
-            ).get(meshId, sessionId, taskId) as { payload: string } | undefined;
-            if (row) return JSON.parse(row.payload) as MeshWorkQueueEntry;
+            const byId = sessionEntries.find(e => e.id === taskId);
+            if (byId) return byId;
             // Fall through to session-based matching if the id didn't line up
             // (e.g. event carried a stale/foreign taskId).
         }
 
         // 2. Session-based match WITHOUT the mutable updated_at filter.
-        const rows = this.db.prepare(
-            `SELECT payload FROM mesh_queue WHERE mesh_id = ? AND assigned_session_id = ? AND status = 'assigned'`
-        ).all(meshId, sessionId) as Array<{ payload: string }>;
-        if (rows.length === 0) return null;
-
-        const entries = rows
-            .map(r => { try { return JSON.parse(r.payload) as MeshWorkQueueEntry; } catch { return null; } })
-            .filter((e): e is MeshWorkQueueEntry => e !== null);
+        const entries = sessionEntries;
         if (entries.length === 0) return null;
         if (entries.length === 1) return entries[0];
 

package/src/mesh/worktree-bootstrap-config.ts

@@ -154,6 +154,25 @@ export function isWorktreeBootstrapStaleRunning(
     }
 }
 
+/**
+ * COMPLETION-PROPAGATION F7 (C2): the single shared consume-ready / bootstrap-pending defer
+ * predicate. A task must NOT be injected into a worktree node whose bootstrap is still 'running'
+ * — the provider is not yet ready to consume input, so the inject lands in the input buffer and
+ * is silently swallowed (empty session). Both the remote dispatch guard (the router agent_command
+ * handler) and the local queue-claim gate (tryAssignQueueTask) route through THIS predicate so
+ * they agree on exactly when to defer. Returns true = defer. The stale-'running' backstop
+ * (isWorktreeBootstrapStaleRunning) is honored here too: a 'running' state far older than any real
+ * bootstrap whose worktree is git-clean is treated as silently complete (do NOT defer), so a node
+ * whose terminal stamp never reached this daemon is not stranded forever.
+ */
+export function shouldDeferDispatchForBootstrap(
+    node: { worktreeBootstrap?: { status?: string; startedAt?: string; updatedAt?: string; completedAt?: string }; workspace?: string } | undefined,
+    nowMs: number = Date.now(),
+): boolean {
+    if (node?.worktreeBootstrap?.status !== 'running') return false;
+    return !isWorktreeBootstrapStaleRunning(node, nowMs);
+}
+
 export interface WorktreeBootstrapConfigLoadResult {
     config?: RepoMeshWorktreeBootstrapConfig;
     source: string;

package/src/providers/approval-utils.ts

@@ -41,6 +41,48 @@ export function hasNegativeApprovalOption(buttons: string[] | null | undefined):
     return (buttons || []).some((button) => isNegativeApprovalLabel(String(button || '')));
 }
 
+/**
+ * True when a button reliably identifies a tool-CONSENT modal on its own — a
+ * scoped permission-grant affirmative such as:
+ *   - "Yes, allow all edits in tmp/ during this session"
+ *   - "Yes, and don't ask again for example.com"
+ *   - "Yes, allow reading from etc/ from this project"
+ *   - "Always allow"
+ *
+ * These options only ever appear in a genuine approval/permission prompt; a
+ * /model or /mode picker ("1. Default  2. Opus  3. Sonnet") never offers a
+ * "grant this scope" choice. They therefore serve as a SECOND reliable
+ * structural anchor alongside {@link hasNegativeApprovalOption}.
+ *
+ * Why this exists (tall-diff fallback, #137): when a Write/Edit diff is tall,
+ * the trailing decline option ("3. No") can scroll off the bottom of the
+ * captured PTY frame, leaving only "1. Yes" + "2. Yes, allow … this session".
+ * hasNegativeApprovalOption then reads false and the auto-approve gate bails —
+ * a delegated worker sits forever on a modal it could safely have approved. The
+ * grant-scope affirmative lets the gate recognize the consent modal WITHOUT
+ * seeing the off-frame decline. The gate still selects the plain "Yes"
+ * (allow-once) via pickApprovalButton, never the broader grant, and the settle
+ * gate still requires a stable modal — so a half-rendered frame never fires.
+ * Kept deliberately narrow so no picker/confirm modal can trip it.
+ */
+export function hasReliableApprovalAffirmative(buttons: string[] | null | undefined): boolean {
+    return (buttons || []).some((button) => {
+        const label = normalizeApprovalLabel(String(button || ''));
+        if (!label) return false;
+        // "always allow …" as a standalone grant option.
+        if (/^always allow\b/.test(label)) return true;
+        // "yes, …" scoped grants: allow / always allow / don't ask again / etc.
+        // (normalizeApprovalLabel strips the apostrophe, so "don't" → "don t").
+        if (/^yes\b/.test(label)) {
+            if (/\ballow\b/.test(label)) return true;
+            if (/\bask again\b/.test(label)) return true;
+            if (/\bduring this session\b/.test(label)) return true;
+            if (/\bfrom this project\b/.test(label)) return true;
+        }
+        return false;
+    });
+}
+
 export function getApprovalPositiveHints(provider?: Pick<ProviderModule, 'approvalPositiveHints'> | null): string[] {
     const customHints = Array.isArray(provider?.approvalPositiveHints)
         ? provider.approvalPositiveHints