@kenkaiiii/ggcoder 5.70.0 → 5.72.0

package/dist/core/agent-session.js

@@ -24,11 +24,12 @@ import { ensureAppDirs } from "../config.js";
 import { buildSubAgentSystemPrompt, buildSystemPrompt, } from "../system-prompt.js";
 import { createTools, createWebSearchTool, } from "../tools/index.js";
 import { partitionToolsByTier } from "../tools/tool-tiers.js";
-import { formatImpactForVerification } from "./test-impact.js";
 import { autoBackgroundedId } from "../tools/bash.js";
 import { buildProcessCompletionFollowUp } from "./process-gate.js";
-import { buildSubAgentCompletionFollowUp, } from "./subagent-manager.js";
+import { buildSubAgentCompletionFollowUp } from "./subagent-manager.js";
 import { applyAsyncSubagentPolicy } from "./subagent-policy.js";
+import { resolveResponsesLite, resolveStrictTools, } from "./codex-request-shape.js";
+import { subAgentDescription } from "../tools/subagent.js";
 import { z } from "zod";
 import { MCPClientManager, getAllMcpServers } from "./mcp/index.js";
 import { clampMcpToolDescription, DeferredToolCatalog } from "./mcp/deferred-catalog.js";
@@ -52,15 +53,13 @@ import { pruneStaleToolResults } from "./compaction/tool-result-pruner.js";
 import { discoverAgents } from "./agents.js";
 import { enhancePrompt } from "../utils/prompt-enhancer.js";
 import { detectLanguages, detectProjectStack } from "./language-detector.js";
-import { evaluateIdealReview, buildIdealReviewMessage, buildReviewCoverageEscalationMessage, buildReviewCoverageMessage, MAX_REVIEW_COVERAGE_INJECTIONS, withReviewCoverageRequirements, detectTestDrift, ReviewCoverageTracker, } from "./ideal-review.js";
 import { evaluateLoopBreak, buildLoopBreakMessage, CycleDetector, ToolCallProgressTracker, detectTextRepetition, } from "./loop-breaker.js";
 import { buildRegroundingMessage, requestTextForRegrounding } from "./regrounding.js";
 import { buildSemanticLoopJudgePrompt, buildSemanticLoopMessage, MAX_SEMANTIC_LOOP_CALLS, parseSemanticLoopVerdict, shouldRunSemanticLoopCheck, SEMANTIC_LOOP_JUDGE_TIMEOUT_MS, withJudgeTimeout, } from "./semantic-loop-check.js";
-import { buildIndependentReviewMessage, buildReviewerTask, INDEPENDENT_REVIEW_SCORE_THRESHOLD, parseReviewerFindings, REVIEWER_TOOLS, REVIEWER_TURN_TIMEOUT_MS, REVIEWER_WAIT_MS, } from "./ideal-review-subagent.js";
 import { buildEnvDeltaMessage } from "./env-delta.js";
 import { wrapSteeringText, buildNotificationSteeringText, STEERING_PREFIX } from "./steering.js";
 import { AgentNotificationQueue } from "./agent-notifications.js";
-import { VerificationGate, extractAddedLines, isCheckOwnFile, isCodeFilePath, VERIFICATION_STATE_KIND, isVerificationCommand, } from "./verification-gate.js";
+import { VerificationGate, isCheckOwnFile, isCodeFilePath, VERIFICATION_STATE_KIND, isVerificationCommand, } from "./verification-gate.js";
 import { classifyVerificationCommand } from "./verification-evidence.js";
 import { captureVerificationSnapshot } from "./verification-snapshot.js";
 import { findUserSessionPrompt, getUserSessionPrompt } from "./session-preview.js";
@@ -75,14 +74,6 @@ import path from "node:path";
  * progressing — refuse to extend its turn budget.
  */
 const TURN_EXTENSION_MAX_FAILURE_RATIO = 0.5;
-/** Terminal subagent states — mirrors SubAgentManager's private isTerminal. */
-function isTerminalSubAgentState(state) {
-    return (state === "completed" ||
-        state === "failed" ||
-        state === "interrupted" ||
-        state === "closed" ||
-        state === "reaped");
-}
 // ── Tool-result policy ─────────────────────────────────────
 /** Resolve the per-result cap passed to the agent loop for the active transport. */
 export function resolveSessionToolResultCharLimit(model, provider, accountId) {
@@ -151,20 +142,13 @@ export class AgentSession {
     /** Forgets every file read; called whenever the conversation is replaced or
      *  rewound, so the model must re-read a file before changing it. */
     clearReadTracker;
+    recordBashReads;
     skills = [];
     cacheKeyLogged = false;
     // ── Self-correction hook state (mirrors the TUI's useAgentLoop refs) ──
     // Reset at the start of every run; observed from the event stream; read by
-    // the loop-break (mid-loop) and ideal-review (pre-stop) callbacks.
-    hookStats = {
-        changedLines: 0,
-        toolCalls: 0,
-        toolFailures: 0,
-        turns: 0,
-        writeCalls: 0,
-        editCalls: 0,
-        bashCalls: 0,
-    };
+    // the loop-break (mid-loop) callback.
+    hookStats = { toolCalls: 0, toolFailures: 0, turns: 0 };
     hookText = "";
     hookConsecutiveFailures = 0;
     hookRepeatedNoProgressCalls = 0;
@@ -174,20 +158,6 @@ export class AgentSession {
     hookFileEditCounts = new Map();
     hookToolCalls = new Map();
     backgroundVerification = new Map();
-    idealReviewPhase = "idle";
-    /** Runtime-only suppression while Ken owns verification in autopilot mode. */
-    idealReviewSuppressed = false;
-    /** Mirror of the last `hook_armed` value broadcast this run, so the event
-     *  fires only on a real edge. */
-    idealReviewArmed = false;
-    /** Cached test-drift probe, keyed by the size of the edited-file set. Drift
-     *  depends only on WHICH files were edited and that set only grows, so this
-     *  keeps the arming check off the filesystem on most tool results — the probe
-     *  is several sync existsSync calls per edited file. */
-    idealDriftProbe = null;
-    reviewCoverage;
-    /** Coverage follow-ups spent this run, capped by MAX_REVIEW_COVERAGE_INJECTIONS. */
-    reviewCoverageInjected = 0;
     /** 0 = none; 1 = first nudge sent; 2 = final stop-and-report injected. */
     loopBreakInjected = 0;
     regroundingInjected = false;
@@ -197,8 +167,6 @@ export class AgentSession {
      *  injection at the next steering poll; judge failures fail open (no
      *  injection) and still consume budget + cooldown. */
     semanticLoop = { checksUsed: 0, lastCheckTurn: 0, pending: false, verdict: null, injected: false };
-    /** Independent Ideal reviewer spawned once per run (score-gated). */
-    independentReviewStarted = false;
     /**
      * The environment as the cached system prompt currently describes it.
      * Re-recorded on every prompt build, so a rebuild (e.g. `/add-dir`) needs no
@@ -209,11 +177,11 @@ export class AgentSession {
     runStartedAt = 0;
     /** Gate injections spent this run, capped by MAX_PROCESS_GATE_INJECTIONS. */
     processGateInjected = 0;
-    /** Verification gate: code edited this run, nothing proved it since. */
+    /** Verification evidence: code edited this run, and what has proved it since.
+     *  Passive tracking only — it feeds run status and autopilot, never a turn. */
     verificationGate = new VerificationGate();
-    /** Mirror of the last verification `hook_armed` value, so the event fires
-     *  only on a real edge. */
-    verificationArmed = false;
+    /** Mirror of the last `hook_armed` value, so the event fires only on an edge. */
+    preFinalArmed = false;
     compactionOccurred = false;
     /**
      * Re-grounding carry-over for post-turn compaction. `resetHookState` clears
@@ -264,7 +232,6 @@ export class AgentSession {
     steeringListeners = new Set();
     processManager;
     lspManager;
-    testImpact;
     debugManager;
     subAgentManager;
     /**
@@ -369,7 +336,6 @@ export class AgentSession {
         this.provider = options.provider;
         this.model = options.model;
         this.cwd = options.cwd;
-        this.reviewCoverage = new ReviewCoverageTracker(this.cwd);
         this.baseUrl = options.baseUrl;
         this.maxTokens = this.resolveMaxTokens(options.model);
         this.thinkingLevel = options.thinkingLevel;
@@ -435,7 +401,7 @@ export class AgentSession {
             : this.opts.globalSubagents
                 ? await discoverAgents({ globalAgentsDir: paths.agentsDir })
                 : [];
-        const { tools: builtInTools, processManager, rebuildReadTool, clearReadTracker, lspManager, testImpact, debugManager, subAgentManager, } = await createTools(this.cwd, {
+        const { tools: builtInTools, processManager, rebuildReadTool, clearReadTracker, recordBashReads, lspManager, debugManager, subAgentManager, } = await createTools(this.cwd, {
             agents,
             skills: this.skills,
             contextLimits: this.contextLimits,
@@ -466,11 +432,9 @@ export class AgentSession {
             }),
             getUseExternalGrep: () => this.settingsManager.get("grepUseRipgrep"),
             authStorage: this.authStorage,
-            onFileRead: (filePath) => this.reviewCoverage.recordRead(filePath),
             onFileMutated: (filePath) => {
                 const relative = path.relative(this.cwd, filePath) || path.basename(filePath);
                 this.hookFileEditCounts.set(relative, (this.hookFileEditCounts.get(relative) ?? 0) + 1);
-                this.reviewCoverage.recordChanged(filePath);
             },
             // Lazy — sessionId/model/provider can change after createTools() runs, so
             // sub-agent spawns read the current parent state at execution time.
@@ -506,6 +470,11 @@ export class AgentSession {
         // a hallucinated call can't mutate the repo — and buildSystemPrompt below is
         // fed the same filtered names so the Tools section matches exactly.
         this.tools = this.opts.allowedTools ? tools.filter((t) => this.isToolAllowed(t.name)) : tools;
+        // Both delegation tools carry the agent roster; when both survive the
+        // allow-list, `subagent` points at `spawn_agent`'s copy instead.
+        if (this.tools.some((t) => t.name === "spawn_agent")) {
+            this.tools = this.tools.map((t) => t.name === "subagent" ? { ...t, description: subAgentDescription(agents, true) } : t);
+        }
         // Tier the built-ins: rarely reached schemas move into the tool_search
         // catalog and cost one hint line each instead of a full parameter schema on
         // every request. Allow-listed sessions keep the eager path — their fixed
@@ -526,9 +495,9 @@ export class AgentSession {
         }
         this.rebuildReadTool = rebuildReadTool;
         this.clearReadTracker = clearReadTracker;
+        this.recordBashReads = recordBashReads;
         this.processManager = processManager;
         this.lspManager = lspManager;
-        this.testImpact = testImpact;
         this.debugManager = debugManager;
         this.subAgentManager = subAgentManager;
         this.bindManagerCancellation(this.opts.signal);
@@ -1116,15 +1085,7 @@ export class AgentSession {
     resetHookState(originalRequest) {
         this.opts.completionReview?.begin(originalRequest);
         this.lspManager?.clearPendingDiagnostics();
-        this.hookStats = {
-            changedLines: 0,
-            toolCalls: 0,
-            toolFailures: 0,
-            turns: 0,
-            writeCalls: 0,
-            editCalls: 0,
-            bashCalls: 0,
-        };
+        this.hookStats = { toolCalls: 0, toolFailures: 0, turns: 0 };
         this.hookText = "";
         this.hookConsecutiveFailures = 0;
         this.hookRepeatedNoProgressCalls = 0;
@@ -1133,13 +1094,6 @@ export class AgentSession {
         this.hookCyclicPattern = null;
         this.hookFileEditCounts.clear();
         this.hookToolCalls.clear();
-        this.reviewCoverage.reset();
-        this.reviewCoverageInjected = 0;
-        this.idealReviewPhase = "idle";
-        // No event here: clients reset their own hold on run_start.
-        this.idealReviewArmed = false;
-        this.verificationArmed = false;
-        this.idealDriftProbe = null;
         this.loopBreakInjected = 0;
         this.regroundingInjected = false;
         this.hookRecentCalls = [];
@@ -1150,7 +1104,6 @@ export class AgentSession {
             verdict: null,
             injected: false,
         };
-        this.independentReviewStarted = false;
         this.runStartedAt = Date.now();
         this.processGateInjected = 0;
         this.verificationGate.beginRun();
@@ -1171,8 +1124,8 @@ export class AgentSession {
     }
     /**
      * Fold one agent event into the hook stat accumulators. Pure bookkeeping —
-     * the same signals the TUI's useAgentLoop collects, so the loop-break and
-     * ideal-review decisions match across the CLI and the app.
+     * the same signals the TUI's useAgentLoop collects, so loop-break decisions
+     * match across the CLI and the app.
      */
     async trackHookEvent(event) {
         if (this.opts.completionReview) {
@@ -1215,7 +1168,7 @@ export class AgentSession {
                             ...this.hookFileEditCounts.keys(),
                         ]);
                         if (call.sourceSnapshot === null)
-                            this.verificationGate.requireFreshVerification(true, event.args.command);
+                            this.verificationGate.requireFreshVerification(true);
                     }
                     else if ((classification.accepted && event.args.persist !== true) ||
                         (!classification.accepted && classification.mayMutate)) {
@@ -1225,7 +1178,7 @@ export class AgentSession {
                         // or a persistent-shell run records nothing at the end, so
                         // flagging it left verified work Unverified forever — and
                         // autopilot silently refused every later turn.
-                        this.verificationGate.requireFreshVerification(!classification.accepted && classification.mayMutate, event.args.command);
+                        this.verificationGate.requireFreshVerification(!classification.accepted && classification.mayMutate);
                     }
                     await this.persistVerificationState();
                 }
@@ -1238,12 +1191,6 @@ export class AgentSession {
                 this.hookStats.toolCalls += 1;
                 if (event.isError)
                     this.hookStats.toolFailures += 1;
-                if (name === "write")
-                    this.hookStats.writeCalls += 1;
-                if (name === "edit")
-                    this.hookStats.editCalls += 1;
-                if (name === "bash")
-                    this.hookStats.bashCalls += 1;
                 this.hookConsecutiveFailures = event.isError ? this.hookConsecutiveFailures + 1 : 0;
                 this.hookRepeatedNoProgressCalls = this.hookProgressTracker.record(name, args, event.result, event.isError);
                 this.hookCyclicPattern = this.hookCycleDetector.record(name, args, event.result, event.isError);
@@ -1260,12 +1207,6 @@ export class AgentSession {
                 if (this.hookRecentCalls.length > MAX_SEMANTIC_LOOP_CALLS) {
                     this.hookRecentCalls.splice(0, this.hookRecentCalls.length - MAX_SEMANTIC_LOOP_CALLS);
                 }
-                if (name === "edit" && !event.isError) {
-                    const diff = event.details?.diff ?? event.result;
-                    const added = (diff.match(/^\+[^+]/gm) ?? []).length;
-                    const removed = (diff.match(/^-[^-]/gm) ?? []).length;
-                    this.hookStats.changedLines += added + removed;
-                }
                 // Only host-observed successful mutations and trustworthy check results
                 // affect approval. The model's text is never evidence.
                 let verificationChanged = false;
@@ -1273,13 +1214,10 @@ export class AgentSession {
                     if (name === "edit" || name === "write") {
                         const filePath = String(args.file_path ?? "");
                         // Check-owning files (tsconfig.json, pytest.ini, vitest.config.ts …)
-                        // are tracked even when they are not source code: editing one is how
-                        // a red suite is turned green without fixing anything.
+                        // are tracked even when they are not source code: editing one
+                        // invalidates earlier check results.
                         if (filePath && (isCodeFilePath(filePath) || isCheckOwnFile(filePath))) {
-                            const addedText = name === "write"
-                                ? String(args.content ?? "")
-                                : extractAddedLines(event.details?.diff ?? event.result);
-                            this.verificationGate.recordMutation(filePath, addedText);
+                            this.verificationGate.recordMutation(filePath);
                             verificationChanged = true;
                         }
                     }
@@ -1307,7 +1245,7 @@ export class AgentSession {
                                         : {}),
                                 });
                             else if (classification.snapshotEligible)
-                                this.verificationGate.requireFreshVerification(true, command);
+                                this.verificationGate.requireFreshVerification(true);
                         }
                         else if (args.persist === true) {
                             // Persistent-shell checks are not bounded evidence (steering can
@@ -1365,10 +1303,35 @@ export class AgentSession {
                 // Tool results for this step are in the array and their side effects
                 // already hit the filesystem. Flushing here is what makes a crash lose
                 // at most the in-flight step instead of the entire turn.
+                await this.creditBashReads();
                 await this.flushPendingMessages();
                 break;
         }
     }
+    /**
+     * Count full-file `cat` output from the step that just finished as reads, so
+     * an edit after `cat` does not cost a second read. Uses the step's results as
+     * stored in the transcript (after per-turn trimming): only bytes the model
+     * actually received count.
+     */
+    async creditBashReads() {
+        if (!this.recordBashReads)
+            return;
+        const messages = this.activeLoopMessages ?? this.messages;
+        const toolMessage = messages.at(-1);
+        const assistant = messages.at(-2);
+        if (toolMessage?.role !== "tool" || assistant?.role !== "assistant")
+            return;
+        if (typeof assistant.content === "string")
+            return;
+        const calls = assistant.content.filter((part) => part.type === "tool_call");
+        try {
+            await this.recordBashReads(calls, toolMessage.content);
+        }
+        catch (err) {
+            log("WARN", "agent-session", "Crediting bash reads failed", { error: String(err) });
+        }
+    }
     /**
      * Append every message added since the last flush to the session file.
      *
@@ -1431,7 +1394,7 @@ export class AgentSession {
         const diagnosticText = this.lspManager?.drainDiagnostics(this.getVerificationProblem() !== null, { deferUnverified: true });
         if (diagnosticText)
             this.eventBus.emit("diagnostics", { text: diagnosticText });
-        this.refreshVerificationArmed();
+        this.refreshHookArming();
         const notified = this.notifications.drain();
         const notificationMessage = notified.length > 0 || diagnosticText
             ? {
@@ -1494,6 +1457,7 @@ export class AgentSession {
         }
         if (this.opts.selfCorrectionHooks === false)
             return null;
+        // Legacy key: the user-facing switch for loop-break and re-grounding nudges.
         if (!this.settingsManager.get("idealReviewEnabled"))
             return null;
         // Deterministic stuck verdict, computed once and shared: the semantic
@@ -1693,83 +1657,6 @@ export class AgentSession {
                 .join("\n")
             : "";
     }
-    /** Independent fresh-context review of the finished work (Codex Guardian
-     *  pattern). Spawns a READ-ONLY child on the ACTIVE model, waits bounded,
-     * and returns findings for the acting agent to address — or nothing when
-     *  the review passes, is unavailable, or fails (in-thread review remains the
-     *  fallback; the feature degrades, never blocks).
-     *
-     *  Runs inside the pre-stop poll, so the candidate final answer is already
-     *  held by arming and this wait cannot race a streamed answer. */
-    async runIndependentReview(decision) {
-        if (!this.subAgentManager)
-            return [];
-        if (this.independentReviewStarted)
-            return [];
-        // An allow-listed session (a subagent worker itself) must not spawn
-        // harness-owned grandchildren the tool policy never granted.
-        if (this.opts.allowedTools && !this.opts.allowedTools.includes("spawn_agent"))
-            return [];
-        if (decision.score < INDEPENDENT_REVIEW_SCORE_THRESHOLD)
-            return [];
-        this.independentReviewStarted = true;
-        const taskName = `ideal-reviewer-${Math.random().toString(36).slice(2, 8)}`;
-        let agentId;
-        try {
-            const task = buildReviewerTask({
-                originalRequest: this.originalRequest,
-                changedFiles: [...this.hookFileEditCounts.keys()],
-                stats: this.hookStats,
-                triggerReasons: decision.reasons,
-            });
-            // Active model forced at spawn time — never routed to a fast/review model.
-            // The reviewer's own time limit ends it with a verdict on what it read;
-            // the wait below is only a backstop against a hung child.
-            const snapshot = await this.subAgentManager.spawn(taskName, task, undefined, {
-                model: this.model,
-                tools: REVIEWER_TOOLS,
-                turnTimeoutMs: REVIEWER_TURN_TIMEOUT_MS,
-            });
-            agentId = snapshot.agent_id;
-            const waited = await this.subAgentManager.wait([agentId], "all", REVIEWER_WAIT_MS);
-            const agent = waited.agents[0];
-            if (!agent || !isTerminalSubAgentState(agent.state)) {
-                // Timeout: collect the straggler so the completion gate cannot fire on
-                // it later, then fall back to the in-thread review.
-                await this.subAgentManager.interrupt(agentId, true).catch(() => { });
-                log("WARN", "ideal", "Independent reviewer timed out; falling back to in-thread review", {
-                    agentId,
-                });
-                return [];
-            }
-            const findings = parseReviewerFindings(agent.output ?? "");
-            if (!findings) {
-                log("WARN", "ideal", "Independent reviewer output unparseable; falling back", {
-                    agentId,
-                    state: agent.state,
-                    ...(agent.error ? { error: agent.error } : {}),
-                });
-                return [];
-            }
-            if (findings.clean) {
-                log("INFO", "ideal", "Independent reviewer verdict: clean", { agentId });
-                return [];
-            }
-            log("INFO", "ideal", "Independent reviewer flagged findings", {
-                agentId,
-                count: String(findings.findings.length),
-            });
-            return [buildIndependentReviewMessage(findings.findings)];
-        }
-        catch (error) {
-            if (agentId)
-                await this.subAgentManager.interrupt(agentId, true).catch(() => { });
-            log("WARN", "ideal", "Independent reviewer failed; falling back to in-thread review", {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return [];
-        }
-    }
     /**
      * Turn-budget extension gate. The loop consults this instead of stopping
      * mid-task when it exhausts `maxTurns`. Grant ONLY on evidence of progress —
@@ -1803,98 +1690,28 @@ export class AgentSession {
         });
         return granted;
     }
-    /**
-     * Would the stop AFTER the current turn inject the Ideal review? Same inputs
-     * as the pre-stop gate below, evaluated early so clients know a candidate
-     * final answer is a review draft BEFORE it streams.
-     *
-     * The turn count is looked ahead by one on purpose. `hookStats.turns` only
-     * advances at `turn_end`, so while the model is writing the draft the counter
-     * still reads the PREVIOUS turn; the real gate sees one more. Without the
-     * lookahead a run sitting on score 3 crosses to 4 on the draft's own
-     * `turn_end` — after the text already streamed — which is precisely the
-     * appear-then-vanish flash. Over-arming by one turn point costs only live
-     * token streaming on a final answer that then shows whole; under-arming costs
-     * the flash, so this errs toward arming.
-     */
-    wouldInjectIdealReview() {
+    /** Would a stop right now inject a pre-final follow-up? Only queued LSP
+     *  diagnostics (real errors injected below) or a mode-owned completion
+     *  review can, so clients hold the candidate answer only then. */
+    wouldInjectBeforeFinal() {
         if (this.opts.completionReview?.armed)
             return true;
-        if (this.opts.selfCorrectionHooks === false || this.idealReviewSuppressed)
-            return false;
-        // Mid-review a stop still injects: the coverage follow-up while files are
-        // unread, or its escalation once the budget is spent. Both make the model
-        // answer again, so the candidate answer is a draft exactly as it is before
-        // the review starts — without arming here it paints and the reviewed answer
-        // lands under it as a duplicate.
-        if (this.idealReviewPhase === "reviewing") {
-            return this.reviewCoverage.evidence().missing.length > 0;
-        }
-        if (this.idealReviewPhase !== "idle")
-            return false;
-        if (!this.settingsManager.get("idealReviewEnabled"))
-            return false;
-        if (evaluateIdealReview({ ...this.hookStats, turns: this.hookStats.turns + 1 }).shouldReview) {
-            return true;
-        }
-        const files = this.hookFileEditCounts.size;
-        if (files === 0)
-            return false;
-        if (this.idealDriftProbe?.files !== files) {
-            this.idealDriftProbe = {
-                files,
-                drifted: detectTestDrift(this.hookFileEditCounts.keys(), this.cwd).length > 0,
-            };
-        }
-        return this.idealDriftProbe.drifted;
-    }
-    /** Would a stop right now inject the verification gate? Same conditions as
-     *  the pre-stop branch below, so arming and injection cannot disagree. */
-    wouldInjectVerification() {
-        if (this.lspManager?.hasQueuedDiagnostics())
-            return true;
-        if (this.opts.selfCorrectionHooks === false)
-            return false;
-        if (!this.settingsManager.get("verificationGateEnabled"))
-            return false;
-        if (this.opts.allowedTools && !this.opts.allowedTools.includes("bash"))
-            return false;
-        return this.verificationGate.willInject();
+        return this.lspManager?.hasQueuedDiagnostics() ?? false;
     }
     /** Broadcast pre-final hook arming on change. Both edges matter: armed=false
-     *  after the hook fires is what lets a client stream the REVIEWED final
-     *  answer live again.
-     *
-     *  Callable before `initialize()`: the sidecar sets Ken's review suppression
-     *  on a freshly constructed session, and every arming predicate below reads
-     *  settings that `initialize()` has not loaded yet. Nothing can be armed
-     *  before the session can run a turn, and the first `tool_result`/`turn_end`
-     *  recomputes both edges — so skipping is the correct answer, not a patch. */
+     *  after the hook fires is what lets a client stream the final answer live
+     *  again. Callable before `initialize()`, when no manager exists yet. */
     refreshHookArming() {
-        if (!this.settingsManager)
-            return;
-        this.refreshIdealReviewArmed();
-        this.refreshVerificationArmed();
-    }
-    refreshVerificationArmed() {
-        if (!this.settingsManager)
-            return;
-        const armed = this.wouldInjectVerification();
-        if (armed === this.verificationArmed)
+        const armed = this.wouldInjectBeforeFinal();
+        if (armed === this.preFinalArmed)
             return;
-        this.verificationArmed = armed;
+        this.preFinalArmed = armed;
         this.eventBus.emit("hook_armed", { kind: "verification", armed });
     }
-    refreshIdealReviewArmed() {
-        const armed = this.wouldInjectIdealReview();
-        if (armed === this.idealReviewArmed)
-            return;
-        this.idealReviewArmed = armed;
-        this.eventBus.emit("hook_armed", { kind: "ideal", armed });
-    }
     /**
-     * Pre-stop Ideal review phase machine. Once review starts, completion is
-     * blocked until harness-owned post-injection reads cover every changed file.
+     * Pre-stop follow-ups: LSP errors, unread child agents and background
+     * processes, and a mode-owned completion review. Verification evidence is
+     * tracked passively for run status; it never forces another turn.
      */
     async getHookFollowUpMessages() {
         // Exit notifications and task_output refer to the same host process record.
@@ -1907,14 +1724,16 @@ export class AgentSession {
         if (backgroundChanged)
             await this.persistVerificationState();
         // Edits return immediately; only the completion boundary waits for remaining
-        // checks. Queued timeouts stay explicitly unverified, never a false all-clear.
+        // checks. Only real errors cost another turn: a timed-out or unavailable
+        // server proves nothing either way, and run status already reports
+        // unverified changes without making the model answer twice.
         await this.lspManager?.flushDiagnostics(this.opts.signal);
         if (this.opts.signal?.aborted)
             return null;
-        const diagnosticText = this.lspManager?.drainDiagnostics(this.getVerificationProblem() !== null);
+        const diagnosticText = this.lspManager?.drainDiagnostics(false);
         if (diagnosticText)
             this.eventBus.emit("diagnostics", { text: diagnosticText });
-        this.refreshVerificationArmed();
+        this.refreshHookArming();
         const diagnosticMessages = diagnosticText
             ? [
                 {
@@ -1938,48 +1757,6 @@ export class AgentSession {
             });
             return [...diagnosticMessages, ...processFollowUp];
         }
-        // Verification gate: code was edited but nothing verified since the last
-        // edit. Above the Ideal review so checks RUN before the read-based review
-        // starts; off for allow-listed sessions that cannot run commands at all.
-        if (this.opts.selfCorrectionHooks !== false &&
-            this.settingsManager.get("verificationGateEnabled") &&
-            (!this.opts.allowedTools || this.opts.allowedTools.includes("bash"))) {
-            const verificationReason = this.verificationGate.pendingReason();
-            const pendingFiles = this.verificationGate.pendingFiles();
-            const verificationFollowUp = this.verificationGate.followUp();
-            if (verificationFollowUp) {
-                // Name the tests that actually reach the unverified files, with the
-                // command that runs exactly those, so the check is targeted rather
-                // than guessed. Best-effort: no index or no runner leaves it unchanged.
-                if (this.testImpact &&
-                    (verificationReason === "initial" || verificationReason === "recheck")) {
-                    const impactLine = await this.testImpact
-                        .impactFor(pendingFiles)
-                        .then(formatImpactForVerification)
-                        .catch(() => "");
-                    const first = verificationFollowUp[0];
-                    if (impactLine && first?.role === "user" && typeof first.content === "string") {
-                        verificationFollowUp[0] = { ...first, content: first.content + impactLine };
-                    }
-                }
-                log("INFO", "verification-gate", "Injecting verification follow-up", {});
-                // Announce, THEN disarm: clients release held text on disarm, so the
-                // reverse order paints the draft and immediately deletes it — the exact
-                // flash arming exists to prevent.
-                this.eventBus.emit("hook", {
-                    kind: "verification",
-                    ...(verificationReason === "tamper"
-                        ? { verificationReason: "check_review" }
-                        : verificationReason === "recheck"
-                            ? { verificationReason }
-                            : {}),
-                });
-                this.refreshHookArming();
-                return [...diagnosticMessages, ...verificationFollowUp];
-            }
-        }
-        // Address real errors before review; unavailable checks share the existing
-        // verification demand above instead of manufacturing a separate hook.
         if (diagnosticMessages.length > 0)
             return diagnosticMessages;
         if (this.opts.completionReview) {
@@ -1998,122 +1775,7 @@ export class AgentSession {
             }
             this.refreshHookArming();
         }
-        if (this.opts.selfCorrectionHooks === false || this.idealReviewSuppressed)
-            return null;
-        if (this.idealReviewPhase === "reviewing") {
-            const coverage = this.reviewCoverage.evidence();
-            const lspEvidence = this.reviewLspEvidence(coverage.expected);
-            log("INFO", "ideal", "Ideal review coverage check", {
-                covered: coverage.covered,
-                missing: coverage.missing,
-                lspLowConfidence: lspEvidence.lowConfidence,
-                lspMissing: lspEvidence.missing,
-            });
-            if (coverage.missing.length > 0) {
-                // Announce like any other pre-final injection: this follow-up makes the
-                // model answer again, so the answer it interrupts is a draft and the
-                // hook event is what tells clients to discard it. Injecting silently is
-                // what let the pre-coverage answer paint above the reviewed one.
-                this.eventBus.emit("hook", {
-                    kind: "ideal",
-                    coverageExpected: coverage.expected,
-                    coverageMissing: coverage.missing,
-                });
-                if (this.reviewCoverageInjected < MAX_REVIEW_COVERAGE_INJECTIONS) {
-                    this.reviewCoverageInjected += 1;
-                    // Stays armed (coverage is still outstanding) — this call is here so a
-                    // client that missed the earlier edge is armed before the next draft.
-                    this.refreshIdealReviewArmed();
-                    return [
-                        this.withReviewLspEvidence(buildReviewCoverageMessage(coverage.missing), lspEvidence),
-                    ];
-                }
-                // Budget spent: close the gate so the run cannot spin on a file that
-                // never becomes readable, and require the gap be reported to the user.
-                this.idealReviewPhase = "complete";
-                // The gate is shut, so this is the real disarm: the answer to the
-                // escalation is final and streams live.
-                this.refreshIdealReviewArmed();
-                log("INFO", "ideal", "Ideal review coverage escalated after retry budget", {
-                    injected: String(this.reviewCoverageInjected),
-                    missing: coverage.missing,
-                });
-                return [buildReviewCoverageEscalationMessage(coverage.missing)];
-            }
-            this.idealReviewPhase = "complete";
-            return null;
-        }
-        if (this.idealReviewPhase === "complete")
-            return null;
-        if (!this.settingsManager.get("idealReviewEnabled"))
-            return null;
-        const decision = evaluateIdealReview(this.hookStats);
-        // Test drift fires the review even on a small change the score would skip:
-        // a green-but-stale test is exactly what the volume gate sleeps through.
-        const driftedFiles = detectTestDrift(this.hookFileEditCounts.keys(), this.cwd).slice(0, 5);
-        if (!decision.shouldReview && driftedFiles.length === 0)
-            return null;
-        // Independent reviewer first (async, bounded): its findings ride in the
-        // SAME follow-up batch as the in-thread review + coverage requirements, so
-        // addressing everything still costs one extra turn.
-        this.reviewCoverage.start(this.hookFileEditCounts.keys());
-        this.idealReviewPhase = "reviewing";
-        const coverage = this.reviewCoverage.evidence();
-        const lspEvidence = this.reviewLspEvidence(coverage.expected);
-        this.eventBus.emit("hook", {
-            kind: "ideal",
-            coverageExpected: coverage.expected,
-            coverageMissing: coverage.missing,
-        });
-        // Recompute strictly AFTER the hook event: clients release held text on
-        // disarm, so the reverse order would paint the draft and then delete it —
-        // the exact flash arming exists to prevent. Arming normally PERSISTS here,
-        // because review starts with every changed file uncovered and a stop while
-        // coverage is outstanding injects again. Disarm lands later, on the read
-        // that closes the last gap (or when the retry budget escalates).
-        this.refreshIdealReviewArmed();
-        // Announce the phase before the reviewer starts, not after its bounded wait.
-        const independentMessages = await this.runIndependentReview(decision);
-        log("INFO", "ideal", "Injecting ideal review before final response", {
-            coverageExpected: coverage.expected,
-            coverageMissing: coverage.missing,
-            lspLowConfidence: lspEvidence.lowConfidence,
-            lspMissing: lspEvidence.missing,
-        });
-        return [
-            ...independentMessages,
-            this.withReviewLspEvidence(withReviewCoverageRequirements(buildIdealReviewMessage(decision.reasons, driftedFiles), coverage.missing), lspEvidence),
-        ];
-    }
-    reviewLspEvidence(files) {
-        const lowConfidence = [];
-        const missing = [];
-        for (const filePath of files) {
-            const outcome = this.lspManager?.getLatestOutcome(filePath);
-            if (outcome?.kind === "low_confidence")
-                lowConfidence.push(filePath);
-            else if (outcome?.kind !== "clean" && outcome?.kind !== "diagnostics")
-                missing.push(filePath);
-        }
-        return { lowConfidence, missing };
-    }
-    withReviewLspEvidence(message, evidence) {
-        if (evidence.lowConfidence.length === 0 && evidence.missing.length === 0)
-            return message;
-        const notes = [
-            ...(evidence.lowConfidence.length > 0
-                ? [`Diagnostics are low confidence while indexing: ${evidence.lowConfidence.join(", ")}.`]
-                : []),
-            ...(evidence.missing.length > 0
-                ? [`Diagnostics evidence is unavailable or missing: ${evidence.missing.join(", ")}.`]
-                : []),
-            "Do not describe those files as compiler-clean without other evidence.",
-        ];
-        return {
-            role: "user",
-            provenance: message.provenance,
-            content: `${String(message.content)}\n\n${notes.join(" ")}`,
-        };
+        return null;
     }
     /** Wraps the real run: cancels an in-flight cache prewarm and tracks run
      *  activity / last real request time for {@link prewarm}. */
@@ -2280,6 +1942,8 @@ export class AgentSession {
                 // + pre-warm before the first turn. "baseline": current 5-min default.
                 cacheRetention: this.isSpeedOptimized() ? "long" : "short",
                 promptCacheKey: this.getPromptCacheKey(),
+                responsesLite: resolveResponsesLite(this.codexShapeSetting("codexResponsesLite"), this.provider, this.model),
+                strictTools: resolveStrictTools(this.codexShapeSetting("codexStrictTools"), this.provider),
                 onContextPrepared: (context) => {
                     const report = this.cacheDiagnostics.prepare(context, {
                         provider: this.provider,
@@ -3288,21 +2952,6 @@ export class AgentSession {
     getPlanMode() {
         return this.planModeRef.current;
     }
-    /**
-     * Suppress only the pre-final Ideal self-review for this live session.
-     * Autopilot uses this while Ken independently owns verification; loop-break
-     * and post-compaction re-grounding remain active.
-     */
-    setIdealReviewSuppressed(suppressed) {
-        this.idealReviewSuppressed = suppressed;
-        if (suppressed) {
-            this.idealReviewPhase = "idle";
-            this.reviewCoverage.reset();
-        }
-        // Suppression flips mid-run (autopilot takes over verification), so a client
-        // holding a draft under a stale arming must be released.
-        this.refreshHookArming();
-    }
     /** Queue a user message (optionally with attachments) to be injected mid-run
      *  as steering. Returns the new queue length. No-op semantics are the caller's
      *  concern. */
@@ -3788,7 +3437,7 @@ export class AgentSession {
             ? await captureVerificationSnapshot(this.opts.cwd, [...this.hookFileEditCounts.keys()])
             : null;
         if (after === null || after !== check.sourceSnapshot) {
-            this.verificationGate.requireFreshVerification(true, check.command);
+            this.verificationGate.requireFreshVerification(true);
             this.verificationGate.recordRejectedCheck(check.command, after === null
                 ? "Workspace inputs could not be compared; run a read-only check after the command"
                 : "Command changed workspace inputs; run checks against the changed source");
@@ -4157,6 +3806,9 @@ export class AgentSession {
                 this.prewarmController = null;
         }
     }
+    codexShapeSetting(key) {
+        return this.settingsManager?.get(key) ?? "auto";
+    }
     /** True when speedProfile is "optimized" (1-h cache TTL + pre-warm), or the
      *  session was constructed with `forceLongCacheRetention` (Ken sessions). */
     isSpeedOptimized() {