@oh-my-pi/pi-coding-agent 15.9.5 → 15.10.0

package/dist/types/eval/idle-timeout.d.ts

@@ -1,27 +1,29 @@
 /**
- * Inactivity watchdog for eval cells.
+ * Watchdog for eval cell work.
  *
- * A cell's `timeout` is treated as an *idle* budget rather than a hard
- * wall-clock deadline: the watchdog aborts {@link signal} (with a
- * `TimeoutError` reason, matching `AbortSignal.timeout`) only once `idleMs`
- * elapses with no {@link bump}. Every progress signal re-arms it, so a
- * long-running fanout that keeps reporting progress (e.g. `agent()` status
- * updates, `log()`/`phase()`) never trips the timeout, while a genuinely
- * stalled cell still gets interrupted.
+ * A cell's `timeout` bounds time while the Python kernel or JS VM is in control.
+ * Host-side bridge calls can {@link pause} the watchdog so delegated
+ * `agent()`/`parallel()`/`llm()` work is ignored completely, then {@link resume}
+ * starts a fresh timeout window once the runtime gets control back.
  *
- * The timer self-reschedules instead of being torn down and recreated on every
- * bump, so a high-frequency stream of bumps (sub-second agent progress) costs
- * one timestamp write per event rather than churning a timer each time.
+ * The active timer self-reschedules instead of being torn down on every
+ * activity event, so frequent activity costs one timestamp write per event.
+ * Pause is reference-counted because `parallel()` can have multiple bridge calls
+ * in flight at once.
  */
 export declare class IdleTimeout {
     #private;
     constructor(idleMs: number);
-    /** Aborts with a `TimeoutError` reason once the inactivity budget is exhausted. */
+    /** Aborts with a `TimeoutError` reason once the active timeout window is exhausted. */
     get signal(): AbortSignal;
-    /** Configured inactivity budget in milliseconds. */
+    /** Configured active timeout window in milliseconds. */
     get idleMs(): number;
-    /** Record activity, pushing the inactivity deadline forward by `idleMs`. */
+    /** Record runtime activity, pushing the active deadline forward by `idleMs`. */
     bump(): void;
+    /** Suspend timeout accounting while control is delegated to host-side work. */
+    pause(): void;
+    /** Resume timeout accounting with a fresh timeout window. */
+    resume(): void;
     /** Stop the watchdog. Safe to call multiple times. */
     dispose(): void;
     [Symbol.dispose](): void;

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

@@ -6,9 +6,9 @@ export interface JsExecutorOptions {
     timeoutMs?: number;
     deadlineMs?: number;
     /**
-     * Inactivity budget (ms). Used for worker cold-start headroom and
-     * timeout-annotation text when the caller drives cancellation via an
-     * idle-aware `signal` instead of `deadlineMs`/`timeoutMs`. Never arms a timer.
+     * Runtime-work budget (ms). Used for worker cold-start headroom and
+     * timeout-annotation text when the caller drives cancellation via the eval
+     * watchdog `signal` instead of `deadlineMs`/`timeoutMs`. Never arms a timer.
      */
     idleTimeoutMs?: number;
     onChunk?: (chunk: string) => Promise<void> | void;

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

@@ -10,8 +10,8 @@ export interface PythonExecutorOptions {
     /** Absolute wall-clock deadline in milliseconds since epoch */
     deadlineMs?: number;
     /**
-     * Inactivity budget (ms). Used only for timeout-annotation text when the
-     * caller drives cancellation via an idle-aware `signal` instead of a
+     * Runtime-work budget (ms). Used only for timeout-annotation text when the
+     * caller drives cancellation via the eval watchdog `signal` instead of a
      * wall-clock `deadlineMs`/`timeoutMs`. Does not arm a timer.
      */
     idleTimeoutMs?: number;

package/dist/types/eval/py/spawn-options.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Decide whether the long-lived Python kernel subprocess should be spawned
+ * with `windowsHide: true`.
+ *
+ * On Windows, Bun maps `windowsHide: true` to the `CREATE_NO_WINDOW` flag,
+ * which detaches the child from any inherited console. The Python kernel
+ * runs user code that imports NumPy/pandas; those native extensions
+ * (`numpy/_core/_multiarray_umath.pyd` + bundled OpenBLAS/SLEEF thread-pool
+ * init) can deadlock inside `LoadLibraryExW` when no console is attached,
+ * and a console-less child cannot receive SIGINT via
+ * `GenerateConsoleCtrlEvent` (the recovery path the host relies on). See
+ * issue #1960.
+ *
+ * So on Windows we hide only when the host itself has no console to share.
+ * In any launch where a console is attached — even one with every stdio
+ * stream redirected — the kernel inherits the parent's console, matching
+ * `python.exe` invoked from `cmd.exe`, which keeps native imports and
+ * SIGINT recovery working.
+ *
+ * Short-lived helper subprocesses elsewhere in the codebase (LSP probes,
+ * git, plugin installs) keep `windowsHide: true` because they don't load
+ * complex native modules and the brief console flash would be user-visible
+ * noise.
+ */
+export declare function shouldHideKernelWindow(opts: {
+    platform: NodeJS.Platform;
+    hostHasInheritableConsole: boolean;
+}): boolean;
+/**
+ * TTY-based fallback used when the Win32 console probe is unavailable.
+ *
+ * Returns `true` if any of stdin/stdout/stderr is currently a TTY. This
+ * correctly detects the common interactive launches and the partial-
+ * redirection cases (`omp -p > out.txt`, `< in.txt`, `2> err.log`) where at
+ * least one stream stays bound to the terminal. The all-stdio-redirected
+ * case (`< in > out 2> err` from a console) is the reason we prefer the
+ * Win32 probe over this fallback whenever possible.
+ */
+export declare function consoleAttachedViaTTY(opts: {
+    stdinIsTTY: boolean;
+    stdoutIsTTY: boolean;
+    stderrIsTTY: boolean;
+}): boolean;
+/** Reset the cached Win32 probe result. Test-only; not part of the public surface. */
+export declare function __resetWindowsConsoleProbeCache(): void;
+/**
+ * Whether the host process owns a console its children can inherit.
+ *
+ * - On Windows, the authoritative signal is `GetConsoleWindow()`. It returns
+ *   a non-NULL HWND whenever the process has a console attached, regardless
+ *   of how the standard streams are redirected — so an `omp -p ... < in.txt
+ *   > out.txt 2> err.log` launched from a real Windows Terminal session is
+ *   correctly classified as console-attached and the kernel keeps its
+ *   inheritable console.
+ * - On any other platform, or if the FFI probe fails, fall back to the
+ *   TTY-OR heuristic. That still catches the common interactive cases.
+ */
+export declare function hostHasInheritableConsole(): boolean;

package/dist/types/extensibility/plugins/marketplace-auto-update.d.ts

@@ -0,0 +1,8 @@
+type MarketplaceAutoUpdateMode = "off" | "notify" | "auto";
+interface MarketplaceAutoUpdateOptions {
+    autoUpdate: MarketplaceAutoUpdateMode;
+    resolveActiveProjectRegistryPath: (cwd: string) => Promise<string | null>;
+    clearPluginRootsCache: () => void;
+}
+export declare function scheduleMarketplaceAutoUpdate(options: MarketplaceAutoUpdateOptions): void;
+export {};

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

@@ -222,6 +222,16 @@ export interface ServerConfig {
     disabled?: boolean;
     /** Per-server warmup timeout in milliseconds. Overrides the global WARMUP_TIMEOUT_MS for this server during startup. */
     warmupTimeoutMs?: number;
+    /**
+     * Per-server overrides for rust-analyzer workspace-ready polling. When omitted, the module
+     * defaults are used. Primarily a tuning/test seam to bound the multi-second settle window.
+     */
+    workspaceReadyTimings?: {
+        timeoutMs?: number;
+        pollMs?: number;
+        settleMs?: number;
+        statusRequestTimeoutMs?: number;
+    };
     capabilities?: ServerCapabilities;
     /** If true, this is a linter/formatter server (e.g., Biome) - used only for diagnostics/actions, not type intelligence */
     isLinter?: boolean;

package/dist/types/main.d.ts

@@ -7,12 +7,13 @@
 import type { Args } from "./cli/args";
 import { ModelRegistry } from "./config/model-registry";
 import { Settings } from "./config/settings";
-import { InteractiveMode, runAcpMode } from "./modes";
+import { InteractiveMode } from "./modes/interactive-mode";
 import type { SubmittedUserInput } from "./modes/types";
 import { type CreateAgentSessionOptions, type CreateAgentSessionResult, createAgentSession, discoverAuthStorage } from "./sdk";
 import type { AgentSession } from "./session/agent-session";
 import type { AuthStorage } from "./session/auth-storage";
 import { type SessionInfo, SessionManager } from "./session/session-manager";
+type RunAcpMode = (createSession: AcpSessionFactory) => Promise<never>;
 export interface InteractiveModeNotify {
     kind: "warn" | "error" | "info";
     message: string;
@@ -47,7 +48,7 @@ export declare function createSessionManager(parsed: Args, cwd: string, activeSe
 interface RunRootCommandDependencies {
     createAgentSession?: typeof createAgentSession;
     discoverAuthStorage?: typeof discoverAuthStorage;
-    runAcpMode?: typeof runAcpMode;
+    runAcpMode?: RunAcpMode;
     settings?: Settings;
     forceSetupWizard?: boolean;
 }

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

@@ -1,4 +1,5 @@
-export * from "../mnemopi";
+export type { MnemopiBackendConfig, MnemopiLlmMode, MnemopiProviderOptions, MnemopiScoping, } from "../mnemopi/config";
+export type { MnemopiMemoryEditOperation, MnemopiMemoryEditOptions, MnemopiMemoryEditResult, MnemopiSessionState, MnemopiSessionStateOptions, } from "../mnemopi/state";
 export * from "./local-backend";
 export * from "./off-backend";
 export * from "./resolve";

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

@@ -13,4 +13,4 @@ import type { MemoryBackend } from "./types";
  * `memories.enabled` remains accepted only as a legacy migration input. Once
  * a config is loaded, `memory.backend` is the sole runtime selector.
  */
-export declare function resolveMemoryBackend(settings: Settings): MemoryBackend;
+export declare function resolveMemoryBackend(settings: Settings): Promise<MemoryBackend>;

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

@@ -1,7 +1,7 @@
 /**
  * Memory backend abstraction.
  *
- * Backends are mutually exclusive — `resolveMemoryBackend(settings)` returns
+ * Backends are mutually exclusive — `await resolveMemoryBackend(settings)` resolves
  * exactly one. Implementations MUST be self-contained: they own the per-session
  * state they create in `start()` and tear it down on `clear()`.
  */

package/dist/types/modes/components/assistant-message.d.ts

@@ -13,6 +13,11 @@ export declare class AssistantMessageComponent extends Container {
     constructor(message?: AssistantMessage, hideThinkingBlock?: boolean, onImageUpdate?: (() => void) | undefined, thinkingRenderers?: readonly AssistantThinkingRenderer[], imageBudget?: ImageBudget | undefined);
     invalidate(): void;
     setHideThinkingBlock(hide: boolean): void;
+    /**
+     * Toggle suppression of the inline `Error: …` line while the same error is
+     * pinned in the banner above the editor. Re-renders so the change is visible.
+     */
+    setErrorPinned(pinned: boolean): void;
     isTranscriptBlockFinalized(): boolean;
     /**
      * Assistant text/thinking streams in append-only: earlier rendered rows never

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

@@ -0,0 +1,22 @@
+import { type Component } from "@oh-my-pi/pi-tui";
+import type { CopyTarget } from "../utils/copy-targets";
+export interface CopySelectorCallbacks {
+    /** A copy target was chosen — copy its `content`. */
+    onPick: (target: CopyTarget) => void;
+    /** The picker was dismissed. */
+    onCancel: () => void;
+}
+/**
+ * Fullscreen `/copy` picker rendered as a `/tree`-style tree inside one
+ * outlined box: a title, the tree of copy targets (recent assistant messages
+ * with their code blocks nested beneath), a live preview of the highlighted
+ * node, and a keybinding footer. Every node copies its `content` on Enter.
+ */
+export declare class CopySelectorComponent implements Component {
+    #private;
+    private readonly callbacks;
+    constructor(roots: CopyTarget[], callbacks: CopySelectorCallbacks);
+    invalidate(): void;
+    handleInput(keyData: string): void;
+    render(width: number): string[];
+}

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

@@ -1,6 +1,6 @@
 import { Editor, type KeyId } from "@oh-my-pi/pi-tui";
 import type { AppKeybinding } from "../../config/keybindings";
-type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.clipboard.pasteImage" | "app.clipboard.pasteTextRaw" | "app.clipboard.copyPrompt">;
+type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.display.reset" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.clipboard.pasteImage" | "app.clipboard.pasteTextRaw" | "app.clipboard.copyPrompt">;
 /**
  * Custom editor that handles configurable app-level shortcuts for coding-agent.
  */
@@ -14,6 +14,7 @@ export declare class CustomEditor extends Editor {
     onEscape?: () => void;
     onClear?: () => void;
     onExit?: () => void;
+    onDisplayReset?: () => void;
     onCycleThinkingLevel?: () => void;
     onCycleModelForward?: () => void;
     onCycleModelBackward?: () => void;

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

@@ -20,6 +20,7 @@ export declare class ModelSelectorComponent extends Container {
     constructor(tui: TUI, _currentModel: Model | undefined, settings: Settings, modelRegistry: ModelRegistry, scopedModels: ReadonlyArray<ScopedModelItem>, onSelect: RoleSelectCallback, onCancel: () => void, options?: {
         temporaryOnly?: boolean;
         initialSearchInput?: string;
+        currentContextTokens?: number;
     });
     handleInput(keyData: string): void;
     getSearchInput(): Input;

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

@@ -61,6 +61,24 @@ export declare class ToolExecutionComponent extends Container {
      * past, or an explicit {@link seal} flips it to `true`.
      */
     isTranscriptBlockFinalized(): boolean;
+    /**
+     * While a tool's preview is still streaming, a block whose preview is
+     * append-only (rows only grow at the bottom, never re-layout) lets the
+     * renderer commit the scrolled-off head of an over-tall preview to native
+     * scrollback instead of dropping it — the same anti-yank path a streaming
+     * assistant reply uses (see {@link TranscriptContainer} +
+     * `NativeScrollbackLiveRegion`). Covers both phases: a pre-result call preview
+     * (a `write` whose content streams in) and a partial-result preview that
+     * streams output below fixed input (an `eval`/`bash` whose stdout grows under
+     * its code cell). Gated on {@link isTranscriptBlockFinalized} so the boundary
+     * closes the instant the block reaches a terminal state — a final result that
+     * may collapse to a compact view, a backgrounded async tool, or a seal — and
+     * the renderer decides whether its current preview shape qualifies via
+     * `isStreamingPreviewAppendOnly` (typically: only the expanded full view,
+     * which is top-anchored; the collapsed tail window re-layouts but is bounded
+     * so it never overflows anyway).
+     */
+    isTranscriptBlockAppendOnly(): boolean;
     /**
      * Mark the tool terminal even though no result arrived (the turn aborted or
      * abandoned it) and stop animating, so it can freeze and stops pinning the

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

@@ -13,7 +13,6 @@ export declare class CommandController {
     handleDumpCommand(): void;
     handleDebugTranscriptCommand(): Promise<void>;
     handleShareCommand(): Promise<void>;
-    handleCopyCommand(sub?: string): void;
     handleSessionCommand(): Promise<void>;
     handleJobsCommand(): Promise<void>;
     handleUsageCommand(reports?: UsageReport[] | null): Promise<void>;

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

@@ -35,11 +35,12 @@ export declare class SelectorController {
     }): void;
     showPluginSelector(mode?: "install" | "uninstall"): Promise<void>;
     showUserMessageSelector(): void;
+    showCopySelector(): void;
     showTreeSelector(): void;
     showSessionSelector(): Promise<void>;
     handleResumeSession(sessionPath: string): Promise<void>;
     handleSessionDeleteCommand(): Promise<void>;
     showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
-    showDebugSelector(): void;
+    showDebugSelector(): Promise<void>;
     showSessionObserver(registry: SessionObserverRegistry): void;
 }

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

@@ -1,9 +1,10 @@
 /**
- * Run modes for the coding agent.
+ * Interactive mode and embeddable RPC client exports for the coding agent.
+ *
+ * Branch-specific runners live in their concrete modules so importing this
+ * barrel does not pull print, RPC server, or ACP server mode into the normal
+ * TUI graph.
  */
-export { runAcpMode } from "./acp";
 export { InteractiveMode, type InteractiveModeOptions } from "./interactive-mode";
-export { type PrintModeOptions, runPrintMode } from "./print-mode";
 export { defineRpcClientTool, type ModelInfo, RpcClient, type RpcClientCustomTool, type RpcClientOptions, type RpcClientToolContext, type RpcClientToolResult, type RpcEventListener, } from "./rpc/rpc-client";
-export { runRpcMode } from "./rpc/rpc-mode";
 export type { RpcCommand, RpcHostToolCallRequest, RpcHostToolCancelRequest, RpcHostToolDefinition, RpcHostToolResult, RpcHostToolUpdate, RpcResponse, RpcSessionState, } from "./rpc/rpc-types";

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

@@ -199,7 +199,6 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleDumpCommand(): void;
     handleDebugTranscriptCommand(): Promise<void>;
     handleShareCommand(): Promise<void>;
-    handleCopyCommand(sub?: string): void;
     handleTodoCommand(args: string): Promise<void>;
     handleSessionCommand(): Promise<void>;
     handleJobsCommand(): Promise<void>;
@@ -215,7 +214,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleRenameCommand(title: string): Promise<void>;
     handleMemoryCommand(text: string): Promise<void>;
     handleSTTToggle(): Promise<void>;
-    showDebugSelector(): void;
+    showDebugSelector(): Promise<void>;
     showSessionObserver(): void;
     resetObserverRegistry(): void;
     handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
@@ -236,6 +235,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     }): void;
     showPluginSelector(mode?: "install" | "uninstall"): void;
     showUserMessageSelector(): void;
+    showCopySelector(): void;
     showTreeSelector(): void;
     showSessionSelector(): void;
     handleResumeSession(sessionPath: string): Promise<void>;

package/dist/types/modes/setup-version.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Setup version the wizard advances a fresh install to. Bump it whenever a new
+ * setup scene lands (or an existing scene raises its `minVersion`).
+ *
+ * Kept in its own dependency-free module so the cold-launch gate in `main.ts`
+ * can answer "is the stored setup version stale?" without statically importing
+ * the full wizard — every scene (sign-in/OAuth, web search, theme previews) plus
+ * the overlay component and their TUI deps. MUST equal `max(scene.minVersion)`
+ * across `ALL_SCENES`; the `setup-wizard` barrel and test suite guard it.
+ */
+export declare const CURRENT_SETUP_VERSION = 1;

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

@@ -1,9 +1,10 @@
 import type { Settings } from "../../config/settings";
+import { CURRENT_SETUP_VERSION } from "../setup-version";
 import type { InteractiveModeContext } from "../types";
 import type { SetupScene } from "./scenes/types";
 export type { SetupScene, SetupSceneController, SetupSceneHost, SetupSceneResult } from "./scenes/types";
+export { CURRENT_SETUP_VERSION };
 export declare const ALL_SCENES: readonly [SetupScene, SetupScene, SetupScene];
-export declare const CURRENT_SETUP_VERSION: number;
 export interface SetupSceneSelectionOptions {
     resuming?: boolean;
     isTTY?: boolean;

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

@@ -2,7 +2,8 @@ import type { SetupSceneHost, SetupTab } from "./types";
 /**
  * "Web search" panel: picks the provider the web_search tool should prefer and
  * reports whether the highlighted provider is ready to use given current
- * credentials (env keys or OAuth sign-ins from the Sign in tab).
+ * credentials (env keys or OAuth sign-ins from the Sign in tab) or an
+ * unauthenticated fallback.
  */
 export declare class WebSearchTab implements SetupTab {
     #private;

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

@@ -197,7 +197,6 @@ export interface InteractiveModeContext {
     toggleTodoExpansion(): void;
     handleExportCommand(text: string): Promise<void>;
     handleShareCommand(): Promise<void>;
-    handleCopyCommand(sub?: string): void;
     handleTodoCommand(args: string): Promise<void>;
     handleSessionCommand(): Promise<void>;
     handleJobsCommand(): Promise<void>;
@@ -235,13 +234,14 @@ export interface InteractiveModeContext {
     }): void;
     showPluginSelector(mode?: "install" | "uninstall"): void;
     showUserMessageSelector(): void;
+    showCopySelector(): void;
     showTreeSelector(): void;
     showSessionSelector(): void;
     handleResumeSession(sessionPath: string): Promise<void>;
     handleSessionDeleteCommand(): Promise<void>;
     showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
     showHookConfirm(title: string, message: string): Promise<boolean>;
-    showDebugSelector(): void;
+    showDebugSelector(): Promise<void>;
     showSessionObserver(): void;
     resetObserverRegistry(): void;
     handleCtrlC(): void;

package/dist/types/modes/utils/copy-targets.d.ts

@@ -0,0 +1,53 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+/** A fenced code block extracted from assistant markdown. */
+export interface CodeBlock {
+    /** Info string after the opening fence (language id), trimmed. */
+    lang: string;
+    /** Block body with the trailing newline stripped. */
+    code: string;
+}
+/** A runnable command found in the transcript. */
+export interface LastCommand {
+    kind: "bash" | "eval";
+    code: string;
+    /** Highlight language: "bash" for bash, "python"/"javascript" for eval. */
+    language: string;
+}
+/**
+ * A node in the `/copy` picker tree. Leaves carry `content` (placed on the
+ * clipboard) plus `copyMessage` (the status shown afterwards); groups carry
+ * `children` to drill into.
+ */
+export interface CopyTarget {
+    /** Stable identifier (e.g. "msg:1", "msg:1:code:0", "msg:1:all", "cmd:1"). */
+    id: string;
+    label: string;
+    /** Dim annotation: line/block counts, language, or tool name. */
+    hint?: string;
+    /** Full text rendered in the preview pane. */
+    preview: string;
+    /** Highlight language for code/command previews (undefined = plain/markdown). */
+    language?: string;
+    /** Leaf: text copied to the clipboard. */
+    content?: string;
+    /** Leaf: status message shown after copying. */
+    copyMessage?: string;
+    /** Group: nested targets to drill into. */
+    children?: CopyTarget[];
+}
+/** Minimal session surface needed to assemble copy targets (eases testing). */
+export interface CopySource {
+    readonly messages: readonly AgentMessage[];
+    getLastVisibleHandoffText(): string | undefined;
+}
+/** Extract fenced code blocks from assistant markdown, in document order. */
+export declare function extractCodeBlocks(text: string): CodeBlock[];
+/** Walk the transcript backwards for the most recent bash command or eval code. */
+export declare function extractLastCommand(messages: readonly AgentMessage[]): LastCommand | undefined;
+/**
+ * Assemble the unified `/copy` target tree: recent assistant messages
+ * (most recent first, each drillable into its code blocks), runnable command
+ * targets interleaved after the assistant message that issued them, and a
+ * fresh-handoff fallback when no assistant message exists yet.
+ */
+export declare function buildCopyTargets(source: CopySource): CopyTarget[];

package/dist/types/sdk.d.ts

@@ -13,7 +13,7 @@ import { type FileSlashCommand } from "./extensibility/slash-commands";
 import type { HindsightSessionState } from "./hindsight/state";
 import { type LocalProtocolOptions } from "./internal-urls";
 import { MCPManager, type MCPToolsLoadResult } from "./mcp";
-import { type MnemopiSessionState } from "./mnemopi/state";
+import type { MnemopiSessionState } from "./mnemopi/state";
 import { AgentRegistry } from "./registry/agent-registry";
 import { AgentSession } from "./session/agent-session";
 import { AuthStorage } from "./session/auth-storage";

package/dist/types/task/executor.d.ts

@@ -48,6 +48,13 @@ export interface ExecutorOptions {
     outputSchema?: unknown;
     /** Parent task recursion depth (0 = top-level, 1 = first child, etc.) */
     taskDepth?: number;
+    /**
+     * Override the `task.maxRuntimeMs` wall-clock cap for this run. When provided
+     * it wins over the settings value; `0` disables the per-subagent wall-clock
+     * limit entirely. Used by the eval `agent()` bridge, whose parent cell
+     * watchdog is already suspended for the call's duration.
+     */
+    maxRuntimeMs?: number;
     enableLsp?: boolean;
     signal?: AbortSignal;
     onProgress?: (progress: AgentProgress) => void;

package/dist/types/telemetry-export.d.ts

@@ -10,7 +10,7 @@ export declare function isTelemetryExportEnabled(): boolean;
  * the OTEL kill-switches are engaged), so it is safe to call unconditionally at
  * startup.
  */
-export declare function initTelemetryExport(): void;
+export declare function initTelemetryExport(): Promise<void>;
 /**
  * Flush any buffered spans to the exporter. No-op when export is disabled.
  * Hosts embedding the agent can call this at natural boundaries (e.g. the end

package/dist/types/tools/eval-render.d.ts

@@ -46,6 +46,7 @@ export declare const evalToolRenderer: {
     }, options: RenderResultOptions & {
         renderContext?: EvalRenderContext;
     }, uiTheme: Theme, _args?: EvalRenderArgs): Component;
+    isStreamingPreviewAppendOnly(_args: EvalRenderArgs, _options: RenderResultOptions, result?: unknown): boolean;
     mergeCallAndResult: boolean;
     inline: boolean;
 };

package/dist/types/tools/fetch.d.ts

@@ -17,14 +17,22 @@ export interface ParsedReadUrlTarget {
     ranges?: readonly LineRange[];
 }
 export declare function parseReadUrlTarget(readPath: string): ParsedReadUrlTarget | null;
+/** Reader backends for {@link renderHtmlToText}, in default priority order. */
+export type FetchProvider = "native" | "trafilatura" | "lynx" | "parallel" | "jina";
 /**
- * Render HTML to markdown using Parallel, jina, trafilatura, lynx, then the
- * in-process native converter. The overall `timeout` budget bounds the call,
- * but remote reader requests are additionally capped at `REMOTE_READER_MAX_MS`
- * so that a hung remote endpoint cannot prevent local fallbacks from running.
- * Only a real `userSignal` cancellation aborts the chain — remote per-attempt
- * timeouts and the overall reader-mode timeout still allow later renderers
- * (especially the purely-local native converter) to be tried.
+ * Render HTML to markdown by trying reader backends in priority order: native
+ * (in-process), trafilatura, lynx, Parallel, then Jina. The `providers.fetch`
+ * setting picks the order — `auto` uses the default above; any specific backend
+ * is tried first, then the remaining backends as fallbacks. Every backend's
+ * output must clear the same quality gate (>100 non-whitespace chars and not
+ * {@link isLowQualityOutput}) before it is accepted, otherwise the next backend
+ * is tried.
+ *
+ * The overall `timeout` budget bounds the whole call; remote backends (Parallel,
+ * Jina) are additionally capped at `REMOTE_READER_MAX_MS` so a hung endpoint
+ * cannot starve later renderers — especially the purely-local native converter,
+ * which always works on already-loaded HTML. Only a real `userSignal`
+ * cancellation aborts the chain (#1449).
  */
 export declare function renderHtmlToText(url: string, html: string, timeout: number, settings: Settings, userSignal: AbortSignal | undefined, storage: AgentStorage | null): Promise<{
     content: string;

package/dist/types/tools/render-utils.d.ts

@@ -76,8 +76,41 @@ export declare function formatBadge(label: string, color: ToolUIColor, theme: Th
  * Uses consistent wording pattern.
  */
 export declare function formatMoreItems(remaining: number, itemType: string): string;
+/**
+ * Maximum rows a tool's streaming/pending *call* preview may render before it is
+ * capped. This is intentionally conservative: the preview still sits inside a
+ * transcript that already consumed some viewport rows, and tool blocks carry
+ * extra chrome (status/header/border/"more lines"), so a "reasonable" raw code
+ * or command preview like 10-12 lines can still overflow and strand its top
+ * while the block is volatile. Keeping the live call window short avoids that
+ * across terminals without turning the transcript into an interactive scroller.
+ */
+export declare const CALL_PREVIEW_MAX_LINES = 6;
+/**
+ * Cap a pre-rendered pending/call preview to a bounded window. When truncated,
+ * show both the head and the live tail so the user can still see what the tool
+ * is currently writing while the volatile block stays short enough not to strand
+ * its top above the viewport. `Ctrl+O` widens the bounded window, but does not
+ * fully uncap live tool previews for the same reason.
+ *
+ * `prefix` (raw, e.g. a dim tree gutter) is prepended to the summary line so
+ * nested previews stay aligned.
+ */
+export declare function capPreviewLines(lines: string[], theme: Theme, options?: {
+    max?: number;
+    expanded?: boolean;
+    prefix?: string;
+}): string[];
 export declare function formatMeta(meta: string[], theme: Theme): string;
 export declare function formatErrorMessage(message: string | undefined, theme: Theme): string;
+/**
+ * Error message rendered as a subordinate detail line beneath a status header
+ * that already carries the error icon (e.g. `✘ Write: <path>`). The header's
+ * icon already signals failure, so this omits the redundant error symbol and
+ * "Error:" prefix that `formatErrorMessage` adds for standalone single-line
+ * errors, indenting two columns to sit under the header title instead.
+ */
+export declare function formatErrorDetail(message: string | undefined, theme: Theme): string;
 export declare function formatEmptyMessage(message: string, theme: Theme): string;
 export type CodeFrameMarker = "" | " " | "*" | "+" | "-" | ">";
 export declare function formatCodeFrameLine(marker: CodeFrameMarker, lineNumber: string | number, content: string, lineNumberWidth: number): string;

package/dist/types/tools/renderers.d.ts

@@ -6,7 +6,7 @@
 import type { Component } from "@oh-my-pi/pi-tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
-type ToolRenderer = {
+export type ToolRenderer = {
     renderCall: (args: unknown, options: RenderResultOptions, theme: Theme) => Component;
     renderResult: (result: {
         content: Array<{
@@ -19,8 +19,22 @@ type ToolRenderer = {
         renderContext?: Record<string, unknown>;
     }, theme: Theme, args?: unknown) => Component;
     mergeCallAndResult?: boolean;
+    /**
+     * While a tool's preview is still streaming, report whether the
+     * currently-rendered preview is append-only: its rows only grow at the bottom
+     * and never re-layout above the bottom live region (a full, top-anchored
+     * content/code preview). The transcript reports this up to the TUI so a
+     * streaming preview taller than the viewport commits its scrolled-off head to
+     * native scrollback instead of dropping it (see
+     * `ToolExecutionComponent.isTranscriptBlockAppendOnly`). `result` is the
+     * latest (possibly partial) tool result, or `undefined` before one exists —
+     * `eval`/`bash` use its presence to defer committing until the streamed input
+     * (code) has finalized. Omit (or return `false`) for previews that slide a
+     * tail window or later collapse to a compact result — committing their head
+     * would strand stale rows.
+     */
+    isStreamingPreviewAppendOnly?: (args: unknown, options: RenderResultOptions, result?: unknown) => boolean;
     /** Render without background box, inline in the response flow */
     inline?: boolean;
 };
 export declare const toolRenderers: Record<string, ToolRenderer>;
-export {};