jeopi-cli 16.2.29 → 16.3.0

package/src/goals/runtime.ts

@@ -3,8 +3,16 @@ import goalBudgetLimitPrompt from "../prompts/goals/goal-budget-limit.md" with {
 import goalContinuationPrompt from "../prompts/goals/goal-continuation.md" with { type: "text" };
 import goalModeActivePrompt from "../prompts/goals/goal-mode-active.md" with { type: "text" };
 import { assertSubstantiveCompletionEvidence } from "./completion-evidence";
+import { GoalEvidenceTracker, isVerificationSignal, MUTATION_TOOL_NAMES } 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;
@@ -16,6 +24,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;
 }
 
@@ -117,9 +135,12 @@ function isAccountingStatus(goal: Goal): boolean {
 
 export class GoalRuntime {
 	readonly #host: GoalRuntimeHost;
+	readonly #evidence = new GoalEvidenceTracker();
 	#turnSnapshot: GoalTurnSnapshot | undefined;
 	#wallClock: GoalWallClockSnapshot;
 	#budgetReportedFor: string | undefined;
+	/** Set when an independent-verifier non-okay verdict was bounced once; cleared by any new mutation/verification or a fresh goal. Mirrors GoalEvidenceTracker's bypass latch, kept separate because it gates a different (probabilistic) signal. */
+	#verifierBypassArmed = false;
 	#accountingTail: Promise<void> = Promise.resolve();
 
 	constructor(host: GoalRuntimeHost) {
@@ -202,6 +223,30 @@ export class GoalRuntime {
 		this.#budgetReportedFor = undefined;
 	}
 
+	/** Deterministic completion-evidence tracker for the active goal (see evidence-gate.ts). */
+	get evidence(): GoalEvidenceTracker {
+		return this.#evidence;
+	}
+
+	/**
+	 * 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 {
+		if (!this.#hasAccountingState()) return;
+		if (MUTATION_TOOL_NAMES[toolName]) {
+			this.#evidence.recordMutation();
+			this.#verifierBypassArmed = false;
+			return;
+		}
+		if (detail && isVerificationSignal(detail.command ?? "", detail.outputHead ?? "")) {
+			this.#evidence.recordVerification();
+			this.#verifierBypassArmed = false;
+		}
+	}
+
 	onTurnStart(turnId: string, baselineUsage: GoalTokenUsage): void {
 		this.#turnSnapshot = { turnId, baselineUsage: { ...baselineUsage } };
 		const state = this.#host.getState();
@@ -393,6 +438,8 @@ export class GoalRuntime {
 			}
 			const state = this.#createGoalState(objective, input.tokenBudget);
 			this.#budgetReportedFor = undefined;
+			this.#evidence.reset();
+			this.#verifierBypassArmed = false;
 			this.#markActiveAccounting(state.goal);
 			await this.#commitState(state, { persist: "goal" });
 			return state;
@@ -411,6 +458,8 @@ export class GoalRuntime {
 			await this.#flushUsageLocked("suppressed");
 			const state = this.#createGoalState(objective, input.tokenBudget);
 			this.#budgetReportedFor = undefined;
+			this.#evidence.reset();
+			this.#verifierBypassArmed = false;
 			this.#markActiveAccounting(state.goal);
 			await this.#commitState(state, { persist: "goal" });
 			return state;
@@ -487,6 +536,43 @@ export class GoalRuntime {
 			if (state.goal.status === "dropped") {
 				throw new Error("cannot complete a dropped goal");
 			}
+			// Deterministic evidence gate (evidence-gate.ts): a goal session that
+			// mutated project files cannot self-report complete unless a verification
+			// signal was observed after the last mutation. First violation bounces
+			// once with a corrective message; a repeat complete with no new mutation
+			// passes (escape hatch for docs/config-only work).
+			const gate = this.#evidence.classifyCompletion();
+			if (gate.block) {
+				throw new Error(gate.message);
+			}
+			// Independent grader (goal-verifier sub-agent, see GoalRuntimeHost.verifyCompletion):
+			// maker != grader, per the compounding-loop primitive — the same agent that did
+			// the work does not get to be the sole judge of whether it's done. Same bounce-once
+			// shape as the deterministic gate above, kept as a separate latch since this signal
+			// is probabilistic (an LLM verdict), not mechanical.
+			if (this.#host.verifyCompletion) {
+				const verdict = await this.#host.verifyCompletion(state.goal.objective, verifiedEvidence);
+				if (verdict.verdict !== "okay") {
+					if (this.#verifierBypassArmed) {
+						// Second attempt with no new mutation/verification since the bounce:
+						// escape hatch for a verifier false-positive-reject/iterate.
+						this.#verifierBypassArmed = false;
+					} else {
+						this.#verifierBypassArmed = true;
+						const fixes =
+							verdict.requiredFixes.length > 0
+								? `\nRequired fixes:\n${verdict.requiredFixes.map(fix => `- ${fix}`).join("\n")}`
+								: "";
+						throw new Error(
+							`Completion blocked: independent verifier verdict was "${verdict.verdict}", not "okay". ` +
+								`${verdict.justification}${fixes}\nAddress the gaps above, then call complete again. ` +
+								"If the verifier is wrong, call complete again unchanged to override.",
+						);
+					}
+				} else {
+					this.#verifierBypassArmed = false;
+				}
+			}
 			state.enabled = false;
 			state.goal.status = "complete";
 			state.goal.completionEvidence = verifiedEvidence;

package/src/goals/verifier.ts

@@ -0,0 +1,100 @@
+/**
+ * Independent-verifier bridge for goal-mode completion (see GoalRuntimeHost.verifyCompletion
+ * in runtime.ts). Spawns the bundled `goal-verifier` sub-agent — a fresh session with its own
+ * kernel, its own read-only tool set, and no exposure to the maker's transcript/reasoning —
+ * to grade a completion claim against the objective and the actual repo diff. Reuses the eval
+ * tool's `agent()` bridge as a plain async call (no eval kernel required outside eval cells;
+ * `withBridgeTimeoutPause` in agent-bridge.ts is a no-op when no `emitStatus` sink is wired).
+ */
+import { runEvalAgent } from "../eval/agent-bridge";
+import { getBundledAgent } from "../task/agents";
+import type { ToolSession } from "../tools";
+import type { GoalCompletionVerdict } from "./runtime";
+
+const VERIFIER_AGENT_NAME = "goal-verifier";
+
+/** Cap the evidence claim embedded in the verifier prompt; the verifier re-derives ground truth from the repo, not from a long claim. */
+const MAX_EVIDENCE_CHARS = 4000;
+
+function parseVerdict(output: string): GoalCompletionVerdict {
+	let data: unknown;
+	try {
+		data = JSON.parse(output);
+	} catch {
+		// Verifier didn't return a structured payload (refused, crashed, plain-text
+		// reply). Fail open to "iterate" rather than silently trusting completion —
+		// a broken verifier bounces once instead of being bypassed unnoticed.
+		return {
+			verdict: "iterate",
+			justification: `goal-verifier did not return a structured verdict. Raw output: ${output.slice(0, 500)}`,
+			requiredFixes: [],
+		};
+	}
+	if (data === null || typeof data !== "object") {
+		return {
+			verdict: "iterate",
+			justification: "goal-verifier returned a non-object payload.",
+			requiredFixes: [],
+		};
+	}
+	const record = data as Record<string, unknown>;
+	const verdict = record.verdict;
+	if (verdict !== "okay" && verdict !== "iterate" && verdict !== "reject") {
+		return {
+			verdict: "iterate",
+			justification: "goal-verifier returned an unrecognized verdict value.",
+			requiredFixes: [],
+		};
+	}
+	const rawFixes = record.required_fixes;
+	const requiredFixes = Array.isArray(rawFixes)
+		? rawFixes.filter((fix): fix is string => typeof fix === "string")
+		: [];
+	const justification = typeof record.justification === "string" ? record.justification : "";
+	const summary = typeof record.summary === "string" ? record.summary : undefined;
+	return { verdict, justification, summary, requiredFixes };
+}
+
+/**
+ * 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 async function verifyGoalCompletion(
+	session: ToolSession,
+	objective: string,
+	evidence: string,
+): Promise<GoalCompletionVerdict> {
+	const truncatedEvidence =
+		evidence.length > MAX_EVIDENCE_CHARS ? `${evidence.slice(0, MAX_EVIDENCE_CHARS)}\n[truncated]` : evidence;
+	const verifierPrompt =
+		`<objective>\n${objective}\n</objective>\n\n` +
+		`<evidence>\n${truncatedEvidence}\n</evidence>\n\n` +
+		"Verdict whether the objective above is genuinely satisfied by the repo's current state. " +
+		"The evidence is the maker's claim, not a fact — verify it independently.";
+	try {
+		// Explicit schema, not the agent's own frontmatter default: runEvalAgent (the
+		// eval `agent()` bridge) only applies `outputSchema` when the caller supplies
+		// one — unlike the `task` tool, it never falls back to `effectiveAgent.output`
+		// (task/index.ts). Read the bundled definition's own `output` so this can't
+		// drift from goal-verifier.md's declared shape. Omit the key entirely when
+		// undefined: `Object.hasOwn` (agent-bridge.ts's `structured` check) is true
+		// for an explicit `schema: undefined`, which would wrongly disable the
+		// agent's frontmatter-schema fallback in the bridge.
+		const schema = getBundledAgent(VERIFIER_AGENT_NAME)?.output;
+		const args =
+			schema === undefined
+				? { prompt: verifierPrompt, agent: VERIFIER_AGENT_NAME }
+				: { prompt: verifierPrompt, agent: VERIFIER_AGENT_NAME, schema };
+		const result = await runEvalAgent(args, { session });
+		return parseVerdict(result.text);
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		return {
+			verdict: "iterate",
+			justification: `Independent verifier could not run: ${message}`,
+			requiredFixes: [],
+		};
+	}
+}

package/src/prompts/agents/goal-verifier.md

@@ -0,0 +1,51 @@
+---
+name: goal-verifier
+description: "Read-only independent grader for goal-mode completion. Verdicts whether the actual diff satisfies the stated objective and evidence claim — sees only the objective, evidence, and repo state, never the maker's reasoning transcript."
+tools: read, grep, glob, bash, ast_grep
+spawns: explore
+model: pi/slow
+thinking-level: high
+output:
+  properties:
+    verdict:
+      metadata:
+        description: Completion verdict for the goal under review
+      enum: [okay, iterate, reject]
+    justification:
+      metadata:
+        description: Evidence-backed reasoning for the verdict, citing inspected files/diff hunks/command output
+      type: string
+    summary:
+      metadata:
+        description: 1-3 sentence plain-text summary of what was actually verified
+      type: string
+  optionalProperties:
+    required_fixes:
+      metadata:
+        description: Concrete gaps that must be fixed before the goal can be marked complete (empty for okay)
+      elements:
+        type: string
+---
+
+Decide whether a goal-mode objective is genuinely satisfied by the repo's current state — you are the independent grader, not the agent that did the work.
+
+<procedure>
+1. Read the `<objective>` and `<evidence>` given to you below. Treat both as claims to verify, not facts.
+2. Run `git status` and `git diff` (add `git diff --stat` first on a large diff) to see every file actually changed this session. Read the changed files for context beyond the diff hunks when the diff alone doesn't establish correctness.
+3. If the evidence claims a verification command ran (test/build/lint/typecheck), re-run the narrowest form of that command yourself against the current tree — do not trust the claim without confirming it. Do not run a full/slow suite when a scoped one covers the changed files; do not run anything destructive.
+4. Cross-check the diff against the objective: does every part of the objective have corresponding evidence in the diff, or a clear reason no code change was needed for that part? Flag objective clauses with no corresponding change.
+5. Decide the verdict and record it with the structured output.
+</procedure>
+
+<constraints>
+- Read-only: you NEVER edit, write, or revert files. Verification commands you run must not mutate the tree (no `--fix`, no auto-format writes, no `git commit`/`git checkout`).
+- Do not invent problems; reject or iterate only with concrete, cited gaps between the objective and the diff.
+- A verdict grounded in nothing is worthless: your justification MUST name the files/diff hunks/commands you actually inspected or ran, and their actual output.
+- You have no access to the maker's reasoning, chat transcript, or thinking blocks — judge the objective against the artifact (diff + verification output) alone. If the evidence text asserts something the diff doesn't support, that is a gap, not a detail to take on faith.
+</constraints>
+
+<verdicts>
+- `okay` — every part of the objective is satisfied by the diff, and claimed verification actually holds when re-checked.
+- `iterate` — real progress exists but named gaps remain (missing piece of the objective, evidence claim that doesn't hold up, or verification that fails when re-run); list each in `required_fixes`.
+- `reject` — the diff does not address the objective at all, or the evidence is fabricated/contradicted by re-running it.
+</verdicts>

package/src/prompts/goals/goal-continuation.md

@@ -22,6 +22,7 @@ Before calling `goal({op:"complete"})`, you MUST perform a completion audit agai
 4. **Match verification scope to claim scope.** A narrow check (one file passes its unit test) does not prove a broad claim (the feature works end-to-end).
 5. **Treat uncertainty as not-yet-achieved.** Indirect evidence, partial coverage, missing artifacts, or "looks right" without inspection mean continue working. Gather stronger evidence or do more work.
 6. **Budget exhaustion is not completion.** NEVER call complete merely because tokens are nearly out. If the budget is tight and the work is unfinished, leave the goal active and stop the turn — the user or runtime decides next steps.
+7. **Reinterpretation is a signal, not a shortcut.** If you catch yourself re-reading the objective to make what you already built count as done, that reinterpretation itself is evidence the objective is NOT met as written — keep working on the gap instead of completing.
 
 Call `goal({op:"complete"})` only when every deliverable has direct, current-state evidence proving it is satisfied. The completion call is a load-bearing claim; it ends the autonomous loop and surfaces a "done" report to the user.
 

package/src/prompts/tools/goal.md

@@ -4,7 +4,7 @@ Use a single `op` field:
 - `create` starts a goal. Requires `objective`; optional `token_budget` must be positive. Use only when no goal exists and no goal is paused.
 - `get` returns the current goal (active or paused) and remaining token budget.
 - `resume` re-activates a paused goal so work can continue.
-- `complete` marks the goal complete after you have verified every deliverable against current evidence. Requires `evidence`: a specific, non-generic description of what you checked and how (tests run, output inspected, files diffed, etc.) — status words like "done" or "verified" are rejected.
+- `complete` marks the goal complete after you have verified every deliverable against current evidence. Requires `evidence`: a specific, non-generic description of what you checked and how (tests run, output inspected, files diffed, etc.) — status words like "done" or "verified" are rejected. Completion is also evidence-gated at runtime: if this goal session modified project files, a verification run (test/build/typecheck/lint) must have succeeded AFTER the last modification, or the first `complete` is rejected with instructions. For docs/config-only work where no verification applies, call `complete` again and explain why in `evidence`.
 - `drop` discards the current goal without completing it.
 
 NEVER call `complete` because a budget is low or a turn is ending. Call it only when the goal is actually done and verified.

package/src/sdk.ts

@@ -76,6 +76,7 @@ import {
 	setActiveSkills,
 } from "./extensibility/skills";
 import { type FileSlashCommand, loadSlashCommands as loadSlashCommandsInternal } from "./extensibility/slash-commands";
+import { verifyGoalCompletion } from "./goals/verifier";
 import type { HindsightSessionState } from "./hindsight/state";
 import { LocalProtocolHandler, type LocalProtocolOptions } from "./internal-urls";
 import { LSP_STARTUP_EVENT_CHANNEL, type LspStartupEvent } from "./lsp/startup-events";
@@ -2756,6 +2757,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			providerSessionId: options.providerSessionId,
 			parentEvalSessionId: options.parentEvalSessionId,
 			advisorTools,
+			verifyGoalCompletion: (objective, evidence) => verifyGoalCompletion(toolSession, objective, evidence),
 			titleSystemPrompt: options.titleSystemPrompt,
 		});
 		hasSession = true;

package/src/session/agent-session.ts

@@ -222,7 +222,7 @@ import { ExtensionToolWrapper } from "../extensibility/extensions/wrapper";
 import type { HookCommandContext } from "../extensibility/hooks/types";
 import type { Skill, SkillWarning } from "../extensibility/skills";
 import { expandSlashCommand, 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 LocalProtocolOptions, resolveLocalUrlToPath } from "../internal-urls";
@@ -539,13 +539,19 @@ function refusalBackoffBudgetMs(): number {
 }
 /**
  * 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 const SHUTDOWN_CONSOLIDATE_BUDGET_MS = 1_500;
+export const SHUTDOWN_CONSOLIDATE_BUDGET_MS = 8_000;
 
 export interface AgentSessionDisposeOptions {
 	mnemopiConsolidateTimeoutMs?: number;
@@ -728,6 +734,15 @@ export interface AgentSessionConfig {
 	rebuildSystemPrompt?: (toolNames: string[], tools: Map<string, AgentTool>) => Promise<{ systemPrompt: string[] }>;
 	/** 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
@@ -1566,6 +1581,9 @@ export class AgentSession {
 	 *  used as the open barrier for the next build so two writers never share a file. */
 	#advisorRecorderClosed: Promise<void> = Promise.resolve();
 	#goalTurnCounter = 0;
+	/** Command text of in-flight bash/eval calls, keyed by toolCallId — consumed by the
+	 *  goal evidence gate at tool_execution_end to classify verification runs. */
+	#goalEvidenceCommands = new Map<string, string>();
 	#planReferenceSent = false;
 	#planReferencePath = "local://PLAN.md";
 	#clientBridge: ClientBridge | undefined;
@@ -2207,6 +2225,14 @@ export class AgentSession {
 					{ deliverAs: message.deliverAs },
 				);
 			},
+			verifyCompletion: config.verifyGoalCompletion
+				? async (objective: string, evidence: string): Promise<GoalCompletionVerdict> => {
+						if (!this.settings.get("goal.verifyCompletion")) {
+							return { verdict: "okay", justification: "goal.verifyCompletion disabled", requiredFixes: [] };
+						}
+						return config.verifyGoalCompletion!(objective, evidence);
+					}
+				: undefined,
 		});
 		this.#cancelExitRecorder = postmortem.register(`agent-session:${this.sessionManager.getSessionId()}`, reason => {
 			this.#recordSessionExit(reason);
@@ -3049,6 +3075,24 @@ export class AgentSession {
 		this.sessionManager.appendCustomEntry(TOOL_EXECUTION_START_CUSTOM_TYPE, data);
 	}
 
+	/** Feed successful tool executions to the goal completion-evidence gate.
+	 *  Mutations (edit/write/ast_edit) arm it; verification-signal bash/eval runs
+	 *  satisfy it. Failed executions prove nothing and are skipped. */
+	#recordGoalToolEvidence(event: Extract<AgentEvent, { type: "tool_execution_end" }>): void {
+		const command = this.#goalEvidenceCommands.get(event.toolCallId);
+		this.#goalEvidenceCommands.delete(event.toolCallId);
+		if (event.isError || event.toolName === "goal") return;
+		let outputHead: string | undefined;
+		if (command !== undefined) {
+			const content = (event.result as { content?: Array<{ type?: string; text?: string }> } | undefined)?.content;
+			if (Array.isArray(content)) {
+				const firstText = content.find(block => block?.type === "text" && typeof block.text === "string");
+				outputHead = firstText?.text;
+			}
+		}
+		this.#goalRuntime.recordToolEvidence(event.toolName, command !== undefined ? { command, outputHead } : undefined);
+	}
+
 	#recordSessionExit(reason: postmortem.Reason | "dispose"): void {
 		if (this.#exitRecorded) return;
 		this.#exitRecorded = true;
@@ -3434,6 +3478,16 @@ export class AgentSession {
 
 		if (event.type === "tool_execution_start") {
 			this.#recordToolExecutionStart(event);
+			// Stash bash/eval command text for the goal evidence gate; consumed at
+			// tool_execution_end. Bounded: entries are deleted on end, and the map
+			// is cleared at turn start.
+			if (event.toolName === "bash" || event.toolName === "eval") {
+				const command = (event.args as { command?: unknown; code?: unknown } | undefined) ?? {};
+				const text = typeof command.command === "string" ? command.command : command.code;
+				if (typeof text === "string" && text.length > 0) {
+					this.#goalEvidenceCommands.set(event.toolCallId, text);
+				}
+			}
 		}
 
 		try {
@@ -3445,6 +3499,7 @@ export class AgentSession {
 
 		if (event.type === "turn_start") {
 			this.#resetStreamingEditState();
+			this.#goalEvidenceCommands.clear();
 			// TTSR: Reset buffer on turn start
 			this.#ttsrManager?.resetBuffer();
 		}
@@ -3465,6 +3520,7 @@ export class AgentSession {
 			}
 		}
 		if (event.type === "tool_execution_end") {
+			this.#recordGoalToolEvidence(event);
 			if (event.toolName === "goal") {
 				await this.#goalRuntime.onGoalToolCompleted();
 			} else {
@@ -5585,7 +5641,27 @@ export class AgentSession {
 		// Reversed, the spliced batch survives just long enough to fail the
 		// identity check and get dropped with a `session vanished` warning.
 		const hindsightState = this.getHindsightSessionState();
-		await hindsightState?.flushRetainQueue();
+		// Bounded when a shutdown budget is set (interactive /quit /exit): the
+		// underlying HindsightApi client makes plain `fetch()` calls with no
+		// timeout/signal, so an unreachable or hung Hindsight server would
+		// otherwise block process exit indefinitely. Callers that keep the
+		// process/session host alive (no timeout passed) still await the flush
+		// unbounded, matching the mnemopi dispose contract below.
+		if (hindsightState) {
+			const { mnemopiConsolidateTimeoutMs: timeoutMs } = options;
+			if (timeoutMs !== undefined && timeoutMs > 0) {
+				try {
+					await withTimeout(hindsightState.flushRetainQueue(), timeoutMs, "Hindsight retain-queue flush");
+				} catch (error) {
+					logger.warn("Hindsight retain-queue flush exceeded shutdown budget; remaining items dropped", {
+						timeoutMs,
+						error: String(error),
+					});
+				}
+			} else {
+				await hindsightState.flushRetainQueue();
+			}
+		}
 		this.setHindsightSessionState(undefined);
 		hindsightState?.dispose();
 		const mnemopiState = setMnemopiSessionState(this, undefined);

package/src/task/agents.ts

@@ -12,6 +12,7 @@ import designerMd from "../prompts/agents/designer.md" with { type: "text" };
 import exploreMd from "../prompts/agents/explore.md" with { type: "text" };
 // Embed agent markdown files at build time
 import agentFrontmatterTemplate from "../prompts/agents/frontmatter.md" with { type: "text" };
+import goalVerifierMd from "../prompts/agents/goal-verifier.md" with { type: "text" };
 import librarianMd from "../prompts/agents/librarian.md" with { type: "text" };
 
 import planMd from "../prompts/agents/plan.md" with { type: "text" };
@@ -47,6 +48,7 @@ const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 	{ fileName: "explore.md", template: exploreMd },
 	{ fileName: "plan.md", template: planMd },
 	{ fileName: "critic.md", template: criticMd },
+	{ fileName: "goal-verifier.md", template: goalVerifierMd },
 	{ fileName: "architect.md", template: architectMd },
 	{ fileName: "designer.md", template: designerMd },
 	{ fileName: "reviewer.md", template: reviewerMd },