@adhdev/daemon-core 0.9.82-rc.44 → 0.9.82-rc.440

package/src/providers/cli-provider-instance.ts

@@ -13,19 +13,25 @@ import { createRequire } from 'node:module';
 import { normalizeInputEnvelope, type ProviderModule, flattenContent, type InputEnvelope, type InputPart } from './contracts.js';
 import { assertProviderSupportsDeclaredInput, getEffectiveMessageInputSupport } from './provider-input-support.js';
 import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext, ProviderErrorReason, HotChatSessionState, SessionModalState } from './provider-instance.js';
+import { normalizeInteractivePrompt, normalizeInteractivePromptResponse, type InteractivePrompt } from './types/interactive-prompt.js';
 import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
+import { shortHash } from '../system/hash.js';
 import type { CliProviderModule } from '../cli-adapters/provider-cli-adapter.js';
+import { createCliAdapter } from './spec/route.js';
 import type { PtyRuntimeMetadata, PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import { StatusMonitor } from './status-monitor.js';
 import { ChatHistoryWriter, isNativeSourceCanonicalHistory, materializeProviderNativeHistory, readChatHistory, readProviderChatHistory } from '../config/chat-history.js';
 import { LOG } from '../logging/logger.js';
+import { traceMeshEventStage, traceMeshEventDrop } from '../mesh/mesh-event-trace.js';
 import type { ChatMessage } from '../types.js';
 import { buildPersistedProviderEffectMessage, normalizeProviderEffects } from './control-effects.js';
-import { formatAutoApprovalMessage, pickApprovalButton } from './approval-utils.js';
+import { formatAutoApprovalMessage, pickApprovalButton, hasNegativeApprovalOption, looksLikeActiveApprovalPromptText } from './approval-utils.js';
 import { getCliScriptCommand, parseCliScriptResult } from './cli-script-results.js';
 import { mergeProviderPatchState, resolveProviderStateSurface } from './provider-patch-state.js';
 import { normalizeProviderSessionId } from './provider-session-id.js';
-import { buildChatMessage, buildRuntimeSystemChatMessage, isUserFacingChatMessage, normalizeChatMessages, resolveChatMessageKind, extractFinalSummaryFromMessages } from './chat-message-normalization.js';
+import { buildChatMessage, buildRuntimeSystemChatMessage, isUserFacingChatMessage, normalizeChatMessages, resolveChatMessageKind, extractFinalSummaryFromMessages, extractFinalSummaryFromMessagesAfter } from './chat-message-normalization.js';
+import { workingDirBasename } from './working-dir.js';
+import { ManualAttendanceTracker } from './manual-attendance.js';
 
 type PersistableCliHistoryMessage = {
     role: string;
@@ -35,16 +41,136 @@ type PersistableCliHistoryMessage = {
     receivedAt?: number;
 };
 
+// Status snapshots only ever surface the newest messages: the cloud 'live'
+// profile drops chat messages entirely (loaded lazily via read_chat on
+// subscribe) and the 'full' profile caps activeChat.messages to the last 60
+// (see status/normalize.ts). Unread/completion markers walk only the tail.
+// So getState()'s saved-history hydration — which runs once per resume/manual
+// CLI session on every status report — must read only a bounded tail, not the
+// entire transcript. A full MAX_SAFE_INTEGER read here makes the initial
+// status report O(transcript) × N(sessions), which is the real cold first-
+// connection bottleneck on chat-heavy machines. The window comfortably exceeds
+// the 60-message snapshot cap so dedup/collapse at the boundary stays stable.
+const STATUS_HYDRATION_TAIL_LIMIT = 200;
+
 type CompletedDebouncePending = {
     chatTitle: string;
     duration: number;
     timestamp: number;
     firstObservedAt: number;
+    previousStatus: string;
     loggedBlockReason?: string;
+    loggedTranscriptProbe?: boolean;
+    transcriptProbeHistory?: ExternalTranscriptProbe[];
+    // ARCH-REFACTOR R1: the taskId of the turn that produced this (debounced) completion,
+    // captured SYNCHRONOUSLY at the generating→idle transition. The actual completion
+    // event is emitted later by the debounce flush, by which point a follow-up task may
+    // already have started its own turn and overwritten engine.currentTurnTaskId — so the
+    // id must be snapshotted here, not re-read at flush time.
+    taskId?: string;
+    // NOTIF Defect-B: the wall-clock start of the turn that produced this (debounced)
+    // completion, snapshotted SYNCHRONOUSLY at the generating→idle transition (same
+    // reason as taskId — a follow-up turn moves engine.currentTurnStartedAt). The
+    // completion's finalSummary is turn-scoped to bubbles at/after this instant so a
+    // debounce that flushes before the producing turn's final assistant bubble lands
+    // in the native transcript never echoes the PRIOR task's last bubble.
+    turnStartedAt?: number;
+};
+
+function isIdleStatus(value: unknown): boolean {
+    const status = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    return !status || status === 'idle' || status === 'ready';
+}
+
+
+function getMessageTime(message: unknown): number {
+    if (!message || typeof message !== 'object') return 0;
+    const record = message as { receivedAt?: unknown; timestamp?: unknown };
+    const value = Number(record.receivedAt ?? record.timestamp ?? 0);
+    return Number.isFinite(value) ? value : 0;
+}
+
+type CompletedFinalizationBlock = {
+    reason: string;
+    terminal?: boolean;
+    allowTimeout?: boolean;
+    // (SETTLE-VALLEY) When set, suppress the CANON-C decoupled-immediate emit for this
+    // missing_final_assistant block and HOLD (retry up to COMPLETED_FINALIZATION_MAX_WAIT_MS)
+    // until the native transcript's final assistant turn arrives (block clears → genuine emit)
+    // or the worker resumes (resume guard cancels). Set only for the inter-approval idle valley
+    // of a native-history mesh worker, where an immediate weak emit would freeze a truncated
+    // preamble summary (evidenceLevel=insufficient) into the append-only ledger before the
+    // worker's next approval turn resumes. Independent of valley length.
+    holdForTranscript?: boolean;
+};
+
+type CompletionFinalAssistantEvidence = {
+    present: boolean;
+    messages: unknown[];
+    source: 'parsed' | 'external-native' | 'unavailable';
+};
+
+type ExternalTranscriptProbe = {
+    readAt: number;
+    msgCount: number;
+    lastRole: string | null;
+    lastKind: string | null;
+    contentLen: number;
+    sourcePath: string | null;
+    sourceMtimeMs: number | null;
+    mtimeAgeMs: number | null;
 };
 
 const COMPLETED_FINALIZATION_RETRY_MS = 1000;
 const COMPLETED_FINALIZATION_MAX_WAIT_MS = 30_000;
+// (FALSEIDLE-BGCHILD-a) Minimum generating→idle settle window for native-history mesh worker
+// sessions. Native-history providers (e.g. claude-cli) normally flush the completion with
+// flushDelay=0 — the transcript is authoritative, so there is no reason to wait. But a worker
+// turn that spawns a BACKGROUND child (e.g. `npm test &`, a backgrounded Bash tool) can paint
+// a burst of child output, fall quiet, and have the screen parser read a PRIOR/intermediate
+// standard assistant as if the turn were done — firing a false idle while the agent is in fact
+// still generating (e.g. mid-commit). With flushDelay=0 there is no window for the resume guard
+// in flushCompletedDebounceIfFinalized (latestVisibleStatus !== 'idle' → cancel) to observe the
+// agent picking the turn back up. A short non-zero settle window restores that resume guard for
+// mesh workers without delaying genuinely-finished turns beyond this bound. Scoped to mesh
+// worker sessions so interactive native-history sessions keep the immediate flush.
+// 4000ms (was 1500): live measurement showed the completion event can fire 1.6–3s
+// BEFORE the worker's final-assistant turn lands in the transcript on a natural
+// generating→idle completion (no approval modal), freezing a prior intermediate
+// bubble as finalSummary (evidenceLevel=insufficient). The 68a3c324 waiting_approval
+// hold only covers the approval-resolved valley; widening this settle window to 4000ms
+// covers that race AND the ~3s waiting_approval valley within the settle bound.
+const NATIVE_HISTORY_MESH_IDLE_SETTLE_MS = 4000;
+// TASKBUBBLE-DUP: window during which an identical user-input ack (same trimmed
+// content on the same instance) is treated as a redelivery of one dispatch and
+// suppressed from the chat transcript. Matches the coordinator-side
+// DUPLICATE_DISPATCH_WINDOW_MS (mesh-tools) so the daemon's bubble-level guard
+// covers the same retry horizon as the MCP-level dispatch dedup.
+const USER_INPUT_ACK_DEDUP_WINDOW_MS = 60_000;
+// GENERATING-BOUNDARY (R4c): window — measured from the startup-grace COLLAPSE moment
+// (startupGraceCollapseAt), not boot — inside which a "first turn that ran+completed
+// without the FSM ever observing a 'generating' frame" is attributed to the startup-grace
+// collapse and synthesized (reason 'startup_grace_idle_turn_collapse').
+// The spec's startup-grace exit is elapsed_ms=8000, so the FSM spends ~8s in 'starting'
+// before collapsing to idle; a turn can be dispatched a few seconds AFTER that collapse
+// (the live R4b miss: collapse at boot+8s, dispatch at boot+12.4s — already past a 12s
+// boot-anchored window before the turn even started). Anchoring on the collapse moment
+// covers dispatch-delay; R4d additionally anchors on the turn-START moment
+// (engine.currentTurnStartedAt) so a non-trivial turn-DURATION cannot push the completion
+// past a now-anchored window (the live rc.405 Probe2 miss). The strong discriminator is
+// generatingStartedAt===0 (generating was never observed) AND a started-but-finished turn
+// — the window only keeps the synthesized reason honest and scopes the synthesis to the
+// boot collapse, so a much-later unobservably-fast turn is not mislabelled a startup collapse.
+const STARTUP_GRACE_IDLE_COLLAPSE_WINDOW_MS = 12_000;
+
+/** Events that signal a dispatched mesh task has reached a terminal state.
+ *  Detach the mesh assignment after emitting one of these so the worker's
+ *  next unrelated turn doesn't impersonate another completion. */
+const TERMINAL_MESH_EVENTS = new Set([
+    'agent:generating_completed',
+    'agent:stopped',
+    'agent:ready',
+]);
 
 const IMAGE_MIME_EXTENSIONS: Record<string, string> = {
     'image/png': '.png',
@@ -120,7 +246,29 @@ function hasNonEmptyCliModalButtons(activeModal: unknown): boolean {
 }
 
 function isCliGeneratingLikeStatus(status: unknown): boolean {
-    return status === 'generating' || status === 'streaming' || status === 'long_generating' || status === 'starting';
+    return status === 'generating' || status === 'streaming' || status === 'no_progress' || status === 'long_generating' || status === 'starting';
+}
+
+/**
+ * NOTIF Defect-2a: the REPORTED short-generating duration, anchored on the IMMUTABLE turn
+ * start. generatingStartedAt is reset to 0 on every mid-turn waiting_approval/idle blip and
+ * re-armed on the next →generating, so a long turn that blips would otherwise measure only the
+ * final 1.5-2.5s sliver. engine.currentTurnStartedAt (set once at onTurnStarted, surviving
+ * mid-turn blips until the next turn starts) is preferred; generatingStartedAt is the fallback
+ * for turns that never recorded an engine turn start. Returns 0 when neither anchor is set.
+ * Pure / unit-testable.
+ */
+export function computeTurnAnchoredDurationMs(
+    engineTurnStartedAt: number | undefined,
+    generatingStartedAt: number,
+    now: number,
+): { durationMs: number; anchor: 'turn-start' | 'generatingStartedAt' | 'none' } {
+    const engineStart = typeof engineTurnStartedAt === 'number' && Number.isFinite(engineTurnStartedAt)
+        ? engineTurnStartedAt
+        : 0;
+    if (engineStart > 0) return { durationMs: now - engineStart, anchor: 'turn-start' };
+    if (generatingStartedAt > 0) return { durationMs: now - generatingStartedAt, anchor: 'generatingStartedAt' };
+    return { durationMs: 0, anchor: 'none' };
 }
 
 export function buildCliStructuredInputPrompt(
@@ -300,24 +448,131 @@ export class CliProviderInstance implements ProviderInstance {
     readonly type: string;
     readonly category = 'cli' as const;
 
+    /**
+     * Quiet period an approval modal's signature must be stable before
+     * auto-approve sends the approve key. Guards against firing on a prompt
+     * that is still streaming into the PTY (the "resolves too fast" symptom):
+     * while the modal text/buttons are still changing, every frame yields a
+     * new signature and the settle clock restarts. Once the prompt finishes
+     * rendering the signature holds and the key is sent after this window.
+     * Bounded + small so genuine approvals stay timely. The FSM is already
+     * authoritative over the `waiting_approval` state; this only delays the
+     * keystroke until the modal *content* has settled.
+     */
+    private static readonly AUTO_APPROVE_SETTLE_MS = 600;
+
+    /**
+     * Busy-side hysteresis for the settle gate. A momentary `generating` flip
+     * while the SAME approval modal's button block is still on screen (its
+     * question line scrolled out of the captured frame, only the buttons + a
+     * residual `esc to interrupt` spinner remain) briefly reports
+     * status!=waiting_approval. Without hysteresis that flip wipes the settle
+     * clock, and the modal→generating→modal flap restarts the 600ms window
+     * every time so auto-approve never fires. We keep the in-progress settle
+     * gate warm across an inactive blip up to this bound; only once the modal
+     * has genuinely stayed gone this long (a real resolution → idle) is the
+     * gate cleared. Bounded so a genuinely new, later approval still re-settles
+     * from scratch rather than firing on a stale timestamp.
+     */
+    private static readonly AUTO_APPROVE_GATE_HYSTERESIS_MS = 1500;
+
+    /**
+     * STATUS-MISMATCH: upper bound on how long the auto-approve→`generating` SURFACE
+     * mask may hide a worker's `waiting_approval` (status + activeModal) before we give
+     * up and surface the real prompt. The mask exists because auto-approve is expected
+     * to resolve the modal momentarily; but if it STALLS without ever calling
+     * resolveModal — the modal signature never settles for AUTO_APPROVE_SETTLE_MS (a
+     * perpetually-flapping/streaming prompt), no concrete modal is ever captured, or the
+     * modal is a picker/non-affirmative we never auto-pick — the mask would persist
+     * forever and read_chat / mesh_status / the dashboard would NEVER see the pending
+     * approval (the coordinator cannot mesh_approve what it cannot see). Once an episode
+     * exceeds this bound we stop masking. Generously larger than
+     * AUTO_APPROVE_SETTLE_MS (600) + AUTO_APPROVE_GATE_HYSTERESIS_MS (1500) so a
+     * legitimately slow-settling / blip-flapping prompt is never unmasked early; a
+     * genuine never-resolving stall surfaces within this window. The settle gate keeps
+     * running underneath, so a prompt that finally stabilises still auto-approves, and
+     * mesh_approve (raw FSM, unmasked) works throughout.
+     */
+    private static readonly AUTO_APPROVE_MASK_STALL_MS = 4500;
+
     private adapter: ProviderCliAdapter;
     private context: InstanceContext | null = null;
     private events: ProviderEvent[] = [];
     private lastStatus: string = 'starting';
+    // Idempotency guard for the queue-claim agent:ready event. agent:ready is the
+    // sole signal the mesh coordinator's tryAssignQueueTask waits on to hand a
+    // queued task to this worker. It is emitted in two places: the boot-time
+    // starting→idle one-shot, and the readySeen re-arm below. This flag makes the
+    // event fire AT MOST ONCE per session so a worker is never claimed twice and a
+    // queued task is never double-dispatched/double-injected. Whichever path fires
+    // first sets it; the other becomes a no-op.
+    private agentReadyEmitted = false;
     private generatingStartedAt: number = 0;
+    // GENERATING-BOUNDARY (R4b): the per-turn taskId for which a startup-grace
+    // started+completed pair was already synthesized. Both fast-collapse callers
+    // (starting→idle transition AND the idle-stayed no-status-change poll) route
+    // through maybeSynthesizeStartupGraceCollapse; the idle-stayed caller re-polls
+    // steadily while the session sits idle, so this guard makes the synthesis fire
+    // AT MOST ONCE per collapsed turn.
+    private fastCollapseSynthesizedTaskId: string | null = null;
+    // GENERATING-BOUNDARY (R4c): the wall-clock moment the FSM's starting→idle
+    // startup-grace collapse was observed (set ONCE, on the first starting→idle
+    // transition this boot). The idle-stayed collapse window is anchored on THIS,
+    // not on instance/boot time (this.startedAt): the FSM spends the full 8s
+    // startup-grace sitting in 'starting' before collapsing, and a turn can be
+    // dispatched a few seconds AFTER the collapse — measuring the window from boot
+    // would have it already closed by the time that turn lands+completes (the live
+    // R4b miss: collapse at boot+8s, dispatch at boot+12.4s > the 12s boot window).
+    // Anchoring on the collapse moment makes the window cover dispatch-delay+turn.
+    private startupGraceCollapseAt: number | null = null;
     private settings: Record<string, any> = {};
     private monitor: StatusMonitor;
     private generatingDebounceTimer: NodeJS.Timeout | null = null;
     private generatingDebouncePending: { chatTitle: string; timestamp: number } | null = null;
-    private lastApprovalEventAt = 0;
+    private lastApprovalEventFingerprint = '';
     private autoApproveBusy = false;
     private autoApproveBusyTimer: NodeJS.Timeout | null = null;
+    private lastAutoApprovalSignature = '';
+    // Settle gate: the approval modal's signature + the wall-clock when this
+    // exact signature was first observed. Auto-approve only fires once the
+    // SAME signature has been stable for AUTO_APPROVE_SETTLE_MS, so a prompt
+    // still streaming into the PTY (its buttons/message changing frame to
+    // frame) keeps resetting the timer and is never approved half-rendered.
+    private pendingAutoApprovalSignature = '';
+    private pendingAutoApprovalSince = 0;
+    private autoApproveSettleTimer: NodeJS.Timeout | null = null;
+    // Wall-clock when auto-approve first observed status!=waiting_approval while
+    // a settle gate was in progress. Drives AUTO_APPROVE_GATE_HYSTERESIS_MS so a
+    // brief generating flip does not immediately wipe the settle clock.
+    private autoApproveInactiveSince = 0;
+    // STATUS-MISMATCH: wall-clock when the CURRENT auto-approve episode (waiting_approval
+    // + shouldAutoApprove) first began wanting to mask. Unlike pendingAutoApprovalSince it
+    // is NOT reset when the modal signature changes (a still-streaming/flapping prompt) and
+    // survives the same hysteresis blips the settle gate does, so it measures the TRUE age
+    // of an unresolved auto-approve. Once it exceeds AUTO_APPROVE_MASK_STALL_MS the surface
+    // mask is dropped so the real waiting_approval surfaces. Cleared when the episode ends
+    // (modal genuinely gone, manual attendance takes over, or auto-approve fires).
+    private autoApproveMaskSince = 0;
+    // Provider-common manual-attendance signal: while a human is actively driving
+    // this session from the dashboard, auto-approve holds so they can take manual
+    // control. Background mesh workers are never attended → delegated auto-approve
+    // is unaffected.
+    private readonly manualAttendance = new ManualAttendanceTracker();
     private controlValues: Record<string, string | number | boolean> = {};
     private summaryMetadata: unknown = undefined;
     private appliedEffectKeys = new Set<string>();
     private historyWriter: ChatHistoryWriter;
     private runtimeMessages: Array<{ key: string; message: ChatMessage }> = [];
     private lastPersistedHistoryMessages: PersistableCliHistoryMessage[] = [];
+    private lastAcknowledgedUserInputAt = 0;
+    // TASKBUBBLE-DUP: per-content last-ack timestamps so the same dispatched
+    // prompt acked twice in quick succession (the worker buffers the first
+    // send during bootstrap/busy, then a redelivery — dispatch-confirm-timeout
+    // requeue or a reconcile re-dispatch — fires a SECOND send_chat before the
+    // outbound queue drains) collapses to ONE user bubble. Keyed on the trimmed
+    // content; an entry older than USER_INPUT_ACK_DEDUP_WINDOW_MS is treated as
+    // a fresh, intentional resend and is NOT suppressed.
+    private recentUserInputAcks = new Map<string, number>();
     private lastNativeSourceCanonicalCheckAt = 0;
     private lastNativeSourceCanonicalCacheKey: string | undefined = undefined;
     private cachedSqliteDb: {
@@ -330,6 +585,7 @@ export class CliProviderInstance implements ProviderInstance {
     private suppressIdleHistoryReplay = false;
     private errorMessage: string | undefined = undefined;
     private errorReason: ProviderErrorReason | undefined = undefined;
+    private activeInteractivePrompt: InteractivePrompt | null = null;
 
     private presentationMode: 'terminal' | 'chat';
     private providerSessionId?: string;
@@ -370,7 +626,10 @@ export class CliProviderInstance implements ProviderInstance {
         this.providerSessionId = options?.providerSessionId;
         this.launchMode = options?.launchMode || 'new';
         this.onProviderSessionResolved = options?.onProviderSessionResolved;
-        this.adapter = new ProviderCliAdapter(provider as CliProviderModule, workingDir, cliArgs, options?.extraEnv || {}, transportFactory);
+        this.adapter = createCliAdapter(provider as CliProviderModule, workingDir, cliArgs, options?.extraEnv || {}, transportFactory) as ProviderCliAdapter;
+        if (this.providerSessionId) {
+            this.adapter.updateRuntimeMeta({ providerSessionId: this.providerSessionId });
+        }
         this.monitor = new StatusMonitor();
         this.historyWriter = new ChatHistoryWriter();
     }
@@ -389,8 +648,8 @@ export class CliProviderInstance implements ProviderInstance {
         this.adapter.updateRuntimeSettings?.(this.settings);
         this.monitor.updateConfig({
             approvalAlert: this.settings.approvalAlert !== false,
-            longGeneratingAlert: this.settings.longGeneratingAlert !== false,
-            longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180,
+            noProgressAlert: (this.settings.noProgressAlert ?? this.settings.longGeneratingAlert) !== false,
+            noProgressThresholdSec: this.settings.noProgressThresholdSec ?? this.settings.longGeneratingThresholdSec ?? 180,
         });
 
  // Server connection
@@ -412,7 +671,7 @@ export class CliProviderInstance implements ProviderInstance {
         await this.adapter.spawn();
         await this.enforceFreshSessionLaunchIfNeeded();
         this.maybeAppendRuntimeRecoveryMessage(this.adapter.getRuntimeMetadata());
-        if (this.providerSessionId) {
+        if (this.providerSessionId && this.shouldHydrateExistingProviderHistory()) {
             this.restorePersistedHistoryFromCurrentSession();
         }
         if (this.providerSessionId && this.launchMode === 'resume') {
@@ -486,14 +745,38 @@ export class CliProviderInstance implements ProviderInstance {
     }
 
     getState(): ProviderState {
+        // TODO(phase5-sandbox): JS override scripts (detectStatus, parseApproval,
+        // parseSession) are currently invoked by CliScriptRunner.invoke() via direct
+        // function calls — the scripts run in the daemon process with full Node.js
+        // access and no resource limits.
+        //
+        // When Phase 5 lands, CliScriptRunner should route these calls through a
+        // SandboxedScriptRunner (see providers/sdk/v1/sandbox/script-runner.ts) so
+        // that each call gets a fresh isolated-vm context with a 50 ms CPU limit and
+        // a 32 MB memory cap.  The execution path to change is:
+        //   CliScriptRunner.invoke() → SandboxedScriptRunner.run(scriptSource, context)
+        //
+        // This getState() call-site is NOT where the change goes — the wiring belongs
+        // in cli-script-runner.ts (CliScriptRunner.detectStatus / parseApproval /
+        // parseSession), with provider-loader.ts updated to store script source strings
+        // alongside the loaded function references for extended-legacy providers.
         const adapterStatus = this.adapter.getStatus();
+        if (Object.prototype.hasOwnProperty.call(adapterStatus, 'activeInteractivePrompt')) {
+            this.activeInteractivePrompt = adapterStatus.activeInteractivePrompt ?? null;
+        }
         let parsedStatus: any = null;
         let parseErrorMessage: string | undefined;
         if (typeof this.adapter.getScriptParsedStatus === 'function') {
             try {
                 parsedStatus = this.adapter.getScriptParsedStatus() || null;
-                this.errorMessage = undefined;
-                this.errorReason = undefined;
+                const parsedErrorMessage = typeof parsedStatus?.errorMessage === 'string' && parsedStatus.errorMessage.trim()
+                    ? parsedStatus.errorMessage.trim()
+                    : undefined;
+                const parsedErrorReason = typeof parsedStatus?.errorReason === 'string' && parsedStatus.errorReason.trim()
+                    ? parsedStatus.errorReason.trim() as ProviderErrorReason
+                    : undefined;
+                this.errorMessage = parsedErrorMessage;
+                this.errorReason = parsedErrorReason;
             } catch (error: any) {
                 parseErrorMessage = error?.message || String(error);
                 this.errorMessage = parseErrorMessage;
@@ -503,22 +786,59 @@ export class CliProviderInstance implements ProviderInstance {
             this.errorMessage = undefined;
             this.errorReason = undefined;
         }
-        const autoApproveActive = this.maybeAutoApproveStatus(adapterStatus, Date.now());
-        const visibleStatus = parseErrorMessage
-            ? 'error'
-            : (autoApproveActive ? 'generating' : adapterStatus.status);
-        const parsedProviderSessionId = normalizeProviderSessionId(
+        const adapterProviderSessionId = normalizeProviderSessionId(
             this.provider,
-            typeof parsedStatus?.providerSessionId === 'string' ? parsedStatus.providerSessionId : '',
+            typeof adapterStatus?.providerSessionId === 'string' ? adapterStatus.providerSessionId : '',
         );
-        if (parsedProviderSessionId) {
-            this.promoteProviderSessionId(parsedProviderSessionId);
+        const nowMs = Date.now();
+        // STATUS-MISMATCH: maybeAutoApproveStatus still runs for its side effects (settle gate,
+        // resolveModal fire), but the SURFACE mask is dropped once the episode has stalled past
+        // AUTO_APPROVE_MASK_STALL_MS — otherwise a never-settling auto-approve hides the worker's
+        // waiting_approval + modal from read_chat/mesh_status/dashboard forever.
+        const autoApproveActive = this.maybeAutoApproveStatus(adapterStatus, nowMs)
+            && !this.autoApproveMaskStalled(nowMs);
+        const autoApproveHoldIdle = this.autoApproveBusy && adapterStatus.status === 'idle';
+        let visibleStatus = parseErrorMessage || parsedStatus?.status === 'error'
+            ? 'error'
+            : (autoApproveActive || autoApproveHoldIdle ? 'generating' : adapterStatus.status);
+        // getState() must agree with the status the FSM-driven detectStatusTransition()
+        // already committed to lastStatus. The adapter's own status is authoritative; we do
+        // not second-guess it with native-transcript shape. Only reconcile a generating-like
+        // read down to idle when our own lastStatus has already flipped idle (avoids a
+        // perpetual dashboard spinner during the brief window before the next getStatus()).
+        if (isCliGeneratingLikeStatus(visibleStatus) && this.lastStatus === 'idle') {
+            visibleStatus = 'idle';
         }
         const runtime = this.adapter.getRuntimeMetadata();
         this.maybeAppendRuntimeRecoveryMessage(runtime);
         let parsedMessages = Array.isArray(parsedStatus?.messages)
             ? parsedStatus.messages
             : [];
+        const parsedProviderSessionId = normalizeProviderSessionId(
+            this.provider,
+            typeof parsedStatus?.providerSessionId === 'string' ? parsedStatus.providerSessionId : '',
+        );
+        const suppressFreshLaunchStartupReplay = this.shouldSuppressFreshLaunchStartupReplay(
+            parsedMessages,
+            parsedStatus,
+            adapterStatus,
+            parsedProviderSessionId,
+        );
+        if (adapterProviderSessionId && !suppressFreshLaunchStartupReplay) {
+            this.promoteProviderSessionId(adapterProviderSessionId);
+        }
+        if (parsedProviderSessionId && !suppressFreshLaunchStartupReplay) {
+            this.promoteProviderSessionId(parsedProviderSessionId);
+        }
+        if (suppressFreshLaunchStartupReplay) {
+            parsedMessages = [];
+        }
+        // Adapter runtime metadata is transport-owned and is not guaranteed to
+        // identify this conversation. Spec adapters historically exposed the
+        // provider spec id (for example "codex-cli") as runtimeId, which made
+        // concurrent sessions share one activeChat identity until their native
+        // provider session ids were discovered.
+        const activeChatId = this.providerSessionId || this.instanceId;
         const historyMessageCount = Number.isFinite(parsedStatus?.historyMessageCount)
             ? Math.max(0, Number(parsedStatus.historyMessageCount))
             : null;
@@ -528,9 +848,20 @@ export class CliProviderInstance implements ProviderInstance {
                 : [];
         }
         const mergedMessages = this.mergeConversationMessages(parsedMessages);
-        const canonicalBackedHistory = this.syncCanonicalSavedHistoryIfNeeded();
+        const canonicalBackedHistory = this.shouldHydrateExistingProviderHistory()
+            ? this.syncCanonicalSavedHistoryIfNeeded()
+            : false;
+        const statusMessages = canonicalBackedHistory && this.lastPersistedHistoryMessages.length > 0
+            ? this.lastPersistedHistoryMessages.map((message) => ({
+                role: message.role,
+                content: message.content,
+                kind: message.kind,
+                senderName: message.senderName,
+                receivedAt: message.receivedAt,
+            }))
+            : mergedMessages;
 
-        const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
+        const dirName = workingDirBasename(this.workingDir);
         const parsedChatStatus = typeof parsedStatus?.status === 'string' && parsedStatus.status.trim()
             ? parsedStatus.status.trim()
             : undefined;
@@ -542,7 +873,7 @@ export class CliProviderInstance implements ProviderInstance {
                 && adapterStatus.status === 'idle'
                 && parsedStatus?.status === 'idle';
             let messagesToSave = parsedMessages;
-            if (!suppressStaleParsedBusyStatus && (parsedChatStatus === 'generating' || parsedChatStatus === 'long_generating')) {
+            if (!suppressStaleParsedBusyStatus && (parsedChatStatus === 'generating' || parsedChatStatus === 'no_progress' || parsedChatStatus === 'long_generating')) {
                 const lastIdx = messagesToSave.length - 1;
                 if (lastIdx >= 0 && messagesToSave[lastIdx]?.role === 'assistant') {
                     messagesToSave = messagesToSave.slice(0, lastIdx);
@@ -572,33 +903,48 @@ export class CliProviderInstance implements ProviderInstance {
             }
         }
 
-        this.applyProviderResponse(parsedStatus, { phase: 'immediate' });
+        this.applyProviderResponse(
+            suppressFreshLaunchStartupReplay && parsedStatus && typeof parsedStatus === 'object'
+                ? { ...parsedStatus, providerSessionId: undefined }
+                : parsedStatus,
+            { phase: 'immediate' },
+        );
         const surface = resolveProviderStateSurface({
             summaryMetadata: this.summaryMetadata as any,
             controlValues: this.controlValues,
         });
         const activeChatStatus = parseErrorMessage
             ? 'error'
-            : autoApproveActive && parsedStatus?.status === 'waiting_approval'
+            : (autoApproveActive && parsedStatus?.status === 'waiting_approval') || autoApproveHoldIdle
             ? 'generating'
             : (adapterStatus.status !== 'idle'
                 ? visibleStatus
                 : (suppressStaleParsedBusyStatus ? visibleStatus : (parsedChatStatus || visibleStatus)));
 
+        // If an AskUserQuestion prompt is awaiting user input, overlay status as
+        // waiting_choice. This is distinct from waiting_approval (tool-use consent)
+        // — the engine's isWaitingForResponse state is unchanged, so completion
+        // tracking continues normally once the user responds.
+        const hasInteractivePrompt = !!this.activeInteractivePrompt;
+        const finalStatus = hasInteractivePrompt ? 'waiting_choice' : visibleStatus;
+        const finalChatStatus = hasInteractivePrompt ? 'waiting_choice' : activeChatStatus;
+
         return {
             type: this.type,
             name: this.provider.name,
             category: 'cli',
-            status: visibleStatus,
+            status: finalStatus,
             mode: this.presentationMode,
             activeChat: {
-                id: `${this.type}_${this.workingDir}`,
+                id: activeChatId,
                 title: parsedStatus?.title || dirName,
-                status: activeChatStatus,
-                messages: mergedMessages,
-                activeModal: autoApproveActive ? null : (parsedStatus?.activeModal ?? adapterStatus.activeModal),
+                status: finalChatStatus,
+                messages: statusMessages,
+                activeModal: (autoApproveActive || autoApproveHoldIdle) ? null : (parsedStatus?.activeModal ?? adapterStatus.activeModal),
+                activeInteractivePrompt: this.activeInteractivePrompt,
                 inputContent: '',
             },
+            activeInteractivePrompt: this.activeInteractivePrompt,
             workspace: this.workingDir,
             instanceId: this.instanceId,
             providerSessionId: this.providerSessionId,
@@ -638,8 +984,12 @@ export class CliProviderInstance implements ProviderInstance {
 
     getHotChatSessionState(): HotChatSessionState {
         const adapterStatus = this.adapter.getStatus({ allowParse: false });
-        const autoApproveActive = adapterStatus.status === 'waiting_approval' && this.shouldAutoApprove();
-        const visibleStatus = autoApproveActive ? 'generating' : adapterStatus.status;
+        const nowMs = Date.now();
+        // STATUS-MISMATCH: drop the mask once the auto-approve episode has stalled (see getState).
+        const autoApproveActive = this.autoApproveEffectivelyActive(adapterStatus.status, nowMs)
+            && !this.autoApproveMaskStalled(nowMs);
+        const autoApproveHoldIdle = this.autoApproveBusy && adapterStatus.status === 'idle';
+        const visibleStatus = autoApproveActive || autoApproveHoldIdle ? 'generating' : adapterStatus.status;
         const runtime = this.adapter.getRuntimeMetadata();
         return {
             id: this.instanceId,
@@ -651,36 +1001,275 @@ export class CliProviderInstance implements ProviderInstance {
         };
     }
 
-    getSessionModalState(): SessionModalState {
-        const adapterStatus = this.adapter.getStatus({ allowParse: false });
-        const autoApproveActive = adapterStatus.status === 'waiting_approval' && this.shouldAutoApprove();
-        const visibleStatus = autoApproveActive ? 'generating' : adapterStatus.status;
-        const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
+    getSessionModalState(sessionId?: string): SessionModalState {
+        const adapterStatus = this.adapter.getStatus({ allowParse: true });
+        const nowMs = Date.now();
+        // STATUS-MISMATCH: drop the mask once the auto-approve episode has stalled (see getState).
+        const autoApproveActive = this.autoApproveEffectivelyActive(adapterStatus.status, nowMs)
+            && !this.autoApproveMaskStalled(nowMs);
+        const autoApproveHoldIdle = this.autoApproveBusy && adapterStatus.status === 'idle';
+        const visibleStatus = autoApproveActive || autoApproveHoldIdle ? 'generating' : adapterStatus.status;
+        const dirName = workingDirBasename(this.workingDir);
         return {
-            id: this.instanceId,
+            // Honor the caller-supplied sessionId — InstanceMgr rejects the
+            // projection when projected.id !== requested sessionId, and
+            // this.instanceId is the manager's internal key, not the public
+            // sessionId the dashboard subscribes by.
+            id: sessionId ?? this.instanceId,
             status: visibleStatus,
             title: dirName,
-            activeModal: autoApproveActive ? null : adapterStatus.activeModal,
+            activeModal: (autoApproveActive || autoApproveHoldIdle) ? null : adapterStatus.activeModal,
         };
     }
 
     updateSettings(newSettings: Record<string, any>): void {
-        this.settings = { ...newSettings };
+        // Merge semantics: a key omitted from newSettings preserves its existing
+        // value, a key present in newSettings (even as false) overrides it.
+        //
+        // This is required because updateSettings has two callers with opposite
+        // intent:
+        //   1. Full re-injection — the dashboard toggle path (handleSetProviderSetting
+        //      → getSettings → updateInstanceSettings) sends the COMPLETE settings
+        //      object, so an explicit autoApprove:false must win.
+        //   2. Partial stamp — the mesh relay-safety stamp (router.ts agent_command,
+        //      buildMeshWorkerRelayStamp) sends ONLY {meshNodeFor, meshNodeId,
+        //      meshCoordinatorDaemonId, launchedByCoordinator} on every coordinator
+        //      re-dispatch. It carries no autoApprove, so a full replacement would
+        //      wipe the launch-time autoApprove:true the worker was started with,
+        //      silently dropping every later approval to a manual gate until the
+        //      machine-page toggle re-injected the full settings.
+        //
+        // A plain merge satisfies both: undefined keys fall through to the existing
+        // value (preserving launch-stamp settings like autoApprove + the mesh routing
+        // keys), explicit keys override. This subsumes the previous mesh-key preserve
+        // list, which only protected the routing keys and not autoApprove.
+        this.settings = { ...this.settings, ...newSettings };
         this.adapter.updateRuntimeSettings?.(this.settings);
         this.monitor.updateConfig({
             approvalAlert: this.settings.approvalAlert !== false,
-            longGeneratingAlert: this.settings.longGeneratingAlert !== false,
-            longGeneratingThresholdSec: this.settings.longGeneratingThresholdSec || 180,
+            noProgressAlert: (this.settings.noProgressAlert ?? this.settings.longGeneratingAlert) !== false,
+            noProgressThresholdSec: this.settings.noProgressThresholdSec ?? this.settings.longGeneratingThresholdSec ?? 180,
         });
     }
 
+    /**
+     * Stamp a direct-dispatch mesh assignment on this instance.
+     * setupMeshEventForwarding reads settings.meshNodeFor + meshActiveTaskId to
+     * route generating_completed back to the originating coordinator. Without
+     * this stamp, mesh_send_task --direct targets a plain CLI session whose
+     * completion events silently drop because the forwarder has nothing to
+     * match against.
+     */
+    attachMeshAssignment(assignment: { meshId: string; nodeId?: string; taskId?: string; coordinatorDaemonId?: string; coordinatorSessionId?: string }): void {
+        if (!assignment?.meshId) return;
+        this.settings = {
+            ...this.settings,
+            meshNodeFor: assignment.meshId,
+            // WTCLAIM (A): track the bound node id under BOTH the active marker
+            // (meshNodeId, cleared on detach) and a sticky marker (meshLastNodeId,
+            // preserved across detach). The sticky marker lets a detached but still
+            // coordinator-owned session be re-picked ONLY for the SAME node it served
+            // — never auto-adopted for a sibling node (e.g. a cloned worktree) that
+            // shares this daemon. See isMeshOwnedDelegateSession's post-detach gate.
+            ...(assignment.nodeId ? { meshNodeId: assignment.nodeId, meshLastNodeId: assignment.nodeId } : {}),
+            ...(assignment.taskId ? { meshActiveTaskId: assignment.taskId } : {}),
+            ...(assignment.coordinatorDaemonId ? { meshCoordinatorDaemonId: assignment.coordinatorDaemonId } : {}),
+            // Session-level routing anchor: the originating coordinator session, so this
+            // worker's completion events route back to the exact session that dispatched it.
+            ...(assignment.coordinatorSessionId ? { meshCoordinatorSessionId: assignment.coordinatorSessionId } : {}),
+        };
+        this.adapter.updateRuntimeSettings?.(this.settings);
+    }
+
+    /**
+     * Clear a previously-attached mesh assignment after the task reaches a
+     * terminal state. Leaving meshNodeFor pinned would route this session's
+     * subsequent unrelated turns (e.g. ad-hoc dashboard chats) to the
+     * coordinator as if they were task completions.
+     *
+     * MESHID-DROP-ON-DETACH (Fix C): a coordinator-LAUNCHED worker session
+     * (launchedByCoordinator) holds its mesh membership (meshNodeFor / meshNodeId /
+     * meshCoordinatorDaemonId) at the SESSION level — set once at launch
+     * (mesh_launch_session / queue auto-launch), independent of any single task.
+     * The original detach wiped meshNodeFor + meshNodeId together with the
+     * task-level meshActiveTaskId, so the FIRST task completion stripped the
+     * membership and EVERY subsequent completion forwarded with meshId absent —
+     * resolveWorkerDelegateRouting fell to mesh_unresolved and the coordinator
+     * rejected the forward "meshId required". For a launched member we therefore
+     * clear ONLY the task-level marker (meshActiveTaskId) and preserve the
+     * session-level membership so its next task's completion still resolves.
+     * A task-less ad-hoc turn on a preserved-membership session is NOT misrouted:
+     * its completion carries no taskId and the session holds no active assignment,
+     * so the forwarder's WARMUPGAP guard skips the dispatch-row flip (it only
+     * injects a benign task-less notification). A NON-launched session (a plain CLI
+     * session adopted by mesh_send_task --direct, launchedByCoordinator falsy)
+     * keeps the original full clear so an ad-hoc session is never left pinned.
+     */
+    detachMeshAssignment(): void {
+        if (!this.settings.meshNodeFor && !this.settings.meshActiveTaskId && !this.settings.meshNodeId) return;
+        // Session-level member: keep membership, drop only the task-level marker.
+        if (this.settings.launchedByCoordinator === true) {
+            if (!this.settings.meshActiveTaskId) return;
+            const { meshActiveTaskId, ...rest } = this.settings;
+            void meshActiveTaskId;
+            this.settings = rest;
+            this.adapter.updateRuntimeSettings?.(this.settings);
+            return;
+        }
+        const { meshNodeFor, meshNodeId, meshActiveTaskId, ...rest } = this.settings;
+        void meshNodeFor; void meshActiveTaskId;
+        // WTCLAIM (A): clear the active binding but PRESERVE the last bound node id
+        // (meshLastNodeId) so a later sessionless dispatch can re-adopt this idle
+        // session ONLY for the node it last served. Carry the id being cleared, or
+        // keep an already-present sticky marker if meshNodeId was absent.
+        const lastNodeId = (typeof meshNodeId === 'string' && meshNodeId.trim())
+            ? meshNodeId.trim()
+            : (typeof rest.meshLastNodeId === 'string' && rest.meshLastNodeId.trim() ? rest.meshLastNodeId.trim() : undefined);
+        this.settings = lastNodeId ? { ...rest, meshLastNodeId: lastNodeId } : rest;
+        this.adapter.updateRuntimeSettings?.(this.settings);
+    }
+
+    /**
+     * The resolved modal-park status of this session, or null when it is not
+     * parked on a modal awaiting a human answer. Mirrors the overlay logic in
+     * getState(): an active AskUserQuestion interactive prompt resolves to
+     * waiting_choice; otherwise the adapter's waiting_approval (tool consent)
+     * counts — UNLESS auto-approve will dismiss it, in which case the session is
+     * effectively generating and is NOT modal-parked. This is the single signal
+     * the mesh force-inject guard consults, and the same status string the
+     * reconcile loop reads off get_status_metadata. Lowercase literals only —
+     * the SessionStatus enum is forked across modules and waiting_choice is
+     * absent from some of them.
+     */
+    resolveModalParkStatus(): 'waiting_choice' | 'waiting_approval' | null {
+        if (this.activeInteractivePrompt) return 'waiting_choice';
+        let adapterStatus: { status?: string };
+        try {
+            adapterStatus = this.adapter.getStatus({ allowParse: false });
+        } catch {
+            return null;
+        }
+        // A session whose auto-approve is held by manual attendance IS parked on a
+        // modal awaiting the human — autoApproveEffectivelyActive folds that in, so
+        // the mesh force-inject guard correctly treats it as modal-parked. STATUS-MISMATCH:
+        // a STALLED auto-approve (never resolving) is likewise effectively parked — treat it
+        // as modal-parked so its events are held/surfaced rather than masked behind generating.
+        if (adapterStatus.status === 'waiting_approval'
+            && (!this.autoApproveEffectivelyActive(adapterStatus.status) || this.autoApproveMaskStalled())) {
+            // NOTIF-HELD-DRAIN (Fix 1): an autonomous mesh session (coordinator or worker)
+            // that is actively progressing a turn — a tool call is in flight
+            // (hasAdapterPendingResponse) and NO human is attending it by hand — surfaces a
+            // routine tool-consent `waiting_approval` on EVERY tool call when auto-approve is
+            // off. That transient consent is part of the turn the harness/operator drives to
+            // completion, NOT a session genuinely wedged awaiting a human's modal answer.
+            // Classifying it modal-parked makes findLiveCoordinators hold the mesh's pending
+            // completion events under `modal_parked` across a busy coordinator's whole work
+            // batch, which is the multi-minute notification stall. Treat such a transient
+            // consent as NOT modal-parked so it is held as ordinary "generating" (released on
+            // the next idle) instead. A manually-attended session, a stalled auto-approve, or a
+            // non-progressing session (no turn in flight) still parks — those are the genuine
+            // human-await cases the guard must keep holding.
+            if (this.isTransientToolConsent()) {
+                return null;
+            }
+            return 'waiting_approval';
+        }
+        return null;
+    }
+
+    /**
+     * NOTIF-HELD-DRAIN: true when this `waiting_approval` is a routine, transient tool-consent
+     * of an autonomously-progressing mesh session rather than a genuine human-await modal —
+     * i.e. it is a mesh coordinator/worker session, a turn is actively in flight
+     * (hasAdapterPendingResponse), and no human is attending it by hand. Such a consent is
+     * driven to resolution by the harness/operator as part of the in-flight turn, so holding
+     * the mesh's completion events behind it (modal_parked) is the false-positive that stalls
+     * delivery. Narrow by design: manual attendance or a non-progressing session falls through
+     * to the genuine-modal classification.
+     */
+    private isTransientToolConsent(now = Date.now()): boolean {
+        const isAutonomousMeshSession = this.isMeshWorkerSession() || !!this.settings.meshCoordinatorFor;
+        return isAutonomousMeshSession
+            && this.hasAdapterPendingResponse()
+            && !this.manualAttendance.isAttended(now);
+    }
+
+    /** True when this session is parked on a modal awaiting a human answer. */
+    isModalParked(): boolean {
+        return this.resolveModalParkStatus() !== null;
+    }
+
+    /**
+     * PTY-OVERTRUST-DRAIN (Defect B). The deliverability/drain status the mesh
+     * reconcile loop must consult — the RAW adapter turn-state, with the
+     * auto-approve "hold-idle" visual mask STRIPPED.
+     *
+     * getState().status overlays `autoApproveHoldIdle`/`autoApproveActive` to paint a
+     * genuinely-idle adapter as `generating` (a UI-flicker suppression while an
+     * auto-approve key-press settles — see getState() ~:800). That mask is correct
+     * for the dashboard, but the reconcile loop trusts it as "the coordinator is
+     * busy" and therefore HOLDS a worker's completion under
+     * `generating_no_idle_coordinator` even though the coordinator's PTY is at a real
+     * turn end and would accept the inject as a turn — the completion is stranded.
+     *
+     * This accessor reports the drain truth instead:
+     *   - 'modal_parked' — a GENUINE human-await modal (AskUserQuestion / a non-
+     *     transient tool-consent). Still excluded from drain (a force-inject here
+     *     writes raw keystrokes the modal eats → data corruption). Mirrors
+     *     isModalParked(), evaluated first so a parked session never reads idle.
+     *   - 'idle' — the RAW adapter is at a turn end (adapter.getStatus(allowParse:false)
+     *     === 'idle') and the session is not modal-parked. Drain-eligible REGARDLESS
+     *     of the auto-approve mask. This is the case the mask used to hide.
+     *   - 'generating' — the raw adapter is genuinely mid-turn. Held (a raw PTY write
+     *     into a generating claude-cli is not consumed as a turn → data loss). The
+     *     intentional removal of force-inject-into-generating is preserved.
+     *   - 'other' — any other raw status (error / starting / waiting_choice handled by
+     *     modal-park above). Not a drain target.
+     *
+     * Uses allowParse:false (engine.activeModal only, side-effect-free) so it never
+     * mutates the very auto-approve mask state the diagnostics read.
+     */
+    getDrainStatus(): 'idle' | 'generating' | 'modal_parked' | 'other' {
+        if (this.isModalParked()) return 'modal_parked';
+        let rawStatus: string;
+        try {
+            const raw = this.adapter.getStatus({ allowParse: false })?.status;
+            rawStatus = typeof raw === 'string' ? raw.trim() : '';
+        } catch {
+            return 'other';
+        }
+        if (rawStatus === 'idle') return 'idle';
+        if (isCliGeneratingLikeStatus(rawStatus)) return 'generating';
+        return 'other';
+    }
+
     onEvent(event: string, data?: any): void {
         if (event === 'send_message') {
             const input = normalizeInputEnvelope(data);
             assertProviderSupportsDeclaredInput(this.provider, input);
             const promptText = buildCliStructuredInputPrompt(input);
             if (promptText) {
-                void this.adapter.sendMessage(promptText).catch((e: any) => {
+                // force:true bypasses the busy/generating send guard so terminal mesh
+                // events (completion/failure/bootstrap) land in a coordinator session that
+                // is itself parked in `generating` while awaiting that very event.
+                // Without it the message is queued and only flushed on the coordinator's
+                // own idle transition — which never happens until it receives the message.
+                const force = data?.force === true;
+                // Modal guard: a force-inject still writes raw keystrokes into the PTY,
+                // bypassing the busy send-guard. If the coordinator is parked on a
+                // harness modal (claude-cli AskUserQuestion → waiting_choice, or a
+                // tool-consent waiting_approval), those keystrokes are consumed by the
+                // modal's key handler and silently select a choice the user never made
+                // (data corruption). Hold the force-inject in that narrow window —
+                // the event stays queued and the reconcile loop redelivers it on the
+                // next tick once the modal is resolved. We ONLY hold for the two modal
+                // states; generating is still force-injected (that is the deadlock the
+                // force path exists to break — see mesh-events-coordinator).
+                if (force && this.isModalParked()) {
+                    LOG.info('CLI', `[${this.type}] force send_message held — coordinator parked on modal (${this.resolveModalParkStatus()})`);
+                    return;
+                }
+                void this.adapter.sendMessage(promptText, force ? { force: true } : {}).catch((e: any) => {
                     LOG.warn('CLI', `[${this.type}] send_message failed: ${e?.message || e}`);
                 });
             }
@@ -690,14 +1279,101 @@ export class CliProviderInstance implements ProviderInstance {
             void this.adapter.resolveAction(data).catch((e: any) => {
                 LOG.warn('CLI', `[${this.type}] resolve_action failed: ${e?.message || e}`);
             });
+        } else if (event === 'interactive_prompt' && data) {
+            const prompt = normalizeInteractivePrompt(data);
+            if (prompt) {
+                this.activeInteractivePrompt = prompt;
+                this.events.push({
+                    event: 'interactive_prompt',
+                    timestamp: Date.now(),
+                    promptId: prompt.promptId,
+                });
+            }
+        } else if (event === 'interactive_prompt_response' && data) {
+            try {
+                const response = normalizeInteractivePromptResponse(data);
+                if (this.activeInteractivePrompt?.promptId === response.promptId) {
+                    this.activeInteractivePrompt = null;
+                }
+                if (typeof this.adapter.setInteractivePromptResponse !== 'function') {
+                    LOG.warn('CLI', `[${this.type}] interactive_prompt_response ignored: adapter does not support interactive prompts`);
+                    return;
+                }
+                void this.adapter.setInteractivePromptResponse(response).catch((e: any) => {
+                    LOG.warn('CLI', `[${this.type}] interactive_prompt_response failed: ${e?.message || e}`);
+                });
+            } catch (e: any) {
+                LOG.warn('CLI', `[${this.type}] invalid interactive_prompt_response: ${e?.message || e}`);
+            }
         } else if (event === 'provider_state_patch' && data && typeof data === 'object') {
             this.applyProviderResponse(data, { phase: 'immediate' });
         }
     }
 
+    recordAcknowledgedUserInput(input: InputEnvelope | string): void {
+        const content = typeof input === 'string'
+            ? input.trim()
+            : buildCliStructuredInputPrompt(input).trim();
+        if (!content) return;
+
+        const receivedAt = Date.now();
+
+        // TASKBUBBLE-DUP: collapse a redelivered dispatch to one bubble. A single
+        // mesh_send_task can reach this instance as TWO send_chat calls when the
+        // first injection is buffered during bootstrap/busy and a retry (dispatch-
+        // confirm-timeout requeue, or a reconcile re-dispatch) fires before the
+        // outbound queue drains. The previous dedupKey hashed receivedAt, so the
+        // two acks produced different keys and BOTH bubbled. Suppress an identical
+        // content ack seen within USER_INPUT_ACK_DEDUP_WINDOW_MS; a later resend of
+        // the same text (beyond the window) is a genuine new turn and still shows.
+        const ackContentKey = shortHash(`${this.instanceId}:${content}`, 24);
+        const lastAckAt = this.recentUserInputAcks.get(ackContentKey);
+        if (lastAckAt !== undefined && receivedAt - lastAckAt <= USER_INPUT_ACK_DEDUP_WINDOW_MS) {
+            // Refresh the timestamp so a steady stream of redeliveries keeps
+            // collapsing, and prune stale entries to bound the map size.
+            this.recentUserInputAcks.set(ackContentKey, receivedAt);
+            this.pruneRecentUserInputAcks(receivedAt);
+            return;
+        }
+        this.recentUserInputAcks.set(ackContentKey, receivedAt);
+        this.pruneRecentUserInputAcks(receivedAt);
+
+        this.lastAcknowledgedUserInputAt = receivedAt;
+        // The runtimeMessages dedupKey stays per-call unique (includes receivedAt)
+        // so a genuine resend of the same text after the window appends a fresh
+        // bubble; redelivery within the window is already suppressed above.
+        const dedupKey = `user_input_ack:${shortHash(`${this.instanceId}:${content}:${receivedAt}`, 24)}`;
+        this.appendRuntimeMessage(buildChatMessage({
+            role: 'user',
+            senderName: 'User',
+            kind: 'standard',
+            content,
+            receivedAt,
+            timestamp: receivedAt,
+            source: 'runtime_input_ack',
+            meta: {
+                runtimeInputAck: true,
+                provider: this.type,
+                workspace: this.workingDir,
+            },
+        } as ChatMessage), dedupKey);
+    }
+
+    /** Drop user-input ack entries older than the dedup window so the map can't grow unbounded. */
+    private pruneRecentUserInputAcks(now: number): void {
+        if (this.recentUserInputAcks.size <= 1) return;
+        for (const [key, at] of this.recentUserInputAcks) {
+            if (now - at > USER_INPUT_ACK_DEDUP_WINDOW_MS) this.recentUserInputAcks.delete(key);
+        }
+    }
+
     dispose(): void {
         this.adapter.shutdown();
         this.monitor.reset();
+        // Cancel any armed auto-approve timers so a pending settle re-check
+        // can't fire resolveModal/detectStatusTransition against a dead adapter.
+        if (this.autoApproveSettleTimer) { clearTimeout(this.autoApproveSettleTimer); this.autoApproveSettleTimer = null; }
+        if (this.autoApproveBusyTimer) { clearTimeout(this.autoApproveBusyTimer); this.autoApproveBusyTimer = null; }
         this.appliedEffectKeys.clear();
         try { this.cachedSqliteDb?.close(); } catch { /* noop */ }
         this.cachedSqliteDb = null;
@@ -706,6 +1382,7 @@ export class CliProviderInstance implements ProviderInstance {
 
     private completedDebounceTimer: NodeJS.Timeout | null = null;
     private completedDebouncePending: CompletedDebouncePending | null = null;
+    private lastExternalCompletionProbe: ExternalTranscriptProbe | null = null;
 
     private async enforceFreshSessionLaunchIfNeeded(): Promise<void> {
         const scriptName = getForcedNewSessionScriptName(this.provider, this.launchMode);
@@ -740,7 +1417,191 @@ export class CliProviderInstance implements ProviderInstance {
         const lastVisible = visibleMessages[visibleMessages.length - 1] as ChatMessage | undefined;
         const role = typeof lastVisible?.role === 'string' ? lastVisible.role.trim().toLowerCase() : '';
         const content = lastVisible ? flattenContent(lastVisible.content).trim() : '';
-        return role === 'assistant' && !!content;
+        if (role !== 'assistant' || !content) return false;
+        // Guard: if the last assistant message looks like an active approval/input prompt,
+        // it is not a real completion — the session is still awaiting user input.
+        if (looksLikeActiveApprovalPromptText(content)) return false;
+        return true;
+    }
+
+    private buildExternalTranscriptProbe(messages: unknown[], sourcePath?: string, sourceMtimeMs?: number): ExternalTranscriptProbe {
+        const visibleMessages = messages.filter((message: any) => isUserFacingChatMessage(message as ChatMessage));
+        const lastVisible = visibleMessages[visibleMessages.length - 1] as ChatMessage | undefined;
+        const readAt = Date.now();
+        const mtimeMs = Number(sourceMtimeMs) || 0;
+        return {
+            readAt,
+            msgCount: messages.length,
+            lastRole: typeof lastVisible?.role === 'string' ? lastVisible.role.trim().toLowerCase() : null,
+            lastKind: typeof (lastVisible as any)?.kind === 'string' ? (lastVisible as any).kind : null,
+            contentLen: lastVisible ? flattenContent(lastVisible.content).trim().length : 0,
+            sourcePath: typeof sourcePath === 'string' && sourcePath ? sourcePath : null,
+            sourceMtimeMs: mtimeMs || null,
+            mtimeAgeMs: mtimeMs ? Math.max(0, readAt - mtimeMs) : null,
+        };
+    }
+
+    private recordPendingTranscriptProbe(pending: CompletedDebouncePending): ExternalTranscriptProbe | null {
+        const probe = this.lastExternalCompletionProbe;
+        if (!probe) return null;
+        const history = pending.transcriptProbeHistory || [];
+        const last = history[history.length - 1];
+        if (!last || last.readAt !== probe.readAt || last.msgCount !== probe.msgCount || last.lastRole !== probe.lastRole || last.contentLen !== probe.contentLen) {
+            history.push(probe);
+            pending.transcriptProbeHistory = history.slice(-5);
+        }
+        return probe;
+    }
+
+    private readExternalCompletionMessages(): unknown[] | null {
+        const adapterOwnsMessagesElsewhere = (this.adapter as any)?.chatMessagesOwnedExternally === true;
+        if (!adapterOwnsMessagesElsewhere) return null;
+        if (!this.providerSessionId) return null;
+        if (!isNativeSourceCanonicalHistory(this.provider.nativeHistory)) return null;
+
+        if (this.lastExternalCompletionProbe?.sourcePath) {
+            try { fs.statSync(this.lastExternalCompletionProbe.sourcePath); } catch { /* best-effort metadata refresh */ }
+        }
+        const restoredHistory = readProviderChatHistory(this.type, {
+            canonicalHistory: this.provider.nativeHistory,
+            historySessionId: this.providerSessionId,
+            workspace: this.workingDir,
+            offset: 0,
+            limit: Number.MAX_SAFE_INTEGER,
+            historyBehavior: this.provider.historyBehavior,
+            scripts: this.provider.scripts as any,
+            sessionStartedAtMs: this.startedAt,
+            forceRefresh: true,
+        });
+        if (restoredHistory.source !== 'provider-native') {
+            this.lastExternalCompletionProbe = null;
+            return null;
+        }
+        this.lastExternalCompletionProbe = this.buildExternalTranscriptProbe(
+            restoredHistory.messages,
+            restoredHistory.sourcePath,
+            restoredHistory.sourceMtimeMs,
+        );
+        return restoredHistory.messages;
+    }
+
+    private completionFinalAssistantEvidence(parsedMessages: unknown): CompletionFinalAssistantEvidence {
+        if (this.completionHasFinalAssistantMessage(parsedMessages)) {
+            return {
+                present: true,
+                messages: Array.isArray(parsedMessages) ? parsedMessages : [],
+                source: 'parsed',
+            };
+        }
+
+        const externalMessages = this.readExternalCompletionMessages();
+        if (externalMessages) {
+            return {
+                present: this.completionHasFinalAssistantMessage(externalMessages),
+                messages: externalMessages,
+                source: 'external-native',
+            };
+        }
+
+        return {
+            present: false,
+            messages: Array.isArray(parsedMessages) ? parsedMessages : [],
+            source: 'unavailable',
+        };
+    }
+
+    private completionFinalSummary(parsedMessages: unknown, turnStartedAt?: number): string | undefined {
+        // For native-source providers (claude-cli: chatMessagesOwnedExternally), the PTY
+        // screen parse is NOT the source of truth for the final summary — the terminal
+        // wraps/scrolls/clips text, so a screen-parsed assistant message is often a partial
+        // prefix (e.g. 76 chars of a 112-char turn). The append-only native transcript holds
+        // the complete turn. Prefer it whenever it yields a longer/complete summary; fall back
+        // to the parsed screen only when the transcript is unavailable. This is the real cause
+        // of the truncated finalSummary — independent of cloud vs standalone (it surfaces on
+        // any short, fast-completing task where screen parse wins the race).
+        //
+        // NOTIF Defect-B: `turnStartedAt` (the producing turn's start, snapshotted on the
+        // completedDebouncePending record) turn-scopes the NATIVE transcript read. The native
+        // transcript holds the WHOLE session filtered only by session start, so a debounce that
+        // flushes before the producing turn's final assistant bubble has landed would otherwise
+        // return the PRIOR task's last bubble (event taskId=B but summary=A). Filtering to bubbles
+        // at/after turnStartedAt yields '' in that race instead of the stale tail; the weak/empty
+        // summary is later upgraded by the mesh reconcile loop once the real bubble is written.
+        const adapterOwnsMessagesElsewhere = (this.adapter as any)?.chatMessagesOwnedExternally === true;
+        const parsedSummary = extractFinalSummaryFromMessages(
+            (this.completionHasFinalAssistantMessage(parsedMessages)
+                ? (Array.isArray(parsedMessages) ? parsedMessages : [])
+                : []) as any,
+        );
+        if (adapterOwnsMessagesElsewhere) {
+            const externalMessages = this.readExternalCompletionMessages();
+            // Turn-scope the external transcript: never return a bubble produced before this
+            // turn started. With no boundary known (turnStartedAt falsy) behaviour is unchanged.
+            const externalSummary = externalMessages
+                ? extractFinalSummaryFromMessagesAfter(externalMessages as any, turnStartedAt)
+                : '';
+            // The transcript is authoritative for native-source providers. Use it unless it is
+            // empty (not yet written, or no in-turn bubble) — only then fall back to the screen
+            // parse, which reflects the LIVE screen (this turn's output), not the stale tail.
+            if (externalSummary) return externalSummary;
+            return parsedSummary || undefined;
+        }
+        return parsedSummary || undefined;
+    }
+
+    private buildCompletedFinalizationDiagnostic(args: {
+        blockReason: string;
+        latestStatus?: any;
+        latestVisibleStatus: string;
+        waitedMs: number;
+        pending: CompletedDebouncePending;
+        emittedAfterFinalizationTimeout: boolean;
+    }): Record<string, unknown> {
+        let parsed: any = null;
+        let parseError: string | undefined;
+        try {
+            parsed = this.adapter.getScriptParsedStatus();
+        } catch (error: any) {
+            parseError = error?.message || String(error);
+        }
+
+        const evidence = this.completionFinalAssistantEvidence(parsed?.messages);
+        if (evidence.source === 'external-native') {
+            this.recordPendingTranscriptProbe(args.pending);
+        }
+        const visibleMessages = (Array.isArray(evidence.messages) ? evidence.messages : [])
+            .filter((message: any) => isUserFacingChatMessage(message as ChatMessage));
+        const lastVisible = visibleMessages[visibleMessages.length - 1] as ChatMessage | undefined;
+        const lastVisibleRole = typeof lastVisible?.role === 'string' ? lastVisible.role.trim().toLowerCase() : null;
+        const lastVisibleKind = typeof (lastVisible as any)?.kind === 'string' ? (lastVisible as any).kind : null;
+        const lastVisibleContentLength = lastVisible ? flattenContent(lastVisible.content).trim().length : 0;
+
+        return {
+            providerType: this.type,
+            sessionId: this.instanceId,
+            providerSessionId: this.providerSessionId || null,
+            workspace: this.workingDir,
+            blockReason: args.blockReason,
+            emittedAfterFinalizationTimeout: args.emittedAfterFinalizationTimeout,
+            waitedMs: args.waitedMs,
+            maxWaitMs: COMPLETED_FINALIZATION_MAX_WAIT_MS,
+            adapterStatus: typeof args.latestStatus?.status === 'string' ? args.latestStatus.status : null,
+            latestVisibleStatus: args.latestVisibleStatus,
+            parsedStatus: typeof parsed?.status === 'string' ? parsed.status : (parseError ? 'parse_error' : 'unknown'),
+            parseError: parseError || undefined,
+            finalAssistantPresent: evidence.present,
+            finalAssistantEvidenceSource: evidence.source,
+            visibleMessageCount: visibleMessages.length,
+            lastVisibleRole,
+            lastVisibleKind,
+            lastVisibleContentLength,
+            pendingStartedAt: this.generatingStartedAt || null,
+            pendingFirstObservedAt: args.pending.firstObservedAt,
+            pendingTimestamp: args.pending.timestamp,
+            pendingDurationSec: args.pending.duration,
+            previousBlockReason: args.pending.loggedBlockReason || null,
+            transcriptProbeHistory: args.pending.transcriptProbeHistory || [],
+        };
     }
 
     private hasAdapterPendingResponse(): boolean {
@@ -765,41 +1626,206 @@ export class CliProviderInstance implements ProviderInstance {
         if (!isCliGeneratingLikeStatus(parsedRawStatus)) return false;
         if (adapterRawStatus !== 'idle') return false;
         if (hasNonEmptyCliModalButtons(parsedStatus?.activeModal ?? parsedStatus?.modal)) return false;
-        return !this.hasAdapterPendingResponse();
+        if (this.hasAdapterPendingResponse()) return false;
+        // Do not suppress when the adapter's raw response buffer is still non-empty.
+        // This catches the case where isWaitingForResponse has already flipped to false
+        // (so getPartialResponse() returns '') but the provider's native parser still
+        // reports generating because it's parsing buffered content. Suppressing the
+        // finalization block here would emit a false completion event while the provider
+        // session is still actively processing its response stream.
+        const adapterAny = this.adapter as any;
+        if (typeof adapterAny?.responseBuffer === 'string' && adapterAny.responseBuffer.trim()) return false;
+        return true;
     }
 
-    private getCompletedFinalizationBlockReason(latestVisibleStatus: string): string | null {
-        if (latestVisibleStatus !== 'idle') return `status:${latestVisibleStatus}`;
+    private getCompletedFinalizationBlock(latestVisibleStatus: string, pending: CompletedDebouncePending): CompletedFinalizationBlock | null {
+        if (latestVisibleStatus !== 'idle') return { reason: `status:${latestVisibleStatus}`, terminal: true };
 
         const adapterAny = this.adapter as any;
-        if (adapterAny?.isWaitingForResponse === true) return 'adapter_waiting_for_response';
-        if (adapterAny?.currentTurnScope) return 'adapter_turn_scope_active';
+        const approvalResolvedIdle = pending.previousStatus === 'waiting_approval';
+        if (!approvalResolvedIdle) {
+            if (adapterAny?.isWaitingForResponse === true) return { reason: 'adapter_waiting_for_response', terminal: true };
+            if (adapterAny?.currentTurnScope) return { reason: 'adapter_turn_scope_active', terminal: true };
+            if (this.hasAdapterPendingResponse()) return { reason: 'adapter_pending_response', terminal: true };
+        }
 
         const partial = typeof this.adapter.getPartialResponse === 'function'
             ? this.adapter.getPartialResponse()
             : '';
-        if (typeof partial === 'string' && partial.trim()) return 'partial_response_pending';
+        if (typeof partial === 'string' && partial.trim()) return { reason: 'partial_response_pending', terminal: true };
 
         let parsed: any;
         try {
             parsed = this.adapter.getScriptParsedStatus();
         } catch (error: any) {
-            return `parse_error:${error?.message || String(error)}`;
+            return { reason: `parse_error:${error?.message || String(error)}` };
         }
 
         const parsedStatus = typeof parsed?.status === 'string' ? parsed.status : 'unknown';
-        if (parsedStatus !== 'idle') return `parsed_status:${parsedStatus}`;
-        if (parsed?.activeModal || parsed?.modal) return 'parsed_modal_active';
-        if (!this.completionHasFinalAssistantMessage(parsed?.messages)) return 'missing_final_assistant';
+        if (parsedStatus !== 'idle') {
+            const adapterStatus = this.adapter.getStatus({ allowParse: false });
+            if (this.shouldSuppressStaleParsedBusyStatus(parsed, adapterStatus)) return null;
+            return { reason: `parsed_status:${parsedStatus}`, terminal: isCliGeneratingLikeStatus(parsedStatus) };
+        }
+        if (parsed?.activeModal || parsed?.modal) return { reason: 'parsed_modal_active', terminal: true };
+        const adapterOwnsMessagesElsewhere = (this.adapter as any)?.chatMessagesOwnedExternally === true;
+        const finalAssistantEvidence = this.completionFinalAssistantEvidence(parsed?.messages);
+        const allowMissingAssistantTimeout = !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId || this.settings.launchedByCoordinator);
+        LOG.debug('CLI', `[${this.type}] finalAssistantEvidence: present=${finalAssistantEvidence.present} source=${finalAssistantEvidence.source} adapterOwnsMessagesElsewhere=${adapterOwnsMessagesElsewhere} parsedStatus=${parsedStatus}`);
+        if (!finalAssistantEvidence.present) {
+            if (adapterOwnsMessagesElsewhere) {
+                if (finalAssistantEvidence.source === 'external-native') {
+                    const probe = this.recordPendingTranscriptProbe(pending);
+                    if (probe && !pending.loggedTranscriptProbe) {
+                        LOG.info('CLI', `[${this.type}] external transcript probe: msgCount=${probe.msgCount} lastRole=${probe.lastRole || 'none'} lastKind=${probe.lastKind || 'none'} contentLen=${probe.contentLen} sourceMtime=${probe.sourceMtimeMs ?? 'unknown'} mtimeAge=${probe.mtimeAgeMs ?? 'unknown'}ms`);
+                        pending.loggedTranscriptProbe = true;
+                    }
+                    LOG.debug('CLI', `[${this.type}] external-native probe result: lastRole=${probe?.lastRole} contentLen=${probe?.contentLen}`);
+                    if (probe?.lastRole === 'assistant' && (probe.contentLen ?? 0) > 0) {
+                        return null;
+                    }
+                    if (this.type === 'antigravity-cli') {
+                        return null;
+                    }
+                    // (SETTLE-VALLEY) The inter-approval idle valley: a native-history mesh worker
+                    // that resolved an approval and fell briefly idle (waiting_approval→idle) BEFORE
+                    // the next approval turn resumes. The live valley (~3s) is mostly covered by the
+                    // 4000ms NATIVE_HISTORY_MESH_IDLE_SETTLE_MS settle window, but a longer valley can
+                    // still let the flush run while the transcript's final assistant turn is not yet
+                    // written (source still the screen parse → finalAssistantPresent=false,
+                    // workerResult.source='default'). CANON-C would emit immediately here, freezing a
+                    // truncated preamble summary as evidenceLevel=insufficient. Instead HOLD: this
+                    // waiting_approval hold complements the settle window. Retry until the transcript finalizes
+                    // (block clears → genuine emit) or the worker resumes (resume guard cancels),
+                    // bounded by COMPLETED_FINALIZATION_MAX_WAIT_MS. Scoped to the approval-resolved
+                    // idle so a genuinely-finished background-child turn keeps the CANON-C immediate
+                    // emit (its transcript trails by a write, not by a whole resume).
+                    if (allowMissingAssistantTimeout && pending.previousStatus === 'waiting_approval') {
+                        return { reason: 'missing_final_assistant', terminal: false, holdForTranscript: true };
+                    }
+                    return { reason: 'missing_final_assistant', terminal: true, allowTimeout: allowMissingAssistantTimeout };
+                }
+                if ((this.provider as any).requiresFinalAssistantBeforeIdle === true) {
+                    return { reason: 'missing_final_assistant', terminal: true, allowTimeout: allowMissingAssistantTimeout };
+                }
+            } else {
+                LOG.debug('CLI', `[${this.type}] missing_final_assistant (not ownsExternal) requiresFinalAssistant=${!!(this.provider as any).requiresFinalAssistantBeforeIdle}`);
+                return {
+                    reason: 'missing_final_assistant',
+                    terminal: (this.provider as any).requiresFinalAssistantBeforeIdle === true,
+                    allowTimeout: allowMissingAssistantTimeout,
+                };
+            }
+        }
+
+        // (FALSEIDLE-a) Structural approval-resolution gate. Runs BEFORE the brittle
+        // screen-text heuristic below so it also catches modals whose text does not match
+        // looksLikeActiveApprovalPromptText (e.g. claude-cli's cd / "untrusted hooks" prompt).
+        const approvalResolutionBlock = this.approvalResolutionFinalizationBlock(pending);
+        if (approvalResolutionBlock) return approvalResolutionBlock;
+
+        // Guard: if the screen still shows an approval/choice prompt as the last visible text,
+        // the turn is not complete even if the parsed status says idle and there is an assistant
+        // message. This catches the case where waiting_approval→idle transitions occur before
+        // the modal has been resolved (e.g. the PTY rendered the prompt but no button press fired).
+        try {
+            const screenText = typeof (this.adapter as any).getScreenText === 'function'
+                ? String((this.adapter as any).getScreenText() || '')
+                : '';
+            if (screenText) {
+                const tailLines = screenText.split(/\r?\n/).slice(-16).join('\n');
+                if (looksLikeActiveApprovalPromptText(tailLines)) {
+                    return { reason: 'screen_shows_approval_prompt', terminal: approvalResolvedIdle };
+                }
+            }
+        } catch { /* defensive: screen text read is best-effort */ }
 
         return null;
     }
 
+    // (FALSEIDLE-a) Positive, structural proof that the latest approval entry was resolved
+    // through ADHDev. resolveModal() — driven by auto-approve, dashboard/mesh_approve, and
+    // dev-cli-debug alike — advances the engine's lastResolvedEntrySeq to the current
+    // approvalEntrySeq. So `lastResolvedEntrySeq >= approvalEntrySeq` (with a real entry,
+    // approvalEntrySeq > 0) means the modal we last saw was actually answered. Absence of this
+    // evidence after a waiting_approval→idle transition means the idle is suspect: the spec's
+    // text-based approval→idle rule false-tripped while the modal is still unresolved.
+    // Fails OPEN (returns true) when the seq fields are unavailable, so the gate can never wedge
+    // a session on a provider/adapter that does not surface the counters.
+    private hasApprovalResolutionEvidence(): boolean {
+        try {
+            const status = this.adapter.getStatus({ allowParse: false }) as any;
+            const entrySeq = typeof status?.approvalEntrySeq === 'number' ? status.approvalEntrySeq : 0;
+            if (entrySeq <= 0) return true;
+            const resolvedSeq = typeof status?.lastResolvedEntrySeq === 'number' ? status.lastResolvedEntrySeq : undefined;
+            if (resolvedSeq === undefined) return true;
+            return resolvedSeq >= entrySeq;
+        } catch {
+            return true;
+        }
+    }
+
+    // (FALSEIDLE-a) Hold a completion that is the anomalous DIRECT waiting_approval→idle
+    // transition with no positive resolution evidence. A genuinely resolved approval routes
+    // through resolveModal → setStatus('generating'), so its completion's previousStatus is
+    // 'generating' (not 'waiting_approval') and this gate never fires for it. Scoped to
+    // delegated mesh/coordinator sessions — whose only modal-resolution path is auto-approve /
+    // mesh_approve (both advance lastResolvedEntrySeq) — so an interactive local session, where
+    // a human may answer the PTY prompt directly and leave no resolveModal record, is untouched.
+    // Non-terminal: the hold is bounded by COMPLETED_FINALIZATION_MAX_WAIT_MS (30s), giving a
+    // settling auto-approve time to fire and advance the seq, and guaranteeing no permanent wedge
+    // if resolution ever happens via a path that does not record evidence.
+    private approvalResolutionFinalizationBlock(pending: CompletedDebouncePending): CompletedFinalizationBlock | null {
+        if (pending.previousStatus !== 'waiting_approval') return null;
+        const meshContext = !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId || this.settings.launchedByCoordinator);
+        if (!meshContext) return null;
+        if (this.hasApprovalResolutionEvidence()) return null;
+        return { reason: 'approval_resolution_unconfirmed', terminal: false };
+    }
+
     private scheduleCompletedDebounceFlush(delayMs: number): void {
         if (this.completedDebounceTimer) clearTimeout(this.completedDebounceTimer);
         this.completedDebounceTimer = setTimeout(() => this.flushCompletedDebounceIfFinalized(), delayMs);
     }
 
+    // EVTTRACE (observation-only): is this a mesh worker session whose completion
+    // events must route to a coordinator? Used purely to gate trace logging so a
+    // non-mesh CLI session's completions don't add EvtTrace noise. No decision logic.
+    private isMeshWorkerSession(): boolean {
+        return !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId
+            || this.settings.meshNodeId || this.settings.launchedByCoordinator);
+    }
+
+    /**
+     * ARCH-REFACTOR R1: the taskId to attribute the CURRENTLY-completing turn to.
+     * Prefers the per-turn binding (engine.currentTurnTaskId, set when the turn was
+     * submitted and surviving until the next turn starts) over the last-write-wins
+     * session scalar (settings.meshActiveTaskId). The scalar is retained only as a
+     * backward-compat alias for the "current/last assignment" and is the source of the
+     * NOTIF-MISDELIVER / TASK-MSG-MISROUTE race: a second task attaching before this
+     * turn completes overwrites it. Returns undefined for a non-task ad-hoc turn.
+     */
+    private completingTurnTaskId(): string | undefined {
+        const turnTaskId = this.adapter?.currentTurnTaskId;
+        if (typeof turnTaskId === 'string' && turnTaskId.trim()) return turnTaskId;
+        const scalar = this.settings.meshActiveTaskId;
+        return typeof scalar === 'string' && scalar.trim() ? scalar : undefined;
+    }
+
+    // EVTTRACE correlation context for this session's completion lifecycle. taskId is
+    // the primary grep anchor; instanceId is the session fallback.
+    private meshTraceCtx(event = 'agent:generating_completed'): Record<string, unknown> {
+        return {
+            // ARCH-REFACTOR R1: trace the per-turn taskId (falling back to the scalar) so
+            // EvtTrace anchors on the same id the completion event actually carries.
+            taskId: this.completingTurnTaskId(),
+            sessionId: this.instanceId,
+            nodeId: this.settings.meshNodeId,
+            meshId: this.settings.meshNodeFor,
+            event,
+        };
+    }
+
     private flushCompletedDebounceIfFinalized(): void {
         const pending = this.completedDebouncePending;
         if (!pending) {
@@ -809,7 +1835,8 @@ export class CliProviderInstance implements ProviderInstance {
 
         const latestStatus = this.adapter.getStatus({ allowParse: false });
         const latestAutoApproveActive = latestStatus.status === 'waiting_approval' && this.shouldAutoApprove();
-        const latestVisibleStatus = latestAutoApproveActive ? 'generating' : latestStatus.status;
+        const latestVisibleStatus = latestAutoApproveActive || this.autoApproveBusy ? 'generating' : latestStatus.status;
+        LOG.debug('CLI', `[${this.type}] flush attempt: adapterStatus=${latestStatus.status} latestVisible=${latestVisibleStatus} generatingStartedAt=${this.generatingStartedAt} isWaitingForResponse=${!!(this.adapter as any)?.isWaitingForResponse} hasPartial=${!!this.adapter.getPartialResponse?.()}`);
         if (latestVisibleStatus !== 'idle') {
             LOG.info('CLI', `[${this.type}] cancelled pending completed (resumed ${latestVisibleStatus})`);
             this.completedDebouncePending = null;
@@ -817,84 +1844,514 @@ export class CliProviderInstance implements ProviderInstance {
             return;
         }
 
-        const blockReason = this.getCompletedFinalizationBlockReason(latestVisibleStatus);
-        if (blockReason) {
+        const block = this.getCompletedFinalizationBlock(latestVisibleStatus, pending);
+        if (block) {
+            const blockReason = block.reason;
             const waitedMs = Date.now() - pending.firstObservedAt;
-            if (waitedMs < COMPLETED_FINALIZATION_MAX_WAIT_MS) {
+            // CANON-C (completion-gate decouple): a block carrying `allowTimeout` is the
+            // transcript-evidence gate — the worker FSM has ALREADY reached idle and the only
+            // thing missing is the append-only transcript's final assistant turn (a native-source
+            // race: claude-cli owns its history externally and the file write trails the idle
+            // transition). `allowTimeout` is set ONLY on the missing_final_assistant block, and
+            // ONLY for mesh worker sessions (meshNodeFor / meshActiveTaskId / launchedByCoordinator).
+            // The coordinator's sole path to learn this session is idle is agent:generating_completed,
+            // so holding it up to COMPLETED_FINALIZATION_MAX_WAIT_MS (30s) leaves the coordinator
+            // false-generating while the worker is done. Decouple the idle NOTIFICATION from the
+            // transcript evidence: emit the completion immediately, marked weak
+            // (completionDiagnostic.blockReason=missing_final_assistant, finalAssistantPresent=false).
+            // The finalSummary is enriched on a SEPARATE path — the mesh reconcile loop reads the
+            // transcript once written and re-emits a GENUINE completion (CANON-B weak→genuine
+            // upgrade; buildPendingEventFingerprint keeps weak and genuine distinct so the enriched
+            // one still surfaces, and isFalseIdleCompletion keeps the direct dispatch active until
+            // then). All OTHER blocks (genuinely-busy adapter/partial/parsed states, transient
+            // parse_error) keep the existing terminal-hold / 30s-retry behavior unchanged.
+            //
+            // (SETTLE-VALLEY) Exception: a `holdForTranscript` block is the inter-approval idle
+            // valley of a native-history mesh worker (waiting_approval→idle that will resume into
+            // the next approval). It deliberately does NOT carry allowTimeout, so it falls into the
+            // hold-and-retry path below (terminal:false) rather than the CANON-C immediate emit —
+            // the retry loop re-runs the resume guard each cycle, so when the worker resumes the
+            // pending completion is cancelled, and when the transcript's final assistant arrives the
+            // block clears for a GENUINE emit. This blocks the truncated weak (insufficient) summary
+            // from ever being emitted during the valley, without depending on the valley's length.
+            const isTranscriptEvidenceGate = block.allowTimeout === true;
+            LOG.debug('CLI', `[${this.type}] finalization block: reason=${blockReason} terminal=${block.terminal} allowTimeout=${isTranscriptEvidenceGate} waitedMs=${waitedMs} maxWait=${COMPLETED_FINALIZATION_MAX_WAIT_MS}`);
+            if (!isTranscriptEvidenceGate && (block.terminal || waitedMs < COMPLETED_FINALIZATION_MAX_WAIT_MS)) {
                 if (pending.loggedBlockReason !== blockReason) {
                     LOG.info('CLI', `[${this.type}] waiting to emit completed until transcript finalizes (${blockReason})`);
+                    // EVTTRACE: completion held by the finalization gate (CANON-C). Observation
+                    // only — does not change the hold decision above.
+                    if (this.isMeshWorkerSession()) {
+                        traceMeshEventDrop('completion_gate_hold', this.meshTraceCtx(), `${blockReason} waited=${waitedMs}ms`);
+                    }
                     pending.loggedBlockReason = blockReason;
                 }
                 this.scheduleCompletedDebounceFlush(COMPLETED_FINALIZATION_RETRY_MS);
                 return;
             }
-            LOG.warn('CLI', `[${this.type}] suppressed completed event after ${waitedMs}ms without finalized assistant turn (${blockReason})`);
+            const emittedAfterFinalizationTimeout = waitedMs >= COMPLETED_FINALIZATION_MAX_WAIT_MS;
+            const completionDiagnostic = this.buildCompletedFinalizationDiagnostic({
+                blockReason,
+                latestStatus,
+                latestVisibleStatus,
+                waitedMs,
+                pending,
+                emittedAfterFinalizationTimeout,
+            });
+            // Surface the CANON-C immediate-emit path distinctly so a delegated worker's idle
+            // notification (transcript still pending) is not mistaken for a 30s-timeout fallback.
+            (completionDiagnostic as Record<string, unknown>).decoupledImmediateEmit = isTranscriptEvidenceGate && !emittedAfterFinalizationTimeout;
+            LOG.warn('CLI', `[${this.type}] emitting completed event (${isTranscriptEvidenceGate && !emittedAfterFinalizationTimeout ? 'CANON-C decoupled-immediate, transcript pending' : `after ${waitedMs}ms`}) without finalized assistant turn (${blockReason})`);
+            // EVTTRACE: completion fired (forced past the finalization timeout / CANON-C decoupled-immediate).
+            if (this.isMeshWorkerSession()) {
+                traceMeshEventStage('fired', this.meshTraceCtx(), `forced after ${waitedMs}ms (${blockReason})`);
+            }
+            this.pushEvent({
+                event: 'agent:generating_completed',
+                chatTitle: pending.chatTitle,
+                duration: pending.duration,
+                timestamp: pending.timestamp,
+                // ARCH-REFACTOR R1: attribute to the turn captured at idle-transition.
+                ...(pending.taskId ? { taskId: pending.taskId } : {}),
+                // When finalization is forced past the timeout on a `parsed_status:` block
+                // (the parser never confirmed a final assistant turn) we previously rode an
+                // empty `finalSummary` unconditionally. That empty value propagates to the
+                // mesh coordinator's mirror preview (meshSessionLastMessagePreview), leaving a
+                // delegated session's inbox preview blank — or, for a LOCAL worktree session,
+                // stuck on the dispatched user task. If the parser DID surface assistant text,
+                // prefer it; only fall back to '' when no assistant summary can be derived.
+                finalSummary: blockReason.startsWith('parsed_status:')
+                    ? (this.completionFinalSummary(this.adapter?.getScriptParsedStatus()?.messages, pending.turnStartedAt) ?? '')
+                    : this.completionFinalSummary(this.adapter?.getScriptParsedStatus()?.messages, pending.turnStartedAt),
+                completionDiagnostic,
+            });
             this.completedDebouncePending = null;
             this.completedDebounceTimer = null;
             this.generatingStartedAt = 0;
+            this.lastApprovalEventFingerprint = '';
             return;
         }
 
         LOG.info('CLI', `[${this.type}] completed in ${pending.duration}s`);
+        // EVTTRACE: completion fired (transcript finalized cleanly).
+        if (this.isMeshWorkerSession()) {
+            traceMeshEventStage('fired', this.meshTraceCtx(), `duration=${pending.duration}s`);
+        }
         this.pushEvent({
             event: 'agent:generating_completed',
             chatTitle: pending.chatTitle,
             duration: pending.duration,
             timestamp: pending.timestamp,
-            finalSummary: extractFinalSummaryFromMessages(this.adapter?.getScriptParsedStatus()?.messages),
+            // ARCH-REFACTOR R1: attribute to the turn captured at idle-transition.
+            ...(pending.taskId ? { taskId: pending.taskId } : {}),
+            finalSummary: this.completionFinalSummary(this.adapter?.getScriptParsedStatus()?.messages, pending.turnStartedAt),
         });
         this.completedDebouncePending = null;
         this.completedDebounceTimer = null;
         this.generatingStartedAt = 0;
+        this.lastApprovalEventFingerprint = '';
     }
 
     private maybeAutoApproveStatus(adapterStatus: any, now = Date.now()): boolean {
+        // Manual-attendance suppression (provider-common): when a human is
+        // actively driving this session from the dashboard, hold auto-approve so
+        // the modal stays visible and they can pick a button / use the controlbar
+        // themselves. Return false (NOT auto-approving) so getState keeps the
+        // modal surfaced. Clear any in-progress settle gate — a genuine fire
+        // after the window lapses must re-settle from scratch — and arm a
+        // re-check for the lapse moment, because the PTY may have gone silent and
+        // would otherwise never re-drive this decision. Background mesh workers
+        // are never attended, so their delegated auto-approve is untouched.
+        if (adapterStatus?.status === 'waiting_approval'
+            && this.shouldAutoApprove()
+            && this.manualAttendance.isAttended(now)) {
+            this.lastAutoApprovalSignature = '';
+            this.pendingAutoApprovalSignature = '';
+            this.pendingAutoApprovalSince = 0;
+            this.autoApproveInactiveSince = 0;
+            // Manual attendance takes over — the modal stays surfaced (maybeAutoApproveStatus
+            // returns false), so end the mask episode.
+            this.autoApproveMaskSince = 0;
+            if (this.autoApproveSettleTimer) clearTimeout(this.autoApproveSettleTimer);
+            this.autoApproveSettleTimer = setTimeout(() => {
+                this.autoApproveSettleTimer = null;
+                this.recheckAutoApproveSettled();
+            }, this.manualAttendance.remainingMs(now) + 20);
+            return false;
+        }
         const autoApproveActive = adapterStatus?.status === 'waiting_approval' && this.shouldAutoApprove();
         // Guard re-entry: onStatusChange/getState can observe the same modal multiple
         // times while the PTY absorbs the approval key. Without this flag, repeated
         // snapshots would write stray keys into the input once the modal dismisses.
-        if (autoApproveActive && !this.autoApproveBusy) {
-            this.autoApproveBusy = true;
-            if (this.autoApproveBusyTimer) clearTimeout(this.autoApproveBusyTimer);
-            this.autoApproveBusyTimer = setTimeout(() => {
-                this.autoApproveBusy = false;
-                this.autoApproveBusyTimer = null;
-            }, 2000);
-            const modal = adapterStatus.activeModal;
-            const { index: buttonIndex, label: buttonLabel } = pickApprovalButton(modal?.buttons, this.provider);
-            this.recordAutoApproval(modal?.message, buttonLabel, now);
-            setTimeout(() => {
-                this.adapter.resolveModal(buttonIndex);
-            }, 0);
+        // However, Claude Code can present a second approval immediately after the
+        // first. Resolve a changed modal signature even while the previous write is
+        // still inside the short busy window.
+        if (!autoApproveActive) {
+            this.lastAutoApprovalSignature = '';
+            // Hysteresis: if a settle gate is mid-progress, a momentary
+            // status!=waiting_approval blip (a generating flip while the same
+            // modal's button block is still on screen) must NOT wipe the settle
+            // clock — otherwise the modal→generating→modal flap restarts the
+            // 600ms window every time and auto-approve never fires. Keep the
+            // gate warm for AUTO_APPROVE_GATE_HYSTERESIS_MS; re-arm a timer so
+            // that if the modal does NOT come back the gate is cleared on the
+            // re-check (a genuine resolution → idle frees the gate normally).
+            if (this.pendingAutoApprovalSince) {
+                if (!this.autoApproveInactiveSince) this.autoApproveInactiveSince = now;
+                const goneForMs = now - this.autoApproveInactiveSince;
+                if (goneForMs < CliProviderInstance.AUTO_APPROVE_GATE_HYSTERESIS_MS) {
+                    if (this.autoApproveSettleTimer) clearTimeout(this.autoApproveSettleTimer);
+                    this.autoApproveSettleTimer = setTimeout(() => {
+                        this.autoApproveSettleTimer = null;
+                        this.recheckAutoApproveSettled();
+                    }, CliProviderInstance.AUTO_APPROVE_GATE_HYSTERESIS_MS - goneForMs + 20);
+                    return autoApproveActive;
+                }
+            }
+            // Clear the settle gate so the next approval starts its own quiet
+            // window from scratch (a stale timestamp would let it fire instantly).
+            this.pendingAutoApprovalSignature = '';
+            this.pendingAutoApprovalSince = 0;
+            this.autoApproveInactiveSince = 0;
+            // Modal has genuinely been gone past the hysteresis window → the episode ended;
+            // end the mask episode too (a later approval starts a fresh stall clock).
+            this.autoApproveMaskSince = 0;
+            if (this.autoApproveSettleTimer) { clearTimeout(this.autoApproveSettleTimer); this.autoApproveSettleTimer = null; }
+            return autoApproveActive;
+        }
+        // Active approval observed — reset the inactivity tracker so a later
+        // blip starts its hysteresis window fresh.
+        this.autoApproveInactiveSince = 0;
+        // STATUS-MISMATCH: start (or keep) the mask-stall clock for this episode. Set ONLY
+        // when zero so it survives modal-signature changes and hysteresis blips — it measures
+        // the true age of the unresolved auto-approve, not the per-signature settle window.
+        if (!this.autoApproveMaskSince) this.autoApproveMaskSince = now;
+        const modal = adapterStatus.activeModal;
+        // (fix) Do not auto-approve when no concrete modal/buttons are present.
+        // Claude TUI flaps between paints; without this guard adapterStatus
+        // could report status=waiting_approval with activeModal=null (or with
+        // an empty buttons array briefly) and we'd still call
+        // resolveModal(-1) — which used to type "1" into the prompt
+        // repeatedly. Skip until a real modal is captured.
+        const buttons = Array.isArray(modal?.buttons)
+            ? modal.buttons.map((b: any) => String(b || '').trim()).filter(Boolean)
+            : [];
+        if (!modal || buttons.length === 0) {
+            return autoApproveActive;
+        }
+        // Picker/confirm exclusion (provider-common). A /model or /mode picker is
+        // surfaced with status=waiting_approval so the dashboard shows it, but it
+        // has no "correct" answer to auto-pick — blindly selecting the first
+        // option silently switches the model (the "always Opus, before I even
+        // choose" bug). Two independent gates, BOTH must pass to fire:
+        //
+        //   (1) modal_kind — the spec/FSM tells us this is an 'approval' modal,
+        //       not a 'picker'/'confirm'. A modal whose kind is unknown (legacy
+        //       adapter, or a spec that predates modal_kind) reads as 'approval'
+        //       so genuine approvals keep auto-approving; only an explicit
+        //       'picker'/'confirm' is excluded here.
+        //   (2) structural anchor — a real approval offers an affirmative AND a
+        //       decline option (pickApprovalButton finds a positive that isn't a
+        //       decline, and hasNegativeApprovalOption confirms a No/Cancel/Deny
+        //       is present). A model picker ("1. Default  2. Opus  3. Sonnet")
+        //       has no decline, so even an un-migrated picker is caught here.
+        //
+        // Mirrors the SDK v1 detect-status approval heuristic (detect-status.ts).
+        const modalKind = typeof modal?.kind === 'string' ? modal.kind : 'approval';
+        if (modalKind !== 'approval') {
+            // Picker/confirm — leave it for the user; keep the modal surfaced.
+            return autoApproveActive;
+        }
+        const { index: buttonIndex, label: buttonLabel } = pickApprovalButton(buttons, this.provider);
+        if (buttonIndex < 0 || !hasNegativeApprovalOption(buttons)) {
+            // No affirmative matched, or no decline option present (→ not a real
+            // consent prompt, e.g. a picker that slipped past the kind gate).
+            // Surface the modal so the user decides; never pick blindly.
+            return autoApproveActive;
         }
+        // Modal *identity* signature — the question/button set only, NO volatile
+        // counters. This is what the settle gate tracks: the FSM bumps
+        // approvalEntrySeq on every fresh waiting_approval entry, and a
+        // modal→generating→modal flap (the question line scrolled out of the
+        // captured frame while the button block stays) re-enters and bumps it
+        // again. Folding that seq into the settle signature made the 600ms
+        // settle clock restart on every flap, so the modal never stayed stable
+        // long enough to fire — the gate was never satisfied. Identity excludes
+        // the seq so button/seq flap of the SAME modal keeps one settle clock.
+        const modalSignature = [
+            typeof modal?.message === 'string' ? modal.message.trim() : '',
+            buttons.join('|'),
+            buttonIndex,
+        ].join('::');
+        // Busy-window re-entry guard still needs the seq: two DISTINCT
+        // back-to-back approvals can carry identical message/buttons (common
+        // with claude-cli). Without the seq their busy signatures collide and
+        // the 5s busy-window guard below would swallow the second auto-approve,
+        // leaving it stuck. The seq is bumped by the FSM on every fresh
+        // waiting_approval entry, so a new approval always yields a new busy
+        // signature and fires through.
+        const approvalEntrySeq = typeof adapterStatus?.approvalEntrySeq === 'number'
+            ? adapterStatus.approvalEntrySeq
+            : 0;
+        const busySignature = `${approvalEntrySeq}::${modalSignature}`;
+        // Already fired for this exact modal entry and still inside the busy
+        // window — nothing to do (re-entry guard for repeated snapshots of one
+        // modal).
+        if (this.autoApproveBusy && busySignature === this.lastAutoApprovalSignature) {
+            return autoApproveActive;
+        }
+
+        // Settle gate: only fire once this modal identity has been stable for
+        // AUTO_APPROVE_SETTLE_MS. A still-streaming prompt mutates its
+        // message/buttons each frame → new identity → clock restarts, so we
+        // never approve a half-rendered prompt (the "resolves too fast" bug).
+        if (modalSignature !== this.pendingAutoApprovalSignature) {
+            this.pendingAutoApprovalSignature = modalSignature;
+            this.pendingAutoApprovalSince = now;
+        }
+        const settledForMs = now - this.pendingAutoApprovalSince;
+        if (settledForMs < CliProviderInstance.AUTO_APPROVE_SETTLE_MS) {
+            // Not yet settled. Arm a timer to re-check after the remaining quiet
+            // window — the PTY may go silent once the prompt finishes painting,
+            // so there is no guaranteed status-change frame to re-drive us.
+            if (this.autoApproveSettleTimer) clearTimeout(this.autoApproveSettleTimer);
+            this.autoApproveSettleTimer = setTimeout(() => {
+                this.autoApproveSettleTimer = null;
+                this.recheckAutoApproveSettled();
+            }, CliProviderInstance.AUTO_APPROVE_SETTLE_MS - settledForMs + 20);
+            return autoApproveActive;
+        }
+
+        // Settled — fire the approve key.
+        if (this.autoApproveSettleTimer) { clearTimeout(this.autoApproveSettleTimer); this.autoApproveSettleTimer = null; }
+        this.autoApproveBusy = true;
+        this.lastAutoApprovalSignature = busySignature;
+        this.pendingAutoApprovalSignature = '';
+        this.pendingAutoApprovalSince = 0;
+        this.autoApproveInactiveSince = 0;
+        // Fired (resolveModal in flight) — the episode resolved; end the mask-stall clock.
+        this.autoApproveMaskSince = 0;
+        if (this.autoApproveBusyTimer) clearTimeout(this.autoApproveBusyTimer);
+        this.autoApproveBusyTimer = setTimeout(() => {
+            this.autoApproveBusy = false;
+            this.autoApproveBusyTimer = null;
+            this.lastAutoApprovalSignature = '';
+        }, 5000);
+        this.recordAutoApproval(modal?.message, buttonLabel, now);
+        setTimeout(() => {
+            this.adapter.resolveModal(buttonIndex);
+        }, 0);
         return autoApproveActive;
     }
 
+    /**
+     * Re-drive the auto-approve check after the settle quiet window elapses.
+     * The PTY may have gone silent once the approval prompt finished painting,
+     * so no status-change frame is guaranteed to re-enter maybeAutoApproveStatus
+     * — this timer-driven re-check picks up the now-settled modal and fires.
+     * Deliberately lighter than detectStatusTransition(): it only re-evaluates
+     * the approval decision; the next real PTY frame refreshes visible status.
+     */
+    private recheckAutoApproveSettled(): void {
+        try {
+            // APPROVAL Defect-C (auto-approve gap): re-probe with a LIVE parse, not the cached
+            // engine snapshot. This timer is the ONLY re-drive when the PTY goes silent after the
+            // approval prompt finishes painting (its whole reason to exist) — but with
+            // allowParse:false it read only engine.activeModal, which the engine's per-frame settle
+            // pass can leave null/stale when the modal arrived between writes. The re-check then saw
+            // no modal and never fired, so the delegated worker's transient/quiet approval was missed
+            // and the coordinator had to step in with a manual mesh_approve. allowParse:true makes
+            // getStatus re-run runDetectStatus/runParseApproval on the current screen buffer (the same
+            // live re-probe the coordinator's resolveAction path uses), recovering the modal so
+            // auto-approve fires on its own. The half-rendered-frame guard (buttons.length===0) and
+            // the settle gate in maybeAutoApproveStatus still protect against firing on a partial modal.
+            const adapterStatus = this.adapter.getStatus({ allowParse: true });
+            this.maybeAutoApproveStatus(adapterStatus, Date.now());
+        } catch { /* adapter gone / transient — next frame retries */ }
+    }
+
+    /**
+     * Emit the queue-claim agent:ready event at most once per session. Both the
+     * boot-time starting→idle one-shot and the fsmReadySeen re-arm call this; the
+     * agentReadyEmitted guard ensures the second caller is a no-op so a worker is
+     * never claimed twice and a queued task is never double-dispatched.
+     */
+    private emitAgentReadyOnce(chatTitle: string, now: number): void {
+        if (this.agentReadyEmitted) return;
+        this.agentReadyEmitted = true;
+        this.pushEvent({ event: 'agent:ready', chatTitle, timestamp: now });
+    }
+
+    /**
+     * GENERATING-BOUNDARY synthetic emit for a first turn that started AND finished
+     * inside the startup-grace window without the FSM ever observing a 'generating'
+     * frame (an unobservably-fast turn). Synthesizes the agent:generating_started +
+     * agent:generating_completed pair so the mesh coordinator learns the worker went
+     * idle. Returns true iff it synthesized.
+     *
+     * Two callers share this defense line:
+     *  - 'startup_grace_fast_collapse' — the starting→idle transition (the FSM whose
+     *    spec lacks/hadn't-synced the starting→busy edge collapses starting→idle
+     *    directly, with no intervening 'generating' frame).
+     *  - 'startup_grace_idle_turn_collapse' — the idle→idle no-status-change poll
+     *    (the launch settle already drained starting→idle BEFORE the first turn, so
+     *    the turn runs+completes while status stays 'idle' the whole time and
+     *    detectStatusTransition never re-enters its change block — the live rc.403
+     *    Probe1 miss).
+     *
+     * False-positive safety (must NOT fire on a benign boot): currentTurnTaskId is
+     * set ONLY by onTurnStarted (a real turn STARTED this boot) and persists past
+     * completion, so it excludes a true idle boot (null) and a queued-pending first
+     * turn that only runs after grace (onTurnStarted not yet called → null).
+     * !hasAdapterPendingResponse() excludes a turn still mid-flight. generating
+     * never armed (generatingStartedAt===0 && !generatingDebouncePending) means the
+     * whole idle→busy→idle never happened for this turn. The once-per-turn guard
+     * (fastCollapseSynthesizedTaskId) keeps the re-polled idle-stayed caller from
+     * re-emitting every poll.
+     */
+    private maybeSynthesizeStartupGraceCollapse(
+        chatTitle: string,
+        now: number,
+        reason: 'startup_grace_fast_collapse' | 'startup_grace_idle_turn_collapse',
+    ): boolean {
+        const startedTurnTaskId = typeof (this.adapter as any)?.currentTurnTaskId === 'string'
+            && (this.adapter as any).currentTurnTaskId.trim()
+            ? (this.adapter as any).currentTurnTaskId as string
+            : undefined;
+        const fastCollapsed = !!startedTurnTaskId
+            && !this.hasAdapterPendingResponse()
+            && !this.generatingStartedAt
+            && !this.generatingDebouncePending;
+        if (!fastCollapsed) return false;
+        // Once-per-turn: the idle-stayed caller re-polls steadily while the session
+        // sits idle; without this guard it would re-emit the pair every poll.
+        if (this.fastCollapseSynthesizedTaskId === startedTurnTaskId) return false;
+
+        let fcFinalSummary: string | undefined;
+        let fcEvidenceSource: CompletionFinalAssistantEvidence['source'] = 'unavailable';
+        try {
+            const parsedMessages = this.adapter?.getScriptParsedStatus()?.messages;
+            const evidence = this.completionFinalAssistantEvidence(parsedMessages);
+            fcEvidenceSource = evidence.source;
+            fcFinalSummary = extractFinalSummaryFromMessages(evidence.messages as any);
+        } catch { /* best-effort */ }
+        const missingEvidence = ((this.provider as any).requiresFinalAssistantBeforeIdle === true || fcEvidenceSource === 'external-native') && !fcFinalSummary;
+        // Mirror the short-generating idle path's suppression: a provider that
+        // requires a final assistant (or external-native history) with NO confirmed
+        // summary and NO mesh context emits nothing — the session is idle with no
+        // confirmed turn, matching startup-blip semantics. With mesh context we still
+        // emit so the coordinator can apply its own timeout/retry logic. Left UNMARKED
+        // so a later poll can retry once the transcript's final assistant lands.
+        const hasMeshContext = !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId || this.settings.launchedByCoordinator);
+        if (missingEvidence && !hasMeshContext) {
+            LOG.info('CLI', `[${this.type}] ${reason} suppressed: missing final assistant evidence, no mesh context (source=${fcEvidenceSource})`);
+            return false;
+        }
+        // Mark BEFORE emitting so a re-entrant poll cannot double-fire.
+        this.fastCollapseSynthesizedTaskId = startedTurnTaskId;
+        LOG.info('CLI', `[${this.type}] ${reason}: synthesizing started+completed (taskId=${startedTurnTaskId} source=${fcEvidenceSource} hadFinalSummary=${!!fcFinalSummary})`);
+        // Retroactive started so the started→completed pair (and the chat bubble) is
+        // well-formed; pushEvent stamps the per-turn taskId for CANON-B ack.
+        this.pushEvent({ event: 'agent:generating_started', chatTitle, timestamp: now });
+        if (this.isMeshWorkerSession()) {
+            traceMeshEventStage('fired', this.meshTraceCtx(), `${reason} (source=${fcEvidenceSource})`);
+        }
+        this.pushEvent({
+            event: 'agent:generating_completed',
+            chatTitle,
+            duration: 0,
+            timestamp: now,
+            finalSummary: fcFinalSummary,
+            completionDiagnostic: {
+                reason,
+                finalAssistantEvidenceSource: fcEvidenceSource,
+                ...(missingEvidence ? { blockReason: 'missing_final_assistant' } : {}),
+            },
+        });
+        return true;
+    }
+
     private detectStatusTransition(): void {
         const now = Date.now();
         // Status-change handling is a hot path: PTY output can fire it many times
         // during long-running CLI sessions. Keep this path on adapter-owned light
         // state only; rich provider parsing is reserved for getState/read_chat.
         const adapterStatus = this.adapter.getStatus({ allowParse: false });
+        const adapterProviderSessionId = normalizeProviderSessionId(
+            this.provider,
+            typeof adapterStatus?.providerSessionId === 'string' ? adapterStatus.providerSessionId : '',
+        );
+        if (adapterProviderSessionId) {
+            this.promoteProviderSessionId(adapterProviderSessionId);
+        }
         const parsedStatus = null;
         const rawStatus = adapterStatus.status;
         const autoApproveActive = this.maybeAutoApproveStatus(adapterStatus, now);
-        const newStatus = autoApproveActive ? 'generating' : rawStatus;
-        const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
+        // During the autoApproveBusy window (2s after firing approval key), the PTY
+        // can briefly report 'idle' before the next generating phase starts. Treat that
+        // transient idle as 'generating' to suppress a spurious agent:generating_completed
+        // push notification. The adapter's status is otherwise authoritative — native
+        // transcript shape does NOT override the FSM's busy/idle decision.
+        const autoApproveHoldIdle = this.autoApproveBusy && rawStatus === 'idle';
+        const newStatus = autoApproveActive || autoApproveHoldIdle ? 'generating' : rawStatus;
+        const dirName = workingDirBasename(this.workingDir);
         const chatTitle = `${this.provider.name} · ${dirName}`;
         const partial = this.adapter.getPartialResponse();
+        // Liveness fingerprint for the no-progress watchdog. The parsed
+        // assistant buffer (`partial`) alone goes static while a tool/build runs
+        // — the assistant emits no tokens even though the PTY is actively
+        // printing tool output — which made the watchdog false-fire a "stuck"
+        // alert mid-turn. Fold in the adapter's raw-activity timestamps so any
+        // visible terminal progress (lastScreenChangeAt) or raw PTY byte
+        // (lastOutputAt) keeps the fingerprint moving. The watchdog then only
+        // survives a genuine stall where nothing at all is happening.
         const progressFingerprint = newStatus === 'generating'
-            ? `${partial || ''}`.slice(-2000)
+            ? `${`${partial || ''}`.slice(-2000)}::scr=${adapterStatus.lastScreenChangeAt ?? 0}::out=${adapterStatus.lastOutputAt ?? 0}`
             : undefined;
 
         const previousStatus = this.lastStatus;
         if (newStatus !== this.lastStatus) {
             LOG.info('CLI', `[${this.type}] status: ${this.lastStatus} → ${newStatus}`);
-            if (this.lastStatus === 'idle' && newStatus === 'generating') {
+            // GENERATING-MISSING (win32 fresh-worktree first-turn): a freshly-launched session
+            // is in 'starting' until its startup-grace settles to idle. When the FIRST inject
+            // lands inside that grace window, the adapter can report status DIRECTLY
+            // starting → generating without an intervening 'idle' frame for
+            // detectStatusTransition() to observe. Previously only the idle→generating arm
+            // armed the bookkeeping, so a starting→generating frame fell straight through to the
+            // bare `this.lastStatus = newStatus` update: generatingStartedAt stayed 0 and no
+            // generating_started was queued. The fast turn's generating→idle completion was then
+            // suppressed by the startup-blip guard below (generatingStartedAt===0 &&
+            // !generatingDebouncePending) — so NO generating_started AND NO generating_completed
+            // ever fired and the mesh coordinator never learned the worker went idle.
+            //
+            // We extend the idle→generating arm to also fire on starting→generating, BUT ONLY
+            // when a real turn is in flight. The adapter script can also report 'generating' from
+            // pure startup PTY noise (no task dispatched) — antigravity/codex/hermes-cli all
+            // exercise that benign starting→generating→idle blip, which must NOT emit a
+            // completion (see "startup-phase spurious completion suppression" tests).
+            // hasAdapterPendingResponse() is the discriminator: a genuine inject sets the
+            // adapter's isWaitingForResponse / currentTurnScope (or leaves a partial response),
+            // whereas startup repaint noise leaves all of them empty. So an armed
+            // starting→generating means "the worker actually started its first turn", and a
+            // bare one stays a suppressed blip via the existing fall-through.
+            const startingToGeneratingWithActiveTurn = this.lastStatus === 'starting'
+                && newStatus === 'generating'
+                && this.hasAdapterPendingResponse();
+            if (((this.lastStatus === 'idle' && newStatus === 'generating') || startingToGeneratingWithActiveTurn)) {
+                // If a completion event is already pending and the turn has ended
+                // (generatingStartedAt===0), the PTY is painting its prompt area
+                // after completing. Ignore this blip — do not cancel the pending
+                // completion and do not advance lastStatus to generating. (On a true
+                // starting→generating the session is fresh: completedDebouncePending is
+                // null, so this blip guard is a no-op and we arm normally below.)
+                if (this.completedDebouncePending && this.generatingStartedAt === 0) {
+                    LOG.debug('CLI', `[${this.type}] ignoring post-completion PTY generating blip (generatingStartedAt=0)`);
+                    return;
+                }
                 this.suppressIdleHistoryReplay = false;
                 // Cancel any pending completed event (multi-step: idle→generating resume)
                 if (this.completedDebouncePending) {
-                    LOG.info('CLI', `[${this.type}] cancelled pending completed (resumed generating)`);
+                    LOG.info('CLI', `[${this.type}] cancelled pending completed (resumed generating) generatingStartedAt=${this.generatingStartedAt} isWaitingForResponse=${!!(this.adapter as any)?.isWaitingForResponse}`);
                     if (this.completedDebounceTimer) { clearTimeout(this.completedDebounceTimer); this.completedDebounceTimer = null; }
                     this.completedDebouncePending = null;
                 }
@@ -926,10 +2383,29 @@ export class CliProviderInstance implements ProviderInstance {
                 if (!this.generatingStartedAt) this.generatingStartedAt = now;
                 const modal = adapterStatus.activeModal;
                 LOG.info('CLI', `[${this.type}] approval modal: "${modal?.message?.slice(0, 80) ?? 'none'}"`);
-                // Only push event if not already in waiting_approval (prevent flood from rapid cycles)
-                const approvalCooldown = 5000;
-                if (this.lastStatus !== 'waiting_approval' && (!this.lastApprovalEventAt || now - this.lastApprovalEventAt > approvalCooldown)) {
-                    this.lastApprovalEventAt = now;
+                // Include the FSM's approval entry seq, mirroring the auto-approve
+                // path (maybeAutoApproveStatus) and resolveModal's sameEntryReResolve
+                // guard. Two distinct back-to-back approvals can carry identical
+                // message/buttons (very common with claude-cli's "Allow Bash
+                // command?"). Without the seq their fingerprints collide and the dedup
+                // below silently drops the second waiting_approval event — it is never
+                // emitted, so it cannot even land in the pending inbox for a later
+                // read_chat reconcile to recover. The seq is bumped by the FSM on every
+                // fresh waiting_approval entry, so a new approval always yields a new
+                // fingerprint and emits.
+                const approvalEntrySeq = typeof adapterStatus?.approvalEntrySeq === 'number'
+                    ? adapterStatus.approvalEntrySeq
+                    : 0;
+                const approvalFingerprint = JSON.stringify({
+                    message: typeof modal?.message === 'string' ? modal.message.trim() : '',
+                    buttons: Array.isArray(modal?.buttons) ? modal.buttons.map((button: unknown) => String(button).trim()) : [],
+                    seq: approvalEntrySeq,
+                });
+                // PTY redraws repeat the same modal content; fingerprint dedup prevents duplicate events.
+                // Do NOT also gate on lastStatus: consecutive approvals can arrive waiting_approval→waiting_approval
+                // (e.g. antigravity-cli resolves one prompt and immediately shows the next) and would be silently dropped.
+                if (approvalFingerprint !== this.lastApprovalEventFingerprint) {
+                    this.lastApprovalEventFingerprint = approvalFingerprint;
                     this.appendRuntimeSystemMessage(
                         this.formatApprovalRequestMessage(modal?.message, modal?.buttons),
                         `approval_request:${now}`,
@@ -941,22 +2417,183 @@ export class CliProviderInstance implements ProviderInstance {
                         modalButtons: modal?.buttons,
                     });
                 }
+            } else if (newStatus === 'generating' && this.lastStatus === 'waiting_approval') {
+                // Approval resolved and the agent resumed work. Defense-in-depth:
+                // clear the approval emit fingerprint here too (not only on
+                // completion at scheduleCompletedDebounceFlush). A subsequent
+                // waiting_approval with the same modal content as the one just
+                // resolved would otherwise collide with the stale fingerprint and be
+                // dropped. The seq in the fingerprint already separates entries; this
+                // reset is a belt-and-suspenders guard for the re-entry case.
+                this.lastApprovalEventFingerprint = '';
             } else if (newStatus === 'idle' && (this.lastStatus === 'generating' || this.lastStatus === 'waiting_approval')) {
                 const duration = this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1000) : 0;
-                // If debounce still pending (generating lasted < 1s), cancel both events
+                // Guard: if generatingStartedAt===0 and no debounce pending, the generating phase
+                // was entered from 'starting' state (startup PTY noise), not from a real idle→generating
+                // task dispatch. The idle→generating handler is the only code path that sets
+                // generatingStartedAt and generatingDebouncePending, so both being absent means no
+                // task was ever dispatched. Suppress the spurious completion event and fall through
+                // to a simple lastStatus update.
+                if (!this.generatingStartedAt && !this.generatingDebouncePending) {
+                    LOG.debug('CLI', `[${this.type}] suppressed startup-phase generating→idle blip (generatingStartedAt=0, no debounce pending)`);
+                } else
+                // If debounce still pending (generating lasted < 1s), cancel both UI events.
+                // Still emit agent:generating_completed so mesh orchestration can record
+                // task_completed for direct dispatches that complete faster than the debounce.
                 if (this.generatingDebouncePending) {
-                    LOG.info('CLI', `[${this.type}] suppressed short generating (${now - this.generatingStartedAt}ms)`);
+                    // NOTIF Defect-2a: shortDurationMs is the REPORTED turn duration, so it must be
+                    // measured from the IMMUTABLE turn start — not generatingStartedAt, which is
+                    // reset to 0 on every mid-turn waiting_approval/idle blip (see :1864/1885/2397/
+                    // 2503/2521) and re-armed on the next →generating, so a long turn that blipped
+                    // would measure only the final 1.5-2.5s sliver. engine.currentTurnStartedAt is
+                    // stamped once at onTurnStarted and persists past mid-turn blips until the next
+                    // turn starts, so it captures the true turn length. generatingStartedAt remains
+                    // the fallback (and the debounce itself stays a pure UI-suppression signal,
+                    // decoupled from the reported duration).
+                    const { durationMs: shortDurationMs, anchor: durationAnchor } = computeTurnAnchoredDurationMs(
+                        (this.adapter as any)?.currentTurnStartedAt,
+                        this.generatingStartedAt,
+                        now,
+                    );
+                    LOG.info('CLI', `[${this.type}] suppressed short generating (${shortDurationMs}ms, anchor=${durationAnchor})`);
                     if (this.generatingDebounceTimer) { clearTimeout(this.generatingDebounceTimer); this.generatingDebounceTimer = null; }
+                    // Emit completion for mesh task association even though the UI generating
+                    // started/completed pair is suppressed (too short for visible UI update).
+                    let shortFinalSummary: string | undefined;
+                    let shortEvidenceSource: CompletionFinalAssistantEvidence['source'] = 'unavailable';
+                    try {
+                        const parsedMessages = this.adapter?.getScriptParsedStatus()?.messages;
+                        const evidence = this.completionFinalAssistantEvidence(parsedMessages);
+                        shortEvidenceSource = evidence.source;
+                        shortFinalSummary = extractFinalSummaryFromMessages(evidence.messages as any);
+                    } catch { /* best-effort */ }
+                    // If a real response is confirmed, retroactively emit started so the chat
+                    // bubble appears even though the debounce suppressed the original event.
+                    if (shortFinalSummary) {
+                        this.pushEvent({ event: 'agent:generating_started', chatTitle, timestamp: now - shortDurationMs });
+                    }
                     this.generatingDebouncePending = null;
                     this.generatingStartedAt = 0;
+                    const missingEvidence = ((this.provider as any).requiresFinalAssistantBeforeIdle === true || shortEvidenceSource === 'external-native') && !shortFinalSummary;
+                    if (missingEvidence) {
+                        LOG.warn('CLI', `[${this.type}] short completion missing final assistant evidence (source=${shortEvidenceSource})`);
+                    }
+                    // When evidence is missing and there is no active mesh task context, suppress
+                    // the completion event. Providers with requiresFinalAssistantBeforeIdle or
+                    // external-native history must confirm a final assistant message before the
+                    // coordinator records task_completed. Only emit here if a mesh task is active
+                    // so the coordinator can apply its own timeout/retry logic.
+                    const hasMeshContext = !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId || this.settings.launchedByCoordinator);
+                    if (missingEvidence && !hasMeshContext) {
+                        LOG.info('CLI', `[${this.type}] short completion suppressed: missing final assistant evidence, no mesh context (source=${shortEvidenceSource})`);
+                        // completedDebouncePending intentionally left null — the session is now idle
+                        // with no confirmed turn, matching the startup-blip suppression semantics.
+                        // (No EvtTrace: not a mesh session, so nothing routes to a coordinator.)
+                    } else {
+                        // EVTTRACE: completion fired (short-generating idle path).
+                        if (this.isMeshWorkerSession()) {
+                            traceMeshEventStage('fired', this.meshTraceCtx(), `short-generating idle (source=${shortEvidenceSource})`);
+                        }
+                        this.pushEvent({
+                            event: 'agent:generating_completed',
+                            chatTitle,
+                            duration: 0,
+                            timestamp: now,
+                            finalSummary: shortFinalSummary,
+                            completionDiagnostic: {
+                                reason: 'short_generating_suppressed',
+                                shortDurationMs,
+                                finalAssistantEvidenceSource: shortEvidenceSource,
+                                ...(missingEvidence ? { blockReason: 'missing_final_assistant' } : {}),
+                            },
+                        });
+                    }
                 } else {
                     // Debounce completed, then require the rich transcript path that read_chat
                     // uses to show an idle turn whose last user-facing message is assistant.
-                    this.completedDebouncePending = { chatTitle, duration, timestamp: now, firstObservedAt: now };
-                    this.scheduleCompletedDebounceFlush(3000);
+                    this.completedDebouncePending = {
+                        chatTitle,
+                        duration,
+                        timestamp: now,
+                        firstObservedAt: now,
+                        previousStatus: this.lastStatus,
+                        // ARCH-REFACTOR R1: snapshot the completing turn's taskId NOW (sync),
+                        // before any follow-up task's flush can start a new turn and move
+                        // engine.currentTurnTaskId.
+                        ...(this.completingTurnTaskId() ? { taskId: this.completingTurnTaskId() } : {}),
+                        // NOTIF Defect-B: snapshot the producing turn's START instant NOW, for the
+                        // same reason as taskId — a follow-up turn moves engine.currentTurnStartedAt.
+                        // Prefer the engine's per-turn start (set at onTurnStarted, earliest reliable
+                        // anchor) and fall back to generatingStartedAt (when generating was observed).
+                        ...((() => {
+                            const engineTurnStart = typeof (this.adapter as any)?.currentTurnStartedAt === 'number'
+                                && Number.isFinite((this.adapter as any).currentTurnStartedAt)
+                                ? (this.adapter as any).currentTurnStartedAt as number
+                                : 0;
+                            const turnStartedAt = engineTurnStart || this.generatingStartedAt || 0;
+                            return turnStartedAt ? { turnStartedAt } : {};
+                        })()),
+                    };
+                    const ownsExternalHistory = !!(this.adapter as any)?.chatMessagesOwnedExternally;
+                    // (FALSEIDLE-BGCHILD-a) Native-history providers flush immediately (the
+                    // transcript is authoritative). For mesh worker sessions, give the
+                    // generating→idle transition a short settle window so a background-child
+                    // false idle (quiet after a backgrounded test/command while the parent turn
+                    // continues) gets caught by the resume guard in flushCompletedDebounceIfFinalized
+                    // instead of firing an early completion the coordinator can never correct.
+                    const meshWorkerSession = this.isMeshWorkerSession();
+                    const flushDelay = ownsExternalHistory
+                        ? (meshWorkerSession ? NATIVE_HISTORY_MESH_IDLE_SETTLE_MS : 0)
+                        : 3000;
+                    LOG.debug('CLI', `[${this.type}] set completedDebouncePending duration=${duration}s ownsExternalHistory=${ownsExternalHistory} meshWorker=${meshWorkerSession} flushDelay=${flushDelay}ms generatingStartedAt=${this.generatingStartedAt}`);
+                    this.scheduleCompletedDebounceFlush(flushDelay);
                 }
             } else if (newStatus === 'idle' && this.lastStatus === 'starting') {
-                this.pushEvent({ event: 'agent:ready', chatTitle, timestamp: now });
+                this.emitAgentReadyOnce(chatTitle, now);
+                // GENERATING-BOUNDARY (R4c): stamp the collapse moment ONCE so the
+                // idle-stayed window below is anchored on the startup-grace collapse,
+                // not on boot. Set only the first time so a later starting re-entry
+                // cannot slide the window forward.
+                if (this.startupGraceCollapseAt === null) this.startupGraceCollapseAt = now;
+                // GENERATING-BOUNDARY fast-collapse (R4, win32 startup-grace first turn):
+                // a turn dispatched into the startup-grace window can START and FINISH while
+                // the FSM is still in 'starting'. On a daemon whose claude-cli spec has NOT yet
+                // synced the starting→busy edge (the primary cure lives in the spec's
+                // idle→busy.from), the FSM never reaches 'busy'/generating, so
+                // detectStatusTransition observes starting→idle DIRECTLY with no intervening
+                // 'generating' frame. The idle→generating arm — the only path that sets
+                // generatingStartedAt and arms the completion — never fired, so the completing
+                // turn's agent:generating_completed is never emitted and the mesh coordinator
+                // never learns the worker went idle. Synthesize the started+completed pair here.
+                //
+                // Discriminator (false-positive safe — must NOT fire on a benign boot):
+                //   adapter.currentTurnTaskId is set ONLY by onTurnStarted (a real turn STARTED
+                //   this boot) and persists past completion, so it cleanly separates the three
+                //   non-firing cases — a true idle boot (no turn → null), a queued-pending
+                //   first turn that only runs AFTER startup-grace drains the composer (onTurnStarted
+                //   not yet called → null; it completes normally later via idle→busy→idle), and a
+                //   turn STILL running at the 8s mark (hasAdapterPendingResponse() still true →
+                //   excluded so we don't fire a premature mid-turn completion; idle→busy self-
+                //   corrects once the FSM reaches idle). We fire only when a turn started AND has
+                //   already finished: started-this-boot && !still-in-flight.
+                this.maybeSynthesizeStartupGraceCollapse(chatTitle, now, 'startup_grace_fast_collapse');
+            } else if (newStatus === 'error') {
+                if (this.generatingDebounceTimer) { clearTimeout(this.generatingDebounceTimer); this.generatingDebounceTimer = null; }
+                this.generatingDebouncePending = null;
+                if (this.completedDebounceTimer) { clearTimeout(this.completedDebounceTimer); this.completedDebounceTimer = null; }
+                this.completedDebouncePending = null;
+                this.errorMessage = adapterStatus.errorMessage || this.errorMessage;
+                this.errorReason = (adapterStatus.errorReason as ProviderErrorReason) || this.errorReason;
+                this.pushEvent({
+                    event: 'agent:stopped',
+                    chatTitle,
+                    timestamp: now,
+                    finalSummary: adapterStatus.errorMessage || adapterStatus.errorReason || 'Provider reported an error',
+                    completionDiagnostic: {
+                        reason: adapterStatus.errorReason || 'provider_error',
+                        errorMessage: adapterStatus.errorMessage || undefined,
+                    },
+                });
             } else if (newStatus === 'stopped') {
                 // Cancel any pending debounce
                 if (this.generatingDebounceTimer) { clearTimeout(this.generatingDebounceTimer); this.generatingDebounceTimer = null; }
@@ -968,6 +2605,79 @@ export class CliProviderInstance implements ProviderInstance {
             this.lastStatus = newStatus;
         }
 
+        // GENERATING-BOUNDARY idle-stayed collapse (R4b): the starting→idle
+        // fast-collapse arm above only fires when the FIRST turn itself drives the
+        // starting→idle transition. When the launch settle already drained
+        // starting→idle BEFORE the first turn arrives, the session is already 'idle'
+        // and a turn that runs+completes inside the startup-grace window — too fast
+        // for any poll to observe a 'generating' frame — produces NO status change
+        // at all (idle→idle). detectStatusTransition's change block above is skipped
+        // entirely, so neither the idle→generating arm nor the starting→idle
+        // fast-collapse arm ever runs, and the mesh coordinator never learns the
+        // worker went idle (the live rc.403 Probe1 miss). Catch it here: an
+        // already-idle poll (no status change), still inside the startup-grace
+        // window, where a turn started this boot and has already finished without
+        // ever arming generating. The same false-positive-safe discriminators apply
+        // (currentTurnTaskId set && !pending && generating never armed), plus a
+        // once-per-turn guard since this branch is re-polled while the session sits
+        // idle. Normal turns that DO reach 'busy' set generatingStartedAt and are
+        // excluded; a queued-pending first turn that only runs after grace falls
+        // outside the window and completes normally via idle→busy→idle.
+        //
+        // R4d (the live rc.405 Probe2 miss): R4c anchored the window on the collapse
+        // moment but still measured its END against `now` (the poll/completion time). The
+        // helper only fires once the turn has FINISHED (!hasAdapterPendingResponse()), so
+        // the first eligible poll happens at completion. When the first turn is dispatched
+        // a few seconds after the collapse AND runs for a non-trivial duration, that
+        // completion lands PAST the 12s now-anchored window even though the turn was a
+        // genuine startup-grace first turn (live: collapse→dispatch +5.2s, turn ~11s →
+        // completion at collapse+16.2s > 12s). Anchor the window on when the first turn
+        // STARTED (engine.currentTurnStartedAt, set by onTurnStarted) instead: a turn that
+        // STARTED within the collapse window is a startup-grace first turn no matter how
+        // long it then ran. The now-anchored check is retained as a union so a fast turn
+        // (dispatched+completed quickly within 12s of collapse) keeps firing too; both
+        // close for a much-later turn, preserving the "don't mislabel a late fast turn"
+        // honesty the window exists for.
+        const firstTurnStartedAt = typeof (this.adapter as any)?.currentTurnStartedAt === 'number'
+            ? (this.adapter as any).currentTurnStartedAt as number
+            : 0;
+        const collapsedAt = this.startupGraceCollapseAt;
+        const turnStartedWithinCollapseWindow = collapsedAt !== null
+            && firstTurnStartedAt > 0
+            && firstTurnStartedAt >= collapsedAt
+            && (firstTurnStartedAt - collapsedAt) < STARTUP_GRACE_IDLE_COLLAPSE_WINDOW_MS;
+        const nowWithinCollapseWindow = collapsedAt !== null
+            && (now - collapsedAt) < STARTUP_GRACE_IDLE_COLLAPSE_WINDOW_MS;
+        if (
+            newStatus === 'idle'
+            && previousStatus === 'idle'
+            && (turnStartedWithinCollapseWindow || nowWithinCollapseWindow)
+        ) {
+            this.maybeSynthesizeStartupGraceCollapse(chatTitle, now, 'startup_grace_idle_turn_collapse');
+        }
+
+        // Re-arm the queue-claim agent:ready on the FSM's first GENUINE ready.
+        //
+        // The boot-time starting→idle one-shot above is the historical claim
+        // trigger, but it is consumed too early for FSM-spec providers whose
+        // INITIAL state already reports status 'idle' (e.g. antigravity-cli): the
+        // adapter reports idle before maybeMarkReady has fired, so lastStatus
+        // advances starting→idle while the prompt is not yet drawn and the worker
+        // cannot yet claim. Subsequent state-driven idle frames are idle→idle (no
+        // status change), so the one-shot never re-fires and the worker strands its
+        // queued task — the coordinator then relaunch-loops every ~90s.
+        //
+        // The adapter surfaces fsmReadySeen=true exactly when the FSM reaches its
+        // first non-initial idle (the prompt is genuinely up). On that signal we
+        // emit agent:ready once more. emitAgentReadyOnce is idempotent (guarded by
+        // agentReadyEmitted), so providers whose boot one-shot already landed on a
+        // real ready (claude-cli / codex-cli / hermes-cli, which use a startup
+        // grace and whose initial state is not idle) treat this as a no-op — no
+        // double claim, no double task injection.
+        if (newStatus === 'idle' && adapterStatus.fsmReadySeen === true && !this.agentReadyEmitted) {
+            this.emitAgentReadyOnce(chatTitle, now);
+        }
+
         this.applyProviderResponse(parsedStatus, {
             phase: (newStatus === 'idle' && (previousStatus === 'generating' || previousStatus === 'waiting_approval'))
                 ? 'turn_completed'
@@ -976,8 +2686,43 @@ export class CliProviderInstance implements ProviderInstance {
 
  // Monitor check (cooldown based notification, IDE/CLI common)
         const agentKey = `${this.type}:cli`;
-        const monitorEvents = this.monitor.check(agentKey, newStatus, now, progressFingerprint);
+        // Approval pending is detected from the raw adapter status, not `newStatus`:
+        // auto-approve synthesizes `waiting_approval` → 'generating', which would
+        // otherwise let the no-progress watchdog accumulate the approval wait.
+        const approvalPending = rawStatus === 'waiting_approval';
+        const monitorEvents = this.monitor.check(agentKey, newStatus, now, progressFingerprint, approvalPending);
+        const monitorParsedStatus: any = parsedStatus;
         for (const me of monitorEvents) {
+            if (
+                me.type === 'monitor:no_progress'
+                && this.completionHasFinalAssistantMessage(monitorParsedStatus?.messages)
+                && !this.hasAdapterPendingResponse()
+                && !hasNonEmptyCliModalButtons(monitorParsedStatus?.activeModal ?? monitorParsedStatus?.modal)
+            ) {
+                // EVTTRACE: completion fired (no-progress monitor reconciled to completion).
+                if (this.isMeshWorkerSession()) {
+                    traceMeshEventStage('fired', this.meshTraceCtx(), 'no_progress_monitor_final_summary');
+                }
+                this.pushEvent({
+                    event: 'agent:generating_completed',
+                    chatTitle,
+                    duration: this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1000) : undefined,
+                    timestamp: me.timestamp,
+                    finalSummary: extractFinalSummaryFromMessages(monitorParsedStatus?.messages),
+                    completionDiagnostic: {
+                        providerType: this.type,
+                        sessionId: this.instanceId,
+                        providerSessionId: this.providerSessionId || null,
+                        reconciliationReason: 'no_progress_monitor_final_summary',
+                        finalAssistantPresent: true,
+                    },
+                });
+                this.generatingStartedAt = 0;
+                // Cancel any pending debounce flush — monitor already fired completion.
+                if (this.completedDebounceTimer) { clearTimeout(this.completedDebounceTimer); this.completedDebounceTimer = null; }
+                this.completedDebouncePending = null;
+                continue;
+            }
             this.pushEvent({ event: me.type, agentKey: me.agentKey, message: me.message, elapsedSec: me.elapsedSec, timestamp: me.timestamp });
         }
     }
@@ -997,15 +2742,61 @@ export class CliProviderInstance implements ProviderInstance {
             workspaceName: typeof event.workspaceName === 'string' && event.workspaceName.trim()
                 ? event.workspaceName
                 : this.workingDir,
+            // Carry the workspace under BOTH `workspace` and `workspaceName` so the
+            // downstream mesh forward/merge path — which reads `workspace` — can
+            // propagate it to the coordinator snapshot. Without `workspace` the live
+            // event path delivers an empty workspace and the dashboard falls back to
+            // the generic "Terminal (Mesh Node)" title.
+            workspace: typeof event.workspace === 'string' && event.workspace.trim()
+                ? event.workspace
+                : this.workingDir,
             providerSessionId: typeof event.providerSessionId === 'string' && event.providerSessionId.trim()
                 ? event.providerSessionId
                 : this.providerSessionId,
         };
+        // TASKIDLESS: stamp the mesh task primary key on lifecycle events emitted by
+        // a mesh worker session. The consumer (updateDirectDispatchStatus) was switched
+        // to key on task_id (CANON-B), but the producer never carried it — so every
+        // forwarded metadataEvent.taskId arrived undefined and the coordinator fell back
+        // to a session_id match, which can flip a sibling dispatch row. Surface it here so
+        // updateDirectDispatchStatus hits the exact PK row and the session_id fallback is
+        // never exercised. Non-mesh sessions get no taskId (regression guard) —
+        // isMeshWorkerSession() gates the injection.
+        //
+        // ARCH-REFACTOR R1 (per-turn identity): resolution order is
+        //   (1) an explicit taskId already on the event — the debounce-flush completion
+        //       path stamps the taskId captured at the generating→idle transition (the
+        //       turn that actually produced this completion);
+        //   (2) the per-turn binding (engine.currentTurnTaskId) for synchronously-emitted
+        //       events whose turn is still the current one;
+        //   (3) the legacy session scalar (settings.meshActiveTaskId) as a last-resort
+        //       backward-compat alias.
+        // The scalar is last because it is last-write-wins: a second task attaching while
+        // this turn was still running overwrites it, which is the exact NOTIF-MISDELIVER /
+        // TASK-MSG-MISROUTE race this refactor removes.
+        if (this.isMeshWorkerSession()) {
+            const existingTaskId = typeof enrichedEvent.taskId === 'string' && enrichedEvent.taskId.trim()
+                ? enrichedEvent.taskId
+                : undefined;
+            if (!existingTaskId) {
+                const resolved = this.completingTurnTaskId();
+                if (resolved) enrichedEvent.taskId = resolved;
+            }
+        }
         if (this.context?.emitProviderEvent) {
             this.context.emitProviderEvent(enrichedEvent);
-            return;
+        } else {
+            this.events.push(enrichedEvent);
+        }
+        // Auto-detach a direct-dispatch mesh assignment once the dispatched
+        // task reaches a terminal state. Leaving meshNodeFor pinned would
+        // route this session's next unrelated turn (a dashboard chat) into
+        // the coordinator as if it were the completion of another task.
+        // We schedule after the emit so the originating coordinator still
+        // observes the completion event with its routing marker intact.
+        if (TERMINAL_MESH_EVENTS.has(event.event) && this.settings.meshActiveTaskId) {
+            try { this.detachMeshAssignment(); } catch { /* best-effort */ }
         }
-        this.events.push(enrichedEvent);
     }
 
     private flushEvents(): ProviderEvent[] {
@@ -1022,7 +2813,13 @@ export class CliProviderInstance implements ProviderInstance {
             typeof data.providerSessionId === 'string' ? data.providerSessionId : '',
         );
         if (patchedProviderSessionId) {
-            this.promoteProviderSessionId(patchedProviderSessionId);
+            // A provider-response id is authoritative when it carries an
+            // explicit `new_session` marker (the CLI genuinely started a new
+            // conversation). Without that marker it's just an observed id and
+            // must not hijack an existing binding (see promoteProviderSessionId).
+            this.promoteProviderSessionId(patchedProviderSessionId, {
+                authoritative: data.sessionEvent === 'new_session',
+            });
         }
 
         if (data.sessionEvent === 'new_session') {
@@ -1151,6 +2948,37 @@ export class CliProviderInstance implements ProviderInstance {
         return false;
     }
 
+    /** @see ProviderInstance.noteManualInteraction */
+    noteManualInteraction(now = Date.now()): void {
+        this.manualAttendance.note(now);
+    }
+
+    /**
+     * Whether auto-approve should be treated as active *right now* for display
+     * and firing decisions: the configured intent AND the user is not currently
+     * attending this session by hand. When a human is attending, auto-approve is
+     * held so the modal stays visible and they can drive it via the controlbar.
+     * Provider-agnostic — the attendance signal is the command set, never any
+     * CLI-specific modal text.
+     */
+    private autoApproveEffectivelyActive(status: string | undefined, now = Date.now()): boolean {
+        return status === 'waiting_approval'
+            && this.shouldAutoApprove()
+            && !this.manualAttendance.isAttended(now);
+    }
+
+    // STATUS-MISMATCH: true once the current auto-approve episode has been masking
+    // waiting_approval behind `generating` for longer than AUTO_APPROVE_MASK_STALL_MS without
+    // resolving (the settle gate never fired). When stalled, the surface mask must be dropped
+    // so read_chat / mesh_status / the dashboard see the real waiting_approval + modal (and a
+    // coordinator can mesh_approve it). autoApproveMaskSince is maintained by
+    // maybeAutoApproveStatus (driven by getState + the recheck timer during a waiting episode);
+    // this read is side-effect-free so getStatusMetadata can consult it too.
+    private autoApproveMaskStalled(now = Date.now()): boolean {
+        return this.autoApproveMaskSince > 0
+            && now - this.autoApproveMaskSince > CliProviderInstance.AUTO_APPROVE_MASK_STALL_MS;
+    }
+
     private recordAutoApproval(modalMessage?: string, buttonLabel?: string, now = Date.now()): void {
         this.appendRuntimeSystemMessage(
             formatAutoApprovalMessage(modalMessage, buttonLabel),
@@ -1238,7 +3066,7 @@ export class CliProviderInstance implements ProviderInstance {
                     receivedAt: normalizedMessage.receivedAt || normalizedMessage.timestamp,
                     historyDedupKey: dedupKey,
                 }],
-                this.adapter.getScriptParsedStatus?.()?.title || this.workingDir.split('/').filter(Boolean).pop() || 'session',
+                this.adapter.getScriptParsedStatus?.()?.title || workingDirBasename(this.workingDir),
                 this.instanceId,
                 this.providerSessionId,
             );
@@ -1258,12 +3086,28 @@ export class CliProviderInstance implements ProviderInstance {
             index,
             source: 'parsed',
         }));
+        const getRole = (message: ChatMessage): string => typeof message.role === 'string'
+            ? message.role.trim().toLowerCase()
+            : '';
         const runtimeEntries: MergeEntry[] = this.runtimeMessages.map((entry, index) => ({
             message: entry.message,
             index: parsedMessages.length + index,
-            source: 'runtime',
+            source: 'runtime' as const,
             runtimeKey: entry.key,
-        }));
+        })).filter((entry) => {
+            const meta = entry.message.meta && typeof entry.message.meta === 'object' && !Array.isArray(entry.message.meta)
+                ? entry.message.meta as Record<string, unknown>
+                : {};
+            if (meta.runtimeInputAck !== true) return true;
+            const runtimeText = flattenContent(entry.message.content).replace(/\s+/g, ' ').trim();
+            if (!runtimeText) return false;
+            return !parsedEntries.some((parsedEntry) => {
+                const parsedRole = getRole(parsedEntry.message);
+                if (parsedRole !== 'user' && parsedRole !== 'human') return false;
+                const parsedText = flattenContent(parsedEntry.message.content).replace(/\s+/g, ' ').trim();
+                return parsedText === runtimeText;
+            });
+        });
         const getTime = (message: ChatMessage): number => {
             const value = typeof message.receivedAt === 'number'
                 ? message.receivedAt
@@ -1273,9 +3117,6 @@ export class CliProviderInstance implements ProviderInstance {
             return Number.isFinite(value) && value > 0 ? value : 0;
         };
 
-        const getRole = (message: ChatMessage): string => typeof message.role === 'string'
-            ? message.role.trim().toLowerCase()
-            : '';
         const isRuntimeOverlay = (entry: MergeEntry): boolean => {
             if (entry.source !== 'runtime') return false;
             const key = typeof entry.runtimeKey === 'string' ? entry.runtimeKey.trim().toLowerCase() : '';
@@ -1332,16 +3173,34 @@ export class CliProviderInstance implements ProviderInstance {
         return lines.join('\n');
     }
 
-    private promoteProviderSessionId(sessionId: string): void {
+    private promoteProviderSessionId(sessionId: string, opts: { authoritative?: boolean } = {}): void {
         const nextSessionId = String(sessionId || '').trim();
         if (!nextSessionId || nextSessionId === this.providerSessionId) return;
 
+        // Sticky binding: once this instance is bound to a provider session,
+        // an *observed* id (one discovered from a status parse or the native
+        // history reader) must NOT hijack the live binding. hermes ≥0.14
+        // spawns a fresh `sessions` row per internal sub-session, so a
+        // newest-wins native read surfaces a different id mid-turn on every
+        // poll; accepting it would re-bind the instance, re-hydrate unbounded
+        // history (daemon saturation) and reset completion detection so the
+        // turn never finalizes. Only an *authoritative* change — the first
+        // bind (no id yet) or an explicit provider `new_session`/resume — may
+        // replace an existing binding. Legitimate resume/new-session paths
+        // pass authoritative:true and are unaffected.
+        if (this.providerSessionId && !opts.authoritative) {
+            LOG.debug('CLI', `[${this.type}] ignoring non-authoritative session id ${nextSessionId} (bound to ${this.providerSessionId})`);
+            return;
+        }
+
         const previousHistorySessionId = this.providerSessionId || this.instanceId;
         const previousProviderSessionId = this.providerSessionId;
         this.providerSessionId = nextSessionId;
         this.historyWriter.promoteHistorySession(this.type, previousHistorySessionId, nextSessionId);
         this.historyWriter.writeSessionStart(this.type, nextSessionId, this.workingDir, this.instanceId);
-        this.restorePersistedHistoryFromCurrentSession();
+        if (this.shouldHydrateExistingProviderHistory()) {
+            this.restorePersistedHistoryFromCurrentSession();
+        }
         this.adapter.updateRuntimeMeta({ providerSessionId: nextSessionId });
         this.onProviderSessionResolved?.({
             instanceId: this.instanceId,
@@ -1354,13 +3213,39 @@ export class CliProviderInstance implements ProviderInstance {
         LOG.info('CLI', `[${this.type}] discovered provider session id: ${nextSessionId}`);
     }
 
-    private syncCanonicalSavedHistoryIfNeeded(): boolean {
+    private shouldHydrateExistingProviderHistory(): boolean {
+        return this.launchMode === 'resume' || this.launchMode === 'manual';
+    }
+
+    private shouldSuppressFreshLaunchStartupReplay(parsedMessages: unknown[], parsedStatus: any, adapterStatus: any, parsedProviderSessionId = ''): boolean {
+        if (this.launchMode !== 'new') return false;
+        if (this.providerSessionId) return false;
+        if (!Array.isArray(parsedMessages) || parsedMessages.length === 0) return false;
+        if (!isIdleStatus(adapterStatus?.status) || !isIdleStatus(parsedStatus?.status)) return false;
+        if (parsedProviderSessionId) return true;
+
+        const newestMessageAt = parsedMessages.reduce<number>((newest, message) => Math.max(newest, getMessageTime(message)), 0);
+
+        // Untimestamped idle parser output during a fresh launch is usually the
+        // provider's last workspace transcript before a new turn exists.
+        return newestMessageAt === 0;
+    }
+
+    private syncCanonicalSavedHistoryIfNeeded(options: { full?: boolean } = {}): boolean {
         if (!this.providerSessionId) return false;
-        const canonicalHistory = this.provider.canonicalHistory;
+        const canonicalHistory = this.provider.nativeHistory;
         if (!canonicalHistory) return false;
 
+        // Per-status-report hydration reads only a bounded tail (snapshot needs at
+        // most the newest 60). The once-per-resume restore path passes full:true
+        // because seedSessionHistory needs the COMPLETE transcript to seed dedup
+        // state. The read-cache key encodes the window so the bounded and full
+        // reads don't share/clobber each other's 2s cache entry.
+        const limit = options.full ? Number.MAX_SAFE_INTEGER : STATUS_HYDRATION_TAIL_LIMIT;
+        const windowTag = options.full ? 'full' : `tail:${STATUS_HYDRATION_TAIL_LIMIT}`;
+
         if (isNativeSourceCanonicalHistory(canonicalHistory)) {
-            const cacheKey = [this.type, this.providerSessionId, this.workingDir].join('\0');
+            const cacheKey = [this.type, this.providerSessionId, this.workingDir, windowTag].join('\0');
             const now = Date.now();
             if (cacheKey === this.lastNativeSourceCanonicalCacheKey && now - this.lastNativeSourceCanonicalCheckAt < 2_000) {
                 return true;
@@ -1373,7 +3258,7 @@ export class CliProviderInstance implements ProviderInstance {
                 historySessionId: this.providerSessionId,
                 workspace: this.workingDir,
                 offset: 0,
-                limit: Number.MAX_SAFE_INTEGER,
+                limit,
                 historyBehavior: this.provider.historyBehavior,
                 scripts: this.provider.scripts as any,
             });
@@ -1390,7 +3275,7 @@ export class CliProviderInstance implements ProviderInstance {
         }
 
         try {
-            const cacheKey = [this.type, this.providerSessionId, this.workingDir, canonicalHistory.mode || 'materialized-mirror'].join('\0');
+            const cacheKey = [this.type, this.providerSessionId, this.workingDir, canonicalHistory.mode || 'materialized-mirror', windowTag].join('\0');
             const now = Date.now();
             if (cacheKey === this.lastNativeSourceCanonicalCacheKey && now - this.lastNativeSourceCanonicalCheckAt < 2_000) {
                 return true;
@@ -1401,7 +3286,14 @@ export class CliProviderInstance implements ProviderInstance {
             if (!materializeProviderNativeHistory(this.type, canonicalHistory, this.providerSessionId, this.workingDir, this.provider.scripts as any)) {
                 return false;
             }
-            const restoredHistory = readChatHistory(this.type, 0, Number.MAX_SAFE_INTEGER, this.providerSessionId, 0, this.provider.historyBehavior);
+            // Bounded by default: the per-status-report path only needs the newest
+            // STATUS_HYDRATION_TAIL_LIMIT messages because the snapshot caps
+            // activeChat.messages to the last 60 (status/normalize.ts) and loads
+            // the rest lazily via read_chat on subscribe. The once-per-resume
+            // restore path passes full:true so seedSessionHistory still sees the
+            // COMPLETE transcript for prefix-dedup seeding. readChatHistory serves
+            // a bounded limit as an O(tail) read.
+            const restoredHistory = readChatHistory(this.type, 0, limit, this.providerSessionId, 0, this.provider.historyBehavior);
             this.lastPersistedHistoryMessages = restoredHistory.messages.map((message) => ({
                 role: message.role,
                 content: message.content,
@@ -1417,10 +3309,13 @@ export class CliProviderInstance implements ProviderInstance {
 
     private restorePersistedHistoryFromCurrentSession(): void {
         if (!this.providerSessionId) return;
-        this.syncCanonicalSavedHistoryIfNeeded();
-        const restoredHistory = isNativeSourceCanonicalHistory(this.provider.canonicalHistory)
+        // Restore is the once-per-resume seeding path: it needs the COMPLETE
+        // transcript so seedSessionHistory can prime dedup state. Pass full so the
+        // hydration read is unbounded here (and only here).
+        this.syncCanonicalSavedHistoryIfNeeded({ full: true });
+        const restoredHistory = isNativeSourceCanonicalHistory(this.provider.nativeHistory)
             ? readProviderChatHistory(this.type, {
-                canonicalHistory: this.provider.canonicalHistory,
+                canonicalHistory: this.provider.nativeHistory,
                 historySessionId: this.providerSessionId,
                 workspace: this.workingDir,
                 offset: 0,