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

package/src/session/agent-session.ts

@@ -202,6 +202,7 @@ import planModeToolDecisionReminderPrompt from "../prompts/system/plan-mode-tool
 };
 import ttsrInterruptTemplate from "../prompts/system/ttsr-interrupt.md" with { type: "text" };
 import ttsrToolReminderTemplate from "../prompts/system/ttsr-tool-reminder.md" with { type: "text" };
+import unexpectedStopRetryTemplate from "../prompts/system/unexpected-stop-retry.md" with { type: "text" };
 import {
 	deobfuscateSessionContext,
 	obfuscateProviderContext,
@@ -270,6 +271,7 @@ import { EPHEMERAL_MODEL_CHANGE_ROLE } from "./session-entries";
 import type { SessionManager } from "./session-manager";
 import type { ShakeMode, ShakeResult } from "./shake-types";
 import { ToolChoiceQueue } from "./tool-choice-queue";
+import { classifyUnexpectedStop, isUnexpectedStopCandidate } from "./unexpected-stop-classifier";
 import { YieldQueue } from "./yield-queue";
 
 /** Session-specific events that extend the core AgentEvent */
@@ -308,14 +310,16 @@ export type AgentSessionEvent =
 			resolved?: Effort;
 	  }
 	| { type: "goal_updated"; goal: Goal | null; state?: GoalModeState };
-
 /** Listener function for agent session events */
 export type AgentSessionEventListener = (event: AgentSessionEvent) => void;
-export type CommandMetadataChangedListener = () => void | Promise<void>;
-export type AsyncJobSnapshotItem = Pick<AsyncJob, "id" | "type" | "status" | "label" | "startTime">;
 
+const UNEXPECTED_STOP_MAX_RETRIES = 3;
+const UNEXPECTED_STOP_TIMEOUT_MS = 4000;
 const EMPTY_STOP_MAX_RETRIES = 3;
 const RETRY_BACKOFF_MAX_DELAY_MS = 8_000;
+export type CommandMetadataChangedListener = () => void | Promise<void>;
+export type AsyncJobSnapshotItem = Pick<AsyncJob, "id" | "type" | "status" | "label" | "startTime">;
+
 const RETRY_BACKOFF_JITTER_RATIO = 0.25;
 /**
  * Hysteresis band for the post-shake "did we actually create headroom?" check.
@@ -1106,15 +1110,23 @@ export class AgentSession {
 	// `#emit(event)` that reaches external subscribers (rpc-mode stdout, ACP bridge,
 	// Cursor exec, TUI listeners) is held back. Without this, a client that resumes
 	// on `agent_end` can fire its next `prompt` before #promptWithMessage's finally
-	// has decremented #promptInFlightCount, hitting AgentBusyError. Flushed from
-	// both #endInFlight (normal) and #resetInFlight (abort).
+	#emptyStopRetryCount = 0;
+	#unexpectedStopRetryCount = 0;
+	#promptGeneration = 0;
 	#pendingAgentEndEmit: AgentSessionEvent | undefined;
+	#pendingProviderRequestNonMessageTokens: number | undefined = undefined;
+	#lastProviderUsageNonMessage:
+		| {
+				provider: AssistantMessage["provider"];
+				model: AssistantMessage["model"];
+				timestamp: AssistantMessage["timestamp"];
+				tokens: number;
+		  }
+		| undefined;
 	#obfuscator: SecretObfuscator | undefined;
 	#checkpointState: CheckpointState | undefined = undefined;
 	#pendingRewindReport: string | undefined = undefined;
 	#lastSuccessfulYieldToolCallId: string | undefined = undefined;
-	#emptyStopRetryCount = 0;
-	#promptGeneration = 0;
 	#providerSessionState = new Map<string, ProviderSessionState>();
 	#hindsightSessionState: HindsightSessionState | undefined = undefined;
 	readonly rawSseDebugBuffer: RawSseDebugBuffer;
@@ -1619,8 +1631,34 @@ export class AgentSession {
 	// Track last assistant message for auto-compaction check
 	#lastAssistantMessage: AssistantMessage | undefined = undefined;
 
-	/** Internal handler for agent events - shared by subscribe and reconnect */
+	/** Internal handler for agent events - shared by subscribe and reconnect.
+	 *
+	 * `agent_end` handling schedules deferred post-prompt recovery work
+	 * (compaction/handoff, context-promotion continuations). It is invoked
+	 * fire-and-forget by the agent's synchronous `#emit`, and only reaches
+	 * `#checkCompaction` after several internal awaits. `prompt()` runs
+	 * `#waitForPostPromptRecovery()` the instant `agent.prompt()` resolves — which
+	 * can land BEFORE the handler registers its tasks, so the wait would observe an
+	 * empty task set and return early, letting a deferred handoff/promotion race
+	 * prompt completion. Tracking the `agent_end` handler as a post-prompt task
+	 * that is registered SYNCHRONOUSLY (before the first await) closes that window:
+	 * `#postPromptTasksPromise` is set the moment `#emit` invokes this handler, so
+	 * the recovery wait always sees the in-flight handler and blocks until it — and
+	 * everything it schedules — settles. */
 	#handleAgentEvent = async (event: AgentEvent): Promise<void> => {
+		if (event.type !== "agent_end") {
+			return this.#processAgentEvent(event);
+		}
+		const { promise, resolve } = Promise.withResolvers<void>();
+		this.#trackPostPromptTask(promise);
+		try {
+			await this.#processAgentEvent(event);
+		} finally {
+			resolve();
+		}
+	};
+
+	#processAgentEvent = async (event: AgentEvent): Promise<void> => {
 		// Plan-mode → compaction transition: stamp `SILENT_ABORT_MARKER` on the
 		// persisted message BEFORE the obfuscator's display-side copy below.
 		// Invariant (must hold across refactors): this branch precedes the
@@ -1787,6 +1825,14 @@ export class AgentSession {
 			if (event.message.role === "assistant") {
 				this.#lastAssistantMessage = event.message;
 				const assistantMsg = event.message as AssistantMessage;
+				if (assistantMsg.stopReason !== "aborted" && assistantMsg.stopReason !== "error" && assistantMsg.usage) {
+					this.#lastProviderUsageNonMessage = {
+						provider: assistantMsg.provider,
+						model: assistantMsg.model,
+						timestamp: assistantMsg.timestamp,
+						tokens: this.#pendingProviderRequestNonMessageTokens ?? computeNonMessageTokens(this),
+					};
+				}
 				const currentGrantsAnthropicPriority =
 					this.serviceTier === "priority" || this.serviceTier === "claude-only";
 				if (assistantMsg.disabledFeatures?.includes("priority") && currentGrantsAnthropicPriority) {
@@ -1933,6 +1979,9 @@ export class AgentSession {
 			if (await this.#handleEmptyAssistantStop(msg)) {
 				return;
 			}
+			if (await this.#handleUnexpectedAssistantStop(msg)) {
+				return;
+			}
 
 			// A deliberate abort should settle the current turn, not trigger queued continuations.
 			if (msg.stopReason === "aborted") {
@@ -4765,6 +4814,7 @@ export class AgentSession {
 			this.#todoReminderCount = 0;
 			this.#todoReminderAwaitingProgress = false;
 			this.#emptyStopRetryCount = 0;
+			this.#unexpectedStopRetryCount = 0;
 
 			await this.#maybeRestoreRetryFallbackPrimary();
 
@@ -4905,7 +4955,12 @@ export class AgentSession {
 			}
 
 			const agentPromptOptions = options?.toolChoice ? { toolChoice: options.toolChoice } : undefined;
-			await this.#promptAgentWithIdleRetry(messages, agentPromptOptions);
+			this.#pendingProviderRequestNonMessageTokens = computeNonMessageTokens(this);
+			try {
+				await this.#promptAgentWithIdleRetry(messages, agentPromptOptions);
+			} finally {
+				this.#pendingProviderRequestNonMessageTokens = undefined;
+			}
 			if (!options?.skipPostPromptRecoveryWait) {
 				await this.#waitForPostPromptRecovery(generation);
 			}
@@ -6771,13 +6826,34 @@ export class AgentSession {
 		return tokens;
 	}
 
+	#estimatePrePromptContextTokens(messages: AgentMessage[], contextWindow: number): number {
+		const currentUsage = this.getContextUsage({ contextWindow });
+		if (typeof currentUsage?.tokens !== "number" || !Number.isFinite(currentUsage.tokens)) {
+			return this.#estimatePendingPromptTokens(messages);
+		}
+
+		const currentEstimate = this.#estimateContextTokens();
+		if (!currentEstimate.providerAnchored) {
+			return this.#estimatePendingPromptTokens(messages);
+		}
+
+		let tokens = currentUsage.tokens;
+		if (currentEstimate.providerNonMessageTokens !== undefined) {
+			tokens += Math.max(0, computeNonMessageTokens(this) - currentEstimate.providerNonMessageTokens);
+		}
+		for (const message of messages) {
+			tokens += estimateTokens(message);
+		}
+		return tokens;
+	}
+
 	async #runPrePromptCompactionIfNeeded(messages: AgentMessage[]): Promise<void> {
 		const model = this.model;
 		if (!model) return;
 		const contextWindow = model.contextWindow ?? 0;
 		if (contextWindow <= 0) return;
 		const compactionSettings = this.settings.getGroup("compaction");
-		const contextTokens = this.#estimatePendingPromptTokens(messages);
+		const contextTokens = this.#estimatePrePromptContextTokens(messages, contextWindow);
 		if (!shouldCompact(contextTokens, contextWindow, compactionSettings)) return;
 
 		// Auto-promote first: switching to a larger-context model avoids compacting
@@ -7027,6 +7103,71 @@ export class AgentSession {
 			maxRetries: EMPTY_STOP_MAX_RETRIES,
 		});
 	}
+	async #handleUnexpectedAssistantStop(assistantMessage: AssistantMessage): Promise<boolean> {
+		if (!this.settings.get("features.unexpectedStopDetection")) {
+			return false;
+		}
+		if (!isUnexpectedStopCandidate(assistantMessage)) {
+			this.#unexpectedStopRetryCount = 0;
+			return false;
+		}
+
+		const text = assistantMessage.content
+			.filter((content): content is TextContent => content.type === "text")
+			.map(content => content.text)
+			.join("\n");
+		if (!/\S/.test(text)) {
+			this.#unexpectedStopRetryCount = 0;
+			return false;
+		}
+
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), UNEXPECTED_STOP_TIMEOUT_MS);
+		let classification: boolean | undefined;
+		try {
+			classification = await classifyUnexpectedStop(text, {
+				settings: this.settings,
+				registry: this.#modelRegistry,
+				sessionId: this.sessionId,
+				metadataResolver: (provider: string) => this.agent.metadataForProvider(provider),
+				signal: controller.signal,
+			});
+		} finally {
+			clearTimeout(timeout);
+		}
+
+		if (classification !== true) {
+			this.#unexpectedStopRetryCount = 0;
+			return false;
+		}
+
+		this.#unexpectedStopRetryCount++;
+		if (this.#unexpectedStopRetryCount > UNEXPECTED_STOP_MAX_RETRIES) {
+			logger.warn("Assistant returned unexpected stop after retry cap", {
+				attempts: this.#unexpectedStopRetryCount - 1,
+				model: assistantMessage.model,
+				provider: assistantMessage.provider,
+			});
+			this.#unexpectedStopRetryCount = 0;
+			return false;
+		}
+
+		this.agent.appendMessage({
+			role: "developer",
+			content: [{ type: "text", text: this.#unexpectedStopRetryReminder() }],
+			attribution: "agent",
+			timestamp: Date.now(),
+		});
+		this.#scheduleAgentContinue({ generation: this.#promptGeneration });
+		return true;
+	}
+
+	#unexpectedStopRetryReminder(): string {
+		return prompt.render(unexpectedStopRetryTemplate, {
+			retryCount: this.#unexpectedStopRetryCount,
+			maxRetries: UNEXPECTED_STOP_MAX_RETRIES,
+		});
+	}
 
 	#removeEmptyStopFromActiveContext(assistantMessage: AssistantMessage): void {
 		const messages = this.agent.state.messages;
@@ -10528,6 +10669,8 @@ export class AgentSession {
 	 */
 	#estimateContextTokens(): {
 		tokens: number;
+		providerAnchored: boolean;
+		providerNonMessageTokens?: number;
 	} {
 		const messages = this.messages;
 
@@ -10554,10 +10697,19 @@ export class AgentSession {
 			}
 			return {
 				tokens: estimated,
+				providerAnchored: false,
 			};
 		}
 
 		const usageTokens = calculatePromptTokens(lastUsage);
+		const providerNonMessage =
+			this.#lastProviderUsageNonMessage &&
+			messages[lastUsageIndex]?.role === "assistant" &&
+			this.#lastProviderUsageNonMessage.provider === (messages[lastUsageIndex] as AssistantMessage).provider &&
+			this.#lastProviderUsageNonMessage.model === (messages[lastUsageIndex] as AssistantMessage).model &&
+			this.#lastProviderUsageNonMessage.timestamp === (messages[lastUsageIndex] as AssistantMessage).timestamp
+				? this.#lastProviderUsageNonMessage.tokens
+				: undefined;
 		let trailingTokens = 0;
 		for (let i = lastUsageIndex + 1; i < messages.length; i++) {
 			trailingTokens += estimateTokens(messages[i]);
@@ -10565,6 +10717,8 @@ export class AgentSession {
 
 		return {
 			tokens: usageTokens + trailingTokens,
+			providerAnchored: true,
+			providerNonMessageTokens: providerNonMessage,
 		};
 	}
 

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

@@ -4,8 +4,9 @@
 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 { getInbandGrammar, renderToolInventory } from "@oh-my-pi/pi-ai/grammar";
+import { preferredToolSyntax } from "@oh-my-pi/pi-catalog/identity";
+import { canonicalizeMessage } from "../utils/thinking-display";
 import {
 	type BashExecutionMessage,
 	type BranchSummaryMessage,
@@ -34,22 +35,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 grammar = getInbandGrammar(preferredToolSyntax(options.model?.id ?? ""));
 
 	const systemPrompt = options.systemPrompt?.filter(prompt => prompt.length > 0) ?? [];
 	if (systemPrompt.length > 0) {
@@ -106,17 +97,15 @@ export function formatSessionDumpText(options: FormatSessionDumpTextOptions): st
 				if (c.type === "text") {
 					lines.push(c.text);
 				} else if (c.type === "thinking") {
-					const thinking = getVisibleThinkingText(c);
+					const thinking = canonicalizeMessage(c.thinking);
 					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");
+					const args = { ...(c.arguments as Record<string, unknown>) };
+					delete args[INTENT_FIELD];
+					lines.push(grammar.renderToolCall({ ...c, arguments: args }));
 				}
 			}
 			lines.push("");

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/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/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);

package/src/tts/tts-client.ts

@@ -142,7 +142,7 @@ const SMOKE_TEST_TIMEOUT_MS = 30_000;
  * Hidden subcommand on the main CLI that boots the TTS worker in the spawned
  * subprocess. Kept in sync with the dispatch in `cli.ts` (Main-owned).
  */
-export const TTS_WORKER_ARG = "__omp_tts_worker";
+export const TTS_WORKER_ARG = "__omp_worker_tts";
 
 function readTinyModelSetting(path: "providers.tinyModelDevice" | "providers.tinyModelDtype"): string | undefined {
 	try {

package/src/utils/thinking-display.ts

@@ -1,37 +1,11 @@
-import type { AssistantMessage } from "@oh-my-pi/pi-ai";
-
-type AssistantContentBlock = AssistantMessage["content"][number];
-type ThinkingBlock = Extract<AssistantContentBlock, { type: "thinking" }>;
-
-function isDotOnlyThinking(text: string): boolean {
-	let sawDot = false;
-	for (let i = 0; i < text.length; i++) {
-		const code = text.charCodeAt(i);
-		if (code === 0x2e || code === 0x2026) {
-			sawDot = true;
-			continue;
+export function canonicalizeMessage(text: string | null | undefined): string {
+	if (!text) return "";
+	const trimmed = text.trim();
+	for (let i = 0; i < trimmed.length; i++) {
+		const code = trimmed.charCodeAt(i);
+		if (code !== 0x2e && code !== 0x2026 && code !== 0x20 && code !== 0x09 && code !== 0x0a && code !== 0x0d) {
+			return trimmed;
 		}
-		if (code === 0x20 || code === 0x09 || code === 0x0a || code === 0x0d) continue;
-		return false;
 	}
-	return sawDot;
-}
-
-/**
- * Returns the operator-visible thinking text for a block.
- *
- * Some OpenAI-compatible reasoning gateways require a non-empty
- * `reasoning_content` field on historical assistant tool-call turns even when
- * the model did not emit any reasoning. The provider adapter uses a single dot
- * as the wire-only placeholder those gateways accept; if that value is later
- * replayed or echoed as a thinking block, it should not render as model thought.
- */
-export function getVisibleThinkingText(block: ThinkingBlock): string {
-	const text = block.thinking.trim();
-	if (text.length === 0) return "";
-	return isDotOnlyThinking(text) ? "" : text;
-}
-
-export function hasVisibleThinking(block: ThinkingBlock): boolean {
-	return getVisibleThinkingText(block).length > 0;
+	return "";
 }