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

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

@@ -12,12 +12,11 @@ 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, resolveInteractivePromptResponse, type InteractivePrompt } from './types/interactive-prompt.js';
+import { normalizeInteractivePrompt, normalizeInteractivePromptResponse, type InteractivePrompt } from './types/interactive-prompt.js';
 import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
 import { shortHash } from '../system/hash.js';
 import type { CliProviderModule } from '../cli-adapters/provider-cli-adapter.js';
 import 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';
@@ -57,11 +56,8 @@ 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,
@@ -75,7 +71,6 @@ 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.
@@ -334,18 +329,6 @@ 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
@@ -386,18 +369,6 @@ 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 = '';
@@ -1289,16 +1260,7 @@ export class CliProviderInstance implements ProviderInstance {
             }
         } else if (event === 'interactive_prompt_response' && data) {
             try {
-                // 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);
+                const response = normalizeInteractivePromptResponse(data);
                 if (this.activeInteractivePrompt?.promptId === response.promptId) {
                     this.activeInteractivePrompt = null;
                 }
@@ -1432,15 +1394,6 @@ 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;
@@ -1944,33 +1897,6 @@ 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() : '';
@@ -2119,11 +2045,6 @@ 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,
                 };
             }
         }
@@ -2427,52 +2348,6 @@ 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
@@ -2523,193 +2398,6 @@ 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;
     }
 
     /**
@@ -2781,7 +2469,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.shouldUsePtyAutoApprove()) return false;
+        if (!this.isAutonomousMeshSession() || !this.shouldAutoApprove()) return false;
         const resolvedAt = typeof (this.adapter as any)?.lastApprovalResolvedAt === 'number'
             ? (this.adapter as any).lastApprovalResolvedAt as number
             : 0;
@@ -2898,7 +2586,7 @@ export class CliProviderInstance implements ProviderInstance {
         }
 
         const latestStatus = this.adapter.getStatus({ allowParse: false });
-        const latestAutoApproveActive = latestStatus.status === 'waiting_approval' && this.shouldUsePtyAutoApprove();
+        const latestAutoApproveActive = latestStatus.status === 'waiting_approval' && this.shouldAutoApprove();
         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') {
@@ -3063,79 +2751,6 @@ 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,
@@ -3253,10 +2868,6 @@ 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,
@@ -3301,7 +2912,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.shouldUsePtyAutoApprove()) return adapterStatus;
+        if (!this.isAutonomousMeshSession() || !this.shouldAutoApprove()) return adapterStatus;
 
         const rawStatus = adapterStatus?.status;
         const resolvedAt = typeof (this.adapter as any)?.lastApprovalResolvedAt === 'number'
@@ -3348,13 +2959,6 @@ 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
@@ -3366,7 +2970,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.shouldUsePtyAutoApprove()
+            && this.shouldAutoApprove()
             && this.manualAttendance.isAttended(now)) {
             this.lastAutoApprovalSignature = '';
             this.pendingAutoApprovalSignature = '';
@@ -3384,7 +2988,7 @@ export class CliProviderInstance implements ProviderInstance {
             }, this.manualAttendance.remainingMs(now) + 20);
             return false;
         }
-        const autoApproveActive = adapterStatus?.status === 'waiting_approval' && this.shouldUsePtyAutoApprove();
+        const autoApproveActive = adapterStatus?.status === 'waiting_approval' && this.shouldAutoApprove();
         // Guard re-entry: onStatusChange/getState can observe the same modal multiple
         // times while the PTY absorbs the approval key. Without this flag, repeated
         // snapshots would write stray keys into the input once the modal dismisses.
@@ -4281,68 +3885,6 @@ 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
@@ -4660,37 +4202,15 @@ 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 {
-        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;
+        if (typeof this.settings.autoApprove === 'boolean') {
+            return this.settings.autoApprove;
         }
-        if (this.autoApproveBusyTimer) {
-            clearTimeout(this.autoApproveBusyTimer);
-            this.autoApproveBusyTimer = null;
+        const providerDefault = this.provider.settings?.autoApprove?.default;
+        if (typeof providerDefault === 'boolean') {
+            return providerDefault;
         }
+        return false;
     }
 
     /** @see ProviderInstance.noteManualInteraction */
@@ -4717,7 +4237,7 @@ export class CliProviderInstance implements ProviderInstance {
      */
     private autoApproveEffectivelyActive(status: string | undefined, now = Date.now()): boolean {
         return status === 'waiting_approval'
-            && this.shouldUsePtyAutoApprove()
+            && this.shouldAutoApprove()
             && !this.manualAttendance.isAttended(now);
     }
 
@@ -4729,8 +4249,7 @@ 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.shouldUsePtyAutoApprove()
-            && this.autoApproveMaskSince > 0
+        return this.autoApproveMaskSince > 0
             && now - this.autoApproveMaskSince > CliProviderInstance.AUTO_APPROVE_MASK_STALL_MS;
     }
 
@@ -4756,7 +4275,6 @@ 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;