@oh-my-pi/pi-coding-agent 17.0.3 → 17.0.4

package/dist/types/mnemopi/state.d.ts

@@ -116,11 +116,15 @@ export declare class MnemopiSessionState {
     beforeAgentStartPrompt(promptText: string): Promise<string | undefined>;
     recallForCompaction(messages: AgentMessage[]): Promise<string | undefined>;
     maybeRetainOnAgentEnd(_messages: AgentMessage[]): Promise<void>;
-    forceRetainCurrentSession(): Promise<void>;
+    forceRetainCurrentSession(options?: {
+        extract?: boolean;
+    }): Promise<void>;
     retainMessages(messages: Array<{
         role: string;
         content: string;
-    }>, sourceId: string): Promise<void>;
+    }>, sourceId: string, options?: {
+        extract?: boolean;
+    }): Promise<void>;
     attachSessionListeners(): void;
     maybeRecallOnAgentStart(): Promise<void>;
     /**
@@ -139,15 +143,34 @@ export declare class MnemopiSessionState {
      * otherwise enqueue would report success while leaving the subagent's
      * retained memories unconsolidated until the parent eventually shuts down
      * (PR #2327 review).
+     *
+     * @param options.full - When true, run `sleepAllSessions` on every owned bank
+     *  (the full cross-session consolidation used by `/memory enqueue`). When
+     *  false (the default), run only `sleep` on the current session for a
+     *  lighter, bounded shutdown pass.
+     * @param options.sleep - When false, skips the bank sleep step entirely.
+     *  Used on the interactive shutdown path so `dispose` does not block on
+     *  synchronous consolidation of old working rows from previous sessions.
+     * @param options.extract - When false, the retained transcript is stored but
+     *  no LLM fact extraction is scheduled. Used on the interactive shutdown path
+     *  so `dispose` does not block on a fresh LLM round-trip.
      */
-    consolidate(): Promise<void>;
+    consolidate(options?: {
+        full?: boolean;
+        extract?: boolean;
+        sleep?: boolean;
+    }): Promise<void>;
     /**
-     * Release the per-session resources. Defaults to running {@link consolidate}
-     * before closing handles so normal session shutdown promotes working memory
-     * into long-term storage. Callers that are about to delete the DB files —
-     * e.g. `mnemopiBackend.clear` — pass `{ consolidate: false }` to skip the
-     * extraction/sleep pass, since spending tokens on memories that will be
-     * wiped on the next line is wasted work (PR #2327 review).
+     * Release the per-session resources. Defaults to running a lighter
+     * {@link consolidate} pass before closing handles: it retains the current
+     * transcript and flushes in-flight extractions, but skips the synchronous
+     * bank sleep so normal session shutdown returns promptly. Full promotion of
+     * working memory into long-term storage is still performed by the explicit
+     * `/memory enqueue` and backend enqueue paths. Callers that are about to
+     * delete the DB files — e.g. `mnemopiBackend.clear` — pass
+     * `{ consolidate: false }` to skip the retain/flush pass, since spending
+     * tokens on memories that will be wiped on the next line is wasted work
+     * (PR #2327 review).
      *
      * `timeoutMs` caps how long the consolidate await blocks the caller
      * (the user-visible `/quit` / `/exit` shutdown path passes this so

package/dist/types/task/types.d.ts

@@ -83,7 +83,7 @@ export declare const taskItemSchema: import("arktype/internal/variants/object.ts
     name?: string | undefined;
     agent: import("arktype/internal/attributes.ts").Default<string, "task">;
     task: string;
-    outputSchema?: unknown;
+    outputSchema?: string | boolean | object | null | undefined;
     schemaMode?: "permissive" | "strict" | undefined;
 }, {}>;
 /** Single task item. Fields are optional defensively: args stream in token by token. */
@@ -105,7 +105,7 @@ export declare const taskSchema: import("arktype/internal/variants/object.ts").O
     name?: string | undefined;
     agent: import("arktype/internal/attributes.ts").Default<string, "task">;
     task: string;
-    outputSchema?: unknown;
+    outputSchema?: string | boolean | object | null | undefined;
     schemaMode?: "permissive" | "strict" | undefined;
     isolated?: boolean | undefined;
 }, {}>;
@@ -113,14 +113,14 @@ declare const ALL_TASK_SCHEMAS: readonly [import("arktype/internal/variants/obje
     name?: string | undefined;
     agent: import("arktype/internal/attributes.ts").Default<string, "task">;
     task: string;
-    outputSchema?: unknown;
+    outputSchema?: string | boolean | object | null | undefined;
     schemaMode?: "permissive" | "strict" | undefined;
     isolated?: boolean | undefined;
 }, {}>, import("arktype/internal/variants/object.ts").ObjectType<{
     name?: string | undefined;
     agent: import("arktype/internal/attributes.ts").Default<string, "task">;
     task: string;
-    outputSchema?: unknown;
+    outputSchema?: string | boolean | object | null | undefined;
     schemaMode?: "permissive" | "strict" | undefined;
 }, {}>, import("arktype/internal/variants/object.ts").ObjectType<{
     context: string;
@@ -128,7 +128,7 @@ declare const ALL_TASK_SCHEMAS: readonly [import("arktype/internal/variants/obje
         name?: string | undefined;
         agent: import("arktype/internal/attributes.ts").Default<string, "task">;
         task: string;
-        outputSchema?: unknown;
+        outputSchema?: string | boolean | object | null | undefined;
         schemaMode?: "permissive" | "strict" | undefined;
         isolated?: boolean | undefined;
     }[];
@@ -138,7 +138,7 @@ declare const ALL_TASK_SCHEMAS: readonly [import("arktype/internal/variants/obje
         name?: string | undefined;
         agent: import("arktype/internal/attributes.ts").Default<string, "task">;
         task: string;
-        outputSchema?: unknown;
+        outputSchema?: string | boolean | object | null | undefined;
         schemaMode?: "permissive" | "strict" | undefined;
     }[];
 }, {}>];

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "17.0.3",
+	"version": "17.0.4",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -52,17 +52,17 @@
 		"@agentclientprotocol/sdk": "1.2.1",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "17.0.3",
-		"@oh-my-pi/omp-stats": "17.0.3",
-		"@oh-my-pi/pi-agent-core": "17.0.3",
-		"@oh-my-pi/pi-ai": "17.0.3",
-		"@oh-my-pi/pi-catalog": "17.0.3",
-		"@oh-my-pi/pi-mnemopi": "17.0.3",
-		"@oh-my-pi/pi-natives": "17.0.3",
-		"@oh-my-pi/pi-tui": "17.0.3",
-		"@oh-my-pi/pi-utils": "17.0.3",
-		"@oh-my-pi/pi-wire": "17.0.3",
-		"@oh-my-pi/snapcompact": "17.0.3",
+		"@oh-my-pi/hashline": "17.0.4",
+		"@oh-my-pi/omp-stats": "17.0.4",
+		"@oh-my-pi/pi-agent-core": "17.0.4",
+		"@oh-my-pi/pi-ai": "17.0.4",
+		"@oh-my-pi/pi-catalog": "17.0.4",
+		"@oh-my-pi/pi-mnemopi": "17.0.4",
+		"@oh-my-pi/pi-natives": "17.0.4",
+		"@oh-my-pi/pi-tui": "17.0.4",
+		"@oh-my-pi/pi-utils": "17.0.4",
+		"@oh-my-pi/pi-wire": "17.0.4",
+		"@oh-my-pi/snapcompact": "17.0.4",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/api-logs": "^0.220.0",
 		"@opentelemetry/context-async-hooks": "^2.9.0",

package/src/mnemopi/backend.ts

@@ -145,7 +145,7 @@ export const mnemopiBackend: MemoryBackend = {
 				state = new MnemopiSessionState({ sessionId: session.sessionId, config, session });
 				setMnemopiSessionState(session, state);
 			}
-			await state?.consolidate();
+			await state?.consolidate({ full: true });
 		} catch (error) {
 			logger.warn("Mnemopi: enqueue failed.", { error: String(error) });
 		}

package/src/mnemopi/embed-worker.ts

@@ -9,8 +9,7 @@
  * in either process.
  */
 
-import type { StandardEmbeddingModel } from "@oh-my-pi/pi-mnemopi/core";
-import { loadFastembed } from "@oh-my-pi/pi-mnemopi/core/fastembed-runtime";
+import { defaultLocalModelInitializer, type StandardEmbeddingModel } from "@oh-my-pi/pi-mnemopi/core";
 import type { MnemopiEmbedModelId, MnemopiEmbedTransport, MnemopiEmbedWorkerInbound } from "./embed-protocol";
 
 interface LoadedModel {
@@ -25,12 +24,14 @@ let loaded: Promise<LoadedModel> | null = null;
 let loadedKey = "";
 
 async function loadModel(model: MnemopiEmbedModelId, cacheDir: string | undefined): Promise<LoadedModel> {
-	const { FlagEmbedding } = await loadFastembed();
+	// Route through mnemopi's shared initializer so the worker inherits BOTH
+	// cache heals (sidecar re-fetch AND corrupt-model quarantine/retry) —
+	// fastembed/onnxruntime still load only in this child address space, the
+	// initializer calls loadFastembed() itself.
 	// Cast: `model` arrives as a string from the parent (resolved by
-	// mnemopi's `fastembedModelName`). Cast to the non-CUSTOM overload's
-	// argument so TypeScript picks the standard-model branch — the parent
-	// only ever passes pre-vetted fast-* identifiers.
-	const instance = await FlagEmbedding.init({
+	// mnemopi's `fastembedModelName`); the parent only ever passes pre-vetted
+	// fast-* identifiers.
+	const instance = await defaultLocalModelInitializer({
 		model: model as StandardEmbeddingModel,
 		cacheDir,
 		showDownloadProgress: false,

package/src/mnemopi/state.ts

@@ -454,18 +454,23 @@ export class MnemopiSessionState {
 		this.lastRetainedTurn = userTurns;
 	}
 
-	async forceRetainCurrentSession(): Promise<void> {
+	async forceRetainCurrentSession(options: { extract?: boolean } = {}): Promise<void> {
 		if (this.aliasOf) return;
 		const flat = extractMessages(this.session.sessionManager);
-		await this.retainMessages(flat, this.sessionId);
+		await this.retainMessages(flat, this.sessionId, options);
 		this.lastRetainedTurn = flat.filter(message => message.role === "user").length;
 	}
 
-	async retainMessages(messages: Array<{ role: string; content: string }>, sourceId: string): Promise<void> {
+	async retainMessages(
+		messages: Array<{ role: string; content: string }>,
+		sourceId: string,
+		options: { extract?: boolean } = {},
+	): Promise<void> {
 		const { transcript, messageCount } = prepareRetentionTranscript(messages, true);
 		if (!transcript) return;
 		const { transcript: extractText } = prepareUserRetentionTranscript(messages);
 		const { transcript: embedText } = prepareEmbeddableRetentionTranscript(messages);
+		const shouldExtract = options.extract !== false && extractText !== null;
 		this.rememberInScope(transcript, {
 			source: "coding-agent-transcript",
 			importance: 0.65,
@@ -476,9 +481,9 @@ export class MnemopiSessionState {
 				cwd: this.session.sessionManager.getCwd(),
 			},
 			scope: "bank",
-			extract: extractText !== null,
-			extractEntities: extractText !== null,
-			extractText,
+			extract: shouldExtract,
+			extractEntities: shouldExtract,
+			extractText: shouldExtract ? extractText : null,
 			embedText,
 			veracity: "unknown",
 			memoryType: "episode",
@@ -530,22 +535,42 @@ export class MnemopiSessionState {
 	 * otherwise enqueue would report success while leaving the subagent's
 	 * retained memories unconsolidated until the parent eventually shuts down
 	 * (PR #2327 review).
+	 *
+	 * @param options.full - When true, run `sleepAllSessions` on every owned bank
+	 *  (the full cross-session consolidation used by `/memory enqueue`). When
+	 *  false (the default), run only `sleep` on the current session for a
+	 *  lighter, bounded shutdown pass.
+	 * @param options.sleep - When false, skips the bank sleep step entirely.
+	 *  Used on the interactive shutdown path so `dispose` does not block on
+	 *  synchronous consolidation of old working rows from previous sessions.
+	 * @param options.extract - When false, the retained transcript is stored but
+	 *  no LLM fact extraction is scheduled. Used on the interactive shutdown path
+	 *  so `dispose` does not block on a fresh LLM round-trip.
 	 */
-	async consolidate(): Promise<void> {
-		await this.forceRetainCurrentSession();
+	async consolidate(options: { full?: boolean; extract?: boolean; sleep?: boolean } = {}): Promise<void> {
+		await this.forceRetainCurrentSession({ extract: options.extract });
 		for (const memory of this.scoped.owned) {
 			await memory.flushExtractions();
-			memory.sleepAllSessions(false);
+			if (options.sleep === false) continue;
+			if (options.full) {
+				memory.sleepAllSessions(false);
+			} else {
+				memory.sleep(false);
+			}
 		}
 	}
 
 	/**
-	 * Release the per-session resources. Defaults to running {@link consolidate}
-	 * before closing handles so normal session shutdown promotes working memory
-	 * into long-term storage. Callers that are about to delete the DB files —
-	 * e.g. `mnemopiBackend.clear` — pass `{ consolidate: false }` to skip the
-	 * extraction/sleep pass, since spending tokens on memories that will be
-	 * wiped on the next line is wasted work (PR #2327 review).
+	 * Release the per-session resources. Defaults to running a lighter
+	 * {@link consolidate} pass before closing handles: it retains the current
+	 * transcript and flushes in-flight extractions, but skips the synchronous
+	 * bank sleep so normal session shutdown returns promptly. Full promotion of
+	 * working memory into long-term storage is still performed by the explicit
+	 * `/memory enqueue` and backend enqueue paths. Callers that are about to
+	 * delete the DB files — e.g. `mnemopiBackend.clear` — pass
+	 * `{ consolidate: false }` to skip the retain/flush pass, since spending
+	 * tokens on memories that will be wiped on the next line is wasted work
+	 * (PR #2327 review).
 	 *
 	 * `timeoutMs` caps how long the consolidate await blocks the caller
 	 * (the user-visible `/quit` / `/exit` shutdown path passes this so
@@ -569,9 +594,11 @@ export class MnemopiSessionState {
 			closeOwned();
 			return;
 		}
-		const consolidatePromise = this.consolidate().catch((error: unknown) => {
-			logger.warn("Mnemopi: consolidation on dispose failed.", { error: String(error) });
-		});
+		const consolidatePromise = this.consolidate({ full: false, extract: false, sleep: false }).catch(
+			(error: unknown) => {
+				logger.warn("Mnemopi: consolidation on dispose failed.", { error: String(error) });
+			},
+		);
 		const { timeoutMs } = options;
 		if (timeoutMs !== undefined && timeoutMs > 0) {
 			const TIMED_OUT = Symbol("mnemopi.dispose.timedOut");

package/src/modes/components/transcript-container.ts

@@ -19,11 +19,17 @@ interface FinalizableBlock {
 	/**
 	 * Monotonic content version for blocks that can still mutate *after*
 	 * reporting finalized (e.g. `AssistantMessageComponent`: the inline error
-	 * restored at the next turn's `agent_start`, late tool-result images). The
-	 * committed-scrollback render bypass only replays a block's previous rows
-	 * when the version is unchanged; without this signal a post-finalize
-	 * mutation would stay invisible until a global invalidation. Blocks that
-	 * never mutate post-finalize simply omit the method.
+	 * restored at the next turn's `agent_start`, late tool-result images). While
+	 * the block's rows are still on screen (not yet fully committed), the
+	 * committed-scrollback render bypass replays its previous rows only when the
+	 * version is unchanged; a bump forces a real render so the TUI's
+	 * committed-prefix audit can observe and re-anchor the change. Once the rows
+	 * fully commit to native scrollback they are dropped from the local frame
+	 * (compacted) — a later mutation no longer recommits on an ordinary frame
+	 * (immutable history the terminal owns; recommitting would duplicate it) and
+	 * instead rehydrates on the next destructive full replay
+	 * ({@link "@oh-my-pi/pi-tui".NativeScrollbackReplay}). Blocks that never
+	 * mutate post-finalize simply omit the method.
 	 */
 	getTranscriptBlockVersion?(): number;
 	/**
@@ -124,7 +130,7 @@ interface BlockSegment {
 	sep: number;
 	/** Whether the block reported finalized when this segment was rendered. */
 	finalized: boolean;
-	/** Safe to drop after commit: produced while finalized, without post-finalize version tracking. */
+	/** Safe to drop from the local frame once its rows fully commit to native scrollback: produced while finalized. */
 	compactable: boolean;
 	/** Block version observed when this segment was rendered (see {@link FinalizableBlock}). */
 	version: number | undefined;
@@ -453,7 +459,7 @@ export class TranscriptContainer
 					previous.width === width &&
 					previous.generation === this.#generation);
 			const contribution = reusable ? previous.contribution : stripPlainBlankEdges(raw);
-			const compactable = finalized && version === undefined && previous?.finalized !== false;
+			const compactable = finalized && previous?.finalized !== false;
 
 			// Empty (or stripped-to-nothing) children contribute nothing and never
 			// affect spacing. An empty still-live child still gates the commit

package/src/session/session-loader.ts

@@ -271,10 +271,38 @@ async function resolvePersistedBlobRefs(value: unknown, blobStore: BlobStore, ke
 	);
 }
 
+/**
+ * Cheap synchronous precheck: does this value's tree contain any `blob:sha256:` string?
+ * Early-exits on the first hit and allocates no promises, so blob-free entries skip the
+ * async {@link resolvePersistedBlobRefs} descent entirely. Conservative — a blob ref in a
+ * non-resolved position still returns true, which only costs an extra (no-op) walk.
+ */
+function containsBlobRef(value: unknown): boolean {
+	if (typeof value === "string") return isBlobRef(value);
+	if (Array.isArray(value)) {
+		for (const item of value) {
+			if (containsBlobRef(item)) return true;
+		}
+		return false;
+	}
+	if (typeof value !== "object" || value === null) return false;
+	for (const key in value) {
+		if (containsBlobRef((value as Record<string, unknown>)[key])) return true;
+	}
+	return false;
+}
+
 export async function resolveBlobRefsInEntries(entries: FileEntry[], blobStore: BlobStore): Promise<void> {
-	await Promise.all(
-		entries.filter(entry => entry.type !== "session").map(entry => resolvePersistedBlobRefs(entry, blobStore)),
-	);
+	const pending: Promise<void>[] = [];
+	// Interleave precheck + initiation per entry so a positive entry begins resolution at the same
+	// relative point as the old filter+map schedule (no scan-all-first pass that could observe a
+	// later entry before an earlier resolution mutates it).
+	for (const entry of entries) {
+		if (entry.type === "session") continue;
+		if (!containsBlobRef(entry)) continue;
+		pending.push(resolvePersistedBlobRefs(entry, blobStore));
+	}
+	await Promise.all(pending);
 }
 
 /**

package/src/stt/recorder.ts

@@ -11,6 +11,8 @@ export interface RecordingHandle {
 }
 
 const isWindows = process.platform === "win32";
+const linuxFFmpegFormats = new Map<string, "pulse" | "alsa">();
+const ffmpegCaptureFlags = ["-hide_banner", "-loglevel", "error", "-nostats"];
 
 /**
  * Returns available recording tools in priority order.
@@ -36,6 +38,36 @@ async function detectWindowsAudioDevice(bin: string): Promise<string> {
 	return audioDevices[0];
 }
 
+async function ffmpegInputArgs(bin: string): Promise<string[]> {
+	if (isWindows) {
+		return ["-f", "dshow", "-i", `audio=${await detectWindowsAudioDevice(bin)}`];
+	}
+	if (process.platform === "darwin") {
+		return ["-f", "avfoundation", "-i", ":default"];
+	}
+
+	let format = linuxFFmpegFormats.get(bin);
+	if (!format) {
+		const result = await $`${bin} -hide_banner -demuxers`.quiet().nothrow();
+		if (result.exitCode !== 0) {
+			const stderr = result.stderr.toString().trim();
+			throw new Error(
+				`Could not inspect ffmpeg input formats (code ${result.exitCode}): ${stderr || "(no output)"}`,
+			);
+		}
+		const demuxers = result.stdout.toString();
+		if (/^\s*D\s+(?:d\s+)?pulse(?:\s|$)/m.test(demuxers)) {
+			format = "pulse";
+		} else if (/^\s*D\s+(?:d\s+)?alsa(?:\s|$)/m.test(demuxers)) {
+			format = "alsa";
+		} else {
+			throw new Error("ffmpeg supports neither PulseAudio nor ALSA input on Linux");
+		}
+		linuxFFmpegFormats.set(bin, format);
+	}
+	return ["-f", format, "-i", "default"];
+}
+
 // ── Recording implementations ──────────────────────────────────────
 
 async function startSoxRecording(bin: string, outputPath: string): Promise<RecordingHandle> {
@@ -44,7 +76,7 @@ async function startSoxRecording(bin: string, outputPath: string): Promise<Recor
 
 	const proc = Bun.spawn([bin, ...inputArgs, "-r", "16000", "-c", "1", "-b", "16", "-t", "wav", outputPath], {
 		stdout: "pipe",
-		stderr: "ignore",
+		stderr: "pipe",
 	});
 	await verifyProcessAlive(proc, "sox");
 	return {
@@ -56,48 +88,24 @@ async function startSoxRecording(bin: string, outputPath: string): Promise<Recor
 }
 
 async function startFFmpegRecording(bin: string, outputPath: string): Promise<RecordingHandle> {
-	let args: string[];
-	if (isWindows) {
-		const device = await detectWindowsAudioDevice(bin);
-		args = [
-			bin,
-			"-f",
-			"dshow",
-			"-i",
-			`audio=${device}`,
-			"-ar",
-			"16000",
-			"-ac",
-			"1",
-			"-sample_fmt",
-			"s16",
-			"-y",
-			outputPath,
-		];
-	} else if (process.platform === "darwin") {
-		args = [
-			bin,
-			"-f",
-			"avfoundation",
-			"-i",
-			":default",
-			"-ar",
-			"16000",
-			"-ac",
-			"1",
-			"-sample_fmt",
-			"s16",
-			"-y",
-			outputPath,
-		];
-	} else {
-		args = [bin, "-f", "pulse", "-i", "default", "-ar", "16000", "-ac", "1", "-sample_fmt", "s16", "-y", outputPath];
-	}
+	const args = [
+		bin,
+		...ffmpegCaptureFlags,
+		...(await ffmpegInputArgs(bin)),
+		"-ar",
+		"16000",
+		"-ac",
+		"1",
+		"-sample_fmt",
+		"s16",
+		"-y",
+		outputPath,
+	];
 
 	const proc = Bun.spawn(args, {
 		stdin: "pipe",
 		stdout: "pipe",
-		stderr: "ignore",
+		stderr: "pipe",
 	});
 	await verifyProcessAlive(proc, "ffmpeg");
 
@@ -119,7 +127,7 @@ async function startFFmpegRecording(bin: string, outputPath: string): Promise<Re
 async function startArecordRecording(bin: string, outputPath: string): Promise<RecordingHandle> {
 	const proc = Bun.spawn([bin, "-f", "S16_LE", "-r", "16000", "-c", "1", outputPath], {
 		stdout: "pipe",
-		stderr: "ignore",
+		stderr: "pipe",
 	});
 	await verifyProcessAlive(proc, "arecord");
 	return {
@@ -260,20 +268,19 @@ async function startPowerShellRecording(outputPath: string): Promise<RecordingHa
 
 // ── Health check ───────────────────────────────────────────────────
 
-type RecorderProcess = Subprocess<"ignore" | "pipe", "pipe", "ignore">;
+type RecorderProcess = Subprocess<"ignore" | "pipe", "pipe", "pipe">;
 
 async function verifyProcessAlive(proc: RecorderProcess, tool: string): Promise<void> {
 	await Bun.sleep(300);
 
 	const exited = await Promise.race([proc.exited.then(code => code), Bun.sleep(0).then(() => "running" as const)]);
-
-	if (exited !== "running") {
-		let stderr = "";
-		if (proc.stderr && typeof proc.stderr !== "number") {
-			stderr = await new Response(proc.stderr as ReadableStream).text();
-		}
-		throw new Error(`${tool} exited immediately (code ${exited}): ${stderr.trim() || "(no output)"}`);
+	if (exited === "running") {
+		void proc.stderr.pipeTo(new WritableStream<Uint8Array>()).catch(() => {});
+		return;
 	}
+
+	const stderr = await new Response(proc.stderr).text();
+	throw new Error(`${tool} exited immediately (code ${exited}): ${stderr.trim() || "(no output)"}`);
 }
 
 // ── Public API ─────────────────────────────────────────────────────
@@ -415,12 +422,18 @@ async function streamingRecorderArgs(recorder: ResolvedRecorder): Promise<string
 		case "arecord":
 			return [bin, "-f", "S16_LE", "-r", "16000", "-c", "1", "-t", "raw", "-"];
 		case "ffmpeg": {
-			const input = isWindows
-				? ["-f", "dshow", "-i", `audio=${await detectWindowsAudioDevice(bin)}`]
-				: process.platform === "darwin"
-					? ["-f", "avfoundation", "-i", ":default"]
-					: ["-f", "pulse", "-i", "default"];
-			return [bin, ...input, "-ar", "16000", "-ac", "1", "-f", "s16le", "pipe:1"];
+			return [
+				bin,
+				...ffmpegCaptureFlags,
+				...(await ffmpegInputArgs(bin)),
+				"-ar",
+				"16000",
+				"-ac",
+				"1",
+				"-f",
+				"s16le",
+				"pipe:1",
+			];
 		}
 		case "powershell":
 			throw new Error("PowerShell recorder cannot stream PCM to a pipe");
@@ -439,7 +452,7 @@ async function startStreamingRecordingWithRecorder(
 ): Promise<StreamingRecordingHandle> {
 	const args = await streamingRecorderArgs(recorder);
 	logger.debug("Starting streaming audio recording", { tool: recorder.tool, bin: recorder.bin });
-	const proc = Bun.spawn(args, { stdin: "pipe", stdout: "pipe", stderr: "ignore" });
+	const proc = Bun.spawn(args, { stdin: "pipe", stdout: "pipe", stderr: "pipe" });
 
 	// Read s16le bytes off stdout, carrying any trailing odd byte across chunk
 	// boundaries so a sample is never split. Runs until the process closes stdout.

package/src/task/types.ts

@@ -106,11 +106,14 @@ export interface SubagentLifecyclePayload {
 /** Display cap for a normalized one-line label (roster line, registry `displayName`, prompt field). */
 export const LABEL_MAX = 80;
 
+// Keep this explicit: ArkType serializes `unknown` as a boolean subschema, which llama.cpp grammars reject.
+const outputSchemaInputSchema = type("object | boolean | string | null");
+
 export const taskItemSchema = type({
 	"name?": "string",
 	agent: "string = 'task'",
 	task: "string",
-	"outputSchema?": "unknown",
+	"outputSchema?": outputSchemaInputSchema,
 	"schemaMode?": '"permissive" | "strict"',
 	"+": "delete",
 });
@@ -118,7 +121,7 @@ const taskItemSchemaIsolated = type({
 	"name?": "string",
 	agent: "string = 'task'",
 	task: "string",
-	"outputSchema?": "unknown",
+	"outputSchema?": outputSchemaInputSchema,
 	"schemaMode?": '"permissive" | "strict"',
 	"isolated?": "boolean",
 	"+": "delete",
@@ -144,7 +147,7 @@ export const taskSchema = type({
 	"name?": "string",
 	agent: "string = 'task'",
 	task: "string",
-	"outputSchema?": "unknown",
+	"outputSchema?": outputSchemaInputSchema,
 	"schemaMode?": '"permissive" | "strict"',
 	"isolated?": "boolean",
 	"+": "delete",
@@ -153,7 +156,7 @@ const taskSchemaNoIsolation = type({
 	"name?": "string",
 	agent: "string = 'task'",
 	task: "string",
-	"outputSchema?": "unknown",
+	"outputSchema?": outputSchemaInputSchema,
 	"schemaMode?": '"permissive" | "strict"',
 	"+": "delete",
 });
@@ -197,7 +200,7 @@ function createTaskSchema(options: {
 				"name?": "string",
 				agent,
 				task: "string",
-				"outputSchema?": "unknown",
+				"outputSchema?": outputSchemaInputSchema,
 				"schemaMode?": '"permissive" | "strict"',
 				"isolated?": "boolean",
 				"+": "delete",
@@ -212,7 +215,7 @@ function createTaskSchema(options: {
 			"name?": "string",
 			agent,
 			task: "string",
-			"outputSchema?": "unknown",
+			"outputSchema?": outputSchemaInputSchema,
 			"schemaMode?": '"permissive" | "strict"',
 			"+": "delete",
 		});
@@ -227,7 +230,7 @@ function createTaskSchema(options: {
 			"name?": "string",
 			agent,
 			task: "string",
-			"outputSchema?": "unknown",
+			"outputSchema?": outputSchemaInputSchema,
 			"schemaMode?": '"permissive" | "strict"',
 			"isolated?": "boolean",
 			"+": "delete",
@@ -237,7 +240,7 @@ function createTaskSchema(options: {
 		"name?": "string",
 		agent,
 		task: "string",
-		"outputSchema?": "unknown",
+		"outputSchema?": outputSchemaInputSchema,
 		"schemaMode?": '"permissive" | "strict"',
 		"+": "delete",
 	});