jeopi-cli 16.2.29 → 16.2.30

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,3 +1,4 @@
+import { GoalEvidenceTracker } from "./evidence-gate";
 import type { Goal, GoalBudgetSteering, GoalModeState, GoalRuntimeEvent, GoalTokenUsage } from "./state";
 export interface GoalRuntimeHost {
     getState(): GoalModeState | undefined;
@@ -37,6 +38,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/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "jeopi-cli",
-	"version": "16.2.29",
+	"version": "16.2.30",
 	"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.2.30",
+		"jeopi-stats": "16.2.30",
+		"jeopi-agent-core": "16.2.30",
+		"jeopi-ai": "16.2.30",
+		"jeopi-catalog": "16.2.30",
+		"jeopi-mnemopi": "16.2.30",
+		"jeopi-natives": "16.2.30",
+		"jeopi-tui": "16.2.30",
+		"jeopi-utils": "16.2.30",
+		"jeopi-wire": "16.2.30",
+		"jeopi-snapcompact": "16.2.30",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

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";

package/src/goals/runtime.ts

@@ -3,6 +3,7 @@ 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 GoalRuntimeHost {
@@ -117,6 +118,7 @@ function isAccountingStatus(goal: Goal): boolean {
 
 export class GoalRuntime {
 	readonly #host: GoalRuntimeHost;
+	readonly #evidence = new GoalEvidenceTracker();
 	#turnSnapshot: GoalTurnSnapshot | undefined;
 	#wallClock: GoalWallClockSnapshot;
 	#budgetReportedFor: string | undefined;
@@ -202,6 +204,28 @@ 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();
+			return;
+		}
+		if (detail && isVerificationSignal(detail.command ?? "", detail.outputHead ?? "")) {
+			this.#evidence.recordVerification();
+		}
+	}
+
 	onTurnStart(turnId: string, baselineUsage: GoalTokenUsage): void {
 		this.#turnSnapshot = { turnId, baselineUsage: { ...baselineUsage } };
 		const state = this.#host.getState();
@@ -393,6 +417,7 @@ export class GoalRuntime {
 			}
 			const state = this.#createGoalState(objective, input.tokenBudget);
 			this.#budgetReportedFor = undefined;
+			this.#evidence.reset();
 			this.#markActiveAccounting(state.goal);
 			await this.#commitState(state, { persist: "goal" });
 			return state;
@@ -411,6 +436,7 @@ export class GoalRuntime {
 			await this.#flushUsageLocked("suppressed");
 			const state = this.#createGoalState(objective, input.tokenBudget);
 			this.#budgetReportedFor = undefined;
+			this.#evidence.reset();
 			this.#markActiveAccounting(state.goal);
 			await this.#commitState(state, { persist: "goal" });
 			return state;
@@ -487,6 +513,15 @@ 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);
+			}
 			state.enabled = false;
 			state.goal.status = "complete";
 			state.goal.completionEvidence = verifiedEvidence;

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/session/agent-session.ts

@@ -1566,6 +1566,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;
@@ -3049,6 +3052,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 +3455,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 +3476,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 +3497,7 @@ export class AgentSession {
 			}
 		}
 		if (event.type === "tool_execution_end") {
+			this.#recordGoalToolEvidence(event);
 			if (event.toolName === "goal") {
 				await this.#goalRuntime.onGoalToolCompleted();
 			} else {