@oh-my-pi/pi-coding-agent 16.2.8 → 16.2.11

package/src/session/agent-session.ts

@@ -250,6 +250,7 @@ import planModeToolDecisionReminderPrompt from "../prompts/system/plan-mode-tool
 	type: "text",
 };
 import sideChannelNoToolsReminder from "../prompts/system/side-channel-no-tools.md" with { type: "text" };
+import thinkingLoopRedirectTemplate from "../prompts/system/thinking-loop-redirect.md" with { type: "text" };
 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" };
@@ -346,6 +347,9 @@ const SESSION_STOP_CONTINUATION_CAP = 8;
 const GEMINI_HEADER_INTERRUPT_REASON = "Interrupted: emit a tool call instead of more planning";
 /** `customType` for the hidden tool-call reminder injected after the interrupt. */
 const GEMINI_TOOL_REMINDER_TYPE = "gemini-tool-call-reminder";
+/** `customType` for the hidden redirect notice injected into a turn retried after a
+ *  thinking/response loop. Steers the model off the repeated content; never displayed. */
+const THINKING_LOOP_REDIRECT_TYPE = "thinking-loop-redirect";
 
 // A side-channel assistant response is signed for the hidden prompt/history that
 // produced it. If we persist that response under a different user turn, native
@@ -2882,10 +2886,10 @@ export class AgentSession {
 	 * the mid-run-compaction planner can ask "is this turn message already on
 	 * the branch?" in O(1) instead of re-walking the branch per check.
 	 *
-	 * The Map's value is the list of branch messages that share a key — almost
-	 * always one. We only need the LIST when content equality matters (rare
-	 * collision tiebreaker via {@link sameMessageContent}); the empty/single-
-	 * entry common case lets the caller's lookup short-circuit at presence.
+	 * The mid-run ordering check uses key identity alone: same-key content
+	 * variants are one logical message at this boundary, because otherwise a
+	 * display-side rewrite can make the assistant look missing after its tool
+	 * results have already persisted.
 	 *
 	 * Pre-#3629 the equivalent was `sessionManager.getBranch()` called twice
 	 * per turn message, each call rebuilding the path via O(n²) `unshift` and
@@ -2893,17 +2897,14 @@ export class AgentSession {
 	 * per `onTurnEnd` on a long session and the load-bearing source of the
 	 * `ui.loop-blocked` warnings in the bug report.
 	 */
-	#indexPersistedMessagesByKey(): Map<string, AgentMessage[]> {
-		const index = new Map<string, AgentMessage[]>();
+	#indexPersistedMessageKeys(): Set<string> {
+		const keys = new Set<string>();
 		for (const entry of this.sessionManager.getBranch()) {
 			if (entry.type !== "message") continue;
 			const key = sessionMessagePersistenceKey(entry.message);
-			if (key === undefined) continue;
-			const existing = index.get(key);
-			if (existing) existing.push(entry.message);
-			else index.set(key, [entry.message]);
+			if (key !== undefined) keys.add(key);
 		}
-		return index;
+		return keys;
 	}
 
 	/**
@@ -3003,17 +3004,17 @@ export class AgentSession {
 		// JSON-compared every entry per turn message, which on long sessions
 		// turned each `onTurnEnd` into a seconds-long sync block (the
 		// `ui.loop-blocked` warnings tagged `subagent:*` in the bug report).
-		const branchIndex = this.#indexPersistedMessagesByKey();
+		const branchKeys = this.#indexPersistedMessageKeys();
 		const turnKeys = turnMessages.map(sessionMessagePersistenceKey);
 		const persistedKeys = new Set<string>();
 		for (let index = 0; index < turnMessages.length; index++) {
 			const key = turnKeys[index];
 			if (key === undefined) continue;
-			const candidates = branchIndex.get(key);
-			if (!candidates) continue;
-			// Key match only counts when content also matches — two distinct
-			// messages that collided on the cheap key must STILL be persisted.
-			if (candidates.some(persisted => sameMessageContent(persisted, turnMessages[index]))) {
+			// Mid-run ordering is keyed by logical identity. A persisted display
+			// variant (for example, redacted/deobfuscated content) must still count;
+			// otherwise the assistant can look missing while later tool results are
+			// present, producing a false out-of-order skip.
+			if (branchKeys.has(key)) {
 				persistedKeys.add(key);
 			}
 		}
@@ -8087,7 +8088,7 @@ export class AgentSession {
 	 */
 	async setModelTemporary(
 		model: Model,
-		thinkingLevel?: ThinkingLevel,
+		thinkingLevel?: ConfiguredThinkingLevel,
 		options?: { ephemeral?: boolean },
 	): Promise<void> {
 		const previousEditMode = this.#resolveActiveEditMode();
@@ -12582,6 +12583,11 @@ export class AgentSession {
 		// Remove the failed assistant message from active context before retrying.
 		this.#removeAssistantMessageFromActiveContext(message);
 
+		// A thinking/response loop retried into identical context loops again. Inject a
+		// hidden redirect so the retried turn sees a directive to break the repeated
+		// pattern instead of re-sampling the same stalled reasoning.
+		this.#maybeInjectThinkingLoopRedirect(id);
+
 		// Wait with exponential backoff (abortable).
 		const retryAbortController = new AbortController();
 		this.#retryAbortController?.abort();
@@ -12615,6 +12621,35 @@ export class AgentSession {
 		return true;
 	}
 
+	/**
+	 * Inject a hidden redirect notice when a thinking/response loop is being retried, so
+	 * the retried turn carries an instruction to break the repeated pattern instead of
+	 * re-sampling the same stalled context. Injected on every {@link AIError.Flag.ThinkingLoop}
+	 * retry (the failed assistant is dropped each attempt, so the notice does not accumulate
+	 * unboundedly). No-op unless `id` carries the ThinkingLoop flag and the loop guard is
+	 * enabled. The notice is generic on purpose — the detector's detail can quote raw model
+	 * text, which must not be interpolated into a higher-priority developer message.
+	 */
+	#maybeInjectThinkingLoopRedirect(id: number): void {
+		if (!AIError.is(id, AIError.Flag.ThinkingLoop)) return;
+		if (this.settings.get("model.loopGuard.enabled") !== true) return;
+		this.agent.appendMessage({
+			role: "custom",
+			customType: THINKING_LOOP_REDIRECT_TYPE,
+			content: thinkingLoopRedirectTemplate,
+			display: false,
+			attribution: "agent",
+			timestamp: Date.now(),
+		});
+		this.sessionManager.appendCustomMessageEntry(
+			THINKING_LOOP_REDIRECT_TYPE,
+			thinkingLoopRedirectTemplate,
+			false,
+			undefined,
+			"agent",
+		);
+	}
+
 	/**
 	 * Cancel in-progress retry.
 	 */

package/src/stt/asr-client.ts

@@ -4,12 +4,12 @@ import {
 	createWorkerHandle,
 	createWorkerSubprocess,
 	logWorkerMessage,
+	type RefCountedWorkerHandle,
 	resolveWorkerSpawnCmd,
 	SMOKE_TEST_TIMEOUT_MS,
 	type SpawnedSubprocess,
 	smokeTestWorker,
 	spawnWorkerOrUnavailable,
-	type WorkerHandle,
 } from "../subprocess/worker-client";
 import { tinyWorkerEnv } from "../tiny/title-client";
 import { safeSend } from "../utils/ipc";
@@ -18,7 +18,7 @@ import type { SttModelKey } from "./models";
 
 type PendingRequest =
 	| { kind: "transcribe"; modelKey: SttModelKey; resolve: (text: string) => void; reject: (error: Error) => void }
-	| { kind: "download"; modelKey: SttModelKey; resolve: (ok: boolean) => void };
+	| { kind: "download"; modelKey: SttModelKey; resolve: (result: SttDownloadResult) => void };
 
 export interface SttTranscribeOptions {
 	language?: string;
@@ -30,6 +30,11 @@ export interface SttDownloadOptions {
 	onProgress?: (event: SttProgressEvent) => void;
 }
 
+export interface SttDownloadResult {
+	ok: boolean;
+	error?: string;
+}
+
 /** Live streaming session handle returned by {@link SttClient.startStream}. */
 export interface SttStreamHandle {
 	/** Feed 16 kHz mono float samples as the recorder produces them. */
@@ -79,30 +84,55 @@ export function createSttSubprocess(): SpawnedSubprocess<SttWorkerOutbound> {
 
 function wrapSubprocess(
 	spawned: SpawnedSubprocess<SttWorkerOutbound>,
-): WorkerHandle<SttWorkerInbound, SttWorkerOutbound> {
+): RefCountedWorkerHandle<SttWorkerInbound, SttWorkerOutbound> {
 	const { proc } = spawned;
-	return createWorkerHandle<SttWorkerInbound, SttWorkerOutbound>(spawned, message => safeSend(proc, message, "stt"));
+	return {
+		...createWorkerHandle<SttWorkerInbound, SttWorkerOutbound>(spawned, message => safeSend(proc, message, "stt")),
+		ref() {
+			try {
+				proc.ref();
+			} catch {
+				// Already gone.
+			}
+		},
+		unref() {
+			try {
+				proc.unref();
+			} catch {
+				// Already gone.
+			}
+		},
+	};
+}
+
+function spawnInlineUnavailableWorker(error: unknown): RefCountedWorkerHandle<SttWorkerInbound, SttWorkerOutbound> {
+	return {
+		...createUnavailableWorker<SttWorkerInbound, SttWorkerOutbound>(error),
+		ref() {},
+		unref() {},
+	};
 }
 
-function spawnSttWorker(): WorkerHandle<SttWorkerInbound, SttWorkerOutbound> {
+function spawnSttWorker(): RefCountedWorkerHandle<SttWorkerInbound, SttWorkerOutbound> {
 	return spawnWorkerOrUnavailable(
 		() => wrapSubprocess(createSttSubprocess()),
-		createUnavailableWorker<SttWorkerInbound, SttWorkerOutbound>,
+		spawnInlineUnavailableWorker,
 		"stt worker spawn failed; speech-to-text disabled",
 	);
 }
 
 export class SttClient {
-	#worker: WorkerHandle<SttWorkerInbound, SttWorkerOutbound> | null = null;
+	#worker: RefCountedWorkerHandle<SttWorkerInbound, SttWorkerOutbound> | null = null;
 	#unsubscribeMessage: (() => void) | null = null;
 	#unsubscribeError: (() => void) | null = null;
 	#pending = new Map<string, PendingRequest>();
 	#streams = new Map<string, StreamState>();
 	#progressListeners = new Set<(event: SttProgressEvent) => void>();
 	#nextRequestId = 0;
-	#spawnWorker: () => WorkerHandle<SttWorkerInbound, SttWorkerOutbound>;
+	#refed = false;
+	#spawnWorker: () => RefCountedWorkerHandle<SttWorkerInbound, SttWorkerOutbound>;
 
-	constructor(spawnWorker: () => WorkerHandle<SttWorkerInbound, SttWorkerOutbound> = spawnSttWorker) {
+	constructor(spawnWorker: () => RefCountedWorkerHandle<SttWorkerInbound, SttWorkerOutbound> = spawnSttWorker) {
 		this.#spawnWorker = spawnWorker;
 	}
 
@@ -121,11 +151,11 @@ export class SttClient {
 		const worker = this.#ensureWorker();
 		const id = String(++this.#nextRequestId);
 		const { promise, resolve, reject } = Promise.withResolvers<string>();
-		this.#pending.set(id, { kind: "transcribe", modelKey, resolve, reject });
+		this.#addPending(id, { kind: "transcribe", modelKey, resolve, reject });
 		const abort = (): void => {
 			const pending = this.#pending.get(id);
 			if (pending?.kind !== "transcribe") return;
-			this.#pending.delete(id);
+			this.#deletePending(id);
 			pending.reject(new DOMException("The operation was aborted.", "AbortError"));
 		};
 		options.signal?.addEventListener("abort", abort, { once: true });
@@ -134,7 +164,7 @@ export class SttClient {
 			return await promise;
 		} finally {
 			options.signal?.removeEventListener("abort", abort);
-			this.#pending.delete(id);
+			this.#deletePending(id);
 		}
 	}
 
@@ -163,6 +193,7 @@ export class SttClient {
 			settled = true;
 			this.#streams.delete(id);
 			signal?.removeEventListener("abort", onAbort);
+			this.#syncWorkerRef();
 			apply();
 		};
 		this.#streams.set(id, {
@@ -173,6 +204,7 @@ export class SttClient {
 			reject,
 			finish,
 		});
+		this.#syncWorkerRef();
 		worker.send({ type: "stream_start", id, modelKey, language: options.language });
 		const handle: SttStreamHandle = {
 			pushAudio: audio => {
@@ -193,19 +225,19 @@ export class SttClient {
 		return handle;
 	}
 
-	async downloadModel(modelKey: SttModelKey, options: SttDownloadOptions = {}): Promise<boolean> {
-		if (options.signal?.aborted) return false;
+	async downloadModel(modelKey: SttModelKey, options: SttDownloadOptions = {}): Promise<SttDownloadResult> {
+		if (options.signal?.aborted) return { ok: false };
 		const unsubscribe = options.onProgress ? this.onProgress(options.onProgress) : undefined;
 		try {
 			const worker = this.#ensureWorker();
 			const id = String(++this.#nextRequestId);
-			const { promise, resolve } = Promise.withResolvers<boolean>();
-			this.#pending.set(id, { kind: "download", modelKey, resolve });
+			const { promise, resolve } = Promise.withResolvers<SttDownloadResult>();
+			this.#addPending(id, { kind: "download", modelKey, resolve });
 			const abort = (): void => {
 				const pending = this.#pending.get(id);
 				if (pending?.kind !== "download") return;
-				this.#pending.delete(id);
-				pending.resolve(false);
+				this.#deletePending(id);
+				pending.resolve({ ok: false });
 			};
 			options.signal?.addEventListener("abort", abort, { once: true });
 			try {
@@ -213,14 +245,15 @@ export class SttClient {
 				return await promise;
 			} finally {
 				options.signal?.removeEventListener("abort", abort);
-				this.#pending.delete(id);
+				this.#deletePending(id);
 			}
 		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
 			logger.debug("stt: local model download failed", {
 				modelKey,
-				error: error instanceof Error ? error.message : String(error),
+				error: message,
 			});
-			return false;
+			return { ok: false, error: message };
 		} finally {
 			unsubscribe?.();
 		}
@@ -236,9 +269,10 @@ export class SttClient {
 		for (const pending of this.#pending.values()) {
 			this.#emitProgress({ modelKey: pending.modelKey, status: "error" });
 			if (pending.kind === "transcribe") pending.reject(new Error("stt worker terminated"));
-			else pending.resolve(false);
+			else pending.resolve({ ok: false });
 		}
 		this.#pending.clear();
+		this.#refed = false;
 		this.#failStreams(new Error("stt worker terminated"));
 		try {
 			await worker?.terminate();
@@ -247,7 +281,7 @@ export class SttClient {
 		}
 	}
 
-	#ensureWorker(): WorkerHandle<SttWorkerInbound, SttWorkerOutbound> {
+	#ensureWorker(): RefCountedWorkerHandle<SttWorkerInbound, SttWorkerOutbound> {
 		if (this.#worker) return this.#worker;
 		const worker = this.#spawnWorker();
 		this.#worker = worker;
@@ -256,6 +290,32 @@ export class SttClient {
 		return worker;
 	}
 
+	/** Register a pending request and keep the worker referenced while work is in flight. */
+	#addPending(id: string, request: PendingRequest): void {
+		this.#pending.set(id, request);
+		this.#syncWorkerRef();
+	}
+
+	/** Drop a pending request and unref the worker once no request or stream is active. */
+	#deletePending(id: string): void {
+		if (this.#pending.delete(id)) this.#syncWorkerRef();
+	}
+
+	/**
+	 * STT workers start unreferenced so an idle warm model never blocks exit.
+	 * Setup/download commands must keep the worker alive while awaiting IPC, or
+	 * Bun can drain the event loop immediately after `Preparing Speech-to-Text`.
+	 */
+	#syncWorkerRef(): void {
+		const worker = this.#worker;
+		if (!worker) return;
+		const shouldRef = this.#pending.size > 0 || this.#streams.size > 0;
+		if (shouldRef === this.#refed) return;
+		this.#refed = shouldRef;
+		if (shouldRef) worker.ref();
+		else worker.unref();
+	}
+
 	#handleMessage(message: SttWorkerOutbound): void {
 		if (message.type === "log") {
 			logWorkerMessage(message);
@@ -287,19 +347,19 @@ export class SttClient {
 			}
 			return;
 		}
-		this.#pending.delete(message.id);
+		this.#deletePending(message.id);
 		if (message.type === "transcription") {
 			if (pending.kind === "transcribe") pending.resolve(message.text);
 			return;
 		}
 		if (message.type === "downloaded") {
-			if (pending.kind === "download") pending.resolve(true);
+			if (pending.kind === "download") pending.resolve({ ok: true });
 			return;
 		}
 		// message.type === "error"
 		this.#emitProgress({ modelKey: pending.modelKey, status: "error" });
 		if (pending.kind === "transcribe") pending.reject(new Error(message.error));
-		else pending.resolve(false);
+		else pending.resolve({ ok: false, error: message.error });
 	}
 
 	#emitProgress(event: SttProgressEvent): void {
@@ -318,7 +378,7 @@ export class SttClient {
 		for (const pending of this.#pending.values()) {
 			this.#emitProgress({ modelKey: pending.modelKey, status: "error" });
 			if (pending.kind === "transcribe") pending.reject(error);
-			else pending.resolve(false);
+			else pending.resolve({ ok: false, error: error.message });
 		}
 		this.#pending.clear();
 		this.#failStreams(error);

package/src/stt/downloader.ts

@@ -90,7 +90,7 @@ export async function downloadSttModel(
 ): Promise<void> {
 	const spec = resolveSttModelSpec(key);
 	const files = new Map<string, { loaded: number; total: number }>();
-	const ok = await sttClient.downloadModel(spec.key, {
+	const result = await sttClient.downloadModel(spec.key, {
 		signal: options?.signal,
 		onProgress: event => {
 			if ((event.status === "progress" || event.status === "progress_total") && event.file) {
@@ -117,7 +117,13 @@ export async function downloadSttModel(
 			});
 		},
 	});
-	if (!ok) throw new Error(`Failed to download speech model (${spec.repo}). Check your network connection.`);
+	if (!result.ok) {
+		const detail = result.error ? `: ${result.error}` : ". Check your network connection.";
+		throw new Error(`Failed to download speech model (${spec.repo})${detail}`);
+	}
+	if (!(await isSttModelCached(spec.key))) {
+		throw new Error(`Speech model download finished without required files (${spec.repo}).`);
+	}
 }
 
 // ── Public API ─────────────────────────────────────────────────────

package/src/stt/index.ts

@@ -3,5 +3,6 @@ export * from "./asr-protocol";
 export * from "./downloader";
 export * from "./models";
 export * from "./stt-controller";
+export * from "./submit-trigger";
 export * from "./transcriber";
 export * from "./wav";

package/src/stt/stt-controller.ts

@@ -15,6 +15,7 @@ import {
 	startStreamingRecording,
 	verifyRecordingFile,
 } from "./recorder";
+import { evaluateSubmitTrigger } from "./submit-trigger";
 import { transcribe } from "./transcriber";
 
 export type SttState = "idle" | "recording" | "transcribing";
@@ -33,6 +34,8 @@ interface Editor {
 	setVolatileText(text: string): void;
 	clearVolatileText(): void;
 	commitVolatileText(text: string): void;
+	submit(): void;
+	deleteBeforeCursor(count: number): void;
 }
 
 export class STTController {
@@ -53,6 +56,7 @@ export class STTController {
 	#streamEditor: Editor | null = null;
 	#streamCommitted = false;
 	#streamAbort: AbortController | null = null;
+	#streamUtterance = "";
 
 	get state(): SttState {
 		return this.#state;
@@ -190,6 +194,7 @@ export class STTController {
 		const language = settings.get("stt.language") as string | undefined;
 		this.#streamEditor = editor;
 		this.#streamCommitted = false;
+		this.#streamUtterance = "";
 		this.#streamAbort = new AbortController();
 		const stream = sttClient.startStream(modelKey, {
 			language: language || undefined,
@@ -205,6 +210,7 @@ export class STTController {
 				if (prefixed) {
 					this.#streamEditor?.commitVolatileText(prefixed);
 					this.#streamCommitted = true;
+					this.#streamUtterance += prefixed;
 				} else {
 					this.#streamEditor?.clearVolatileText();
 				}
@@ -266,13 +272,27 @@ export class STTController {
 			return;
 		}
 		if (!this.#streamCommitted && finalText) {
-			this.#streamEditor?.commitVolatileText(this.#prefixed(finalText));
+			const prefixed = this.#prefixed(finalText);
+			this.#streamEditor?.commitVolatileText(prefixed);
 			this.#streamCommitted = true;
+			this.#streamUtterance = prefixed;
 		} else {
 			this.#streamEditor?.clearVolatileText();
 		}
 		options.requestRender?.();
 		if (!failed) options.showStatus(this.#streamCommitted ? "" : "No speech detected.");
+
+		if (this.#streamCommitted && !failed && this.#streamEditor) {
+			const trigger = settings.get("stt.submitTrigger");
+			const { submit, trimTrailing } = evaluateSubmitTrigger(this.#streamUtterance, trigger);
+			if (trimTrailing > 0) {
+				this.#streamEditor.deleteBeforeCursor(trimTrailing);
+			}
+			if (submit) {
+				this.#streamEditor.submit();
+			}
+		}
+
 		this.#cleanupStream();
 		this.#setState("idle", options);
 	}
@@ -283,6 +303,7 @@ export class STTController {
 		this.#streamEditor = null;
 		this.#streamCommitted = false;
 		this.#streamAbort = null;
+		this.#streamUtterance = "";
 	}
 
 	// ── Batch (single-shot) ─────────────────────────────────────────
@@ -327,8 +348,16 @@ export class STTController {
 			this.#transcriptionAbort = null;
 			if (this.#disposed) return;
 			if (text.length > 0) {
-				editor.insertText(text);
+				const trigger = settings.get("stt.submitTrigger");
+				const { submit, trimTrailing } = evaluateSubmitTrigger(text, trigger);
+				const textToInsert = trimTrailing > 0 ? text.slice(0, -trimTrailing) : text;
+				if (textToInsert.length > 0) {
+					editor.insertText(textToInsert);
+				}
 				options.showStatus("");
+				if (submit) {
+					editor.submit();
+				}
 			} else {
 				options.showStatus("No speech detected.");
 			}

package/src/stt/submit-trigger.ts

@@ -0,0 +1,74 @@
+/**
+ * TTS/STT Submit Trigger options and evaluation logic.
+ */
+
+export const STT_SUBMIT_TRIGGER_VALUES = ["never", "release", "release-complete", "say-submit"] as const;
+
+export type SttSubmitTrigger = (typeof STT_SUBMIT_TRIGGER_VALUES)[number];
+
+export const STT_SUBMIT_TRIGGER_OPTIONS = [
+	{
+		value: "never",
+		label: "Never",
+		description: "Never automatically submit; insert dictation and remain in editor.",
+	},
+	{
+		value: "release",
+		label: "Release",
+		description: "Submit on release if the utterance has 2+ words to avoid accidental sends.",
+	},
+	{
+		value: "release-complete",
+		label: "Release with complete sentence",
+		description: "Submit on release if the utterance ends with sentence-terminal punctuation (. ? ! etc.).",
+	},
+	{
+		value: "say-submit",
+		label: "When I Say Submit",
+		description: "Submit if the utterance ends with a word containing 'submit' (strips that word before submitting).",
+	},
+] satisfies ReadonlyArray<{ value: SttSubmitTrigger; label: string; description: string }>;
+
+/**
+ * Evaluate the submit trigger against a transcribed utterance.
+ * Returns whether to submit, and the number of characters to trim from the end of the utterance.
+ */
+export function evaluateSubmitTrigger(
+	utterance: string,
+	trigger: SttSubmitTrigger,
+): { submit: boolean; trimTrailing: number } {
+	const trimmed = utterance.trim();
+	if (!trimmed) {
+		return { submit: false, trimTrailing: 0 };
+	}
+
+	if (trigger === "never") {
+		return { submit: false, trimTrailing: 0 };
+	}
+
+	if (trigger === "release") {
+		// Split by whitespace and count words
+		const words = trimmed.split(/\s+/).filter(Boolean);
+		const submit = words.length >= 2;
+		return { submit, trimTrailing: 0 };
+	}
+
+	if (trigger === "release-complete") {
+		// Matches typical sentence terminators: . ? ! ... or full-width equivalents, optionally followed by space
+		const hasTerminalPunctuation = /[.?!…。？！]\s*$/.test(trimmed);
+		return { submit: hasTerminalPunctuation, trimTrailing: 0 };
+	}
+
+	if (trigger === "say-submit") {
+		// Matches space followed by any word containing "submit" (case-insensitive), optionally followed by punctuation/spaces
+		// Also handles the case where "submit" is the only word in the utterance (no leading space)
+		const match = utterance.match(/(?:^|\s+)(\S*submit\S*)[.?!…。？！]*\s*$/i);
+		if (match && match.index !== undefined) {
+			const trimTrailing = utterance.length - match.index;
+			return { submit: true, trimTrailing };
+		}
+		return { submit: false, trimTrailing: 0 };
+	}
+
+	return { submit: false, trimTrailing: 0 };
+}

package/src/task/agents.ts

@@ -11,11 +11,11 @@ import exploreMd from "../prompts/agents/explore.md" with { type: "text" };
 // Embed agent markdown files at build time
 import agentFrontmatterTemplate from "../prompts/agents/frontmatter.md" with { type: "text" };
 import librarianMd from "../prompts/agents/librarian.md" with { type: "text" };
-import oracleMd from "../prompts/agents/oracle.md" with { type: "text" };
 
 import planMd from "../prompts/agents/plan.md" with { type: "text" };
 import reviewerMd from "../prompts/agents/reviewer.md" with { type: "text" };
 import taskMd from "../prompts/agents/task.md" with { type: "text" };
+import testerMd from "../prompts/agents/tester.md" with { type: "text" };
 
 import type { AgentDefinition, AgentSource } from "./types";
 
@@ -47,7 +47,7 @@ const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 	{ fileName: "designer.md", template: designerMd },
 	{ fileName: "reviewer.md", template: reviewerMd },
 	{ fileName: "librarian.md", template: librarianMd },
-	{ fileName: "oracle.md", template: oracleMd },
+	{ fileName: "tester.md", template: testerMd },
 	{
 		fileName: "task.md",
 		frontmatter: {
@@ -59,9 +59,9 @@ const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 		template: taskMd,
 	},
 	{
-		fileName: "quick_task.md",
+		fileName: "sonic.md",
 		frontmatter: {
-			name: "quick_task",
+			name: "sonic",
 			description: "Low-reasoning agent for strictly mechanical updates or data collection only",
 			model: "pi/smol",
 			thinkingLevel: Effort.Medium,

package/src/task/executor.ts

@@ -87,7 +87,7 @@ const MCP_CALL_TIMEOUT_MS = 60_000;
  */
 export const SOFT_REQUEST_BUDGET: Record<string, number> = {
 	explore: 40,
-	quick_task: 40,
+	sonic: 40,
 	default: 90,
 };
 
@@ -2053,9 +2053,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					? formatModelSelectorValue(formatModelStringWithRouting(model), resolvedThinkingLevel)
 					: formatModelStringWithRouting(model);
 			}
-			const effectiveThinkingLevel = explicitThinkingLevel
-				? resolvedThinkingLevel
-				: (thinkingLevel ?? resolvedThinkingLevel);
+			const effectiveThinkingLevel = thinkingLevel ?? resolvedThinkingLevel;
 			resolvedAt = performance.now();
 
 			const effectiveCwd = worktree ?? cwd;