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

package/dist/types/cli/args.d.ts

@@ -8,6 +8,7 @@ export interface Args {
     allowHome?: boolean;
     provider?: string;
     model?: string;
+    config?: string[];
     smol?: string;
     slow?: string;
     plan?: string;

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

@@ -10,6 +10,7 @@
  */
 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;
 /**
  * Return true when `first` matches a registered subcommand name or alias.
  *
@@ -17,3 +18,14 @@ export declare const commands: CommandEntry[];
  * runner skips ahead to the default `launch` command.
  */
 export declare function isSubcommand(first: string | undefined): boolean;
+export type ResolvedCliArgv = {
+    argv: string[];
+} | {
+    error: string;
+};
+/**
+ * Decide what the CLI runner should do with raw argv: reject bare reserved
+ * management words, pass help/version through untouched, and route everything
+ * that is not a known subcommand to `launch`.
+ */
+export declare function resolveCliArgv(argv: string[]): ResolvedCliArgv;

package/dist/types/commands/launch.d.ts

@@ -47,6 +47,10 @@ export default class Index extends Command {
             description: string;
             options: string[];
         };
+        config: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+            multiple: true;
+        };
         print: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"boolean"> & {
             char: string;
             description: string;

package/dist/types/config/api-key-resolver.d.ts

@@ -4,6 +4,8 @@ export interface ApiKeyResolverOptions {
     sessionId?: string;
     /** Provider base URL hint forwarded to the auth-storage cascade. */
     baseUrl?: string;
+    /** Provider model id forwarded to model-scoped usage ranking/backoff. */
+    modelId?: string;
 }
 /**
  * Minimal slice of `ModelRegistry` the resolver needs. Typed structurally so
@@ -13,6 +15,7 @@ export interface ApiKeyResolverOptions {
 export interface ApiKeyResolverRegistry {
     getApiKeyForProvider(provider: string, sessionId?: string, options?: {
         baseUrl?: string;
+        modelId?: string;
         forceRefresh?: boolean;
         signal?: AbortSignal;
     }): Promise<string | undefined>;

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

@@ -148,6 +148,7 @@ export declare class ModelRegistry {
      */
     getApiKeyForProvider(provider: string, sessionId?: string, options?: {
         baseUrl?: string;
+        modelId?: string;
         forceRefresh?: boolean;
         signal?: AbortSignal;
     }): Promise<string | undefined>;

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

@@ -174,6 +174,24 @@ export declare function resolveModelScope(patterns: string[], modelRegistry: Pic
  * rather than falling back to the global default (see issue #1022).
  */
 export declare function resolveAllowedModels(modelRegistry: Pick<ModelRegistry, "getAvailable" | "getCanonicalVariants">, settings: Settings | undefined, preferences?: ModelMatchPreferences): Promise<Model<Api>[]>;
+/**
+ * Synchronous subset of {@link resolveAllowedModels} for contexts where async is unavailable
+ * (e.g. `getAvailableModels()` which is called from the ACP model-list advertisement, RPC
+ * `get_available_models`, and the `/model` slash command). Uses the same effective
+ * `enabledModels` scope semantics as startup resolution:
+ *
+ * - Glob selectors match `provider/modelId` and bare model id
+ * - Exact canonical ids expand to all available concrete variants
+ * - Exact `provider/modelId`, bare ids, provider-scoped fuzzy, and substring selectors
+ *   resolve through the shared model-pattern matcher
+ * - Optional `:thinkingLevel` suffixes are stripped only when valid
+ *
+ * When no pattern resolves to any model (misconfiguration / typo) an empty list is returned,
+ * consistent with the empty-list contract of {@link resolveAllowedModels}. Callers that render
+ * a UI picker should treat an empty list as "hide the picker entry", matching how the SDK
+ * surfaces the same misconfiguration during session initialization.
+ */
+export declare function filterAvailableModelsByEnabledPatterns(available: Model<Api>[], patterns: readonly string[], registry: Pick<ModelRegistry, "getCanonicalVariants">): Model<Api>[];
 export interface ResolveCliModelResult {
     model: Model<Api> | undefined;
     selector?: string;

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

@@ -62,7 +62,7 @@ export type AnyUiMetadata = UiBase & {
 };
 interface BooleanDef {
     type: "boolean";
-    default: boolean;
+    default: boolean | undefined;
     ui?: UiBoolean;
 }
 interface StringDef {
@@ -2392,6 +2392,20 @@ export declare const SETTINGS_SCHEMA: {
         readonly type: "number";
         readonly default: number;
     };
+    readonly "shellMinimizer.sourceOutlineLevel": {
+        readonly type: "enum";
+        readonly values: readonly ["default", "aggressive"];
+        readonly default: "default";
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Shell Minimizer Source Outline";
+            readonly description: "Source outline mode for cat/read of source files: default or aggressive";
+        };
+    };
+    readonly "shellMinimizer.legacyFilters": {
+        readonly type: "boolean";
+        readonly default: undefined;
+    };
     readonly "eval.py": {
         readonly type: "boolean";
         readonly default: true;
@@ -2420,6 +2434,15 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Whether to keep IPython kernel alive across calls";
         };
     };
+    readonly "python.interpreter": {
+        readonly type: "string";
+        readonly default: "";
+        readonly ui: {
+            readonly tab: "editing";
+            readonly label: "Python Interpreter";
+            readonly description: "Optional path to an exact Python executable. When set, automatic Python runtime discovery is skipped.";
+        };
+    };
     readonly "tools.approval": {
         readonly type: "record";
         readonly default: {};
@@ -3896,6 +3919,9 @@ export type SettingPath = keyof Schema;
 /** Infer the value type for a setting path */
 export type SettingValue<P extends SettingPath> = Schema[P] extends {
     type: "boolean";
+    default: undefined;
+} ? boolean | undefined : Schema[P] extends {
+    type: "boolean";
 } ? boolean : Schema[P] extends {
     type: "string";
 } ? string | undefined : Schema[P] extends {
@@ -4051,6 +4077,8 @@ export interface ShellMinimizerSettings {
     only: string[];
     except: string[];
     maxCaptureBytes: number;
+    sourceOutlineLevel: "default" | "aggressive";
+    legacyFilters: boolean | undefined;
 }
 /** Map group prefix -> typed settings interface */
 export interface GroupTypeMap {

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

@@ -30,6 +30,8 @@ export interface SettingsOptions {
     inMemory?: boolean;
     /** Initial overrides */
     overrides?: Partial<Record<SettingPath, unknown>>;
+    /** Extra config.yml-style overlays loaded after global/project settings */
+    configFiles?: string[];
 }
 export declare class Settings {
     #private;
@@ -54,6 +56,11 @@ export declare class Settings {
      * Returns the merged value from global + project + overrides, or the default.
      */
     get<P extends SettingPath>(path: P): SettingValue<P>;
+    /**
+     * Whether `path` has an explicitly configured value (global config, project
+     * config, or runtime override) rather than falling back to the schema default.
+     */
+    isConfigured(path: SettingPath): boolean;
     /**
      * Set a setting value (sync).
      * Updates global settings and queues a background save.

package/dist/types/edit/hashline/noop-loop-guard.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Per-session guard against subagents looping on byte-identical no-op edits.
+ *
+ * A hashline patch can apply cleanly yet produce no change when the body rows
+ * are already byte-identical to the targeted lines. {@link executeHashlineSingle}
+ * surfaces a soft hint ("re-read the file before issuing another edit"), but in
+ * the wild some models ignore the hint and keep re-issuing the same bytes
+ * (issue #2081 captured 182 such repeats in 205 calls before the user aborted).
+ *
+ * This module tracks consecutive byte-identical no-op edits per canonical file
+ * path within a single session. Once the same payload no-ops {@link NOOP_HARD_LIMIT}
+ * times in a row the caller is expected to escalate from a soft text result to
+ * a thrown {@link ToolError} so the agent loop sees a tool *failure* — empirically
+ * far more effective at breaking the cycle than the soft hint alone.
+ *
+ * A successful (non-noop) commit for a path resets that path's counter; a
+ * different payload on the same path also resets it because the body hash
+ * changed, which is a sign of model progress and deserves another soft hint.
+ */
+interface NoopLoopEntry {
+    /** Hash of the most recent input that no-op'd on this canonical path. */
+    hash: string;
+    /** Consecutive no-op count for the same `hash` on this path. */
+    count: number;
+}
+/** Cross-session-safe state slot held on the `ToolSession`. */
+export interface NoopLoopGuard {
+    entries: Map<string, NoopLoopEntry>;
+}
+/**
+ * After this many consecutive byte-identical no-op edits on the same path,
+ * {@link recordNoopEdit} returns `escalate: true`. Picked deliberately small
+ * so the soft hint still fires once or twice before we escalate — the model
+ * deserves a chance to recover, but a tight bound is what actually breaks
+ * loops in practice.
+ */
+export declare const NOOP_HARD_LIMIT = 3;
+interface NoopLoopGuardOwner {
+    noopLoopGuard?: NoopLoopGuard;
+}
+/** Lazily create the per-session guard, mirroring `getFileSnapshotStore`. */
+export declare function getNoopLoopGuard(session: NoopLoopGuardOwner): NoopLoopGuard;
+/** Result of recording one no-op against the guard. */
+export interface NoopRecordResult {
+    /** Consecutive identical no-op count, including the current one. */
+    count: number;
+    /** True once `count >= NOOP_HARD_LIMIT` and the caller MUST escalate. */
+    escalate: boolean;
+}
+/**
+ * Record a no-op edit for `canonicalPath` keyed by `inputHash` (a stable hash
+ * of the raw patch input bytes). Returns the running consecutive-no-op count
+ * and whether the caller should escalate from a soft text result to a thrown
+ * error.
+ *
+ * `inputHash` is intentionally derived from the raw model-authored bytes
+ * rather than from file content: when the model emits a different payload
+ * (even whitespace-only) that's progress and earns a fresh soft hint, but
+ * re-issuing the same bytes after being warned is what we want to break.
+ */
+export declare function recordNoopEdit(session: NoopLoopGuardOwner, canonicalPath: string, inputHash: string): NoopRecordResult;
+/**
+ * Clear the no-op counter for `canonicalPath`. Call after a non-noop commit
+ * for the same path so a future no-op starts fresh from the soft hint.
+ */
+export declare function resetNoopEdit(session: NoopLoopGuardOwner, canonicalPath: string): void;
+/**
+ * Stable hash of the raw patch input. Bun's `Bun.hash` is xxHash64 — fast,
+ * non-cryptographic, more than adequate for "is this the same payload?".
+ */
+export declare function hashPatchInput(input: string): string;
+export {};

package/dist/types/eval/py/executor.d.ts

@@ -25,6 +25,11 @@ export interface PythonExecutorOptions {
     kernelOwnerId?: string;
     /** Kernel mode (session reuse vs per-call) */
     kernelMode?: PythonKernelMode;
+    /**
+     * Explicit interpreter path (`python.interpreter` resolved from the
+     * session's settings). Skips automatic runtime discovery when set.
+     */
+    interpreter?: string;
     /** Restart the kernel before executing */
     reset?: boolean;
     /** Session file path for accessing task outputs */

package/dist/types/eval/py/kernel.d.ts

@@ -45,6 +45,11 @@ interface KernelLifecycleOptions {
 interface KernelStartOptions extends KernelLifecycleOptions {
     cwd: string;
     env?: Record<string, string | undefined>;
+    /**
+     * Explicit interpreter path (`python.interpreter` from the session's
+     * settings). When set, runtime discovery is skipped entirely.
+     */
+    interpreter?: string;
 }
 interface KernelShutdownOptions {
     signal?: AbortSignal;
@@ -57,7 +62,7 @@ export interface PythonKernelAvailability {
     /** The probed-working runtime, when one was found. */
     runtime?: PythonRuntime;
 }
-export declare function checkPythonKernelAvailability(cwd: string): Promise<PythonKernelAvailability>;
+export declare function checkPythonKernelAvailability(cwd: string, interpreter?: string): Promise<PythonKernelAvailability>;
 export declare class PythonKernel {
     #private;
     readonly id: string;

package/dist/types/eval/py/runtime.d.ts

@@ -15,6 +15,15 @@ export declare function filterEnv(env: Record<string, string | undefined>): Reco
  * Detect virtual environment path from VIRTUAL_ENV or common locations.
  */
 export declare function resolveVenvPath(cwd: string): string | undefined;
+/**
+ * Resolve an explicitly configured interpreter (`python.interpreter`) into a
+ * runtime, bypassing discovery. Does not probe or validate the executable —
+ * callers must check it actually runs. `~` expands to the home directory and
+ * relative paths resolve against `cwd`. When the interpreter sits inside a
+ * virtualenv (a `pyvenv.cfg` above its bin dir), the venv activation env is
+ * applied so subprocesses and `pip` resolve consistently.
+ */
+export declare function resolveExplicitPythonRuntime(interpreter: string, cwd: string, baseEnv: Record<string, string | undefined>): PythonRuntime;
 /**
  * Enumerate candidate Python runtimes in priority order: an active/project venv,
  * the managed `~/.omp/python-env`, then the system interpreter on PATH. Every

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

@@ -10,6 +10,8 @@ export interface BashExecutorOptions {
     sessionKey?: string;
     /** Additional environment variables to inject */
     env?: Record<string, string>;
+    /** Run through the configured user shell instead of brush parsing directly. */
+    useUserShell?: boolean;
     /** Artifact path/id for full output storage */
     artifactPath?: string;
     artifactId?: string;

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/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/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;
@@ -108,10 +110,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>;
     /**
@@ -260,6 +264,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>;