@oh-my-pi/pi-coding-agent 15.13.2 → 16.0.0

package/src/session/session-dump-format.ts

@@ -2,21 +2,10 @@
  * Plain-text / markdown session formatting (same shape as /dump clipboard export).
  */
 import type { AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import { INTENT_FIELD } from "@oh-my-pi/pi-agent-core";
-import type { AssistantMessage, Model, ToolExample, TSchema } from "@oh-my-pi/pi-ai";
-import { renderToolInventory } from "@oh-my-pi/pi-ai/grammar";
-import { getVisibleThinkingText } from "../utils/thinking-display";
-import {
-	type BashExecutionMessage,
-	type BranchSummaryMessage,
-	bashExecutionToText,
-	type CompactionSummaryMessage,
-	type CustomMessage,
-	type FileMentionMessage,
-	type HookMessage,
-	type PythonExecutionMessage,
-	pythonExecutionToText,
-} from "./messages";
+import type { Model, ToolExample, TSchema } from "@oh-my-pi/pi-ai";
+import { getDialectDefinition, renderToolInventory } from "@oh-my-pi/pi-ai/dialect";
+import { preferredDialect } from "@oh-my-pi/pi-catalog/identity";
+import { convertToLlm } from "./messages";
 
 /** Minimal tool shape for dump output (matches AgentTool fields used by formatSessionDumpText). */
 export interface SessionDumpToolInfo {
@@ -34,22 +23,12 @@ export interface FormatSessionDumpTextOptions {
 	tools?: readonly SessionDumpToolInfo[];
 }
 
-/** Serialize an object as XML parameter elements, one per key. */
-function formatArgsAsXml(args: Record<string, unknown>, indent = "\t"): string {
-	const parts: string[] = [];
-	for (const [key, value] of Object.entries(args)) {
-		if (key === INTENT_FIELD) continue;
-		const text = typeof value === "string" ? value : JSON.stringify(value);
-		parts.push(`${indent}<parameter name="${key}">${text}</parameter>`);
-	}
-	return parts.join("\n");
-}
-
 /**
  * Format messages and session metadata as markdown/plain text (same as AgentSession.formatSessionAsText / /dump).
  */
 export function formatSessionDumpText(options: FormatSessionDumpTextOptions): string {
 	const lines: string[] = [];
+	const definition = getDialectDefinition(preferredDialect(options.model?.id ?? ""));
 
 	const systemPrompt = options.systemPrompt?.filter(prompt => prompt.length > 0) ?? [];
 	if (systemPrompt.length > 0) {
@@ -71,127 +50,21 @@ export function formatSessionDumpText(options: FormatSessionDumpTextOptions): st
 	lines.push("\n");
 
 	const tools = options.tools ?? [];
-	if (tools.length > 0) {
+	const inventoryTools = tools.map(tool => ({
+		name: tool.name,
+		description: tool.description,
+		parameters: tool.parameters as TSchema,
+		examples: tool.examples,
+	}));
+	if (inventoryTools.length > 0) {
 		lines.push("## Available Tools\n");
-		const inventoryTools = tools.map(tool => ({
-			name: tool.name,
-			description: tool.description,
-			parameters: tool.parameters as TSchema,
-			examples: tool.examples,
-		}));
 		lines.push(renderToolInventory(inventoryTools, options.model?.id ?? ""));
 		lines.push("\n");
 	}
 
-	for (const msg of options.messages) {
-		if (msg.role === "user" || msg.role === "developer") {
-			lines.push(msg.role === "developer" ? "## Developer\n" : "## User\n");
-			if (typeof msg.content === "string") {
-				lines.push(msg.content);
-			} else {
-				for (const c of msg.content) {
-					if (c.type === "text") {
-						lines.push(c.text);
-					} else if (c.type === "image") {
-						lines.push("[Image]");
-					}
-				}
-			}
-			lines.push("\n");
-		} else if (msg.role === "assistant") {
-			const assistantMsg = msg as AssistantMessage;
-			lines.push("## Assistant\n");
-
-			for (const c of assistantMsg.content) {
-				if (c.type === "text") {
-					lines.push(c.text);
-				} else if (c.type === "thinking") {
-					const thinking = getVisibleThinkingText(c);
-					if (thinking.length === 0) continue;
-					lines.push("<thinking>");
-					lines.push(thinking);
-					lines.push("</thinking>\n");
-				} else if (c.type === "toolCall") {
-					lines.push(`<invoke name="${c.name}">`);
-					if (c.arguments && typeof c.arguments === "object") {
-						lines.push(formatArgsAsXml(c.arguments as Record<string, unknown>));
-					}
-					lines.push("<" + "/invoke>\n");
-				}
-			}
-			lines.push("");
-		} else if (msg.role === "toolResult") {
-			lines.push(`### Tool Result: ${msg.toolName}`);
-			if (msg.isError) {
-				lines.push("(error)");
-			}
-			for (const c of msg.content) {
-				if (c.type === "text") {
-					lines.push("```");
-					lines.push(c.text);
-					lines.push("```");
-				} else if (c.type === "image") {
-					lines.push("[Image output]");
-				}
-			}
-			lines.push("");
-		} else if (msg.role === "bashExecution") {
-			const bashMsg = msg as BashExecutionMessage;
-			if (!bashMsg.excludeFromContext) {
-				lines.push("## Bash Execution\n");
-				lines.push(bashExecutionToText(bashMsg));
-				lines.push("\n");
-			}
-		} else if (msg.role === "pythonExecution") {
-			const pythonMsg = msg as PythonExecutionMessage;
-			if (!pythonMsg.excludeFromContext) {
-				lines.push("## Python Execution\n");
-				lines.push(pythonExecutionToText(pythonMsg));
-				lines.push("\n");
-			}
-		} else if (msg.role === "custom" || msg.role === "hookMessage") {
-			const customMsg = msg as CustomMessage | HookMessage;
-			lines.push(`## ${customMsg.customType}\n`);
-			if (typeof customMsg.content === "string") {
-				lines.push(customMsg.content);
-			} else {
-				for (const c of customMsg.content) {
-					if (c.type === "text") {
-						lines.push(c.text);
-					} else if (c.type === "image") {
-						lines.push("[Image]");
-					}
-				}
-			}
-			lines.push("\n");
-		} else if (msg.role === "branchSummary") {
-			const branchMsg = msg as BranchSummaryMessage;
-			lines.push("## Branch Summary\n");
-			lines.push(`(from branch: ${branchMsg.fromId})\n`);
-			lines.push(branchMsg.summary);
-			lines.push("\n");
-		} else if (msg.role === "compactionSummary") {
-			const compactMsg = msg as CompactionSummaryMessage;
-			lines.push("## Compaction Summary\n");
-			lines.push(`(${compactMsg.tokensBefore} tokens before compaction)\n`);
-			lines.push(compactMsg.summary);
-			lines.push("\n");
-		} else if (msg.role === "fileMention") {
-			const fileMsg = msg as FileMentionMessage;
-			lines.push("## File Mention\n");
-			for (const file of fileMsg.files) {
-				lines.push(`<file path="${file.path}">`);
-				if (file.content) {
-					lines.push(file.content);
-				}
-				if (file.image) {
-					lines.push("[Image attached]");
-				}
-				lines.push("</file>\n");
-			}
-			lines.push("\n");
-		}
-	}
+	lines.push("## Transcript\n");
+	lines.push(definition.renderTranscript(convertToLlm([...options.messages]), { tools: inventoryTools }));
+	lines.push("\n");
 
 	return lines.join("\n").trim();
 }

package/src/session/session-history-format.ts

@@ -22,6 +22,10 @@ import type {
 export interface HistoryFormatOptions {
 	/** Optional H1 prepended to the transcript. */
 	title?: string;
+	/** Render assistant thinking blocks (default: elided). */
+	includeThinking?: boolean;
+	/** Render tool intent comment before tool call lines. */
+	includeToolIntent?: boolean;
 }
 
 /** Max length of the primary-arg summary inside `→ tool(...)` lines. */
@@ -100,17 +104,30 @@ function toolCallLine(
 	name: string,
 	args: Record<string, unknown> | undefined,
 	result: ToolResultMessage | undefined,
+	includeToolIntent?: boolean,
 ): string {
 	const head = `→ ${name}(${primaryArg(args)})`;
-	if (!result) return `${head} ⇒ pending`;
-	const text = contentToText(result.content);
-	const lines = lineCount(text);
-	const count = `${lines} ${lines === 1 ? "line" : "lines"}`;
-	if (result.isError) {
-		const firstLine = oneLine(text.split("\n", 1)[0] ?? "");
-		return firstLine ? `${head} ⇒ error · ${count} — ${firstLine}` : `${head} ⇒ error · ${count}`;
+	let base: string;
+	if (!result) {
+		base = `${head} ⇒ pending`;
+	} else {
+		const text = contentToText(result.content);
+		const lines = lineCount(text);
+		const count = `${lines} ${lines === 1 ? "line" : "lines"}`;
+		if (result.isError) {
+			const firstLine = oneLine(text.split("\n", 1)[0] ?? "");
+			base = firstLine ? `${head} ⇒ error · ${count} — ${firstLine}` : `${head} ⇒ error · ${count}`;
+		} else {
+			base = `${head} ⇒ ok · ${count}`;
+		}
+	}
+
+	const intent = includeToolIntent ? args?.[INTENT_FIELD] : undefined;
+	if (typeof intent === "string" && intent.trim()) {
+		const formattedIntent = oneLine(intent, 80);
+		return `# ${formattedIntent}\n${base}`;
 	}
-	return `${head} ⇒ ok · ${count}`;
+	return base;
 }
 
 /** One line for a user-initiated `!`/`$` execution. */
@@ -193,9 +210,11 @@ export function formatSessionHistoryMarkdown(messages: unknown[], opts?: History
 					} else if (block.type === "toolCall") {
 						const result = resultsByCallId.get(block.id);
 						if (result) consumed.add(block.id);
-						body.push(toolCallLine(block.name, block.arguments, result));
+						body.push(toolCallLine(block.name, block.arguments, result, opts?.includeToolIntent));
+					} else if (opts?.includeThinking && block.type === "thinking" && block.thinking.trim()) {
+						body.push(`_thinking:_ ${block.thinking}`);
 					}
-					// thinking / redactedThinking elided entirely
+					// redactedThinking elided entirely (no readable text)
 				}
 				if (body.length === 0) break;
 				lines.push("## assistant", "", ...body, "");
@@ -204,7 +223,7 @@ export function formatSessionHistoryMarkdown(messages: unknown[], opts?: History
 			case "toolResult": {
 				// Normally consumed by its toolCall; orphans (e.g. truncated history) get their own line.
 				if (consumed.has(msg.toolCallId)) break;
-				lines.push(toolCallLine(msg.toolName, undefined, msg), "");
+				lines.push(toolCallLine(msg.toolName, undefined, msg, opts?.includeToolIntent), "");
 				break;
 			}
 			case "bashExecution": {

package/src/session/unexpected-stop-classifier.ts

@@ -0,0 +1,129 @@
+import { type AssistantMessage, completeSimple } from "@oh-my-pi/pi-ai";
+import { logger, prompt } from "@oh-my-pi/pi-utils";
+
+import type { ModelRegistry } from "../config/model-registry";
+import { resolveRoleSelection } from "../config/model-resolver";
+import type { Settings } from "../config/settings";
+import unexpectedStopClassifierPrompt from "../prompts/system/unexpected-stop-classifier.md" with { type: "text" };
+import { isTinyMemoryLocalModelKey, ONLINE_MEMORY_MODEL_KEY } from "../tiny/models";
+import { tinyModelClient } from "../tiny/title-client";
+
+const CLASSIFIER_SYSTEM_PROMPT = prompt.render(unexpectedStopClassifierPrompt);
+
+/**
+ * The answer is a single word. OpenAI-compatible endpoints reject values below
+ * 16, so 16 is the smallest portable budget for this classifier.
+ */
+const ANSWER_MAX_TOKENS = 16;
+/**
+ * Reasoning backends ignore `disableReasoning` on some providers, so reserve
+ * enough output room for the keyword to still land after unavoidable thinking.
+ */
+const REASONING_SAFE_MAX_TOKENS = 1024;
+
+export interface ClassifyUnexpectedStopDeps {
+	settings: Settings;
+	registry: ModelRegistry;
+	sessionId: string;
+	metadataResolver?: (provider: string) => Record<string, unknown> | undefined;
+	signal?: AbortSignal;
+}
+
+export function isUnexpectedStopCandidate(message: AssistantMessage): boolean {
+	if (message.stopReason !== "stop") return false;
+	let hasText = false;
+	for (const content of message.content) {
+		if (content.type === "toolCall") return false;
+		if (content.type === "text" && /\S/.test(content.text)) {
+			hasText = true;
+		}
+	}
+	return hasText;
+}
+
+export async function classifyUnexpectedStop(
+	text: string,
+	deps: ClassifyUnexpectedStopDeps,
+): Promise<boolean | undefined> {
+	const backend = deps.settings.get("providers.unexpectedStopModel");
+	try {
+		if (backend === ONLINE_MEMORY_MODEL_KEY) {
+			return await classifyOnline(text, deps);
+		}
+		if (isTinyMemoryLocalModelKey(backend)) {
+			return await classifyLocal(text, backend, deps);
+		}
+		return undefined;
+	} catch (error) {
+		logger.debug("unexpected-stop: classification failed", {
+			error: error instanceof Error ? error.message : String(error),
+			backend,
+		});
+		return undefined;
+	}
+}
+
+async function classifyOnline(text: string, deps: ClassifyUnexpectedStopDeps): Promise<boolean | undefined> {
+	const resolved = resolveRoleSelection(["smol"], deps.settings, deps.registry.getAvailable(), deps.registry);
+	const model = resolved?.model;
+	if (!model) {
+		throw new Error("unexpected-stop: no smol model available for classification");
+	}
+	const apiKey = await deps.registry.getApiKey(model, deps.sessionId);
+	if (!apiKey) {
+		throw new Error(`unexpected-stop: no API key for ${model.provider}/${model.id}`);
+	}
+	const metadata = deps.metadataResolver?.(model.provider);
+	const maxTokens = model.reasoning ? Math.max(ANSWER_MAX_TOKENS, REASONING_SAFE_MAX_TOKENS) : ANSWER_MAX_TOKENS;
+
+	const response = await completeSimple(
+		model,
+		{
+			systemPrompt: [CLASSIFIER_SYSTEM_PROMPT],
+			messages: [{ role: "user", content: text, timestamp: Date.now() }],
+		},
+		{
+			apiKey: deps.registry.resolver(model, deps.sessionId),
+			maxTokens,
+			disableReasoning: true,
+			metadata,
+			signal: deps.signal,
+		},
+	);
+
+	if (response.stopReason === "error") {
+		throw new Error(`unexpected-stop: online classification failed: ${response.errorMessage ?? "unknown error"}`);
+	}
+
+	const outputText = response.content
+		.filter((part): part is { type: "text"; text: string } => part.type === "text")
+		.map(part => part.text)
+		.join("\n");
+	return parseUnexpectedStopClassification(outputText);
+}
+
+async function classifyLocal(
+	text: string,
+	modelKey: string,
+	deps: ClassifyUnexpectedStopDeps,
+): Promise<boolean | undefined> {
+	if (!isTinyMemoryLocalModelKey(modelKey)) {
+		throw new Error(`unexpected-stop: unsupported local classifier model: ${modelKey}`);
+	}
+	const builtPrompt = prompt.render(unexpectedStopClassifierPrompt, { message: text });
+	const output = await tinyModelClient.complete(modelKey, builtPrompt, {
+		maxTokens: ANSWER_MAX_TOKENS,
+		signal: deps.signal,
+	});
+	if (!output) {
+		return undefined;
+	}
+	return parseUnexpectedStopClassification(output);
+}
+
+export function parseUnexpectedStopClassification(text: string): boolean | undefined {
+	const trimmed = text.trim().toLowerCase();
+	if (trimmed.startsWith("yes")) return true;
+	if (trimmed.startsWith("no")) return false;
+	return undefined;
+}

package/src/session/yield-queue.ts

@@ -6,6 +6,8 @@ export interface YieldDispatcher<P> {
 	isStale?(entry: P): boolean;
 	/** Produce one batched AgentMessage from non-stale entries. Return null to skip. */
 	build(survivors: P[]): AgentMessage | null;
+	/** If true, entries for this kind are drained only by {@link drainLazy} and never trigger the idle flush. */
+	skipIdleFlush?: boolean;
 }
 
 export interface YieldQueueOptions {
@@ -20,6 +22,7 @@ type YieldFlushMode = "streaming" | "idle";
 interface StoredDispatcher {
 	isStale?: (entry: unknown) => boolean;
 	build: (survivors: unknown[]) => AgentMessage | null;
+	skipIdleFlush?: boolean;
 }
 
 function formatError(error: unknown): string {
@@ -40,6 +43,7 @@ export class YieldQueue {
 		const stored: StoredDispatcher = {
 			...(dispatcher.isStale ? { isStale: entry => dispatcher.isStale?.(entry as P) ?? false } : {}),
 			build: survivors => dispatcher.build(survivors as P[]),
+			...(dispatcher.skipIdleFlush ? { skipIdleFlush: true } : {}),
 		};
 		this.#dispatchers.set(kind, stored);
 		return () => {
@@ -60,7 +64,7 @@ export class YieldQueue {
 			this.#entries.set(kind, entries);
 		}
 		entries.push(entry);
-		if (!this.#options.isStreaming()) {
+		if (!this.#options.isStreaming() && !this.#dispatchers.get(kind)!.skipIdleFlush) {
 			this.#scheduleIdleFlush();
 		}
 	}

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

@@ -419,6 +419,100 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "advisor",
+		description: "Toggle the advisor (a second model that reviews each turn and injects notes)",
+		acpDescription: "Toggle advisor",
+		acpInputHint: "[on|off|status|dump [raw]]",
+		subcommands: [
+			{ name: "on", description: "Enable the advisor" },
+			{ name: "off", description: "Disable the advisor" },
+			{ name: "status", description: "Show advisor status" },
+			{ name: "dump", description: "Copy the advisor's transcript to clipboard", usage: "[raw]" },
+		],
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const { verb, rest } = parseSubcommand(command.args);
+			if (!verb || verb === "toggle") {
+				const active = runtime.session.toggleAdvisorEnabled();
+				const configured = runtime.session.settings.get("advisor.enabled") as boolean;
+				if (active) {
+					await runtime.output("Advisor enabled.");
+				} else if (configured) {
+					await runtime.output("Advisor setting enabled, but no model is assigned to the 'advisor' role.");
+				} else {
+					await runtime.output("Advisor disabled.");
+				}
+				return commandConsumed();
+			}
+			if (verb === "on") {
+				const active = runtime.session.setAdvisorEnabled(true);
+				await runtime.output(
+					active ? "Advisor enabled." : "Advisor setting enabled, but no model is assigned to the 'advisor' role.",
+				);
+				return commandConsumed();
+			}
+			if (verb === "off") {
+				runtime.session.setAdvisorEnabled(false);
+				await runtime.output("Advisor disabled.");
+				return commandConsumed();
+			}
+			if (verb === "status") {
+				await runtime.output(runtime.session.formatAdvisorStatus());
+				return commandConsumed();
+			}
+			if (verb === "dump") {
+				const isRaw = rest.toLowerCase() === "raw";
+				const text = runtime.session.formatAdvisorHistoryAsText({ compact: !isRaw });
+				await runtime.output(text ?? "Advisor is not active for this session.");
+				return commandConsumed();
+			}
+			return usage("Usage: /advisor [on|off|status|dump [raw]]", runtime);
+		},
+		handleTui: async (command, runtime) => {
+			const { verb, rest } = parseSubcommand(command.args);
+			if (!verb || verb === "toggle") {
+				const active = runtime.ctx.session.toggleAdvisorEnabled();
+				const configured = runtime.ctx.session.settings.get("advisor.enabled") as boolean;
+				if (active) {
+					runtime.ctx.showStatus("Advisor enabled.");
+				} else if (configured) {
+					runtime.ctx.showStatus("Advisor setting enabled, but no model is assigned to the 'advisor' role.");
+				} else {
+					runtime.ctx.showStatus("Advisor disabled.");
+				}
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			if (verb === "on") {
+				const active = runtime.ctx.session.setAdvisorEnabled(true);
+				runtime.ctx.showStatus(
+					active ? "Advisor enabled." : "Advisor setting enabled, but no model is assigned to the 'advisor' role.",
+				);
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			if (verb === "off") {
+				runtime.ctx.session.setAdvisorEnabled(false);
+				runtime.ctx.showStatus("Advisor disabled.");
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			if (verb === "status") {
+				await runtime.ctx.handleAdvisorStatusCommand();
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			if (verb === "dump") {
+				const isRaw = rest.toLowerCase() === "raw";
+				runtime.ctx.handleAdvisorDumpCommand(isRaw);
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			runtime.ctx.showStatus("Usage: /advisor [on|off|status|dump [raw]]");
+			runtime.ctx.editor.setText("");
+		},
+	},
 	{
 		name: "export",
 		description: "Export session to HTML file",
@@ -450,13 +544,17 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 		name: "dump",
 		description: "Copy session transcript to clipboard",
 		acpDescription: "Return full transcript as plain text",
-		handle: async (_command, runtime) => {
-			const text = runtime.session.formatSessionAsText();
+		inlineHint: "[raw]",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const isRaw = command.args.trim().toLowerCase() === "raw";
+			const text = runtime.session.formatSessionAsText({ compact: !isRaw });
 			await runtime.output(text || "No messages to dump yet.");
 			return commandConsumed();
 		},
-		handleTui: async (_command, runtime) => {
-			await runtime.ctx.handleDumpCommand();
+		handleTui: (command, runtime) => {
+			const isRaw = command.args.trim().toLowerCase() === "raw";
+			runtime.ctx.handleDumpCommand(isRaw);
 			runtime.ctx.editor.setText("");
 		},
 	},

package/src/stt/asr-client.ts

@@ -72,7 +72,7 @@ const SMOKE_TEST_TIMEOUT_MS = 30_000;
  * Hidden subcommand on the main CLI that boots the speech-recognition worker in
  * the spawned subprocess. Kept in sync with the dispatch in `cli.ts`.
  */
-export const STT_WORKER_ARG = "__omp_stt_worker";
+export const STT_WORKER_ARG = "__omp_worker_stt";
 
 function readTinyModelSetting(key: "providers.tinyModelDevice" | "providers.tinyModelDtype"): string | undefined {
 	try {

package/src/system-prompt.ts

@@ -5,7 +5,7 @@
 import * as os from "node:os";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { ToolExample, TSchema } from "@oh-my-pi/pi-ai";
-import { renderToolInventory } from "@oh-my-pi/pi-ai/grammar";
+import { renderToolInventory } from "@oh-my-pi/pi-ai/dialect";
 import { $env, getGpuCachePath, getProjectDir, hasFsCode, isEnoent, logger, prompt } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 import { contextFileCapability } from "./capability/context-file";

package/src/tiny/title-client.ts

@@ -69,7 +69,7 @@ function normalizeTinyTitleGenerateOptions(
  * Hidden subcommand on the main CLI that boots the tiny-model worker in the
  * spawned subprocess. Kept in sync with the dispatch in `cli.ts`.
  */
-export const TINY_WORKER_ARG = "--tiny-worker";
+export const TINY_WORKER_ARG = "__omp_worker_tiny_inference";
 
 function readTinyModelSetting(path: "providers.tinyModelDevice" | "providers.tinyModelDtype"): string | undefined {
 	try {

package/src/tools/browser/tab-supervisor.ts

@@ -685,7 +685,7 @@ async function spawnTabWorker(): Promise<WorkerHandle> {
 	try {
 		const hostEntry = workerHostEntry();
 		const worker = hostEntry
-			? new Worker(hostEntry, { type: "module", argv: ["__omp_tab_worker"] })
+			? new Worker(hostEntry, { type: "module", argv: ["__omp_worker_tab"] })
 			: new Worker(new URL("./tab-worker-entry.ts", import.meta.url).href, { type: "module" });
 		return wrapBunWorker(worker);
 	} catch (err) {

package/src/tools/browser/tab-worker-entry.ts

@@ -1,20 +1,28 @@
 import { parentPort } from "node:worker_threads";
+import { consumeWorkerInbox } from "@oh-my-pi/pi-utils/worker-host";
 import type { Transport, WorkerInbound, WorkerOutbound } from "./tab-protocol";
 import { WorkerCore } from "./tab-worker";
 
 if (!parentPort) throw new Error("tab-worker-entry: missing parentPort");
 
+const port = parentPort;
+// When the CLI host pre-buffered messages (it imports this module dynamically),
+// bind that inbox so the parent's already-delivered `init` is replayed. Loaded
+// directly (test/SDK fallback), this module's top-level runs synchronously at
+// worker start, so the direct `parentPort.on` below wins the flush on its own.
+const inbox = consumeWorkerInbox();
 const transport: Transport = {
 	send(msg, transferList) {
-		parentPort!.postMessage(msg, transferList ?? []);
+		port.postMessage(msg, transferList ?? []);
 	},
 	onMessage(handler) {
+		if (inbox) return inbox.bind(data => handler(data as WorkerOutbound | WorkerInbound));
 		const wrap = (message: unknown): void => handler(message as WorkerOutbound | WorkerInbound);
-		parentPort!.on("message", wrap);
-		return () => parentPort!.off("message", wrap);
+		port.on("message", wrap);
+		return () => port.off("message", wrap);
 	},
 	close() {
-		parentPort!.close();
+		port.close();
 	},
 };
 

package/src/tools/job.ts

@@ -87,6 +87,7 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 	readonly description: string;
 	readonly parameters = jobSchema;
 	readonly strict = true;
+	readonly interruptible = true;
 	readonly loadMode = "discoverable";
 	constructor(private readonly session: ToolSession) {
 		this.description = prompt.render(jobDescription);