@oh-my-pi/pi-coding-agent 16.3.0 → 16.3.3

package/dist/types/tools/ast-grep.d.ts

@@ -7,7 +7,7 @@ import type { ToolSession } from ".";
 import type { OutputMeta } from "./output-meta";
 declare const astGrepSchema: import("arktype/internal/variants/object.ts").ObjectType<{
     pat: string;
-    paths: string[];
+    path?: string | undefined;
     skip?: number | undefined;
 }, {}>;
 export interface AstGrepToolDetails {
@@ -44,7 +44,7 @@ export declare class AstGrepTool implements AgentTool<typeof astGrepSchema, AstG
     readonly description: string;
     readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
         pat: string;
-        paths: string[];
+        path?: string | undefined;
         skip?: number | undefined;
     }, {}>;
     readonly strict = true;
@@ -55,6 +55,8 @@ export declare class AstGrepTool implements AgentTool<typeof astGrepSchema, AstG
 }
 interface AstGrepRenderArgs {
     pat?: string;
+    path?: string | string[];
+    /** Legacy pre-`path` argument name; kept so historical transcripts still render a scope. */
     paths?: string[];
     skip?: number;
 }

package/dist/types/tools/bash.d.ts

@@ -5,6 +5,33 @@ import { type Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";
 import { type OutputMeta } from "./output-meta";
 export declare const BASH_DEFAULT_PREVIEW_LINES = 10;
+/**
+ * Shape a shell command line for an ACP-conformant `terminal/create` request.
+ *
+ * ACP's `command` field is documented as the executable and `args` as its
+ * argv tail (see https://agentclientprotocol.com/protocol/v1/terminals), so a
+ * spec-conformant client `spawn(command, args)`s them directly — no implicit
+ * shell. A raw `bash` tool line ("git status && echo x | head") therefore has
+ * to be wrapped in an explicit shell invocation, otherwise the client tries
+ * to spawn the whole line as argv[0] and fails with `ENOENT` for anything
+ * containing a space, pipe, `&&`, redirect, or `$(...)`.
+ *
+ * The wrap reuses the same shell binary + args the local `bash-executor` would
+ * pick via `settings.getShellConfig()` — Git Bash / `bash.exe` on Windows,
+ * `$SHELL` (bash/zsh) with the `sh` fallback on POSIX — so the ACP path
+ * preserves `bash` tool semantics (`$VAR`, `$(...)`, `source`, POSIX quoting,
+ * `-l`) instead of dropping to `cmd.exe` on Windows. The agent host's shell
+ * path is used as a proxy for the client's, matching the near-universal
+ * ACP deployment shape of an editor spawning omp as a co-hosted subprocess.
+ */
+export declare function wrapShellLineForClientTerminal(line: string, shellConfig: {
+    shell: string;
+    args: string[];
+    prefix?: string | undefined;
+}): {
+    command: string;
+    args: string[];
+};
 /**
  * Bash patterns flagged as safety critical for approval policy.
  *

package/dist/types/tools/browser/render.d.ts

@@ -35,6 +35,8 @@ interface BrowserRenderContext {
     previewLines?: number;
 }
 export declare const browserToolRenderer: {
+    animatedPendingPreview: (args: unknown) => boolean;
+    animatedPartialResult: (args: unknown) => boolean;
     renderCall(args: BrowserRenderArgs, options: RenderResultOptions, theme: Theme): Component;
     renderResult(result: {
         content: Array<{

package/dist/types/tools/debug.d.ts

@@ -85,6 +85,7 @@ interface DebugToolDetails {
 interface DebugRenderArgs extends Partial<DebugParams> {
 }
 export declare const debugToolRenderer: {
+    animatedPartialResult: boolean;
     renderCall(args: DebugRenderArgs, _options: RenderResultOptions, theme: Theme): Component;
     renderResult(result: {
         content: Array<{

package/dist/types/tools/eval-render.d.ts

@@ -40,6 +40,8 @@ interface EvalRenderContext {
  */
 export declare function upsertStatusEvent(events: EvalStatusEvent[], event: EvalStatusEvent): void;
 export declare const evalToolRenderer: {
+    animatedPendingPreview: boolean;
+    animatedPartialResult: boolean;
     renderCall(args: EvalRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
     renderResult(result: {
         content: Array<{

package/dist/types/tools/glob.d.ts

@@ -7,7 +7,7 @@ import { type TruncationResult } from "../session/streaming-output";
 import type { ToolSession } from ".";
 import { type OutputMeta } from "./output-meta";
 declare const findSchema: import("arktype/internal/variants/object.ts").ObjectType<{
-    paths: string[];
+    path?: string | undefined;
     hidden?: boolean | undefined;
     gitignore?: boolean | undefined;
     limit?: number | undefined;
@@ -64,7 +64,7 @@ export declare class GlobTool implements AgentTool<typeof findSchema, GlobToolDe
     readonly label = "Glob";
     readonly description: string;
     readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
-        paths: string[];
+        path?: string | undefined;
         hidden?: boolean | undefined;
         gitignore?: boolean | undefined;
         limit?: number | undefined;
@@ -75,6 +75,8 @@ export declare class GlobTool implements AgentTool<typeof findSchema, GlobToolDe
     execute(_toolCallId: string, params: typeof findSchema.infer, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<GlobToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<GlobToolDetails>>;
 }
 interface GlobRenderArgs {
+    path?: string | string[];
+    /** Legacy pre-`path` argument name; kept so historical transcripts still render a scope. */
     paths?: string | string[];
     limit?: number;
 }

package/dist/types/tools/grep.d.ts

@@ -7,13 +7,12 @@ import type { ToolSession } from ".";
 import type { OutputMeta } from "./output-meta";
 declare const searchSchema: import("arktype/internal/variants/object.ts").ObjectType<{
     pattern: string;
-    paths?: string | string[] | undefined;
+    path?: string | undefined;
     case?: boolean | undefined;
     gitignore?: boolean | undefined;
     skip?: number | null | undefined;
 }, {}>;
 export type GrepToolInput = typeof searchSchema.infer;
-export declare function toPathList(input: string | string[] | undefined): string[];
 /** Maximum number of distinct files surfaced in a single response. The
  * agent paginates further pages via `skip`. */
 export declare const DEFAULT_FILE_LIMIT = 20;
@@ -66,7 +65,7 @@ export declare class GrepTool implements AgentTool<typeof searchSchema, GrepTool
     readonly description: string;
     readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
         pattern: string;
-        paths?: string | string[] | undefined;
+        path?: string | undefined;
         case?: boolean | undefined;
         gitignore?: boolean | undefined;
         skip?: number | null | undefined;
@@ -77,6 +76,8 @@ export declare class GrepTool implements AgentTool<typeof searchSchema, GrepTool
 }
 interface GrepRenderArgs {
     pattern: string;
+    path?: string | string[];
+    /** Legacy pre-`path` argument name; kept so historical transcripts still render a scope. */
     paths?: string | string[];
     case?: boolean;
     gitignore?: boolean;

package/dist/types/tools/path-utils.d.ts

@@ -117,6 +117,13 @@ export declare function formatPathRelativeToCwd(filePath: string, cwd: string, o
  */
 export declare function stripOuterDoubleQuotes(input: string): string;
 export declare function normalizePathLikeInput(input: string): string;
+/**
+ * Normalize a path argument that may arrive as a single string, a JSON-encoded
+ * string array (`'["a.ts"]'`), or an actual array into a flat `string[]`.
+ * Delimited single strings (`"a.ts b.ts"`) are left for
+ * {@link expandDelimitedPathEntries} to split.
+ */
+export declare function toPathList(input: string | string[] | undefined): string[];
 export declare function hasGlobPathChars(filePath: string): boolean;
 type PathEntrySplitter = (item: string) => {
     basePath: string;

package/dist/types/tools/renderers.d.ts

@@ -41,5 +41,29 @@ export type ToolRenderer = {
      * with the final render and may commit like any settled stream.
      */
     provisionalPartialResult?: boolean;
+    /**
+     * Whether the renderer's pending-call path visibly consumes
+     * `options.spinnerFrame`. Used to avoid scheduling repaint ticks for live
+     * partial calls whose bytes cannot change between spinner frames.
+     */
+    animatedPendingPreview?: boolean | ((args: unknown) => boolean);
+    /**
+     * Whether the renderer's partial-result path visibly consumes
+     * `options.spinnerFrame`.
+     */
+    animatedPartialResult?: boolean | ((args: unknown) => boolean);
+    /**
+     * Whether replacing a streamed pending placeholder with the first result
+     * requires a full viewport repaint. Use for merged renderers whose pending
+     * streamed args may have committed placeholder rows that the result render
+     * re-anchors instead of preserving.
+     */
+    forceFirstResultViewportRepaint?: boolean;
+    /**
+     * Whether settling a provisional partial result into the final render requires
+     * a full viewport repaint. Use when the result renderer changes chrome or
+     * frame topology at `options.isPartial: true -> false`.
+     */
+    forceResultViewportRepaintOnSettle?: boolean;
 };
 export declare const toolRenderers: Record<string, ToolRenderer>;

package/dist/types/tools/ssh.d.ts

@@ -55,7 +55,8 @@ interface SshRenderContext {
     totalVisualLines?: number;
 }
 export declare const sshToolRenderer: {
-    renderCall(args: SshRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    animatedPendingPreview: boolean;
+    renderCall(args: SshRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
     renderResult(result: {
         content: Array<{
             type: string;
@@ -69,5 +70,7 @@ export declare const sshToolRenderer: {
     mergeCallAndResult: boolean;
     provisionalPendingPreview: boolean;
     provisionalPartialResult: boolean;
+    forceFirstResultViewportRepaint: boolean;
+    forceResultViewportRepaintOnSettle: boolean;
 };
 export {};

package/dist/types/tts/index.d.ts

@@ -1,6 +1,8 @@
 export * from "./downloader";
 export * from "./models";
 export * from "./runtime";
+export * from "./speakable";
+export * from "./speech-enhancer";
 export * from "./tts-client";
 export * from "./tts-protocol";
 export * from "./tts-worker";

package/dist/types/tts/speakable.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Streaming markdown → speakable-segment transform for assistant speech.
+ *
+ * Sits between the assistant's raw streaming text deltas and the TTS engine,
+ * deciding both *what* is worth speaking and *when* a piece of text is ready
+ * to synthesize. Three passes:
+ *
+ * 1. Block pass (per character, stateful): drops fenced code blocks and table
+ *    rows, strips heading/bullet/blockquote markers (numbered-list markers are
+ *    spoken as "1, …"), and turns newlines into hard segment breaks.
+ * 2. Segmentation (stateful): emits a segment the moment a sentence boundary
+ *    appears — no next-sentence confirmation, which is what made the previous
+ *    engine-side splitter stall a full sentence behind generation. The first
+ *    segment cuts early at a clause boundary for fast time-to-first-audio, and
+ *    over-long unpunctuated runs are force-split so no segment exceeds the
+ *    synthesizer's input budget.
+ * 3. Inline normalization (per segment): markdown links speak their label,
+ *    bare URLs speak their host, inline-code ticks and emphasis markers are
+ *    stripped, multi-directory file paths collapse to their basename, HTML
+ *    tags are dropped, and whitespace is collapsed. Segments with no letters
+ *    or digits left are not spoken at all.
+ *
+ * Pure and synchronous — the vocalizer owns timers (idle flush) and the
+ * session lifecycle, so this class stays trivially unit-testable.
+ */
+/**
+ * One per utterance. Feed raw assistant deltas through {@link push}; each call
+ * returns the segments that became ready to speak. {@link flush} drains the
+ * remainder at message end; {@link flushIdle} drains it when generation stalls
+ * mid-sentence so speech doesn't sit on buffered text through a tool call.
+ */
+export declare class SpeakableStream {
+    #private;
+    /** Consume a raw delta; returns segments now ready to speak, in order. */
+    push(delta: string): string[];
+    /** Message end: drain everything left, including a trailing partial sentence. */
+    flush(): string[];
+    /**
+     * Generation stalled (tool call, thinking block): speak what we have rather
+     * than sit silent on buffered text. Keeps block state so the stream resumes
+     * afterwards, and refuses stubby mid-sentence fragments — the buffer must be
+     * a complete thought (trailing sentence punctuation) or at least
+     * {@link MIN_SEGMENT} long, so a stall right after "The" stays silent
+     * instead of turning into choppy one-word speech.
+     */
+    flushIdle(): string[];
+}

package/dist/types/tts/speech-enhancer.d.ts

@@ -0,0 +1,46 @@
+import type { ModelRegistry } from "../config/model-registry";
+import type { Settings } from "../config/settings";
+/** Session-scoped dependencies; mirrors the auto-thinking classifier's deps. */
+export interface SpeechEnhancerDeps {
+    settings: Settings;
+    registry: ModelRegistry;
+    sessionId: string;
+    metadataResolver?: (provider: string) => Record<string, unknown> | undefined;
+}
+/**
+ * Rewrites one markdown block into spoken prose via the tiny/smol role.
+ * Constructed per session by the event controller and handed to the vocalizer.
+ */
+export declare class SpeechEnhancer {
+    #private;
+    constructor(deps: SpeechEnhancerDeps);
+    /**
+     * Rewrite `block` for speech. Returns the spoken text (empty string when
+     * the model judged the block unspeakable — pure code/markup), or null when
+     * the rewrite failed, timed out, or no model/key resolved; the caller then
+     * falls back to mechanical normalization.
+     */
+    rewrite(block: string, signal?: AbortSignal): Promise<string | null>;
+}
+/**
+ * Fence-aware paragraph accumulator over raw streaming deltas. One instance
+ * per utterance.
+ */
+export declare class BlockAccumulator {
+    #private;
+    /** Feed a delta; returns the blocks it completed, in order. */
+    push(delta: string): string[];
+    /**
+     * Message end: drain everything. An unterminated code fence is dropped from
+     * its opening line onward (a truncated block is never worth speaking); the
+     * prose before it still comes out.
+     */
+    flush(): string | null;
+    /**
+     * Generation stalled: drain the pending partial block — unless we are
+     * inside a code fence, where the only thing buffered is code and speaking
+     * or rewriting half a fence would re-introduce vocalized code. Fence state
+     * is preserved so the eventual closing fence still matches.
+     */
+    flushPartial(): string | null;
+}

package/dist/types/tts/streaming-player.d.ts

@@ -12,8 +12,7 @@ export interface StreamingPlayerLookup {
  * and plays it to the default output device. An empty list means no streaming
  * backend is available and the caller should fall back to per-file playback.
  *
- * - darwin: none; `afplay` is file-only, so macOS uses the interruptible
- *   per-file fallback.
+ * - darwin: `ffmpeg` (AudioToolbox output device) → sox's `play` (coreaudio).
  * - linux/other POSIX: `ffmpeg` (`-f pulse` then `-f alsa`) → `paplay`/`aplay`
  *   raw fallbacks.
  * - win32: none (PowerShell `SoundPlayer` is file-only).

package/dist/types/tts/tts-client.d.ts

@@ -17,7 +17,7 @@ export interface TtsStreamOptions {
     voice?: string;
     signal?: AbortSignal;
 }
-/** One synthesized sentence of a streaming session, in emission order. */
+/** One synthesized segment of a streaming session, in emission order. */
 export interface TtsAudioChunk {
     index: number;
     text: string;
@@ -25,10 +25,10 @@ export interface TtsAudioChunk {
     sampleRate: number;
 }
 /**
- * A live streaming-synthesis session. Feed text incrementally with {@link push}
- * and close the input with {@link end}; `chunks` yields each synthesized
- * sentence's audio as soon as it is ready, then completes once the worker
- * finishes draining the closed input.
+ * A live streaming-synthesis session. Feed complete speakable segments with
+ * {@link push} (the worker synthesizes each push as-is) and close the input
+ * with {@link end}; `chunks` yields each segment's audio as soon as it is
+ * ready, then completes once the worker finishes draining the closed input.
  */
 export interface TtsStreamHandle {
     push(text: string): void;
@@ -51,11 +51,12 @@ export declare class TtsClient {
     onProgress(listener: (event: TtsProgressEvent) => void): () => void;
     synthesize(modelKey: string, text: string, options?: TtsSynthesizeOptions): Promise<TtsAudio | null>;
     /**
-     * Open a streaming-synthesis session. Text is fed incrementally through the
-     * returned handle's `push`/`end`; audio is emitted one synthesized sentence at
-     * a time via `chunks`, so playback can begin before the full text is known.
-     * Returns an inert handle (immediately-ended `chunks`) for unknown models or
-     * an already-aborted signal, and fails the iterator if the worker cannot spawn.
+     * Open a streaming-synthesis session. Complete speakable segments are fed
+     * through the returned handle's `push`/`end`; audio is emitted one segment
+     * at a time via `chunks`, so playback can begin before the full text is
+     * known. Returns an inert handle (immediately-ended `chunks`) for unknown
+     * models or an already-aborted signal, and fails the iterator if the worker
+     * cannot spawn.
      */
     synthesizeStream(modelKey: string, options?: TtsStreamOptions): TtsStreamHandle;
     downloadModel(modelKey: string, options?: TtsDownloadOptions): Promise<boolean>;

package/dist/types/tts/tts-protocol.d.ts

@@ -91,5 +91,12 @@ export type TtsWorkerOutbound = {
  */
 export interface TtsTransport {
     send(message: TtsWorkerOutbound): void;
+    /**
+     * Send and resolve once the message has drained into the IPC channel.
+     * Streaming synthesis awaits this per audio chunk: ONNX inference blocks
+     * the worker's event loop for seconds at a time, so fire-and-forget sends
+     * queue unflushed until the session ends and arrive as one burst.
+     */
+    sendAndFlush(message: TtsWorkerOutbound): Promise<void>;
     onMessage(handler: (message: TtsWorkerInbound) => void): () => void;
 }

package/dist/types/tts/vocalizer.d.ts

@@ -1,3 +1,4 @@
+import { type SpeechEnhancer } from "./speech-enhancer";
 export interface VocalizerPlayer {
     start(sampleRate: number): void;
     write(pcm: Float32Array): void;
@@ -8,16 +9,22 @@ export interface VocalizerPlayer {
 export declare class Vocalizer {
     #private;
     constructor(createPlayer?: () => VocalizerPlayer);
+    /** Wire (or drop) the per-session enhanced-rewrite service. */
+    setEnhancer(enhancer: SpeechEnhancer | null): void;
     /**
-     * Stream a delta of assistant text into the engine. No-op when vocalization
-     * is disabled. The engine buffers the running text and emits audio for each
-     * complete sentence; the trailing partial is flushed by {@link flush}.
+     * Stream a delta of assistant text into the pipeline. No-op when
+     * vocalization is disabled. The synthesis session (worker, player) is only
+     * opened once the first speakable segment exists, so a reply that
+     * normalizes to silence (pure code, tables, URLs) costs nothing. The
+     * trailing partial is flushed by {@link flush} or the idle timer. The
+     * pipeline (enhanced vs mechanical) is latched per utterance.
      */
     pushDelta(text: string): void;
     /**
-     * Close the current input stream (call at message/turn end). The engine
-     * flushes its trailing partial as a final chunk; the player keeps draining
-     * queued audio until it completes.
+     * Close the current input stream (call at message/turn end). Drains the
+     * trailing partial as final segments; in enhanced mode the session ends
+     * only after the last in-flight rewrite has pushed, while the next
+     * utterance may already be streaming.
      */
     flush(): void;
     /**
@@ -26,8 +33,8 @@ export declare class Vocalizer {
      */
     speak(text: string): void;
     /**
-     * Interrupt and drop the current session, killing in-flight playback and
-     * synthesis (new turn / user message / Esc interrupt). Audio stops at once.
+     * Interrupt and drop every utterance, killing in-flight playback, synthesis,
+     * and rewrites (new turn / user message / Esc interrupt). Audio stops at once.
      */
     clear(): void;
     /** Lower the volume while the user is speaking (push-to-talk), so speech doesn't drown them out. */

package/dist/types/utils/fetch-timeout.d.ts

@@ -0,0 +1,4 @@
+/** Create an abort signal that fires after a timeout and preserves caller cancellation. */
+export declare function withTimeoutSignal(timeoutMs: number, signal?: AbortSignal): AbortSignal;
+/** Detect a timeout raised by an abortable fetch. */
+export declare function isTimeoutError(error: unknown): boolean;

package/dist/types/utils/git.d.ts

@@ -385,6 +385,8 @@ export declare const ls: {
     }): Promise<string[]>;
     /** List untracked files (excludes ignored). */
     untracked(cwd: string, signal?: AbortSignal): Promise<string[]>;
+    /** List paths present in a ref, optionally filtered to specific paths. */
+    tree(cwd: string, ref: string, files?: readonly string[], signal?: AbortSignal): Promise<string[]>;
     /** List submodule paths (recursive). */
     submodules(cwd: string, signal?: AbortSignal): Promise<string[]>;
 };

package/dist/types/web/search/providers/base.d.ts

@@ -51,6 +51,7 @@ export interface SearchParams {
      */
     sessionId?: string;
     antigravityEndpointMode?: "auto" | "production" | "sandbox";
+    geminiModel?: string;
 }
 /** Base class for web search providers. */
 export declare abstract class SearchProvider {

package/dist/types/web/search/providers/gemini.d.ts

@@ -32,6 +32,7 @@ export interface GeminiSearchParams extends GeminiToolParams {
     sessionId?: string;
     fetch?: FetchImpl;
     antigravityEndpointMode?: "auto" | "production" | "sandbox";
+    geminiModel?: string;
 }
 export declare function buildGeminiRequestTools(params: GeminiToolParams): Array<Record<string, Record<string, unknown>>>;
 /** First configured Gemini OAuth provider plus its pre-resolved access. */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.3.0",
+	"version": "16.3.3",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -56,17 +56,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.3.0",
-		"@oh-my-pi/omp-stats": "16.3.0",
-		"@oh-my-pi/pi-agent-core": "16.3.0",
-		"@oh-my-pi/pi-ai": "16.3.0",
-		"@oh-my-pi/pi-catalog": "16.3.0",
-		"@oh-my-pi/pi-mnemopi": "16.3.0",
-		"@oh-my-pi/pi-natives": "16.3.0",
-		"@oh-my-pi/pi-tui": "16.3.0",
-		"@oh-my-pi/pi-utils": "16.3.0",
-		"@oh-my-pi/pi-wire": "16.3.0",
-		"@oh-my-pi/snapcompact": "16.3.0",
+		"@oh-my-pi/hashline": "16.3.3",
+		"@oh-my-pi/omp-stats": "16.3.3",
+		"@oh-my-pi/pi-agent-core": "16.3.3",
+		"@oh-my-pi/pi-ai": "16.3.3",
+		"@oh-my-pi/pi-catalog": "16.3.3",
+		"@oh-my-pi/pi-mnemopi": "16.3.3",
+		"@oh-my-pi/pi-natives": "16.3.3",
+		"@oh-my-pi/pi-tui": "16.3.3",
+		"@oh-my-pi/pi-utils": "16.3.3",
+		"@oh-my-pi/pi-wire": "16.3.3",
+		"@oh-my-pi/snapcompact": "16.3.3",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/scripts/generate-legacy-pi-bundled-registry.ts

@@ -332,9 +332,15 @@ async function formatInPlace(targets: readonly string[]): Promise<void> {
 		stdout: "pipe",
 		stderr: "pipe",
 	});
-	const exit = await proc.exited;
+	// Drain both pipes concurrently with proc.exited to avoid a pipe-buffer
+	// deadlock — biome check can emit thousands of lines when it rewrites the
+	// generated registry, easily exceeding the ~64 KiB OS pipe buffer.
+	const [exit, , stderr] = await Promise.all([
+		proc.exited,
+		new Response(proc.stdout).text(),
+		new Response(proc.stderr).text(),
+	]);
 	if (exit !== 0) {
-		const stderr = await new Response(proc.stderr).text();
 		throw new Error(`biome check --write failed (exit ${exit}): ${stderr}`);
 	}
 }

package/src/advisor/__tests__/advisor.test.ts

@@ -41,7 +41,7 @@ describe("advisor", () => {
 							type: "toolCall",
 							id: "search-timeout",
 							name: "grep",
-							arguments: { pattern: "needle", paths: ["packages/coding-agent/src"] },
+							arguments: { pattern: "needle", path: "packages/coding-agent/src" },
 						},
 					],
 					timestamp: 1,

package/src/cli/gallery-fixtures/fs.ts

@@ -182,8 +182,8 @@ export const fsFixtures: Record<string, GalleryFixture> = {
 	glob: {
 		label: "Glob",
 		// Streaming: glob half-typed, no limit yet.
-		streamingArgs: { paths: ["packages/coding-agent/src/tools/*-render"] },
-		args: { paths: ["packages/coding-agent/src/**/*.test.ts"], limit: 50 },
+		streamingArgs: { path: "packages/coding-agent/src/tools/*-render" },
+		args: { path: "packages/coding-agent/src/**/*.test.ts", limit: 50 },
 		result: {
 			content: [
 				{

package/src/cli/gallery-fixtures/search.ts

@@ -9,7 +9,7 @@ export const searchFixtures: Record<string, GalleryFixture> = {
 		},
 		args: {
 			pattern: "useState",
-			paths: ["packages/tui/src"],
+			path: "packages/tui/src",
 		},
 		result: {
 			content: [
@@ -160,7 +160,7 @@ export const searchFixtures: Record<string, GalleryFixture> = {
 		},
 		args: {
 			pat: "useState($A)",
-			paths: ["packages/tui/src/components"],
+			path: "packages/tui/src/components",
 		},
 		result: {
 			content: [

package/src/cli/models-cli.ts

@@ -84,6 +84,14 @@ function writeLine(line = ""): void {
 	process.stdout.write(`${line}\n`);
 }
 
+function writeModelsConfigError(error: Error): void {
+	writeLine(chalk.yellow("Warning: models.yml validation failed — custom providers disabled"));
+	for (const line of error.message.split("\n")) {
+		writeLine(`  ${line}`);
+	}
+	writeLine();
+}
+
 function formatLimit(n: number | null): string {
 	return n === null ? "-" : formatNumber(n);
 }
@@ -187,12 +195,23 @@ function renderProviderModels(
 		}
 	}
 
+	const configError = modelRegistry.getError();
+
 	if (json) {
+		if (configError) {
+			process.stderr.write(
+				`Warning: models.yml validation failed — custom providers disabled\n${configError.message}\n`,
+			);
+		}
 		const output: ModelsJson = { models: filtered.slice().sort(byProviderThenId).map(toModelJson) };
 		writeLine(JSON.stringify(output));
 		return;
 	}
 
+	if (configError) {
+		writeModelsConfigError(configError);
+	}
+
 	if (available.length === 0) {
 		writeLine("No models available. Set API keys in environment variables.");
 		return;

package/src/cli/update-cli.test.ts

@@ -0,0 +1,28 @@
+import { afterEach, describe, expect, it, vi } from "bun:test";
+import { runUpdateCommand } from "./update-cli";
+
+type FetchInput = string | URL | Request;
+type FetchInit = RequestInit | BunFetchRequestInit;
+
+describe("runUpdateCommand fetch cancellation", () => {
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	it("checks release metadata with a timeout signal", async () => {
+		let requestSignal: AbortSignal | undefined;
+		vi.spyOn(console, "log").mockImplementation(() => {});
+		const fetchStub = Object.assign(
+			async (_input: FetchInput, init?: FetchInit) => {
+				requestSignal = init?.signal ?? undefined;
+				return Response.json({ version: "999.0.0" });
+			},
+			{ preconnect: globalThis.fetch.preconnect },
+		);
+		vi.spyOn(globalThis, "fetch").mockImplementation(fetchStub);
+
+		await runUpdateCommand({ force: false, check: true });
+
+		expect(requestSignal).toBeInstanceOf(AbortSignal);
+	});
+});