@prestyj/cli 5.17.0 → 5.20.0

package/dist/core/agent-session.js

@@ -31,10 +31,13 @@ import { CONTEXT_LIMITS, resolveContextLimits } from "./context-limits.js";
 import { McpCatalogCache } from "./mcp/catalog-cache.js";
 import { describeDropped, importForeignSession, } from "./foreign-session-import.js";
 import { createToolSearchTool } from "../tools/tool-search.js";
+import { createSessionStatsTool } from "../tools/session-stats.js";
+import { createDiagnoseCommand, isInternalDiagnosticsEnabled, SessionDiagnosticsRecorder, } from "./internal-diagnostics.js";
 import { log } from "./logger.js";
 import { setEstimatorModel, calibrateEstimatorFromUsage } from "./compaction/token-estimator.js";
 import { calculateActiveContextTokens } from "./compaction/active-context.js";
 import { resolveCompactionPolicy } from "./compaction/policy.js";
+import { clampThinkingForPlanMode } from "./thinking-level.js";
 import { pruneStaleToolResults } from "./compaction/tool-result-pruner.js";
 import { discoverAgents } from "./agents.js";
 import { enhancePrompt } from "../utils/prompt-enhancer.js";
@@ -49,6 +52,7 @@ import { wrapSteeringText, buildNotificationSteeringText, STEERING_PREFIX } from
 import { AgentNotificationQueue } from "./agent-notifications.js";
 import { VerificationGate, extractAddedLines, 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";
 import { normalizeMessageImages } from "./message-images.js";
 import crypto from "node:crypto";
@@ -124,6 +128,9 @@ export class AgentSession {
     // transcript rows the live run showed.
     appMarkers = [];
     turnMetrics = [];
+    /** Internal-only (EZ_INTERNAL): live per-session cost/reliability recorder.
+     * Absent entirely in public builds — see core/internal-diagnostics.ts. */
+    diagnosticsRecorder;
     tools = [];
     /** Rebuilds the read tool for a new model (video byte cap is baked in at
      *  creation). Called from switchModel so video-capable models get the
@@ -193,6 +200,15 @@ export class AgentSession {
      *  only on a real edge. */
     verificationArmed = false;
     compactionOccurred = false;
+    /**
+     * Re-grounding carry-over for post-turn compaction. `resetHookState` clears
+     * `compactionOccurred` at run start — before the injection point — so a
+     * background compaction that finished after the final response parks its
+     * "re-ground next turn" signal here for pickup at the next run start.
+     */
+    compactionArmedForNextRun = false;
+    /** In-flight post-turn (background) compaction, if any. */
+    postTurnCompaction;
     lastCompactionCompacted = false;
     compactionRetryAfter = 0;
     /** A restored oversized checkpoint must be canonicalized before its first prompt is persisted. */
@@ -221,6 +237,7 @@ export class AgentSession {
     notifications = new AgentNotificationQueue();
     managerAbortSignal;
     managerAbortHandler = () => {
+        this.lspManager?.clearPendingDiagnostics();
         void this.subAgentManager?.interruptAll();
     };
     mcpManager;
@@ -375,6 +392,7 @@ export class AgentSession {
             provider: this.provider,
             model: this.model,
             lspDiagnostics: this.settingsManager.get("lspDiagnostics"),
+            deferLspDiagnostics: true,
             getWriteGuardSettings: () => ({
                 allowOutsideWorkspaceWrites: this.settingsManager.get("allowOutsideWorkspaceWrites"),
                 additionalRoots: this.additionalRoots,
@@ -429,6 +447,11 @@ export class AgentSession {
                 : {}),
         });
         const tools = [...builtInTools, ...(this.opts.additionalTools ?? [])];
+        // Internal-only tool, appended last so public sessions keep a
+        // byte-identical tool block (prefix-cache stability).
+        if (isInternalDiagnosticsEnabled()) {
+            tools.push(createSessionStatsTool(() => this.diagnosticsRecorder));
+        }
         // Apply the optional tool allow-list (read-only advisory sessions). Filtering
         // here means the excluded tools are never registered with the agent loop, so
         // a hallucinated call can't mutate the repo — and buildSystemPrompt below is
@@ -528,6 +551,20 @@ export class AgentSession {
             const builtins = createBuiltinCommands();
             for (const cmd of builtins)
                 this.slashCommands.register(cmd);
+            // Internal-only diagnostics: recorder + /diagnose exist exclusively when
+            // the internal flag is on. Public sessions never see either, so the
+            // command list and prompt stay identical to a build without this code.
+            if (isInternalDiagnosticsEnabled()) {
+                this.diagnosticsRecorder = new SessionDiagnosticsRecorder({
+                    // Lazy: the session id is assigned at first prompt, not init.
+                    sessionId: () => this.sessionId,
+                    cwd: this.cwd,
+                    provider: this.provider,
+                    model: this.model,
+                });
+                this.diagnosticsRecorder.attach(this.eventBus);
+                this.slashCommands.register(createDiagnoseCommand());
+            }
             // Wire up /help to show all registered + prompt + custom commands.
             const helpCmd = this.slashCommands.get("help");
             if (helpCmd) {
@@ -862,6 +899,7 @@ export class AgentSession {
         kind: "prompt",
         visibility: "transcript",
     }, options = {}) {
+        await this.settlePostTurnCompaction();
         await this.adoptDeferredCheckpointBeforePrompt();
         const slash = await this.resolveSlashInput(content);
         if (slash?.kind === "template") {
@@ -896,6 +934,7 @@ export class AgentSession {
      * attachments are always a direct conversational turn.
      */
     async promptWithAttachments(text, attachments) {
+        await this.settlePostTurnCompaction();
         await this.adoptDeferredCheckpointBeforePrompt();
         const parts = this.buildAttachmentParts(text, attachments);
         if (parts.length === 0)
@@ -991,6 +1030,7 @@ export class AgentSession {
      * is the verbatim user ask, pinned for post-compaction re-grounding.
      */
     resetHookState(originalRequest) {
+        this.lspManager?.clearPendingDiagnostics();
         this.hookStats = {
             changedLines: 0,
             toolCalls: 0,
@@ -1035,6 +1075,13 @@ export class AgentSession {
                 this.backgroundVerification.delete(id);
         }
         this.compactionOccurred = false;
+        // Post-turn compaction may have landed between runs — adopt its armed
+        // signal so the re-grounding hook fires for this run exactly as it would
+        // after a pre-run compaction.
+        if (this.compactionArmedForNextRun) {
+            this.compactionArmedForNextRun = false;
+            this.compactionOccurred = true;
+        }
         this.originalRequest = originalRequest;
     }
     /**
@@ -1064,7 +1111,17 @@ export class AgentSession {
                     // it poisoned the gate on green output and re-armed the hook into
                     // every later question turn.
                     const classification = classifyVerificationCommand(event.args.command);
-                    this.verificationGate.requireFreshVerification(!classification.accepted && classification.mayMutate, event.args.command);
+                    if (classification.snapshotEligible && event.args.persist !== true) {
+                        const call = this.hookToolCalls.get(event.toolCallId);
+                        call.sourceSnapshot = await captureVerificationSnapshot(this.opts.cwd, [
+                            ...this.hookFileEditCounts.keys(),
+                        ]);
+                        if (call.sourceSnapshot === null)
+                            this.verificationGate.requireFreshVerification(true, event.args.command);
+                    }
+                    else {
+                        this.verificationGate.requireFreshVerification(!classification.accepted && classification.mayMutate, event.args.command);
+                    }
                     await this.persistVerificationState();
                 }
                 break;
@@ -1124,20 +1181,32 @@ export class AgentSession {
                 if (args && call && name === "bash") {
                     const command = typeof args.command === "string" ? args.command : "";
                     const classification = classifyVerificationCommand(command);
-                    if (classification.accepted) {
+                    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];
                             // 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.
                             if (id)
-                                this.backgroundVerification.set(id, { revision: call.revision, command });
+                                this.backgroundVerification.set(id, {
+                                    revision: call.revision,
+                                    command,
+                                    ...(classification.snapshotEligible
+                                        ? { sourceSnapshot: call.sourceSnapshot ?? null }
+                                        : {}),
+                                });
+                            else if (classification.snapshotEligible)
+                                this.verificationGate.requireFreshVerification(true, command);
                         }
                         else if (args.persist === true) {
                             // Persistent-shell checks are not bounded evidence (steering can
                             // interleave): neither a pass nor a failure. A recorded failure
                             // here blocked approval for sessions that prefer the shell.
                         }
+                        else if (classification.snapshotEligible) {
+                            await this.finishSnapshotVerification({ command, revision: call.revision, sourceSnapshot: call.sourceSnapshot ?? null }, !event.isError && /^Exit code:\s*0(?:\s|$)/i.test(event.result.trim()));
+                            verificationChanged = true;
+                        }
                         else {
                             if (!event.isError && /^Exit code:\s*0(?:\s|$)/i.test(event.result.trim())) {
                                 this.verificationGate.recordVerification(call.revision, command);
@@ -1147,6 +1216,7 @@ export class AgentSession {
                             }
                             verificationChanged = true;
                         }
+                        delete call.sourceSnapshot;
                     }
                     else if (classification.candidate) {
                         // Green but untrusted: remember WHY so the demand can tell the
@@ -1155,18 +1225,8 @@ export class AgentSession {
                     }
                 }
                 if (!event.isError && args && name === "task_output" && typeof args.id === "string") {
-                    const started = this.backgroundVerification.get(args.id);
-                    const proc = this.processManager?.list().find((p) => p.id === args.id);
-                    if (started && proc && proc.exitCode !== null) {
-                        if (proc.exitCode === 0) {
-                            this.verificationGate.recordVerification(started.revision, started.command);
-                        }
-                        else {
-                            this.verificationGate.recordFailedVerification(started.command, started.revision);
-                        }
-                        this.backgroundVerification.delete(args.id);
-                        verificationChanged = true;
-                    }
+                    verificationChanged =
+                        (await this.recordFinishedBackgroundVerification(args.id)) || verificationChanged;
                 }
                 if (verificationChanged)
                     await this.persistVerificationState();
@@ -1257,11 +1317,18 @@ export class AgentSession {
         // it in the very next turn instead of discovering it at the pre-stop
         // completion gate — but it never displaces user steering, which rides out
         // in the same batch when both are pending.
+        const diagnosticText = this.lspManager?.drainDiagnostics(this.getVerificationProblem() !== null, { deferUnverified: true });
+        if (diagnosticText)
+            this.eventBus.emit("diagnostics", { text: diagnosticText });
+        this.refreshVerificationArmed();
         const notified = this.notifications.drain();
-        const notificationMessage = notified.length > 0
+        const notificationMessage = notified.length > 0 || diagnosticText
             ? {
                 role: "user",
-                content: buildNotificationSteeringText(notified.map((entry) => entry.text)),
+                content: buildNotificationSteeringText([
+                    ...notified.map((entry) => entry.text),
+                    ...(diagnosticText ? [diagnosticText] : []),
+                ]),
                 provenance: { source: "runtime", kind: "notification", visibility: "hidden" },
             }
             : null;
@@ -1611,6 +1678,8 @@ export class AgentSession {
     /** 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"))
@@ -1632,6 +1701,11 @@ export class AgentSession {
         if (!this.settingsManager)
             return;
         this.refreshIdealReviewArmed();
+        this.refreshVerificationArmed();
+    }
+    refreshVerificationArmed() {
+        if (!this.settingsManager)
+            return;
         const armed = this.wouldInjectVerification();
         if (armed === this.verificationArmed)
             return;
@@ -1650,9 +1724,36 @@ export class AgentSession {
      * blocked until harness-owned post-injection reads cover every changed file.
      */
     async getHookFollowUpMessages() {
+        // Exit notifications and task_output refer to the same host process record.
+        // Do not force an extra polling tool/turn merely to acknowledge a known exit.
+        let backgroundChanged = false;
+        for (const id of this.backgroundVerification.keys()) {
+            backgroundChanged =
+                (await this.recordFinishedBackgroundVerification(id)) || backgroundChanged;
+        }
+        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.
+        await this.lspManager?.flushDiagnostics(this.opts.signal);
+        if (this.opts.signal?.aborted)
+            return null;
+        const diagnosticText = this.lspManager?.drainDiagnostics(this.getVerificationProblem() !== null);
+        if (diagnosticText)
+            this.eventBus.emit("diagnostics", { text: diagnosticText });
+        this.refreshVerificationArmed();
+        const diagnosticMessages = diagnosticText
+            ? [
+                {
+                    role: "user",
+                    content: buildNotificationSteeringText([diagnosticText]),
+                    provenance: { source: "runtime", kind: "notification", visibility: "hidden" },
+                },
+            ]
+            : [];
         const childCompletionFollowUp = buildSubAgentCompletionFollowUp(this.subAgentManager);
         if (childCompletionFollowUp)
-            return childCompletionFollowUp;
+            return [...diagnosticMessages, ...childCompletionFollowUp];
         // Background processes started this run and never read block completion:
         // their progress/exit checkpoints only land on the steering path, which an
         // agent about to stop never reaches.
@@ -1662,7 +1763,7 @@ export class AgentSession {
             log("INFO", "process-gate", "Injecting background-process completion gate", {
                 injected: String(this.processGateInjected),
             });
-            return processFollowUp;
+            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
@@ -1679,12 +1780,20 @@ export class AgentSession {
                 // flash arming exists to prevent.
                 this.eventBus.emit("hook", {
                     kind: "verification",
-                    ...(verificationReason === "recheck" ? { verificationReason } : {}),
+                    ...(verificationReason === "tamper"
+                        ? { verificationReason: "check_review" }
+                        : verificationReason === "recheck"
+                            ? { verificationReason }
+                            : {}),
                 });
                 this.refreshHookArming();
-                return verificationFollowUp;
+                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.selfCorrectionHooks === false || this.idealReviewSuppressed)
             return null;
         if (this.idealReviewPhase === "reviewing") {
@@ -1743,7 +1852,6 @@ export class AgentSession {
         // 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.
-        const independentMessages = await this.runIndependentReview(decision);
         this.reviewCoverage.start(this.hookFileEditCounts.keys());
         this.idealReviewPhase = "reviewing";
         const coverage = this.reviewCoverage.evidence();
@@ -1760,6 +1868,8 @@ export class AgentSession {
         // 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,
@@ -1839,6 +1949,11 @@ export class AgentSession {
         // of the public API model window. Failed/no-op attempts cool down across
         // prompts; provider overflow recovery still bypasses this path entirely.
         if (this.settingsManager.get("autoCompact") && Date.now() >= this.compactionRetryAfter) {
+            // A post-turn compaction may still be running in the background. Let it
+            // settle first: it usually already compacted this history, so the
+            // decision below turns into a no-op instead of duplicate work.
+            if (this.postTurnCompaction)
+                await this.postTurnCompaction;
             const contextWindow = getContextWindow(this.model, {
                 provider: this.provider,
                 accountId: creds.accountId,
@@ -1906,7 +2021,13 @@ export class AgentSession {
                 maxTokens: this.maxTokens,
                 maxTurns: this.opts.maxTurns,
                 maxTurnExtensions: this.opts.maxTurnExtensions,
-                thinking: this.thinkingLevel,
+                // Plan mode caps effort at medium (Codex `plan_mode_reasoning_effort`
+                // preset): read-only exploration doesn't need xhigh/max reasoning, and
+                // deep-reasoning models left at the ceiling burn enormous thinking
+                // budgets re-deriving context they cannot act on.
+                thinking: this.planModeRef.current
+                    ? clampThinkingForPlanMode(this.thinkingLevel)
+                    : this.thinkingLevel,
                 apiKey,
                 // Per-turn credential resolution. A run can span many minutes; if any
                 // process sharing auth.json refreshes this grant meanwhile, the token
@@ -2172,8 +2293,15 @@ export class AgentSession {
             await this.persistMessage(this.messages[i]);
         }
         this.lastPersistedIndex = this.messages.length;
+        // Final response is delivered — compact in the background while the user
+        // reads it, instead of charging the summarizer latency to their next
+        // prompt. Detached by design; the pre-run path above remains the backstop.
+        this.maybeCompactPostTurn(creds);
     }
     async switchModel(provider, model) {
+        // The model-switch note is appended to `this.messages`; settle any
+        // background compaction first so the note cannot be swapped out.
+        await this.settlePostTurnCompaction();
         const prevProvider = this.provider;
         const prevModel = this.model;
         // Diff gate: a "switch" to the model already in use is not state change.
@@ -2374,7 +2502,104 @@ export class AgentSession {
             newCount: result.newCount,
         });
     }
-    async compact(existingCredentials, mode = "manual") {
+    /**
+     * Wait out any in-flight post-turn background compaction before a new
+     * entry point mutates `this.messages` (prompt, attachments, model switch).
+     * The background compact() snapshots and then REPLACES the array, so a
+     * message pushed while it runs would be silently dropped from the live
+     * history — the pre-run await in runLoop() sits after the push and cannot
+     * protect it.
+     */
+    async settlePostTurnCompaction() {
+        if (this.postTurnCompaction)
+            await this.postTurnCompaction;
+    }
+    /**
+     * Post-turn compaction: once the final response has been delivered, compact
+     * in the background while the user reads the answer, instead of making the
+     * next prompt pay the summarizer latency up front (the pre-run path stays as
+     * the backstop, so a skipped or failed attempt costs nothing). Mirrors the
+     * Codex `model_post_turn_compact_threshold_percent` guards: skip when user
+     * input is already queued (it would race the next turn), when the run was
+     * aborted, or during the failure cooldown — and never let a compaction
+     * error surface in the completed turn.
+     */
+    maybeCompactPostTurn(creds) {
+        if (!this.settingsManager.get("autoCompact"))
+            return;
+        if (this.opts.signal?.aborted)
+            return;
+        if (this.userQueue.length > 0)
+            return;
+        if (this.postTurnCompaction)
+            return;
+        if (Date.now() < this.compactionRetryAfter)
+            return;
+        // One compaction per turn boundary: a pre-run or overflow-recovery
+        // compaction already shrank this run's history — re-probing right after
+        // the final response would only re-derive that decision.
+        if (this.compactionOccurred)
+            return;
+        const contextWindow = getContextWindow(this.model, {
+            provider: this.provider,
+            accountId: creds.accountId,
+        });
+        const policy = resolveCompactionPolicy({
+            provider: this.provider,
+            model: this.model,
+            contextWindow,
+            threshold: this.settingsManager.get("compactThreshold"),
+            accountId: creds.accountId,
+            approvedPlanPath: this.approvedPlanPath,
+        });
+        let activeTokens;
+        if (this.providerContext) {
+            const anchorIndex = this.messages.lastIndexOf(this.providerContext.anchor);
+            if (anchorIndex >= 0) {
+                activeTokens = calculateActiveContextTokens(this.messages, {
+                    usage: this.providerContext.usage,
+                    pendingMessages: this.messages.slice(anchorIndex + 1),
+                });
+            }
+        }
+        if (!shouldCompact(this.messages, contextWindow, policy.threshold, activeTokens))
+            return;
+        log("INFO", "compaction", "Post-turn compaction decision — compacting in background", {
+            provider: this.provider,
+            model: this.model,
+            transport: this.provider === "openai" && creds.accountId ? "codex_oauth" : "public_api",
+            contextWindow: String(contextWindow),
+            activeTokens: activeTokens === undefined ? "estimated" : String(activeTokens),
+            triggerLimit: String(policy.targetTokens),
+        });
+        this.postTurnCompaction = (async () => {
+            try {
+                await this.compact(creds, "automatic");
+                if (this.lastCompactionCompacted) {
+                    // Arm re-grounding for the next turn. resetHookState clears
+                    // compactionOccurred at run start, before the injection point, so
+                    // park the signal for pickup there.
+                    this.compactionArmedForNextRun = true;
+                    this.compactionRetryAfter = 0;
+                }
+                else {
+                    this.compactionRetryAfter = Date.now() + 30_000;
+                }
+            }
+            catch (error) {
+                this.compactionRetryAfter = Date.now() + 30_000;
+                if (isAbortError(error) || this.opts.signal?.aborted)
+                    return;
+                log("WARN", "compaction", `Post-turn compaction failed; cooling down for 30s: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            finally {
+                this.postTurnCompaction = undefined;
+            }
+        })();
+    }
+    async compact(existingCredentials, mode = "manual", 
+    /** User-stated focus (`/compact <focus>`): what must survive verbatim. */
+    focus) {
         this.lastCompactionCompacted = false;
         const creds = existingCredentials ??
             (await this.authStorage.resolveCredentials(this.provider, {
@@ -2407,6 +2632,7 @@ export class AgentSession {
                 targetTokens: policy.targetTokens,
                 signal: this.opts.signal,
                 approvedPlanPath: this.approvedPlanPath,
+                focus,
             });
             contextSelection = output.result.contextSelection;
             return output;
@@ -2968,6 +3194,9 @@ export class AgentSession {
             },
         };
         this.turnMetrics.push(payload);
+        // Internal diagnostics piggyback on the authoritative per-turn metric —
+        // one source of truth, and the record flushes to disk every turn.
+        this.diagnosticsRecorder?.recordTurnMetric(payload);
         if (this.sessionPath)
             await this.sessionManager.appendTurnMetric(this.sessionPath, payload);
     }
@@ -3066,7 +3295,55 @@ export class AgentSession {
      * instead of dropping the marker or falling back to a raw verdict string.
      * No-op persistence for transient sessions (kept in memory only).
      */
+    async recordFinishedBackgroundVerification(id) {
+        const started = this.backgroundVerification.get(id);
+        const proc = this.processManager?.list().find((entry) => entry.id === id);
+        if (!started || !proc || proc.exitCode === null)
+            return false;
+        if (started.sourceSnapshot !== undefined) {
+            await this.finishSnapshotVerification(started, proc.exitCode === 0);
+        }
+        else if (proc.exitCode === 0) {
+            this.verificationGate.recordVerification(started.revision, started.command);
+        }
+        else {
+            this.verificationGate.recordFailedVerification(started.command, started.revision);
+        }
+        this.backgroundVerification.delete(id);
+        return true;
+    }
+    getVerificationEvidence() {
+        return this.verificationGate.evidence();
+    }
+    async finishSnapshotVerification(check, passed) {
+        const after = check.sourceSnapshot
+            ? await captureVerificationSnapshot(this.opts.cwd, [...this.hookFileEditCounts.keys()])
+            : null;
+        if (after === null || after !== check.sourceSnapshot) {
+            this.verificationGate.requireFreshVerification(true, check.command);
+            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");
+            if (!passed)
+                this.verificationGate.recordFailedVerification(check.command);
+        }
+        else if (passed) {
+            const classification = classifyVerificationCommand(check.command);
+            if (classification.snapshotPreserveOnly) {
+                this.verificationGate.recordRejectedCheck(check.command, classification.reason);
+            }
+            else {
+                this.verificationGate.recordVerification(check.revision, check.command);
+            }
+        }
+        else {
+            this.verificationGate.recordFailedVerification(check.command, check.revision);
+        }
+    }
     getVerificationProblem() {
+        if ([...this.hookToolCalls.values()].some((call) => call.sourceSnapshot !== undefined)) {
+            return "Unverified: a build is still running or its workspace comparison is pending.";
+        }
         return (this.verificationGate.verificationProblem() ??
             (this.backgroundVerification.size > 0
                 ? "Unverified: a background check is still running or its result has not been confirmed."
@@ -3214,7 +3491,10 @@ export class AgentSession {
     async enhancePrompt(text) {
         if (!text.trim())
             return { enhanced: text, segments: [{ kind: "text", text }] };
-        const creds = await this.authStorage.resolveCredentials(this.provider, {
+        // Keep credentials and settings on the model selected at click time, even
+        // if the user switches models while credential resolution is pending.
+        const { provider, model, thinkingLevel, maxTokens, baseUrl } = this;
+        const creds = await this.authStorage.resolveCredentials(provider, {
             storageKeys: this.currentAuthStorageKeys(),
         });
         // Cheap, best-effort stack detection from the project root so terminology is
@@ -3227,12 +3507,16 @@ export class AgentSession {
             /* detection is best-effort — fall back to no stack hint */
         }
         return enhancePrompt({
-            provider: this.provider,
-            model: this.model,
+            provider,
+            model,
+            thinking: thinkingLevel,
+            maxTokens,
+            userAgent: provider === "anthropic" ? await getClaudeCliUserAgent() : undefined,
+            projectId: creds.projectId,
             prompt: text,
             stack,
             apiKey: creds.accessToken,
-            baseUrl: this.baseUrl ?? creds.baseUrl,
+            baseUrl: baseUrl ?? creds.baseUrl,
             accountId: creds.accountId,
             signal: this.opts.signal,
         });
@@ -3287,6 +3571,13 @@ export class AgentSession {
         return this.getPromptCacheKey();
     }
     async dispose() {
+        // 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
+        // and leak a junk session file after teardown.
+        if (this.postTurnCompaction)
+            await this.postTurnCompaction;
+        this.diagnosticsRecorder?.finalize();
         this.managerAbortSignal?.removeEventListener("abort", this.managerAbortHandler);
         this.processManager?.shutdownAll();
         this.lspManager?.shutdownAll();
@@ -3489,7 +3780,7 @@ export class AgentSession {
     createSlashCommandContext() {
         return {
             switchModel: (provider, model) => this.switchModel(provider, model),
-            compact: () => this.compact(undefined, "manual"),
+            compact: (focus) => this.compact(undefined, "manual", focus),
             newSession: () => this.newSession(),
             listSessions: async () => {
                 const sessions = await this.sessionManager.list(this.cwd);