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

package/scripts/generate-docs-index.ts

@@ -1,56 +1,148 @@
 #!/usr/bin/env bun
 
 /**
- * Populate (or reset) the embedded harness documentation index for `omp://`.
+ * Populate, check, or reset the embedded harness documentation index for `omp://`.
  *
  * `--generate` writes `src/internal-urls/docs-index.generated.txt` as two lines:
  * a plain JSON array of the sorted `docs/**\/*.md` file names, then a base64
- * gzip blob of the index-aligned doc bodies (`string[]`). Keeping the filename
- * list out of the blob lets the loader list docs without inflating it.
- * Compiled binaries and the prepacked npm bundle inline this (~0.5MB) instead of
- * the ~1.6MB raw map; `--reset` restores the checked-in empty placeholder so the
+ * gzip blob of the index-aligned doc bodies (`string[]`). `--check` rebuilds
+ * that payload from the real docs corpus and compares it to the embed when
+ * present; the checked-in empty placeholder is accepted after verifying that a
+ * fresh generated payload round-trips. `--reset` restores the placeholder so the
  * dev tree reads `docs/` from disk. Mirrors the stats / model-catalog embeds.
  */
 
 import * as path from "node:path";
-import { gzipSync } from "node:zlib";
+import { gunzipSync, gzipSync } from "node:zlib";
 import { Glob } from "bun";
 
 const docsDir = path.resolve(import.meta.dir, "../../../docs");
 const outputPath = path.resolve(import.meta.dir, "../src/internal-urls/docs-index.generated.txt");
 const GENERATE_FLAG = "--generate";
 const RESET_FLAG = "--reset";
+const CHECK_FLAG = "--check";
+
+export interface DocsIndexPayload {
+	/** Sorted `docs/**\/*.md` file names plus index-aligned bodies and embed text. */
+	readonly files: readonly string[];
+	readonly bodies: readonly string[];
+	readonly payload: string;
+}
+
+export interface DecodedDocsIndexPayload {
+	/** Sorted `docs/**\/*.md` file names decoded from an embed payload. */
+	readonly files: readonly string[];
+	/** Index-aligned Markdown bodies decoded from an embed payload. */
+	readonly bodies: readonly string[];
+}
+
+function isStringArray(value: unknown): value is string[] {
+	return Array.isArray(value) && value.every(item => typeof item === "string");
+}
+
+/** Build the exact two-line `omp://` docs embed from the source `docs/**\/*.md` corpus. */
+export async function buildDocsIndexPayload(): Promise<DocsIndexPayload> {
+	const glob = new Glob("**/*.md");
+	const files: string[] = [];
+	for await (const relativePath of glob.scan(docsDir)) {
+		files.push(relativePath.split(path.sep).join("/"));
+	}
+	files.sort();
+
+	const bodies = await Promise.all(files.map(file => Bun.file(path.join(docsDir, file)).text()));
+	const bodiesB64 = Buffer.from(gzipSync(Buffer.from(JSON.stringify(bodies)), { level: 9 })).toString("base64");
+	return {
+		files,
+		bodies,
+		payload: `${JSON.stringify(files)}\n${bodiesB64}`,
+	};
+}
+
+/** Decode a populated docs embed payload into filenames and index-aligned Markdown bodies. */
+export function decodeDocsIndexPayload(embed: string): DecodedDocsIndexPayload | null {
+	const newline = embed.indexOf("\n");
+	if (newline === -1) return null;
+
+	const filenames: unknown = JSON.parse(embed.slice(0, newline));
+	if (!isStringArray(filenames)) {
+		throw new Error("Embedded docs index filename line is not a JSON string array.");
+	}
+
+	const inflated = gunzipSync(Buffer.from(embed.slice(newline + 1), "base64"));
+	const bodies: unknown = JSON.parse(inflated.toString("utf8"));
+	if (!isStringArray(bodies)) {
+		throw new Error("Embedded docs index body blob is not a JSON string array.");
+	}
+
+	return { files: filenames, bodies };
+}
+
+/**
+ * Assert that an embed payload is fresh against the current source docs payload.
+ * An empty placeholder is accepted by round-tripping the expected payload (the
+ * dev tree and post-build reset state both checked-in placeholders).
+ */
+export function assertDocsIndexFresh(embed: string, expected: DecodedDocsIndexPayload): void {
+	const source =
+		embed.length > 0
+			? embed
+			: `${JSON.stringify(expected.files)}\n${Buffer.from(gzipSync(Buffer.from(JSON.stringify(expected.bodies)), { level: 9 })).toString("base64")}`;
+	const decoded = decodeDocsIndexPayload(source);
+	if (decoded === null) {
+		throw new Error("Embedded docs index is malformed: missing newline separator.");
+	}
+	if (decoded.files.length !== expected.files.length) {
+		throw new Error(
+			`Embedded docs index has ${decoded.files.length} docs; source corpus has ${expected.files.length}.`,
+		);
+	}
+	if (decoded.bodies.length !== expected.bodies.length) {
+		throw new Error(
+			`Embedded docs index has ${decoded.bodies.length} bodies; source corpus has ${expected.bodies.length}.`,
+		);
+	}
+	for (let i = 0; i < expected.files.length; i++) {
+		if (decoded.files[i] !== expected.files[i]) {
+			throw new Error(
+				`Embedded docs index filename mismatch at ${i}: ${decoded.files[i] ?? "<missing>"} !== ${expected.files[i]}.`,
+			);
+		}
+		if (decoded.bodies[i] !== expected.bodies[i]) {
+			throw new Error(`Embedded docs index body mismatch for ${expected.files[i]}. Run \`bun run gen:docs\`.`);
+		}
+	}
+}
 
 async function main(): Promise<void> {
 	const rel = path.relative(process.cwd(), outputPath);
 
 	if (process.argv.includes(RESET_FLAG)) {
 		await Bun.write(outputPath, "");
-		console.log(`Reset ${rel}`);
+		process.stdout.write(`Reset ${rel}\n`);
 		return;
 	}
 
-	if (!process.argv.includes(GENERATE_FLAG)) {
-		console.log(`Skipping ${rel}; pass ${GENERATE_FLAG} to embed docs (the dev tree reads docs/ from disk)`);
+	if (process.argv.includes(CHECK_FLAG)) {
+		const current = await buildDocsIndexPayload();
+		const embed = await Bun.file(outputPath).text();
+		assertDocsIndexFresh(embed, current);
+		process.stdout.write(`Docs index fresh for ${current.files.length} docs (${rel})\n`);
 		return;
 	}
 
-	const glob = new Glob("**/*.md");
-	const files: string[] = [];
-	for await (const relativePath of glob.scan(docsDir)) {
-		files.push(relativePath.split(path.sep).join("/"));
+	if (!process.argv.includes(GENERATE_FLAG)) {
+		process.stdout.write(
+			`Skipping ${rel}; pass ${GENERATE_FLAG} to embed docs (the dev tree reads docs/ from disk)\n`,
+		);
+		return;
 	}
-	files.sort();
-
-	// Index-aligned bodies (Promise.all preserves order), kept separate from the
-	// filename list so the loader can list docs without inflating the blob.
-	const bodies = await Promise.all(files.map(file => Bun.file(path.join(docsDir, file)).text()));
 
-	const bodiesB64 = Buffer.from(gzipSync(Buffer.from(JSON.stringify(bodies)), { level: 9 })).toString("base64");
-	// Two lines: plain filename array, then the base64 gzip blob.
-	const payload = `${JSON.stringify(files)}\n${bodiesB64}`;
-	await Bun.write(outputPath, payload);
-	console.log(`Generated ${rel} (${files.length} docs, ${payload.length} bytes)`);
+	const current = await buildDocsIndexPayload();
+	assertDocsIndexFresh(current.payload, current);
+	await Bun.write(outputPath, current.payload);
+	process.stdout.write(`Generated ${rel} (${current.files.length} docs, ${current.payload.length} bytes)\n`);
 }
 
-await main();
+if (import.meta.main) {
+	await main();
+}

package/src/async/job-manager.ts

@@ -397,6 +397,27 @@ export class AsyncJobManager {
 		await Promise.all(Array.from(this.#jobs.values()).map(job => job.promise));
 	}
 
+	async #waitForAllUntil(deadline: number): Promise<boolean> {
+		const promises = Array.from(this.#jobs.values()).map(job => job.promise);
+		if (promises.length === 0) return true;
+		if (deadline === Number.POSITIVE_INFINITY) {
+			await Promise.all(promises);
+			return true;
+		}
+		const remainingMs = deadline - Date.now();
+		if (remainingMs <= 0) return false;
+
+		const timeout = Promise.withResolvers<"timeout">();
+		const timer = setTimeout(() => timeout.resolve("timeout"), remainingMs);
+		timer.unref();
+		try {
+			const result = await Promise.race([Promise.all(promises).then(() => "settled" as const), timeout.promise]);
+			return result === "settled";
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+
 	async drainDeliveries(options?: { timeoutMs?: number; filter?: AsyncJobFilter }): Promise<boolean> {
 		const timeoutMs = options?.timeoutMs;
 		const filter = options?.filter;
@@ -445,8 +466,10 @@ export class AsyncJobManager {
 		this.#disposed = true;
 		this.#clearEvictionTimers();
 		this.cancelAll();
-		await this.waitForAll();
-		const drained = await this.drainDeliveries({ timeoutMs: options?.timeoutMs ?? 3_000 });
+		const timeoutMs = Math.max(options?.timeoutMs ?? 3_000, 0);
+		const deadline = Date.now() + timeoutMs;
+		const jobsSettled = await this.#waitForAllUntil(deadline);
+		const drained = await this.drainDeliveries({ timeoutMs: Math.max(deadline - Date.now(), 0) });
 		this.#clearEvictionTimers();
 		this.#jobs.clear();
 		this.#deliveries.length = 0;
@@ -454,7 +477,7 @@ export class AsyncJobManager {
 		this.#suppressedDeliveries.clear();
 		this.#watchedJobs.clear();
 		this.#pollEscalation.clear();
-		return drained;
+		return jobsSettled && drained;
 	}
 
 	#resolveJobId(preferredId?: string): string {
@@ -483,6 +506,7 @@ export class AsyncJobManager {
 	}
 
 	#scheduleEviction(jobId: string): void {
+		if (this.#disposed) return;
 		if (this.#retentionMs <= 0) {
 			this.#jobs.delete(jobId);
 			this.#suppressedDeliveries.delete(jobId);

package/src/cli/grep-cli.ts

@@ -150,7 +150,7 @@ ${chalk.bold("Options:")}
   --no-gitignore        Include files excluded by .gitignore
 
 ${chalk.bold("Environment:")}
-  PI_GREP_WORKERS=N    Set filesystem walker workers (default 4, 0 = auto)
+  PI_WALK_WORKERS=N    Set filesystem walker workers (default 4, 0 = auto)
 
 ${chalk.bold("Examples:")}
   ${APP_NAME} grep "import" src/

package/src/commit/agentic/agent.ts

@@ -42,7 +42,7 @@ export async function runCommitAgentSession(input: CommitAgentInput): Promise<Co
 		types_description: typesDescription,
 	});
 	const state: CommitAgentState = { diffText: input.diffText };
-	const spawns = "quick_task";
+	const spawns = "sonic";
 	const tools = createCommitTools({
 		cwd: input.cwd,
 		authStorage: input.authStorage,

package/src/commit/agentic/prompts/system.md

@@ -27,7 +27,7 @@ Tool guidance:
 - git_file_diff: diff for specific files
 - git_hunk: specific hunks for large diffs
 - recent_commits: recent commit subjects + style stats
-- analyze_files: spawn quick_task subagents in parallel for analysis
+- analyze_files: spawn sonic subagents in parallel for analysis
 - propose_changelog: provide changelog entries for each changelog target
 - propose_commit: submit final commit proposal and run validation
 - split_commit: propose multiple commit groups (no overlapping files; all staged files covered)

package/src/commit/agentic/tools/analyze-file.ts

@@ -63,7 +63,7 @@ export function createAnalyzeFileTool(options: {
 	return {
 		name: "analyze_files",
 		label: "Analyze Files",
-		description: "Spawn quick_task agents to analyze files.",
+		description: "Spawn sonic agents to analyze files.",
 		parameters: analyzeFileSchema,
 		async execute(toolCallId, params, _onUpdate, ctx, signal) {
 			const toolSession = buildToolSession(ctx, options);
@@ -83,7 +83,7 @@ export function createAnalyzeFileTool(options: {
 						related_files: relatedFiles,
 					});
 					const taskParams: TaskParams = {
-						agent: "quick_task",
+						agent: "sonic",
 						id: `AnalyzeFile${index + 1}`,
 						description: `Analyze ${file}`,
 						assignment,

package/src/config/model-discovery.ts

@@ -35,6 +35,31 @@ import type { ProviderDiscovery } from "./models-config-schema";
 export const DISCOVERY_DEFAULT_CONTEXT_WINDOW = OPENAI_COMPAT_DISCOVERY_DEFAULT_CONTEXT_WINDOW;
 export const DISCOVERY_DEFAULT_MAX_TOKENS = OPENAI_COMPAT_DISCOVERY_DEFAULT_MAX_TOKENS;
 
+/**
+ * Run `fn` with an abort signal that fires after `timeoutMs`, clearing the
+ * backing timer the instant the operation settles.
+ *
+ * Unlike the built-in abort-signal timeout API, the timer never outlives the
+ * request: on the success path it is cancelled before `fn` resolves, so the
+ * signal is never aborted and no pending callback lingers on the heap. A leaked
+ * abort-signal timeout (e.g. discovery against a mocked fetch that resolves
+ * instantly) fires seconds later and sets its abort `reason` — which crashed
+ * Bun's concurrent GC while it marked the signal's wrapped reason during an
+ * unrelated allocation (`JSAbortSignal::visitAdditionalChildren`).
+ */
+async function withTimeoutSignal<T>(timeoutMs: number, fn: (signal: AbortSignal) => Promise<T>): Promise<T> {
+	const controller = new AbortController();
+	const timer = setTimeout(
+		() => controller.abort(new DOMException("The operation timed out.", "TimeoutError")),
+		timeoutMs,
+	);
+	try {
+		return await fn(controller.signal);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+
 const DEFAULT_OLLAMA_BASE_URL = "http://127.0.0.1:11434";
 const OLLAMA_HOST_DEFAULT_PORT = "11434";
 
@@ -288,16 +313,18 @@ async function discoverOllamaModelMetadata(
 ): Promise<OllamaDiscoveredModelMetadata | null> {
 	const showUrl = `${endpoint}/api/show`;
 	try {
-		const response = await ctx.fetch(showUrl, {
-			method: "POST",
-			headers: { ...(headers ?? {}), "Content-Type": "application/json" },
-			body: JSON.stringify({ model: modelId }),
-			signal: AbortSignal.timeout(150),
+		const payload = await withTimeoutSignal(150, async signal => {
+			const response = await ctx.fetch(showUrl, {
+				method: "POST",
+				headers: { ...(headers ?? {}), "Content-Type": "application/json" },
+				body: JSON.stringify({ model: modelId }),
+				signal,
+			});
+			if (!response.ok) {
+				return null;
+			}
+			return (await response.json()) as unknown;
 		});
-		if (!response.ok) {
-			return null;
-		}
-		const payload = (await response.json()) as unknown;
 		if (!isRecord(payload)) {
 			return null;
 		}
@@ -339,14 +366,16 @@ export async function discoverOllamaModels(
 	const endpoint = normalizeOllamaBaseUrl(providerConfig.baseUrl);
 	const tagsUrl = `${endpoint}/api/tags`;
 	const headers = { ...(providerConfig.headers ?? {}) };
-	const response = await ctx.fetch(tagsUrl, {
-		headers,
-		signal: AbortSignal.timeout(250),
+	const payload = await withTimeoutSignal(250, async signal => {
+		const response = await ctx.fetch(tagsUrl, {
+			headers,
+			signal,
+		});
+		if (!response.ok) {
+			throw new Error(`HTTP ${response.status} from ${tagsUrl}`);
+		}
+		return (await response.json()) as { models?: Array<{ name?: string; model?: string }> };
 	});
-	if (!response.ok) {
-		throw new Error(`HTTP ${response.status} from ${tagsUrl}`);
-	}
-	const payload = (await response.json()) as { models?: Array<{ name?: string; model?: string }> };
 	const entries = (payload.models ?? []).flatMap(item => {
 		const id = item.model || item.name;
 		return id ? [{ id, name: item.name || id }] : [];
@@ -384,14 +413,16 @@ async function discoverLlamaCppServerMetadata(
 ): Promise<LlamaCppDiscoveredServerMetadata | null> {
 	const propsUrl = `${toLlamaCppNativeBaseUrl(baseUrl)}/props`;
 	try {
-		const response = await ctx.fetch(propsUrl, {
-			headers,
-			signal: AbortSignal.timeout(150),
+		const payload = await withTimeoutSignal(150, async signal => {
+			const response = await ctx.fetch(propsUrl, {
+				headers,
+				signal,
+			});
+			if (!response.ok) {
+				return null;
+			}
+			return (await response.json()) as unknown;
 		});
-		if (!response.ok) {
-			return null;
-		}
-		const payload = (await response.json()) as unknown;
 		if (!isRecord(payload)) {
 			return null;
 		}
@@ -415,24 +446,26 @@ export async function discoverLlamaCppModels(
 	const baseHeaders: Record<string, string> = { ...(providerConfig.headers ?? {}) };
 	let headers = baseHeaders;
 	const attempt = async (h: Record<string, string>) => {
-		const [response, metadata] = await Promise.all([
-			ctx.fetch(modelsUrl, {
-				headers: h,
-				signal: AbortSignal.timeout(250),
+		const [payload, metadata] = await Promise.all([
+			withTimeoutSignal(250, async signal => {
+				const response = await ctx.fetch(modelsUrl, {
+					headers: h,
+					signal,
+				});
+				if (!response.ok) {
+					throw new Error(`HTTP ${response.status} from ${modelsUrl}`);
+				}
+				headers = h;
+				return (await response.json()) as unknown;
 			}),
 			discoverLlamaCppServerMetadata(ctx, baseUrl, h),
 		]);
-		if (!response.ok) {
-			throw new Error(`HTTP ${response.status} from ${modelsUrl}`);
-		}
-		headers = h;
-		return [response, metadata] as const;
+		return [payload, metadata] as const;
 	};
 	const apiKey = await ctx.getBearerApiKeyResolver(providerConfig.provider);
-	const [response, serverMetadata] = apiKey
+	const [payload, serverMetadata] = apiKey
 		? await withAuth(apiKey, key => attempt({ ...baseHeaders, Authorization: `Bearer ${key}` }))
 		: await attempt(baseHeaders);
-	const payload = (await response.json()) as unknown;
 	const models = parseLlamaCppModelList(payload);
 	const discovered: Model<Api>[] = [];
 	for (const item of models) {
@@ -476,17 +509,22 @@ export async function discoverLlamaCppModelRuntimeMetadata(
 	const modelsUrl = `${baseUrl}/models`;
 	const baseHeaders: Record<string, string> = { ...(model.headers ?? {}) };
 	const attempt = async (headers: Record<string, string>) => {
-		const [response, serverMetadata] = await Promise.all([
-			ctx.fetch(modelsUrl, {
-				headers,
-				signal: AbortSignal.timeout(250),
+		const [entries, serverMetadata] = await Promise.all([
+			withTimeoutSignal(250, async signal => {
+				const response = await ctx.fetch(modelsUrl, {
+					headers,
+					signal,
+				});
+				if (!response.ok) {
+					return undefined;
+				}
+				return parseLlamaCppModelList(await response.json());
 			}),
 			discoverLlamaCppServerMetadata(ctx, baseUrl, headers),
 		]);
-		if (!response.ok) {
+		if (!entries) {
 			return undefined;
 		}
-		const entries = parseLlamaCppModelList(await response.json());
 		const entry = entries.find(entry => entry.id === model.id);
 		if (!entry) {
 			return undefined;
@@ -524,26 +562,28 @@ export async function discoverOpenAIModelsList(
 			providerConfig.discovery.type === "lm-studio"
 				? fetchLmStudioNativeModelMetadata(baseUrl, ctx.fetch, { headers: h })
 				: Promise.resolve(null);
-		const [res, nativeMetadata] = await Promise.all([
-			ctx.fetch(modelsUrl, {
-				headers: h,
-				signal: AbortSignal.timeout(10_000),
+		const [payload, nativeMetadata] = await Promise.all([
+			withTimeoutSignal(10_000, async signal => {
+				const res = await ctx.fetch(modelsUrl, {
+					headers: h,
+					signal,
+				});
+				if (!res.ok) {
+					throw new Error(`HTTP ${res.status} from ${modelsUrl}`);
+				}
+				headers = h;
+				return (await res.json()) as {
+					data?: Array<{ id?: string; max_model_len?: unknown; context_length?: unknown }>;
+				};
 			}),
 			nativeMetadataPromise,
 		]);
-		if (!res.ok) {
-			throw new Error(`HTTP ${res.status} from ${modelsUrl}`);
-		}
-		headers = h;
-		return [res, nativeMetadata] as const;
+		return [payload, nativeMetadata] as const;
 	};
 	const apiKey = await ctx.getBearerApiKeyResolver(providerConfig.provider);
-	const [response, nativeMetadata] = apiKey
+	const [payload, nativeMetadata] = apiKey
 		? await withAuth(apiKey, key => attempt({ ...baseHeaders, Authorization: `Bearer ${key}` }))
 		: await attempt(baseHeaders);
-	const payload = (await response.json()) as {
-		data?: Array<{ id?: string; max_model_len?: unknown; context_length?: unknown }>;
-	};
 	const models = payload.data ?? [];
 	const discovered: Model<Api>[] = [];
 	for (const item of models) {
@@ -600,15 +640,17 @@ export async function discoverLiteLLMModels(
 			}
 			return response;
 		};
-		const models = await fetchLiteLLMRichModels({
-			api: providerConfig.api,
-			provider: providerConfig.provider,
-			baseUrl,
-			headers: h,
-			fetch: authAwareFetch,
-			referenceResolver: resolveReference,
-			signal: AbortSignal.timeout(10_000),
-		});
+		const models = await withTimeoutSignal(10_000, signal =>
+			fetchLiteLLMRichModels({
+				api: providerConfig.api,
+				provider: providerConfig.provider,
+				baseUrl,
+				headers: h,
+				fetch: authAwareFetch,
+				referenceResolver: resolveReference,
+				signal,
+			}),
+		);
 		if (authError && models === null) {
 			throw authError;
 		}
@@ -657,24 +699,24 @@ export async function discoverProxyModels(
 
 	const baseHeaders: Record<string, string> = { ...(providerConfig.headers ?? {}) };
 	let headers = baseHeaders;
-	const attempt = async (h: Record<string, string>) => {
-		const res = await ctx.fetch(modelsUrl, {
-			headers: h,
-			signal: AbortSignal.timeout(10_000),
+	const attempt = async (h: Record<string, string>) =>
+		withTimeoutSignal(10_000, async signal => {
+			const res = await ctx.fetch(modelsUrl, {
+				headers: h,
+				signal,
+			});
+			if (!res.ok) {
+				throw new Error(`HTTP ${res.status} from ${modelsUrl}`);
+			}
+			headers = h;
+			return (await res.json()) as {
+				data?: Array<{ id?: string; name?: string; supported_endpoint_types?: string[]; context_length?: number }>;
+			};
 		});
-		if (!res.ok) {
-			throw new Error(`HTTP ${res.status} from ${modelsUrl}`);
-		}
-		headers = h;
-		return res;
-	};
 	const apiKey = await ctx.getBearerApiKeyResolver(providerConfig.provider);
-	const response = apiKey
+	const payload = apiKey
 		? await withAuth(apiKey, key => attempt({ ...baseHeaders, Authorization: `Bearer ${key}` }))
 		: await attempt(baseHeaders);
-	const payload = (await response.json()) as {
-		data?: Array<{ id?: string; name?: string; supported_endpoint_types?: string[]; context_length?: number }>;
-	};
 	const items = payload.data ?? [];
 	const discovered: Model<Api>[] = [];
 	for (const item of items) {

package/src/config/settings-schema.ts

@@ -3,6 +3,7 @@ import { DEFAULT_SHARE_URL } from "@oh-my-pi/pi-wire";
 import { SHAPE_VARIANT_NAMES } from "@oh-my-pi/snapcompact";
 import { DEFAULT_RELAY_URL } from "../collab/protocol";
 import { DEFAULT_STT_MODEL_KEY, STT_MODEL_OPTIONS, STT_MODEL_VALUES } from "../stt/models";
+import { STT_SUBMIT_TRIGGER_OPTIONS, STT_SUBMIT_TRIGGER_VALUES } from "../stt/submit-trigger";
 import { AUTO_THINKING, getConfiguredThinkingLevelMetadata, getThinkingLevelMetadata } from "../thinking";
 import {
 	TINY_MODEL_DEVICE_DEFAULT,
@@ -1794,6 +1795,19 @@ export const SETTINGS_SCHEMA = {
 			options: STT_MODEL_OPTIONS,
 		},
 	},
+	"stt.submitTrigger": {
+		type: "enum",
+		values: STT_SUBMIT_TRIGGER_VALUES,
+		default: "never",
+		ui: {
+			tab: "interaction",
+			group: "Speech",
+			label: "Speech-to-Text Submit Trigger",
+			description:
+				"Choose when speech dictation automatically submits: Never, Release (2+ words), Release with complete sentence, or When I Say Submit.",
+			options: STT_SUBMIT_TRIGGER_OPTIONS,
+		},
+	},
 
 	// ────────────────────────────────────────────────────────────────────────
 	// Context
@@ -4081,7 +4095,7 @@ export const SETTINGS_SCHEMA = {
 			group: "Subagents",
 			label: "Soft Subagent Request Budget",
 			description:
-				"Soft per-subagent request budget (assistant requests per run). Crossing it injects one steering notice asking the subagent to wrap up; at 1.5x the budget the run is aborted gracefully, salvaging partial output. 0 disables the guard. Bundled explore/quick_task agents use a lower built-in budget.",
+				"Soft per-subagent request budget (assistant requests per run). Crossing it injects one steering notice asking the subagent to wrap up; at 1.5x the budget the run is aborted gracefully, salvaging partial output. 0 disables the guard. Bundled explore/sonic agents use a lower built-in budget.",
 			options: [
 				{ value: "0", label: "Disabled" },
 				{ value: "40", label: "40 requests" },

package/src/debug/profiler.ts

@@ -114,7 +114,13 @@ function formatProfileAsMarkdown(profileJson: string): string {
  */
 export async function startCpuProfile(): Promise<ProfilerSession> {
 	const v8 = await import("node:v8");
-	v8.setFlagsFromString("--allow-natives-syntax");
+	try {
+		// Enables `%GetOptimizationStatus` and friends when V8 natives are needed
+		// for ad-hoc profiling. Best-effort: Bun does not implement
+		// `setFlagsFromString` (oven-sh/bun#1702) but the CPU profiler itself
+		// works without it, so swallow the error and continue.
+		v8.setFlagsFromString("--allow-natives-syntax");
+	} catch {}
 
 	const { Session } = await import("node:inspector/promises");
 	const session = new Session();