@oh-my-pi/pi-coding-agent 15.7.1 → 15.7.3

package/src/session/session-manager.ts

@@ -1837,6 +1837,12 @@ export class SessionManager {
 		premiumRequests: 0,
 		cost: 0,
 	} satisfies UsageStatistics;
+	/** Per-turn output-token budget set by a `+Nk` directive (total null when none this turn). */
+	#turnBudget: { total: number | null; hard: boolean } = { total: null, hard: false };
+	/** Cumulative `output` snapshot captured when the current turn budget window opened. */
+	#turnBaselineOutput = 0;
+	/** Output tokens consumed by eval-spawned subagents in the current turn window. */
+	#turnEvalOutput = 0;
 	#persistWriter: NdjsonFileWriter | undefined;
 	#persistWriterPath: string | undefined;
 	#persistChain: Promise<void> = Promise.resolve();
@@ -2397,6 +2403,32 @@ export class SessionManager {
 		return this.#usageStatistics;
 	}
 
+	/**
+	 * Open a new per-turn budget window: snapshot the cumulative output baseline,
+	 * reset the eval-subagent counter, and set the (optional) ceiling. Called once
+	 * per real user message; `total` is null when no `+Nk` directive was present.
+	 */
+	beginTurnBudget(total: number | null, hard: boolean): void {
+		this.#turnBudget = { total, hard };
+		this.#turnBaselineOutput = this.#usageStatistics.output;
+		this.#turnEvalOutput = 0;
+	}
+
+	/** Record output tokens consumed by an eval-spawned subagent in the current turn. */
+	recordEvalSubagentOutput(output: number): void {
+		if (Number.isFinite(output) && output > 0) this.#turnEvalOutput += output;
+	}
+
+	/**
+	 * Current turn budget for the eval `budget` helper: the ceiling (null = none),
+	 * output tokens spent this turn (main loop + eval-spawned subagents, no
+	 * double-count), and whether the ceiling is hard.
+	 */
+	getTurnBudget(): { total: number | null; spent: number; hard: boolean } {
+		const mainDelta = Math.max(0, this.#usageStatistics.output - this.#turnBaselineOutput);
+		return { total: this.#turnBudget.total, spent: mainDelta + this.#turnEvalOutput, hard: this.#turnBudget.hard };
+	}
+
 	getSessionDir(): string {
 		return this.sessionDir;
 	}

package/src/session/session-storage.ts

@@ -272,8 +272,8 @@ class MemorySessionStorageWriter implements SessionStorageWriter {
 		if (this.#closed) throw new Error("Writer closed");
 		if (this.#error) throw this.#error;
 		try {
-			const existing = this.#storage.existsSync(this.#path) ? this.#storage.readTextSync(this.#path) : "";
-			this.#storage.writeTextSync(this.#path, `${existing}${line}`);
+			// O(1) chunked append — see MemorySessionStorage.appendChunkSync.
+			this.#storage.appendChunkSync(this.#path, line);
 		} catch (err) {
 			throw this.#recordError(err);
 		}
@@ -302,8 +302,26 @@ class MemorySessionStorageWriter implements SessionStorageWriter {
 	}
 }
 
+/**
+ * Mirror entry stored per path. Chunks accumulate via O(1) `push` on
+ * `appendChunkSync`; readers materialise into a single string lazily.
+ * `byteLen` is kept in sync so `statSync` is O(1) (and returns true UTF-8
+ * bytes, not character count).
+ */
+interface MirrorEntry {
+	chunks: string[];
+	byteLen: number;
+	mtimeMs: number;
+}
+
+function materialiseMirror(entry: MirrorEntry): string {
+	if (entry.chunks.length === 0) return "";
+	if (entry.chunks.length === 1) return entry.chunks[0];
+	return entry.chunks.join("");
+}
+
 export class MemorySessionStorage implements SessionStorage {
-	#files = new Map<string, { content: string; mtimeMs: number }>();
+	#files = new Map<string, MirrorEntry>();
 
 	ensureDirSync(_dir: string): void {
 		// No-op for in-memory storage.
@@ -314,20 +332,40 @@ export class MemorySessionStorage implements SessionStorage {
 	}
 
 	writeTextSync(path: string, content: string): void {
-		this.#files.set(path, { content, mtimeMs: Date.now() });
+		this.#files.set(path, {
+			chunks: content.length === 0 ? [] : [content],
+			byteLen: Buffer.byteLength(content, "utf-8"),
+			mtimeMs: Date.now(),
+		});
+	}
+
+	/**
+	 * Internal O(1) append used by {@link MemorySessionStorageWriter}. Lazily
+	 * creates the entry. External callers should go through `openWriter()`
+	 * rather than touching the mirror directly.
+	 */
+	appendChunkSync(path: string, chunk: string): void {
+		let entry = this.#files.get(path);
+		if (!entry) {
+			entry = { chunks: [], byteLen: 0, mtimeMs: Date.now() };
+			this.#files.set(path, entry);
+		}
+		entry.chunks.push(chunk);
+		entry.byteLen += Buffer.byteLength(chunk, "utf-8");
+		entry.mtimeMs = Date.now();
 	}
 
 	readTextSync(path: string): string {
 		const entry = this.#files.get(path);
 		if (!entry) throw new Error(`File not found: ${path}`);
-		return entry.content;
+		return materialiseMirror(entry);
 	}
 
 	statSync(path: string): SessionStorageStat {
 		const entry = this.#files.get(path);
 		if (!entry) throw new Error(`File not found: ${path}`);
 		return {
-			size: entry.content.length,
+			size: entry.byteLen,
 			mtimeMs: entry.mtimeMs,
 			mtime: new Date(entry.mtimeMs),
 		};
@@ -353,13 +391,35 @@ export class MemorySessionStorage implements SessionStorage {
 	readText(path: string): Promise<string> {
 		const entry = this.#files.get(path);
 		if (!entry) return Promise.reject(new Error(`File not found: ${path}`));
-		return Promise.resolve(entry.content);
+		return Promise.resolve(materialiseMirror(entry));
 	}
 
 	readTextPrefix(path: string, maxBytes: number): Promise<string> {
 		const entry = this.#files.get(path);
 		if (!entry) return Promise.reject(new Error(`File not found: ${path}`));
-		return Promise.resolve(entry.content.slice(0, maxBytes));
+		if (entry.chunks.length === 0 || maxBytes <= 0) return Promise.resolve("");
+
+		// Walk chunks until the byte budget is exhausted. Avoids materialising
+		// the full mirror just to slice a prefix — bounded work for big files.
+		let accumulatedBytes = 0;
+		const out: string[] = [];
+		for (const chunk of entry.chunks) {
+			const chunkBytes = Buffer.byteLength(chunk, "utf-8");
+			if (accumulatedBytes + chunkBytes <= maxBytes) {
+				out.push(chunk);
+				accumulatedBytes += chunkBytes;
+				if (accumulatedBytes === maxBytes) break;
+				continue;
+			}
+			// Boundary chunk: slice in byte space and decode. Result MAY be
+			// shorter than the budget if a multi-byte codepoint straddles the
+			// boundary — matches `peekFile` semantics (partial decode at cap).
+			const remainingBytes = maxBytes - accumulatedBytes;
+			const utf8 = Buffer.from(chunk, "utf-8");
+			out.push(utf8Decoder.decode(utf8.subarray(0, remainingBytes)));
+			break;
+		}
+		return Promise.resolve(out.join(""));
 	}
 
 	writeText(path: string, content: string): Promise<void> {

package/src/session/shake-types.ts

@@ -0,0 +1,44 @@
+/**
+ * Public shape of the `shake` operation, kept in a dependency-free leaf module
+ * so slash-command registries and controllers can import `formatShakeSummary`
+ * without pulling in the heavy `agent-session` module graph (which would form
+ * an import cycle through the slash-command registry).
+ */
+
+/** Mode selector for `AgentSession.shake`. */
+export type ShakeMode = "elide" | "summary" | "images";
+
+/** Outcome of an `AgentSession.shake` run. */
+export interface ShakeResult {
+	mode: ShakeMode;
+	/** Whole tool-call results dropped/compressed. */
+	toolResultsDropped: number;
+	/** Large fenced/XML blocks dropped/compressed. */
+	blocksDropped: number;
+	/** Image blocks removed (images mode only). */
+	imagesDropped?: number;
+	/** Estimated context tokens reclaimed. */
+	tokensFreed: number;
+	/** Session artifact holding the dropped originals, when persisted. */
+	artifactId?: string;
+}
+
+/** One-line operator summary of a {@link ShakeResult} (shared by TUI + ACP). */
+export function formatShakeSummary(result: ShakeResult): string {
+	if (result.mode === "images") {
+		const n = result.imagesDropped ?? 0;
+		return n === 0
+			? "No images found in this session."
+			: `Dropped ${n} image${n === 1 ? "" : "s"} from this session.`;
+	}
+	const parts: string[] = [];
+	if (result.toolResultsDropped > 0) {
+		parts.push(`${result.toolResultsDropped} tool result${result.toolResultsDropped === 1 ? "" : "s"}`);
+	}
+	if (result.blocksDropped > 0) {
+		parts.push(`${result.blocksDropped} block${result.blocksDropped === 1 ? "" : "s"}`);
+	}
+	if (parts.length === 0) return "Nothing to shake.";
+	const verb = result.mode === "summary" ? "Compressed" : "Shook";
+	return `${verb} ${parts.join(" + ")} (~${result.tokensFreed} tokens freed).`;
+}

package/src/slash-commands/builtin-registry.ts

@@ -21,6 +21,7 @@ import {
 } from "../extensibility/plugins/marketplace";
 import { resolveMemoryBackend } from "../memory-backend";
 import type { InteractiveModeContext } from "../modes/types";
+import { formatShakeSummary, type ShakeMode } from "../session/shake-types";
 import { getChangelogPath, parseChangelog } from "../utils/changelog";
 import { buildContextReportText } from "./helpers/context-report";
 import { formatDuration } from "./helpers/format";
@@ -57,6 +58,15 @@ const shutdownHandlerTui = (_command: ParsedSlashCommand, runtime: TuiSlashComma
 	return commandConsumed();
 };
 
+/** Parse the `/shake` subcommand into a {@link ShakeMode}; empty defaults to elide. */
+function parseShakeMode(args: string): ShakeMode | { error: string } {
+	const verb = args.trim().toLowerCase();
+	if (verb === "" || verb === "elide") return "elide";
+	if (verb === "summary") return "summary";
+	if (verb === "images") return "images";
+	return { error: `Unknown /shake mode "${verb}". Use elide, summary, or images.` };
+}
+
 const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	{
 		name: "settings",
@@ -811,27 +821,31 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 		},
 	},
 	{
-		name: "drop-images",
-		description: "Strip every image from this session's history",
-		acpDescription: "Drop all images from the conversation history",
-		handle: async (_command, runtime) => {
-			const { removed } = await runtime.session.dropImages();
-			await runtime.output(
-				removed === 0
-					? "No images found in this session."
-					: `Dropped ${removed} image${removed === 1 ? "" : "s"} from this session.`,
-			);
+		name: "shake",
+		description: "Drop heavy content from context (tool results, large blocks)",
+		acpDescription: "Shake heavy content out of the conversation context",
+		subcommands: [
+			{ name: "elide", description: "Strip tool results + large blocks (default)" },
+			{ name: "summary", description: "Compress heavy regions with a local on-device model" },
+			{ name: "images", description: "Strip image blocks" },
+		],
+		acpInputHint: "[elide|summary|images]",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const mode = parseShakeMode(command.args);
+			if (typeof mode !== "string") return usage(mode.error, runtime);
+			const result = await runtime.session.shake(mode);
+			await runtime.output(formatShakeSummary(result));
 			return commandConsumed();
 		},
-		handleTui: async (_command, runtime) => {
+		handleTui: async (command, runtime) => {
 			runtime.ctx.editor.setText("");
-			const { removed } = await runtime.ctx.session.dropImages();
-			if (removed === 0) {
-				runtime.ctx.showStatus("No images found in this session.");
+			const mode = parseShakeMode(command.args);
+			if (typeof mode !== "string") {
+				runtime.ctx.showWarning(mode.error);
 				return;
 			}
-			runtime.ctx.rebuildChatFromMessages();
-			runtime.ctx.showStatus(`Dropped ${removed} image${removed === 1 ? "" : "s"} from this session.`);
+			await runtime.ctx.handleShakeCommand(mode);
 		},
 	},
 	{
@@ -864,6 +878,17 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			await runtime.ctx.handleBtwCommand(question);
 		},
 	},
+	{
+		name: "omfg",
+		description: "Forge a TTSR rule from a complaint to stop a recurring behavior",
+		inlineHint: "<complaint>",
+		allowArgs: true,
+		handleTui: async (command, runtime) => {
+			const complaint = command.text.slice(`/${command.name}`.length).trim();
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleOmfgCommand(complaint);
+		},
+	},
 	{
 		name: "retry",
 		description: "Retry the last failed agent turn",

package/src/task/executor.ts

@@ -21,7 +21,7 @@ import type { HindsightSessionState } from "../hindsight/state";
 import type { LocalProtocolOptions } from "../internal-urls";
 import { callTool } from "../mcp/client";
 import type { MCPManager } from "../mcp/manager";
-import type { MnemosyneSessionState } from "../mnemosyne/state";
+import type { MnemopiSessionState } from "../mnemopi/state";
 import subagentSystemPromptTemplate from "../prompts/system/subagent-system-prompt.md" with { type: "text" };
 import submitReminderTemplate from "../prompts/system/subagent-yield-reminder.md" with { type: "text" };
 import { AgentRegistry } from "../registry/agent-registry";
@@ -186,7 +186,7 @@ export interface ExecutorOptions {
 	 */
 	parentArtifactManager?: ArtifactManager;
 	parentHindsightSessionState?: HindsightSessionState;
-	parentMnemosyneSessionState?: MnemosyneSessionState;
+	parentMnemopiSessionState?: MnemopiSessionState;
 	/** Parent agent's eval executor session id. Subagents reuse it so eval state is shared. */
 	parentEvalSessionId?: string;
 	/**
@@ -1245,7 +1245,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					spawns: spawnsEnv,
 					taskDepth: childDepth,
 					parentHindsightSessionState: options.parentHindsightSessionState,
-					parentMnemosyneSessionState: options.parentMnemosyneSessionState,
+					parentMnemopiSessionState: options.parentMnemopiSessionState,
 					parentTaskPrefix: id,
 					agentId: id,
 					agentDisplayName: agent.name,

package/src/task/index.ts

@@ -762,8 +762,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 		const tempArtifactsDir = artifactsDir ? null : path.join(os.tmpdir(), `omp-task-${Snowflake.next()}`);
 		const effectiveArtifactsDir = artifactsDir || tempArtifactsDir!;
 
-		// Share the parent session's local:// root with subagents so they read/write the same scratch space
-		const localProtocolOptions: LocalProtocolOptions = {
+		const localProtocolOptions: LocalProtocolOptions = this.session.localProtocolOptions ?? {
 			getArtifactsDir: this.session.getArtifactsDir ?? (() => null),
 			getSessionId: this.session.getSessionId ?? (() => null),
 		};
@@ -864,6 +863,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			);
 			const promptTemplates = this.session.promptTemplates;
 			const parentEvalSessionId = this.session.getEvalSessionId?.() ?? undefined;
+			const mcpManager = this.session.mcpManager ?? MCPManager.instance();
 
 			// Initialize progress for all tasks
 			for (let i = 0; i < tasksWithUniqueIds.length; i++) {
@@ -921,7 +921,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						authStorage: this.session.authStorage,
 						modelRegistry: this.session.modelRegistry,
 						settings: this.session.settings,
-						mcpManager: MCPManager.instance(),
+						mcpManager,
 						contextFiles,
 						skills: availableSkills,
 						autoloadSkills: resolvedAutoloadSkills,
@@ -930,7 +930,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						localProtocolOptions,
 						parentArtifactManager,
 						parentHindsightSessionState: this.session.getHindsightSessionState?.(),
-						parentMnemosyneSessionState: this.session.getMnemosyneSessionState?.(),
+						parentMnemopiSessionState: this.session.getMnemopiSessionState?.(),
 						parentTelemetry: this.session.getTelemetry?.(),
 						parentEvalSessionId,
 					});
@@ -978,7 +978,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						authStorage: this.session.authStorage,
 						modelRegistry: this.session.modelRegistry,
 						settings: this.session.settings,
-						mcpManager: MCPManager.instance(),
+						mcpManager,
 						contextFiles,
 						skills: availableSkills,
 						autoloadSkills: resolvedAutoloadSkills,
@@ -987,7 +987,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						localProtocolOptions,
 						parentArtifactManager,
 						parentHindsightSessionState: this.session.getHindsightSessionState?.(),
-						parentMnemosyneSessionState: this.session.getMnemosyneSessionState?.(),
+						parentMnemopiSessionState: this.session.getMnemopiSessionState?.(),
 						parentTelemetry: this.session.getTelemetry?.(),
 						parentEvalSessionId,
 					});

package/src/thinking.ts

@@ -1,5 +1,5 @@
 import { type ResolvedThinkingLevel, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import { clampThinkingLevelForModel, type Effort, type Model, THINKING_EFFORTS } from "@oh-my-pi/pi-ai";
+import { clampThinkingLevelForModel, Effort, getSupportedEfforts, type Model, THINKING_EFFORTS } from "@oh-my-pi/pi-ai";
 
 /**
  * Metadata used to render thinking selector values in the coding-agent UI.
@@ -85,3 +85,75 @@ export function resolveThinkingLevelForModel(
 	}
 	return clampThinkingLevelForModel(model, level);
 }
+
+/**
+ * Sentinel selector for the coding-agent "auto" thinking mode. Kept entirely
+ * inside the coding-agent layer: it is never an {@link Effort} or
+ * {@link ThinkingLevel}, so provider mapping/clamping keeps seeing concrete
+ * efforts. The session resolves `auto` to a concrete effort each turn.
+ */
+export const AUTO_THINKING = "auto" as const;
+
+/** A thinking selector as configured by the user — a concrete level or `auto`. */
+export type ConfiguredThinkingLevel = ThinkingLevel | typeof AUTO_THINKING;
+
+/** Metadata used to render the `auto` selector value alongside concrete levels. */
+export interface ConfiguredThinkingLevelMetadata {
+	value: ConfiguredThinkingLevel;
+	label: string;
+	description: string;
+}
+
+const AUTO_THINKING_METADATA: ConfiguredThinkingLevelMetadata = {
+	value: AUTO_THINKING,
+	label: "auto",
+	description: "Auto-detect per prompt (low–xhigh)",
+};
+
+/**
+ * Parses a configured thinking selector, accepting `auto` in addition to every
+ * value {@link parseThinkingLevel} accepts. {@link parseThinkingLevel} itself
+ * stays strict so model-suffix parsing (`model:high`) keeps rejecting `auto`.
+ */
+export function parseConfiguredThinkingLevel(value: string | null | undefined): ConfiguredThinkingLevel | undefined {
+	if (value === AUTO_THINKING) return AUTO_THINKING;
+	return parseThinkingLevel(value);
+}
+
+/** Returns display metadata for a configured selector, including `auto`. */
+export function getConfiguredThinkingLevelMetadata(level: ConfiguredThinkingLevel): ConfiguredThinkingLevelMetadata {
+	return level === AUTO_THINKING ? AUTO_THINKING_METADATA : getThinkingLevelMetadata(level);
+}
+
+/**
+ * Resolves an auto-classified effort against the active model's supported
+ * range. Unlike {@link clampThinkingLevelForModel}, `auto` never resolves below
+ * {@link Effort.Low}: the eligible pool is the model's supported efforts at or
+ * above Low (falling back to the full supported set only when the model maxes
+ * out below Low). Within that pool the request snaps to the highest level not
+ * exceeding it, or the pool minimum when the request is below the pool.
+ */
+export function clampAutoThinkingEffort(model: Model | undefined, effort: Effort): Effort {
+	const supported = model ? getSupportedEfforts(model) : THINKING_EFFORTS;
+	if (supported.length === 0) return effort;
+	const lowIndex = THINKING_EFFORTS.indexOf(Effort.Low);
+	const eligible = supported.filter(level => THINKING_EFFORTS.indexOf(level) >= lowIndex);
+	const pool = eligible.length > 0 ? eligible : supported;
+	const requestedIndex = THINKING_EFFORTS.indexOf(effort);
+	let chosen = pool[0];
+	for (const candidate of pool) {
+		if (THINKING_EFFORTS.indexOf(candidate) > requestedIndex) break;
+		chosen = candidate;
+	}
+	return chosen;
+}
+
+/**
+ * The provisional concrete level shown while `auto` is configured but before a
+ * turn has been classified. Prefers the model's `defaultLevel`, otherwise High,
+ * clamped into the auto range. Returns `undefined` for non-reasoning models.
+ */
+export function resolveProvisionalAutoLevel(model: Model | undefined): Effort | undefined {
+	if (!model?.reasoning) return undefined;
+	return clampAutoThinkingEffort(model, model.thinking?.defaultLevel ?? Effort.High);
+}

package/src/tiny/device.ts

@@ -27,12 +27,6 @@ const DEVICE_VALUES: Record<TinyModelDevice, true> = {
 	"webnn-cpu": true,
 };
 
-function defaultTinyModelDevice(): TinyModelDevice {
-	if (process.platform === "win32") return "dml";
-	if (process.platform === "linux" && process.arch === "x64") return "cuda";
-	return CPU_DEVICE;
-}
-
 function usesDarwinWorkerWebGpu(device: TinyModelDevice): boolean {
 	return process.platform === "darwin" && (device === "gpu" || device === "webgpu" || device === "auto");
 }
@@ -51,7 +45,7 @@ export function resolveTinyModelDevicePreference(
 	value: string | undefined = $env.PI_TINY_DEVICE,
 ): TinyModelDevicePreference {
 	return {
-		device: normalizeTinyModelDevice(value) ?? defaultTinyModelDevice(),
+		device: normalizeTinyModelDevice(value) ?? CPU_DEVICE,
 		raw: value,
 	};
 }
@@ -62,7 +56,7 @@ export function tinyModelDeviceLoadOrder(preference: TinyModelDevicePreference):
 	return [preference.device, CPU_DEVICE];
 }
 
-/** Sentinel `providers.tinyModelDevice` value meaning "use the built-in platform default". */
+/** Sentinel `providers.tinyModelDevice` value meaning "use the built-in CPU default". */
 export const TINY_MODEL_DEVICE_DEFAULT = "default";
 
 /** Accepted values for the `providers.tinyModelDevice` setting (validation + UI). */
@@ -85,7 +79,7 @@ export const TINY_MODEL_DEVICE_SETTING_VALUES = [
 
 /** Submenu metadata for the `providers.tinyModelDevice` setting. */
 export const TINY_MODEL_DEVICE_SETTING_OPTIONS = [
-	{ value: "default", label: "Default", description: "DirectML on Windows, CUDA on Linux x64, CPU elsewhere" },
+	{ value: "default", label: "Default", description: "CPU-only inference" },
 	{ value: "gpu", label: "GPU", description: "Accelerated provider (WebGPU/Metal, CUDA, or DirectML)" },
 	{ value: "cpu", label: "CPU", description: "CPU-only inference" },
 	{ value: "metal", label: "Metal", description: "WebGPU alias for Apple GPUs" },
@@ -108,7 +102,7 @@ export const TINY_MODEL_DEVICE_SETTING_OPTIONS = [
 /**
  * Map a `providers.tinyModelDevice` setting value onto a `PI_TINY_DEVICE` env
  * value for the worker. Returns `undefined` for the default sentinel so the
- * worker keeps its built-in platform default; the worker still validates the
+ * worker keeps its built-in CPU default; the worker still validates the
  * forwarded value via {@link normalizeTinyModelDevice}.
  */
 export function tinyModelDeviceSettingToEnv(value: string | undefined): string | undefined {

package/src/tiny/models.ts

@@ -108,7 +108,7 @@ export const ONLINE_MEMORY_MODEL_KEY = "online";
 export const DEFAULT_MEMORY_LOCAL_MODEL_KEY = "qwen3-1.7b";
 
 /**
- * Local models for Mnemosyne memory tasks (fact extraction + consolidation).
+ * Local models for Mnemopi memory tasks (fact extraction + consolidation).
  * These are larger (1B-1.7B) than the title models: structured extraction and
  * faithful summarization need more capacity than 3-6 word titles. All q4.
  * Ranking/recipe rationale lives in docs/local-models.md.
@@ -177,7 +177,7 @@ export const TINY_MEMORY_MODEL_OPTIONS = [
 		value: ONLINE_MEMORY_MODEL_KEY,
 		label: "Online (smol/remote)",
 		description:
-			"Use the configured Mnemosyne LLM mode (smol or remote); no local model download or on-device inference.",
+			"Use the configured Mnemopi LLM mode (smol or remote); no local model download or on-device inference.",
 	},
 	...TINY_MEMORY_LOCAL_MODELS.map(model => ({
 		value: model.key,
@@ -196,6 +196,34 @@ export function getTinyMemoryModelSpec(key: TinyMemoryLocalModelKey): (typeof TI
 	return spec;
 }
 
+/**
+ * Shake-summary models. Shake's `summary` mode (and the `shake-summary`
+ * compaction strategy) compress heavy regions strictly on-device — there is no
+ * online/remote option, so this registry reuses the local memory models only.
+ */
+export const SHAKE_SUMMARY_MODEL_VALUES = [
+	"qwen3-1.7b",
+	"gemma-3-1b",
+	"qwen2.5-1.5b",
+	"lfm2-1.2b",
+] as const satisfies readonly TinyMemoryLocalModelKey[];
+
+export type ShakeSummaryModelKey = (typeof SHAKE_SUMMARY_MODEL_VALUES)[number];
+
+// Guard: every local memory model is offered for shake summary (catches drift).
+type MissingShakeSummaryValue = Exclude<TinyMemoryLocalModelKey, ShakeSummaryModelKey>;
+const SHAKE_SUMMARY_MODEL_VALUES_MATCH_REGISTRY: MissingShakeSummaryValue extends never ? true : never = true;
+void SHAKE_SUMMARY_MODEL_VALUES_MATCH_REGISTRY;
+
+export const SHAKE_SUMMARY_MODEL_OPTIONS = TINY_MEMORY_LOCAL_MODELS.map(model => ({
+	value: model.key,
+	label: model.label,
+	description: model.description,
+})) satisfies ReadonlyArray<{ value: ShakeSummaryModelKey; label: string; description: string }>;
+
+/** Default shake-summary local model when none is named. */
+export const DEFAULT_SHAKE_SUMMARY_MODEL_KEY: ShakeSummaryModelKey = DEFAULT_MEMORY_LOCAL_MODEL_KEY;
+
 /** Any local model key (title or memory), used by the shared inference worker. */
 export type TinyLocalModelKey = TinyTitleLocalModelKey | TinyMemoryLocalModelKey;
 
@@ -216,3 +244,27 @@ export const TINY_LOCAL_MODELS = [
 	...TINY_TITLE_LOCAL_MODELS,
 	...TINY_MEMORY_LOCAL_MODELS,
 ] as const satisfies readonly TinyTitleLocalModelSpec[];
+
+/**
+ * Difficulty-classifier model for the `auto` thinking level. Defaults to the
+ * online smol path; the local options reuse the memory-model registry because
+ * the shared worker's `complete()` only accepts memory local keys, and the
+ * 1B+ memory models classify coding difficulty far more reliably than the
+ * sub-1B title models.
+ */
+export const ONLINE_AUTO_THINKING_MODEL_KEY = ONLINE_MEMORY_MODEL_KEY;
+export const AUTO_THINKING_MODEL_VALUES = TINY_MEMORY_MODEL_VALUES;
+export type AutoThinkingModelKey = TinyMemoryModelKey;
+
+export const AUTO_THINKING_MODEL_OPTIONS = [
+	{
+		value: ONLINE_AUTO_THINKING_MODEL_KEY,
+		label: "Online (smol)",
+		description: "Classify prompt difficulty with the online smol model; no local download or on-device inference.",
+	},
+	...TINY_MEMORY_LOCAL_MODELS.map(model => ({
+		value: model.key,
+		label: model.label,
+		description: model.description,
+	})),
+] satisfies ReadonlyArray<{ value: AutoThinkingModelKey; label: string; description: string }>;

package/src/tiny/title-protocol.ts

@@ -30,7 +30,17 @@ export interface TinyTitleProgressEvent {
 export type TinyTitleWorkerInbound =
 	| { type: "ping"; id: string }
 	| { type: "generate"; id: string; modelKey: TinyTitleLocalModelKey; message: string }
-	| { type: "complete"; id: string; modelKey: TinyLocalModelKey; prompt: string; maxTokens?: number }
+	| {
+			type: "complete";
+			id: string;
+			modelKey: TinyLocalModelKey;
+			prompt: string;
+			maxTokens?: number;
+			/** Optional assistant-turn prefix appended after the generation prompt to pin output format. */
+			prefill?: string;
+			/** Optional literal stop string; generation halts once it appears in the decoded tail. */
+			stop?: string;
+	  }
 	| { type: "download"; id: string; modelKey: TinyLocalModelKey }
 	| { type: "close" };