@adhdev/daemon-core 1.0.18-rc.2 → 1.0.18-rc.20

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

@@ -12,11 +12,12 @@ import * as fs from 'fs';
 import { normalizeInputEnvelope, type ProviderModule, flattenContent, type InputEnvelope } 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 { normalizeInteractivePrompt, normalizeInteractivePromptResponse, resolveInteractivePromptResponse, 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 type { MeshSendKeyItem, MeshSendKeyName } from '../cli-adapters/provider-cli-shared.js';
+import { isPurePtyTranscriptProvider } from '../cli-adapters/provider-cli-shared.js';
 import { createCliAdapter } from './spec/route.js';
 import type { PtyRuntimeMetadata, PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import { StatusMonitor } from './status-monitor.js';
@@ -56,8 +57,11 @@ import {
     STATUS_HYDRATION_TAIL_LIMIT,
     COMPLETED_FINALIZATION_RETRY_MS,
     COMPLETED_FINALIZATION_MAX_WAIT_MS,
+    CANON_C_MISSING_ASSISTANT_MIN_ELAPSED_MS,
     NATIVE_HISTORY_MESH_IDLE_SETTLE_MS,
     PTY_PARSED_FINAL_ASSISTANT_QUIET_DWELL_MS,
+    ANTIGRAVITY_HOLD_QUIET_DWELL_MS,
+    ANTIGRAVITY_HOLD_HARD_CAP_MS,
     BACKGROUND_TASK_HOLD_MAX_MS,
     USER_INPUT_ACK_DEDUP_WINDOW_MS,
     STARTUP_GRACE_IDLE_COLLAPSE_WINDOW_MS,
@@ -71,6 +75,7 @@ import type {
 } from './cli-provider-instance-types.js';
 import { mergeConversationMessages, buildExternalTranscriptProbe } from './cli-provider-transcript-merge.js';
 import { getEffectDedupKey, formatApprovalRequestMessage, formatMarkerTimestamp } from './cli-provider-effect-format.js';
+import { resolveProviderAutoApproveMode, type ResolvedAutoApproveMode } from './auto-approve-modes.js';
 
 // Re-export moved public symbols so existing importers (index.ts, tests) keep
 // their `./cli-provider-instance.js` path. Pure move — no behavior change.
@@ -329,6 +334,18 @@ export class CliProviderInstance implements ProviderInstance {
     // MESH_WORKER_STALL_REFIRE_COOLDOWN_MS between successive emissions across
     // anchor re-arms (the per-anchor guard only covers a single continuous stall).
     private meshStallLastFiredAt = -1;
+    // KIMI-MESH-COMPLETION-EMIT (axis 1): the native-source transcript progress
+    // fingerprint (record count + source mtime) observed the LAST time the stall
+    // watchdog checked a native-source provider (transcriptAuthority=provider — e.g.
+    // kimi wire.jsonl). A pure-PTY native-source worker running a long, screen-quiet
+    // tool (no viewport bytes for minutes) looks stalled by the lastOutputAt clock
+    // even though its transcript file is still growing. Before firing the stall, we
+    // compare the current transcript fingerprint against this snapshot; if the
+    // transcript advanced, the "stall" is a false positive of PTY-render stasis, so
+    // we re-arm the anchor instead of paging the coordinator (whose no_progress
+    // handling can lead to the worker being stopped mid-work → completion never
+    // emitted). null = not yet sampled for this session/anchor.
+    private meshStallNativeTranscriptSample: { msgCount: number; sourceMtimeMs: number } | null = null;
     // FALSE-IDLE continuity epoch: monotonically bumped on EVERY entry into a busy
     // phase (→generating or →waiting_approval). The completedDebouncePending snapshots
     // this value at arm time (busyEpochAtArm); the flush guard requires it UNCHANGED
@@ -369,6 +386,18 @@ export class CliProviderInstance implements ProviderInstance {
     private generatingDebounceTimer: NodeJS.Timeout | null = null;
     private generatingDebouncePending: { chatTitle: string; timestamp: number } | null = null;
     private lastApprovalEventFingerprint = '';
+    // INTERACTIVE-PROMPT-PUSH: edge-trigger key for the AskUserQuestion / waiting_choice
+    // notification. An AskUserQuestion prompt is surfaced only as a display-only
+    // `waiting_choice` overlay in getState(); the raw adapter status stays idle/generating,
+    // so detectStatusTransition()'s status-keyed arms never fire and no push-worthy
+    // agent:* event is emitted — the owner misses the "ACTION REQUIRED" prompt when the
+    // app is backgrounded. We emit one agent:waiting_choice on ENTRY into the prompt
+    // state (its own coordinator event, NOT the approval channel — a multi-choice
+    // question is answered with mesh_answer_question, never mesh_approve) carrying the
+    // FULL InteractivePrompt payload, and dedupe on this key so repeated status ticks
+    // with the same prompt do not re-fire. '' means no prompt is currently active
+    // (cleared when the prompt is answered/gone).
+    private lastInteractivePromptEventKey = '';
     private autoApproveBusy = false;
     private autoApproveBusyTimer: NodeJS.Timeout | null = null;
     private lastAutoApprovalSignature = '';
@@ -1260,7 +1289,16 @@ export class CliProviderInstance implements ProviderInstance {
             }
         } else if (event === 'interactive_prompt_response' && data) {
             try {
-                const response = normalizeInteractivePromptResponse(data);
+                // mesh_answer_question (mission f1d25e11) sends a coordinator-friendly answer
+                // form (per-question select by label/index) that must be resolved against the
+                // AUTHORITATIVE active prompt held here. When the active prompt is present and
+                // the promptId matches, resolve it; otherwise fall back to the strict keyed
+                // form (dashboard local answers already send that shape).
+                const response = (this.activeInteractivePrompt
+                    && this.activeInteractivePrompt.promptId === (data as { promptId?: unknown })?.promptId
+                    && Array.isArray((data as { answers?: unknown })?.answers))
+                    ? resolveInteractivePromptResponse(this.activeInteractivePrompt, data)
+                    : normalizeInteractivePromptResponse(data);
                 if (this.activeInteractivePrompt?.promptId === response.promptId) {
                     this.activeInteractivePrompt = null;
                 }
@@ -1394,6 +1432,15 @@ export class CliProviderInstance implements ProviderInstance {
      */
     private lastCompletionSummary: { content: string; receivedAt: number; sourceTimestampMs?: number } | null = null;
 
+    // KIMI-MESH-COMPLETION-EMIT (axis 2, double-emit guard): the (taskId, wall-clock)
+    // of the most recent agent:generating_completed this instance emitted, stamped by
+    // emitGeneratingCompleted. The pre-cleanup completion flush
+    // (flushMeshCompletionBeforeCleanup, driven by cli-manager's exit monitor) reads
+    // this to refuse a SECOND completion for a turn whose completion already fired —
+    // so a worker that finished cleanly and is simply being auto-cleaned never emits a
+    // duplicate. taskId '' covers an ad-hoc (no-task) turn. null = none emitted yet.
+    private lastEmittedCompletion: { taskId: string; at: number } | null = null;
+
     private async enforceFreshSessionLaunchIfNeeded(): Promise<void> {
         const scriptName = getForcedNewSessionScriptName(this.provider, this.launchMode);
         if (!scriptName) return;
@@ -1897,6 +1944,33 @@ export class CliProviderInstance implements ProviderInstance {
         return false;
     }
 
+    // (ANTIGRAVITY-30S-CAP-PREMATURE) Discriminator gating the 30s-cap release of an antigravity
+    // `holdForTranscript` block. Antigravity's idle verdict is PTY-screen-derived but its assistant
+    // answer lands in native-history, which can legitimately lag past COMPLETED_FINALIZATION_MAX_WAIT_MS
+    // (30s) on a long turn. The cap releases on elapsed time, not proof-of-idle, so it force-emitted a
+    // premature weak completion WHILE THE PTY WAS STILL GENERATING. Returns true when the PTY is still
+    // active — i.e. the adapter reports a pending response OR raw PTY output arrived within the last
+    // ANTIGRAVITY_HOLD_QUIET_DWELL_MS — meaning the 30s cap must KEEP HOLDING (the turn is not proven
+    // over). Returns false when the PTY is genuinely quiescent (no pending response AND no recent
+    // output), so a real tool-only turn with no assistant bubble still force-emits a weak completion
+    // rather than wedging. The absolute ANTIGRAVITY_HOLD_HARD_CAP_MS bound is enforced at the call site
+    // so a runaway PTY that never falls quiet still eventually releases. Fails OPEN (returns false =
+    // allow release) when lastOutputAt is unreadable, so the gate can never wedge a session.
+    private antigravityHoldPtyStillActive(): boolean {
+        if (this.hasAdapterPendingResponse()) return true;
+        try {
+            const outStatus = this.adapter.getStatus({ allowParse: false }) as any;
+            const lastOutputAt = typeof outStatus?.lastOutputAt === 'number' && Number.isFinite(outStatus.lastOutputAt)
+                ? outStatus.lastOutputAt as number
+                : undefined;
+            if (typeof lastOutputAt === 'number') {
+                const quietMs = Date.now() - lastOutputAt;
+                if (quietMs < ANTIGRAVITY_HOLD_QUIET_DWELL_MS) return true;
+            }
+        } catch { /* defensive: dwell read is best-effort — fall through to allow release */ }
+        return false;
+    }
+
     private shouldSuppressStaleParsedBusyStatus(parsedStatus: any, adapterStatus: any): boolean {
         const parsedRawStatus = typeof parsedStatus?.status === 'string' ? parsedStatus.status.trim() : '';
         const adapterRawStatus = typeof adapterStatus?.status === 'string' ? adapterStatus.status.trim() : '';
@@ -2045,6 +2119,11 @@ export class CliProviderInstance implements ProviderInstance {
                     reason: 'missing_final_assistant',
                     terminal: (this.provider as any).requiresFinalAssistantBeforeIdle === true,
                     allowTimeout: allowMissingAssistantTimeout,
+                    // PTY-parsed provider (codex-cli): no external transcript trails the idle
+                    // transition, so the CANON-C decoupled emit must observe the min-elapsed floor
+                    // rather than fire at the first-poll waitedMs. (claude-cli's external-native
+                    // branch above is exempt — its transcript legitimately lands moments later.)
+                    noExternalTranscriptSource: true,
                 };
             }
         }
@@ -2348,6 +2427,52 @@ export class CliProviderInstance implements ProviderInstance {
         const stalledMs = now - this.meshStallAnchorAt;
         if (stalledMs < threshold) return;
 
+        // KIMI-MESH-COMPLETION-EMIT (axis 1): transcript-aware stall for native-source
+        // providers. A pure-PTY native-source worker (transcriptAuthority=provider,
+        // e.g. kimi) running a long, screen-quiet tool emits no viewport bytes for
+        // minutes, so the lastOutputAt clock above reads it as stalled — but its
+        // authoritative transcript (wire.jsonl) is still being appended. Firing
+        // monitor:no_progress here surfaces a false stall to the coordinator whose
+        // downstream handling can stop the worker mid-work, killing the emit window
+        // before the real completion propagates. So before firing, sample the native
+        // transcript's progress fingerprint: if it advanced (more records OR a fresher
+        // source mtime) since the last sample, the worker is demonstrably alive — treat
+        // it as progress. Re-arm the anchor to `now` and reset the episode so the clock
+        // restarts from this proven-live moment; only a transcript that is ALSO static
+        // falls through to the genuine-stall fire below. No-op for pure-PTY providers
+        // (sample is null → unchanged behavior).
+        const nativeSample = this.sampleNativeTranscriptProgress();
+        if (nativeSample) {
+            const prev = this.meshStallNativeTranscriptSample;
+            const advanced = !prev
+                || nativeSample.msgCount > prev.msgCount
+                || nativeSample.sourceMtimeMs > prev.sourceMtimeMs;
+            this.meshStallNativeTranscriptSample = nativeSample;
+            if (advanced) {
+                if (this.isMeshWorkerSession()) {
+                    traceMeshEventDrop('mesh_worker_stall_transcript_advancing', this.meshTraceCtx('monitor:no_progress'),
+                        `msgCount=${nativeSample.msgCount} sourceMtime=${nativeSample.sourceMtimeMs} (PTY quiet ${Math.round(stalledMs / 1000)}s but transcript advancing)`);
+                }
+                this.meshStallAnchorAt = now;
+                this.meshStallEmittedForAnchor = false;
+                return;
+            }
+        }
+
+        // KIMI-PURE-PTY-COMPLETION-EMIT (Fix 3): before firing a false stall, check the
+        // pure-PTY class (no native transcript → nativeSample was null above). A finished
+        // pure-PTY worker sits at a static idle prompt with an in-turn final assistant
+        // message but never emitted generating_completed — the status-agnostic watchdog
+        // would misread that quiet as a wedge. If the PTY transcript proves a finished
+        // turn, emit the missing completion and SUPPRESS the stall (mark the anchor
+        // emitted so this static idle is not re-checked every tick). No-op for
+        // native-source providers and for a genuinely mid-turn / wedged worker with no
+        // final assistant → the real stall fires below unchanged.
+        if (this.tryReconcilePurePtyCompletionForStall(observedStatus)) {
+            this.meshStallEmittedForAnchor = true;
+            return;
+        }
+
         // FALSE-STALL-WATCHDOG-OVERFIRE (fix E): per-session refire cooldown. Mark
         // this anchor emitted regardless so a still-static anchor does not re-check
         // every tick, but suppress the actual coordinator notification (and the
@@ -2398,6 +2523,193 @@ export class CliProviderInstance implements ProviderInstance {
         this.meshStallEmittedForAnchor = false;
         this.meshStallTurnActiveLast = undefined;
         this.meshStallLastFiredAt = -1;
+        this.meshStallNativeTranscriptSample = null;
+    }
+
+    /**
+     * KIMI-MESH-COMPLETION-EMIT (axis 1). For a native-source provider
+     * (transcriptAuthority=provider — its authoritative history is an on-disk
+     * transcript file, e.g. kimi's wire.jsonl), sample the transcript's current
+     * progress fingerprint (record count + source-file mtime) WITHOUT parsing the
+     * PTY. Used by the stall watchdog to distinguish "PTY render is quiet but the
+     * worker is still doing long tool work (transcript growing)" from a genuine
+     * wedge. Returns null for a pure-PTY provider (no native source) or when the
+     * source cannot be resolved this tick — the caller then falls back to the
+     * unchanged lastOutputAt-only judgment.
+     *
+     * Generalized on the provider's native-source flag, NOT a hardcoded provider
+     * type, so every current and future pure-PTY long-tool native-source provider
+     * benefits. Cheap enough for the stall path: it runs only at the stall threshold
+     * (≥180s of PTY stasis), never on the routine 5s tick.
+     */
+    private sampleNativeTranscriptProgress(): { msgCount: number; sourceMtimeMs: number } | null {
+        if (!isNativeSourceCanonicalHistory(this.provider?.nativeHistory)) return null;
+        // readExternalCompletionMessages resolves this session's OWN native-source
+        // conversation (providerSessionId / persisted pin / floor claim) and, as a
+        // side effect, refreshes this.lastExternalCompletionProbe with the source
+        // path, mtime, and message count. Reusing it keeps the resolution logic in
+        // one place and immune to the antigravity-style session-id quirks.
+        let messages: unknown[] | null = null;
+        try {
+            messages = this.readExternalCompletionMessages();
+        } catch {
+            return null; // best-effort: an unresolved transcript → fall back to PTY clock
+        }
+        const probe = this.lastExternalCompletionProbe;
+        if (!probe) return null;
+        return {
+            msgCount: typeof probe.msgCount === 'number' ? probe.msgCount : (Array.isArray(messages) ? messages.length : 0),
+            sourceMtimeMs: typeof probe.sourceMtimeMs === 'number' ? probe.sourceMtimeMs : 0,
+        };
+    }
+
+    /**
+     * KIMI-MESH-COMPLETION-EMIT (axis 2). Last-chance completion emit for a mesh
+     * DELEGATED worker whose PTY has already exited (e.g. killed by a false stall)
+     * and is about to be auto-cleaned (cli-manager.startCliExitMonitor →
+     * removeInstance closes the event-emit window forever). If the worker actually
+     * FINISHED its assigned turn — its authoritative native transcript holds a final
+     * assistant message for the injected task — but the completion event never fired
+     * (the stall-kill happened before the FSM's idle transition), emit it now so the
+     * coordinator learns the task completed instead of waiting ~180s for the reconcile
+     * transcript-poll to reclaim it.
+     *
+     * Scope & guards (must all hold to emit):
+     *   • mesh worker session only — a normal standalone session's ordinary exit is
+     *     never synthesized (isMeshWorkerSession()).
+     *   • DOUBLE-EMIT guard — refuse if this turn's completion already fired
+     *     (lastEmittedCompletion matches the current taskId). A worker that completed
+     *     cleanly and is merely being cleaned up never double-emits.
+     *   • evidence gate — reuse the same final-assistant/turn-scoped summary machinery
+     *     as the normal completion path (completionFinalSummary over the native
+     *     transcript). No in-turn assistant summary ⇒ no proof of completion ⇒ leave
+     *     the reclaim path to handle a genuinely-unfinished worker.
+     *
+     * Returns true when a synthetic completion was emitted, false otherwise. Safe to
+     * call unconditionally from the cleanup path.
+     */
+    flushMeshCompletionBeforeCleanup(): boolean {
+        if (!this.isMeshWorkerSession()) return false;
+        const taskId = this.completingTurnTaskId();
+
+        // DOUBLE-EMIT guard: this turn's completion already fired — never re-emit.
+        if (this.lastEmittedCompletion && this.lastEmittedCompletion.taskId === (taskId ?? '')) {
+            return false;
+        }
+
+        // Evidence gate: the injected task's own turn must have genuinely started
+        // (guards against synthesizing a completion off a reused session's stale tail
+        // before this task ran) and the native transcript must hold an in-turn final
+        // assistant summary. turnStartedAt anchors the turn-scoped read.
+        if (!this.injectedTaskHasStartedGenerating()) return false;
+        const turnStartedAt = typeof (this.adapter as any)?.currentTurnStartedAt === 'number'
+            ? (this.adapter as any).currentTurnStartedAt as number
+            : this.meshTaskInjectedAt || undefined;
+        let parsedMessages: unknown;
+        try {
+            parsedMessages = this.adapter?.getScriptParsedStatus?.()?.messages;
+        } catch { parsedMessages = undefined; }
+        let finalSummary: string | undefined;
+        try {
+            finalSummary = this.completionFinalSummary(parsedMessages, turnStartedAt);
+        } catch { finalSummary = undefined; }
+        // No in-turn final assistant evidence → not a proven turn-end. Defer to the
+        // coordinator's reclaim/reconcile path rather than fabricate a completion.
+        if (!finalSummary) return false;
+
+        LOG.warn('CLI', `[${this.type}] emitting pre-cleanup mesh completion for session ${this.instanceId} `
+            + `task=${taskId ?? '(none)'} — PTY exited before the completion event fired but the native transcript `
+            + `shows a finished turn; synthesizing completion so the coordinator is not left waiting for reclaim.`);
+        if (this.isMeshWorkerSession()) {
+            traceMeshEventStage('fired', this.meshTraceCtx(), 'pre_cleanup_transcript_completion');
+        }
+        this.emitGeneratingCompleted({
+            chatTitle: '',
+            duration: undefined,
+            timestamp: Date.now(),
+            taskId,
+            finalSummary,
+            evidenceLevel: 'transcript',
+            completionDiagnostic: { source: 'pre_cleanup_transcript_completion' },
+        });
+        return true;
+    }
+
+    /**
+     * KIMI-PURE-PTY-COMPLETION-EMIT (Fix 3): stall-path completion reconcile for the
+     * PURE-PTY transcript class (kimi and kin — no native transcript, no provider
+     * authority; see isPurePtyTranscriptProvider). Such a worker whose
+     * generating_completed never emitted (the onTurnStarted idle→idle collapse Fix 1
+     * fixes at the source) sits at a STATIC idle prompt: its PTY output stops the
+     * instant the answer is rendered, so the status-agnostic no-progress watchdog
+     * (checkMeshWorkerStall) reads the finished-but-quiet session as a stall and would
+     * false-fire monitor:no_progress. The native-transcript reconcile
+     * (sampleNativeTranscriptProgress) does NOT cover this class (no native source →
+     * null sample), so the stall path needs its own guard.
+     *
+     * Called from checkMeshWorkerStall just before the fire. Returns true when the
+     * session is a finished pure-PTY turn — idle, no pending response, and a PTY-parsed
+     * in-turn final assistant summary — in which case it emits the missing
+     * generating_completed (idempotent: a real/late emit writes the terminal ledger and
+     * the coordinator's reconcile makes any duplicate a no-op) and the caller SUPPRESSES
+     * the stall. Returns false for every other class/state (native-source provider, a
+     * genuinely mid-turn or wedged worker with no final assistant), so a real stall still
+     * fires unchanged.
+     *
+     * Evidence bar is identical to flushMeshCompletionBeforeCleanup: injected task's turn
+     * genuinely started + an in-turn final assistant summary. Conservative by
+     * construction — no summary ⇒ no proof of completion ⇒ return false and let the real
+     * stall fire.
+     */
+    private tryReconcilePurePtyCompletionForStall(observedStatus: string): boolean {
+        // Only the pure-PTY class — native-source providers are handled by
+        // sampleNativeTranscriptProgress above.
+        if (!isPurePtyTranscriptProvider(this.provider)) return false;
+        // A finished turn is idle with nothing pending. A generating/waiting session is
+        // mid-turn (the real stall path should evaluate it), so never complete it here.
+        if (observedStatus !== 'idle') return false;
+        if (this.hasAdapterPendingResponse()) return false;
+
+        const taskId = this.completingTurnTaskId();
+        // DOUBLE-EMIT guard: this turn's completion already fired — never re-emit.
+        if (this.lastEmittedCompletion && this.lastEmittedCompletion.taskId === (taskId ?? '')) {
+            return false;
+        }
+        // The injected task's own turn must have genuinely started (guards against a
+        // reused session's stale tail before this task ran).
+        if (!this.injectedTaskHasStartedGenerating()) return false;
+
+        const turnStartedAt = typeof (this.adapter as any)?.currentTurnStartedAt === 'number'
+            ? (this.adapter as any).currentTurnStartedAt as number
+            : this.meshTaskInjectedAt || undefined;
+        let parsedMessages: unknown;
+        try {
+            parsedMessages = this.adapter?.getScriptParsedStatus?.()?.messages;
+        } catch { parsedMessages = undefined; }
+        let finalSummary: string | undefined;
+        try {
+            finalSummary = this.completionFinalSummary(parsedMessages, turnStartedAt);
+        } catch { finalSummary = undefined; }
+        // No in-turn final assistant evidence → not a proven turn-end. Let the real
+        // stall fire so a genuinely-wedged worker is still surfaced.
+        if (!finalSummary) return false;
+
+        LOG.warn('CLI', `[${this.type}] reconciling pure-PTY mesh completion from the stall path for session ${this.instanceId} `
+            + `task=${taskId ?? '(none)'} — PTY is idle-quiet with an in-turn final assistant message but the completion `
+            + `event never fired (pure-PTY provider); emitting it instead of a false monitor:no_progress.`);
+        if (this.isMeshWorkerSession()) {
+            traceMeshEventStage('fired', this.meshTraceCtx(), 'stall_pure_pty_transcript_completion');
+        }
+        this.emitGeneratingCompleted({
+            chatTitle: '',
+            duration: undefined,
+            timestamp: Date.now(),
+            taskId,
+            finalSummary,
+            evidenceLevel: 'transcript',
+            completionDiagnostic: { source: 'stall_pure_pty_transcript_completion' },
+        });
+        return true;
     }
 
     /**
@@ -2469,7 +2781,7 @@ export class CliProviderInstance implements ProviderInstance {
      * resolveModal, so a plain turn that never saw an approval always returns false.
      */
     private inApprovalResumeGrace(now = Date.now()): boolean {
-        if (!this.isAutonomousMeshSession() || !this.shouldAutoApprove()) return false;
+        if (!this.isAutonomousMeshSession() || !this.shouldUsePtyAutoApprove()) return false;
         const resolvedAt = typeof (this.adapter as any)?.lastApprovalResolvedAt === 'number'
             ? (this.adapter as any).lastApprovalResolvedAt as number
             : 0;
@@ -2586,7 +2898,7 @@ export class CliProviderInstance implements ProviderInstance {
         }
 
         const latestStatus = this.adapter.getStatus({ allowParse: false });
-        const latestAutoApproveActive = latestStatus.status === 'waiting_approval' && this.shouldAutoApprove();
+        const latestAutoApproveActive = latestStatus.status === 'waiting_approval' && this.shouldUsePtyAutoApprove();
         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') {
@@ -2751,6 +3063,79 @@ export class CliProviderInstance implements ProviderInstance {
                 this.scheduleCompletedDebounceFlush(COMPLETED_FINALIZATION_RETRY_MS);
                 return;
             }
+            // (CANON-C EARLY-EMIT FLOOR) The transcript-evidence gate would otherwise fire its
+            // decoupled-immediate completion at ANY waitedMs — including the ~13s a codex PLAIN
+            // terminal `missing_final_assistant` block reaches on the first completion-gate poll,
+            // with NO final assistant ever observed. That stamps a weak evidenceLevel=insufficient
+            // completion the coordinator marks reviewRecommended but does not auto-hold, racing the
+            // transcript before it can land and pre-empting the 180s mesh-worker stall watchdog.
+            // Impose a minimum dwell — but ONLY for the no-external-transcript case
+            // (noExternalTranscriptSource): a PTY-parsed provider has no separate transcript that
+            // will land to upgrade the weak emit, so firing immediately is a pure timing guess. A
+            // native-source block (claude-cli external-native) is deliberately NOT floored: its
+            // transcript legitimately trails the idle transition by a write and the CANON-C
+            // immediate emit is correct (upgraded by the reconcile). Keep holding (re-probe each
+            // retry — the block clears for a GENUINE emit the moment the assistant turn lands) until
+            // either the floor is met or the 30s cap force-releases the weak completion below.
+            // Scoped to mesh worker sessions (the only place allowTimeout is set), so interactive
+            // completion timing is untouched.
+            if (isTranscriptEvidenceGate
+                && blockReason === 'missing_final_assistant'
+                && block.noExternalTranscriptSource === true
+                && waitedMs < CANON_C_MISSING_ASSISTANT_MIN_ELAPSED_MS) {
+                if (pending.loggedBlockReason !== 'canon_c_min_elapsed_floor') {
+                    LOG.info('CLI', `[${this.type}] holding CANON-C decoupled emit until min-elapsed floor (waitedMs=${waitedMs} floor=${CANON_C_MISSING_ASSISTANT_MIN_ELAPSED_MS}); no final assistant yet (${blockReason})`);
+                    if (this.isMeshWorkerSession()) {
+                        traceMeshEventDrop('completion_gate_hold', this.meshTraceCtx(), `canon_c_min_elapsed_floor waited=${waitedMs}ms`);
+                    }
+                    if (this.completionTraceOn()) this.recordCompletionGateTrace('hold', {
+                        blockReason,
+                        latestVisibleStatus,
+                        terminal: block.terminal === true,
+                        canonCMinElapsedFloor: true,
+                        waitedMs,
+                    });
+                    pending.loggedBlockReason = 'canon_c_min_elapsed_floor';
+                }
+                this.scheduleCompletedDebounceFlush(COMPLETED_FINALIZATION_RETRY_MS);
+                return;
+            }
+            // (ANTIGRAVITY-30S-CAP-PREMATURE) The 30s cap has been reached for an antigravity
+            // `holdForTranscript` block. The cap releases on ELAPSED TIME, not proof-of-idle — but
+            // antigravity is native-source (assistant answer in native-history) with a PTY-derived
+            // idle verdict, so the transcript's final assistant bubble can legitimately land past 30s
+            // on a long turn. Releasing here would fire a premature weak completed/idle to the
+            // coordinator WHILE THE PTY IS STILL GENERATING (the live-reproduced defect). Gate the
+            // release on the PTY being genuinely quiet: if it is still active (adapter pending
+            // response OR raw output within ANTIGRAVITY_HOLD_QUIET_DWELL_MS) and we are under the
+            // absolute ANTIGRAVITY_HOLD_HARD_CAP_MS bound, KEEP HOLDING (re-probe next retry — the
+            // transcript branch above clears the block for a genuine emit once the answer lands).
+            // A genuinely quiescent tool-only turn (no assistant bubble, PTY stable) falls through
+            // to the existing weak force-emit; a runaway PTY that never quiets releases at the hard
+            // cap so it cannot wedge forever. Scoped to antigravity holdForTranscript so
+            // claude-cli/codex-cli completion timing is unchanged.
+            if (this.type === 'antigravity-cli'
+                && block.holdForTranscript === true
+                && waitedMs < ANTIGRAVITY_HOLD_HARD_CAP_MS
+                && this.antigravityHoldPtyStillActive()) {
+                if (pending.loggedBlockReason !== 'antigravity_hold_pty_active') {
+                    LOG.info('CLI', `[${this.type}] 30s cap reached but PTY still generating; holding antigravity completion past cap (waitedMs=${waitedMs} hardCap=${ANTIGRAVITY_HOLD_HARD_CAP_MS}) (${blockReason})`);
+                    if (this.isMeshWorkerSession()) {
+                        traceMeshEventDrop('completion_gate_hold', this.meshTraceCtx(), `antigravity_hold_pty_active waited=${waitedMs}ms`);
+                    }
+                    if (this.completionTraceOn()) this.recordCompletionGateTrace('hold', {
+                        blockReason,
+                        latestVisibleStatus,
+                        terminal: block.terminal === true,
+                        holdForTranscript: true,
+                        antigravityPtyStillActive: true,
+                        waitedMs,
+                    });
+                    pending.loggedBlockReason = 'antigravity_hold_pty_active';
+                }
+                this.scheduleCompletedDebounceFlush(COMPLETED_FINALIZATION_RETRY_MS);
+                return;
+            }
             const emittedAfterFinalizationTimeout = waitedMs >= COMPLETED_FINALIZATION_MAX_WAIT_MS;
             const completionDiagnostic = this.buildCompletedFinalizationDiagnostic({
                 blockReason,
@@ -2868,6 +3253,10 @@ export class CliProviderInstance implements ProviderInstance {
         if (summary) {
             this.lastCompletionSummary = { content: summary, receivedAt: opts.timestamp };
         }
+        // KIMI-MESH-COMPLETION-EMIT (axis 2, double-emit guard): record that THIS turn's
+        // completion has now been emitted, keyed by its taskId, so the pre-cleanup
+        // completion flush never fires a duplicate for the same turn.
+        this.lastEmittedCompletion = { taskId: typeof opts.taskId === 'string' ? opts.taskId : '', at: Date.now() };
         this.pushEvent({
             event: 'agent:generating_completed',
             chatTitle: opts.chatTitle,
@@ -2912,7 +3301,7 @@ export class CliProviderInstance implements ProviderInstance {
     private stabilizeFlappingApprovalStatus(adapterStatus: any, now = Date.now()): any {
         // Only autonomous auto-approving mesh sessions are subject to the delegated flap;
         // never overlay for attended/foreground/non-mesh sessions.
-        if (!this.isAutonomousMeshSession() || !this.shouldAutoApprove()) return adapterStatus;
+        if (!this.isAutonomousMeshSession() || !this.shouldUsePtyAutoApprove()) return adapterStatus;
 
         const rawStatus = adapterStatus?.status;
         const resolvedAt = typeof (this.adapter as any)?.lastApprovalResolvedAt === 'number'
@@ -2959,6 +3348,13 @@ export class CliProviderInstance implements ProviderInstance {
     }
 
     private maybeAutoApproveStatus(adapterStatus: any, now = Date.now()): boolean {
+        // launch-args modes grant approval in the CLI process itself and therefore
+        // must never enter the PTY modal parser/fire/settle/mask/nudge subsystem.
+        // post-boot-command is reserved and resolves inactive in v1.
+        if (!this.shouldUsePtyAutoApprove()) {
+            this.resetPtyAutoApproveState();
+            return false;
+        }
         // Manual-attendance suppression (provider-common): when a human is
         // Manual-attendance suppression (provider-common): when a human is
         // actively driving this session from the dashboard, hold auto-approve so
@@ -2970,7 +3366,7 @@ export class CliProviderInstance implements ProviderInstance {
         // 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.shouldUsePtyAutoApprove()
             && this.manualAttendance.isAttended(now)) {
             this.lastAutoApprovalSignature = '';
             this.pendingAutoApprovalSignature = '';
@@ -2988,7 +3384,7 @@ export class CliProviderInstance implements ProviderInstance {
             }, this.manualAttendance.remainingMs(now) + 20);
             return false;
         }
-        const autoApproveActive = adapterStatus?.status === 'waiting_approval' && this.shouldAutoApprove();
+        const autoApproveActive = adapterStatus?.status === 'waiting_approval' && this.shouldUsePtyAutoApprove();
         // 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.
@@ -3885,6 +4281,68 @@ export class CliProviderInstance implements ProviderInstance {
             this.lastStatus = newStatus;
         }
 
+        // INTERACTIVE-QUESTION-EMIT: fire a coordinator/push-worthy notification when the
+        // session ENTERS an AskUserQuestion / waiting_choice state. This is orthogonal to
+        // the status-change block above: an AskUserQuestion prompt is surfaced only as a
+        // display-only `waiting_choice` overlay in getState() (mirrored here off
+        // adapterStatus.activeInteractivePrompt, the exact signal getState uses), while
+        // the raw adapter status stays idle/generating — so none of the status-keyed
+        // arms above ever emit an agent:* event for it and the owner gets no web-push.
+        //
+        // MESH-QUESTION-ANSWER-PATH (mission f1d25e11): this used to REUSE
+        // agent:waiting_approval (question as modalMessage, choice labels as modalButtons).
+        // That mis-classified a multi-choice QUESTION as an approval — the coordinator saw
+        // a task_approval_needed ledger row and tried mesh_approve, which cannot answer a
+        // question (it resolves a yes/no modal). We now emit a DISTINCT
+        // agent:waiting_choice event carrying the FULL InteractivePrompt payload
+        // (promptId + every question's header/question/multiSelect and each option's
+        // label/description) so the coordinator can render the choices and answer with the
+        // dedicated mesh_answer_question tool. The rich payload survives the cross-machine
+        // relay (see buildRelayMetadataEvent) so a REMOTE worker's question reaches the
+        // coordinator with its options intact.
+        //
+        // We keep modalMessage/modalButtons on the event too so the existing server
+        // web-push path (which reads those two fields) still fires with no cloud change —
+        // but the payload's `interactivePrompt` is the authoritative, structured signal.
+        //
+        // Edge-triggered: emit exactly once on entry, keyed on promptId + question text,
+        // and reset the key when the prompt clears so a fresh prompt re-fires and a later
+        // real completion still flows through the idle arm normally. We do NOT emit when
+        // the session is ALSO in a genuine approval state (newStatus === 'waiting_approval'):
+        // that arm already emits agent:waiting_approval. A question (waiting_choice) and a
+        // real approval (waiting_approval) therefore NEVER both fire for the same tick —
+        // the approval arm wins and this arm yields (owner requirement: the two are
+        // mutually exclusive).
+        const interactivePrompt = adapterStatus.activeInteractivePrompt ?? null;
+        if (interactivePrompt && newStatus !== 'waiting_approval') {
+            const firstQuestion = interactivePrompt.questions?.[0];
+            const promptKey = `${interactivePrompt.promptId}::${firstQuestion?.question ?? ''}`;
+            if (promptKey !== this.lastInteractivePromptEventKey) {
+                this.lastInteractivePromptEventKey = promptKey;
+                const modalMessage = firstQuestion
+                    ? (firstQuestion.header
+                        ? `${firstQuestion.header}: ${firstQuestion.question}`
+                        : firstQuestion.question)
+                    : undefined;
+                const modalButtons = firstQuestion?.options?.map((option: { label: string }) => option.label);
+                this.pushEvent({
+                    event: 'agent:waiting_choice', chatTitle, timestamp: now,
+                    // Structured, authoritative payload — the coordinator renders these and
+                    // answers via mesh_answer_question. Carried whole (all questions, all
+                    // options) so multi-question / multi-select prompts round-trip fully.
+                    interactivePrompt,
+                    promptId: interactivePrompt.promptId,
+                    multiSelect: firstQuestion?.multiSelect === true,
+                    // Push-notification-friendly projection (server push path reads these).
+                    modalMessage,
+                    modalButtons,
+                });
+            }
+        } else if (!interactivePrompt && this.lastInteractivePromptEventKey) {
+            // Prompt answered / gone — reset so the next AskUserQuestion re-fires.
+            this.lastInteractivePromptEventKey = '';
+        }
+
         // 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
@@ -4202,15 +4660,37 @@ export class CliProviderInstance implements ProviderInstance {
     get cliType(): string { return this.type; }
     get cliName(): string { return this.provider.name; }
 
+    private resolveAutoApproveMode(): ResolvedAutoApproveMode {
+        return resolveProviderAutoApproveMode(this.provider, this.settings);
+    }
+
+    /** Legacy boolean view retained for internal/test compatibility. */
     private shouldAutoApprove(): boolean {
-        if (typeof this.settings.autoApprove === 'boolean') {
-            return this.settings.autoApprove;
+        return this.resolveAutoApproveMode().active;
+    }
+
+    private shouldUsePtyAutoApprove(): boolean {
+        const resolved = this.resolveAutoApproveMode();
+        return this.shouldAutoApprove() && resolved.strategy === 'pty-parse-default';
+    }
+
+    private resetPtyAutoApproveState(): void {
+        this.lastAutoApprovalSignature = '';
+        this.pendingAutoApprovalSignature = '';
+        this.pendingAutoApprovalSince = 0;
+        this.autoApproveInactiveSince = 0;
+        this.autoApproveMaskSince = 0;
+        this.stalledApprovalNudgeEpisode = 0;
+        this.autoApproveLastModalSeenAt = 0;
+        this.autoApproveBusy = false;
+        if (this.autoApproveSettleTimer) {
+            clearTimeout(this.autoApproveSettleTimer);
+            this.autoApproveSettleTimer = null;
         }
-        const providerDefault = this.provider.settings?.autoApprove?.default;
-        if (typeof providerDefault === 'boolean') {
-            return providerDefault;
+        if (this.autoApproveBusyTimer) {
+            clearTimeout(this.autoApproveBusyTimer);
+            this.autoApproveBusyTimer = null;
         }
-        return false;
     }
 
     /** @see ProviderInstance.noteManualInteraction */
@@ -4237,7 +4717,7 @@ export class CliProviderInstance implements ProviderInstance {
      */
     private autoApproveEffectivelyActive(status: string | undefined, now = Date.now()): boolean {
         return status === 'waiting_approval'
-            && this.shouldAutoApprove()
+            && this.shouldUsePtyAutoApprove()
             && !this.manualAttendance.isAttended(now);
     }
 
@@ -4249,7 +4729,8 @@ export class CliProviderInstance implements ProviderInstance {
     // 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
+        return this.shouldUsePtyAutoApprove()
+            && this.autoApproveMaskSince > 0
             && now - this.autoApproveMaskSince > CliProviderInstance.AUTO_APPROVE_MASK_STALL_MS;
     }
 
@@ -4275,6 +4756,7 @@ export class CliProviderInstance implements ProviderInstance {
      * mask-clock value) so a modal that flaps between parsed/unparsed states is announced once.
      */
     private maybeEmitStalledApprovalNudge(adapterStatus: any, now: number): void {
+        if (!this.shouldUsePtyAutoApprove()) return;
         if (!this.isMeshWorkerSession()) return;
         if (adapterStatus?.status !== 'waiting_approval') return;
         if (!this.autoApproveMaskStalled(now)) return;