@oh-my-pi/pi-coding-agent 17.0.1 → 17.0.2

package/dist/types/advisor/config.d.ts

@@ -13,7 +13,21 @@ export interface AdvisorConfig {
     model?: string;
     tools?: string[];
     instructions?: string;
+    /** Per-advisor on/off toggle (default `true`). When `false`, the advisor
+     *  stays in the roster but its runtime is never built — it shows `○` in
+     *  the status line and `/advisor status` rather than disappearing. */
+    enabled?: boolean;
 }
+/**
+ * Runtime health of a single advisor, surfaced in stats and the status line.
+ * - `running` — actively processing primary turns
+ * - `paused` — user-toggled off via per-advisor switch (runtime disposed)
+ * - `quota_exhausted` — provider returned a quota/rate-limit error; the
+ *   runtime auto-retries after a cooldown so it can resume without user action
+ * - `error` — repeated transient failures; backlog dropped to prevent stall
+ * - `no_model` — no model resolved for this advisor's role/explicit model
+ */
+export type AdvisorRuntimeStatus = "running" | "paused" | "quota_exhausted" | "error" | "no_model";
 /**
  * The result of walking the `WATCHDOG.yml`/`WATCHDOG.yaml` search path: the
  * deduped advisor roster plus the concatenated top-level `instructions` baseline
@@ -83,12 +97,6 @@ export declare function resolveAdvisorConfigEditPath(scope: AdvisorConfigScope,
  * editor opens cleanly on a fresh or broken file.
  */
 export declare function loadWatchdogConfigFile(filePath: string): Promise<WatchdogConfigDoc>;
-/**
- * Serialize an editable doc back to block-style `WATCHDOG.yml` text via Bun's
- * `YAML.stringify` (the same API the repo uses for other hand-editable config),
- * omitting empty fields. Round-trips through {@link loadWatchdogConfigFile}.
- * Returns `""` for an empty doc.
- */
 export declare function serializeWatchdogConfig(doc: WatchdogConfigDoc): string;
 /**
  * Write an editable doc to `WATCHDOG.yml`. An empty doc removes the file so

package/dist/types/advisor/runtime.d.ts

@@ -33,10 +33,10 @@ export interface AdvisorRuntimeHost {
      * Pre-prompt context maintenance for the advisor's own append-only context.
      * Promotes the advisor model to a larger sibling when its context nears the
      * window (mirroring the primary's promote-first policy) and resolves `true`
-     * when the advisor should re-prime — reset and replay the current
-     * primary-bounded transcript — because promotion did not free enough room.
-     * Optional: hosts that omit it get no maintenance (context only shrinks when
-     * the primary's next compaction triggers {@link AdvisorRuntime.reset}).
+     * when the advisor must clear its own context before sending the current
+     * incremental update. The cursor stays at the current primary position: this
+     * recovery path must never replay the full primary transcript.
+     * Optional: hosts that omit it get no proactive maintenance.
      */
     maintainContext?(incomingTokens: number): Promise<boolean>;
     /**
@@ -49,16 +49,21 @@ export interface AdvisorRuntimeHost {
     /**
      * Called with the error of every failed advisor turn, before the retry sleep
      * or the dropped-after-3 path. Lets the host apply credential-level remedies
-     * the advisor loop lacks: the in-stream a/b/c auth retry rotates through
-     * sibling credentials within one request but never blocks the LAST failing
-     * one — the primary agent's retry pipeline does that via
-     * `markUsageLimitReached`, so without this hook the advisor re-picks the
-     * same usage-limited account on every retry. Errors thrown here are logged
-     * and swallowed.
+     * and configured model fallback that the advisor loop cannot perform itself.
+     * Return `true` after switching models so the same clean batch is retried
+     * immediately with a fresh failure budget. `failedMessages` contains the
+     * failed prompt's appended turns before rollback. Errors thrown here are
+     * logged and swallowed.
      */
-    onTurnError?(error: unknown): Promise<void> | void;
+    onTurnError?(error: unknown, failedMessages: readonly AgentMessage[]): Promise<boolean | undefined> | boolean | undefined;
+    /** Called after a successful advisor turn so the host can finish fallback lifecycle reporting. */
+    onTurnSuccess?(): Promise<void> | void;
     /** Surface a non-recovering advisor failure to the host UI without adding model-visible context. */
     notifyFailure?(error: unknown): void;
+    /** Signal that the advisor paused on a quota/rate-limit after host-level
+     *  recovery (credential switch, fallback chain) declined. Cleared only by
+     *  an explicit reset (`/new`, config rebuild, session restart). */
+    notifyQuotaExhausted?(): void;
 }
 /** Signals that an advisor response was discarded before it could become model-visible context. */
 export declare class AdvisorOutputQuarantinedError extends Error {
@@ -86,6 +91,10 @@ export declare class AdvisorRuntime {
     disposed: boolean;
     constructor(agent: AdvisorAgent, host: AdvisorRuntimeHost, retryDelayMs?: number);
     get backlog(): number;
+    get quotaExhausted(): boolean;
+    get failureNotified(): boolean;
+    /** True after the runtime hard-stopped on repeated or permanent failures. */
+    get halted(): boolean;
     /**
      * True when `#pending` is non-empty while the drain loop is busy — i.e., newer
      * primary turns arrived after the current batch's transcript window was fixed

package/dist/types/autolearn/controller.d.ts

@@ -18,6 +18,7 @@ export declare function buildAutoLearnInstructions(available: {
 export interface AutoLearnControllerOptions {
     session: AgentSession;
     settings: Settings;
+    capture: (content: string) => Promise<void>;
 }
 export declare class AutoLearnController {
     #private;

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

@@ -44,6 +44,23 @@ type LlamaCppDiscoveredModelRuntimeMetadata = {
 };
 export declare function discoverModelsByProviderType(providerConfig: DiscoveryProviderConfig, ctx: DiscoveryContext): Promise<Model<Api>[]>;
 export declare function discoverOllamaModels(providerConfig: DiscoveryProviderConfig, ctx: DiscoveryContext): Promise<Model<Api>[]>;
+/**
+ * applyLlamaCppQwenThinking rewrites a discovered or cached llama.cpp model so a
+ * Qwen-family chat template (which defaults `enable_thinking: true`) can be
+ * turned off. Qwen ids and the Qwen3.6-based PrismLM Ternary Bonsai GGUFs are
+ * routed through chat-completions (the implicit llama.cpp provider defaults to
+ * `openai-responses`, whose disable path has no Qwen encoding) with the
+ * `qwen-template-false` dialect; omp emits `preserve_thinking` inside
+ * `chat_template_kwargs` for Qwen, so the toggle rides there too and history
+ * `<think>` blocks survive (`qwenPreserveThinking`). The runtime base URL gets a
+ * `/v1` suffix because the chat-completions request would otherwise POST to the
+ * native root, which does not serve it. A model with a custom transport (e.g.
+ * `pi-native`, whose client appends `/v1/pi/stream`) keeps its base URL so the
+ * suffix is not doubled. Non-Qwen models pass through unchanged. Applied on both
+ * fresh discovery and cache load, so an upgraded cache is corrected without
+ * waiting for re-discovery.
+ */
+export declare function applyLlamaCppQwenThinking(model: Model<Api>): Model<Api>;
 export declare function discoverLlamaCppModels(providerConfig: DiscoveryProviderConfig, ctx: DiscoveryContext): Promise<Model<Api>[]>;
 export declare function discoverLlamaCppModelRuntimeMetadata(model: Pick<Model<Api>, "provider" | "id" | "baseUrl" | "headers">, ctx: DiscoveryContext): Promise<LlamaCppDiscoveredModelRuntimeMetadata | undefined>;
 export declare function discoverOpenAIModelsList(providerConfig: DiscoveryProviderConfig, ctx: DiscoveryContext): Promise<Model<Api>[]>;

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

@@ -94,11 +94,14 @@ export interface ParsedModelResult {
 export declare function parseModelPattern(pattern: string, availableModels: Model<Api>[], preferences?: ModelMatchPreferences, options?: {
     allowInvalidThinkingSelectorFallback?: boolean;
 }): ParsedModelResult;
+export interface ModelRoleLookup {
+    getModelRole(role: ModelRole | string): string | undefined;
+}
 /**
  * Expand a role alias like "@smol" to the configured model string.
  */
-export declare function expandRoleAlias(value: string, settings?: Settings): string;
-export declare function resolveConfiguredModelPatterns(value: string | string[] | undefined, settings?: Settings): string[];
+export declare function expandRoleAlias(value: string, settings?: ModelRoleLookup): string;
+export declare function resolveConfiguredModelPatterns(value: string | string[] | undefined, settings?: ModelRoleLookup): string[];
 export interface AgentModelPatternResolutionOptions {
     settingsOverride?: string | string[];
     agentModel?: string | string[];
@@ -135,6 +138,7 @@ export interface ResolvedModelRoleValue {
 }
 export declare function resolveModelRoleValue(roleValue: string | undefined, availableModels: Model<Api>[], options?: {
     settings?: Settings;
+    roleLookup?: ModelRoleLookup;
     matchPreferences?: ModelMatchPreferences;
 }): ResolvedModelRoleValue;
 interface ExplicitThinkingSelectorOptions {

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

@@ -14,6 +14,7 @@ import { type SearchProviderId } from "../web/search/types.js";
  *   settings.get("compaction.enabled")  // => boolean
  *   settings.set("theme.dark", "titanium")  // sync, saves in background
  */
+export type ModelRoleStorage = "global" | "project";
 export type SettingTab = "appearance" | "model" | "interaction" | "context" | "memory" | "files" | "shell" | "tools" | "tasks" | "providers";
 /** Tab display metadata - icon is resolved via theme.symbol() */
 export type TabMetadata = {
@@ -281,6 +282,26 @@ export declare const SETTINGS_SCHEMA: {
         readonly type: "array";
         readonly default: string[];
     };
+    readonly modelRoleStorage: {
+        readonly type: "enum";
+        readonly values: readonly ["global", "project"];
+        readonly default: "global";
+        readonly ui: {
+            readonly tab: "model";
+            readonly group: "Prompt";
+            readonly label: "Model Role Storage";
+            readonly description: "Where model selector role assignments are saved";
+            readonly options: readonly [{
+                readonly value: "global";
+                readonly label: "Global";
+                readonly description: "Save role models in the active profile config (current behavior)";
+            }, {
+                readonly value: "project";
+                readonly label: "Per-project";
+                readonly description: "Save project role models in .omp/config.yml; missing project roles use global defaults";
+            }];
+        };
+    };
     readonly modelRoles: {
         readonly type: "record";
         readonly default: Record<string, string>;
@@ -1424,7 +1445,7 @@ export declare const SETTINGS_SCHEMA: {
             readonly tab: "model";
             readonly group: "Retry & Fallback";
             readonly label: "Retry Fallback Chains";
-            readonly description: 'JSON object mapping model roles, model selectors ("provider/model-id"), or provider wildcards ("provider/*") to ordered fallback selectors, e.g. {"default":["openai/gpt-4o-mini"],"google-antigravity/*":["google/*","google-vertex/*"]}. Model-oriented keys apply whenever that model/provider is active, regardless of role; a "provider/*" entry keeps the failing model\'s id and swaps the provider.';
+            readonly description: 'JSON object mapping model roles, model selectors ("provider/model-id"), or provider wildcards ("provider/*") to ordered fallback selectors, e.g. {"default":["openai/gpt-4o-mini"],"google-antigravity/*":["google/*","google-vertex/*"]}. Model-oriented keys apply whenever that model/provider is active, regardless of role; a "provider/*" entry keeps the failing model\'s id and swaps the provider. An id-prefixed wildcard ("openrouter/google/*") re-prefixes the failing model\'s bare id (google-antigravity/gemini-x -> openrouter/google/gemini-x) and, used as a key, matches only that provider\'s ids under the prefix.';
         };
     };
     readonly "retry.fallbackRevertPolicy": {
@@ -2547,7 +2568,7 @@ export declare const SETTINGS_SCHEMA: {
             readonly tab: "memory";
             readonly group: "Auto-Learn";
             readonly label: "Auto-run capture at stop";
-            readonly description: "When on, auto-run one capture turn at stop (uses extra tokens). Off = passive reminder on your next turn.";
+            readonly description: "When on, auto-run one private capture turn at stop (uses extra tokens). When off, only standing auto-learn guidance remains.";
             readonly condition: "autolearnActive";
         };
     };
@@ -3721,7 +3742,7 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly "generate_image.enabled": {
         readonly type: "boolean";
-        readonly default: true;
+        readonly default: false;
         readonly ui: {
             readonly tab: "tools";
             readonly group: "Available Tools";
@@ -4619,7 +4640,7 @@ export declare const SETTINGS_SCHEMA: {
             }, {
                 readonly value: "kimi";
                 readonly label: "Kimi";
-                readonly description: "Requires MOONSHOT_SEARCH_API_KEY or MOONSHOT_API_KEY";
+                readonly description: "Kimi Code search (requires a Kimi Code Console key via KIMI_SEARCH_API_KEY/MOONSHOT_SEARCH_API_KEY or /login kimi-code; not MOONSHOT_API_KEY)";
             }, {
                 readonly value: "parallel";
                 readonly label: "Parallel";
@@ -4705,7 +4726,7 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly "providers.image": {
         readonly type: "enum";
-        readonly values: readonly ["auto", "openai", "antigravity", "xai", "gemini", "openrouter"];
+        readonly values: readonly ["auto", "openai", "openai-codex", "antigravity", "xai", "gemini", "openrouter"];
         readonly default: "auto";
         readonly ui: {
             readonly tab: "providers";
@@ -4715,11 +4736,15 @@ export declare const SETTINGS_SCHEMA: {
             readonly options: readonly [{
                 readonly value: "auto";
                 readonly label: "Auto";
-                readonly description: "Priority: active session provider > GPT model image tool > Antigravity > xAI > OpenRouter > Gemini";
+                readonly description: "Priority: per-request provider > configured provider > active session provider > GPT model image tool > Codex subscription > Antigravity > xAI > OpenRouter > Gemini";
             }, {
                 readonly value: "openai";
                 readonly label: "OpenAI";
-                readonly description: "Uses the active GPT Responses/Codex model";
+                readonly description: "OPENAI_API_KEY (gpt-image-2) or active GPT model; falls back to a connected Codex subscription";
+            }, {
+                readonly value: "openai-codex";
+                readonly label: "OpenAI Codex (ChatGPT)";
+                readonly description: "Uses a connected Codex / ChatGPT subscription — no OPENAI_API_KEY needed";
             }, {
                 readonly value: "antigravity";
                 readonly label: "Antigravity";

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

@@ -131,12 +131,62 @@ export declare class Settings {
     /**
      * Set a model role (helper for modelRoles record). Passing `undefined`
      * clears the role from the persisted record and any runtime override.
+     *
+     * In project storage mode, when a project edit has temporarily replaced
+     * the process-wide runtime override for `role` and that override is still
+     * active (the runtime slot currently matches the project value), the
+     * global-layer write must not rewrite that runtime slot — otherwise the
+     * global fallback would immediately shadow the still-configured project
+     * role. The global layer is still persisted; only the runtime override is
+     * left untouched. The guard is precise so that a later clear, a late
+     * `overrideModelRoles`, or a storage-mode transition does not leave a
+     * stale skip in place.
      */
     setModelRole(role: ModelRole | string, modelId: string | undefined): void;
+    /**
+     * Whether `role`'s runtime override slot currently holds the temporary
+     * project-scoped value installed by a prior `setProjectModelRole`. Returns
+     * `false` when storage is not project-mode, no capture exists, or the
+     * project role was cleared. With explicit provenance invalidation, a
+     * surviving capture implies no external supersession occurred.
+     */
+    isProjectModelRoleRuntimeOverrideActive(role: ModelRole | string): boolean;
+    /**
+     * Set a model role in the current project's settings layer.
+     */
+    setProjectModelRole(role: ModelRole | string, modelId: string): void;
+    /**
+     * Clear a model role from the current project's settings layer.
+     */
+    clearProjectModelRole(role: ModelRole | string): void;
     /**
      * Get a model role (helper for modelRoles record).
      */
     getModelRole(role: ModelRole | string): string | undefined;
+    /**
+     * Get a model role from only the global settings layer.
+     */
+    getGlobalModelRole(role: ModelRole | string): string | undefined;
+    /**
+     * Get a model role from only the current project settings layer.
+     */
+    getProjectModelRole(role: ModelRole | string): string | undefined;
+    /**
+     * Report which layer actually supplies the effective model role across
+     * full merge precedence (runtime override → config overlay → project →
+     * global → default). Unlike {@link getModelRoleSource}, this accounts
+     * for runtime and config-overlay layers and detects ownership by key
+     * presence rather than normalized value, so a `null` tombstone in the
+     * overlay or runtime layer correctly blocks lower layers. The project
+     * layer is checked through {@link #projectSettingsForMerge} because a
+     * project null is a cleared value (falls back to global), not a
+     * tombstone.
+     */
+    getModelRoleProvenance(role: ModelRole | string): "runtime" | "overlay" | "project" | "global" | "default";
+    /**
+     * Get the persisted layer supplying a model role (project/global/default only).
+     */
+    getModelRoleSource(role: ModelRole | string): "project" | "global" | "default";
     /**
      * Get all model roles (helper for modelRoles record).
      */

package/dist/types/cursor.d.ts

@@ -2,9 +2,20 @@ import type { AgentEvent, AgentTool, AgentToolContext } from "@oh-my-pi/pi-agent
 import type { CursorMcpCall, CursorShellStreamCallbacks, CursorExecHandlers as ICursorExecHandlers, ToolResultMessage } from "@oh-my-pi/pi-ai";
 interface CursorExecBridgeOptions {
     cwd: string;
+    getCwd?: () => string;
     tools: Map<string, AgentTool>;
+    getTool?: (name: string) => AgentTool | undefined;
     getToolContext?: () => AgentToolContext | undefined;
     emitEvent?: (event: AgentEvent) => void;
+    /**
+     * Whether the Cursor native `delete` frame may remove files. Unlike every
+     * other exec handler, `executeDelete` mutates the filesystem directly instead
+     * of consulting {@link tools}, so a background read-only advisor could delete
+     * workspace files it was never granted a mutating tool for (issue #5680
+     * review). Defaults to allowed to preserve the primary agent's behavior;
+     * callers with a restricted tool set (advisors) opt out.
+     */
+    allowNativeDelete?: boolean;
 }
 export declare class CursorExecHandlers implements ICursorExecHandlers {
     private options;

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

@@ -185,13 +185,16 @@ export declare function buildExtensionModuleItems(providerId: string, userPaths:
  * Entry for an installed Claude Code plugin.
  */
 export interface ClaudePluginEntry {
-    scope: "user" | "project";
+    /** Claude registry scope; local entries are restricted to their project path. */
+    scope?: "user" | "project" | "local";
     installPath: string;
     version: string;
     installedAt: string;
     lastUpdated: string;
     gitCommitSha?: string;
     enabled?: boolean;
+    /** Project root recorded by Claude for a local installation. */
+    projectPath?: string;
 }
 /**
  * Claude Code installed_plugins.json registry format.
@@ -254,7 +257,7 @@ export declare function registerPluginCacheInvalidator(invalidator: () => void):
  * Reads ~/.claude/plugins/installed_plugins.json and ~/.omp/plugins/installed_plugins.json,
  * and optionally the nearest project-scoped registry resolved from `cwd`.
  *
- * Results are cached per `home:resolvedProjectPath` key to avoid repeated parsing.
+ * Results are cached per home, project registry, and canonical active project.
  */
 export declare function listClaudePluginRoots(home: string, cwd?: string): Promise<{
     roots: ClaudePluginRoot[];

package/dist/types/exec/bash-executor.d.ts

@@ -33,6 +33,8 @@ export interface BashResult {
     output: string;
     exitCode: number | undefined;
     cancelled: boolean;
+    /** True when the command was killed by its timeout deadline (not a user abort). */
+    timedOut?: boolean;
     truncated: boolean;
     totalLines: number;
     totalBytes: number;

package/dist/types/extensibility/extensions/managed-timers.d.ts

@@ -0,0 +1,15 @@
+/** Callback invoked when a managed timer's callback throws or rejects. */
+export type ManagedTimerErrorHandler = (event: string, error: string, stack?: string) => void;
+export declare class ManagedTimers {
+    #private;
+    private readonly onError;
+    constructor(onError: ManagedTimerErrorHandler);
+    /** Schedule a repeating callback whose throws are contained. */
+    setInterval(callback: (...args: unknown[]) => void, ms?: number, ...args: unknown[]): Timer;
+    /** Schedule a one-shot callback whose throws are contained. Deregisters after it fires. */
+    setTimeout(callback: (...args: unknown[]) => void, ms?: number, ...args: unknown[]): Timer;
+    /** Clear one managed timer. Accepts an interval or timeout handle. */
+    clear(timer: Timer): void;
+    /** Clear every outstanding managed timer. Called on session teardown. */
+    clearAll(): void;
+}

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

@@ -118,6 +118,13 @@ export declare class ExtensionRunner {
      * Request a graceful shutdown. Called by extension tools and event handlers.
      */
     shutdown(): void;
+    /**
+     * Clear every timer scheduled through `ctx.setInterval` / `ctx.setTimeout`.
+     * Called during session teardown so extension background work does not
+     * outlive the session (a self-scheduling interval would otherwise keep
+     * firing against a disposed session).
+     */
+    clearManagedTimers(): void;
     createCommandContext(): ExtensionCommandContext;
     emit<TEvent extends RunnerEmitEvent>(event: TEvent): Promise<RunnerEmitResult<TEvent>>;
     emitToolResult(event: ToolResultEvent): Promise<ToolResultEventResult | undefined>;

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

@@ -304,6 +304,24 @@ export interface ExtensionContext {
     getSystemPrompt(): string[];
     /** Structured memory runtime for status/search/save across the configured backend. */
     memory?: MemoryRuntimeContext;
+    /**
+     * Schedule a repeating callback whose throws are contained. Unlike raw
+     * `setInterval`, a synchronous throw or rejected promise from `callback` is
+     * logged and surfaced through the extension error channel instead of
+     * escaping as a process-fatal `uncaughtException` — one misbehaving timer
+     * can no longer take down the whole session. The handle is `unref`'d and
+     * cleared automatically on `session_shutdown`. Prefer this over raw
+     * `setInterval` for any extension background work.
+     */
+    setInterval(callback: (...args: unknown[]) => void, ms?: number, ...args: unknown[]): Timer;
+    /**
+     * Schedule a one-shot callback whose throws are contained, mirroring
+     * {@link setInterval}. Cleared automatically on `session_shutdown` if it has
+     * not yet fired.
+     */
+    setTimeout(callback: (...args: unknown[]) => void, ms?: number, ...args: unknown[]): Timer;
+    /** Clear a timer scheduled via {@link setInterval} or {@link setTimeout}. */
+    clearTimer(timer: Timer): void;
 }
 /**
  * Extended context for command handlers.

package/dist/types/extensibility/legacy-pi-coding-agent-shim.d.ts

@@ -114,6 +114,46 @@ export declare const SettingsManager: {
     readonly create: (cwd: string, agentDir?: string) => Promise<Settings>;
     readonly inMemory: () => Settings;
 };
+/** Scope used by the legacy package manager for discovered resources. */
+export type SourceScope = "user" | "project" | "temporary";
+/** Discovery metadata exposed alongside a legacy package resource path. */
+export interface PathMetadata {
+    source: string;
+    scope: SourceScope;
+    origin: "package" | "top-level";
+    baseDir?: string;
+}
+/** One extension, skill, prompt, or theme resolved by the legacy package manager. */
+export interface ResolvedResource {
+    path: string;
+    enabled: boolean;
+    metadata: PathMetadata;
+}
+/** Resource groups returned by {@link DefaultPackageManager.resolve}. */
+export interface ResolvedPaths {
+    extensions: ResolvedResource[];
+    skills: ResolvedResource[];
+    prompts: ResolvedResource[];
+    themes: ResolvedResource[];
+}
+/** Action a legacy caller requests when a configured package is unavailable. */
+export type MissingSourceAction = "install" | "skip" | "error";
+/** Construction inputs accepted by the legacy package manager. */
+export interface DefaultPackageManagerOptions {
+    cwd: string;
+    agentDir: string;
+    settingsManager: Settings | Promise<Settings>;
+}
+/**
+ * Enumerates the extensions OMP would load through the historical package
+ * manager surface used by legacy extensions.
+ */
+export declare class DefaultPackageManager {
+    #private;
+    constructor(options: DefaultPackageManagerOptions);
+    /** Resolve enabled extension paths with their OMP plugin provenance. */
+    resolve(_onMissing?: (source: string) => Promise<MissingSourceAction>): Promise<ResolvedPaths>;
+}
 /**
  * Resource-loader compatibility layer for legacy pi extensions.
  *

package/dist/types/extensibility/shared-events.d.ts

@@ -152,6 +152,12 @@ export interface AgentStartEvent {
 export interface AgentEndEvent {
     type: "agent_end";
     messages: AgentMessage[];
+    /**
+     * When true, the session has already scheduled an automatic continuation
+     * (auto-retry, empty/unexpected-stop retry, etc.). Subscribers must not
+     * treat this as a user-visible terminal settle.
+     */
+    willContinue?: boolean;
 }
 /** Fired at the start of each turn */
 export interface TurnStartEvent {

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

@@ -11,7 +11,7 @@ export declare function resolvePath(filePath: string, cwd: string): string;
  */
 export declare function createNoOpUIContext(): HookUIContext;
 /**
- * Raised by {@link withExitGuard} when a guarded callback synchronously
+ * Raised by {@link withHostGuard} when a guarded callback synchronously
  * attempts to terminate the host process. Callers catch this like any other
  * load-time failure so the extension/hook is skipped with a logged error
  * instead of taking the CLI down with it.
@@ -21,4 +21,4 @@ export declare class ExtensionExitError extends Error {
     readonly code: number | string | undefined;
     constructor(code: number | string | undefined, alias?: string);
 }
-export declare function withExitGuard<T>(fn: () => Promise<T>): Promise<T>;
+export declare function withHostGuard<T>(fn: () => Promise<T>): Promise<T>;

package/dist/types/mcp/transports/stdio.d.ts

@@ -37,6 +37,18 @@ export interface StdioSpawnCommand {
      * grandchildren keep stdout routed through our pipe (#3544).
      */
     detached: boolean;
+    /**
+     * Pass argv to `Bun.spawn` verbatim (Windows only), suppressing the
+     * default libuv backslash-quoting.
+     *
+     * Set when `cmd` already holds a `cmd.exe /d /e:ON /v:OFF /c "<line>"`
+     * command line escaped for `cmd.exe`'s parser (see `buildCmdExeArgv`).
+     * libuv's quoting targets `CommandLineToArgvW`, not `cmd.exe`, so letting
+     * it re-quote a batch launch would corrupt arguments and re-open the
+     * `%VAR%` / quote-injection holes the escaping closes (BatBadBut,
+     * CVE-2024-24576).
+     */
+    windowsVerbatimArguments?: boolean;
 }
 /** Inputs used to resolve platform-specific stdio spawn behavior. */
 export interface ResolveStdioSpawnOptions {
@@ -55,7 +67,7 @@ export interface ResolveStdioSpawnOptions {
  * only appends `.exe` for extensionless names — `.cmd`/`.bat` are never
  * tried, so `npx` (which exists only as `npx.cmd` on Windows) crashes the
  * subprocess immediately. When the resolver can't pin the command down,
- * route through `cmd.exe /d /s /c` so Windows's own PATHEXT lookup runs.
+ * route through `cmd.exe` so Windows's own PATHEXT lookup runs.
  */
 export declare function resolveStdioSpawnCommand(config: MCPStdioServerConfig, options: ResolveStdioSpawnOptions): Promise<StdioSpawnCommand>;
 /** Minimal write surface of `Subprocess.stdin` we need for framed sends. */

package/dist/types/modes/components/advisor-config.d.ts

@@ -16,11 +16,13 @@
  * `save` callback.
  */
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Model } from "@oh-my-pi/pi-ai";
+import type { Model, UsageReport } from "@oh-my-pi/pi-ai";
 import { type Component, type TUI } from "@oh-my-pi/pi-tui";
 import { type AdvisorConfigScope, type WatchdogConfigDoc } from "../../advisor/index.js";
 import type { ModelRegistry } from "../../config/model-registry.js";
 import type { Settings } from "../../config/settings.js";
+import type { PerAdvisorStat } from "../../session/agent-session.js";
+import type { OAuthAccountIdentity } from "../../session/auth-storage.js";
 /** Host callbacks: all disk + live-runtime effects flow through these. */
 export interface AdvisorConfigCallbacks {
     /** Load a scope's `WATCHDOG.yml` into an editable doc (empty when absent). */
@@ -32,6 +34,11 @@ export interface AdvisorConfigCallbacks {
     requestRender: () => void;
     /** Surface a transient status/warning line to the user. */
     notify: (message: string) => void;
+    /** Live advisor usage stats; lets the preview show tokens/cost per advisor. */
+    getAdvisorStats?: () => PerAdvisorStat[];
+    getUsageReports?: () => Promise<UsageReport[] | null>;
+    /** Resolve the active OAuth identity for quota filtering (per-advisor account stickiness). */
+    resolveActiveAccount?: (provider: string, sessionId?: string) => OAuthAccountIdentity | undefined;
 }
 export interface AdvisorConfigDeps {
     modelRegistry: ModelRegistry;

package/dist/types/modes/components/hook-editor.d.ts

@@ -11,6 +11,13 @@ import { Container, type Focusable, type TUI } from "@oh-my-pi/pi-tui";
 export interface HookEditorOptions {
     /** When true, use prompt-style keybindings with the legacy ask prompt chrome. */
     promptStyle?: boolean;
+    /**
+     * Max rows the inner Editor may occupy. When omitted, the editor is
+     * bounded to the current terminal height minus the component's chrome
+     * (≈10 rows) so long content scrolls instead of pushing the submit
+     * hint out of view.
+     */
+    maxHeight?: number;
 }
 /** Interactive multiline dialog used by hooks and the ask tool's Other response. */
 export declare class HookEditorComponent extends Container implements Focusable {

package/dist/types/modes/components/model-hub.d.ts

@@ -8,11 +8,12 @@ export interface ScopedModelItem {
     model: Model;
     thinkingLevel?: string;
 }
+export type ModelRoleSelectionScope = "global" | "project";
 export interface ModelHubCallbacks {
     /** Persist a role assignment. */
-    onAssign: (model: Model, role: string, thinkingLevel: ConfiguredThinkingLevel | undefined, selector: string) => void;
+    onAssign: (model: Model, role: string, thinkingLevel: ConfiguredThinkingLevel | undefined, selector: string, scope?: ModelRoleSelectionScope) => void;
     /** Clear a configured role back to auto-selection. */
-    onUnassign: (role: string) => void;
+    onUnassign: (role: string, scope?: ModelRoleSelectionScope) => void;
     /** Persist a `retry.fallbackChains` entry — keyed by a role, `provider/model-id`, or `provider/*`; an empty chain clears the key. */
     onFallbackChainChange?: (role: string, chain: string[]) => void;
     /** Locked provider activation: forward to the /login flow. */
@@ -37,6 +38,8 @@ export declare class ModelHubComponent implements Component {
     /** Cancel pending provider refresh timers and the spinner. Host calls this on overlay close. */
     dispose(): void;
     invalidate(): void;
+    /** Re-sync after an asynchronous callback finishes mutating settings. */
+    refreshAfterExternalMutation(): void;
     handleInput(data: string): void;
     render(width: number): string[];
 }

package/dist/types/modes/components/session-selector.d.ts

@@ -85,6 +85,8 @@ export declare class SessionSelectorComponent extends Container {
     setOnRequestRender(callback: () => void): void;
     /** Ignore input after selection while the host resumes the session. */
     lockInput(): void;
+    /** Re-enable input after a failed resume so the user can pick again. */
+    unlockInput(): void;
     /**
      * Dispose the session list explicitly: while the delete-confirmation dialog
      * is mounted the list is detached from the child tree, so Container's

package/dist/types/modes/controllers/command-controller.d.ts

@@ -52,4 +52,12 @@ export declare class CommandController {
     handleHandoffCommand(customInstructions?: string): Promise<void>;
 }
 export declare function renderProviderSection(details: ProviderDetails, uiTheme: Pick<typeof theme, "fg">): string;
+/**
+ * Compact one-line quota summary for a single advisor's provider.
+ * Returns `null` when the provider has no usage data.
+ * When `activeAccount` is provided, only limits matching that credential
+ * are shown (mirrors `renderUsageReports`'s account-stickiness filtering).
+ * Example output: `Quota: 7d window · 67% used · resets in 3.2d`
+ */
+export declare function formatCompactQuota(provider: string, reports: UsageReport[], nowMs: number, activeAccount?: OAuthAccountIdentity): string | null;
 export declare function renderUsageReports(reports: UsageReport[], uiTheme: typeof theme, nowMs: number, availableWidth: number, resolveActiveAccount?: (provider: string) => OAuthAccountIdentity | undefined): string;