jeopi-cli 16.2.30 → 16.4.0

package/src/memories/index.ts

@@ -1342,7 +1342,7 @@ export function getMemoryRoot(agentDir: string, cwd: string): string {
  * consolidation artifacts (`MEMORY.md`, `memory_summary.md`, `skills/`) so a
  * consolidation pass never clobbers manually captured lessons.
  */
-const LEARNED_LESSONS_FILE = "learned.md";
+export const LEARNED_LESSONS_FILE = "learned.md";
 /** Newest-first cap on retained lessons, bounding file growth by entry count. */
 const MAX_LEARNED_LESSONS = 100;
 /** Per-field char caps so a single huge capture can't bloat learned.md. */
@@ -1414,7 +1414,15 @@ export async function saveLearnedLesson(
 		return { backend: "local", stored: 0, message: "Empty lesson; nothing stored." };
 	}
 	const context = input.context ? normalizeLearnedText(input.context, MAX_LEARNED_CONTEXT_CHARS) : "";
-	const line = context ? `- ${content} _(context: ${context})_` : `- ${content}`;
+	const contextSuffix = context ? ` _(context: ${context})_` : "";
+	let line: string;
+	if (input.verified === true) {
+		const evidence = input.evidence ? normalizeLearnedText(input.evidence, MAX_LEARNED_CONTEXT_CHARS) : "";
+		const evidenceSuffix = evidence ? ` _(evidence: ${evidence})_` : "";
+		line = `- [VERIFIED] ${content}${evidenceSuffix}${contextSuffix}`;
+	} else {
+		line = `- [UNVERIFIED] ${content}${contextSuffix}`;
+	}
 	const filePath = path.join(getMemoryRoot(agentDir, cwd), LEARNED_LESSONS_FILE);
 
 	// Serialize the read-modify-write per file: parallel `learn` calls (sibling

package/src/memory-backend/local-backend.ts

@@ -1,8 +1,12 @@
+import * as path from "node:path";
+import { isEnoent } from "jeopi-utils";
 import {
 	buildMemoryToolDeveloperInstructions,
 	clearMemoryData,
 	clearMemoryToolDeveloperInstructionsCache,
 	enqueueMemoryConsolidation,
+	getMemoryRoot,
+	LEARNED_LESSONS_FILE,
 	saveLearnedLesson,
 	startMemoryStartupTask,
 } from "../memories";
@@ -44,4 +48,34 @@ export const localBackend: MemoryBackend = {
 				"Local rollout-summary memory is active; lessons from the `learn` tool are saved to learned.md. Structured search is not available.",
 		};
 	},
+	async stats(agentDir, cwd) {
+		const filePath = path.join(getMemoryRoot(agentDir, cwd), LEARNED_LESSONS_FILE);
+		let raw = "";
+		try {
+			raw = await Bun.file(filePath).text();
+		} catch (err) {
+			if (!isEnoent(err)) throw err;
+		}
+		let total = 0;
+		let verified = 0;
+		for (const rawLine of raw.split("\n")) {
+			const line = rawLine.trim();
+			if (!line.startsWith("- ")) continue;
+			total++;
+			if (line.startsWith(VERIFIED_PREFIX)) verified++;
+		}
+		const unverified = total - verified;
+		const coverage = total > 0 ? `${((verified / total) * 100).toFixed(1)}%` : "N/A";
+		return [
+			"# Local Memory Stats",
+			"",
+			`- Lessons: ${total}`,
+			`- Verified: ${verified}`,
+			`- Unverified: ${unverified}`,
+			`- Verification coverage: ${coverage}`,
+		].join("\n");
+	},
 };
+
+/** Line prefix `saveLearnedLesson` writes for verified/unverified lessons in `learned.md`. */
+const VERIFIED_PREFIX = "- [VERIFIED]";

package/src/memory-backend/types.ts

@@ -60,6 +60,17 @@ export interface MemoryBackendSaveInput {
 	context?: string;
 	source?: string;
 	importance?: number;
+	/**
+	 * Marks this lesson as independently re-checked against the repo (a
+	 * command run, a file read, a test executed) rather than merely asserted
+	 * from inference. Mirrors the "verify" stage of the fail → investigate →
+	 * verify → distill → consult self-improvement progression: a lesson that
+	 * skips verification is still worth capturing, but downstream consumers
+	 * (e.g. `stats()`) should be able to tell the two apart.
+	 */
+	verified?: boolean;
+	/** The short check that was run to establish `verified` (a command, a file path, a test name). Ignored when `verified` is not `true`. */
+	evidence?: string;
 }
 
 export interface MemoryBackendSaveResult {

package/src/prompts/agents/designer.md

@@ -20,6 +20,7 @@ Treat the design system as the foundation — UI built without one collapses int
 2. **No coherent system? Build the minimal one first.** Extract what exists, then define a palette, type scale, spacing scale (4px/8px base), radii/shadows/transitions, and primitive components — THEN implement the request against it.
 3. **Compose with the system, never around it.** Colors → tokens/CSS variables, never hardcoded hex; spacing → scale values, never arbitrary px; type → scale steps; components → extend/compose existing primitives, not one-off div soup. Need something outside the system? Add the new token to the system first, then use it — never a one-off override.
 4. **Verify before done.** Every color a token, every spacing on the scale, every component on the existing composition pattern, zero magic numbers — a designer would see consistency across old and new. Any "no" → not done.
+5. **Visually verify the rendered result.** Code-level checks (tokens/spacing) don't catch layout/rendering bugs. After producing a UI change, capture it (`tab.screenshot()` for browser-rendered UI, or the existing screenshot path) and call `vision_verify` with the task's stated goal — pass `baseline` when checking for regression against a known-good prior state.
 </design-system>
 
 <procedure>

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/tools/learn.md

@@ -5,3 +5,5 @@ Use after solving something whose insight will pay off again: a non-obvious fix,
 Provide the optional `skill` object when the lesson is a repeatable *procedure* worth codifying as a `SKILL.md` (not just a fact). Managed skills are written to an isolated directory (`~/.jeopi/agent/managed-skills`) and are surfaced like normal skills next session. They NEVER touch user-authored skills. Frontmatter is generated from `name` and `description`.
 
 Capture sparingly and specifically. One strong, reusable lesson beats several vague ones.
+
+Set `verified: true` when you independently re-checked the claim against the repo — you ran a command, read a file, or ran a test that directly confirmed it — and pass a short `evidence` string naming that check (e.g. "ran `bun test src/foo.test.ts`, all 12 pass" or "read `package.json:12`, confirms dependency pin"). Leave `verified` unset (the default) for a hypothesis or pattern you noticed but did not independently confirm.

package/src/prompts/tools/vision-verify-system.md

@@ -0,0 +1,16 @@
+You are a UI/artifact verification assistant.
+
+Core behavior:
+- Be evidence-first: judge only what is visibly present in the image(s).
+- If something is unclear or partially occluded, treat it as unmet rather than guessing it is fine.
+- NEVER fabricate details that are not visible.
+- When a baseline (prior) screenshot is provided, compare the current screenshot against it and treat any visible divergence as a gap unless the goal explicitly calls for that change.
+
+Output contract — respond with ONLY a single JSON object, no prose before or after it, no markdown code fence, matching exactly:
+{"matches": boolean, "summary": string, "gaps": string[]}
+
+- `matches`: true only if the current screenshot fully satisfies the stated goal (and, when a baseline is given, shows no unintended regression from it).
+- `summary`: one to three sentences describing what you observed.
+- `gaps`: specific, concrete differences between what is observed and what the goal (or baseline) requires. Empty array when `matches` is true.
+
+Return raw JSON only — any other format is a failure to follow instructions.

package/src/prompts/tools/vision-verify.md

@@ -0,0 +1,20 @@
+Verifies a screenshot or UI artifact against a stated goal with a vision-capable model and returns a structured verdict.
+
+<instruction>
+- Use this after producing or modifying a UI to check the result against the task's stated goal
+- Provide `screenshot` as a local image file path, `Image #N` attachment label, or `attachment://N` URI
+- Write a specific `goal`: what the UI/artifact should look like or achieve
+- Pass `baseline` (a path to a prior screenshot of the same view) to check for visual regression against a known-good state
+- Use this tool over `inspect_image` when you need a pass/fail verdict with structured gaps, not free-text description
+</instruction>
+
+<output>
+- Returns a structured verdict: `matches` (boolean), `summary`, and `gaps` (empty when `matches` is true)
+- No image content blocks are returned in tool output
+</output>
+
+<critical>
+- If image submission is blocked by settings, the tool will fail with an actionable error
+- If configured model does not support image input, configure a vision-capable model role before retrying
+- If the model's response cannot be parsed as the expected JSON shape, the tool fails with the raw response included — retry rather than trust an unstructured fallback
+</critical>

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
@@ -2210,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);
@@ -5618,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/slash-commands/builtin-registry.ts

@@ -43,6 +43,7 @@ import { createMarketplaceManager } from "./helpers/marketplace-manager";
 import { handleMcpAcp } from "./helpers/mcp";
 import { commandConsumed, errorMessage, parseSlashCommand, parseSubcommand, usage } from "./helpers/parse";
 import { describeRedeemOutcome, type ResetUsageAccount, toResetUsageAccounts } from "./helpers/reset-usage";
+import { handleSkillCommand } from "./helpers/skill-verify";
 import { handleSshAcp } from "./helpers/ssh";
 import { launchStatsDashboard, parseStatsDashboardArgs } from "./helpers/stats-dashboard";
 import { handleTodoAcp } from "./helpers/todo";
@@ -1348,6 +1349,14 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			await runtime.ctx.handleSSHCommand(command.text);
 		},
 	},
+	{
+		name: "verify-skill",
+		description: "Run a skill's `## Eval Cases` and report pass/fail",
+		acpDescription: "Verify a skill's eval cases",
+		inlineHint: "<name>",
+		allowArgs: true,
+		handle: handleSkillCommand,
+	},
 	{
 		name: "new",
 		priority: 96,

package/src/slash-commands/helpers/skill-verify.ts

@@ -0,0 +1,171 @@
+/**
+ * `/verify-skill <name>` — self-verification for a skill's `## Eval Cases`.
+ *
+ * Resolves a skill from the active session, extracts a bulleted `## Eval
+ * Cases` markdown section from its `SKILL.md` body (if present), and spawns
+ * one read-only `critic` subagent per case to verdict whether the claim still
+ * holds against the current repo state. Renders a pass/fail markdown report;
+ * never mutates the skill file.
+ *
+ * Named `verify-skill` (not `skill`) to avoid colliding with the pre-existing
+ * `/skill:<name>` direct-skill-invocation convention (both parse to the
+ * command-name token `skill` under `parseSlashCommand`'s earliest-whitespace-
+ * or-colon splitting rule — see slash-commands/helpers/parse.ts).
+ */
+import { MANAGED_SKILLS_PROVIDER_ID } from "../../autolearn/managed-skills";
+import { runEvalAgent } from "../../eval/agent-bridge";
+import { getBundledAgent } from "../../task/agents";
+import * as taskDiscovery from "../../task/discovery";
+import type { ToolSession } from "../../tools";
+import type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime } from "../types";
+import { commandConsumed, usage } from "./parse";
+
+const VERIFIER_AGENT_NAME = "critic";
+
+interface EvalCaseVerdict {
+	claim: string;
+	passed: boolean;
+	reason: string;
+}
+
+/** Extract the bulleted list under a `## Eval Cases` heading, if present. */
+export function extractEvalCases(skillBody: string): string[] {
+	const headingMatch = /^##\s+Eval Cases\s*$/m.exec(skillBody);
+	if (!headingMatch) return [];
+	const sectionStart = headingMatch.index + headingMatch[0].length;
+	const rest = skillBody.slice(sectionStart);
+	const nextHeadingMatch = /^#{1,6}\s+\S/m.exec(rest);
+	const sectionBody = nextHeadingMatch ? rest.slice(0, nextHeadingMatch.index) : rest;
+	const cases: string[] = [];
+	for (const line of sectionBody.split("\n")) {
+		const bulletMatch = /^\s*[-*+]\s+(.+)$/.exec(line);
+		if (bulletMatch?.[1]) cases.push(bulletMatch[1].trim());
+	}
+	return cases;
+}
+
+/** Verdict a single eval-case claim against the current repo state via the bundled `critic` agent. */
+async function verifyEvalCase(session: ToolSession, claim: string): Promise<EvalCaseVerdict> {
+	const verifyPrompt =
+		`Verify this claim against the current repository state: ${claim}\n\n` +
+		"Report whether it still holds (yes/no) and why, citing files/commands.";
+	// Explicit schema, not the agent's own frontmatter default: runEvalAgent (the
+	// eval `agent()` bridge) only applies `outputSchema` when the caller supplies
+	// one — it never falls back to the agent's `output` frontmatter on its own
+	// (see goals/verifier.ts for the same pattern). Read the bundled definition's
+	// declared shape so this can't drift from critic.md.
+	const schema = getBundledAgent(VERIFIER_AGENT_NAME)?.output;
+	const args =
+		schema === undefined
+			? { prompt: verifyPrompt, agent: VERIFIER_AGENT_NAME }
+			: { prompt: verifyPrompt, agent: VERIFIER_AGENT_NAME, schema };
+	try {
+		const result = await runEvalAgent(args, { session });
+		let verdict: unknown;
+		try {
+			verdict = JSON.parse(result.text);
+		} catch {
+			// Freeform fallback: no parseable JSON, treat non-empty output as inconclusive-pass with raw text as reason.
+			return { claim, passed: true, reason: result.text.trim().slice(0, 300) || "No structured verdict returned." };
+		}
+		if (verdict && typeof verdict === "object") {
+			const record = verdict as Record<string, unknown>;
+			const rawVerdict = record.verdict;
+			const passed = rawVerdict === "okay";
+			const reason =
+				(typeof record.summary === "string" && record.summary) ||
+				(typeof record.justification === "string" && record.justification) ||
+				"No justification returned.";
+			return { claim, passed, reason: reason.slice(0, 400) };
+		}
+		return { claim, passed: false, reason: "Verifier returned an unparseable verdict." };
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		return { claim, passed: false, reason: `Verification subagent failed: ${message}` };
+	}
+}
+
+function renderReport(skillName: string, isManaged: boolean, verdicts: EvalCaseVerdict[]): string {
+	const lines: string[] = [`## Skill verification: \`${skillName}\``, ""];
+	const failures: EvalCaseVerdict[] = [];
+	for (const verdict of verdicts) {
+		lines.push(`- ${verdict.passed ? "✅ PASS" : "❌ FAIL"} — ${verdict.claim}`);
+		lines.push(`  ${verdict.reason}`);
+		if (!verdict.passed) failures.push(verdict);
+	}
+	const passCount = verdicts.length - failures.length;
+	lines.push("", `${passCount}/${verdicts.length} eval cases passed.`);
+	if (failures.length > 0 && isManaged) {
+		lines.push(
+			"",
+			"This is a managed (auto-learn) skill. To record the failure mode, append a line like this under a `## Known Failure Modes` section (not applied automatically):",
+			"",
+		);
+		for (const failure of failures) {
+			lines.push(`- "${failure.claim}" — ${failure.reason}`);
+		}
+	}
+	return lines.join("\n");
+}
+
+/** `/verify-skill <name>` handler — resolves a skill, runs its `## Eval Cases`, reports pass/fail. */
+export async function handleSkillCommand(
+	command: ParsedSlashCommand,
+	runtime: SlashCommandRuntime,
+): Promise<SlashCommandResult> {
+	const skillName = command.args.trim();
+	if (!skillName) {
+		return usage("Usage: /verify-skill <name>", runtime);
+	}
+	const skill = runtime.session.skills.find(candidate => candidate.name === skillName);
+	if (!skill) {
+		const available = runtime.session.skills.map(candidate => candidate.name).join(", ") || "none";
+		return usage(`Unknown skill "${skillName}". Available: ${available}`, runtime);
+	}
+
+	const body = await Bun.file(skill.filePath).text();
+	const evalCases = extractEvalCases(body);
+	if (evalCases.length === 0) {
+		await runtime.output(
+			`No eval cases defined for this skill — add an \`## Eval Cases\` section with bulleted verifiable claims to enable self-verification`,
+		);
+		return commandConsumed();
+	}
+
+	await runtime.output(`Verifying ${evalCases.length} eval case(s) for \`${skillName}\`…`);
+
+	// Discover once, upfront, to fail fast with a clear message if the critic
+	// agent is unavailable (disabled, or bundled agents failed to load) rather
+	// than surfacing N identical spawn errors.
+	const { agents } = await taskDiscovery.discoverAgents(runtime.cwd);
+	if (!taskDiscovery.getAgent(agents, VERIFIER_AGENT_NAME)) {
+		return usage(
+			`The "${VERIFIER_AGENT_NAME}" agent is unavailable in this session; cannot run eval cases.`,
+			runtime,
+		);
+	}
+
+	const session: ToolSession = {
+		cwd: runtime.cwd,
+		hasUI: false,
+		settings: runtime.settings,
+		skills: [...runtime.session.skills],
+		taskDepth: 0,
+		getSessionFile: () => runtime.session.sessionManager.getSessionFile() ?? null,
+		getSessionSpawns: () => "*",
+		getPlanModeState: () => runtime.session.getPlanModeState(),
+		getActiveModelString: () =>
+			runtime.session.model ? `${runtime.session.model.provider}/${runtime.session.model.id}` : undefined,
+		modelRegistry: runtime.session.modelRegistry,
+		authStorage: runtime.session.modelRegistry.authStorage,
+		getAgentId: () => runtime.session.getAgentId() ?? null,
+	};
+	const verdicts: EvalCaseVerdict[] = [];
+	for (const claim of evalCases) {
+		verdicts.push(await verifyEvalCase(session, claim));
+	}
+
+	const isManaged = skill._source?.provider === MANAGED_SKILLS_PROVIDER_ID;
+	await runtime.output(renderReport(skillName, isManaged, verdicts));
+	return commandConsumed();
+}

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 },

package/src/task/index.ts

@@ -67,6 +67,7 @@ import {
 	prepareIsolationContext,
 	runIsolatedSubprocess,
 } from "./isolation-runner";
+import { classifyDefaultTaskModelTier } from "./model-tier-classifier";
 import { generateTaskName } from "./name-generator";
 import { AgentOutputManager } from "./output-manager";
 import { mapWithConcurrencyLimit, normalizeConcurrencyLimit, Semaphore } from "./parallel";
@@ -1202,7 +1203,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 		const agentModelOverrides = this.session.settings.get("task.agentModelOverrides");
 		const settingsModelOverride = agentModelOverrides[agentName];
 		const parentActiveModelPattern = this.session.getActiveModelString?.();
-		const modelOverride = resolveAgentModelPatterns({
+		let modelOverride = resolveAgentModelPatterns({
 			settingsOverride: settingsModelOverride,
 			agentModel: effectiveAgent.model,
 			settings: this.session.settings,
@@ -1211,6 +1212,30 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 		});
 		const thinkingLevelOverride = effectiveAgent.thinkingLevel;
 
+		// Auto-tier the generic default `task` agent to the cheap `smol` model
+		// when the assignment classifies as trivially simple and nothing else
+		// (settings override) already pinned the model. Named specialists carry
+		// their own `model:` frontmatter, so gating on the literal "task" agent
+		// name naturally excludes them without inspecting frontmatter here.
+		const autoModel = this.session.getActiveModel?.();
+		const autoModelRegistry = this.session.modelRegistry;
+		if (
+			agentName === "task" &&
+			settingsModelOverride === undefined &&
+			this.session.settings.get("task.autoModelTier") &&
+			autoModel &&
+			autoModelRegistry
+		) {
+			const tier = await classifyDefaultTaskModelTier(assignment, {
+				settings: this.session.settings,
+				registry: autoModelRegistry,
+				model: autoModel,
+				sessionId: this.session.getSessionId?.() ?? undefined,
+				signal,
+			});
+			if (tier === "smol") modelOverride = ["pi/smol"];
+		}
+
 		// Output schema priority: agent frontmatter > inherited parent session.
 		// The task call itself never carries a schema; workflows needing ad-hoc
 		// structured output go through eval agent(prompt, schema).

package/src/task/model-tier-classifier.ts

@@ -0,0 +1,43 @@
+/**
+ * Default `task`-agent spawn model-tier classifier.
+ *
+ * Reuses the auto-thinking difficulty classifier ({@link classifyDifficulty})
+ * to decide whether a `task()` spawn's assignment is trivially simple enough
+ * to route to the cheap `smol` model tier instead of the default `task`
+ * tier. Only ever suggests a downgrade — never blocks or upgrades — and
+ * fails open (returns `undefined`, meaning "don't override") on any
+ * classification error or timeout, mirroring `AgentSession`'s
+ * `#applyAutoThinkingLevel` fallback behavior.
+ */
+import { Effort } from "jeopi-ai";
+import { logger } from "jeopi-utils";
+import { type ClassifyDifficultyDeps, classifyDifficulty } from "../auto-thinking/classifier";
+
+/** Timeout (ms) for the spawn-time model-tier classification before failing open. */
+const MODEL_TIER_CLASSIFICATION_TIMEOUT_MS = 2000;
+
+/**
+ * Classify `assignment` and return `"smol"` when the work is trivially
+ * simple ({@link Effort.Minimal} or {@link Effort.Low}), or `undefined` when
+ * the caller should leave normal model resolution in place (not-simple
+ * enough, no classifier available, or the classification failed/timed out).
+ */
+export async function classifyDefaultTaskModelTier(
+	assignment: string,
+	deps: ClassifyDifficultyDeps,
+): Promise<"smol" | undefined> {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), MODEL_TIER_CLASSIFICATION_TIMEOUT_MS);
+	const signal = deps.signal ? AbortSignal.any([deps.signal, controller.signal]) : controller.signal;
+	try {
+		const effort = await classifyDifficulty(assignment, { ...deps, signal });
+		return effort === Effort.Minimal || effort === Effort.Low ? "smol" : undefined;
+	} catch (error) {
+		logger.debug("task: model-tier classification failed; leaving model resolution unchanged", {
+			error: error instanceof Error ? error.message : String(error),
+		});
+		return undefined;
+	} finally {
+		clearTimeout(timer);
+	}
+}

package/src/tools/builtin-names.ts

@@ -13,6 +13,7 @@ export const BUILTIN_TOOL_NAMES = [
 	"grep",
 	"lsp",
 	"inspect_image",
+	"vision_verify",
 	"browser",
 	"checkpoint",
 	"rewind",