@oh-my-pi/pi-coding-agent 17.1.8 → 17.2.1

package/dist/types/edit/edit-clipboard.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Session-bound edit clipboard register.
+ *
+ * `CUT`/`PASTE` hashline ops share one {@link Clipboard} per session so
+ * content captured by one edit call can be pasted by a later one (and across
+ * files within one call). The executor works on a fork per batch and commits
+ * it back only after every write lands — see `executeHashlineSingle`.
+ */
+import type { Clipboard } from "@oh-my-pi/hashline";
+interface EditClipboardOwner {
+    editClipboard?: Clipboard;
+}
+/**
+ * Look up (or lazily create) the clipboard register attached to a session.
+ * Storage lives on `session.editClipboard` so it ages out exactly with the
+ * session itself.
+ */
+export declare function getEditClipboard(session: EditClipboardOwner): Clipboard;
+export {};

package/dist/types/edit/hashline/diff.d.ts

@@ -1,4 +1,4 @@
-import { type PatchSection, type SnapshotStore } from "@oh-my-pi/hashline";
+import { type Clipboard, type PatchSection, type SnapshotStore } from "@oh-my-pi/hashline";
 export interface HashlineDiffOptions {
     /**
      * Use the streaming-tolerant applier ({@link PatchSection.applyPartialTo})
@@ -12,6 +12,14 @@ export interface HashlineDiffOptions {
      * authoring input; the final apply path still validates through Patcher.
      */
     skipHashValidation?: boolean;
+    /**
+     * Clipboard register shared across the sections of one patch preview.
+     * `CUT` in an earlier section feeds `PASTE` in a later one, so the preview
+     * matches apply. Multi-section previews MUST thread one register through
+     * sections in patch order; omitted, each section gets a
+     * private register (same-file cut/paste still previews correctly).
+     */
+    clipboard?: Clipboard;
 }
 export declare function computeHashlineSectionDiff(section: PatchSection, cwd: string, snapshots: SnapshotStore, options?: HashlineDiffOptions): Promise<{
     diff: string;

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

@@ -33,7 +33,14 @@ export declare class EditTool implements AgentTool<TInput> {
     readonly loadMode = "essential";
     readonly concurrency = "exclusive";
     readonly strict = true;
-    constructor(session: ToolSession);
+    /**
+     * `mode` pins the edit variant for this instance, for callers whose protocol
+     * fixes the shape of an edit. The Cursor `pi_edit` frame carries
+     * `old_text`/`new_text` pairs, which only `replace` accepts — under the
+     * default `hashline` mode those args do not match the schema at all. Left
+     * unset, the env/settings resolution applies as before.
+     */
+    constructor(session: ToolSession, mode?: EditMode);
     get mode(): EditMode;
     get description(): string;
     get parameters(): TInput;

package/dist/types/edit/streaming.d.ts

@@ -12,7 +12,7 @@
  * The shared renderer / `ToolExecutionComponent` consult the strategy via
  * the injected `editMode` rather than probing argument shape.
  */
-import { type SnapshotStore } from "@oh-my-pi/hashline";
+import { type Clipboard, type SnapshotStore } from "@oh-my-pi/hashline";
 import type { Theme } from "../modes/theme/theme.js";
 import { type EditMode, resolveEditMode } from "../utils/edit-mode.js";
 export interface PerFileDiffPreview {
@@ -34,6 +34,13 @@ export interface StreamingDiffContext {
      * not flicker in the preview.
      */
     isStreaming?: boolean;
+    /**
+     * Session-persistent clipboard register (`CUT`/`PASTE`). Previews
+     * fork it per frame — never mutating it — so a `PASTE` of content cut in
+     * an earlier edit call (or an earlier section of this patch) renders the
+     * real rows.
+     */
+    clipboard?: Clipboard;
 }
 /**
  * Per-file projection of a streamed edit payload. Pairs one target file path

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

@@ -8,9 +8,10 @@ import type { ModelRegistry } from "../../config/model-registry.js";
 import type { Settings } from "../../config/settings.js";
 import type { LocalProtocolOptions } from "../../internal-urls/local-protocol.js";
 import type { MemoryRuntimeContext } from "../../memory-backend/index.js";
+import type { AsyncJobSnapshot } from "../../session/agent-session.js";
 import type { SessionManager } from "../../session/session-manager.js";
 import type { BranchHandler, NavigateTreeHandler, NewSessionHandler } from "../session-handler-types.js";
-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, SessionStopEvent, SessionStopEventResult, ToolCallEvent, ToolCallEventResult, ToolResultEvent, ToolResultEventResult, UserBashEvent, UserBashEventResult, UserPythonEvent, UserPythonEventResult } from "./types.js";
+import type { AfterProviderResponseEvent, AssistantThinkingRenderer, BeforeAgentStartEvent, BeforeAgentStartEventResult, BeforeProviderRequestEvent, BeforeProviderRequestEventResult, ContextEvent, Extension, ExtensionActions, ExtensionCommandContext, ExtensionCommandContextActions, ExtensionContext, ExtensionContextActions, ExtensionError, ExtensionEvent, ExtensionFlag, ExtensionRuntime, ExtensionShortcut, ExtensionUIContext, InputEvent, InputEventResult, McpNotificationEvent, MessageRenderer, RegisteredCommand, RegisteredTool, ResourcesDiscoverEvent, SessionBeforeBranchResult, SessionBeforeCompactResult, SessionBeforeSwitchResult, SessionBeforeTreeResult, SessionCompactingResult, SessionStopEvent, SessionStopEventResult, ToolCallEvent, ToolCallEventResult, ToolResultEvent, ToolResultEventResult, UserBashEvent, UserBashEventResult, UserPythonEvent, UserPythonEventResult } from "./types.js";
 /** Combined result from all before_agent_start handlers */
 interface BeforeAgentStartCombinedResult {
     messages?: NonNullable<BeforeAgentStartEventResult["message"]>[];
@@ -73,7 +74,7 @@ export declare class ExtensionRunner {
     markToolCallEmitted(toolCallId: string, toolName: string): void;
     /** Consumes a {@link markToolCallEmitted} marker; true when the loop already emitted. */
     consumeToolCallEmitted(toolCallId: string, toolName: string): boolean;
-    constructor(extensions: Extension[], runtime: ExtensionRuntime, cwd: string, sessionManager: SessionManager, modelRegistry: ModelRegistry, getMemory?: () => MemoryRuntimeContext | undefined, settings?: Settings | undefined, localProtocolOptions?: LocalProtocolOptions | undefined);
+    constructor(extensions: Extension[], runtime: ExtensionRuntime, cwd: string, sessionManager: SessionManager, modelRegistry: ModelRegistry, getMemory?: () => MemoryRuntimeContext | undefined, settings?: Settings | undefined, localProtocolOptions?: LocalProtocolOptions | undefined, getAsyncJobSnapshot?: () => AsyncJobSnapshot | null);
     initialize(actions: ExtensionActions, contextActions: ExtensionContextActions, commandContextActions?: ExtensionCommandContextActions, uiContext?: ExtensionUIContext): void;
     /**
      * Forward a `credential_disabled` event from `AuthStorage` to extension handlers.
@@ -90,6 +91,22 @@ export declare class ExtensionRunner {
      * {@link onError} via {@link emit}'s normal isolation.
      */
     emitCredentialDisabled(event: CredentialDisabledEvent): Promise<void>;
+    /**
+     * Forward an MCP server notification to extension handlers.
+     *
+     * If {@link initialize} has not yet run, the notification is buffered and replayed
+     * once initialize wires the runtime/UI context. Matches the credential-disabled
+     * deferral above: the sdk.ts bridge registers `MCPManager.addNotificationListener`
+     * inside `createAgentSession` — BEFORE the mode controller calls `initialize()` on
+     * this runner — so notification frames drained by the manager (either fresh
+     * arrivals or replay from its own startup buffer) can reach us pre-init. Without
+     * this buffer they would evaporate for a second time here.
+     *
+     * Bounded at {@link MAX_PENDING_MCP_NOTIFICATIONS}; oldest entries drop under
+     * pressure. Never throws; per-handler errors are routed through {@link onError}
+     * via {@link emit}'s normal isolation.
+     */
+    emitMcpNotification(event: Omit<McpNotificationEvent, "type">): Promise<void>;
     /** Emits a session stop pass that can be cancelled with the active settle signal. */
     emitSessionStop(event: Omit<SessionStopEvent, "type">): Promise<SessionStopEventResult | undefined>;
     getUIContext(): ExtensionUIContext;

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

@@ -26,6 +26,7 @@ import type { LocalProtocolOptions } from "../../internal-urls/local-protocol.js
 import type { MemoryRuntimeContext } from "../../memory-backend/index.js";
 import type { CustomEditor } from "../../modes/components/custom-editor.js";
 import type { Theme } from "../../modes/theme/theme.js";
+import type { AsyncJobSnapshot } from "../../session/agent-session.js";
 import type { CompactMode } from "../../session/compact-modes.js";
 import type { CustomMessage, CustomMessagePayload } from "../../session/messages.js";
 import type { ReadonlySessionManager, SessionManager } from "../../session/session-manager.js";
@@ -276,6 +277,8 @@ export interface ExtensionContext {
     ui: ExtensionUIContext;
     /** Get current context usage for the active model. */
     getContextUsage(): ContextUsage | undefined;
+    /** Get a read-only snapshot of async jobs owned by this session. */
+    getAsyncJobSnapshot(): AsyncJobSnapshot | null;
     /** Compact the session context (interactive mode shows UI). */
     compact(instructionsOrOptions?: string | CompactOptions): Promise<void>;
     /** Whether UI is available (false in print/RPC mode) */
@@ -494,6 +497,26 @@ export interface CredentialDisabledEvent {
     /** Verbatim error captured for forensics (truncated upstream). */
     disabledCause: string;
 }
+/**
+ * Fired for every JSON-RPC notification received from a connected MCP server,
+ * AFTER the runtime's own handling of known list/update methods. Unknown or
+ * server-custom methods are delivered too — extensions can bridge them into
+ * session behavior by inspecting `method`/`params` and injecting a follow-up
+ * via `pi.sendMessage(..., { deliverAs })` or `pi.sendUserMessage(...)`.
+ */
+export interface McpNotificationEvent {
+    type: "mcp_notification";
+    /**
+     * Server name as declared in the MCP config (raw, unsanitized). Note this
+     * differs from the sanitized prefix used in `mcp__<sanitized_server>_<tool>`
+     * tool names — filter by this raw name, not by tool-name prefix matching.
+     */
+    server: string;
+    /** JSON-RPC method (e.g. `notifications/tools/list_changed`, or server-custom). */
+    method: string;
+    /** JSON-RPC params, opaque to the runtime. */
+    params: unknown;
+}
 /** Fired when user executes a bash command via ! or !! prefix */
 export interface UserBashEvent {
     type: "user_bash";
@@ -639,7 +662,7 @@ export declare function isToolCallEventType<TName extends string, TInput extends
     input: TInput;
 };
 /** Union of all event types */
-export type ExtensionEvent = ResourcesDiscoverEvent | SessionEvent | ContextEvent | BeforeProviderRequestEvent | AfterProviderResponseEvent | BeforeAgentStartEvent | AgentStartEvent | AgentEndEvent | SessionStopEvent | TurnStartEvent | TurnEndEvent | MessageStartEvent | MessageUpdateEvent | MessageEndEvent | ToolExecutionStartEvent | ToolExecutionUpdateEvent | ToolExecutionEndEvent | AutoCompactionStartEvent | AutoCompactionEndEvent | AutoRetryStartEvent | AutoRetryEndEvent | TtsrTriggeredEvent | TodoReminderEvent | GoalUpdatedEvent | CredentialDisabledEvent | UserBashEvent | UserPythonEvent | InputEvent | ToolCallEvent | ToolResultEvent | ToolApprovalRequestedEvent | ToolApprovalResolvedEvent;
+export type ExtensionEvent = ResourcesDiscoverEvent | SessionEvent | ContextEvent | BeforeProviderRequestEvent | AfterProviderResponseEvent | BeforeAgentStartEvent | AgentStartEvent | AgentEndEvent | SessionStopEvent | TurnStartEvent | TurnEndEvent | MessageStartEvent | MessageUpdateEvent | MessageEndEvent | ToolExecutionStartEvent | ToolExecutionUpdateEvent | ToolExecutionEndEvent | AutoCompactionStartEvent | AutoCompactionEndEvent | AutoRetryStartEvent | AutoRetryEndEvent | TtsrTriggeredEvent | TodoReminderEvent | GoalUpdatedEvent | CredentialDisabledEvent | McpNotificationEvent | UserBashEvent | UserPythonEvent | InputEvent | ToolCallEvent | ToolResultEvent | ToolApprovalRequestedEvent | ToolApprovalResolvedEvent;
 export interface ContextEventResult {
     messages?: AgentMessage[];
 }
@@ -748,6 +771,7 @@ export interface ExtensionAPI {
     on(event: "tool_result", handler: ExtensionHandler<ToolResultEvent, ToolResultEventResult>): void;
     on(event: "user_bash", handler: ExtensionHandler<UserBashEvent, UserBashEventResult>): void;
     on(event: "user_python", handler: ExtensionHandler<UserPythonEvent, UserPythonEventResult>): void;
+    on(event: "mcp_notification", handler: ExtensionHandler<McpNotificationEvent>): void;
     /** Register a tool that the LLM can call. */
     registerTool<TParams extends TSchema = TSchema, TDetails = unknown>(tool: ToolDefinition<TParams, TDetails>): void;
     /** Register a custom command. */

package/dist/types/extensibility/legacy-pi-coding-agent-shim.d.ts

@@ -77,6 +77,21 @@ export interface LsOperations {
 export interface LsToolOptions {
     operations?: LsOperations;
 }
+export interface EditOperations {
+    readFile: (absolutePath: string) => Promise<Buffer>;
+    writeFile: (absolutePath: string, content: string) => Promise<void>;
+    access: (absolutePath: string) => Promise<void>;
+}
+export interface EditToolOptions {
+    operations?: EditOperations;
+}
+export interface WriteOperations {
+    writeFile: (absolutePath: string, content: string) => Promise<void>;
+    mkdir: (dir: string) => Promise<void>;
+}
+export interface WriteToolOptions {
+    operations?: WriteOperations;
+}
 /** Format the active shortcut for legacy extensions that render keybinding hints. */
 export declare function keyText(action: Keybinding): string;
 /** Parse frontmatter using the historical Pi package-root helper. */
@@ -110,6 +125,14 @@ export declare function createFindTool(cwd: string, options?: FindToolOptions):
 export declare function createLsToolDefinition(cwd: string, options?: LsToolOptions): ToolDefinition;
 /** Create the legacy ls tool. */
 export declare function createLsTool(cwd: string, options?: LsToolOptions): ToolDefinition;
+/** Create the legacy edit tool definition. */
+export declare function createEditToolDefinition(cwd: string, options?: EditToolOptions): ToolDefinition;
+/** Create the legacy edit tool. */
+export declare function createEditTool(cwd: string, options?: EditToolOptions): ToolDefinition;
+/** Create the legacy write tool definition. */
+export declare function createWriteToolDefinition(cwd: string, options?: WriteToolOptions): ToolDefinition;
+/** Create the legacy write tool. */
+export declare function createWriteTool(cwd: string, options?: WriteToolOptions): ToolDefinition;
 /** Create legacy read, bash, edit, and write tools. */
 export declare function createCodingTools(cwd: string): ToolDefinition[];
 /** Create legacy read, grep, find, and ls tools. */
@@ -376,6 +399,8 @@ export { getProjectDir } from "@oh-my-pi/pi-utils";
  */
 export declare function getPackageDir(): string;
 export { estimateTokens } from "@oh-my-pi/pi-agent-core/compaction";
+export { CONFIG_DIR_NAME } from "@oh-my-pi/pi-utils";
+export { parseArgs } from "../cli/args.js";
 export * from "../index.js";
 export { formatBytes as formatSize } from "../tools/render-utils.js";
 export { copyToClipboard } from "../utils/clipboard.js";

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

@@ -19,6 +19,7 @@ export * from "./omp-protocol.js";
 export * from "./parse.js";
 export * from "./router.js";
 export * from "./rule-protocol.js";
+export * from "./security-protocol.js";
 export * from "./skill-protocol.js";
 export * from "./ssh-protocol.js";
 export type * from "./types.js";

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

@@ -47,8 +47,9 @@ export declare class LocalProtocolHandler implements ProtocolHandler {
     readonly immutable = false;
     /**
      * Install a process-global override that wins over the AgentRegistry-based
-     * derivation. Used by SDK consumers that wire `localProtocolOptions` on
-     * `createAgentSession` and by subagents that share their parent's root.
+     * derivation. Used by top-level SDK consumers that wire
+     * `localProtocolOptions` on `createAgentSession`; subagents keep their
+     * inherited mapping session-bound.
      */
     static setOverride(value: LocalProtocolOptions | undefined): void;
     /** Reset the process-global override. Test-only. */

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

@@ -0,0 +1,15 @@
+import { SecurityStore } from "../security/store.js";
+import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext, UrlCompletion } from "./types.js";
+export type SecurityStoreResolver = (cwd: string, signal?: AbortSignal) => Promise<SecurityStore>;
+export declare function isSecurityEnabled(): boolean;
+export declare class SecurityDisabledError extends Error {
+    constructor();
+}
+export declare class SecurityProtocolHandler implements ProtocolHandler {
+    #private;
+    readonly scheme = "security";
+    readonly immutable = true;
+    constructor(resolveStore?: SecurityStoreResolver, enabled?: () => boolean);
+    resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource>;
+    complete(query?: string, context?: ResolveContext): Promise<UrlCompletion[]>;
+}

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

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

package/dist/types/launch/terminal-output-worker-client.d.ts

@@ -0,0 +1,5 @@
+import type { TerminalOutputOptions } from "./terminal-output.js";
+/** Replay legacy broker PTY bytes without evaluating xterm in the client process. */
+export declare function renderTerminalOutputIsolated(output: string, options: TerminalOutputOptions): Promise<string[] | undefined>;
+/** Distribution smoke for source, npm-bundle, and compiled worker routing. */
+export declare function smokeTestTerminalOutputWorker(): Promise<void>;

package/dist/types/launch/terminal-output-worker-protocol.d.ts

@@ -0,0 +1,14 @@
+import type { TerminalOutputOptions } from "./terminal-output.js";
+/** Hidden CLI selector for legacy PTY replay outside the client process. */
+export declare const TERMINAL_OUTPUT_WORKER_ARG = "__omp_worker_terminal_output";
+export interface TerminalOutputWorkerRequest {
+    output: string;
+    options: TerminalOutputOptions;
+}
+export type TerminalOutputWorkerResult = {
+    ok: true;
+    rows: string[] | undefined;
+} | {
+    ok: false;
+    error: string;
+};

package/dist/types/launch/terminal-output-worker.d.ts

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

package/dist/types/lsp/client.d.ts

@@ -19,6 +19,8 @@ export interface WatchedFileChange {
 export declare function supportsDocumentDiagnostics(client: LspClient): boolean;
 /** Timeout for warmup initialize requests (5 seconds) */
 export declare const WARMUP_TIMEOUT_MS = 5000;
+/** Allow an explicit user reload to retry a matching initialization failure immediately. */
+export declare function clearInitializationFailure(config: ServerConfig, cwd: string): void;
 /**
  * Get or create an LSP client for the given server configuration and working directory.
  * @param config - Server configuration

package/dist/types/main.d.ts

@@ -8,6 +8,7 @@ import type { SubmittedUserInput } from "./modes/types.js";
 import { type CreateAgentSessionOptions, type CreateAgentSessionResult, createAgentSession, discoverAuthStorage } from "./sdk.js";
 import type { AgentSession } from "./session/agent-session.js";
 import type { AuthStorage } from "./session/auth-storage.js";
+import type { ForeignSessionSource, ForeignSessionStore } from "./session/foreign-session-store.js";
 import { type SessionInfo } from "./session/session-listing.js";
 import { SessionManager } from "./session/session-manager.js";
 type RunAcpMode = (createSession: AcpSessionFactory) => Promise<never>;
@@ -65,6 +66,7 @@ interface RunRootCommandDependencies {
     discoverAuthStorage?: typeof discoverAuthStorage;
     selectSession?: typeof selectSession;
     runAcpMode?: RunAcpMode;
+    createForeignSessionStore?: (source: ForeignSessionSource) => ForeignSessionStore;
     settings?: Settings;
     forceSetupWizard?: boolean;
 }

package/dist/types/mcp/manager.d.ts

@@ -61,13 +61,42 @@ export declare class MCPManager {
     static resetForTests(): void;
     constructor(cwd: string, toolCache?: MCPToolCache | null);
     /**
-     * Set a callback to receive all server notifications.
+     * Register a listener for server-initiated MCP notifications.
+     *
+     * The listener is called for every JSON-RPC notification received from any
+     * connected server, AFTER the manager's own handling of known methods
+     * (`notifications/tools/list_changed`, `notifications/resources/list_changed`,
+     * `notifications/resources/updated`, `notifications/prompts/list_changed`).
+     * For list-change methods the internal refresh promise is awaited before
+     * fanout, so listeners observe up-to-date manager and tool state. Unknown
+     * or server-custom methods are also delivered, letting consumers bridge
+     * server-initiated events into session-level behavior (e.g. an extension
+     * injecting a steer via `pi.sendMessage`).
+     *
+     * Notifications received before any listener attached are buffered
+     * (bounded FIFO, cap {@link NOTIFICATION_BUFFER_CAP}, drop-oldest) and
+     * drained into the first subscriber — matches {@link setOnPromptsChanged}'s
+     * replay-on-attach and {@link IrcBus}'s mailbox semantics.
+     *
+     * Returns an unsubscribe function; call it to remove the listener.
+     *
+     * Multiple listeners are allowed; each is invoked with independent error
+     * isolation — a listener that throws does not prevent other listeners from
+     * firing.
      */
-    setOnNotification(handler: (serverName: string, method: string, params: unknown) => void): void;
+    addNotificationListener(listener: (serverName: string, method: string, params: unknown) => void): () => void;
     /**
      * Set a callback to fire when any server's tools change.
-     */
-    setOnToolsChanged(handler: (tools: CustomTool<TSchema, MCPToolDetails>[]) => void): void;
+     *
+     * May return a Promise; if so, {@link refreshServerTools} awaits it so that
+     * downstream consumers (e.g. `mcp_notification` listeners for
+     * `notifications/tools/list_changed`) observe not just the manager's
+     * refreshed tool set but also any session-level rebind driven by the
+     * handler (`session.refreshMCPTools`). Other callsites (initial connect,
+     * disconnect, reconnect) invoke the handler synchronously — their downstream
+     * chains don't need to serialize on the rebind.
+     */
+    setOnToolsChanged(handler: (tools: CustomTool<TSchema, MCPToolDetails>[]) => void | Promise<void>): void;
     /**
      * Set a callback to fire when any server's resources change.
      */

package/dist/types/modes/components/codex-reset-fireworks.d.ts

@@ -0,0 +1,51 @@
+import { type Component, type OverlayHandle, type OverlayOptions } from "@oh-my-pi/pi-tui";
+/** The active Codex account fields retained between status refreshes. */
+export interface CodexResetUsageSnapshot {
+    /** When this usage report was observed, if supplied by the provider. */
+    observedAt?: number;
+    /** Weekly usage, its quota identity, and its previously scheduled reset deadline. */
+    sevenDay?: {
+        percent: number;
+        resetsAt?: number;
+        tier?: string;
+        plan?: string;
+    };
+    savedResets?: number;
+}
+/** A detected Codex quota event that can trigger the fireworks presentation. */
+export type CodexResetFireworksEvent = {
+    kind: "unscheduled-weekly-reset";
+} | {
+    kind: "saved-reset-banked";
+    added: number;
+    available: number;
+};
+interface CodexResetFireworksHost {
+    ui: {
+        showOverlay(component: Component, options?: OverlayOptions): OverlayHandle;
+        setFocus(component: Component): void;
+        requestRender(): void;
+        readonly terminal: {
+            readonly rows: number;
+        };
+    };
+}
+/**
+ * Compare consecutive reports for one Codex account. A saved-reset grant takes
+ * precedence when both changes arrive in the same report. A verified decrease,
+ * or a prior positive balance becoming unavailable, suppresses the weekly event
+ * because the user may have redeemed a credit. Other weekly usage drops are
+ * celebrated only before the previously scheduled reset deadline.
+ */
+export declare function detectCodexResetFireworks(previous: CodexResetUsageSnapshot, current: CodexResetUsageSnapshot): CodexResetFireworksEvent | undefined;
+/** Owns the at-most-one modal celebration lifecycle for an interactive session. */
+export declare class CodexResetFireworksController {
+    #private;
+    private readonly host;
+    constructor(host: CodexResetFireworksHost);
+    /** Present a celebration unless another one already owns the modal overlay. */
+    show(event: CodexResetFireworksEvent): boolean;
+    /** Stop the active celebration and release its overlay, if present. */
+    dispose(): void;
+}
+export {};

package/dist/types/modes/components/read-tool-group.d.ts

@@ -1,3 +1,4 @@
+import type { AssistantMessage, Usage } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Container } from "@oh-my-pi/pi-tui";
 import type { ToolExecutionHandle } from "./tool-execution.js";
@@ -10,6 +11,12 @@ export declare function readArgsHaveTarget(args: unknown): boolean;
  * they list devices/docs and read better in the compact grouped view.
  */
 export declare function readArgsCollapseIntoGroup(args: unknown): boolean;
+/**
+ * Return the collapsed read calls that can own a turn's usage row. Mixed-tool
+ * turns and visible content after a read keep the standalone row so request
+ * metrics retain their transcript ordering.
+ */
+export declare function groupedReadUsageCallIds(message: AssistantMessage): string[] | undefined;
 type ReadRenderArgs = {
     path?: string;
     file_path?: string;
@@ -37,6 +44,11 @@ export declare class ReadToolGroupComponent extends Container implements ToolExe
         details?: unknown;
         isError?: boolean;
     }, isPartial?: boolean, toolCallId?: string): void;
+    /**
+     * Nest one request's usage beneath the last visible read call from that
+     * request. Parallel reads share one row rather than duplicating request totals.
+     */
+    attachUsage(toolCallIds: readonly string[], usage: Usage, durationMs?: number, ttftMs?: number, timestamp?: number): boolean;
     setArgsComplete(_toolCallId?: string): void;
     setExpanded(expanded: boolean): void;
     getComponent(): Component;

package/dist/types/modes/components/session-selector.d.ts

@@ -63,6 +63,12 @@ export interface SessionSelectorOptions {
     loadAllSessions?: () => Promise<SessionInfo[]>;
     /** Preloaded all-projects list; cached so the first Tab toggle is instant. */
     allSessions?: SessionInfo[];
+    /** Picker heading; defaults to "Resume Session". */
+    title?: string;
+    /** Fixed scope label, or false to omit the scope suffix. */
+    scopeLabel?: string | false;
+    /** Show each session's working directory in the list. */
+    showCwd?: boolean;
     /**
      * Reads the live terminal height so the visible window fits the viewport.
      * Omitted only in tests; defaults to a conservative 24 rows.

package/dist/types/modes/components/status-line/component.d.ts

@@ -1,5 +1,6 @@
 import { type Component } from "@oh-my-pi/pi-tui";
 import type { AgentSession } from "../../../session/agent-session.js";
+import { type CodexResetFireworksEvent } from "../codex-reset-fireworks.js";
 import { type SegmentContext } from "./segments.js";
 import type { CollabStatus, EffectiveStatusLineSettings, StatusLineSettings } from "./types.js";
 export declare class StatusLineComponent implements Component {
@@ -73,10 +74,32 @@ export declare class StatusLineComponent implements Component {
      */
     setVibeWorkerTokenRateProvider(provider: (() => number | null) | undefined): void;
     setCollabStatus(status: CollabStatus | null): void;
+    /** Set the callback that presents detected Codex reset celebrations, or clear it with `undefined`. */
+    setCodexResetFireworksHandler(handler: ((event: CodexResetFireworksEvent) => void) | undefined): void;
     setHookStatus(key: string, text: string | undefined): void;
     watchBranch(onBranchChange: () => void): void;
     dispose(): void;
     invalidate(): void;
+    /**
+     * Explicit Git/repository cache invalidation. Aborts any in-flight
+     * reftable HEAD/PR resolve, bumps the stale-result generation, and drops
+     * the branch/PR/jj caches so the next render refetches from disk. Called
+     * by the git watcher on a HEAD move and by {@link applyCwdChange} on a
+     * repo/cwd switch. Generic repaints use {@link invalidate} instead and
+     * must never reach this path.
+     */
+    invalidateGitCaches(): void;
+    /**
+     * Re-point the status line's VCS watcher and caches at a new cwd/repository.
+     * Atomically retires the old watcher/listeners, invalidates VCS caches and
+     * in-flight controllers, then runs watcher setup for the new cwd and requests
+     * a repaint. Called by {@link InteractiveMode.applyCwdChange} after the
+     * SessionManager's cwd has moved — the watcher ownership always follows the
+     * effective cwd/repo, so a stale watcher for the previous repo can never
+     * invalidate the new one. Generic repaints use {@link invalidate} and must
+     * never retire the watcher or abort a live resolve.
+     */
+    applyCwdChange(): void;
     /**
      * Startup redraws only arm a short-delayed task; timeout releases the render
      * cadence while a late successful fetch can still refresh the cached segment.

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

@@ -1,4 +1,4 @@
-import type { SnapshotStore } from "@oh-my-pi/hashline";
+import type { Clipboard, SnapshotStore } from "@oh-my-pi/hashline";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import { type Component, Container, type NativeScrollbackLiveRegion, type TUI } from "@oh-my-pi/pi-tui";
 /**
@@ -8,6 +8,13 @@ import { type Component, Container, type NativeScrollbackLiveRegion, type TUI }
  */
 export interface TranscriptLiveRegionProbe {
     isBlockInLiveRegion(component: Component): boolean;
+    /**
+     * Whether none of the block's rows have entered native scrollback (see
+     * `TranscriptContainer.isBlockUncommitted`). Optional: standalone hosts
+     * without commit tracking omit it, and blocks treat their rows as
+     * uncommitted.
+     */
+    isBlockUncommitted?(component: Component): boolean;
 }
 /** Minimal TUI surface ToolExecutionComponent uses to schedule repaints and share image budget. */
 export interface ToolExecutionUi {
@@ -18,6 +25,8 @@ export interface ToolExecutionUi {
 }
 export interface ToolExecutionOptions {
     snapshots?: SnapshotStore;
+    /** Session-persistent edit clipboard register, forked per preview frame. */
+    clipboard?: Clipboard;
     showImages?: boolean;
     editFuzzyThreshold?: number;
     editAllowFuzzy?: boolean;
@@ -94,12 +103,12 @@ export declare class ToolExecutionComponent extends Container implements NativeS
     getNativeScrollbackLiveRegionStart(): number | undefined;
     /**
      * Keeps in-flight TV-wall frames out of immutable native scrollback: the
-     * `vibe_wait` wall and displaceable snapshots (`hub` waiting polls, `todo`
-     * lists). Their frames replace each other rather than append, and their
-     * rows mutate every spinner tick — an unpinned commit records a per-tick
-     * frozen snapshot AND force-seals the block (see TranscriptContainer's
-     * committed-snapshot seal), so the next poll stacks a new frame instead of
-     * displacing this one.
+     * `vibe_wait` wall, displaceable snapshots (`hub` waiting polls, `todo`
+     * lists), and live `task` calls. Their frames replace each other rather
+     * than append — task progress rows rewrite in place on every snapshot —
+     * so an unpinned commit records a per-tick frozen snapshot (and for
+     * displaceable blocks force-seals them, stacking the next poll below).
+     * The finalized frame commits exactly once when the pin lifts.
      */
     isNativeScrollbackLiveRegionPinned(): boolean;
     /**

package/dist/types/modes/components/usage-row.d.ts

@@ -1,3 +1,5 @@
 import type { Usage } from "@oh-my-pi/pi-ai";
 import { Container } from "@oh-my-pi/pi-tui";
+/** Format the metrics shared by standalone usage blocks and compact tool groups. */
+export declare function formatUsageRow(usage: Usage, durationMs?: number, ttftMs?: number, timestamp?: number): string;
 export declare function createUsageRowBlock(usage: Usage, durationMs?: number, ttftMs?: number, timestamp?: number): Container;

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

@@ -1,5 +1,5 @@
 import { type Component } from "@oh-my-pi/pi-tui";
-import type { MCPAuthChallenge, MCPServerConfig } from "../../mcp/types.js";
+import type { MCPAuthChallenge, MCPConfigFile, MCPServerConfig } from "../../mcp/types.js";
 import type { InteractiveModeContext } from "../types.js";
 /**
  * Renders the MCP OAuth fallback URL. Always shows the full authorization URL
@@ -34,6 +34,31 @@ export declare class MCPAuthorizationLinkPrompt implements Component {
 export declare class MCPOAuthCancelledError extends Error {
     constructor(message?: string);
 }
+/**
+ * Collect the de-duplicated union of every MCP server name we know about:
+ * user config, project config, and any runtime-discovered servers not
+ * already present in either config (`ctx.mcpManager.getAllServerNames()`
+ * covers connections, pending connections, and discovered-but-not-yet-
+ * connected sources).
+ *
+ * `includeDisabledOnly` controls names found only in
+ * `userConfig.disabledServers`, while `includeDisabledConfigured` controls
+ * config entries whose `enabled` flag is false. Both default to true because
+ * callers such as `/mcp list` need the complete union. Autocomplete callers
+ * must disable the categories their target operation cannot accept.
+ *
+ * This is the single source of truth for "every known server name": both
+ * `MCPCommandController#handleList()` and the `/mcp` slash-command argument
+ * completer (server-name autocomplete for `enable`/`disable`/`test`/etc.)
+ * call this instead of re-deriving the union themselves.
+ *
+ * `preloaded` lets a caller that already read both config files (e.g.
+ * `#handleList()`) pass them in and skip the redundant re-read.
+ */
+export declare function collectMcpServerNames(ctx: InteractiveModeContext, preloaded?: {
+    userConfig: MCPConfigFile;
+    projectConfig: MCPConfigFile;
+}, includeDisabledOnly?: boolean, includeDisabledConfigured?: boolean): Promise<string[]>;
 export declare class MCPCommandController {
     #private;
     private ctx;

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

@@ -1,5 +1,6 @@
 import type { Component } from "@oh-my-pi/pi-tui";
 import type { InteractiveModeContext } from "../../modes/types.js";
+import type { ForeignSessionSource } from "../../session/foreign-session-store.js";
 import type { SessionObserverRegistry } from "../session-observer-registry.js";
 export declare class SelectorController {
     #private;
@@ -49,7 +50,7 @@ export declare class SelectorController {
     showUserMessageSelector(): void;
     showCopySelector(): void;
     showTreeSelector(): void;
-    showSessionSelector(): Promise<void>;
+    showSessionSelector(source?: ForeignSessionSource): Promise<void>;
     handleResumeSession(sessionPath: string, options?: {
         settingsFlushed?: boolean;
     }): Promise<boolean>;