@oh-my-pi/pi-coding-agent 16.1.2 → 16.1.4

package/dist/types/config/model-resolver.d.ts

@@ -201,9 +201,9 @@ export declare function resolveModelScope(patterns: string[], modelRegistry: Pic
  * the result to models matching those patterns.
  *
  * Returns the unfiltered available list when `enabledModels` is empty.
- * Returns an empty list when `enabledModels` is configured but no available
- * model matches any pattern — callers MUST treat this as "no usable model"
- * rather than falling back to the global default (see issue #1022).
+ * Returns an empty list when `enabledModels` is configured but no model matches
+ * any pattern — callers MUST treat this as "no usable model" rather than
+ * falling back to the global default (see issue #1022).
  */
 export declare function resolveAllowedModels(modelRegistry: Pick<ModelRegistry, "getAvailable" | "getCanonicalVariants">, settings: Settings | undefined, preferences?: ModelMatchPreferences): Promise<Model<Api>[]>;
 /**

package/dist/types/mnemopi/embed-client.d.ts

@@ -0,0 +1,70 @@
+import type { Subprocess } from "bun";
+import type { MnemopiEmbedModelId, MnemopiEmbedWorkerInbound, MnemopiEmbedWorkerOutbound } from "./embed-protocol";
+/**
+ * Abstraction over the mnemopi embeddings subprocess. The runtime
+ * implementation is a Bun child process so `onnxruntime-node`'s NAPI
+ * constructor + finalizer never run inside the main agent address space —
+ * those destructors segfault Bun on Windows when mnemopi's local embedding
+ * provider loads fastembed in the main process (issue #3031; the mnemopi
+ * sibling of the tiny-model fix from #1606 / #1607).
+ */
+export interface MnemopiEmbedWorkerHandle {
+    send(message: MnemopiEmbedWorkerInbound): void;
+    onMessage(handler: (message: MnemopiEmbedWorkerOutbound) => void): () => void;
+    onError(handler: (error: Error) => void): () => void;
+    terminate(): Promise<void>;
+}
+/**
+ * Hidden subcommand on the main CLI that boots the mnemopi embeddings worker
+ * in the spawned subprocess. Kept in sync with the dispatch in `cli.ts`.
+ */
+export declare const MNEMOPI_EMBED_WORKER_ARG = "__omp_worker_mnemopi_embed";
+interface SpawnedSubprocess {
+    proc: Subprocess<"ignore", "ignore", "ignore">;
+    inbound: Set<(message: MnemopiEmbedWorkerOutbound) => void>;
+    errors: Set<(error: Error) => void>;
+    /**
+     * Flipped to `true` right before the deliberate SIGKILL so `onExit` can
+     * distinguish the expected hard-kill from a crash (SIGSEGV from a native
+     * fault, OOM SIGKILL, operator `kill -9`). Only the latter surfaces as a
+     * worker error so callers don't await forever.
+     */
+    intentionalExit: {
+        value: boolean;
+    };
+}
+/**
+ * Spawn the mnemopi embeddings worker as a subprocess. Exported for tests and
+ * the smoke probe; production callers go through {@link spawnMnemopiEmbedWorker}.
+ */
+export declare function createMnemopiEmbedSubprocess(): SpawnedSubprocess;
+/**
+ * Per-model wrapper produced by {@link MnemopiEmbedClient.initialize}.
+ * `embed()` round-trips one batch of texts through the worker subprocess and
+ * yields the resulting vectors in a single asynchronous batch — fastembed's
+ * own iterator was emitting batches that we collect on the child side anyway,
+ * and serializing per-batch over IPC would not improve throughput.
+ */
+export interface MnemopiSubprocessEmbeddingModel {
+    embed(texts: string[], batchSize?: number): AsyncIterable<number[][]>;
+}
+export declare class MnemopiEmbedClient {
+    #private;
+    constructor(spawnWorker?: () => MnemopiEmbedWorkerHandle);
+    /**
+     * Load the named fastembed model inside the subprocess. Resolves to a
+     * thin wrapper whose `embed()` round-trips through the same worker, or
+     * `null` when the worker cannot init the model (missing peer, native
+     * load failure, etc.). Multiple calls with the same model reuse the
+     * single in-flight worker; calling with a different model loads it on
+     * the child without restarting the process.
+     */
+    initialize(model: MnemopiEmbedModelId, cacheDir: string | undefined): Promise<MnemopiSubprocessEmbeddingModel | null>;
+    terminate(): Promise<void>;
+}
+export declare const mnemopiEmbedClient: MnemopiEmbedClient;
+export declare function shutdownMnemopiEmbedClient(): Promise<void>;
+export declare function smokeTestMnemopiEmbedWorker({ timeoutMs, }?: {
+    timeoutMs?: number;
+}): Promise<void>;
+export {};

package/dist/types/mnemopi/embed-protocol.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Wire types between the parent (`MnemopiEmbedClient`) and the local
+ * embeddings subprocess. The parent owns the subprocess lifecycle (graceful
+ * work, hard `SIGKILL` on shutdown); the protocol carries no explicit close
+ * handshake — once the parent decides to terminate, it signals the OS to reap
+ * the child so `onnxruntime-node`'s NAPI finalizer never runs in the main
+ * agent address space (it crashes Bun on Windows shutdown — issue #3031, the
+ * mnemopi sibling of the tiny-model fix from #1606/#1607). See
+ * `embed-client.ts` for the spawn/kill glue.
+ */
+/** Identifier of the fastembed model the worker should load (e.g. `fast-bge-base-en-v1.5`). */
+export type MnemopiEmbedModelId = string;
+export type MnemopiEmbedWorkerInbound = {
+    type: "ping";
+    id: string;
+} | {
+    type: "init";
+    id: string;
+    model: MnemopiEmbedModelId;
+    cacheDir?: string;
+} | {
+    type: "embed";
+    id: string;
+    model: MnemopiEmbedModelId;
+    cacheDir?: string;
+    texts: string[];
+    batchSize?: number;
+};
+export type MnemopiEmbedWorkerOutbound = {
+    type: "pong";
+    id: string;
+} | {
+    type: "ready";
+    id: string;
+} | {
+    type: "vectors";
+    id: string;
+    vectors: number[][];
+} | {
+    type: "error";
+    id: string;
+    error: string;
+} | {
+    type: "log";
+    level: "debug" | "warn" | "error";
+    msg: string;
+    meta?: Record<string, unknown>;
+};
+export interface MnemopiEmbedTransport {
+    send(message: MnemopiEmbedWorkerOutbound): void;
+    onMessage(handler: (message: MnemopiEmbedWorkerInbound) => void): () => void;
+}

package/dist/types/mnemopi/embed-worker.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Mnemopi local-embeddings worker. Loaded inside the dedicated subprocess
+ * spawned by `embed-client.ts` (re-entered through the agent CLI's hidden
+ * `__omp_worker_mnemopi_embed` selector). The whole point of this module is
+ * that `loadFastembed()` — and therefore `onnxruntime-node`'s NAPI
+ * constructor + finalizer — only ever runs in this child address space. The
+ * parent `SIGKILL`s us on shutdown so the destructor that crashes Bun on
+ * Windows shutdown (issue #3031, mnemopi sibling of #1606/#1607) never runs
+ * in either process.
+ */
+import type { MnemopiEmbedTransport } from "./embed-protocol";
+export declare function startMnemopiEmbedWorker(transport: MnemopiEmbedTransport): void;

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

@@ -4,7 +4,15 @@ import type { Mnemopi, RecallResult } from "@oh-my-pi/pi-mnemopi";
 import type * as MnemopiCoreNs from "@oh-my-pi/pi-mnemopi/core";
 import type { AgentSession } from "../session/agent-session";
 import type { MnemopiBackendConfig } from "./config";
-/** Lazily load `@oh-my-pi/pi-mnemopi` (memoized). */
+/**
+ * Lazily load `@oh-my-pi/pi-mnemopi` (memoized) and route fastembed loads
+ * through the dedicated embeddings subprocess. The override is installed once
+ * — before any consumer gets the chance to call `embed()` — so
+ * `onnxruntime-node`'s NAPI constructor + finalizer never run inside the
+ * agent's address space (issue #3031). Test seams that swap the initializer
+ * with `setLocalModelInitializerForTests` still win because both go through
+ * the same module-level slot.
+ */
 export declare function loadMnemopi(): Promise<typeof MnemopiNs>;
 /** Lazily load `@oh-my-pi/pi-mnemopi/core` (memoized). */
 export declare function loadMnemopiCore(): Promise<typeof MnemopiCoreNs>;

package/dist/types/modes/components/cache-invalidation-marker.d.ts

@@ -6,20 +6,33 @@ export interface CacheInvalidation {
     reprocessedTokens: number;
 }
 /**
- * Decide whether `current` turn lost the prompt cache that `prev` established.
+ * Decide whether `current` turn lost a *working* prompt cache that `prev` was
+ * reusing.
  *
  * The provider reports a warm prefix as `cacheRead`; a model/thinking/tool/
  * system-prompt change (or a history rewrite) breaks the prefix, so the next
- * request reads nothing from cache and re-pays for the whole prompt. We detect
- * that as: the previous turn cached a meaningful prefix, yet this turn's
+ * request reads nothing from cache and re-pays for the whole prompt. We flag
+ * only the transition where a demonstrably warm cache goes cold: the previous
+ * turn must have actually READ a meaningful prefix back, and this turn's
  * `cacheRead` collapsed to zero while it still reprocessed a non-trivial prompt.
- * Returns `undefined` (no marker) for the first turn, tiny contexts, turns
- * that reused any cache, and — crucially — turns on providers with *implicit*
- * best-effort caching. Only an explicit, prefix-controlled cache (Anthropic /
- * Bedrock `cache_control`) re-creates the prefix on a cold turn (`cacheWrite >
- * 0`); implicit caches (Google / OpenAI / Fireworks) report `cacheWrite: 0` and
- * drop `cacheRead` to zero intermittently as routine propagation noise that
- * self-heals the next turn, so flagging it would be a false positive.
+ *
+ * Requiring a prior warm read is deliberate. A turn that merely WROTE the prefix
+ * (`cacheRead` 0) has not proven the cache is live — that is the session's first
+ * request, or a re-write after expiry — so a following cold turn there is
+ * expected, not an invalidation the user caused (e.g. a long-running first tool
+ * call outliving the provider's 5-minute cache TTL surfaced a spurious "cache
+ * miss" right under the opening message). It also collapses a run of consecutive
+ * cold turns to the single marker at the moment the cache actually broke, instead
+ * of repeating the banner on every turn while it re-warms.
+ *
+ * Returns `undefined` (no marker) for the first turn, turns whose predecessor
+ * never read a warm prefix, tiny contexts, turns that reused any cache, and —
+ * crucially — turns on providers with *implicit* best-effort caching. Only an
+ * explicit, prefix-controlled cache (Anthropic / Bedrock `cache_control`)
+ * re-creates the prefix on a cold turn (`cacheWrite > 0`); implicit caches
+ * (Google / OpenAI / Fireworks) report `cacheWrite: 0` and drop `cacheRead` to
+ * zero intermittently as routine propagation noise that self-heals the next
+ * turn, so flagging it would be a false positive.
  */
 export declare function detectCacheInvalidation(prev: Usage | undefined, current: Usage): CacheInvalidation | undefined;
 /**

package/dist/types/modes/components/status-line/component.d.ts

@@ -34,9 +34,8 @@ export declare class StatusLineComponent implements Component {
     dispose(): void;
     invalidate(): void;
     /**
-     * Background-refresh the Anthropic OAuth quota report. Guarded by a 5-min
-     * TTL on both success (cache lifetime) and error (backoff). Exposed
-     * (non-private) so unit tests can verify the backoff invariant.
+     * Startup redraws only arm a short-delayed task; timeout releases the render
+     * cadence while a late successful fetch can still refresh the cached segment.
      */
     refreshUsageInBackground(): void;
     /**

package/dist/types/sdk.d.ts

@@ -262,6 +262,18 @@ export declare function discoverSessionExtensionPaths(options: Pick<CreateAgentS
  * repeated. Keep this the single source of the discovery branch logic.
  */
 export declare function loadSessionExtensions(options: Pick<CreateAgentSessionOptions, "disableExtensionDiscovery" | "additionalExtensionPaths">, cwd: string, settings: Settings, eventBus: EventBus): Promise<LoadExtensionsResult>;
+/**
+ * Load discovered/configured extensions and register their providers into
+ * `modelRegistry`, then discover the dynamic provider catalogs. One-shot CLIs
+ * (`omp bench`, dry-balance) build a bare {@link ModelRegistry} that only knows
+ * built-in catalog providers; without this, providers contributed by an
+ * extension (e.g. a custom OpenAI-compatible provider under
+ * `~/.omp/agent/extensions/`) never reach model resolution. Mirrors the
+ * session / `omp models` path: drain the queued provider registrations, then
+ * `refreshRuntimeProviders` so dynamically-discovered models exist before
+ * selectors are resolved.
+ */
+export declare function loadCliExtensionProviders(modelRegistry: ModelRegistry, settings: Settings, cwd: string, options?: Pick<CreateAgentSessionOptions, "disableExtensionDiscovery" | "additionalExtensionPaths">): Promise<void>;
 /**
  * Discover skills from cwd and agentDir.
  */

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

@@ -399,6 +399,8 @@ export declare class AgentSession {
     nextToolChoiceDirective(): ToolChoiceDirective | undefined;
     /** Peek the head non-forcing pending preview invoker, for the `resolve` tool's dispatch. */
     peekPendingInvoker(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
+    /** Clear stale non-forcing pending preview invokers after `resolve` proves none can run. */
+    clearPendingInvokers(): void;
     /**
      * Force the next model call to target a specific active tool, then terminate
      * the agent loop. Pushes a two-step sequence [forced, "none"] so the model

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

@@ -16,6 +16,8 @@ export declare class AgentStorage {
      * @returns AgentStorage instance for the given path
      */
     static open(dbPath?: string): Promise<AgentStorage>;
+    /** @internal Reset all singletons and close their databases — test-only. */
+    static resetInstance(): void;
     /**
      * Reads legacy settings persisted in the agent.db `settings` table.
      * The canonical settings store is `config.yml`; this accessor only

package/dist/types/session/auth-broker-config.d.ts

@@ -20,7 +20,8 @@
  * `runRootCommand`, and we want hand-edited config entries to be honoured at
  * boot without forcing a startup reorder.
  */
-import { type AuthBrokerClientConfig, type DiscoverAuthStorageOptions, discoverAuthStorage as discoverAuthStorageShared, getAuthBrokerTokenFilePath } from "@oh-my-pi/pi-ai/auth-broker/discover";
+import { type AuthBrokerClientConfig, type DiscoverAuthStorageOptions, getAuthBrokerTokenFilePath } from "@oh-my-pi/pi-ai/auth-broker/discover";
+import type { AuthStorage } from "./auth-storage";
 export { type AuthBrokerClientConfig, getAuthBrokerTokenFilePath };
 /**
  * Read broker configuration. Returns null when the URL is missing
@@ -41,4 +42,4 @@ export declare function resolveAuthBrokerConfig(): Promise<AuthBrokerClientConfi
  *
  * Default `agentDir` is the current configured agent directory.
  */
-export declare function discoverAuthStorage(agentDir?: string, options?: Omit<DiscoverAuthStorageOptions, "agentDir" | "configValueResolver">): ReturnType<typeof discoverAuthStorageShared>;
+export declare function discoverAuthStorage(agentDir?: string, options?: Omit<DiscoverAuthStorageOptions, "agentDir" | "configValueResolver">): Promise<AuthStorage>;

package/dist/types/session/history-storage.d.ts

@@ -10,7 +10,7 @@ export declare class HistoryStorage {
     #private;
     private constructor();
     static open(dbPath?: string): HistoryStorage;
-    /** @internal Reset the singleton — test-only. */
+    /** @internal Reset the singleton and close its database — test-only. */
     static resetInstance(): void;
     /**
      * Register a resolver that supplies the current session ID for prompts added

package/dist/types/session/tool-choice-queue.d.ts

@@ -71,6 +71,8 @@ export declare class ToolChoiceQueue {
     registerPendingInvoker(id: string, sourceToolName: string, onInvoked: (input: unknown) => Promise<unknown> | unknown): void;
     /** Drop the pending invoker with this id (e.g. after it resolves). */
     removePendingInvoker(id: string): void;
+    /** Drop every pending preview invoker without touching hard tool-choice directives. */
+    clearPendingInvokers(): void;
     /** True when at least one non-forcing pending preview is registered. */
     get hasPendingInvoker(): boolean;
     /** The head (most-recently registered) pending invoker's handler, for resolve dispatch. */

package/dist/types/tools/image-gen.d.ts

@@ -61,6 +61,6 @@ export declare function isImageProviderPreference(value: unknown): value is Imag
 /** Set the preferred image provider from settings */
 export declare function setPreferredImageProvider(provider: ImageProviderPreference): void;
 export declare const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails>;
-export declare function getImageGenTools(modelRegistry?: ModelRegistry, activeModel?: Model): Promise<Array<CustomTool<typeof imageGenSchema, ImageGenToolDetails>>>;
-export declare function getImageGenToolsWithRegistry(modelRegistry: ModelRegistry, activeModel?: Model): Promise<Array<CustomTool<typeof imageGenSchema, ImageGenToolDetails>>>;
+export declare function getImageGenTools(_modelRegistry?: ModelRegistry, _activeModel?: Model): Promise<Array<CustomTool<typeof imageGenSchema, ImageGenToolDetails>>>;
+export declare function getImageGenToolsWithRegistry(_modelRegistry: ModelRegistry, _activeModel?: Model): Promise<Array<CustomTool<typeof imageGenSchema, ImageGenToolDetails>>>;
 export {};

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

@@ -276,6 +276,8 @@ export interface ToolSession {
      *  tool dispatches to it so a staged preview resolves WITHOUT forcing tool_choice — the
      *  agent-loop's SoftToolRequirement lifecycle owns reminder injection and escalation. */
     peekPendingInvoker?(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
+    /** Clear stale pending preview markers when `resolve` cannot dispatch them. */
+    clearPendingInvokers?(): void;
     /** Peek the long-lived "standing" resolve handler registered by a mode (e.g. plan mode).
      *  Consulted by the `resolve` tool as a fallback when no queue invoker is in flight,
      *  letting modes accept `resolve` invocations without forcing the tool choice every turn. */

package/dist/types/tui/hyperlink.d.ts

@@ -5,6 +5,7 @@
  * - `"off"`: never
  * - `"auto"`: when `process.stdout.isTTY`, `NO_COLOR` is unset, and the detected terminal reports hyperlink support
  * - `"always"`: unconditionally (useful for viewers that support OSC 8 without advertising it)
+ * Before settings initialization, returns false so early render paths stay plain text.
  */
 export declare function isHyperlinkEnabled(): boolean;
 /**
@@ -23,8 +24,8 @@ export declare function urlHyperlink(url: string, displayText: string): string;
  * Wrap `displayText` in an OSC 8 hyperlink pointing at an HTTP(S) URL,
  * bypassing terminal capability auto-detection. Used for auth prompts where
  * an inert "click" label blocks login on terminals whose capabilities are
- * not advertised. Still returns plain text when the user has explicitly
- * opted out via `tui.hyperlinks=off`.
+ * not advertised. Still returns plain text before settings initialization or
+ * when the user has explicitly opted out via `tui.hyperlinks=off`.
  */
 export declare function urlHyperlinkAlways(url: string, displayText: string): string;
 /**

package/dist/types/utils/image-loading.d.ts

@@ -8,7 +8,7 @@ export declare const SUPPORTED_INPUT_IMAGE_MIME_TYPES: Set<string>;
  * with an opaque HTTP 400. Detect those models so the resize pipeline encodes
  * to PNG/JPEG instead — the automatic equivalent of `OMP_NO_WEBP=1`.
  */
-export declare function modelLacksWebpSupport(model: Pick<Model, "provider" | "api"> | undefined): boolean;
+export declare function modelLacksWebpSupport(model: Pick<Model, "provider" | "api" | "imageInputDecoder"> | undefined): boolean;
 /**
  * `true` when `model` cannot decode WebP, otherwise `undefined` so the
  * `OMP_NO_WEBP` env fallback in {@link resizeImage} still applies. Feed straight

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

@@ -0,0 +1,22 @@
+/**
+ * Narrow a value to a thenable so a rejection handler can be attached.
+ *
+ * Mirrors the local helper in `mcp/transports/stdio.ts` (kept separate because
+ * that copy serves the FileSink stdin-write path and is battle-tested there).
+ * This shared copy is the home for the IPC `send()` sites.
+ */
+export declare function isThenable(value: unknown): value is PromiseLike<unknown>;
+/**
+ * Send a message to a Bun subprocess over IPC, neutralizing both the
+ * synchronous throw ("cannot be used after the process has exited") and any
+ * asynchronous rejection (EPIPE from a pipe that broke between exit being
+ * observed and the next `send()`). The dead worker is detected separately via
+ * `onExit`/`onError` and respawned or disabled by the owning client; an
+ * un-awaited EPIPE rejection must not escape as a fatal unhandled rejection
+ * that takes down the whole session. See issue #2997.
+ *
+ * `label` prefixes the debug log on synchronous failure (e.g. "tts").
+ */
+export declare function safeSend(proc: {
+    send(message: unknown): unknown;
+}, message: unknown, label: string): void;

package/dist/types/web/search/providers/perplexity-auth.d.ts

@@ -0,0 +1,37 @@
+import type { AuthStorage, OAuthAccess } from "@oh-my-pi/pi-ai";
+export declare const PERPLEXITY_CHAT_BASE_URL = "https://api.perplexity.ai";
+export declare const PERPLEXITY_RESPONSES_BASE_URL = "https://api.perplexity.ai/v1";
+export declare const OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+export declare const OAUTH_EXPIRY_BUFFER_MS: number;
+export interface ApiConfig {
+    type: "api_key";
+    apiKey: string;
+    provider: "perplexity" | "openrouter";
+    chatBaseUrl: string;
+    responsesBaseUrl: string;
+    modelPrefix: string;
+    useResponses: boolean;
+}
+export type PerplexityAuth = ApiConfig | {
+    type: "oauth";
+    access: OAuthAccess;
+} | {
+    type: "cookies";
+    cookies: string;
+} | {
+    type: "anonymous";
+};
+export interface PerplexityAuthOptions {
+    signal?: AbortSignal;
+    forceRefresh?: boolean;
+}
+/** Detect API-key endpoints to try in priority order (Perplexity direct, then OpenRouter). */
+export declare function getApiConfigs(authStorage: AuthStorage, sessionId: string | undefined, options?: PerplexityAuthOptions): Promise<ApiConfig[]>;
+/**
+ * Decode a Perplexity JWT's `exp` claim, in ms. Returns `undefined` when the
+ * token has no `exp` (which is the common case — Perplexity sessions are
+ * server-side and effectively non-expiring from the client's POV).
+ */
+export declare function jwtExpiryMs(token: string): number | undefined;
+/** Collect all available auth methods to try in priority order */
+export declare function getAvailableAuthMethods(authStorage: AuthStorage, sessionId: string | undefined, options?: PerplexityAuthOptions): Promise<PerplexityAuth[]>;

package/package.json

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

package/src/cli/bench-cli.ts

@@ -25,7 +25,7 @@ import {
 } from "../config/model-resolver";
 import { Settings } from "../config/settings";
 import benchPrompt from "../prompts/bench.md" with { type: "text" };
-import { discoverAuthStorage } from "../sdk";
+import { discoverAuthStorage, loadCliExtensionProviders } from "../sdk";
 import { resolveThinkingLevelForModel, shouldDisableReasoning, toReasoningEffort } from "../thinking";
 
 const DEFAULT_RUNS = 1;
@@ -145,6 +145,23 @@ function isFirstTokenEvent(event: AssistantMessageEvent): boolean {
 	}
 }
 
+/** Final message carries visible output — non-empty text/thinking or a tool call. */
+function hasVisibleFinalContent(message: AssistantMessage): boolean {
+	return message.content.some(block => {
+		switch (block.type) {
+			case "text":
+				return block.text.length > 0;
+			case "thinking":
+				return block.thinking.length > 0;
+			case "redactedThinking":
+			case "toolCall":
+				return true;
+			default:
+				return false;
+		}
+	});
+}
+
 /**
  * Tokens/s over the generation window (duration minus TTFT) so queue/prefill
  * latency does not dilute throughput. Falls back to total duration when the
@@ -232,6 +249,18 @@ async function runBenchRequest(
 		const rawTtft = message.ttft ?? (firstTokenAt === undefined ? durationMs : firstTokenAt - startedAt);
 		const ttftMs = Number.isFinite(rawTtft) && rawTtft > 0 ? rawTtft : 0;
 		const outputTokens = Number.isFinite(message.usage.output) && message.usage.output > 0 ? message.usage.output : 0;
+		// A run that streamed no content (no delta/end event set firstTokenAt),
+		// carries no visible final content, and measured no output tokens
+		// benchmarked nothing — a genuinely empty stream (e.g. a gateway that 200s
+		// with an empty body). Surface it as a failure instead of a misleading
+		// 0-token "✓". Streaming and buffered providers that produce content keep
+		// passing even when usage is omitted.
+		if (firstTokenAt === undefined && outputTokens === 0 && !hasVisibleFinalContent(message)) {
+			return {
+				ok: false,
+				error: `provider returned no output (0 tokens, empty stream; stop reason: ${message.stopReason ?? "unknown"})`,
+			};
+		}
 		return {
 			ok: true,
 			ttftMs,
@@ -328,8 +357,10 @@ export function formatBenchTable(summary: BenchSummary): string {
 async function createDefaultRuntime(): Promise<BenchRuntime> {
 	const authStorage = await discoverAuthStorage();
 	try {
-		const settings = await Settings.init({ cwd: getProjectDir() });
+		const cwd = getProjectDir();
+		const settings = await Settings.init({ cwd });
 		const modelRegistry = new ModelRegistry(authStorage);
+		await loadCliExtensionProviders(modelRegistry, settings, cwd);
 		return {
 			modelRegistry,
 			settings,

package/src/cli/dry-balance-cli.ts

@@ -26,7 +26,7 @@ import {
 } from "../config/model-resolver";
 import { Settings } from "../config/settings";
 import dryBalanceBenchPrompt from "../prompts/dry-balance-bench.md" with { type: "text" };
-import { discoverAuthStorage } from "../sdk";
+import { discoverAuthStorage, loadCliExtensionProviders } from "../sdk";
 
 const DEFAULT_SAMPLE_COUNT = 100;
 const DEFAULT_CONCURRENCY = 32;
@@ -523,8 +523,10 @@ async function runBenchTargets(
 async function createDefaultRuntime(): Promise<DryBalanceRuntime> {
 	const authStorage = await discoverAuthStorage();
 	try {
-		const settings = await Settings.init({ cwd: getProjectDir() });
+		const cwd = getProjectDir();
+		const settings = await Settings.init({ cwd });
 		const modelRegistry = new ModelRegistry(authStorage);
+		await loadCliExtensionProviders(modelRegistry, settings, cwd);
 		return {
 			modelRegistry,
 			settings,

package/src/cli.ts

@@ -68,6 +68,7 @@ async function runSmokeTest(): Promise<void> {
 	const { smokeTestTinyTitleWorker } = await import("./tiny/title-client");
 	const { smokeTestSttWorker } = await import("./stt/asr-client");
 	const { smokeTestTtsWorker } = await import("./tts/tts-client");
+	const { smokeTestMnemopiEmbedWorker } = await import("./mnemopi/embed-client");
 	const { smokeTestJsEvalWorker } = await import("./eval/js/context-manager");
 	await smokeTestSyncWorker();
 
@@ -87,6 +88,7 @@ async function runSmokeTest(): Promise<void> {
 	await smokeTestSttWorker();
 	await smokeTestJsEvalWorker();
 	await smokeTestTtsWorker();
+	await smokeTestMnemopiEmbedWorker();
 	process.stdout.write("smoke-test: ok\n");
 }
 
@@ -96,6 +98,7 @@ const TAB_WORKER_ARG = "__omp_worker_tab";
 const JS_EVAL_WORKER_ARG = "__omp_worker_js_eval";
 const STT_WORKER_ARG = "__omp_worker_stt";
 const TTS_WORKER_ARG = "__omp_worker_tts";
+const MNEMOPI_EMBED_WORKER_ARG = "__omp_worker_mnemopi_embed";
 
 async function runWorkerEntrypoint(arg: string | undefined): Promise<boolean> {
 	if (arg === TINY_WORKER_ARG) {
@@ -151,6 +154,11 @@ async function runWorkerEntrypoint(arg: string | undefined): Promise<boolean> {
 		await runIpcSubprocessWorker(startTtsWorker);
 		return true;
 	}
+	if (arg === MNEMOPI_EMBED_WORKER_ARG) {
+		const { startMnemopiEmbedWorker } = await import("./mnemopi/embed-worker");
+		await runIpcSubprocessWorker(startMnemopiEmbedWorker);
+		return true;
+	}
 	return false;
 }