jeopi-cli 16.3.0 → 16.4.0

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

@@ -3690,6 +3690,16 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Enable the inspect_image tool, delegating image understanding to a vision-capable model";
         };
     };
+    readonly "vision_verify.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly group: "Available Tools";
+            readonly label: "Vision Verify";
+            readonly description: "Enable the vision_verify tool, checking a screenshot/artifact against a stated goal with a vision-capable model";
+        };
+    };
     readonly "checkpoint.enabled": {
         readonly type: "boolean";
         readonly default: false;
@@ -4257,6 +4267,16 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Allow subagents spawned via the task tool to use the lsp tool. Off by default to keep subagents cheap; enable when LSP-aware delegation is worth the extra tokens.";
         };
     };
+    readonly "task.autoModelTier": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly group: "Subagents";
+            readonly label: "Auto Model Tier for Simple Tasks";
+            readonly description: "Classify a task() spawn's assignment text and route trivially-simple work to the cheap 'smol' model tier instead of the default 'task' tier, when the caller has not explicitly overridden the model. Off-by-default agent-type model pins (named specialist agents like reviewer/critic/architect) are never affected — this only applies to the generic default 'task' agent.";
+        };
+    };
     readonly "task.maxRecursionDepth": {
         readonly type: "number";
         readonly default: 2;

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

@@ -45,6 +45,15 @@ export declare function clearMemoryData(agentDir: string, cwd: string): Promise<
  */
 export declare function enqueueMemoryConsolidation(agentDir: string, cwd: string, sourceUpdatedAt?: number): void;
 export declare function getMemoryRoot(agentDir: string, cwd: string): string;
+/**
+ * Filename of the captured-lessons file under a project's memory root.
+ *
+ * Written by the `learn` tool via {@link saveLearnedLesson} and read back by
+ * {@link buildMemoryToolDeveloperInstructions}. Deliberately distinct from the
+ * consolidation artifacts (`MEMORY.md`, `memory_summary.md`, `skills/`) so a
+ * consolidation pass never clobbers manually captured lessons.
+ */
+export declare const LEARNED_LESSONS_FILE = "learned.md";
 /**
  * Append one lesson to the project's `learned.md` (newest-first, deduped,
  * capped, secret-redacted, injection-neutralized). The file backs the `learn`

package/dist/types/memory-backend/types.d.ts

@@ -53,6 +53,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 {
     backend: MemoryBackendId;

package/dist/types/slash-commands/helpers/skill-verify.d.ts

@@ -0,0 +1,5 @@
+import type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime } from "../types";
+/** Extract the bulleted list under a `## Eval Cases` heading, if present. */
+export declare function extractEvalCases(skillBody: string): string[];
+/** `/verify-skill <name>` handler — resolves a skill, runs its `## Eval Cases`, reports pass/fail. */
+export declare function handleSkillCommand(command: ParsedSlashCommand, runtime: SlashCommandRuntime): Promise<SlashCommandResult>;

package/dist/types/task/model-tier-classifier.d.ts

@@ -0,0 +1,8 @@
+import { type ClassifyDifficultyDeps } from "../auto-thinking/classifier";
+/**
+ * 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 declare function classifyDefaultTaskModelTier(assignment: string, deps: ClassifyDifficultyDeps): Promise<"smol" | undefined>;

package/dist/types/tools/builtin-names.d.ts

@@ -1,4 +1,4 @@
-export declare const BUILTIN_TOOL_NAMES: readonly ["read", "bash", "edit", "ast_grep", "ast_edit", "ask", "debug", "eval", "ssh", "github", "glob", "grep", "lsp", "inspect_image", "browser", "checkpoint", "rewind", "task", "job", "irc", "subagent", "todo", "web_search", "search_tool_bm25", "write", "memory_edit", "retain", "recall", "reflect", "learn", "manage_skill"];
+export declare const BUILTIN_TOOL_NAMES: readonly ["read", "bash", "edit", "ast_grep", "ast_edit", "ask", "debug", "eval", "ssh", "github", "glob", "grep", "lsp", "inspect_image", "vision_verify", "browser", "checkpoint", "rewind", "task", "job", "irc", "subagent", "todo", "web_search", "search_tool_bm25", "write", "memory_edit", "retain", "recall", "reflect", "learn", "manage_skill"];
 export type BuiltinToolName = (typeof BUILTIN_TOOL_NAMES)[number];
 /** Return the canonical tool name for current and legacy built-in tool IDs. */
 export declare function normalizeToolName(name: string): string;

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

@@ -64,6 +64,7 @@ export * from "./ssh";
 export * from "./subagent";
 export * from "./todo";
 export * from "./tts";
+export * from "./vision-verify";
 export * from "./write";
 export * from "./yield";
 /** Tool type (AgentTool from pi-ai) */

package/dist/types/tools/learn.d.ts

@@ -3,6 +3,8 @@ import type { ToolSession } from ".";
 declare const learnSchema: import("arktype/internal/variants/object.ts").ObjectType<{
     memory: string;
     context?: string | undefined;
+    verified?: boolean | undefined;
+    evidence?: string | undefined;
     skill?: {
         action: "create" | "update";
         name: string;
@@ -27,6 +29,8 @@ export declare class LearnTool implements AgentTool<typeof learnSchema> {
     readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
         memory: string;
         context?: string | undefined;
+        verified?: boolean | undefined;
+        evidence?: string | undefined;
         skill?: {
             action: "create" | "update";
             name: string;

package/dist/types/tools/path-write-lock.d.ts

@@ -0,0 +1,10 @@
+import type { WritethroughCallback } from "../lsp";
+/**
+ * Wrap a {@link WritethroughCallback} so concurrent writes to the same `dst`
+ * are serialized instead of racing. `dst` is used as-is for the chain key:
+ * every caller (edit's hashline/patch/replace paths, and the write tool)
+ * resolves `dst` to an absolute path via `resolvePlanPath`/`resolveToCwd`
+ * before invoking the writethrough, so the same logical file always arrives
+ * under the same string.
+ */
+export declare function withPathWriteLock(callback: WritethroughCallback): WritethroughCallback;

package/dist/types/tools/vision-verify.d.ts

@@ -0,0 +1,34 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "jeopi-agent-core";
+import { completeSimple, type ToolExample } from "jeopi-ai";
+import type { ToolSession } from "./index";
+declare const visionVerifySchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    goal: string;
+    screenshot: string;
+    baseline?: string | undefined;
+}, {}>;
+export type VisionVerifyParams = typeof visionVerifySchema.infer;
+export interface VisionVerifyToolDetails {
+    model: string;
+    matches: boolean;
+    gaps: string[];
+}
+export declare class VisionVerifyTool implements AgentTool<typeof visionVerifySchema, VisionVerifyToolDetails> {
+    private readonly session;
+    private readonly completeImageRequest;
+    readonly name = "vision_verify";
+    readonly approval: "read";
+    readonly label = "VisionVerify";
+    readonly loadMode = "discoverable";
+    readonly summary = "Check a screenshot/artifact against a stated goal with a vision model";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        goal: string;
+        screenshot: string;
+        baseline?: string | undefined;
+    }, {}>;
+    readonly strict = false;
+    readonly examples: readonly ToolExample<typeof visionVerifySchema.infer>[];
+    constructor(session: ToolSession, completeImageRequest?: typeof completeSimple);
+    execute(_toolCallId: string, params: VisionVerifyParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<VisionVerifyToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<VisionVerifyToolDetails>>;
+}
+export {};

package/package.json

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

package/src/autolearn/controller.ts

@@ -1,10 +1,15 @@
 /**
  * Auto-learn session controller (experimental).
  *
- * Subscribes to the session event stream and, after a substantive turn,
- * optionally auto-runs a synthetic capture turn. Passive mode is intentionally
- * prompt-cache neutral: the standing system guidance remains available, but no
- * hidden mid-session reminder is inserted into the conversation.
+ * Subscribes to the session event stream and, after a turn becomes eligible
+ * for the capture nudge, optionally auto-runs a synthetic capture turn. A
+ * turn is eligible via either of two independent paths: it cleared the
+ * `autolearn.minToolCalls` volume threshold, OR it saw at least one failed
+ * tool call regardless of volume — a single failure is treated as a likely
+ * reusable lesson even in an otherwise-short turn. Passive mode is
+ * intentionally prompt-cache neutral: the standing system guidance remains
+ * available, but no hidden mid-session reminder is inserted into the
+ * conversation.
  *
  * Installed once per top-level session (taskDepth 0). The subscription lives
  * for the session's lifetime — `newSession` resets the session in place
@@ -54,6 +59,8 @@ export class AutoLearnController {
 	 * would let a goal-continuation turn slip through and get nudged.
 	 */
 	#turnStartedInGoalMode = false;
+	/** Whether any `tool_execution_end` in the in-flight turn carried `isError === true`. */
+	#sawFailure = false;
 	/** Swallow the agent_end produced by an auto-run capture turn so it cannot re-trigger. */
 	#suppressNext = false;
 
@@ -73,6 +80,7 @@ export class AutoLearnController {
 		}
 		if (event.type === "tool_execution_end") {
 			this.#toolCalls++;
+			if (event.isError === true) this.#sawFailure = true;
 			return;
 		}
 		if (event.type === "agent_end") {
@@ -90,6 +98,10 @@ export class AutoLearnController {
 		// observed no agent_start can never inherit a stale value.
 		const startedInGoalMode = this.#turnStartedInGoalMode;
 		this.#turnStartedInGoalMode = false;
+		// Snapshot and reset alongside the counter above: a failure describes
+		// only the just-finished turn.
+		const sawFailure = this.#sawFailure;
+		this.#sawFailure = false;
 
 		if (this.#suppressNext) {
 			this.#suppressNext = false;
@@ -99,7 +111,11 @@ export class AutoLearnController {
 		// the current flag rather than trusting install-time state.
 		if (!this.#settings.get("autolearn.enabled")) return;
 		const minToolCalls = this.#settings.get("autolearn.minToolCalls") ?? DEFAULT_MIN_TOOL_CALLS;
-		if (toolCalls < minToolCalls) return;
+		// Eligible when EITHER the turn cleared the volume threshold OR it saw at
+		// least one failed tool call — a single failure is a reusable lesson
+		// regardless of how few tools ran, while the volume gate remains the
+		// fallback for long clean turns.
+		if (toolCalls < minToolCalls && !sawFailure) return;
 		// Never interrupt plan-mode review.
 		if (this.#session.getPlanModeState()?.enabled) return;
 		// Never divert a goal loop. Skip when the turn STARTED in goal mode — a

package/src/config/settings-schema.ts

@@ -3560,6 +3560,18 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"vision_verify.enabled": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "tools",
+			group: "Available Tools",
+			label: "Vision Verify",
+			description:
+				"Enable the vision_verify tool, checking a screenshot/artifact against a stated goal with a vision-capable model",
+		},
+	},
+
 	"checkpoint.enabled": {
 		type: "boolean",
 		default: false,
@@ -4124,6 +4136,18 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"task.autoModelTier": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "tasks",
+			group: "Subagents",
+			label: "Auto Model Tier for Simple Tasks",
+			description:
+				"Classify a task() spawn's assignment text and route trivially-simple work to the cheap 'smol' model tier instead of the default 'task' tier, when the caller has not explicitly overridden the model. Off-by-default agent-type model pins (named specialist agents like reviewer/critic/architect) are never affected — this only applies to the generic default 'task' agent.",
+		},
+	},
+
 	"task.maxRecursionDepth": {
 		type: "number",
 		default: 2,

package/src/edit/index.ts

@@ -19,6 +19,7 @@ import replaceDescription from "../prompts/tools/replace.md" with { type: "text"
 import type { DeferredDiagnosticsEntry, ToolSession } from "../tools";
 import { truncateForPrompt } from "../tools/approval";
 import { isInternalUrlPath } from "../tools/path-utils";
+import { withPathWriteLock } from "../tools/path-write-lock";
 import { type EditMode, normalizeEditMode, resolveEditMode } from "../utils/edit-mode";
 import { executeHashlineSingle, hashlineEditParamsSchema } from "./hashline";
 import { type ApplyPatchParams, applyPatchSchema, expandApplyPatchToEntries } from "./modes/apply-patch";
@@ -405,7 +406,7 @@ export class EditTool implements AgentTool<TInput> {
 			(session.enableLsp ?? true) &&
 			session.settings.get("lsp.diagnosticsOnEdit") &&
 			session.settings.get("lsp.diagnosticsDeduplicate");
-		this.#writethrough = createEditWritethrough(session);
+		this.#writethrough = withPathWriteLock(createEditWritethrough(session));
 	}
 
 	get mode(): EditMode {