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

package/dist/types/config/settings-schema.d.ts

@@ -4752,6 +4752,16 @@ export declare const SETTINGS_SCHEMA: {
             }];
         };
     };
+    readonly "speech.enhanced": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "providers";
+            readonly group: "Services";
+            readonly label: "Enhanced Speech Rewriting";
+            readonly description: "Rewrite assistant output into natural spoken prose with the tiny/smol model before synthesis (describes code, drops links and markdown). Falls back to mechanical cleanup on failure";
+        };
+    };
     readonly "speech.voice": {
         readonly type: "enum";
         readonly values: readonly string[];

package/dist/types/discovery/helpers.d.ts

@@ -236,6 +236,8 @@ export declare function resolveActiveProjectRegistryPath(cwd: string): Promise<s
  * never alias as the project registry.
  */
 export declare function resolveOrDefaultProjectRegistryPath(cwd: string): Promise<string | undefined>;
+/** Register a process-global plugin cache invalidator called whenever plugin roots are cleared. */
+export declare function registerPluginCacheInvalidator(invalidator: () => void): void;
 /**
  * List all installed Claude Code plugin roots from the plugin cache.
  * Reads ~/.claude/plugins/installed_plugins.json and ~/.omp/plugins/installed_plugins.json,

package/dist/types/irc/bus.d.ts

@@ -8,10 +8,11 @@
  * agents receive the message as a non-interrupting aside at the next step
  * boundary (see AgentSession.deliverIrcMessage). Replies are real turns by
  * the recipient, observed via `wait` — with one exception: when the sender
- * awaits a reply and the recipient is mid-turn with async execution
- * disabled, the recipient session generates an ephemeral side-channel
- * auto-reply (it may be blocked in a synchronous task spawn whose batch
- * includes the sender, so a real turn could never happen in time).
+ * awaits a reply and the recipient cannot run a real reply turn in time
+ * (mid-turn with async execution disabled — possibly blocked in a
+ * synchronous task spawn whose batch includes the sender — or idle in plan
+ * mode, where autonomous wake turns are suppressed), the recipient session
+ * generates an ephemeral side-channel auto-reply.
  */
 import { AgentLifecycleManager } from "../registry/agent-lifecycle";
 import { AgentRegistry } from "../registry/agent-registry";

package/dist/types/session/agent-session.d.ts

@@ -882,12 +882,10 @@ export declare class AgentSession {
     /**
      * Set model directly.
      * Validates that a credential source is configured (synchronously, without
-     * refreshing OAuth or running command-backed key programs). The active
-     * session switches by default; when `currentContextTokens` is provided and
-     * exceeds the refreshed candidate's context window, the live switch is
-     * skipped while role persistence still runs. Returns whether the active
-     * model actually switched, computed against the refreshed metadata so
-     * dynamic providers (e.g. llama.cpp) honor their post-load contextWindow.
+     * refreshing OAuth or running command-backed key programs). Active switches
+     * always take effect; if the current transcript is too large for the target
+     * model, the next prompt's compaction/error path owns that recovery instead
+     * of leaving the session pinned to the old model.
      * @throws Error if no API key available for the model
      */
     setModel(model: Model, role?: string, options?: {
@@ -1163,18 +1161,20 @@ export declare class AgentSession {
      *
      * - mid-turn → queued on the aside channel and folded in at the next step
      *   boundary (non-interrupting, like async-result deliveries) → "injected";
+     * - idle in plan mode → appended into context without waking an autonomous
+     *   turn (convergence stays user-driven) → "injected";
      * - idle → starts a real turn with the message so the recipient wakes
      *   → "woken".
      *
      * Never blocks on the recipient's turn: the wake turn is fire-and-forget.
      *
-     * When the sender expects a reply (`send await:true`) and this session is
-     * mid-turn with async execution disabled, the next step boundary may be
-     * gated on the sender's own batch finishing (blocking task spawns), so a
-     * real reply turn can never happen in time. In that case an ephemeral
-     * side-channel auto-reply is generated from the current context (the old
-     * `respondAsBackground` path) and sent back over the bus on this agent's
-     * behalf.
+     * When the sender expects a reply (`send await:true`) and this session
+     * cannot produce a real reply turn in time — mid-turn with async execution
+     * disabled (the next step boundary may be gated on the sender's own batch
+     * finishing), or idle in plan mode (wake turns are suppressed) — an
+     * ephemeral side-channel auto-reply is generated from the current context
+     * (the old `respondAsBackground` path) and sent back over the bus on this
+     * agent's behalf.
      */
     deliverIrcMessage(msg: IrcMessage, opts?: {
         expectsReply?: boolean;

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

@@ -6,8 +6,11 @@ export interface DiscoveryResult {
 }
 /**
  * Discover agents from filesystem and merge with bundled agents.
- *
- * Precedence (highest wins): project .omp, user .omp, Claude plugin agents, then bundled
+ * Precedence (highest wins): project `.omp/agents`, user `.omp/agents`,
+ * OMP extension-package agents in `listOmpExtensionRoots` source order
+ * (CLI roots > project `extensions:` settings > user `extensions:` settings >
+ * installed npm/link plugins), Claude marketplace plugin agents (project
+ * scope before user), then bundled.
  * @param cwd - Current working directory for project agent discovery
  */
 export declare function discoverAgents(cwd: string, home?: string): Promise<DiscoveryResult>;

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

@@ -10,4 +10,5 @@ export declare const taskToolRenderer: {
     readonly renderCall: typeof renderCall;
     readonly renderResult: typeof renderResult;
     readonly mergeCallAndResult: true;
+    readonly animatedPartialResult: true;
 };

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/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,16 @@ 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);
 };
 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;

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/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/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.3.0",
+	"version": "16.3.2",
 	"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.2",
+		"@oh-my-pi/omp-stats": "16.3.2",
+		"@oh-my-pi/pi-agent-core": "16.3.2",
+		"@oh-my-pi/pi-ai": "16.3.2",
+		"@oh-my-pi/pi-catalog": "16.3.2",
+		"@oh-my-pi/pi-mnemopi": "16.3.2",
+		"@oh-my-pi/pi-natives": "16.3.2",
+		"@oh-my-pi/pi-tui": "16.3.2",
+		"@oh-my-pi/pi-utils": "16.3.2",
+		"@oh-my-pi/pi-wire": "16.3.2",
+		"@oh-my-pi/snapcompact": "16.3.2",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

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.ts

@@ -173,14 +173,20 @@ async function runWorkerEntrypoint(arg: string | undefined): Promise<boolean> {
  * worker is idle, and hard-kills the process on parent `disconnect`.
  */
 async function runIpcSubprocessWorker<In, Out>(
-	start: (transport: { send(message: Out): void; onMessage(handler: (message: In) => void): () => void }) => void,
+	start: (transport: {
+		send(message: Out): void;
+		sendAndFlush(message: Out): Promise<void>;
+		onMessage(handler: (message: In) => void): () => void;
+	}) => void,
 ): Promise<void> {
 	const { promise: shuttingDown, resolve: shutdown } = Promise.withResolvers<void>();
+	type IpcSend = (this: NodeJS.Process, message: unknown, callback?: (error: Error | null) => void) => boolean;
+	// `process.send` only exists when spawned with an IPC channel; the parent
+	// always spawns us that way. If it's missing, the parent vanished and
+	// there's no one to talk to.
+	const ipcSend = (): IpcSend | undefined => (process as NodeJS.Process & { send?: IpcSend }).send;
 	const send = (message: Out): void => {
-		// `process.send` only exists when spawned with an IPC channel; the
-		// parent always spawns us that way. If it's missing, the parent
-		// vanished and there's no one to talk to.
-		const sender = (process as NodeJS.Process & { send?: (m: unknown) => boolean }).send;
+		const sender = ipcSend();
 		if (!sender) {
 			shutdown();
 			return;
@@ -191,8 +197,24 @@ async function runIpcSubprocessWorker<In, Out>(
 			shutdown();
 		}
 	};
+	const sendAndFlush = (message: Out): Promise<void> => {
+		const sender = ipcSend();
+		if (!sender) {
+			shutdown();
+			return Promise.resolve();
+		}
+		const { promise, resolve } = Promise.withResolvers<void>();
+		try {
+			sender.call(process, message, () => resolve());
+		} catch {
+			shutdown();
+			resolve();
+		}
+		return promise;
+	};
 	start({
 		send,
+		sendAndFlush,
 		onMessage(handler) {
 			const wrap = (data: unknown): void => handler(data as In);
 			process.on("message", wrap);