@oh-my-pi/pi-coding-agent 15.10.11 → 15.11.0

package/dist/types/extensibility/custom-tools/types.d.ts

@@ -88,10 +88,10 @@ export type CustomToolSessionEvent = {
 } | {
     reason: "auto_compaction_start";
     trigger: "threshold" | "overflow" | "idle" | "incomplete";
-    action: "context-full" | "handoff" | "shake";
+    action: "context-full" | "handoff" | "shake" | "snapcompact";
 } | {
     reason: "auto_compaction_end";
-    action: "context-full" | "handoff" | "shake";
+    action: "context-full" | "handoff" | "shake" | "snapcompact";
     result: CompactionResult | undefined;
     aborted: boolean;
     willRetry: boolean;

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

@@ -5,6 +5,7 @@ import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { CredentialDisabledEvent, ImageContent, Model, ProviderResponseMetadata } from "@oh-my-pi/pi-ai";
 import type { KeyId } from "@oh-my-pi/pi-tui";
 import type { ModelRegistry } from "../../config/model-registry";
+import type { MemoryRuntimeContext } from "../../memory-backend";
 import type { SessionManager } from "../../session/session-manager";
 import type { AfterProviderResponseEvent, AssistantThinkingRenderer, BeforeAgentStartEvent, BeforeAgentStartEventResult, BeforeProviderRequestEvent, BeforeProviderRequestEventResult, ContextEvent, Extension, ExtensionActions, ExtensionCommandContext, ExtensionCommandContextActions, ExtensionContext, ExtensionContextActions, ExtensionError, ExtensionEvent, ExtensionFlag, ExtensionRuntime, ExtensionShortcut, ExtensionUIContext, InputEvent, InputEventResult, MessageRenderer, RegisteredCommand, RegisteredTool, ResourcesDiscoverEvent, SessionBeforeBranchResult, SessionBeforeCompactResult, SessionBeforeSwitchResult, SessionBeforeTreeResult, SessionCompactingResult, ToolCallEvent, ToolCallEventResult, ToolResultEvent, ToolResultEventResult, UserBashEvent, UserBashEventResult, UserPythonEvent, UserPythonEventResult } from "./types";
 /** Combined result from all before_agent_start handlers */
@@ -61,7 +62,7 @@ export declare class ExtensionRunner {
     private readonly cwd;
     private readonly sessionManager;
     private readonly modelRegistry;
-    constructor(extensions: Extension[], runtime: ExtensionRuntime, cwd: string, sessionManager: SessionManager, modelRegistry: ModelRegistry);
+    constructor(extensions: Extension[], runtime: ExtensionRuntime, cwd: string, sessionManager: SessionManager, modelRegistry: ModelRegistry, getMemory?: () => MemoryRuntimeContext | undefined);
     initialize(actions: ExtensionActions, contextActions: ExtensionContextActions, commandContextActions?: ExtensionCommandContextActions, uiContext?: ExtensionUIContext): void;
     /**
      * Forward a `credential_disabled` event from `AuthStorage` to extension handlers.
@@ -99,7 +100,7 @@ export declare class ExtensionRunner {
     hasHandlers(eventType: string): boolean;
     getMessageRenderer(customType: string): MessageRenderer | undefined;
     getAssistantThinkingRenderers(): AssistantThinkingRenderer[];
-    getRegisteredCommands(reserved?: Set<string>): RegisteredCommand[];
+    getRegisteredCommands(reserved?: ReadonlySet<string>): RegisteredCommand[];
     getCommandDiagnostics(): Array<{
         type: string;
         message: string;

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

@@ -21,6 +21,7 @@ import type { EditToolDetails } from "../../edit";
 import type { PythonResult } from "../../eval/py/executor";
 import type { BashResult } from "../../exec/bash-executor";
 import type { ExecOptions, ExecResult } from "../../exec/exec";
+import type { MemoryRuntimeContext } from "../../memory-backend";
 import type { CustomEditor } from "../../modes/components/custom-editor";
 import type { Theme } from "../../modes/theme/theme";
 import type { CustomMessage } from "../../session/messages";
@@ -199,6 +200,8 @@ export interface ExtensionContext {
     shutdown(): void;
     /** Get the current effective system prompt. */
     getSystemPrompt(): string[];
+    /** Structured memory runtime for status/search/save across the configured backend. */
+    memory?: MemoryRuntimeContext;
 }
 /**
  * Extended context for command handlers.

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

@@ -160,12 +160,12 @@ export interface TurnEndEvent {
 export interface AutoCompactionStartEvent {
     type: "auto_compaction_start";
     reason: "threshold" | "overflow" | "idle" | "incomplete";
-    action: "context-full" | "handoff" | "shake";
+    action: "context-full" | "handoff" | "shake" | "snapcompact";
 }
 /** Fired when auto-compaction ends */
 export interface AutoCompactionEndEvent {
     type: "auto_compaction_end";
-    action: "context-full" | "handoff" | "shake";
+    action: "context-full" | "handoff" | "shake" | "snapcompact";
     result: CompactionResult | undefined;
     aborted: boolean;
     willRetry: boolean;

package/dist/types/internal-urls/history-protocol.d.ts

@@ -0,0 +1,14 @@
+import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
+/**
+ * Handler for history:// URLs.
+ *
+ * Resolves agent ids against the global AgentRegistry, serving transcripts
+ * for both live and parked agents.
+ */
+export declare class HistoryProtocolHandler implements ProtocolHandler {
+    #private;
+    readonly scheme = "history";
+    readonly immutable = false;
+    resolve(url: InternalUrl): Promise<InternalResource>;
+    complete(): Promise<UrlCompletion[]>;
+}

package/dist/types/internal-urls/index.d.ts

@@ -9,6 +9,7 @@
  */
 export * from "./agent-protocol";
 export * from "./artifact-protocol";
+export * from "./history-protocol";
 export * from "./issue-pr-protocol";
 export * from "./json-query";
 export * from "./local-protocol";

package/dist/types/internal-urls/types.d.ts

@@ -1,7 +1,7 @@
 /**
  * Types for the internal URL routing system.
  *
- * Internal URLs (`agent://`, `artifact://`, `issue://`, `local://`, `mcp://`, `memory://`, `omp://`, `pr://`, `rule://`, `skill://`, and `vault://`) are resolved by tools like read,
+ * Internal URLs (`agent://`, `artifact://`, `history://`, `issue://`, `local://`, `mcp://`, `memory://`, `omp://`, `pr://`, `rule://`, `skill://`, and `vault://`) are resolved by tools like read,
  * providing access to agent outputs and server resources without exposing filesystem paths.
  */
 import type { LocalProtocolOptions } from "./local-protocol";

package/dist/types/irc/bus.d.ts

@@ -0,0 +1,66 @@
+/**
+ * IrcBus - Process-global mailbox bus for agent-to-agent messaging.
+ *
+ * Replaces the old auto-reply model: a `send` never blocks on the recipient
+ * generating anything. Delivery resolves the recipient via the global
+ * AgentRegistry — parked agents are revived through the
+ * AgentLifecycleManager, idle agents are woken with a real turn, and busy
+ * agents receive the message as a non-interrupting aside at the next step
+ * boundary (see AgentSession.deliverIrcMessage). Replies are real turns by
+ * the recipient, observed via `wait`.
+ */
+import { AgentLifecycleManager } from "../registry/agent-lifecycle";
+import { AgentRegistry } from "../registry/agent-registry";
+export interface IrcMessage {
+    id: string;
+    /** Sender agent id. */
+    from: string;
+    /** Recipient agent id (resolved; "all" is expanded by the tool, not stored). */
+    to: string;
+    body: string;
+    ts: number;
+    /** Message id being answered. */
+    replyTo?: string;
+}
+export interface IrcDeliveryReceipt {
+    to: string;
+    outcome: "injected" | "woken" | "revived" | "failed";
+    error?: string;
+}
+export declare class IrcBus {
+    #private;
+    static global(): IrcBus;
+    /** Reset the global bus. Test-only. */
+    static resetGlobalForTests(): void;
+    constructor(registry?: AgentRegistry, lifecycle?: AgentLifecycleManager);
+    /**
+     * Fire-and-forget delivery. Never blocks on the recipient generating
+     * anything: the receipt reports how the message reached the recipient
+     * (waiter/aside = "injected", idle wake = "woken", park revival =
+     * "revived"), not what they did with it.
+     *
+     * Mailbox semantics: a successfully delivered message never lingers in
+     * the recipient's mailbox — injection/wake puts the full body into their
+     * context, so buffering it too would double-deliver via a later
+     * `wait`/`inbox` and inflate unread counts. Only a failed live hand-off
+     * is buffered for the recipient to drain later.
+     */
+    send(msg: Omit<IrcMessage, "id" | "ts">): Promise<IrcDeliveryReceipt>;
+    /**
+     * Block until a message for `agentId` (optionally from `filter.from`)
+     * arrives; consume + return it. Null on timeout (`timeoutMs <= 0` waits
+     * forever). Rejects when `signal` aborts. By default, already-buffered
+     * mail satisfies the wait before parking a future waiter; callers that
+     * need a strictly future reply can disable that drain.
+     */
+    wait(agentId: string, filter: {
+        from?: string;
+    }, timeoutMs: number, signal?: AbortSignal, options?: {
+        drainPending?: boolean;
+    }): Promise<IrcMessage | null>;
+    /** Drain (or peek) pending messages for `agentId`. */
+    inbox(agentId: string, opts?: {
+        peek?: boolean;
+    }): IrcMessage[];
+    unreadCount(agentId: string): number;
+}

package/dist/types/memory-backend/index.d.ts

@@ -3,4 +3,5 @@ export type { MnemopiMemoryEditOperation, MnemopiMemoryEditOptions, MnemopiMemor
 export * from "./local-backend";
 export * from "./off-backend";
 export * from "./resolve";
+export * from "./runtime";
 export * from "./types";

package/dist/types/memory-backend/runtime.d.ts

@@ -0,0 +1,4 @@
+import type { AgentSession } from "../session/agent-session";
+import type { MemoryBackendOperationContext, MemoryRuntimeContext } from "./types";
+export declare function createMemoryRuntimeContext(context: MemoryBackendOperationContext): MemoryRuntimeContext;
+export declare function createSessionMemoryRuntimeContext(session: AgentSession, agentDir: string, cwd: string): MemoryRuntimeContext;

package/dist/types/memory-backend/types.d.ts

@@ -1,7 +1,7 @@
 /**
  * Memory backend abstraction.
  *
- * Backends are mutually exclusive — `await resolveMemoryBackend(settings)` resolves
+ * Backends are mutually exclusive — `await resolveMemoryBackend(settings)` returns
  * exactly one. Implementations MUST be self-contained: they own the per-session
  * state they create in `start()` and tear it down on `clear()`.
  */
@@ -12,6 +12,65 @@ import type { HindsightSessionState } from "../hindsight/state";
 import type { MnemopiSessionState } from "../mnemopi/state";
 import type { AgentSession } from "../session/agent-session";
 export type MemoryBackendId = "off" | "local" | "hindsight" | "mnemopi";
+export interface MemoryBackendStatus {
+    backend: MemoryBackendId;
+    active: boolean;
+    writable: boolean;
+    searchable: boolean;
+    scope?: string;
+    retainBank?: string;
+    recallBanks?: string[];
+    workingCount?: number;
+    episodicCount?: number;
+    tripleCount?: number;
+    lastMemory?: string;
+    lastRecall?: boolean;
+    database?: string;
+    message?: string;
+    error?: string;
+}
+export interface MemoryBackendSearchOptions {
+    limit?: number;
+    /** Best-effort abort signal. Backends may only observe it before/after an underlying recall call. */
+    signal?: AbortSignal;
+}
+export interface MemoryBackendSearchItem {
+    id?: string;
+    content: string;
+    source?: string;
+    timestamp?: string;
+    score?: number;
+}
+export interface MemoryBackendSearchResult {
+    backend: MemoryBackendId;
+    query: string;
+    count: number;
+    items: MemoryBackendSearchItem[];
+    message?: string;
+}
+export interface MemoryBackendSaveInput {
+    content: string;
+    context?: string;
+    source?: string;
+    importance?: number;
+}
+export interface MemoryBackendSaveResult {
+    backend: MemoryBackendId;
+    stored: number;
+    ids?: string[];
+    queued?: boolean;
+    message?: string;
+}
+export interface MemoryBackendOperationContext {
+    agentDir: string;
+    cwd: string;
+    session?: AgentSession;
+}
+export interface MemoryRuntimeContext {
+    status(): Promise<MemoryBackendStatus>;
+    search(query: string, options?: MemoryBackendSearchOptions): Promise<MemoryBackendSearchResult>;
+    save(input: string | MemoryBackendSaveInput): Promise<MemoryBackendSaveResult>;
+}
 export interface MemoryBackendStartOptions {
     session: AgentSession;
     settings: Settings;
@@ -40,6 +99,12 @@ export interface MemoryBackend {
     clear(agentDir: string, cwd: string, session?: AgentSession): Promise<void>;
     /** Force consolidation/retain to happen now (slash `/memory enqueue`). */
     enqueue(agentDir: string, cwd: string, session?: AgentSession): Promise<void>;
+    /** Structured state for UI, slash commands, and extensions. */
+    status?(context: MemoryBackendOperationContext): Promise<MemoryBackendStatus>;
+    /** Explicit user-facing semantic/lexical search. */
+    search?(context: MemoryBackendOperationContext, query: string, options?: MemoryBackendSearchOptions): Promise<MemoryBackendSearchResult>;
+    /** Explicit user-facing save operation. */
+    save?(context: MemoryBackendOperationContext, input: MemoryBackendSaveInput): Promise<MemoryBackendSaveResult>;
     /** Render backend-specific memory statistics as markdown (`/memory stats`). */
     stats?(agentDir: string, cwd: string, session?: AgentSession): Promise<string | undefined>;
     /** Render backend-specific memory diagnostics as markdown (`/memory diagnose`). */

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

@@ -0,0 +1,30 @@
+import { Container } from "@oh-my-pi/pi-tui";
+import type { KeyId } from "../../config/keybindings";
+import { IrcBus } from "../../irc/bus";
+import { AgentLifecycleManager } from "../../registry/agent-lifecycle";
+import { AgentRegistry } from "../../registry/agent-registry";
+import type { SessionObserverRegistry } from "../session-observer-registry";
+export interface AgentHubDeps {
+    /** Progress/status snapshot source (task lifecycle + progress channels). */
+    observers: SessionObserverRegistry;
+    /** Keys that toggle the hub closed from inside (app.agents.hub + app.session.observe). */
+    hubKeys: KeyId[];
+    onDone: () => void;
+    requestRender: () => void;
+    /** Injectable for tests; defaults to the process-global registry. */
+    registry?: AgentRegistry;
+    /** Injectable for tests; defaults to the process-global lifecycle manager. */
+    lifecycle?: AgentLifecycleManager;
+    /** Injectable for tests; defaults to the process-global bus. */
+    irc?: IrcBus;
+}
+export declare class AgentHubOverlayComponent extends Container {
+    #private;
+    constructor(deps: AgentHubDeps);
+    /** Tear down every subscription and timer. Called by the overlay owner on close. */
+    dispose(): void;
+    render(width: number): readonly string[];
+    handleInput(keyData: string): void;
+    /** Open the chat view for an agent id (public for table Enter and tests). */
+    openChat(id: string): void;
+}

package/dist/types/modes/components/compaction-summary-message.d.ts

@@ -1,13 +1,19 @@
-import { Box } from "@oh-my-pi/pi-tui";
+import { type Component } from "@oh-my-pi/pi-tui";
 import type { CompactionSummaryMessage } from "../../session/messages";
 /**
- * Component that renders a compaction message with collapsed/expanded state.
- * Uses same background color as hook messages for visual consistency.
+ * Compaction point in the transcript, rendered as a slim horizontal divider:
+ *
+ *   ──────── 📷 compacted · ctrl+o ────────
+ *
+ * The conversation above the divider stays visible (display transcript keeps
+ * full history); only the LLM context was reset. Expanding (ctrl+o) reveals
+ * the compaction summary below the divider.
  */
-export declare class CompactionSummaryMessageComponent extends Box {
+export declare class CompactionSummaryMessageComponent implements Component {
     #private;
     private readonly message;
     constructor(message: CompactionSummaryMessage);
     setExpanded(expanded: boolean): void;
     invalidate(): void;
+    render(width: number): readonly string[];
 }

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

@@ -42,6 +42,8 @@ export declare class CustomEditor extends Editor {
     onDequeue?: () => void;
     /** Called when Caps Lock is pressed. */
     onCapsLock?: () => void;
+    /** Called when left-arrow is pressed while the editor is empty (cursor necessarily at start). */
+    onLeftAtStart?: () => void;
     setActionKeys(action: ConfigurableEditorAction, keys: KeyId[]): void;
     /**
      * Register a custom key handler. Extensions use this for shortcuts.

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

@@ -67,6 +67,14 @@ export declare class ToolExecutionComponent extends Container {
      * transcript live region.
      */
     seal(): void;
+    /**
+     * Whether this block is a waiting `job` poll (every watched job still
+     * running) that has not been sealed. Such a block never finalized, so none
+     * of its rows entered native scrollback (the ticking spinner keeps the
+     * stable-prefix ratchet at zero) and the whole block can be removed when a
+     * follow-up `job` call supersedes it.
+     */
+    isDisplaceableBlock(): boolean;
     /**
      * Stop spinner animation and cleanup resources.
      */

package/dist/types/modes/components/ttsr-notification.d.ts

@@ -3,11 +3,15 @@ import type { Rule } from "../../capability/rule";
 /**
  * Component that renders a TTSR (Time Traveling Stream Rules) notification.
  * Shows when a rule violation is detected and the stream is being rewound.
+ * One block can carry several rules: a single event may match multiple rules,
+ * and consecutive notifications merge into the previous block via
+ * {@link addRules} while it is still the live transcript tail.
  */
 export declare class TtsrNotificationComponent extends Container {
     #private;
-    private readonly rules;
     constructor(rules: Rule[]);
+    /** Merge additional rules into this block (deduped by rule name). */
+    addRules(rules: Rule[]): void;
     setExpanded(expanded: boolean): void;
     isExpanded(): boolean;
 }

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

@@ -1,7 +1,7 @@
 import { type Component } from "@oh-my-pi/pi-tui";
 /**
- * Fixed number of session rows in the welcome box so its height doesn't shift
- * between the pre-TUI splash (loading placeholder) and the loaded state.
+ * Fixed number of session rows in the welcome box so its height stays stable
+ * across recent-session updates.
  */
 export declare const WELCOME_SESSION_SLOTS = 4;
 /**
@@ -29,14 +29,8 @@ export declare class WelcomeComponent implements Component {
     private providerName;
     private recentSessions;
     private lspServers;
-    constructor(version: string, modelName: string, providerName: string, recentSessions?: RecentSession[] | null, lspServers?: LspServerInfo[]);
+    constructor(version: string, modelName: string, providerName: string, recentSessions?: RecentSession[], lspServers?: LspServerInfo[]);
     invalidate(): void;
-    /**
-     * Freeze the logo on the intro animation's first frame. The pre-TUI startup
-     * splash uses this so the in-TUI intro — which starts at that exact frame —
-     * picks up seamlessly from the splash's static box.
-     */
-    holdIntroFirstFrame(): void;
     /**
      * Play a one-shot intro that sweeps the gradient through every phase
      * before settling on the resting frame. Safe to call multiple times —

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

@@ -42,5 +42,5 @@ export declare class SelectorController {
     handleSessionDeleteCommand(): Promise<void>;
     showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
     showDebugSelector(): Promise<void>;
-    showSessionObserver(registry: SessionObserverRegistry): void;
+    showAgentHub(observers: SessionObserverRegistry): void;
 }

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

@@ -5,6 +5,6 @@
  * barrel does not pull print, RPC server, or ACP server mode into the normal
  * TUI graph.
  */
-export { InteractiveMode, type InteractiveModeOptions } from "./interactive-mode";
-export { defineRpcClientTool, type ModelInfo, RpcClient, type RpcClientCustomTool, type RpcClientOptions, type RpcClientToolContext, type RpcClientToolResult, type RpcEventListener, } from "./rpc/rpc-client";
-export type { RpcCommand, RpcHostToolCallRequest, RpcHostToolCancelRequest, RpcHostToolDefinition, RpcHostToolResult, RpcHostToolUpdate, RpcResponse, RpcSessionState, } from "./rpc/rpc-types";
+export * from "./interactive-mode";
+export * from "./rpc/rpc-client";
+export * from "./rpc/rpc-types";

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

@@ -7,6 +7,7 @@ import { KeybindingsManager } from "../config/keybindings";
 import { Settings } from "../config/settings";
 import type { ExtensionUIContext, ExtensionUIDialogOptions, ExtensionUISelectItem, ExtensionWidgetContent, ExtensionWidgetOptions } from "../extensibility/extensions";
 import type { CompactOptions } from "../extensibility/extensions/types";
+import type { MCPManager } from "../mcp";
 import { type PlanApprovalDetails } from "../plan-mode/approved-plan";
 import type { AgentSession } from "../session/agent-session";
 import { HistoryStorage } from "../session/history-storage";
@@ -49,6 +50,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     keybindings: KeybindingsManager;
     agent: Agent;
     historyStorage?: HistoryStorage;
+    titleSystemPrompt?: string;
     ui: TUI;
     chatContainer: TranscriptContainer;
     pendingMessagesContainer: Container;
@@ -98,6 +100,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     locallySubmittedUserSignatures: Set<string>;
     lastSigintTime: number;
     lastEscapeTime: number;
+    lastLeftTapTime: number;
     shutdownRequested: boolean;
     hookSelector: HookSelectorComponent | undefined;
     hookInput: HookInputComponent | undefined;
@@ -108,10 +111,12 @@ export declare class InteractiveMode implements InteractiveModeContext {
     skillCommands: Map<string, string>;
     oauthManualInput: OAuthManualInputManager;
     readonly lspServers: LspStartupServerInfo[] | undefined;
-    mcpManager?: import("../mcp").MCPManager;
-    constructor(session: AgentSession, version: string, changelogMarkdown?: string | undefined, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void, lspServers?: LspStartupServerInfo[] | undefined, mcpManager?: import("../mcp").MCPManager, eventBus?: EventBus);
+    mcpManager?: MCPManager;
+    constructor(session: AgentSession, version: string, changelogMarkdown?: string | undefined, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void, lspServers?: LspStartupServerInfo[] | undefined, mcpManager?: MCPManager, eventBus?: EventBus, titleSystemPrompt?: string);
     playWelcomeIntro(): void;
     init(options?: InteractiveModeInitOptions): Promise<void>;
+    /** Reload the title-generation system prompt override for the provided working directory. */
+    refreshTitleSystemPrompt(cwd?: string): Promise<void>;
     /** Reload slash commands and autocomplete for the provided working directory. */
     refreshSlashCommandState(cwd?: string): Promise<void>;
     /**
@@ -206,7 +211,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
         updateFooter?: boolean;
         populateHistory?: boolean;
     }): void;
-    renderInitialMessages(prebuiltContext?: SessionContext, options?: {
+    renderInitialMessages(options?: {
         preserveExistingChat?: boolean;
         clearTerminalHistory?: boolean;
     }): void;
@@ -234,7 +239,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleMemoryCommand(text: string): Promise<void>;
     handleSTTToggle(): Promise<void>;
     showDebugSelector(): Promise<void>;
-    showSessionObserver(): void;
+    showAgentHub(): void;
     resetObserverRegistry(): void;
     handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
     handlePythonCommand(code: string, excludeFromContext?: boolean): Promise<void>;
@@ -260,6 +265,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleResumeSession(sessionPath: string): Promise<void>;
     handleSessionDeleteCommand(): Promise<void>;
     showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
+    showProviderSetup(): Promise<void>;
     showHookConfirm(title: string, message: string): Promise<boolean>;
     handleCtrlC(): void;
     handleCtrlD(): void;

package/dist/types/modes/oauth-manual-input.d.ts

@@ -1,8 +1,15 @@
+type ClaimedInput = {
+    promise: Promise<string>;
+    clear: (reason?: string) => void;
+};
 export declare class OAuthManualInputManager {
     #private;
     waitForInput(providerId: string): Promise<string>;
+    tryWaitForInput(providerId: string): Promise<string> | undefined;
+    tryClaimInput(providerId: string): ClaimedInput | undefined;
     submit(input: string): boolean;
     clear(reason?: string): void;
     hasPending(): boolean;
     get pendingProviderId(): string | undefined;
 }
+export {};

package/dist/types/modes/rpc/rpc-client.d.ts

@@ -7,8 +7,8 @@ import type { AgentEvent, AgentMessage, AgentToolResult, ThinkingLevel } from "@
 import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
 import type { ImageContent, Model } from "@oh-my-pi/pi-ai";
 import type { BashResult } from "../../exec/bash-executor";
-import type { SessionStats } from "../../session/agent-session";
-import type { RpcHandoffResult, RpcHostToolDefinition, RpcSessionState } from "./rpc-types";
+import type { AgentSessionEvent, SessionStats } from "../../session/agent-session";
+import type { RpcHandoffResult, RpcHostToolDefinition, RpcSessionState, RpcSubagentEventFrame, RpcSubagentLifecycleFrame, RpcSubagentMessagesResult, RpcSubagentProgressFrame, RpcSubagentSnapshot, RpcSubagentSubscriptionLevel } from "./rpc-types";
 export interface RpcClientOptions {
     /** Path to the CLI entry point (default: searches for dist/cli.js) */
     cliPath?: string;
@@ -29,6 +29,10 @@ export interface RpcClientOptions {
 }
 export type ModelInfo = Pick<Model, "provider" | "id" | "contextWindow" | "reasoning" | "thinking">;
 export type RpcEventListener = (event: AgentEvent) => void;
+export type RpcSessionEventListener = (event: AgentSessionEvent) => void;
+export type RpcSubagentLifecycleListener = (payload: RpcSubagentLifecycleFrame["payload"]) => void;
+export type RpcSubagentProgressListener = (payload: RpcSubagentProgressFrame["payload"]) => void;
+export type RpcSubagentEventListener = (payload: RpcSubagentEventFrame["payload"]) => void;
 export interface RpcClientToolContext<TDetails = unknown> {
     toolCallId: string;
     signal: AbortSignal;
@@ -60,6 +64,22 @@ export declare class RpcClient {
      * Subscribe to agent events.
      */
     onEvent(listener: RpcEventListener): () => void;
+    /**
+     * Subscribe to all top-level session events, including non-core session state events.
+     */
+    onSessionEvent(listener: RpcSessionEventListener): () => void;
+    /**
+     * Subscribe to subagent lifecycle frames after setSubagentSubscription("progress" | "events").
+     */
+    onSubagentLifecycle(listener: RpcSubagentLifecycleListener): () => void;
+    /**
+     * Subscribe to aggregated subagent progress frames after setSubagentSubscription("progress" | "events").
+     */
+    onSubagentProgress(listener: RpcSubagentProgressListener): () => void;
+    /**
+     * Subscribe to raw subagent session events. Call setSubagentSubscription(\"events\") to enable them server-side.
+     */
+    onSubagentEvent(listener: RpcSubagentEventListener): () => void;
     /**
      * Get collected stderr output (useful for debugging).
      */
@@ -98,6 +118,23 @@ export declare class RpcClient {
      * Get current session state.
      */
     getState(): Promise<RpcSessionState>;
+    /**
+     * Configure subagent frames emitted by the RPC server. Servers default to "off".
+     * "progress" emits lifecycle/progress frames; "events" additionally emits raw subagent session events.
+     */
+    setSubagentSubscription(level: RpcSubagentSubscriptionLevel): Promise<RpcSubagentSubscriptionLevel>;
+    /**
+     * Return the RPC server's current subagent snapshot.
+     */
+    getSubagents(): Promise<RpcSubagentSnapshot[]>;
+    /**
+     * Read persisted transcript entries for a tracked subagent session.
+     */
+    getSubagentMessages(selector: {
+        subagentId?: string;
+        sessionFile?: string;
+        fromByte?: number;
+    }): Promise<RpcSubagentMessagesResult>;
     /**
      * Set model by provider and ID.
      */

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

@@ -1,12 +1,41 @@
 import { type ExtensionUIContext, type ExtensionUIDialogOptions } from "../../extensibility/extensions";
 import type { AgentSession } from "../../session/agent-session";
-import type { RpcExtensionUIRequest, RpcExtensionUIResponse, RpcHostToolCallRequest, RpcHostToolCancelRequest, RpcHostUriCancelRequest, RpcHostUriRequest, RpcResponse } from "./rpc-types";
+import type { EventBus } from "../../utils/event-bus";
+import { RpcSubagentRegistry } from "./rpc-subagents";
+import type { RpcCommand, RpcExtensionUIRequest, RpcExtensionUIResponse, RpcHostToolCallRequest, RpcHostToolCancelRequest, RpcHostUriCancelRequest, RpcHostUriRequest, RpcResponse } from "./rpc-types";
 export type * from "./rpc-types";
 export type PendingExtensionRequest = {
     resolve: (response: RpcExtensionUIResponse) => void;
     reject: (error: Error) => void;
 };
 type RpcOutput = (obj: RpcResponse | RpcExtensionUIRequest | RpcHostToolCallRequest | RpcHostToolCancelRequest | RpcHostUriRequest | RpcHostUriCancelRequest | object) => void;
+export type RpcSessionChangeCommand = Extract<RpcCommand, {
+    type: "new_session";
+} | {
+    type: "switch_session";
+} | {
+    type: "branch";
+}>;
+export type RpcSessionChangeResult = {
+    type: "new_session";
+    data: {
+        cancelled: boolean;
+    };
+} | {
+    type: "switch_session";
+    data: {
+        cancelled: boolean;
+    };
+} | {
+    type: "branch";
+    data: {
+        text: string;
+        cancelled: boolean;
+    };
+};
+export type RpcSessionChangeSession = Pick<AgentSession, "newSession" | "switchSession" | "branch">;
+export type RpcSubagentResetRegistry = Pick<RpcSubagentRegistry, "clear">;
+export declare function handleRpcSessionChange(session: RpcSessionChangeSession, command: RpcSessionChangeCommand, subagentRegistry?: RpcSubagentResetRegistry): Promise<RpcSessionChangeResult>;
 export declare function requestRpcEditor(pendingRequests: Map<string, PendingExtensionRequest>, output: RpcOutput, title: string, prefill?: string, dialogOptions?: ExtensionUIDialogOptions, editorOptions?: {
     promptStyle?: boolean;
 }): Promise<string | undefined>;
@@ -14,4 +43,4 @@ export declare function requestRpcEditor(pendingRequests: Map<string, PendingExt
  * Run in RPC mode.
  * Listens for JSON commands on stdin, outputs events and responses on stdout.
  */
-export declare function runRpcMode(session: AgentSession, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void): Promise<never>;
+export declare function runRpcMode(session: AgentSession, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void, eventBus?: EventBus): Promise<never>;

package/dist/types/modes/rpc/rpc-subagents.d.ts

@@ -0,0 +1,24 @@
+import { type SubagentEventPayload, type SubagentLifecyclePayload, type SubagentProgressPayload } from "../../task";
+import type { EventBus } from "../../utils/event-bus";
+import type { RpcSubagentFrame, RpcSubagentMessagesResult, RpcSubagentSnapshot, RpcSubagentSubscriptionLevel } from "./rpc-types";
+export interface RpcSubagentTranscriptSelector {
+    subagentId?: string;
+    sessionFile?: string;
+    fromByte?: number;
+}
+type RpcSubagentOutput = (frame: RpcSubagentFrame) => void;
+export declare function readRpcSubagentTranscript(sessionFile: string, fromByte?: number): Promise<RpcSubagentMessagesResult>;
+export declare class RpcSubagentRegistry {
+    #private;
+    constructor(eventBus: EventBus, output: RpcSubagentOutput);
+    dispose(): void;
+    clear(): void;
+    setSubscriptionLevel(level: RpcSubagentSubscriptionLevel): void;
+    getSubscriptionLevel(): RpcSubagentSubscriptionLevel;
+    getSubagents(): RpcSubagentSnapshot[];
+    handleLifecycle(payload: SubagentLifecyclePayload): void;
+    handleProgress(payload: SubagentProgressPayload): void;
+    handleEvent(payload: SubagentEventPayload): void;
+    resolveSessionFile(selector: RpcSubagentTranscriptSelector): string;
+}
+export {};