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

package/dist/types/advisor/advise-tool.d.ts

@@ -59,8 +59,11 @@ export declare function isAdvisorInterruptImmuneTurnActive(opts: {
  *   the live turn while one is streaming, or (when idle) a triggered turn so the
  *   advice is acted on immediately.
  * - If the primary tail is already a terminal text answer and there is no queued
- *   work, late interrupting advice is preserved as a visible card instead of
- *   waking the primary to restate completion.
+ *   work, a late `concern` is preserved as a visible card instead of waking the
+ *   primary to restate completion. A `blocker` is the exception: it means the
+ *   agent handed off broken or unexercised work, so it still steers a triggered
+ *   turn to force the primary to acknowledge and continue before the turn is
+ *   considered done (#5628) — deferring it to the next user turn is the bug.
  * - After a deliberate user interrupt (`autoResumeSuppressed`) the advisor must
  *   not auto-resume the stopped run. While the agent is idle — or still tearing
  *   the interrupted turn down (`aborting`) — the note is preserved as a visible

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/cli-commands.d.ts

@@ -10,7 +10,20 @@
  */
 import type { CommandEntry } from "@oh-my-pi/pi-utils/cli";
 export declare const commands: CommandEntry[];
-export declare function reservedTopLevelWordMessage(first: string | undefined, argc?: number): string | undefined;
+/**
+ * Hint for a reserved plugin/marketplace verb used as a top-level command, or
+ * `undefined` when the argv should fall through to `launch`.
+ *
+ * A bare verb (`omp marketplace`) always hints. A multi-word invocation only
+ * hints when the arguments follow the documented plugin grammar — a marketplace
+ * sub-action (`omp marketplace add …`) or a `name@marketplace` plugin id
+ * (`omp uninstall foo@bar`) — so genuine prompts that merely begin with one of
+ * these words (`omp list all my files`, `omp upgrade the deps`) still launch.
+ *
+ * Flags (`-…`) and `@file` arguments in the verb slot are never management
+ * commands; those fall through to the default `launch` command.
+ */
+export declare function reservedTopLevelWordMessage(argv: readonly string[]): string | undefined;
 /**
  * Return true when `first` matches a registered subcommand name or alias.
  *

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

@@ -134,6 +134,10 @@ export declare class ModelRegistry {
      * Get the base URL associated with a provider, if any model defines one.
      */
     getProviderBaseUrl(provider: string): string | undefined;
+    /**
+     * Get provider-level headers without including per-model overrides.
+     */
+    getProviderHeaders(provider: string): Record<string, string> | undefined;
     /**
      * Get API key for a model.
      */

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/models-config-schema.d.ts

@@ -46,6 +46,7 @@ export declare const OpenAICompatSchema: import("arktype/internal/variants/objec
     alwaysSendMaxTokens?: boolean | undefined;
     strictResponsesPairing?: boolean | undefined;
     supportsImageDetailOriginal?: boolean | undefined;
+    supportsEagerToolInputStreaming?: boolean | undefined;
     requiresToolResultId?: boolean | undefined;
     replayUnsignedThinking?: boolean | undefined;
     whenThinking?: {
@@ -96,6 +97,7 @@ export declare const OpenAICompatSchema: import("arktype/internal/variants/objec
         alwaysSendMaxTokens?: boolean | undefined;
         strictResponsesPairing?: boolean | undefined;
         supportsImageDetailOriginal?: boolean | undefined;
+        supportsEagerToolInputStreaming?: boolean | undefined;
         requiresToolResultId?: boolean | undefined;
         replayUnsignedThinking?: boolean | undefined;
     } | undefined;
@@ -189,6 +191,7 @@ export declare const ModelOverrideSchema: import("arktype/internal/variants/obje
         alwaysSendMaxTokens?: boolean | undefined;
         strictResponsesPairing?: boolean | undefined;
         supportsImageDetailOriginal?: boolean | undefined;
+        supportsEagerToolInputStreaming?: boolean | undefined;
         requiresToolResultId?: boolean | undefined;
         replayUnsignedThinking?: boolean | undefined;
         whenThinking?: {
@@ -239,6 +242,7 @@ export declare const ModelOverrideSchema: import("arktype/internal/variants/obje
             alwaysSendMaxTokens?: boolean | undefined;
             strictResponsesPairing?: boolean | undefined;
             supportsImageDetailOriginal?: boolean | undefined;
+            supportsEagerToolInputStreaming?: boolean | undefined;
             requiresToolResultId?: boolean | undefined;
             replayUnsignedThinking?: boolean | undefined;
         } | undefined;
@@ -319,6 +323,7 @@ export declare const ModelsConfigSchema: import("arktype/internal/variants/objec
                 alwaysSendMaxTokens?: boolean | undefined;
                 strictResponsesPairing?: boolean | undefined;
                 supportsImageDetailOriginal?: boolean | undefined;
+                supportsEagerToolInputStreaming?: boolean | undefined;
                 requiresToolResultId?: boolean | undefined;
                 replayUnsignedThinking?: boolean | undefined;
                 whenThinking?: {
@@ -369,6 +374,7 @@ export declare const ModelsConfigSchema: import("arktype/internal/variants/objec
                     alwaysSendMaxTokens?: boolean | undefined;
                     strictResponsesPairing?: boolean | undefined;
                     supportsImageDetailOriginal?: boolean | undefined;
+                    supportsEagerToolInputStreaming?: boolean | undefined;
                     requiresToolResultId?: boolean | undefined;
                     replayUnsignedThinking?: boolean | undefined;
                 } | undefined;
@@ -479,6 +485,7 @@ export declare const ModelsConfigSchema: import("arktype/internal/variants/objec
                     alwaysSendMaxTokens?: boolean | undefined;
                     strictResponsesPairing?: boolean | undefined;
                     supportsImageDetailOriginal?: boolean | undefined;
+                    supportsEagerToolInputStreaming?: boolean | undefined;
                     requiresToolResultId?: boolean | undefined;
                     replayUnsignedThinking?: boolean | undefined;
                     whenThinking?: {
@@ -529,6 +536,7 @@ export declare const ModelsConfigSchema: import("arktype/internal/variants/objec
                         alwaysSendMaxTokens?: boolean | undefined;
                         strictResponsesPairing?: boolean | undefined;
                         supportsImageDetailOriginal?: boolean | undefined;
+                        supportsEagerToolInputStreaming?: boolean | undefined;
                         requiresToolResultId?: boolean | undefined;
                         replayUnsignedThinking?: boolean | undefined;
                     } | undefined;
@@ -635,6 +643,7 @@ export declare const ModelsConfigSchema: import("arktype/internal/variants/objec
                         alwaysSendMaxTokens?: boolean | undefined;
                         strictResponsesPairing?: boolean | undefined;
                         supportsImageDetailOriginal?: boolean | undefined;
+                        supportsEagerToolInputStreaming?: boolean | undefined;
                         requiresToolResultId?: boolean | undefined;
                         replayUnsignedThinking?: boolean | undefined;
                         whenThinking?: {
@@ -685,6 +694,7 @@ export declare const ModelsConfigSchema: import("arktype/internal/variants/objec
                             alwaysSendMaxTokens?: boolean | undefined;
                             strictResponsesPairing?: boolean | undefined;
                             supportsImageDetailOriginal?: boolean | undefined;
+                            supportsEagerToolInputStreaming?: boolean | undefined;
                             requiresToolResultId?: boolean | undefined;
                             replayUnsignedThinking?: boolean | undefined;
                         } | undefined;

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

@@ -84,6 +84,7 @@ export declare const ModelsConfigFile: ConfigFile<{
                 alwaysSendMaxTokens?: boolean | undefined;
                 strictResponsesPairing?: boolean | undefined;
                 supportsImageDetailOriginal?: boolean | undefined;
+                supportsEagerToolInputStreaming?: boolean | undefined;
                 requiresToolResultId?: boolean | undefined;
                 replayUnsignedThinking?: boolean | undefined;
                 whenThinking?: {
@@ -134,6 +135,7 @@ export declare const ModelsConfigFile: ConfigFile<{
                     alwaysSendMaxTokens?: boolean | undefined;
                     strictResponsesPairing?: boolean | undefined;
                     supportsImageDetailOriginal?: boolean | undefined;
+                    supportsEagerToolInputStreaming?: boolean | undefined;
                     requiresToolResultId?: boolean | undefined;
                     replayUnsignedThinking?: boolean | undefined;
                 } | undefined;
@@ -228,6 +230,7 @@ export declare const ModelsConfigFile: ConfigFile<{
                     alwaysSendMaxTokens?: boolean | undefined;
                     strictResponsesPairing?: boolean | undefined;
                     supportsImageDetailOriginal?: boolean | undefined;
+                    supportsEagerToolInputStreaming?: boolean | undefined;
                     requiresToolResultId?: boolean | undefined;
                     replayUnsignedThinking?: boolean | undefined;
                     whenThinking?: {
@@ -278,6 +281,7 @@ export declare const ModelsConfigFile: ConfigFile<{
                         alwaysSendMaxTokens?: boolean | undefined;
                         strictResponsesPairing?: boolean | undefined;
                         supportsImageDetailOriginal?: boolean | undefined;
+                        supportsEagerToolInputStreaming?: boolean | undefined;
                         requiresToolResultId?: boolean | undefined;
                         replayUnsignedThinking?: boolean | undefined;
                     } | undefined;
@@ -368,6 +372,7 @@ export declare const ModelsConfigFile: ConfigFile<{
                         alwaysSendMaxTokens?: boolean | undefined;
                         strictResponsesPairing?: boolean | undefined;
                         supportsImageDetailOriginal?: boolean | undefined;
+                        supportsEagerToolInputStreaming?: boolean | undefined;
                         requiresToolResultId?: boolean | undefined;
                         replayUnsignedThinking?: boolean | undefined;
                         whenThinking?: {
@@ -418,6 +423,7 @@ export declare const ModelsConfigFile: ConfigFile<{
                             alwaysSendMaxTokens?: boolean | undefined;
                             strictResponsesPairing?: boolean | undefined;
                             supportsImageDetailOriginal?: boolean | undefined;
+                            supportsEagerToolInputStreaming?: boolean | undefined;
                             requiresToolResultId?: boolean | undefined;
                             replayUnsignedThinking?: boolean | undefined;
                         } | undefined;

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: 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/discovery/substitute-plugin-root.d.ts

@@ -1,23 +1,36 @@
 export declare function substitutePluginRoot<T>(value: T, rootPath: string): T;
 /**
- * Rebase relative filesystem values in a discovered plugin stdio config against
- * the directory of the `.mcp.json` that declared them.
+ * Where a relative, path-like `command` is rooted by {@link resolvePluginStdioPaths}.
  *
- * External plugin configs (bundled ChatGPT/Codex plugins, Claude marketplace
- * plugins) express `command`/`cwd` relative to their own config file, but MCP
- * stdio spawning roots relative values at the session cwd — so a plugin shipping
+ * - `"config-dir"` (default): the directory of the config file that declared the
+ *   server — the plugin package root for `.mcp.json`. A plugin can ship its
+ *   executable at the package root (`command: "./bin/server"`) yet run from a
+ *   data subdir (`cwd: "work"`); the command stays `<pkg>/bin/server`.
+ * - `"cwd"`: the rooted `cwd`, falling back to the config dir when no `cwd` is
+ *   set. This matches how the OS resolves a relative command against the
+ *   subprocess's working directory, which is the Codex `config.toml` contract:
+ *   `cwd = "server"`, `command = "./bin/mcp"` → `<configDir>/server/bin/mcp`.
+ */
+export type StdioCommandBase = "config-dir" | "cwd";
+/**
+ * Rebase relative filesystem values in a discovered stdio server config against
+ * the directory of the config file (`.mcp.json`/`config.toml`) that declared them.
+ *
+ * External configs (bundled ChatGPT/Codex plugins, Claude marketplace plugins)
+ * express `command`/`cwd` relative to their own config file, but MCP stdio
+ * spawning roots relative values at the session cwd — so a server shipping
  * `command: "./bin/server"`, `cwd: "."` launches from the wrong directory and
  * fails with ENOENT. This resolves those against `configDir` instead:
  *
  * - relative `cwd` → resolved against `configDir`;
  * - path-like `command` (`./`, `../`, or the Windows `.\`/`..\` forms) →
- *   resolved against `configDir`;
+ *   resolved against the base selected by `commandBase` (see {@link StdioCommandBase});
  * - bare executables (`npx`, `uvx`, …) and absolute paths are left untouched.
  */
 export declare function resolvePluginStdioPaths(config: {
     command?: string;
     cwd?: string;
-}, configDir: string): {
+}, configDir: string, commandBase?: StdioCommandBase): {
     command?: string;
     cwd?: string;
 };

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>;