@adhdev/daemon-core 0.9.82-rc.28 → 0.9.82-rc.280

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

@@ -13,15 +13,17 @@ 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 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 type { ChatMessage } from '../types.js';
 import { buildPersistedProviderEffectMessage, normalizeProviderEffects } from './control-effects.js';
-import { formatAutoApprovalMessage, pickApprovalButton } from './approval-utils.js';
+import { formatAutoApprovalMessage, pickApprovalButton, pickAutoApprovalButton, 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';
@@ -40,12 +42,60 @@ type CompletedDebouncePending = {
     duration: number;
     timestamp: number;
     firstObservedAt: number;
+    previousStatus: string;
     loggedBlockReason?: string;
+    loggedTranscriptProbe?: boolean;
+    transcriptProbeHistory?: ExternalTranscriptProbe[];
+};
+
+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;
+};
+
+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;
 
+/** 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',
     'image/jpeg': '.jpg',
@@ -300,6 +350,19 @@ 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;
+
     private adapter: ProviderCliAdapter;
     private context: InstanceContext | null = null;
     private events: ProviderEvent[] = [];
@@ -309,15 +372,25 @@ export class CliProviderInstance implements ProviderInstance {
     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;
     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;
     private lastNativeSourceCanonicalCheckAt = 0;
     private lastNativeSourceCanonicalCacheKey: string | undefined = undefined;
     private cachedSqliteDb: {
@@ -330,6 +403,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 +444,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();
     }
@@ -412,7 +489,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 +563,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 +604,53 @@ 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 autoApproveActive = this.maybeAutoApproveStatus(adapterStatus, Date.now());
+        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,7 +660,18 @@ 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 parsedChatStatus = typeof parsedStatus?.status === 'string' && parsedStatus.status.trim()
@@ -572,33 +715,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,
@@ -639,7 +797,8 @@ 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 autoApproveHoldIdle = this.autoApproveBusy && adapterStatus.status === 'idle';
+        const visibleStatus = autoApproveActive || autoApproveHoldIdle ? 'generating' : adapterStatus.status;
         const runtime = this.adapter.getRuntimeMetadata();
         return {
             id: this.instanceId,
@@ -651,21 +810,41 @@ export class CliProviderInstance implements ProviderInstance {
         };
     }
 
-    getSessionModalState(): SessionModalState {
-        const adapterStatus = this.adapter.getStatus({ allowParse: false });
+    getSessionModalState(sessionId?: string): SessionModalState {
+        const adapterStatus = this.adapter.getStatus({ allowParse: true });
         const autoApproveActive = adapterStatus.status === 'waiting_approval' && this.shouldAutoApprove();
-        const visibleStatus = autoApproveActive ? 'generating' : adapterStatus.status;
+        const autoApproveHoldIdle = this.autoApproveBusy && adapterStatus.status === 'idle';
+        const visibleStatus = autoApproveActive || autoApproveHoldIdle ? 'generating' : adapterStatus.status;
         const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
         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 };
+        const runtimeMeshSettings: Record<string, any> = {};
+        for (const key of [
+            'meshNodeFor',
+            'meshNodeId',
+            'meshActiveTaskId',
+            'meshCoordinatorFor',
+            'meshCoordinatorDaemonId',
+            'meshCoordinatorNodeId',
+            'spawnedSessionVisibility',
+            'launchedByCoordinator',
+        ]) {
+            if (this.settings[key] !== undefined && newSettings[key] === undefined) {
+                runtimeMeshSettings[key] = this.settings[key];
+            }
+        }
+        this.settings = { ...newSettings, ...runtimeMeshSettings };
         this.adapter.updateRuntimeSettings?.(this.settings);
         this.monitor.updateConfig({
             approvalAlert: this.settings.approvalAlert !== false,
@@ -674,13 +853,53 @@ export class CliProviderInstance implements ProviderInstance {
         });
     }
 
+    /**
+     * 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 }): void {
+        if (!assignment?.meshId) return;
+        this.settings = {
+            ...this.settings,
+            meshNodeFor: assignment.meshId,
+            ...(assignment.nodeId ? { meshNodeId: assignment.nodeId } : {}),
+            ...(assignment.taskId ? { meshActiveTaskId: assignment.taskId } : {}),
+            ...(assignment.coordinatorDaemonId ? { meshCoordinatorDaemonId: assignment.coordinatorDaemonId } : {}),
+        };
+        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.
+     */
+    detachMeshAssignment(): void {
+        if (!this.settings.meshNodeFor && !this.settings.meshActiveTaskId && !this.settings.meshNodeId) return;
+        const { meshNodeFor, meshNodeId, meshActiveTaskId, ...rest } = this.settings;
+        void meshNodeFor; void meshNodeId; void meshActiveTaskId;
+        this.settings = rest;
+        this.adapter.updateRuntimeSettings?.(this.settings);
+    }
+
     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;
+                void this.adapter.sendMessage(promptText, force ? { force: true } : {}).catch((e: any) => {
                     LOG.warn('CLI', `[${this.type}] send_message failed: ${e?.message || e}`);
                 });
             }
@@ -690,14 +909,73 @@ 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();
+        this.lastAcknowledgedUserInputAt = receivedAt;
+        const dedupKey = `user_input_ack:${crypto
+            .createHash('sha256')
+            .update(`${this.instanceId}:${content}:${receivedAt}`)
+            .digest('hex')
+            .slice(0, 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);
+    }
+
     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 +984,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 +1019,180 @@ 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): 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).
+        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();
+            const externalSummary = externalMessages
+                ? extractFinalSummaryFromMessages(externalMessages as any)
+                : '';
+            // The transcript is authoritative for native-source providers. Use it unless it is
+            // empty (not yet written) — only then fall back to whatever the screen parsed.
+            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,32 +1217,97 @@ 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;
+                    }
+                    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,
+                };
+            }
+        }
+
+        // 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;
     }
@@ -809,7 +1326,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,10 +1335,12 @@ 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) {
+            LOG.debug('CLI', `[${this.type}] finalization block: reason=${blockReason} terminal=${block.terminal} waitedMs=${waitedMs} maxWait=${COMPLETED_FINALIZATION_MAX_WAIT_MS}`);
+            if ((block.terminal && !block.allowTimeout) || waitedMs < COMPLETED_FINALIZATION_MAX_WAIT_MS) {
                 if (pending.loggedBlockReason !== blockReason) {
                     LOG.info('CLI', `[${this.type}] waiting to emit completed until transcript finalizes (${blockReason})`);
                     pending.loggedBlockReason = blockReason;
@@ -828,10 +1348,29 @@ export class CliProviderInstance implements ProviderInstance {
                 this.scheduleCompletedDebounceFlush(COMPLETED_FINALIZATION_RETRY_MS);
                 return;
             }
-            LOG.warn('CLI', `[${this.type}] suppressed completed event after ${waitedMs}ms without finalized assistant turn (${blockReason})`);
+            const completionDiagnostic = this.buildCompletedFinalizationDiagnostic({
+                blockReason,
+                latestStatus,
+                latestVisibleStatus,
+                waitedMs,
+                pending,
+                emittedAfterFinalizationTimeout: true,
+            });
+            LOG.warn('CLI', `[${this.type}] emitting completed event after ${waitedMs}ms without finalized assistant turn (${blockReason})`);
+            this.pushEvent({
+                event: 'agent:generating_completed',
+                chatTitle: pending.chatTitle,
+                duration: pending.duration,
+                timestamp: pending.timestamp,
+                finalSummary: blockReason.startsWith('parsed_status:')
+                    ? ''
+                    : this.completionFinalSummary(this.adapter?.getScriptParsedStatus()?.messages),
+                completionDiagnostic,
+            });
             this.completedDebouncePending = null;
             this.completedDebounceTimer = null;
             this.generatingStartedAt = 0;
+            this.lastApprovalEventFingerprint = '';
             return;
         }
 
@@ -841,11 +1380,12 @@ export class CliProviderInstance implements ProviderInstance {
             chatTitle: pending.chatTitle,
             duration: pending.duration,
             timestamp: pending.timestamp,
-            finalSummary: extractFinalSummaryFromMessages(this.adapter?.getScriptParsedStatus()?.messages),
+            finalSummary: this.completionFinalSummary(this.adapter?.getScriptParsedStatus()?.messages),
         });
         this.completedDebouncePending = null;
         this.completedDebounceTimer = null;
         this.generatingStartedAt = 0;
+        this.lastApprovalEventFingerprint = '';
     }
 
     private maybeAutoApproveStatus(adapterStatus: any, now = Date.now()): boolean {
@@ -853,33 +1393,137 @@ export class CliProviderInstance implements ProviderInstance {
         // 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 = '';
+            // 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;
+            if (this.autoApproveSettleTimer) { clearTimeout(this.autoApproveSettleTimer); this.autoApproveSettleTimer = null; }
+            return autoApproveActive;
+        }
+        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;
+        }
+        const { index: buttonIndex, label: buttonLabel } = pickAutoApprovalButton(buttons);
+        if (buttonIndex < 0) {
+            // No concrete button matched — don't pick a random index, just
+            // surface the modal so the user can decide.
+            return autoApproveActive;
+        }
+        // Include the FSM's approval entry seq: two distinct back-to-back
+        // approvals can carry identical message/buttons (common with
+        // claude-cli). Without the seq their signatures collide and the 5s
+        // busy-window re-entry guard below swallows 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
+        // signature and fires through.
+        const approvalEntrySeq = typeof adapterStatus?.approvalEntrySeq === 'number'
+            ? adapterStatus.approvalEntrySeq
+            : 0;
+        const signature = [
+            approvalEntrySeq,
+            typeof modal?.message === 'string' ? modal.message.trim() : '',
+            buttons.join('|'),
+            buttonIndex,
+        ].join('::');
+        // Already fired for this exact modal and still inside the busy window —
+        // nothing to do (re-entry guard for repeated snapshots of one modal).
+        if (this.autoApproveBusy && signature === this.lastAutoApprovalSignature) {
+            return autoApproveActive;
+        }
+
+        // Settle gate: only fire once this exact signature has been stable for
+        // AUTO_APPROVE_SETTLE_MS. A still-streaming prompt mutates its
+        // message/buttons each frame → new signature → clock restarts, so we
+        // never approve a half-rendered prompt (the "resolves too fast" bug).
+        if (signature !== this.pendingAutoApprovalSignature) {
+            this.pendingAutoApprovalSignature = signature;
+            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 = signature;
+        this.pendingAutoApprovalSignature = '';
+        this.pendingAutoApprovalSince = 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 {
+            const adapterStatus = this.adapter.getStatus({ allowParse: false });
+            this.maybeAutoApproveStatus(adapterStatus, Date.now());
+        } catch { /* adapter gone / transient — next frame retries */ }
+    }
+
     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;
+        // 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 = this.workingDir.split('/').filter(Boolean).pop() || 'session';
         const chatTitle = `${this.provider.name} · ${dirName}`;
         const partial = this.adapter.getPartialResponse();
@@ -891,10 +1535,18 @@ export class CliProviderInstance implements ProviderInstance {
         if (newStatus !== this.lastStatus) {
             LOG.info('CLI', `[${this.type}] status: ${this.lastStatus} → ${newStatus}`);
             if (this.lastStatus === 'idle' && newStatus === 'generating') {
+                // 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.
+                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 +1578,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 +1612,113 @@ 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)`);
+                    const shortDurationMs = this.generatingStartedAt ? now - this.generatingStartedAt : 0;
+                    LOG.info('CLI', `[${this.type}] suppressed short generating (${shortDurationMs}ms)`);
                     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.
+                    } else {
+                        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,
+                    };
+                    const ownsExternalHistory = !!(this.adapter as any)?.chatMessagesOwnedExternally;
+                    const flushDelay = ownsExternalHistory ? 0 : 3000;
+                    LOG.debug('CLI', `[${this.type}] set completedDebouncePending duration=${duration}s ownsExternalHistory=${ownsExternalHistory} flushDelay=${flushDelay}ms generatingStartedAt=${this.generatingStartedAt}`);
+                    this.scheduleCompletedDebounceFlush(flushDelay);
                 }
             } else if (newStatus === 'idle' && this.lastStatus === 'starting') {
                 this.pushEvent({ event: 'agent:ready', chatTitle, timestamp: now });
+            } 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; }
@@ -977,7 +1739,34 @@ 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);
+        const monitorParsedStatus: any = parsedStatus;
         for (const me of monitorEvents) {
+            if (
+                me.type === 'monitor:long_generating'
+                && this.completionHasFinalAssistantMessage(monitorParsedStatus?.messages)
+                && !this.hasAdapterPendingResponse()
+                && !hasNonEmptyCliModalButtons(monitorParsedStatus?.activeModal ?? monitorParsedStatus?.modal)
+            ) {
+                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: 'long_generating_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 });
         }
     }
@@ -1003,9 +1792,18 @@ export class CliProviderInstance implements ProviderInstance {
         };
         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[] {
@@ -1258,12 +2056,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 +2087,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() : '';
@@ -1341,7 +2152,9 @@ export class CliProviderInstance implements ProviderInstance {
         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,9 +2167,27 @@ export class CliProviderInstance implements ProviderInstance {
         LOG.info('CLI', `[${this.type}] discovered provider session id: ${nextSessionId}`);
     }
 
+    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(): boolean {
         if (!this.providerSessionId) return false;
-        const canonicalHistory = this.provider.canonicalHistory;
+        const canonicalHistory = this.provider.nativeHistory;
         if (!canonicalHistory) return false;
 
         if (isNativeSourceCanonicalHistory(canonicalHistory)) {
@@ -1401,6 +2232,14 @@ export class CliProviderInstance implements ProviderInstance {
             if (!materializeProviderNativeHistory(this.type, canonicalHistory, this.providerSessionId, this.workingDir, this.provider.scripts as any)) {
                 return false;
             }
+            // Full read is intentional: lastPersistedHistoryMessages is the COMPLETE
+            // session transcript — emitted as statusMessages and used as the
+            // prefix-comparison base for incremental appends — so a bounded tail
+            // would both truncate output and break prefix dedup. This is gated to
+            // once-per-2s (cache key above) for resume/manual launches only, so it
+            // does not run on the per-subscribe/per-poll dashboard tail path (that
+            // path goes through handleReadChat → readChatHistory with a bounded
+            // tailLimit, which is now O(tail)).
             const restoredHistory = readChatHistory(this.type, 0, Number.MAX_SAFE_INTEGER, this.providerSessionId, 0, this.provider.historyBehavior);
             this.lastPersistedHistoryMessages = restoredHistory.messages.map((message) => ({
                 role: message.role,
@@ -1418,9 +2257,9 @@ export class CliProviderInstance implements ProviderInstance {
     private restorePersistedHistoryFromCurrentSession(): void {
         if (!this.providerSessionId) return;
         this.syncCanonicalSavedHistoryIfNeeded();
-        const restoredHistory = isNativeSourceCanonicalHistory(this.provider.canonicalHistory)
+        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,