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

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/internal-urls/agent-protocol.d.ts

@@ -6,6 +6,7 @@ import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } fr
  * with optional JSON extraction.
  */
 export declare class AgentProtocolHandler implements ProtocolHandler {
+    #private;
     readonly scheme = "agent";
     readonly immutable = true;
     resolve(url: InternalUrl): Promise<InternalResource>;

package/dist/types/lib/xai-http.d.ts

@@ -5,6 +5,17 @@ interface XAICredentials {
     baseURL: string;
 }
 export declare function ohMyPiXAIUserAgent(): string;
+/** xAI provider ids supported by shared HTTP tool transport resolution. */
+export type XAIHttpProvider = "xai-oauth" | "xai";
+/** Resolved endpoint and configured headers for an xAI HTTP tool request. */
+export interface XAIHttpTransport {
+    baseURL: string;
+    headers?: Record<string, string>;
+}
+/**
+ * Resolve an xAI tool endpoint and its provider/model header overrides.
+ */
+export declare function resolveXAIHttpTransport(modelRegistry: ModelRegistry, provider: XAIHttpProvider, modelId?: string): XAIHttpTransport;
 /**
  * Resolve xAI credentials for HTTP tool calls.
  *

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/acp/acp-agent.d.ts

@@ -1,4 +1,5 @@
 import { type Agent, type AgentSideConnection, type AuthenticateRequest, type AuthenticateResponse, type ClientCapabilities, type CloseSessionRequest, type CloseSessionResponse, type ForkSessionRequest, type ForkSessionResponse, type InitializeRequest, type InitializeResponse, type ListSessionsRequest, type ListSessionsResponse, type LoadSessionRequest, type LoadSessionResponse, type NewSessionRequest, type NewSessionResponse, type PromptRequest, type PromptResponse, type ResumeSessionRequest, type ResumeSessionResponse, type SetSessionConfigOptionRequest, type SetSessionConfigOptionResponse, type SetSessionModeRequest, type SetSessionModeResponse } from "@agentclientprotocol/sdk";
+import { type postmortem } from "@oh-my-pi/pi-utils";
 import { type ExtensionUIContext } from "../../extensibility/extensions/index.js";
 import type { AgentSession } from "../../session/agent-session.js";
 /**
@@ -56,5 +57,7 @@ export declare class AcpAgent implements Agent {
     }): Promise<void>;
     get signal(): AbortSignal;
     get closed(): Promise<void>;
+    /** Dispose every session owned by this ACP connection and await persisted teardown. */
+    dispose(reason?: postmortem.Reason): Promise<void>;
 }
 export {};

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

@@ -1,5 +1,9 @@
 import { AgentSideConnection, type Stream } from "@agentclientprotocol/sdk";
 import type { AgentSession } from "../../session/agent-session.js";
+import { AcpAgent } from "./acp-agent.js";
+/** Creates sessions requested by an ACP client. */
 export type AcpSessionFactory = (cwd: string) => Promise<AgentSession>;
-export declare function createAcpConnection(transport: Stream, createSession: AcpSessionFactory, initialSession?: AgentSession): AgentSideConnection;
-export declare function runAcpMode(createSession: AcpSessionFactory, initialSession?: AgentSession): Promise<never>;
+/** Creates an ACP connection and exposes its agent when process-level teardown must own it. */
+export declare function createAcpConnection(transport: Stream, createSession: AcpSessionFactory, initialSession?: AgentSession, onAgent?: (agent: AcpAgent) => void): AgentSideConnection;
+/** Serves ACP over stdio until the peer disconnects, then awaits session teardown before exit. */
+export declare function runAcpMode(createSession: AcpSessionFactory, initialSession?: AgentSession): Promise<void>;

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/assistant-message.d.ts

@@ -51,6 +51,8 @@ export declare class AssistantMessageComponent extends Container {
     markTranscriptBlockFinalized(): void;
     applyRetryRecovery(retryRecovery: AssistantMessage["retryRecovery"]): void;
     messagePersistenceKey(): string | undefined;
+    /** Toggle rendering for assistant-native and tool-result images. */
+    setImagesVisible(visible: boolean): void;
     setToolResultImages(toolCallId: string, images: ImageContent[]): void;
     updateContent(message: AssistantMessage, opts?: {
         transient?: boolean;

package/dist/types/modes/components/custom-editor-plugin-ctor.test.d.ts

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

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

@@ -1,5 +1,5 @@
 import type { ImageContent } from "@oh-my-pi/pi-ai";
-import { Editor, type KeyId } from "@oh-my-pi/pi-tui";
+import { Editor, type KeyId, TUI } from "@oh-my-pi/pi-tui";
 import type { AppKeybinding } from "../../config/keybindings.js";
 type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.display.reset" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.retry" | "app.clipboard.pasteImage" | "app.clipboard.pasteTextRaw" | "app.clipboard.copyPrompt">;
 /** Max gap (ms) between two spaces for the later one to count as OS key auto-repeat rather than a
@@ -73,6 +73,28 @@ export declare class CustomEditor extends Editor {
     /** Per-image source links (file:// targets) parallel to {@link pendingImages};
      *  `undefined` entries are images without a backing reference yet. */
     pendingImageLinks: (string | undefined)[];
+    /**
+     * The host {@link TUI}, captured when a plugin constructs this editor through
+     * the upstream-pi `(tui, theme, keybindings)` convention. Undefined for omp's
+     * own `new CustomEditor(theme)` callers (they drive repaints through the
+     * interactive-mode wiring instead). Plugins that call `this.tui.requestRender()`
+     * in their overrides read it here (issue #4766).
+     */
+    tui?: TUI;
+    /**
+     * Accept both the omp constructor convention — `new CustomEditor(theme)` —
+     * and the upstream-pi `Editor` convention — `new Editor(tui, theme, keybindings)`
+     * — that {@link ExtensionUIContext.setEditorComponent}'s factory contract
+     * advertises `(tui, theme, keybindings)`. Plugins written against upstream pi
+     * subclass `CustomEditor`/`Editor` and forward `super(tui, theme, keybindings)`;
+     * without this shim the `TUI` lands in the `theme` slot and every render throws
+     * `undefined is not an object (evaluating 'this.#theme.symbols.boxRound')`
+     * (issue #4766). We locate the real {@link EditorTheme} among the args by shape
+     * (it carries `symbols`/`borderColor`) rather than by position, and capture a
+     * leading {@link TUI} so plugin overrides calling `this.tui.requestRender()`
+     * keep working.
+     */
+    constructor(...args: readonly unknown[]);
     /** Clear the composer draft: optionally commit `historyText` to history, then
      *  reset the editor text and all pending draft-image state. The shared tail of
      *  every "message submitted" path; pass no argument for a plain discard. */

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

@@ -7,14 +7,28 @@
  *   (Ctrl+Q / Ctrl+Enter) submits, bordered popup
  * - Prompt-style (ask): Enter submits, Shift+Enter inserts newline, legacy ask chrome
  */
-import { Container, type TUI } from "@oh-my-pi/pi-tui";
+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;
 }
-export declare class HookEditorComponent extends Container {
+/** Interactive multiline dialog used by hooks and the ask tool's Other response. */
+export declare class HookEditorComponent extends Container implements Focusable {
     #private;
+    /** Focus state mirrored to the nested editor during rendering. */
+    focused: boolean;
     constructor(tui: TUI, title: string, prefill: string | undefined, onSubmit: (value: string) => void, onCancel: () => void, options?: HookEditorOptions);
+    /** Keep the nested editor's software/hardware cursor mode aligned with the dialog focus target. */
+    setUseTerminalCursor(useTerminalCursor: boolean): void;
+    /** Render the dialog after forwarding its focus state to the nested editor. */
+    render(width: number): readonly string[];
     handleInput(keyData: string): void;
     /** Route non-bracketed paste transports (e.g. kitty's OSC 5522 enhanced clipboard)
      *  into the inner editor, mirroring bracketed-paste semantics. Without this hook,

package/dist/types/modes/components/login-dialog.test.d.ts

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

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

@@ -83,6 +83,10 @@ export declare class SessionSelectorComponent extends Container {
     #private;
     constructor(sessions: SessionInfo[], onSelect: (session: SessionInfo) => void, onCancel: () => void, onExit: () => void, options?: SessionSelectorOptions);
     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/components/tool-execution.d.ts

@@ -9,6 +9,13 @@ import { type Component, Container, type NativeScrollbackLiveRegion, type TUI }
 export interface TranscriptLiveRegionProbe {
     isBlockInLiveRegion(component: Component): boolean;
 }
+/** Minimal TUI surface ToolExecutionComponent uses to schedule repaints and share image budget. */
+export interface ToolExecutionUi {
+    requestRender(): void;
+    requestComponentRender(component: Component): void;
+    resetDisplay(): void;
+    imageBudget?: TUI["imageBudget"];
+}
 export interface ToolExecutionOptions {
     snapshots?: SnapshotStore;
     showImages?: boolean;
@@ -52,7 +59,7 @@ export declare function sharedSpinnerFrame(frameCount: number, now?: number): nu
  */
 export declare class ToolExecutionComponent extends Container implements NativeScrollbackLiveRegion {
     #private;
-    constructor(toolName: string, args: any, options: ToolExecutionOptions | undefined, tool: AgentTool | undefined, ui: TUI, cwd?: string, _toolCallId?: string);
+    constructor(toolName: string, args: any, options: ToolExecutionOptions | undefined, tool: AgentTool | undefined, ui: ToolExecutionUi, cwd?: string, _toolCallId?: string);
     updateArgs(args: any, _toolCallId?: string): void;
     /**
      * Signal that args are complete (tool is about to execute).

package/dist/types/modes/components/tool-execution.test.d.ts

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

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;

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

@@ -50,7 +50,9 @@ export declare class SelectorController {
     showCopySelector(): void;
     showTreeSelector(): void;
     showSessionSelector(): Promise<void>;
-    handleResumeSession(sessionPath: string): Promise<void>;
+    handleResumeSession(sessionPath: string, options?: {
+        settingsFlushed?: boolean;
+    }): Promise<boolean>;
     handleSessionDeleteCommand(): Promise<void>;
     showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
     showResetUsageSelector(): Promise<void>;

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

@@ -180,6 +180,8 @@ export declare class InteractiveMode implements InteractiveModeContext {
      *  ({@link AgentSession.#refreshTitleAfterReplan}) share one source
      *  ({@link discoverTitleSystemPromptFile}; issue #3734). */
     refreshTitleSystemPrompt(cwd?: string): Promise<void>;
+    /** Reload session skills and the `/skill:<name>` command list. */
+    refreshSkillState(): Promise<void>;
     /** Reload slash commands and autocomplete for the provided working directory. */
     refreshSlashCommandState(cwd?: string): Promise<void>;
     /** Stack extension autocomplete behavior on top of the built-in editor provider (#4919). */
@@ -270,6 +272,10 @@ export declare class InteractiveMode implements InteractiveModeContext {
     initializeHookRunner(uiContext: ExtensionUIContext, hasUI: boolean): void;
     setEditorComponent(factory: ((tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) => CustomEditor) | undefined): void;
     present(content: Component | readonly Component[]): void;
+    /** Defer transcript command panels until the active turn can no longer grow above them. */
+    presentCommandOutput(content: Component | readonly Component[]): void;
+    /** Mount every command panel queued for the current session while the agent was streaming. */
+    flushPendingCommandOutput(): void;
     resetTranscript(): void;
     showStatus(message: string, options?: {
         dim?: boolean;

package/dist/types/modes/noninteractive-dispose.test.d.ts

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

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

@@ -1,5 +1,5 @@
 import type { ImageContent } from "@oh-my-pi/pi-ai";
-import type { AgentSession, AgentSessionEvent } from "../session/agent-session.js";
+import { type AgentSession, type AgentSessionEvent } from "../session/agent-session.js";
 /**
  * Options for print mode.
  */

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

@@ -209,6 +209,14 @@ export interface InteractiveModeContext {
      * runs) so their timers/subscriptions start.
      */
     present(content: Component | readonly Component[]): void;
+    /**
+     * Mount command output immediately while idle, or defer it until the active
+     * agent turn ends so a growing live block cannot push duplicate rows into
+     * native scrollback.
+     */
+    presentCommandOutput(content: Component | readonly Component[]): void;
+    /** Mount command output deferred by {@link presentCommandOutput}. */
+    flushPendingCommandOutput(): void;
     /**
      * Dispose every live block in the transcript (stopping timers/subscriptions)
      * and clear it. Used before a full rebuild so animated/streaming blocks do not
@@ -322,6 +330,8 @@ export interface InteractiveModeContext {
     executeCompaction(customInstructionsOrOptions?: string | CompactOptions, isAuto?: boolean): Promise<CompactionOutcome>;
     openInBrowser(urlOrPath: string): void;
     refreshSlashCommandState(cwd?: string): Promise<void>;
+    /** Reload session skills and derived `/skill:<name>` commands. */
+    refreshSkillState(): Promise<void>;
     applyCwdChange(newCwd: string): Promise<void>;
     showSettingsSelector(): void;
     showAdvisorConfigure(): void;

package/dist/types/modes/utils/transcript-render-helpers.d.ts

@@ -34,8 +34,8 @@ export declare function buildIrcMessageCard(message: CustomOrHookMessage, getExp
  */
 export declare function buildFileMentionBlock(files: FileMentionMessage["files"], indent: number): TranscriptBlock;
 /**
- * Whether an assistant turn has visible text or thinking content (after
- * canonicalization) — i.e. content that closes the current read-tool run.
+ * Whether an assistant turn has visible text, thinking, or image content — i.e.
+ * content that closes the current read-tool run.
  */
 export declare function assistantHasVisibleContent(message: AssistantAgentMessage): boolean;
 /**

package/dist/types/modes/warp-events.d.ts

@@ -0,0 +1,24 @@
+import type { ExtensionFactory } from "../extensibility/extensions/types.js";
+/** True when Warp has negotiated the structured CLI-agent OSC protocol. */
+export declare function isWarpCliAgentProtocolActive(): boolean;
+export type WarpEventValue = string | number | boolean | null | readonly WarpEventValue[] | {
+    readonly [key: string]: WarpEventValue | undefined;
+};
+/** Fields added to the Warp CLI-agent event envelope by the event bridge. */
+export type WarpEvent = Readonly<Record<string, WarpEventValue | undefined>>;
+export interface WarpEventEmitterOptions {
+    sessionId: string;
+    getCwd?: () => string;
+}
+export interface WarpEventEmitter {
+    emit(event: WarpEvent): void;
+}
+/**
+ * Creates the Warp event transport for a top-level interactive TUI session.
+ * The caller MUST enforce that install-site invariant; the sole production
+ * caller is gated by `isInteractive`, so ACP, RPC, print, headless, and
+ * subagent sessions never construct an emitter.
+ */
+export declare function createWarpEventEmitter(options: WarpEventEmitterOptions): WarpEventEmitter | undefined;
+/** Internal event bridge installed only by the top-level interactive TUI runner. */
+export declare function createWarpEventBridgeExtension(): ExtensionFactory;

package/dist/types/modes/warp-events.test.d.ts

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

package/dist/types/plan-mode/model-transition.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Plan-mode model transition policy.
+ *
+ * Plan mode drives the active session model from the `plan` role: it switches
+ * to the plan model on entry and restores the pre-plan model on exit. The same
+ * policy also runs when the `plan` role is reassigned mid-planning, so a
+ * correction to the wrong plan model takes effect at the next turn boundary
+ * (issue #5657).
+ *
+ * This module holds only the pure decision — what transition a given
+ * (current model, resolved role, streaming) triple implies — so the branching
+ * is testable without a live session or TUI. The interactive mode performs the
+ * resulting side effect.
+ */
+import type { Model } from "@oh-my-pi/pi-ai";
+import type { ResolvedModelRoleValue } from "../config/model-resolver.js";
+import type { ConfiguredThinkingLevel } from "../thinking.js";
+/** The action implied by resolving the `plan` role against the active model. */
+export type PlanModelTransition = 
+/** Already on the plan model with no thinking-level change to apply. */
+{
+    kind: "none";
+}
+/** Same model; only the plan role's explicit thinking level differs. */
+ | {
+    kind: "thinking";
+    thinkingLevel: ConfiguredThinkingLevel;
+}
+/**
+ * Switch to `model`. `deferred` is set when the session is mid-stream: the
+ * switch must wait for the current turn to end (a live `setModelTemporary`
+ * resets the provider session), so the caller queues it instead.
+ */
+ | {
+    kind: "apply";
+    model: Model;
+    thinkingLevel: ConfiguredThinkingLevel | undefined;
+    deferred: boolean;
+};
+/**
+ * Decide how to reconcile the active model with the resolved `plan` role.
+ *
+ * @param currentModel - The session's active model, or `undefined` before one is set.
+ * @param resolved - The `plan` role resolved against the available models.
+ * @param isStreaming - Whether the session is mid-turn (forces a deferred switch).
+ */
+export declare function resolvePlanModelTransition(currentModel: Model | undefined, resolved: ResolvedModelRoleValue, isStreaming: boolean): PlanModelTransition;

package/dist/types/plan-mode/model-transition.test.d.ts

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

package/dist/types/registry/agent-lifecycle.d.ts

@@ -8,6 +8,12 @@
  * sessionFile), and revives it on demand through
  * {@link AgentLifecycleManager.ensureLive}. Only this manager flips
  * `parked` ↔ `idle`.
+ *
+ * Park/dispose is gated against concurrent ensureLive/hub-send:
+ * - A disposing session is never handed out.
+ * - ensureLive during an in-flight park either cancels the park (session still
+ *   live) or waits for detach+park and then revives.
+ * - Concurrent ensureLive/park operations coalesce per id.
  */
 import type { AgentSession } from "../session/agent-session.js";
 import { type AgentRef, AgentRegistry } from "./agent-registry.js";
@@ -46,17 +52,36 @@ export declare class AgentLifecycleManager {
     adopt(id: string, opts: AdoptOptions): void;
     /** True if the id is adopted (parked or live). */
     has(id: string): boolean;
-    /** True while {@link park} is disposing this agent's session (lets dispose hooks distinguish park from teardown). */
+    /**
+     * True when this manager owns `registry` — i.e. its adopt/park/revive state
+     * describes that registry's refs. Lets a caller holding a specific registry
+     * (e.g. a custom-registry {@link IrcBus} that fell back to the global
+     * manager) skip lifecycle gating that would consult unrelated park state.
+     */
+    manages(registry: AgentRegistry): boolean;
+    /**
+     * True while {@link park} is disposing this agent's session (lets dispose
+     * hooks distinguish park from teardown). False once the park is cancelled
+     * by ensureLive or after detach+dispose completes.
+     */
     isParking(id: string): boolean;
     /**
      * Dispose the live session, detach it from the registry, and mark the
      * agent `parked`. No-op unless the id is adopted and live.
+     *
+     * The session is detached (and status flipped to `parked`) *before*
+     * `session.dispose()` so concurrent {@link ensureLive}/hub-send never
+     * observe or inject into a disposing session. A concurrent ensureLive that
+     * arrives before detach cancels the park and keeps the live session.
      */
     park(id: string): Promise<void>;
     /**
      * Return the live session, reviving from the sessionFile if parked.
      * Throws a plain Error if the id is unknown or parked without a reviver.
      * Concurrent calls share one in-flight revive.
+     *
+     * Never returns a session that is mid-dispose: an in-flight park is either
+     * cancelled (session still live) or awaited to completion before revive.
      */
     ensureLive(id: string): Promise<AgentSession>;
     /** Hard removal: dispose if live, unregister from registry, drop timers. */

package/dist/types/sdk.d.ts

@@ -1,5 +1,5 @@
-import { type AgentTelemetryConfig, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Model } from "@oh-my-pi/pi-ai";
+import { Agent, type AgentOptions, type AgentTelemetryConfig, type AgentTool, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Model, SimpleStreamOptions } from "@oh-my-pi/pi-ai";
 import type { Dialect } from "@oh-my-pi/pi-ai/dialect";
 import { type Rule } from "./capability/rule.js";
 import { ModelRegistry } from "./config/model-registry.js";
@@ -346,6 +346,17 @@ export interface BuildSystemPromptOptions {
  * as separate entries so providers can cache prompt prefixes without concatenating blocks.
  */
 export declare function buildSystemPrompt(options?: BuildSystemPromptOptions): Promise<BuildSystemPromptResult>;
+/** Dependencies used to construct an isolated auto-learn capture agent. */
+export interface AutoLearnCaptureRunnerOptions {
+    sourceAgent: Agent;
+    captureTools: AgentTool[];
+    createAgent: (options: AgentOptions) => Agent;
+    onPayload?: SimpleStreamOptions["onPayload"];
+    onResponse?: SimpleStreamOptions["onResponse"];
+    createSessionId?: () => string;
+}
+/** Build a private capture runner over a detached message snapshot and provider session. */
+export declare function createAutoLearnCaptureRunner(options: AutoLearnCaptureRunnerOptions): (content: string, signal?: AbortSignal) => Promise<void>;
 /**
  * Create an AgentSession with the specified options.
  *