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

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

@@ -1,4 +1,14 @@
 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.
+ */
+export declare const WELCOME_SESSION_SLOTS = 4;
+/**
+ * Fixed number of LSP-server rows, for the same reason. Overflow is sliced so
+ * the box height is constant regardless of how many servers a project has.
+ */
+export declare const WELCOME_LSP_SLOTS = 4;
 export declare function renderWelcomeTip(tip: string, boxWidth: number): string[];
 export interface RecentSession {
     name: string;
@@ -6,7 +16,7 @@ export interface RecentSession {
 }
 export interface LspServerInfo {
     name: string;
-    status: "ready" | "error" | "connecting";
+    status: "ready" | "error" | "connecting" | "available";
     fileTypes: string[];
 }
 /**
@@ -19,8 +29,14 @@ export declare class WelcomeComponent implements Component {
     private providerName;
     private recentSessions;
     private lspServers;
-    constructor(version: string, modelName: string, providerName: string, recentSessions?: RecentSession[], lspServers?: LspServerInfo[]);
+    constructor(version: string, modelName: string, providerName: string, recentSessions?: RecentSession[] | null, 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 —
@@ -30,7 +46,7 @@ export declare class WelcomeComponent implements Component {
     setModel(modelName: string, providerName: string): void;
     setRecentSessions(sessions: RecentSession[]): void;
     setLspServers(servers: LspServerInfo[]): void;
-    render(termWidth: number): string[];
+    render(termWidth: number): readonly string[];
 }
 export declare const PI_LOGO: string[];
 export interface ShineConfig {

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

@@ -5,7 +5,7 @@ export declare class MCPAuthorizationLinkPrompt implements Component {
     #private;
     constructor(url: string);
     invalidate(): void;
-    render(_width: number): string[];
+    render(_width: number): readonly string[];
 }
 export declare class MCPCommandController {
     #private;

package/dist/types/modes/controllers/streaming-reveal.d.ts

@@ -10,7 +10,7 @@ type StreamingRevealControllerOptions = {
     requestRender(): void;
 };
 export declare function visibleUnits(message: AssistantMessage, hideThinking: boolean): number;
-export declare function buildDisplayMessage(target: AssistantMessage, revealed: number, hideThinking: boolean): AssistantMessage;
+export declare function buildDisplayMessage(target: AssistantMessage, revealed: number, hideThinking: boolean, countOf?: (index: number, text: string) => number): AssistantMessage;
 export declare function nextStep(backlog: number): number;
 export declare class StreamingRevealController {
     #private;

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

@@ -1,12 +1,13 @@
 import { type Agent, type AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { CompactionOutcome } from "@oh-my-pi/pi-agent-core/compaction";
-import { type AssistantMessage, type ImageContent, type Message, type UsageReport } from "@oh-my-pi/pi-ai";
+import type { AssistantMessage, ImageContent, Message, UsageReport } from "@oh-my-pi/pi-ai";
 import type { Component, EditorTheme } from "@oh-my-pi/pi-tui";
 import { Container, Loader, Spacer, Text, TUI } from "@oh-my-pi/pi-tui";
 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>;

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

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

@@ -9,7 +9,9 @@ import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
 import type { Effort, ImageContent, Model } from "@oh-my-pi/pi-ai";
 import type { BashResult } from "../../exec/bash-executor";
 import type { ContextUsage } from "../../extensibility/extensions/types";
-import type { SessionStats } from "../../session/agent-session";
+import type { AgentSessionEvent, SessionStats } from "../../session/agent-session";
+import type { FileEntry } from "../../session/session-manager";
+import type { AgentProgress, SubagentEventPayload, SubagentLifecyclePayload, SubagentProgressPayload } from "../../task";
 import type { TodoPhase } from "../../tools/todo";
 export type RpcCommand = {
     id?: string;
@@ -54,6 +56,19 @@ export type RpcCommand = {
     id?: string;
     type: "set_host_uri_schemes";
     schemes: RpcHostUriSchemeDefinition[];
+} | {
+    id?: string;
+    type: "set_subagent_subscription";
+    level: RpcSubagentSubscriptionLevel;
+} | {
+    id?: string;
+    type: "get_subagents";
+} | {
+    id?: string;
+    type: "get_subagent_messages";
+    subagentId?: string;
+    sessionFile?: string;
+    fromByte?: number;
 } | {
     id?: string;
     type: "set_model";
@@ -174,6 +189,29 @@ export interface RpcSessionState {
 export interface RpcHandoffResult {
     savedPath?: string;
 }
+export type RpcSubagentSubscriptionLevel = "off" | "progress" | "events";
+export interface RpcSubagentSnapshot {
+    id: string;
+    index: number;
+    agent: string;
+    agentSource: AgentProgress["agentSource"];
+    description?: string;
+    status: AgentProgress["status"];
+    task?: string;
+    assignment?: string;
+    sessionFile?: string;
+    lastUpdate: number;
+    progress?: AgentProgress;
+    parentToolCallId?: string;
+}
+export interface RpcSubagentMessagesResult {
+    sessionFile: string;
+    fromByte: number;
+    nextByte: number;
+    reset: boolean;
+    entries: FileEntry[];
+    messages: AgentMessage[];
+}
 export type RpcResponse = {
     id?: string;
     type: "response";
@@ -237,6 +275,28 @@ export type RpcResponse = {
     data: {
         schemes: string[];
     };
+} | {
+    id?: string;
+    type: "response";
+    command: "set_subagent_subscription";
+    success: true;
+    data: {
+        level: RpcSubagentSubscriptionLevel;
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "get_subagents";
+    success: true;
+    data: {
+        subagents: RpcSubagentSnapshot[];
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "get_subagent_messages";
+    success: true;
+    data: RpcSubagentMessagesResult;
 } | {
     id?: string;
     type: "response";
@@ -418,6 +478,20 @@ export type RpcResponse = {
     success: false;
     error: string;
 };
+export interface RpcSubagentLifecycleFrame {
+    type: "subagent_lifecycle";
+    payload: SubagentLifecyclePayload;
+}
+export interface RpcSubagentProgressFrame {
+    type: "subagent_progress";
+    payload: SubagentProgressPayload;
+}
+export interface RpcSubagentEventFrame {
+    type: "subagent_event";
+    payload: SubagentEventPayload;
+}
+export type RpcSubagentFrame = RpcSubagentLifecycleFrame | RpcSubagentProgressFrame | RpcSubagentEventFrame;
+export type RpcSessionEventFrame = AgentSessionEvent | RpcSubagentFrame;
 /** Emitted when an extension needs user input */
 export type RpcExtensionUIRequest = {
     type: "extension_ui_request";

package/dist/types/modes/setup-wizard/index.d.ts

@@ -14,4 +14,8 @@ export interface SetupSceneSelectionOptions {
 }
 export declare function selectSetupScenes(storedVersion: number, scenes: readonly SetupScene[], ctx?: InteractiveModeContext, options?: SetupSceneSelectionOptions): Promise<SetupScene[]>;
 export declare function markSetupWizardComplete(settings: Settings, version?: number): Promise<void>;
-export declare function runSetupWizard(ctx: InteractiveModeContext, scenes?: readonly SetupScene[]): Promise<void>;
+export interface RunSetupWizardOptions {
+    markComplete?: boolean;
+    playWelcomeIntro?: boolean;
+}
+export declare function runSetupWizard(ctx: InteractiveModeContext, scenes?: readonly SetupScene[], options?: RunSetupWizardOptions): Promise<void>;

package/dist/types/modes/setup-wizard/lazy.d.ts

@@ -0,0 +1,2 @@
+import type { InteractiveModeContext } from "../types";
+export declare function runProviderSetupWizard(ctx: InteractiveModeContext): Promise<void>;

package/dist/types/modes/setup-wizard/scenes/sign-in.d.ts

@@ -15,5 +15,5 @@ export declare class SignInTab implements SetupTab {
     dispose(): void;
     invalidate(): void;
     handleInput(data: string): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
 }

package/dist/types/modes/setup-wizard/scenes/types.d.ts

@@ -27,7 +27,7 @@ export interface SetupTab {
      * login). The parent scene MUST NOT switch tabs or finish while modal.
      */
     readonly modal: boolean;
-    render(width: number): string[];
+    render(width: number): readonly string[];
     handleInput(data: string): void;
     invalidate(): void;
     /** Called when the tab becomes active (including initial mount). */

package/dist/types/modes/setup-wizard/scenes/web-search.d.ts

@@ -16,5 +16,5 @@ export declare class WebSearchTab implements SetupTab {
     handleInput(data: string): void;
     invalidate(): void;
     dispose(): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
 }

package/dist/types/modes/setup-wizard/wizard-overlay.d.ts

@@ -10,5 +10,5 @@ export declare class SetupWizardComponent implements Component {
     dispose(): void;
     invalidate(): void;
     handleInput(data: string): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
 }

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

@@ -22,6 +22,7 @@ import type { HookInputComponent } from "./components/hook-input";
 import type { HookSelectorComponent, HookSelectorOptions } from "./components/hook-selector";
 import type { StatusLineComponent } from "./components/status-line";
 import type { ToolExecutionHandle } from "./components/tool-execution";
+import type { TranscriptContainer } from "./components/transcript-container";
 import type { LoopLimitRuntime } from "./loop-limit";
 import type { OAuthManualInputManager } from "./oauth-manual-input";
 import type { Theme } from "./theme/theme";
@@ -61,7 +62,7 @@ export interface InteractiveModeInitOptions {
 export type InteractiveSelectorDialogOptions = ExtensionUIDialogOptions & Pick<HookSelectorOptions, "disabledIndices">;
 export interface InteractiveModeContext {
     ui: TUI;
-    chatContainer: Container;
+    chatContainer: TranscriptContainer;
     pendingMessagesContainer: Container;
     statusContainer: Container;
     todoContainer: Container;
@@ -81,6 +82,7 @@ export interface InteractiveModeContext {
     historyStorage?: HistoryStorage;
     mcpManager?: MCPManager;
     lspServers?: LspStartupServerInfo[];
+    titleSystemPrompt?: string;
     isInitialized: boolean;
     isBashMode: boolean;
     toolOutputExpanded: boolean;
@@ -261,6 +263,7 @@ export interface 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>;
     showDebugSelector(): Promise<void>;
     showSessionObserver(): void;

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

@@ -1,5 +1,5 @@
 import type { SecretEntry } from "./obfuscator";
-export { deobfuscateSessionContext, obfuscateMessages, type SecretEntry, SecretObfuscator } from "./obfuscator";
+export { deobfuscateSessionContext, obfuscateMessages, obfuscateProviderContext, obfuscateProviderTools, type SecretEntry, SecretObfuscator, } from "./obfuscator";
 /**
  * Load secrets from project-local and global secrets.yml files.
  * Project-local entries override global entries with matching content.

package/dist/types/secrets/obfuscator.d.ts

@@ -1,4 +1,4 @@
-import type { Message } from "@oh-my-pi/pi-ai";
+import type { Context, Message, Tool } from "@oh-my-pi/pi-ai";
 import type { SessionContext } from "../session/session-manager";
 export interface SecretEntry {
     type: "plain" | "regex";
@@ -17,7 +17,13 @@ export declare class SecretObfuscator {
     deobfuscate(text: string): string;
     /** Deep-walk an object, deobfuscating all string values. */
     deobfuscateObject<T>(obj: T): T;
+    /** Deep-walk an object, obfuscating all string values. */
+    obfuscateObject<T>(obj: T): T;
 }
 export declare function deobfuscateSessionContext(sessionContext: SessionContext, obfuscator: SecretObfuscator | undefined): SessionContext;
-/** Obfuscate all text content in LLM messages (for outbound interception). */
+/** Obfuscate all string content in LLM messages (for outbound interception). */
 export declare function obfuscateMessages(obfuscator: SecretObfuscator, messages: Message[]): Message[];
+/** Obfuscate provider request context without walking live tool schema instances. */
+export declare function obfuscateProviderContext(obfuscator: SecretObfuscator | undefined, context: Context): Context;
+/** Convert tool schemas to wire JSON Schema before obfuscating provider-visible strings. */
+export declare function obfuscateProviderTools(obfuscator: SecretObfuscator | undefined, tools: Tool[] | undefined): Tool[] | undefined;

package/dist/types/session/agent-session.d.ts

@@ -19,7 +19,7 @@ import type { AssistantMessage, ImageContent, Message, MessageAttribution, Model
 import { Effort } from "@oh-my-pi/pi-ai";
 import { type AsyncJob, type AsyncJobDeliveryState, AsyncJobManager } from "../async";
 import type { Rule } from "../capability/rule";
-import { type ModelRegistry } from "../config/model-registry";
+import type { ModelRegistry } from "../config/model-registry";
 import { type ResolvedModelRoleValue } from "../config/model-resolver";
 import { type PromptTemplate } from "../config/prompt-templates";
 import type { Settings, SkillsSettings } from "../config/settings";
@@ -127,6 +127,8 @@ export interface AgentSessionConfig {
     agent: Agent;
     sessionManager: SessionManager;
     settings: Settings;
+    /** Whether the caller explicitly requested yolo/auto-approve behavior for this session. */
+    autoApprove?: boolean;
     /** Models to cycle through with Ctrl+P (from --models flag) */
     scopedModels?: Array<{
         model: Model;
@@ -548,7 +550,14 @@ export declare class AgentSession {
      * @throws Error if streaming and no streamingBehavior specified
      * @throws Error if no model selected or no API key available (when not streaming)
      */
-    prompt(text: string, options?: PromptOptions): Promise<void>;
+    /**
+     * Returns `false` when the command was fully handled locally (extension or
+     * custom-TS command consumed without calling the LLM). Returns `true` when
+     * the prompt was forwarded to the agent — either directly or queued as a
+     * steer/follow-up. Callers that render a UI or manage turn lifecycle (e.g.
+     * the ACP agent) use this to know whether to expect an `agent_end` event.
+     */
+    prompt(text: string, options?: PromptOptions): Promise<boolean>;
     promptCustomMessage<T = unknown>(message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">, options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice">): Promise<void>;
     /**
      * Queue a steering message to interrupt the agent mid-run.
@@ -700,7 +709,8 @@ export declare class AgentSession {
      */
     cycleRoleModels(roleOrder: readonly string[], direction?: "forward" | "backward"): Promise<RoleModelCycleResult | undefined>;
     /**
-     * Get all available models with valid API keys.
+     * Get all available models with valid API keys, filtered by `enabledModels` when configured.
+     * See {@link filterAvailableModelsByEnabledPatterns} for supported pattern forms and limitations.
      */
     getAvailableModels(): Model[];
     /**
@@ -849,9 +859,11 @@ export declare class AgentSession {
      * @param command The bash command to execute
      * @param onChunk Optional streaming callback for output
      * @param options.excludeFromContext If true, command output won't be sent to LLM (!! prefix)
+     * @param options.useUserShell If true, allow caller to request configured user-shell routing
      */
     executeBash(command: string, onChunk?: (chunk: string) => void, options?: {
         excludeFromContext?: boolean;
+        useUserShell?: boolean;
     }): Promise<BashResult>;
     /**
      * Record a bash execution result in session history.

package/dist/types/session/auth-broker-config.d.ts

@@ -9,5 +9,9 @@ export declare function getAuthBrokerTokenFilePath(): string;
  * (broker disabled — local store is used). Throws when URL is set but no
  * token is available — the caller cannot fall back silently because the
  * user explicitly asked to use the broker.
+ *
+ * Successful resolutions (including "no broker configured") are memoized for
+ * the process lifetime; failures are not, so a missing token can be fixed and
+ * retried. Concurrent callers share one in-flight resolution.
  */
 export declare function resolveAuthBrokerConfig(): Promise<AuthBrokerClientConfig | null>;

package/dist/types/session/session-manager.d.ts

@@ -249,7 +249,7 @@ declare class RecentSessionInfo {
 export declare function recoverOrphanedBackups(sessionDir: string, storage: SessionStorage): Promise<void>;
 /** Exported for testing */
 export declare function findMostRecentSession(sessionDir: string, storage?: SessionStorage): Promise<string | null>;
-/** Get recent sessions for display in welcome screen */
+/** Get recent sessions for display in welcome screen (which reserves WELCOME_SESSION_SLOTS rows) */
 export declare function getRecentSessions(sessionDir: string, limit?: number, storage?: SessionStorage): Promise<RecentSessionInfo[]>;
 /**
  * Manages conversation sessions as append-only trees stored in JSONL files.

package/dist/types/session/streaming-output.d.ts

@@ -2,6 +2,15 @@ import type { AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 export declare const DEFAULT_MAX_LINES = 3000;
 export declare const DEFAULT_MAX_BYTES: number;
 export declare const DEFAULT_MAX_COLUMN = 512;
+/**
+ * Default artifact-on-disk cap for {@link OutputSink}.
+ *
+ * `0` means unbounded: by default, `artifact://<id>` references preserve the
+ * complete raw stream instead of a capped head/tail sample.
+ */
+export declare const ARTIFACT_DEFAULT_MAX_BYTES = 0;
+/** Default head budget; the remainder becomes the rolling tail window. */
+export declare const ARTIFACT_DEFAULT_HEAD_BYTES: number;
 export interface OutputSummary {
     output: string;
     truncated: boolean;
@@ -41,6 +50,20 @@ export interface OutputSinkOptions {
     onChunk?: (chunk: string) => void;
     /** Minimum ms between onChunk calls. 0 = every chunk (default). */
     chunkThrottleMs?: number;
+    /**
+     * Optional cap on bytes written to the artifact-on-disk file. When the cap
+     * is hit, the head window is preserved verbatim and subsequent output feeds
+     * a rolling tail window; on close, the sink writes a single
+     * `[ARTIFACT TRUNCATED: …]` notice between them. Default
+     * {@link ARTIFACT_DEFAULT_MAX_BYTES} (unbounded).
+     */
+    artifactMaxBytes?: number;
+    /**
+     * Bytes reserved for the head window of the capped artifact file. The
+     * tail window receives `artifactMaxBytes - artifactHeadBytes`. Default
+     * {@link ARTIFACT_DEFAULT_HEAD_BYTES}; clamped to `[0, artifactMaxBytes]`.
+     */
+    artifactHeadBytes?: number;
 }
 export interface TruncationResult {
     content: string;

package/dist/types/slash-commands/acp-builtins.d.ts

@@ -1,6 +1,22 @@
 import type { AvailableCommand } from "@agentclientprotocol/sdk";
 import type { AcpBuiltinSlashCommandResult, SlashCommandRuntime } from "./types";
 export type { AcpBuiltinSlashCommandResult } from "./types";
+/**
+ * All names (primary + aliases) that are reserved by ACP builtins. Used to
+ * filter out extension commands that would shadow a builtin or its alias at
+ * dispatch time (e.g. `models` is an alias for `/model`, so an extension
+ * registering `models` would appear in the palette but execute the builtin).
+ */
+export declare const ACP_BUILTIN_RESERVED_NAMES: ReadonlySet<string>;
+/**
+ * Whether an extension command named `name` would be captured by ACP builtin
+ * dispatch before reaching the extension handler. Beyond exact name/alias
+ * collisions, `parseSlashCommand` treats `:` as a name/args separator, so a
+ * colon-namespaced name whose prefix is a handled builtin (e.g. `model:foo`)
+ * executes the `/model` builtin with `foo` as args. Such names must not be
+ * advertised to ACP clients.
+ */
+export declare function isAcpBuiltinShadowedName(name: string): boolean;
 /**
  * Commands advertised to ACP clients. Entries without a text-mode `handle`
  * (e.g. `/quit`, `/login`, dashboards) are filtered out so the client doesn't