@kenkaiiii/ggcoder 5.59.0 → 5.59.1

package/dist/core/agent-session.d.ts

@@ -7,6 +7,7 @@ import type { BackgroundProcess } from "./process-manager.js";
 import type { MCPElicitHandler } from "./mcp/index.js";
 import { type ImportForeignTranscriptResult } from "./foreign-session-import.js";
 import { type EnhanceResult } from "../utils/prompt-enhancer.js";
+import { type VerificationEvidence } from "./verification-evidence.js";
 /** A chat attachment (image / video / other file) prepared for the model. The
  *  raw base64 `data` rides native blocks; `path` (when persisted to disk) lets
  *  the agent's tools open the file directly. */
@@ -777,6 +778,9 @@ export declare 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).
      */
+    private recordFinishedBackgroundVerification;
+    getVerificationEvidence(): VerificationEvidence[];
+    private finishSnapshotVerification;
     getVerificationProblem(): string | null;
     private persistVerificationState;
     persistAutopilotMarker(phase: AutopilotMarkerPayload["phase"], extra?: {

package/dist/core/agent-session.js

@@ -49,6 +49,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";
@@ -1073,7 +1074,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;
@@ -1133,20 +1144,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);
@@ -1156,6 +1179,7 @@ export class AgentSession {
                             }
                             verificationChanged = true;
                         }
+                        delete call.sourceSnapshot;
                     }
                     else if (classification.candidate) {
                         // Green but untrusted: remember WHY so the demand can tell the
@@ -1164,18 +1188,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();
@@ -1266,9 +1280,9 @@ 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);
+        const diagnosticText = this.lspManager?.drainDiagnostics(this.getVerificationProblem() !== null, { deferUnverified: true });
         if (diagnosticText)
-            this.eventBus.emit("hook", { kind: "verification" });
+            this.eventBus.emit("diagnostics", { text: diagnosticText });
         this.refreshVerificationArmed();
         const notified = this.notifications.drain();
         const notificationMessage = notified.length > 0 || diagnosticText
@@ -1673,6 +1687,15 @@ 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);
@@ -1680,20 +1703,20 @@ export class AgentSession {
             return null;
         const diagnosticText = this.lspManager?.drainDiagnostics(this.getVerificationProblem() !== null);
         if (diagnosticText)
-            this.eventBus.emit("hook", { kind: "verification" });
+            this.eventBus.emit("diagnostics", { text: diagnosticText });
         this.refreshVerificationArmed();
-        if (diagnosticText) {
-            return [
+        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.
@@ -1703,7 +1726,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
@@ -1727,9 +1750,13 @@ export class AgentSession {
                             : {}),
                 });
                 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") {
@@ -1788,7 +1815,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();
@@ -1805,6 +1831,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,
@@ -3111,7 +3139,49 @@ 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 build"
+                : "Build changed workspace inputs; run checks against the changed source");
+            if (!passed)
+                this.verificationGate.recordFailedVerification(check.command);
+        }
+        else if (passed) {
+            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."