jeopi-cli 16.2.30 → 16.4.0

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

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

@@ -1,5 +1,11 @@
 import { GoalEvidenceTracker } from "./evidence-gate";
 import type { Goal, GoalBudgetSteering, GoalModeState, GoalRuntimeEvent, GoalTokenUsage } from "./state";
+export interface GoalCompletionVerdict {
+    verdict: "okay" | "iterate" | "reject";
+    justification: string;
+    summary?: string;
+    requiredFixes: string[];
+}
 export interface GoalRuntimeHost {
     getState(): GoalModeState | undefined;
     setState(state: GoalModeState | undefined): void;
@@ -11,6 +17,16 @@ export interface GoalRuntimeHost {
         content: string;
         deliverAs?: "steer" | "followUp" | "nextTurn";
     }): Promise<void>;
+    /**
+     * Spawn an independent grader sub-agent to verdict a completion claim against
+     * the objective and the actual repo diff (article gap: "the agent that wrote
+     * the code is not the agent that grades it"). The sub-agent sees only the
+     * objective + evidence text passed here plus its own repo inspection — never
+     * this session's transcript/reasoning. Optional: hosts that don't wire this
+     * (e.g. test harnesses, `goal.verifyCompletion` disabled) skip independent
+     * grading and fall back to the deterministic evidence gate alone.
+     */
+    verifyCompletion?(objective: string, evidence: string): Promise<GoalCompletionVerdict>;
     now?(): number;
 }
 export interface GoalTurnSnapshot {

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

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

package/dist/types/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/session/agent-session.d.ts

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

package/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.2.30",
+	"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.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",
+		"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/autoresearch/index.ts

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

package/src/config/settings-schema.ts

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