@kenkaiiii/ggcoder 5.69.0 → 5.71.0

package/dist/core/agent-session.js

@@ -24,8 +24,9 @@ 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 { 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 { z } from "zod";
 import { MCPClientManager, getAllMcpServers } from "./mcp/index.js";
@@ -50,15 +51,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";
@@ -73,14 +72,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) {
@@ -149,20 +140,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;
@@ -172,20 +156,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;
@@ -195,8 +165,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
@@ -207,11 +175,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
@@ -262,6 +230,7 @@ export class AgentSession {
     steeringListeners = new Set();
     processManager;
     lspManager;
+    debugManager;
     subAgentManager;
     /**
      * Out-of-band push notifications (finished children, background-process
@@ -365,7 +334,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;
@@ -431,7 +399,7 @@ export class AgentSession {
             : this.opts.globalSubagents
                 ? await discoverAgents({ globalAgentsDir: paths.agentsDir })
                 : [];
-        const { tools: builtInTools, processManager, rebuildReadTool, clearReadTracker, lspManager, 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,
@@ -462,17 +430,14 @@ 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.
             getProvider: () => this.provider,
             getModel: () => this.model,
-            getThinkingLevel: () => this.thinkingLevel,
             getBaseUrl: () => this.baseUrl,
             getCacheKey: () => this.getPromptCacheKey(),
             getMaxPerModel: () => this.settingsManager.get("subagentMaxPerModel"),
@@ -523,8 +488,10 @@ export class AgentSession {
         }
         this.rebuildReadTool = rebuildReadTool;
         this.clearReadTracker = clearReadTracker;
+        this.recordBashReads = recordBashReads;
         this.processManager = processManager;
         this.lspManager = lspManager;
+        this.debugManager = debugManager;
         this.subAgentManager = subAgentManager;
         this.bindManagerCancellation(this.opts.signal);
         // Connect MCP servers. The connect attempt itself can block for up to the
@@ -1111,15 +1078,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;
@@ -1128,13 +1087,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 = [];
@@ -1145,7 +1097,6 @@ export class AgentSession {
             verdict: null,
             injected: false,
         };
-        this.independentReviewStarted = false;
         this.runStartedAt = Date.now();
         this.processGateInjected = 0;
         this.verificationGate.beginRun();
@@ -1166,8 +1117,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) {
@@ -1210,7 +1161,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)) {
@@ -1220,7 +1171,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();
                 }
@@ -1233,12 +1184,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);
@@ -1255,12 +1200,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;
@@ -1268,13 +1207,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;
                         }
                     }
@@ -1283,8 +1219,13 @@ export class AgentSession {
                     const command = typeof args.command === "string" ? args.command : "";
                     const classification = classifyVerificationCommand(command);
                     if (classification.accepted || classification.snapshotEligible) {
-                        if (args.run_in_background === true && !event.isError && args.persist !== true) {
-                            const id = /^ID:\s*(\S+)/m.exec(event.result)?.[1];
+                        // A foreground check that outlived the default budget was moved to
+                        // the background, not failed: track it to its real exit the same way.
+                        const autoBackgroundId = event.isError ? undefined : autoBackgroundedId(event.result);
+                        if ((autoBackgroundId !== undefined || args.run_in_background === true) &&
+                            !event.isError &&
+                            args.persist !== true) {
+                            const id = autoBackgroundId ?? /^ID:\s*(\S+)/m.exec(event.result)?.[1];
                             // No parseable ID means the check cannot be tracked to a real exit
                             // code — no evidence either way. Recording a FAILURE here made
                             // every later green run of a different spelling look owed.
@@ -1297,7 +1238,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
@@ -1355,10 +1296,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.
      *
@@ -1421,7 +1387,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
             ? {
@@ -1484,6 +1450,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
@@ -1683,83 +1650,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 —
@@ -1793,98 +1683,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)
+        const armed = this.wouldInjectBeforeFinal();
+        if (armed === this.preFinalArmed)
             return;
-        const armed = this.wouldInjectVerification();
-        if (armed === this.verificationArmed)
-            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.
@@ -1897,14 +1717,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
             ? [
                 {
@@ -1928,33 +1750,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 verificationFollowUp = this.verificationGate.followUp();
-            if (verificationFollowUp) {
-                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) {
@@ -1973,122 +1768,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}. */
@@ -3263,21 +2943,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. */
@@ -3339,6 +3004,15 @@ export class AgentSession {
             return `No background process with id "${id}"`;
         return this.processManager.stop(id);
     }
+    /**
+     * Force-stop every background process tree, synchronously. Background
+     * commands run in their own process group, so the daemon's group kill on
+     * quit never reaches them: this is the only thing that does. Callers on a
+     * shutdown deadline run it before awaiting anything that can hang.
+     */
+    stopBackgroundProcesses() {
+        this.processManager?.shutdownAll();
+    }
     /** Replace a host-owned system prompt in place without resetting conversation history. */
     setCustomSystemPrompt(systemPrompt, promptCacheKeyPrefix) {
         this.customSystemPrompt = systemPrompt;
@@ -3754,7 +3428,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");
@@ -4151,6 +3825,9 @@ export class AgentSession {
         return this.getPromptCacheKey();
     }
     async dispose() {
+        // First and synchronous: nothing below may delay this, or a hung teardown
+        // step leaves background commands running after the app has quit.
+        this.stopBackgroundProcesses();
         // Quiesce any in-flight post-turn compaction BEFORE tearing down state:
         // the background compact() snapshots and replaces `this.messages`, so
         // letting it run past this point would checkpoint a near-empty history
@@ -4160,8 +3837,10 @@ export class AgentSession {
         this.cacheDiagnostics.reset();
         this.diagnosticsRecorder?.finalize();
         this.managerAbortSignal?.removeEventListener("abort", this.managerAbortHandler);
-        this.processManager?.shutdownAll();
+        // Again, in case a turn racing teardown started one while we awaited.
+        this.stopBackgroundProcesses();
         this.lspManager?.shutdownAll();
+        this.debugManager?.shutdown();
         await Promise.all([this.subAgentManager?.shutdownAll(), this.mcpManager?.dispose()]);
         await this.extensionLoader.deactivateAll();
         this.setSessionPath("");