jeopi-cli 16.2.29 → 16.3.0

package/dist/types/config/settings-schema.d.ts

@@ -189,12 +189,12 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly "advisor.includeThinking": {
         readonly type: "boolean";
-        readonly default: true;
+        readonly default: false;
         readonly ui: {
             readonly tab: "model";
             readonly group: "Advisor";
             readonly label: "Advisor Sees Thinking";
-            readonly description: "Include the primary agent's thinking blocks in advisor transcript updates. Some provider classifiers (e.g. Anthropic's reasoning_extraction) refuse payloads that replay thinking as text; the advisor also auto-disables this for the session after such a refusal.";
+            readonly description: "Include the primary agent's thinking blocks in advisor transcript updates. Off by default: a reviewer that sees the maker's own reasoning trail tends to anchor on conclusions the maker already committed to instead of bringing an independent angle (the advisor's own directive is to 'bring the angle they skipped, never re-run reasoning they already have'); the advisor still sees full messages, tool calls, results, and diffs. Some provider classifiers (e.g. Anthropic's reasoning_extraction) also refuse payloads that replay thinking as text if enabled; the advisor auto-disables this for the session after such a refusal.";
             readonly condition: "advisorEnabled";
         };
     };
@@ -4056,6 +4056,16 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Run modes where active goals may auto-continue between turns";
         };
     };
+    readonly "goal.verifyCompletion": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly group: "Modes";
+            readonly label: "Verify Goal Completion";
+            readonly description: "Spawn an independent goal-verifier sub-agent to grade a completion claim against the objective and diff before accepting it";
+        };
+    };
     readonly "title.refreshOnReplan": {
         readonly type: "boolean";
         readonly default: true;

package/dist/types/goals/evidence-gate.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Deterministic evidence gate for goal completion — the code-level counterpart to
+ * the prompt-side completion audit (`prompts/goals/goal-continuation.md`).
+ *
+ * `assertSubstantiveCompletionEvidence` (completion-evidence.ts) only checks that
+ * the completion *claim text* is non-generic; it cannot see whether the work was
+ * actually verified. This gate closes that "gate theater" failure mode with
+ * runtime signals the session already observes: a goal turn that MUTATED project
+ * files can self-report complete only when a verification signal (test / build /
+ * typecheck / lint run) was observed AFTER the last mutation.
+ *
+ * Design mirrors gajae-code's `classifyDoneGate` + jeo-code's `applyEvidenceGate`:
+ * - Pure classification over recorded signals — no re-scan of the transcript.
+ * - Single-pushback latch: the first blocked `complete` bounces with a corrective
+ *   message; a second `complete` with no new evidence passes (the escape hatch for
+ *   docs/config-only changes where no verification command applies). Any new
+ *   mutation recorded after a bounce re-arms the gate.
+ */
+/** Tool names whose successful execution counts as a project-file mutation. */
+export declare const MUTATION_TOOL_NAMES: Record<string, true>;
+/**
+ * Commands (or their output head) that count as a verification signal: a test,
+ * build, typecheck, or lint invocation. Matches command text and the first
+ * `VERIFY_OUTPUT_SCAN_LIMIT` chars of output — enough to catch a runner's banner
+ * without rescanning megabytes of logs.
+ */
+export declare const VERIFY_SIGNAL_RE: RegExp;
+/** Output prefix length scanned for verification signals. */
+export declare const VERIFY_OUTPUT_SCAN_LIMIT = 2000;
+/** True when a bash/eval command (or the head of its output) proves a verification ran. */
+export declare function isVerificationSignal(command: string, output?: string): boolean;
+export type EvidenceGateState = "pass" | "unverified" | "stale-verification";
+export interface EvidenceGateVerdict {
+    state: EvidenceGateState;
+    /** When true, `complete` should be bounced once with `message`. */
+    block: boolean;
+    /** Corrective message for the bounce; empty when `state === "pass"`. */
+    message: string;
+}
+/**
+ * Tracks mutation/verification evidence for the active goal. Sequence-ordered so
+ * "verified, then mutated again" is detected as stale evidence regardless of how
+ * many turns separate the two.
+ */
+export declare class GoalEvidenceTracker {
+    #private;
+    /** Reset all evidence (new goal, or goal replaced). */
+    reset(): void;
+    /** Record a successful project-file mutation (edit/write/ast_edit). */
+    recordMutation(): void;
+    /** Record a successful verification run (test/build/typecheck/lint). */
+    recordVerification(): void;
+    get sawMutation(): boolean;
+    get sawVerification(): boolean;
+    /** True when the last mutation happened after the last verification. */
+    get verificationStale(): boolean;
+    /**
+     * Classify a `complete` attempt. First blocked attempt arms the bypass latch;
+     * the next attempt (with no new mutation in between) passes.
+     */
+    classifyCompletion(): EvidenceGateVerdict;
+}

package/dist/types/goals/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./evidence-gate";
 export * from "./runtime";
 export * from "./state";
 export * from "./tools/goal-tool";

package/dist/types/goals/runtime.d.ts

@@ -1,4 +1,11 @@
+import { GoalEvidenceTracker } from "./evidence-gate";
 import type { Goal, GoalBudgetSteering, GoalModeState, GoalRuntimeEvent, GoalTokenUsage } from "./state";
+export interface GoalCompletionVerdict {
+    verdict: "okay" | "iterate" | "reject";
+    justification: string;
+    summary?: string;
+    requiredFixes: string[];
+}
 export interface GoalRuntimeHost {
     getState(): GoalModeState | undefined;
     setState(state: GoalModeState | undefined): void;
@@ -10,6 +17,16 @@ export interface GoalRuntimeHost {
         content: string;
         deliverAs?: "steer" | "followUp" | "nextTurn";
     }): Promise<void>;
+    /**
+     * Spawn an independent grader sub-agent to verdict a completion claim against
+     * the objective and the actual repo diff (article gap: "the agent that wrote
+     * the code is not the agent that grades it"). The sub-agent sees only the
+     * objective + evidence text passed here plus its own repo inspection — never
+     * this session's transcript/reasoning. Optional: hosts that don't wire this
+     * (e.g. test harnesses, `goal.verifyCompletion` disabled) skip independent
+     * grading and fall back to the deterministic evidence gate alone.
+     */
+    verifyCompletion?(objective: string, evidence: string): Promise<GoalCompletionVerdict>;
     now?(): number;
 }
 export interface GoalTurnSnapshot {
@@ -37,6 +54,18 @@ export declare class GoalRuntime {
     constructor(host: GoalRuntimeHost);
     get snapshot(): GoalRuntimeSnapshot;
     clearAccounting(): void;
+    /** Deterministic completion-evidence tracker for the active goal (see evidence-gate.ts). */
+    get evidence(): GoalEvidenceTracker;
+    /**
+     * Record a successful tool execution as completion evidence for the active goal.
+     * Mutation tools (edit/write/ast_edit) arm the completion gate; bash/eval runs
+     * whose command or output head carries a verification signal (test/build/
+     * typecheck/lint) satisfy it. No-op when no goal is accounting.
+     */
+    recordToolEvidence(toolName: string, detail?: {
+        command?: string;
+        outputHead?: string;
+    }): void;
     onTurnStart(turnId: string, baselineUsage: GoalTokenUsage): void;
     onToolCompleted(toolName: string): Promise<void>;
     onGoalToolCompleted(): Promise<void>;

package/dist/types/goals/verifier.d.ts

@@ -0,0 +1,9 @@
+import type { ToolSession } from "../tools";
+import type { GoalCompletionVerdict } from "./runtime";
+/**
+ * Grade a goal-completion claim with the independent `goal-verifier` sub-agent.
+ * Never throws: a spawn failure (depth limit, disabled agent, no model) fails
+ * open to `iterate` so it costs one corrective bounce, the same as a genuine
+ * gap — never a silent skip of independent grading, never a permanent block.
+ */
+export declare function verifyGoalCompletion(session: ToolSession, objective: string, evidence: string): Promise<GoalCompletionVerdict>;

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

@@ -35,7 +35,7 @@ import type { ExtensionRunner } from "../extensibility/extensions";
 import type { CompactOptions, ContextUsage } from "../extensibility/extensions/types";
 import type { Skill, SkillWarning } from "../extensibility/skills";
 import { type FileSlashCommand } from "../extensibility/slash-commands";
-import { GoalRuntime } from "../goals/runtime";
+import { type GoalCompletionVerdict, GoalRuntime } from "../goals/runtime";
 import type { Goal, GoalModeState } from "../goals/state";
 import type { HindsightSessionState } from "../hindsight/state";
 import { type IrcMessage } from "../irc/bus";
@@ -124,13 +124,19 @@ export type AgentSessionEvent = AgentEvent | {
 export type AgentSessionEventListener = (event: AgentSessionEvent) => void;
 /**
  * Budget for callers on the user-visible `/quit` / `/exit` shutdown path that
- * want to cap how long they wait for `MnemopiSessionState.dispose()` to finish
- * its consolidate pass. Consolidate fires fresh LLM fact extractions, each a
- * 1–3 s round-trip, so interactive shutdown passes this budget to keep the
- * UI responsive. Callers that keep the process/session host alive must omit it
- * so dispose still awaits the full consolidate-then-close pipeline.
+ * want to cap how long they wait for `MnemopiSessionState.dispose()` (and the
+ * Hindsight retain-queue flush, see the dispose() call site) to finish writing
+ * this session's memory before the process exits. Consolidate fires fresh LLM
+ * fact extractions, each a 1-3s round-trip; the retain-queue flush is a single
+ * HTTP POST. The prior 1500ms budget was tighter than a single extraction
+ * round-trip, so it lost the race on effectively every session with any
+ * memory-worthy content — "write before walking away" in name only. 8s still
+ * bounds worst-case UI unresponsiveness on /exit while giving a small
+ * consolidation batch (1-3 facts) a realistic chance to land before the
+ * process exits. Callers that keep the process/session host alive must omit
+ * it so dispose still awaits the full write pipeline unbounded.
  */
-export declare const SHUTDOWN_CONSOLIDATE_BUDGET_MS = 1500;
+export declare const SHUTDOWN_CONSOLIDATE_BUDGET_MS = 8000;
 export interface AgentSessionDisposeOptions {
     mnemopiConsolidateTimeoutMs?: number;
     /**
@@ -225,6 +231,15 @@ export interface AgentSessionConfig {
     }>;
     /** Rebuild the SSH tool from current capability discovery results. */
     reloadSshTool?: () => Promise<AgentTool | null>;
+    /**
+     * Independent-verifier bridge for goal-mode completion (see goals/verifier.ts).
+     * Spawns the bundled `goal-verifier` sub-agent to grade a completion claim against
+     * the objective and the actual repo diff — a fresh session/context, no exposure to
+     * this session's transcript. Wired from sdk.ts (needs the constructed `toolSession`).
+     * Undefined when `goal.verifyCompletion` is off or the caller has no tool session
+     * (e.g. minimal SDK embedders) — GoalRuntime skips independent grading in that case.
+     */
+    verifyGoalCompletion?: (objective: string, evidence: string) => Promise<GoalCompletionVerdict>;
     requestedToolNames?: ReadonlySet<string>;
     /**
      * Optional accessor for live MCP server instructions. Read by the session's

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "jeopi-cli",
-	"version": "16.2.29",
+	"version": "16.3.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/akillness/jeopi",
 	"author": "Can Boluk",
@@ -57,17 +57,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"jeopi-hashline": "16.2.29",
-		"jeopi-stats": "16.2.29",
-		"jeopi-agent-core": "16.2.29",
-		"jeopi-ai": "16.2.29",
-		"jeopi-catalog": "16.2.29",
-		"jeopi-mnemopi": "16.2.29",
-		"jeopi-natives": "16.2.29",
-		"jeopi-tui": "16.2.29",
-		"jeopi-utils": "16.2.29",
-		"jeopi-wire": "16.2.29",
-		"jeopi-snapcompact": "16.2.29",
+		"jeopi-hashline": "16.3.0",
+		"jeopi-stats": "16.3.0",
+		"jeopi-agent-core": "16.3.0",
+		"jeopi-ai": "16.3.0",
+		"jeopi-catalog": "16.3.0",
+		"jeopi-mnemopi": "16.3.0",
+		"jeopi-natives": "16.3.0",
+		"jeopi-tui": "16.3.0",
+		"jeopi-utils": "16.3.0",
+		"jeopi-wire": "16.3.0",
+		"jeopi-snapcompact": "16.3.0",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/autoresearch/index.ts

@@ -30,6 +30,16 @@ import type { AutoresearchRuntime, ExperimentResult, PendingRunSummary } from ".
 
 const EXPERIMENT_TOOL_NAMES = ["init_experiment", "run_experiment", "log_experiment", "update_notes"];
 
+/**
+ * Cross-process auto-resume window: a pending (run-but-never-logged) experiment
+ * completed within this long ago is resumed automatically on the next session
+ * load; older ones are left for the user to inspect and resume by hand. Bounds
+ * the "open your laptop, the loop picks back up" pattern to realistic gaps
+ * (overnight, a workday) without silently relaunching token-spending work
+ * against a session nobody touched in weeks.
+ */
+const AUTORESEARCH_RESUME_STALENESS_MS = 24 * 60 * 60 * 1000;
+
 export const createAutoresearchExtension: ExtensionFactory = api => {
 	const runtimeStore = createRuntimeStore();
 	const dashboard = createDashboardController();
@@ -47,7 +57,7 @@ export const createAutoresearchExtension: ExtensionFactory = api => {
 		return { session, currentBranch };
 	};
 
-	const rehydrate = async (ctx: ExtensionContext): Promise<void> => {
+	const rehydrate = async (ctx: ExtensionContext, resumeEligible: boolean): Promise<void> => {
 		const runtime = getRuntime(ctx);
 		const control = reconstructControlState(ctx.sessionManager.getBranch());
 		runtime.goal = control.goal;
@@ -69,13 +79,15 @@ export const createAutoresearchExtension: ExtensionFactory = api => {
 		const onActiveBranch = session === null || session.branch === null || session.branch === currentBranch;
 		runtime.autoresearchMode = control.autoresearchMode && onActiveBranch;
 
+		let pendingRow: RunRow | null = null;
 		if (session && onActiveBranch) {
 			const storage = await openAutoresearchStorageIfExists(ctx.cwd);
 			if (storage) {
 				const loggedRuns = storage.listLoggedRuns(session.id);
 				runtime.state = buildExperimentState(session, loggedRuns);
 				runtime.goal = runtime.goal ?? session.goal;
-				runtime.lastRunSummary = pendingRunSummaryFromRow(storage.getPendingRun(session.id));
+				pendingRow = storage.getPendingRun(session.id);
+				runtime.lastRunSummary = pendingRunSummaryFromRow(pendingRow);
 			} else {
 				runtime.state = createExperimentState();
 				runtime.lastRunSummary = null;
@@ -102,6 +114,41 @@ export const createAutoresearchExtension: ExtensionFactory = api => {
 		if (toolsChanged) {
 			await api.setActiveTools(nextActiveTools);
 		}
+
+		// Auto-rearm across a process restart (article gap: "the mode itself has to be
+		// manually re-armed with /autoresearch after a restart, since session_shutdown
+		// doesn't leave anything wired to auto-relaunch" — the "morning briefing"/
+		// nightly-loop pattern requires the NEXT process to pick a pending run back up
+		// on its own, not wait for the user to notice and retype /autoresearch).
+		// `autoResumeArmed` is deliberately NOT restored here (reset above, matching
+		// existing behavior) — that flag is a live in-process signal set by the
+		// experiment tools mid-run; it cannot be reconstructed from persisted state
+		// and re-arming it unconditionally on every resume would fire even when the
+		// prior process ended cleanly with nothing left to continue. The only
+		// cross-restart-durable signal is an actual pending (run-but-never-logged)
+		// run row, so that's the sole trigger here.
+		if (
+			resumeEligible &&
+			runtime.autoresearchMode &&
+			pendingRow?.completedAt !== undefined &&
+			pendingRow.completedAt !== null &&
+			Date.now() - pendingRow.completedAt <= AUTORESEARCH_RESUME_STALENESS_MS &&
+			!ctx.hasPendingMessages()
+		) {
+			const pendingRun = runtime.lastRunSummary;
+			runtime.lastAutoResumePendingRunNumber = pendingRow.id;
+			api.sendMessage(
+				{
+					customType: "autoresearch-resume",
+					content: prompt.render(resumeMessageTemplate, {
+						has_pending_run: Boolean(pendingRun),
+					}),
+					display: false,
+					attribution: "agent",
+				},
+				{ deliverAs: "nextTurn", triggerTurn: true },
+			);
+		}
 	};
 
 	const setMode = (
@@ -245,10 +292,17 @@ export const createAutoresearchExtension: ExtensionFactory = api => {
 		},
 	});
 
-	api.on("session_start", (_event, ctx) => rehydrate(ctx));
-	api.on("session_switch", (_event, ctx) => rehydrate(ctx));
-	api.on("session_branch", (_event, ctx) => rehydrate(ctx));
-	api.on("session_tree", (_event, ctx) => rehydrate(ctx));
+	api.on("session_start", (_event, ctx) => rehydrate(ctx, true));
+	// "resume" = picked from the /resume session picker or `jeopi -r`, the exact
+	// "reopen your laptop, the loop should still be going" moment the article
+	// describes. "new"/"fork" start a fresh conversation off old history — no
+	// auto-continuation there, matching session_start's "don't fire on plain
+	// process launch into an unrelated session" restraint.
+	api.on("session_switch", (event, ctx) => rehydrate(ctx, event.reason === "resume"));
+	// Mid-conversation navigation (branch off an earlier message, move through the
+	// tree), not a process/session restart — never auto-fires a fresh turn here.
+	api.on("session_branch", (_event, ctx) => rehydrate(ctx, false));
+	api.on("session_tree", (_event, ctx) => rehydrate(ctx, false));
 	api.on("session_shutdown", (_event, ctx) => {
 		dashboard.clear(ctx);
 		runtimeStore.clear(getSessionKey(ctx));

package/src/config/settings-schema.ts

@@ -416,13 +416,13 @@ export const SETTINGS_SCHEMA = {
 	},
 	"advisor.includeThinking": {
 		type: "boolean",
-		default: true,
+		default: false,
 		ui: {
 			tab: "model",
 			group: "Advisor",
 			label: "Advisor Sees Thinking",
 			description:
-				"Include the primary agent's thinking blocks in advisor transcript updates. Some provider classifiers (e.g. Anthropic's reasoning_extraction) refuse payloads that replay thinking as text; the advisor also auto-disables this for the session after such a refusal.",
+				"Include the primary agent's thinking blocks in advisor transcript updates. Off by default: a reviewer that sees the maker's own reasoning trail tends to anchor on conclusions the maker already committed to instead of bringing an independent angle (the advisor's own directive is to 'bring the angle they skipped, never re-run reasoning they already have'); the advisor still sees full messages, tool calls, results, and diffs. Some provider classifiers (e.g. Anthropic's reasoning_extraction) also refuse payloads that replay thinking as text if enabled; the advisor auto-disables this for the session after such a refusal.",
 			condition: "advisorEnabled",
 		},
 	},
@@ -3946,6 +3946,18 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"goal.verifyCompletion": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "tasks",
+			group: "Modes",
+			label: "Verify Goal Completion",
+			description:
+				"Spawn an independent goal-verifier sub-agent to grade a completion claim against the objective and diff before accepting it",
+		},
+	},
+
 	"title.refreshOnReplan": {
 		type: "boolean",
 		default: true,

package/src/goals/evidence-gate.ts

@@ -0,0 +1,137 @@
+/**
+ * Deterministic evidence gate for goal completion — the code-level counterpart to
+ * the prompt-side completion audit (`prompts/goals/goal-continuation.md`).
+ *
+ * `assertSubstantiveCompletionEvidence` (completion-evidence.ts) only checks that
+ * the completion *claim text* is non-generic; it cannot see whether the work was
+ * actually verified. This gate closes that "gate theater" failure mode with
+ * runtime signals the session already observes: a goal turn that MUTATED project
+ * files can self-report complete only when a verification signal (test / build /
+ * typecheck / lint run) was observed AFTER the last mutation.
+ *
+ * Design mirrors gajae-code's `classifyDoneGate` + jeo-code's `applyEvidenceGate`:
+ * - Pure classification over recorded signals — no re-scan of the transcript.
+ * - Single-pushback latch: the first blocked `complete` bounces with a corrective
+ *   message; a second `complete` with no new evidence passes (the escape hatch for
+ *   docs/config-only changes where no verification command applies). Any new
+ *   mutation recorded after a bounce re-arms the gate.
+ */
+
+/** Tool names whose successful execution counts as a project-file mutation. */
+export const MUTATION_TOOL_NAMES: Record<string, true> = {
+	edit: true,
+	write: true,
+	ast_edit: true,
+};
+
+/**
+ * Commands (or their output head) that count as a verification signal: a test,
+ * build, typecheck, or lint invocation. Matches command text and the first
+ * `VERIFY_OUTPUT_SCAN_LIMIT` chars of output — enough to catch a runner's banner
+ * without rescanning megabytes of logs.
+ */
+export const VERIFY_SIGNAL_RE = /\b(test|tests|tsc|tsgo|typecheck|lint|build|check|spec|pytest|vitest|jest|biome)\b/i;
+
+/** Output prefix length scanned for verification signals. */
+export const VERIFY_OUTPUT_SCAN_LIMIT = 2000;
+
+/** True when a bash/eval command (or the head of its output) proves a verification ran. */
+export function isVerificationSignal(command: string, output = ""): boolean {
+	return VERIFY_SIGNAL_RE.test(command) || VERIFY_SIGNAL_RE.test(output.slice(0, VERIFY_OUTPUT_SCAN_LIMIT));
+}
+
+export type EvidenceGateState = "pass" | "unverified" | "stale-verification";
+
+export interface EvidenceGateVerdict {
+	state: EvidenceGateState;
+	/** When true, `complete` should be bounced once with `message`. */
+	block: boolean;
+	/** Corrective message for the bounce; empty when `state === "pass"`. */
+	message: string;
+}
+
+/**
+ * Tracks mutation/verification evidence for the active goal. Sequence-ordered so
+ * "verified, then mutated again" is detected as stale evidence regardless of how
+ * many turns separate the two.
+ */
+export class GoalEvidenceTracker {
+	#seq = 0;
+	#lastMutationSeq = 0;
+	#lastVerificationSeq = 0;
+	/** Set when a `complete` was bounced; cleared by any new mutation. */
+	#bypassArmed = false;
+
+	/** Reset all evidence (new goal, or goal replaced). */
+	reset(): void {
+		this.#seq = 0;
+		this.#lastMutationSeq = 0;
+		this.#lastVerificationSeq = 0;
+		this.#bypassArmed = false;
+	}
+
+	/** Record a successful project-file mutation (edit/write/ast_edit). */
+	recordMutation(): void {
+		this.#lastMutationSeq = ++this.#seq;
+		// New mutation invalidates a previously granted escape hatch: the model
+		// must re-justify (or re-verify) the new change.
+		this.#bypassArmed = false;
+	}
+
+	/** Record a successful verification run (test/build/typecheck/lint). */
+	recordVerification(): void {
+		this.#lastVerificationSeq = ++this.#seq;
+	}
+
+	get sawMutation(): boolean {
+		return this.#lastMutationSeq > 0;
+	}
+
+	get sawVerification(): boolean {
+		return this.#lastVerificationSeq > 0;
+	}
+
+	/** True when the last mutation happened after the last verification. */
+	get verificationStale(): boolean {
+		return this.#lastMutationSeq > this.#lastVerificationSeq;
+	}
+
+	/**
+	 * Classify a `complete` attempt. First blocked attempt arms the bypass latch;
+	 * the next attempt (with no new mutation in between) passes.
+	 */
+	classifyCompletion(): EvidenceGateVerdict {
+		if (!this.sawMutation) {
+			return { state: "pass", block: false, message: "" };
+		}
+		if (this.sawVerification && !this.verificationStale) {
+			return { state: "pass", block: false, message: "" };
+		}
+		if (this.#bypassArmed) {
+			// Second attempt without new evidence: the escape hatch for changes
+			// where no verification command applies (docs/config-only).
+			return { state: "pass", block: false, message: "" };
+		}
+		this.#bypassArmed = true;
+		if (!this.sawVerification) {
+			return {
+				state: "unverified",
+				block: true,
+				message:
+					"Completion blocked: this goal session modified project files but no verification signal " +
+					"(test/build/typecheck/lint run) was observed. Run the narrowest command that proves the " +
+					"change works, then call complete again. If verification is genuinely not applicable " +
+					"(docs/config-only change), call complete again and say why in the evidence.",
+			};
+		}
+		return {
+			state: "stale-verification",
+			block: true,
+			message:
+				"Completion blocked: files were modified AFTER the last successful verification run, so that " +
+				"evidence no longer reflects the current tree. Re-run the narrowest verification command " +
+				"against the latest changes, then call complete again. If the later edits are " +
+				"verification-irrelevant (docs/config-only), call complete again and say why in the evidence.",
+		};
+	}
+}

package/src/goals/index.ts

@@ -1,3 +1,4 @@
+export * from "./evidence-gate";
 export * from "./runtime";
 export * from "./state";
 export * from "./tools/goal-tool";