@oh-my-pi/pi-coding-agent 16.2.9 → 16.2.12

package/dist/types/cli/bench-cli.d.ts

@@ -1,8 +1,6 @@
 import type { ResolvedThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, ApiKeyResolver, AssistantMessageEventStream, Context, Model, ServiceTierByFamily, SimpleStreamOptions } from "@oh-my-pi/pi-ai";
-import { type CanonicalModelVariant } from "@oh-my-pi/pi-catalog/identity";
 import type { ApiKeyResolverModel } from "../config/api-key-resolver";
-import { type CanonicalModelQueryOptions } from "../config/model-registry";
 import { Settings } from "../config/settings";
 export interface BenchCommandArgs {
     models: string[];
@@ -20,9 +18,6 @@ export interface BenchModelRegistry {
     getAll(): Model<Api>[];
     getApiKey(model: Model<Api>, sessionId?: string): Promise<string | undefined>;
     resolver(model: ApiKeyResolverModel, sessionId?: string): ApiKeyResolver;
-    resolveCanonicalModel?(canonicalId: string, options?: CanonicalModelQueryOptions): Model<Api> | undefined;
-    getCanonicalVariants?(canonicalId: string, options?: CanonicalModelQueryOptions): CanonicalModelVariant[];
-    getCanonicalId?(model: Model<Api>): string | undefined;
     hasConfiguredAuth?(model: Model<Api>): boolean;
 }
 export interface BenchRuntime {

package/dist/types/cli/dry-balance-cli.d.ts

@@ -1,6 +1,4 @@
 import type { Api, AssistantMessageEventStream, AuthCredentialSnapshotEntry, Context, Model, OAuthAccess, OAuthAccessResolution, SimpleStreamOptions } from "@oh-my-pi/pi-ai";
-import type { CanonicalModelVariant } from "@oh-my-pi/pi-catalog/identity";
-import { type CanonicalModelQueryOptions } from "../config/model-registry";
 import { Settings } from "../config/settings";
 export interface DryBalanceCommandArgs {
     model?: string;
@@ -32,9 +30,6 @@ export interface DryBalanceModelRegistry {
     getAll(): Model<Api>[];
     getAvailable(): Model<Api>[];
     getApiKey(model: Model<Api>, sessionId?: string): Promise<string | undefined>;
-    getCanonicalVariants(canonicalId: string, options?: CanonicalModelQueryOptions): CanonicalModelVariant[];
-    resolveCanonicalModel?(canonicalId: string, options?: CanonicalModelQueryOptions): Model<Api> | undefined;
-    getCanonicalId?(model: Model<Api>): string | undefined;
 }
 export interface DryBalanceRuntime {
     modelRegistry: DryBalanceModelRegistry;

package/dist/types/cli/models-cli.d.ts

@@ -1,5 +1,5 @@
 import { ModelRegistry } from "../config/model-registry";
-export type ModelsAction = "ls" | "find" | "refresh" | "canonical";
+export type ModelsAction = "ls" | "find" | "refresh";
 export interface ModelsCommandArgs {
     action: ModelsAction;
     /** Search substring for `find`, or optional filter for `ls`. */

package/dist/types/config/inline-tool-descriptors-mode.d.ts

@@ -7,7 +7,6 @@
  * Gemini benefits from descriptors in-prompt; other providers keep them in the
  * tool schemas. `on`/`off` are explicit user overrides.
  *
- * @param modelId Canonical model id (e.g. `gemini-3-pro`); resolve aliases via
- *   `ModelRegistry.getCanonicalId` before calling so `auto` classifies correctly.
+ * @param modelId Model id (e.g. `gemini-3-pro`) used to classify `auto`.
  */
 export declare function shouldInlineToolDescriptors(setting: "auto" | "on" | "off" | undefined, modelId: string | undefined): boolean;

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

@@ -3,11 +3,9 @@ import type { AssistantMessageEventStream } from "@oh-my-pi/pi-ai/utils/event-st
 import { type ModelRefreshStrategy } from "@oh-my-pi/pi-catalog/model-manager";
 import type { ApiKeyResolver, FetchImpl } from "@oh-my-pi/pi-ai";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/oauth/types";
-import { type CanonicalModelIndex, type CanonicalModelRecord, type CanonicalModelVariant, type ModelEquivalenceConfig } from "@oh-my-pi/pi-catalog/identity";
 import type { AuthStorage } from "../session/auth-storage";
 import { type ApiKeyResolverModel, type ApiKeyResolverOptions } from "./api-key-resolver";
 import type { ConfigError } from "./config-file";
-export type { CanonicalModelIndex, CanonicalModelRecord, CanonicalModelVariant, ModelEquivalenceConfig };
 export declare const kNoAuth = "N/A";
 export declare function isAuthenticated(apiKey: string | undefined | null): apiKey is string;
 /** Provider override config (baseUrl, headers, apiKey, compat, transport) without custom models */
@@ -57,15 +55,6 @@ export interface ProviderDiscoveryState {
     models: string[];
     error?: string;
 }
-export interface CanonicalModelQueryOptions {
-    availableOnly?: boolean;
-    candidates?: readonly Model<Api>[];
-}
-/** A canonical record (with query-filtered variants) plus the variant model selected for it. */
-export interface CanonicalModelSelection {
-    record: CanonicalModelRecord;
-    model: Model<Api>;
-}
 /**
  * Model registry - loads and manages models, resolves API keys via AuthStorage.
  */
@@ -113,18 +102,6 @@ export declare class ModelRegistry {
      * If models.json had errors, returns only built-in models.
      */
     getAll(): Model<Api>[];
-    getCanonicalModels(options?: CanonicalModelQueryOptions): CanonicalModelRecord[];
-    /**
-     * One-pass equivalent of `getCanonicalModels` + `resolveCanonicalModel` per
-     * record. The per-query state (candidate-selector set, availability memo,
-     * provider rank, candidate order) is built once, so the whole catalog
-     * resolves in O(records + candidates) instead of O(records × candidates).
-     * This is the path the model selector hydrates from synchronously on open.
-     */
-    getCanonicalModelSelections(options?: CanonicalModelQueryOptions): CanonicalModelSelection[];
-    getCanonicalVariants(canonicalId: string, options?: CanonicalModelQueryOptions): CanonicalModelVariant[];
-    resolveCanonicalModel(canonicalId: string, options?: CanonicalModelQueryOptions): Model<Api> | undefined;
-    getCanonicalId(model: Model<Api>): string | undefined;
     /**
      * Get only models that have auth configured.
      * This is a fast check that doesn't refresh OAuth tokens.
@@ -271,3 +248,4 @@ export interface ProviderConfigInput {
         premiumMultiplier?: number;
     }>;
 }
+export {};

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

@@ -4,8 +4,8 @@
  * Layering:
  * - `matchModel` is the single matching engine. Order: exact `provider/id`
  *   reference (with variant-alias and OpenRouter routed/date fallbacks) →
- *   exact canonical id → exact bare id → retired variant alias →
- *   provider-scoped fuzzy → substring with alias-vs-dated pick.
+ *   exact bare id → retired variant alias → provider-scoped fuzzy → substring
+ *   with alias-vs-dated pick.
  * - `parseModelPatternWithContext`/`parseModelPattern` layer the selector
  *   grammar on top: trailing `:level` thinking suffixes (`splitThinkingSuffix`)
  *   and `@upstream` provider routing (`splitUpstreamRouting`).
@@ -75,9 +75,8 @@ export interface ModelMatchPreferences {
     /** Providers to deprioritize when no recent usage or provider priority is available. */
     deprioritizeProviders?: string[];
 }
-export type CanonicalModelRegistry = Partial<Pick<ModelRegistry, "resolveCanonicalModel" | "getCanonicalVariants" | "getCanonicalId">>;
-export type ModelLookupRegistry = Pick<ModelRegistry, "getAvailable"> & Partial<CanonicalModelRegistry>;
-type CliModelRegistry = Pick<ModelRegistry, "getAll"> & Partial<CanonicalModelRegistry>;
+export type ModelLookupRegistry = Pick<ModelRegistry, "getAvailable">;
+type CliModelRegistry = Pick<ModelRegistry, "getAll">;
 type InitialModelRegistry = Pick<ModelRegistry, "getAvailable" | "find">;
 type RestorableModelRegistry = Pick<ModelRegistry, "getAvailable" | "find" | "getApiKey">;
 export declare function getModelMatchPreferences(settings?: Partial<Pick<Settings, "get" | "getStorage">>): ModelMatchPreferences;
@@ -92,7 +91,6 @@ export interface ParsedModelResult {
 }
 export declare function parseModelPattern(pattern: string, availableModels: Model<Api>[], preferences?: ModelMatchPreferences, options?: {
     allowInvalidThinkingSelectorFallback?: boolean;
-    modelRegistry?: CanonicalModelRegistry;
 }): ParsedModelResult;
 /**
  * Expand a role alias like "pi/smol" to the configured model string.
@@ -119,7 +117,6 @@ export interface ResolvedModelRoleValue {
 export declare function resolveModelRoleValue(roleValue: string | undefined, availableModels: Model<Api>[], options?: {
     settings?: Settings;
     matchPreferences?: ModelMatchPreferences;
-    modelRegistry?: CanonicalModelRegistry;
 }): ResolvedModelRoleValue;
 interface ExplicitThinkingSelectorOptions {
     isLiteralModelId?: (provider: string, id: string) => boolean;
@@ -128,7 +125,7 @@ export declare function extractExplicitThinkingSelector(value: string | undefine
 /**
  * Resolve a model identifier or pattern to a Model instance.
  */
-export declare function resolveModelFromString(value: string, available: Model<Api>[], matchPreferences?: ModelMatchPreferences, modelRegistry?: CanonicalModelRegistry): Model<Api> | undefined;
+export declare function resolveModelFromString(value: string, available: Model<Api>[], matchPreferences?: ModelMatchPreferences): Model<Api> | undefined;
 /**
  * Resolve a model from configured roles, honoring order and overrides.
  */
@@ -137,7 +134,6 @@ export declare function resolveModelFromSettings(options: {
     availableModels: Model<Api>[];
     matchPreferences?: ModelMatchPreferences;
     roleOrder?: readonly ModelRole[];
-    modelRegistry?: CanonicalModelRegistry;
 }): Model<Api> | undefined;
 /**
  * Resolve a list of override patterns to the first matching model.
@@ -177,7 +173,7 @@ export declare function resolveModelOverrideWithAuthFallback(modelPatterns: stri
 /**
  * Resolve a list of role patterns to the first matching model.
  */
-export declare function resolveRoleSelection(roles: readonly string[], settings: Settings, availableModels: Model<Api>[], modelRegistry?: CanonicalModelRegistry): {
+export declare function resolveRoleSelection(roles: readonly string[], settings: Settings, availableModels: Model<Api>[]): {
     model: Model<Api>;
     thinkingLevel?: ThinkingLevel;
 } | undefined;
@@ -189,7 +185,7 @@ export declare function resolveRoleSelection(roles: readonly string[], settings:
  * the `slow` role itself, never inherits the primary's model. Returns undefined
  * only when no candidate in the resolved chain is available.
  */
-export declare function resolveAdvisorRoleSelection(settings: Settings, availableModels: Model<Api>[], modelRegistry?: CanonicalModelRegistry): {
+export declare function resolveAdvisorRoleSelection(settings: Settings, availableModels: Model<Api>[]): {
     model: Model<Api>;
     thinkingLevel?: ThinkingLevel;
 } | undefined;
@@ -204,7 +200,7 @@ export declare function resolveAdvisorRoleSelection(settings: Settings, availabl
  * The algorithm tries to match the full pattern first, then progressively
  * strips colon-suffixes to find a match.
  */
-export declare function resolveModelScope(patterns: string[], modelRegistry: Pick<ModelRegistry, "getAvailable" | "getCanonicalVariants">, preferences?: ModelMatchPreferences): Promise<ScopedModel[]>;
+export declare function resolveModelScope(patterns: string[], modelRegistry: Pick<ModelRegistry, "getAvailable">, preferences?: ModelMatchPreferences): Promise<ScopedModel[]>;
 /**
  * Resolve the set of models a session is allowed to use, given the active
  * settings. Starts from `modelRegistry.getAvailable()` (so disabled providers
@@ -217,7 +213,7 @@ export declare function resolveModelScope(patterns: string[], modelRegistry: Pic
  * 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>[]>;
+export declare function resolveAllowedModels(modelRegistry: Pick<ModelRegistry, "getAvailable">, settings: Settings | undefined, preferences?: ModelMatchPreferences): Promise<Model<Api>[]>;
 /**
  * Synchronous subset of {@link resolveAllowedModels} for contexts where async is unavailable
  * (e.g. `getAvailableModels()` which is called from the ACP model-list advertisement, RPC
@@ -225,7 +221,6 @@ export declare function resolveAllowedModels(modelRegistry: Pick<ModelRegistry,
  * `enabledModels` scope semantics as startup resolution:
  *
  * - Glob selectors match `provider/modelId` and bare model id
- * - Exact canonical ids expand to all available concrete variants
  * - Exact `provider/modelId`, bare ids, provider-scoped fuzzy, and substring selectors
  *   resolve through the shared model-pattern matcher
  * - Optional `:thinkingLevel` suffixes are stripped only when valid
@@ -235,7 +230,7 @@ export declare function resolveAllowedModels(modelRegistry: Pick<ModelRegistry,
  * a UI picker should treat an empty list as "hide the picker entry", matching how the SDK
  * surfaces the same misconfiguration during session initialization.
  */
-export declare function filterAvailableModelsByEnabledPatterns(available: Model<Api>[], patterns: readonly string[], registry: Pick<ModelRegistry, "getCanonicalVariants">): Model<Api>[];
+export declare function filterAvailableModelsByEnabledPatterns(available: Model<Api>[], patterns: readonly string[]): Model<Api>[];
 export interface ResolveCliModelResult {
     model: Model<Api> | undefined;
     selector?: string;

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

@@ -681,11 +681,5 @@ export declare const ModelsConfigSchema: import("arktype/internal/variants/objec
             transport?: "pi-native" | undefined;
         };
     } | undefined;
-    equivalence?: {
-        overrides?: {
-            [x: string]: string;
-        } | undefined;
-        exclude?: string[] | undefined;
-    } | undefined;
 }, {}>;
 export type ModelsConfig = typeof ModelsConfigSchema.infer;

package/dist/types/config/models-config.d.ts

@@ -424,10 +424,4 @@ export declare const ModelsConfigFile: ConfigFile<{
             transport?: "pi-native" | undefined;
         };
     } | undefined;
-    equivalence?: {
-        overrides?: {
-            [x: string]: string;
-        } | undefined;
-        exclude?: string[] | undefined;
-    } | undefined;
 }>;

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

@@ -919,7 +919,7 @@ export declare const SETTINGS_SCHEMA: {
             readonly tab: "model";
             readonly group: "Thinking";
             readonly label: "Loop Guard";
-            readonly description: "Enable automatic stream loop detection for Gemini and DeepSeek models";
+            readonly description: "Enable automatic stream loop detection for model reasoning and prose";
         };
     };
     readonly "model.loopGuard.checkAssistantContent": {
@@ -942,6 +942,36 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "When a Gemini reasoning stream emits many consecutive planning headers without calling a tool, interrupt it and inject a reminder to issue a tool call (requires Loop Guard)";
         };
     };
+    readonly "model.toolCallLoopGuard.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "model";
+            readonly group: "Thinking";
+            readonly label: "Tool-Call Loop Guard";
+            readonly description: "Detect consecutive identical tool calls across turns and inject a corrective steer";
+        };
+    };
+    readonly "model.toolCallLoopGuard.threshold": {
+        readonly type: "number";
+        readonly default: 5;
+        readonly ui: {
+            readonly tab: "model";
+            readonly group: "Thinking";
+            readonly label: "Tool-Call Loop Threshold";
+            readonly description: "Consecutive identical tool calls required before the corrective steer is injected";
+        };
+    };
+    readonly "model.toolCallLoopGuard.exemptTools": {
+        readonly type: "array";
+        readonly default: string[];
+        readonly ui: {
+            readonly tab: "model";
+            readonly group: "Thinking";
+            readonly label: "Tool-Call Loop Exempt Tools";
+            readonly description: "Tool names that may repeat consecutively without triggering the cross-turn loop guard";
+        };
+    };
     readonly inlineToolDescriptors: {
         readonly type: "enum";
         readonly values: readonly ["auto", "on", "off"];

package/dist/types/eval/py/__tests__/runner-shell-output.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/extensibility/extensions/runner.d.ts

@@ -119,6 +119,21 @@ export declare class ExtensionRunner {
     createCommandContext(): ExtensionCommandContext;
     emit<TEvent extends RunnerEmitEvent>(event: TEvent): Promise<RunnerEmitResult<TEvent>>;
     emitToolResult(event: ToolResultEvent): Promise<ToolResultEventResult | undefined>;
+    /**
+     * Emit a `tool_call` event to every subscribed extension before the tool executes.
+     *
+     * Each handler is bounded by `extensionHandlerTimeoutMs` (default 30s). This
+     * matches the timeout policy already applied to `emitToolResult` and every
+     * other handler routed through `#runHandlerWithTimeout`; without it a single
+     * hung extension (unresolved `await`, network call with no timeout) would
+     * park `ExtensionToolWrapper.execute` indefinitely and freeze tool
+     * dispatch — see issue #3948.
+     *
+     * On-timeout policy: **fail-closed** (return `{ block: true }`). This is
+     * symmetric with the existing error path below and safer for a
+     * pre-execution gate — an unresponsive extension MUST NOT be treated as
+     * silent consent to run the tool.
+     */
     emitToolCall(event: ToolCallEvent): Promise<ToolCallEventResult | undefined>;
     emitUserBash(event: UserBashEvent): Promise<UserBashEventResult | undefined>;
     emitUserPython(event: UserPythonEvent): Promise<UserPythonEventResult | undefined>;

package/dist/types/extensibility/skills.d.ts

@@ -64,4 +64,33 @@ export interface BuiltSkillPromptMessage {
     details: SkillPromptDetails;
 }
 export declare function getSkillSlashCommandName(skill: Pick<Skill, "name">): string;
+/**
+ * Parsed `/skill:<name>` invocation: either at the start of the draft (the
+ * traditional slash-command position) or as a `/skill:<name>` token embedded
+ * mid-prompt. For the mid-prompt form the surrounding prose is threaded
+ * through as `args` so the skill sees the full user request.
+ */
+export interface ParsedSkillInvocation {
+    /** Bare skill name without the leading `skill:` prefix. */
+    name: string;
+    /** User-supplied arguments (everything outside the `/skill:<name>` token). */
+    args: string;
+}
+/**
+ * Detect a `/skill:<name>` invocation in a user draft.
+ *
+ * Returns `undefined` when the text contains no skill token. Otherwise:
+ *   - Leading form (`/skill:foo bar baz`): name=`foo`, args=`bar baz`.
+ *   - Mid-prompt form (`fix the bug /skill:foo focus on auth`): name=`foo`,
+ *     args=`fix the bug focus on auth` — the surrounding prose collapsed
+ *     into a single args string.
+ *
+ * Mid-prompt detection is disabled when the draft itself starts with a
+ * different slash command (e.g. `/compact /skill:foo`) or a local-execution
+ * sigil — `!cmd` / `!!cmd` for the bash tool and `$ cmd` / `$$ cmd` for the
+ * python tool. Those handlers run after the skill-command dispatcher and
+ * their bodies routinely contain `/skill:<name>` references that are not
+ * meant as skill invocations.
+ */
+export declare function parseSkillInvocation(text: string): ParsedSkillInvocation | undefined;
 export declare function buildSkillPromptMessage(skill: Pick<Skill, "name" | "filePath">, args: string): Promise<BuiltSkillPromptMessage>;

package/dist/types/lsp/client.d.ts

@@ -10,9 +10,13 @@ export declare const WARMUP_TIMEOUT_MS = 5000;
  * Get or create an LSP client for the given server configuration and working directory.
  * @param config - Server configuration
  * @param cwd - Working directory
- * @param initTimeoutMs - Optional timeout for the initialize request (defaults to 30s)
+ * @param initTimeoutMs - Optional hard deadline for the initialize handshake (warmup / other
+ *   short-lived callers). When set it takes precedence over `signal` inside `sendRequest`.
+ * @param signal - Optional caller abort signal. Threaded into the initialize `sendRequest`
+ *   and the `initialized` notification so a wedged server surfaces the caller's
+ *   timeout/cancel instead of falling back to the internal 30s default.
  */
-export declare function getOrCreateClient(config: ServerConfig, cwd: string, initTimeoutMs?: number): Promise<LspClient>;
+export declare function getOrCreateClient(config: ServerConfig, cwd: string, initTimeoutMs?: number, signal?: AbortSignal): Promise<LspClient>;
 /**
  * Ensure a file is opened in the LSP client.
  * Sends didOpen notification if the file is not already tracked.
@@ -59,8 +63,10 @@ export declare function shutdownClient(key: string): Promise<void>;
 export declare function sendRequest(client: LspClient, method: string, params: unknown, signal?: AbortSignal, timeoutMs?: number): Promise<unknown>;
 /**
  * Send an LSP notification (no response expected).
+ * `signal` bounds the underlying `sink.flush()` — without it a server that
+ * stops draining stdin blocks every future write on the client's write queue.
  */
-export declare function sendNotification(client: LspClient, method: string, params: unknown): Promise<void>;
+export declare function sendNotification(client: LspClient, method: string, params: unknown, signal?: AbortSignal): Promise<void>;
 /**
  * Shutdown all LSP clients.
  */

package/dist/types/modes/components/todo-reminder.d.ts

@@ -1,7 +1,9 @@
 import { Container } from "@oh-my-pi/pi-tui";
 import type { TodoItem } from "../../tools/todo";
 /**
- * Component that renders a todo completion reminder notification.
+ * Component that renders a todo completion reminder notification, committed into
+ * the transcript like a TTSR notification so it stays anchored in history rather
+ * than floating above the editor.
  * Shows when the agent stops with incomplete todos.
  */
 export declare class TodoReminderComponent extends Container {

package/dist/types/modes/interactive-mode.d.ts

@@ -83,7 +83,6 @@ export declare class InteractiveMode implements InteractiveModeContext {
     chatContainer: TranscriptContainer;
     pendingMessagesContainer: Container;
     statusContainer: Container;
-    todoReminderContainer: Container;
     todoContainer: Container;
     subagentContainer: Container;
     btwContainer: Container;

package/dist/types/modes/skill-command.d.ts

@@ -23,7 +23,7 @@ export interface BuiltSkillCommandPrompt {
     message: SkillPromptMessage;
     options: SkillPromptOptions;
 }
-/** Return true when `text` names a registered `/skill:<name>` command. */
+/** Return true when `text` invokes a registered `/skill:<name>` command. */
 export declare function isKnownSkillCommand(ctx: SkillCommandHost, text: string): boolean;
 /** Build the user-attributed custom message for a registered `/skill:<name>` command. */
 export declare function buildSkillCommandPrompt(ctx: SkillCommandHost, text: string, streamingBehavior: "steer" | "followUp", images?: ImageContent[]): Promise<BuiltSkillCommandPrompt | undefined>;

package/dist/types/modes/types.d.ts

@@ -81,7 +81,6 @@ export interface InteractiveModeContext {
     chatContainer: TranscriptContainer;
     pendingMessagesContainer: Container;
     statusContainer: Container;
-    todoReminderContainer: Container;
     todoContainer: Container;
     subagentContainer: Container;
     btwContainer: Container;

package/dist/types/stt/asr-client.d.ts

@@ -1,4 +1,4 @@
-import { type SpawnedSubprocess, type WorkerHandle } from "../subprocess/worker-client";
+import { type RefCountedWorkerHandle, type SpawnedSubprocess } from "../subprocess/worker-client";
 import type { SttProgressEvent, SttWorkerInbound, SttWorkerOutbound } from "./asr-protocol";
 import type { SttModelKey } from "./models";
 export interface SttTranscribeOptions {
@@ -9,6 +9,10 @@ export interface SttDownloadOptions {
     signal?: AbortSignal;
     onProgress?: (event: SttProgressEvent) => void;
 }
+export interface SttDownloadResult {
+    ok: boolean;
+    error?: string;
+}
 /** Live streaming session handle returned by {@link SttClient.startStream}. */
 export interface SttStreamHandle {
     /** Feed 16 kHz mono float samples as the recorder produces them. */
@@ -38,7 +42,7 @@ export declare const STT_WORKER_ARG = "__omp_worker_stt";
 export declare function createSttSubprocess(): SpawnedSubprocess<SttWorkerOutbound>;
 export declare class SttClient {
     #private;
-    constructor(spawnWorker?: () => WorkerHandle<SttWorkerInbound, SttWorkerOutbound>);
+    constructor(spawnWorker?: () => RefCountedWorkerHandle<SttWorkerInbound, SttWorkerOutbound>);
     onProgress(listener: (event: SttProgressEvent) => void): () => void;
     /**
      * Transcribe 16 kHz mono audio on the warm worker. Rejects with the worker
@@ -54,7 +58,7 @@ export declare class SttClient {
      * an aborted signal) tears the session down and resolves `stop()` with "".
      */
     startStream(modelKey: SttModelKey, options?: SttStreamOptions): SttStreamHandle;
-    downloadModel(modelKey: SttModelKey, options?: SttDownloadOptions): Promise<boolean>;
+    downloadModel(modelKey: SttModelKey, options?: SttDownloadOptions): Promise<SttDownloadResult>;
     terminate(): Promise<void>;
 }
 export declare const sttClient: SttClient;

package/dist/types/task/spawn-policy.d.ts

@@ -0,0 +1,17 @@
+/** Default agent used when a session has unrestricted spawning. */
+export declare const DEFAULT_SPAWN_AGENT = "task";
+/** Spawn policy derived from a parent agent's `spawns` frontmatter. */
+export interface ResolvedSpawnPolicy {
+    /** True when at least one subagent may be spawned. */
+    enabled: boolean;
+    /** Agent used when the caller omits the agent field. */
+    defaultAgent: string;
+    /** Explicitly allowed agents, or `null` when the policy is unrestricted. */
+    allowedAgents: readonly string[] | null;
+    /** Text used in spawn rejection messages. */
+    allowedErrorText: string;
+    /** Backtick-quoted explicit agents for prompt descriptions. */
+    allowedPromptText?: string;
+}
+/** Resolves spawn frontmatter into the default and prompt/error surfaces. */
+export declare function resolveSpawnPolicy(parentSpawns: string | boolean | null | undefined): ResolvedSpawnPolicy;

package/dist/types/task/spawn-policy.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -1,5 +1,6 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
+import { type BaseType } from "arktype";
 import type { AgentSessionEvent } from "../session/agent-session";
 import type { NestedRepoPatch } from "./worktree";
 /** Source of an agent definition */
@@ -117,11 +118,16 @@ declare const ALL_TASK_SCHEMAS: readonly [import("arktype/internal/variants/obje
 type DynamicTaskSchema = (typeof ALL_TASK_SCHEMAS)[number];
 export type TaskSchema = typeof taskSchema;
 /** Active task tool parameter schema for the current isolation / batch flags */
-export type TaskToolSchemaInstance = DynamicTaskSchema;
+export type TaskToolSchemaInstance = DynamicTaskSchema | BaseType;
 export declare function getTaskSchema(options: {
     isolationEnabled: boolean;
     batchEnabled: boolean;
 }): DynamicTaskSchema;
+export declare function getTaskSchema(options: {
+    isolationEnabled: boolean;
+    batchEnabled: boolean;
+    defaultAgent: string;
+}): TaskToolSchemaInstance;
 /**
  * Runtime params union over both wire shapes. The model sees exactly one shape
  * (`{ agent, context, tasks[] }` when `task.batch` is on, `{ agent, ...item }`
@@ -129,7 +135,7 @@ export declare function getTaskSchema(options: {
  * transcripts using the flat form keep working under either setting.
  */
 export interface TaskParams {
-    /** Agent type to spawn; defaults to `"task"` (the general-purpose worker) when omitted. */
+    /** Agent type to spawn; omitted values resolve from the session spawn policy. */
     agent?: string;
     /** Stable agent id (flat form); default = generated AdjectiveNoun. */
     id?: string;

package/dist/types/tools/__tests__/eval-description.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tools/browser/cmux/cmux-tab.d.ts

@@ -1,5 +1,5 @@
 import { JsRuntime } from "../../../eval/js/shared/runtime";
-import type { ToolSession } from "../../../sdk";
+import type { ToolSession } from "../../index";
 import { type AriaSnapshotOptions } from "../aria/aria-snapshot";
 import { type ReadableFormat } from "../readable";
 import type { Observation, ReadyInfo, RunResultOk, ScreenshotResult, SessionSnapshot } from "../tab-protocol";
@@ -19,7 +19,7 @@ interface RunContext {
     session: SessionSnapshot;
     displays: RunResultOk["displays"];
     screenshots: ScreenshotResult[];
-    signal?: AbortSignal;
+    signal: AbortSignal;
     timeoutMs: number;
 }
 type WaitUntil = "load" | "domcontentloaded" | "networkidle0" | "networkidle2";

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

@@ -53,4 +53,6 @@ export declare function holdBrowser(handle: BrowserHandle): void;
 export declare function releaseBrowser(handle: BrowserHandle, opts: {
     kill: boolean;
 }): Promise<void>;
+/** Test-only accessor for the module-global browsers map. */
+export declare function getBrowsersMapForTest(): ReadonlyMap<string, BrowserHandle>;
 export {};

package/dist/types/tools/browser/run-cancellation.d.ts

@@ -0,0 +1,4 @@
+/** Sleeps inside evaluated browser code while honoring the owning run's cancellation signal. */
+export declare function waitForBrowserRun(ms: number, signal: AbortSignal): Promise<void>;
+/** Binds a long-lived browser facade to one evaluated run's abort signal. */
+export declare function bindBrowserRunFacade<T extends object>(target: T, signal: AbortSignal): T;

package/dist/types/tools/browser/tab-supervisor.d.ts

@@ -1,4 +1,4 @@
-import type { ToolSession } from "../../sdk";
+import type { ToolSession } from "../index";
 import { CmuxTab } from "./cmux/cmux-tab";
 import { type BrowserHandle, type BrowserKindTag, type CmuxBrowserHandle, type PuppeteerBrowserHandle } from "./registry";
 import type { ReadyInfo, RunResultOk, Transferable, WorkerInbound, WorkerInitPayload, WorkerOutbound } from "./tab-protocol";
@@ -26,6 +26,13 @@ interface TabSessionBase<TBrowser extends BrowserHandle = BrowserHandle> {
     pending: Map<string, PendingRun>;
     dialogPolicy?: DialogPolicy;
     kindTag: BrowserKindTag;
+    /**
+     * Session id of the caller that CREATED the tab. Preserved across reuse so
+     * that dispose of the creating session can reap browser resources without
+     * yanking the tab out from under a subagent that only reused it.
+     * Undefined when the acquirer did not identify itself.
+     */
+    ownerSessionId?: string;
 }
 export interface WorkerTabSession extends TabSessionBase<PuppeteerBrowserHandle> {
     backend: "worker";
@@ -51,6 +58,12 @@ export interface AcquireTabOptions {
     timeoutMs: number;
     dialogs?: DialogPolicy;
     cmuxSurface?: string;
+    /**
+     * Session id of the acquirer. Recorded on the tab when created (never on
+     * reuse) so `releaseTabsForOwner` can walk the shared tabs map on session
+     * dispose. Optional — omitting it opts the tab out of session-scoped reap.
+     */
+    ownerSessionId?: string;
 }
 export interface AcquireTabResult {
     tab: TabSession;
@@ -71,5 +84,21 @@ export declare function runInTab(name: string, opts: RunInTabOptions): Promise<R
 export declare function releaseTab(name: string, opts?: ReleaseTabOptions): Promise<boolean>;
 export declare function releaseAllTabs(opts?: ReleaseTabOptions): Promise<number>;
 export declare function dropHeadlessTabs(): Promise<void>;
+/**
+ * Release every tab created by the given session id. Invoked from
+ * `AgentSession.dispose()` so headless/spawned Chromium and workers the
+ * session opened do not leak into the long-lived process — the module-global
+ * `tabs`/`browsers` maps that back this tool are not otherwise walked by
+ * session teardown. (Issue #3963.)
+ *
+ * Ownership is recorded ONLY on tab creation (`acquireTab` with
+ * `ownerSessionId`), never on reuse: a subagent re-driving a tab another
+ * session opened will not yank teardown responsibility away from the
+ * creator. Tabs opened with no owner (e.g. from an SDK caller that doesn't
+ * identify a session) are skipped and must be released explicitly.
+ */
+export declare function releaseTabsForOwner(ownerId: string, opts?: ReleaseTabOptions): Promise<number>;
+/** Test-only accessor for the module-global tabs map. */
+export declare function getTabsMapForTest(): ReadonlyMap<string, TabSession>;
 export declare function initializeTabWorkerForTest(worker: WorkerHandle, payload: WorkerInitPayload, timeoutMs: number): Promise<ReadyInfo>;
 export {};

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

@@ -35,13 +35,10 @@ export interface EvalToolDescriptionOptions {
     rb?: boolean;
     jl?: boolean;
     /**
-     * Whether `agent()` is allowed in this session. Driven by the parent's
-     * spawn policy (`getSessionSpawns`). Defaults to `true` for backward
-     * compatibility — when the session forbids spawning, the prelude doc
-     * omits the `agent()` entry so the model does not promise itself a
-     * helper that will only ever throw "spawns disabled".
+     * Parent spawn policy (`getSessionSpawns`). `true`/omitted means unrestricted,
+     * `false`/`""` hides `agent()`, and a comma list drives the advertised default.
      */
-    spawns?: boolean;
+    spawns?: boolean | string | null;
 }
 export declare function getEvalToolDescription(options?: EvalToolDescriptionOptions): string;
 export interface EvalToolOptions {

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

@@ -44,7 +44,7 @@ export declare class WriteTool implements AgentTool<typeof writeSchema, WriteToo
     /** Stream matchers should see the real file content, not its JSON-escaped argument encoding. */
     matcherDigest(args: unknown): string | undefined;
     constructor(session: ToolSession);
-    execute(_toolCallId: string, { path: rawPath, content }: WriteParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<WriteToolDetails>, context?: AgentToolContext): Promise<AgentToolResult<WriteToolDetails>>;
+    execute(_toolCallId: string, { path: rawPath, content }: WriteParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<WriteToolDetails>, context?: AgentToolContext): Promise<AgentToolResult<WriteToolDetails>>;
 }
 interface WriteRenderArgs {
     path?: string;

package/dist/types/utils/image-vision-fallback.d.ts

@@ -4,7 +4,7 @@ import type { ModelRegistry } from "../config/model-registry";
 import type { Settings } from "../config/settings";
 import { type LocalProtocolOptions } from "../internal-urls";
 /** Registry surface needed to resolve a vision model and authorize requests. */
-export type VisionFallbackRegistry = Pick<ModelRegistry, "getAvailable" | "getApiKey" | "resolver"> & Partial<Pick<ModelRegistry, "resolveCanonicalModel" | "getCanonicalVariants" | "getCanonicalId">>;
+export type VisionFallbackRegistry = Pick<ModelRegistry, "getAvailable" | "getApiKey" | "resolver">;
 export interface DescribeAttachedImagesDeps {
     /** Active (text-only) model the prompt is destined for. */
     activeModel: Model<Api>;