@oh-my-pi/pi-coding-agent 15.9.3 → 15.9.67

package/CHANGELOG.md

@@ -2,6 +2,79 @@
 
 ## [Unreleased]
 
+## [15.9.67] - 2026-06-06
+### Added
+
+- Added `timeout-pause` and `timeout-resume` eval bridge status events emitted around `agent()`/`llm()` operations
+- Added a `/copy` picker: `/copy` now opens a fullscreen, outlined tree of recent assistant messages with their code blocks nested beneath (like `/tree`). Navigate with ↑↓, and Enter copies the highlighted node — a whole message, an individual code block, "All N blocks", or a bash/eval command interleaved with the assistant turn that issued it. A live preview pane shows the selected target, wrapping prose and syntax-highlighting code/commands.
+
+### Changed
+
+- Changed eval timeout accounting so delegated bridge calls now suspend the cell watchdog and start a fresh timeout window when runtime control returns
+- Changed `IdleTimeout` to support reference-counted pauses so overlapping delegated bridge calls keep timeout paused until all calls complete
+- Changed the default `app.message.followUp` binding from `Ctrl+Enter` alone to `[Ctrl+Q, Ctrl+Enter]` so the follow-up shortcut works in Windows Terminal, which does not deliver a distinct `Ctrl+Enter` event to console apps. `Ctrl+Q` mirrors the GitHub Copilot CLI default for the same action; existing remaps in `~/.omp/agent/keybindings.yml` are untouched, and if another user-remapped action already claims `Ctrl+Q`, that user binding wins while follow-up keeps `Ctrl+Enter`. `Ctrl+Q` is also reserved by `ExtensionRunner` so an extension cannot register that chord and be silently overwritten by the built-in follow-up handler ([#1903](https://github.com/can1357/oh-my-pi/issues/1903)).
+- Changed all scrollable TUI pickers and viewports to render through the shared `ScrollView` right-edge scrollbar for a uniform look, replacing their ad-hoc `(N/M)` / `[a-b/total]` text indicators (search hints and the tree filter-mode label are preserved). Covers the session/resume picker, model selector, OAuth provider selector, history search, session tree selector, agent dashboard list, extension list, user-message selector, the raw SSE debug viewer, the autoresearch dashboard overlay, and the session observer overlay.
+- Changed the `/model` and `/switch` selectors to dim and skip models whose context windows are smaller than the current chat context.
+- Changed `/copy` command targets to appear inline with recent assistant messages instead of as a separate "Last bash command" row at the end of the picker.
+
+### Fixed
+
+- Fixed the idle `Working...` loader freezing on ED3-risk terminals with unobservable native scrollback by keeping foreground live-region rendering enabled from `agent_start` until `agent_end`, before the first assistant or tool event arrives.
+- Fixed framed tool output blocks rendering one column inset inside tool boxes; modern bordered blocks now span the same width as legacy background-filled tool boxes.
+- Fixed potential `TimeoutError` aborts for short `timeout` eval cells during long bridged `agent()`/`llm()` work where no progress events are emitted until completion
+- Fixed retry recovery to allow automatic retries without switching models when `retry.modelFallback` is disabled.
+- Fixed `ttsr.enabled: false` being ignored at runtime. TTSR rules were still being registered with `TtsrManager.addRule` and matched against stream deltas even when the global toggle was off, so disabling TTSR did not suppress rule injection or stream abort. The manager now gates `addRule`, `hasRules`, and `#matchBuffer` on the enabled flag, so disabling fully short-circuits the TTSR path. Condition rules fall through to the rulebook bucket instead of being silently swallowed. ([#1767](https://github.com/can1357/oh-my-pi/issues/1767))
+- Fixed the Python eval kernel hanging on Windows during `import pandas` / `import numpy`, with SIGINT unable to recover the cell. `PythonKernel.start()` spawned the runner with `windowsHide: true`, which in Bun maps to the Win32 `CREATE_NO_WINDOW` flag and detaches the long-lived child from any inherited console — so native extensions like `numpy/_core/_multiarray_umath.pyd` (and its bundled OpenBLAS/SLEEF thread-pool init) could deadlock inside `LoadLibraryExW`, and `GenerateConsoleCtrlEvent`-based SIGINT delivery silently became a no-op. The kernel now hides its window only when the host itself has no console to share (service / piped launch); an interactive TUI launch lets the kernel inherit the parent's console, matching the behavior of `python.exe` invoked from `cmd.exe` ([#1960](https://github.com/can1357/oh-my-pi/issues/1960)).
+- Fixed `task` renderer crashing the TUI with `TypeError: completeData?.map is not a function` when a subagent's `extractedToolData.yield` slot held a non-array value. `renderAgentResult` (and the live-progress sibling) cast the slot to `Array<{ data }>` and called `?.map`, but optional chaining short-circuits only on `null`/`undefined`, so a plain object made `.map` `undefined` and threw — taking down every `review` task render. Both sites now go through `normalizeYieldData`, which wraps a single object as a 1-element array and drops primitives ([#1987](https://github.com/can1357/oh-my-pi/issues/1987))
+- Fixed `sdk-async-job-manager-singleton` tests flaking under the full parallel suite. The four `createAgentSession`-based cases ran on the default 5000ms per-test timeout, which two real session startups can exceed when `test:ts` saturates the machine across packages; on timeout the still-running test body and `afterEach` reset raced, surfacing a spurious "Unhandled error between tests" on the `AsyncJobManager.instance()` assertion. They now carry an explicit 60000ms timeout, matching the convention used by the other session-creating tests in this suite.
+- Fixed streaming `eval`, `bash`, `ssh`, and `task` call previews overflowing the live transcript viewport and cutting off their top while pending. A volatile tool block taller than the viewport could strand its scrolled-off head out of native scrollback on ED3-risk terminals (committed nowhere, repainted nowhere) until the result landed. The pending `eval` source preview now follows the streaming edge in a bounded 12-line tail window (newest lines pinned to the bottom, "… N earlier lines" on top) so you can watch the code being written without the box overflowing; `bash`/`ssh` commands and `task` context use a bounded head+tail window. `Ctrl+O` still lifts the cap for a full view.
+- Fixed the streaming `write` call preview ignoring `Ctrl+O` so the expand toggle was a no-op while a file was being written. Unlike the `eval`/`bash`/`ssh`/`task` streaming previews, `formatStreamingContent` never received the `expanded` flag, leaving the preview pinned to a bounded 12-line tail window even after pressing `Ctrl+O` — so on a large write you could not widen past the streaming edge until the tool result landed. The preview now lifts the cap to the full file (head through tail) when expanded, matching the documented streaming-preview behavior of the other tools.
+- Fixed turn-ending provider errors rendering twice — once as the transcript's inline `Error: …` line and again in the pinned banner above the editor (added in 15.9.5). The inline line is now suppressed while the same error is mirrored in the banner and restored to the transcript when the banner clears at the next turn, so the error stays in history without the duplicate render at the error moment.
+
+### Removed
+
+- Removed the `/copy last|code|all|cmd` subcommands; every copy target is now reachable by picking it in the `/copy` tree.
+
+## [15.9.5] - 2026-06-05
+
+### Added
+
+- Added a persistent error banner pinned above the editor when an assistant turn ends on a provider error (e.g. Anthropic's "Output blocked by content filtering policy"). The transcript `Error: …` line scrolls away as the conversation grows, so terminal turns that ended on a stream error could pass unnoticed; the banner stays in the fixed region above the input and is cleared when the next turn starts.
+
+- Added bold, underlined, clickable `[Image #N]` placeholders in the draft editor and sent user-message bubbles, backed by extension-bearing blob-store sidecar files so terminal `file://` links open in image viewers.
+- Added the active model identifier (`provider/id`) to the system prompt's `<workstation>` block so the agent knows which model it is running as. Gated by the new `includeModelInPrompt` setting (default on); the base prompt is rebuilt on a mid-session model switch so the surfaced identifier stays current.
+- Added `OLLAMA_HOST` support for implicit local Ollama discovery when `OLLAMA_BASE_URL` is unset, so OMP picks up the same host setting used by Ollama.
+- Added `OLLAMA_CONTEXT_LENGTH` as a positive-integer context-window override for implicit local Ollama discovery, so users can correct OMP context budgeting without writing per-model overrides.
+
+### Changed
+
+- Changed `tools.discoveryMode` to default to `auto`, which keeps discovery off for small tool sets and automatically switches to MCP-only tool discovery when more than 40 tools are registered.
+
+### Fixed
+
+- Fixed user-message rendering to materialize image links from embedded image blocks when rebuilding chat output, so image placeholders remain clickable after replayed or restored messages
+- Fixed queued/steering user messages carrying a pasted image rendering out of order — sometimes dropping the user bubble *below* the very tool output it was sent to steer. `EventController.#handleMessageStart` awaited async image-link materialization between the user `message_start` and `addMessageToChat`; since `AgentSession.#emit` dispatches TUI listeners fire-and-forget, that mid-handler yield let the next synchronously-handled events (assistant `message_start`, tool execution start/end) append their components first, scrambling transcript order and live-region block boundaries. The bubble is now appended synchronously, with clickable image links still materialized via the synchronous blob-store fallback.
+- Fixed tool execution cards to finalize promptly when a turn is abandoned or completed so stale streaming previews and frozen spinner frames no longer keep transcript rows in the live region
+- Fixed `read` and `search` TUI rendering to emit OSC 8 hyperlinks for HTTP URLs, `local://` resources backed by files, and filesystem search targets, including line-specific links for search match rows.
+- Fixed aborted streaming assistant messages staying frozen before their red "Operation aborted" label when status rows were appended underneath on ED3-risk terminals.
+- Fixed `omp` / `omp -c` stacking a fresh welcome screen and transcript on top of the previous run's leftover terminal scrollback. The cold-launch transcript render was the only session-load path that did not pass `clearTerminalHistory`, so the TUI's scrollback-preserving initial paint left the prior run's welcome + conversation above the new one; the cold launch now clears native scrollback before painting, matching every in-process session switch.
+- Fixed a long streamed assistant reply dropping its earlier lines on ED3-risk terminals (Ghostty/kitty/iTerm2) once it grew past the viewport — the head scrolled off the top and never reached scrollback, so the reply rendered as a ~viewport-tall circular buffer of only its latest lines. `AssistantMessageComponent` now reports itself as an append-only transcript block and `TranscriptContainer` surfaces the resulting commit-safe boundary, so the renderer commits the scrolled-off head to native scrollback instead of discarding it (volatile tool previews stay deferred as before).
+
+### Security
+
+- Blocked OSC 8 hyperlink wrapping for URI targets containing terminal control bytes to avoid rendering malformed control-sequence links
+
+## [15.9.4] - 2026-06-05
+
+### Fixed
+
+- Fixed chat transcript updates after submitting input so frozen scrollback is only thawed when native scrollback replay succeeds, preventing misplaced or duplicated rows when the viewport is not at the tail
+- Fixed `read` of `.zip` archives to list the central directory without inflating every member, so large or corrupt zip payloads no longer freeze directory reads; member contents are inflated only when a specific entry is read.
+- Fixed the Python `eval` kernel being hard-killed (and its persistent session state lost) when a cell blocked in `parallel()` / `agent()` was interrupted. Each `agent()`/`tool.*` call blocks a kernel worker thread in a synchronous `urllib` request to the host bridge, and `parallel()`'s `ThreadPoolExecutor` exit joins those threads — so the kernel cannot unwind a `KeyboardInterrupt` until every in-flight bridge call returns. A wide subagent fan-out's teardown routinely outlasted the kernel's 5s SIGINT-escalation window, so the kernel was force-killed (surfacing `[kernel] Python kernel shutdown`) while the subagents were still winding down. The host bridge now resolves an in-flight call the instant the cell's signal aborts, so the kernel unwinds cleanly and keeps its state; the already-signaled subagent continues tearing down in the background.
+- Fixed `github` tool `run_watch` op ignoring the explicit `repo` argument and silently watching the cwd-inferred repository in nested/umbrella workspaces. `executeRunWatch` passed `undefined` for the user-supplied `repo` to `resolveGitHubRepo`, so a call like `{op: "run_watch", repo: "owner/cxf", branch: "main"}` fell back to `gh repo view` in cwd and streamed `watching <sha> on <cwd-repo>` against the wrong repository. The explicit `repo` now takes precedence over the cwd inference, and the no-`branch`/no-`run` path refuses to derive the watched commit from `git HEAD` unless the cwd actually points at the resolved repo — otherwise it raises a `ToolError` telling the caller to pass `branch` or `run` instead of silently rebinding to an unrelated commit ([#1949](https://github.com/can1357/oh-my-pi/issues/1949)).
+- Fixed `omp plugin install <local-path>` failing with `Invalid package name: .` (and similar) for cwd-relative (`.`, `./pkg`), absolute (`/abs`, `C:\…`, `\\unc`), and tilde-prefixed (`~/pkg`) specs. `classifyInstallTarget` now returns a `local` arm in addition to `marketplace`/`npm`, and `plugin install` routes those specs to `PluginManager.link()` — the same code path as `omp plugin link`. ([#1945](https://github.com/can1357/oh-my-pi/issues/1945))
+- Fixed the `web_search` result renderer capping the synthesized answer at 12 lines even when expanded, while the Sources list expanded in full — so a long answer stayed truncated ("… N more lines") after `Ctrl+O`, making the expand toggle look like a no-op and dwarfing the answer next to its sources. The answer now renders the full text (markdown-formatted) when expanded and a short markdown preview when collapsed, matching the sources' collapse/expand behavior. The answer is also rendered through the Markdown component instead of dimmed raw lines, so headings, bold, lists, and code in the answer display formatted.
+
 ## [15.9.3] - 2026-06-05
 
 ### Fixed
@@ -9361,4 +9434,4 @@ Initial public release.
 - Git branch display in footer
 - Message queueing during streaming responses
 - OAuth integration for Gmail and Google Calendar access
-- HTML export with syntax highlighting and collapsible sections
+- HTML export with syntax highlighting and collapsible sections

package/dist/types/cli/classify-install-target.d.ts

@@ -1,4 +1,7 @@
-export declare function classifyInstallTarget(spec: string, knownMarketplaces: Set<string>): {
+export type ClassifiedInstallTarget = {
+    type: "local";
+    path: string;
+} | {
     type: "marketplace";
     name: string;
     marketplace: string;
@@ -6,3 +9,4 @@ export declare function classifyInstallTarget(spec: string, knownMarketplaces: S
     type: "npm";
     spec: string;
 };
+export declare function classifyInstallTarget(spec: string, knownMarketplaces: Set<string>): ClassifiedInstallTarget;

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

@@ -224,7 +224,7 @@ export declare const KEYBINDINGS: {
         readonly description: "Open external editor";
     };
     readonly "app.message.followUp": {
-        readonly defaultKeys: "ctrl+enter";
+        readonly defaultKeys: ["ctrl+q", "ctrl+enter"];
         readonly description: "Send follow-up message";
     };
     readonly "app.message.dequeue": {
@@ -329,6 +329,9 @@ export declare class KeybindingsManager extends TuiKeybindingsManager {
      * Reload keybindings from the config file.
      */
     reload(): void;
+    setUserBindings(userBindings: KeybindingsConfig): void;
+    getKeys(keybinding: Keybinding): KeyId[];
+    getResolvedBindings(): KeybindingsConfig;
     /**
      * Get the effective resolved bindings (defaults + user overrides).
      */

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

@@ -659,7 +659,7 @@ export declare const SETTINGS_SCHEMA: {
         readonly ui: {
             readonly tab: "appearance";
             readonly label: "Terminal Hyperlinks";
-            readonly description: "Wrap file paths in OSC 8 hyperlinks for terminal-native click-to-open (auto: detect support; off: never; always: unconditional)";
+            readonly description: "Wrap paths and URLs in OSC 8 hyperlinks for terminal-native click-to-open (auto: detect support; off: never; always: unconditional)";
         };
     };
     readonly "display.tabWidth": {
@@ -745,6 +745,15 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Render full tool descriptions in the system prompt instead of a tool name list";
         };
     };
+    readonly includeModelInPrompt: {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "model";
+            readonly label: "Include Model In Prompt";
+            readonly description: "Surface the active model identifier in the system prompt so the agent knows which model it is";
+        };
+    };
     readonly temperature: {
         readonly type: "number";
         readonly default: -1;
@@ -1018,6 +1027,15 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Maximum wait between retries, in ms. When the provider asks us to wait longer than this and no credential or model fallback succeeds, the request fails fast instead of sleeping (e.g. 3-hour Anthropic rate-limit windows).";
         };
     };
+    readonly "retry.modelFallback": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "model";
+            readonly label: "Retry Model Fallback";
+            readonly description: "Allow retry recovery to switch to configured fallback models";
+        };
+    };
     readonly "retry.fallbackChains": {
         readonly type: "record";
         readonly default: Record<string, string[]>;
@@ -2177,7 +2195,7 @@ export declare const SETTINGS_SCHEMA: {
         readonly ui: {
             readonly tab: "editing";
             readonly label: "Hash Lines";
-            readonly description: "Include snapshot-tag headers and line numbers in read output for hashline edit mode (¶PATH#tag plus LINE:content)";
+            readonly description: "Include snapshot-tag headers and line numbers in read output for hashline edit mode ([PATH#TAG] plus LINE:content)";
         };
     };
     readonly "read.defaultLimit": {
@@ -2828,12 +2846,12 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly "tools.discoveryMode": {
         readonly type: "enum";
-        readonly values: readonly ["off", "mcp-only", "all"];
-        readonly default: "off";
+        readonly values: readonly ["auto", "off", "mcp-only", "all"];
+        readonly default: "auto";
         readonly ui: {
             readonly tab: "tools";
             readonly label: "Tool Discovery";
-            readonly description: "Hide tools behind a search tool to save tokens. 'mcp-only' hides MCP tools; 'all' hides all non-essential built-ins too.";
+            readonly description: "Hide tools behind a search tool to save tokens. 'auto' hides MCP tools once the tool set has more than 40 tools; 'mcp-only' always hides MCP tools; 'all' hides all non-essential built-ins too.";
         };
     };
     readonly "tools.essentialOverride": {
@@ -3893,6 +3911,7 @@ export interface RetrySettings {
     maxRetries: number;
     baseDelayMs: number;
     maxDelayMs: number;
+    modelFallback: boolean;
 }
 export interface MemoriesSettings {
     enabled: boolean;

package/dist/types/edit/file-snapshot-store.d.ts

@@ -12,7 +12,7 @@ import { InMemorySnapshotStore } from "@oh-my-pi/hashline";
 /**
  * Upper bound on the file size we snapshot. A section tag is a content hash of
  * the *whole* file, so minting one means holding the full normalized text in
- * the store. Files above this cap emit no `¶path#tag` header — line-anchored
+ * the store. Files above this cap emit no `[path#tag]` header — line-anchored
  * editing of multi-megabyte files is out of scope under the full-content model.
  */
 export declare const SNAPSHOT_MAX_BYTES: number;

package/dist/types/eval/__tests__/kernel-spawn.test.d.ts

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

package/dist/types/eval/backend.d.ts

@@ -9,12 +9,12 @@ export interface ExecutorBackendExecOptions {
     signal?: AbortSignal;
     session: ToolSession;
     /**
-     * Inactivity budget in milliseconds (the cell's `timeout`). Cancellation is
-     * driven entirely by `signal`, which the eval tool arms as an idle watchdog
-     * that fires a `TimeoutError` reason after this much time with no progress
-     * (status) events. Backends use this value only for timeout-annotation text
-     * and as cold-start headroom; they MUST NOT derive a competing wall-clock
-     * timer from it.
+     * Runtime-work budget in milliseconds (the cell's `timeout`). Cancellation is
+     * driven entirely by `signal`, which the eval tool arms as a watchdog that
+     * pauses on bridge timeout-control status events and fires a `TimeoutError`
+     * reason only while the Python/JS runtime owns control. Backends use this
+     * value only for timeout-annotation text and as cold-start headroom; they MUST
+     * NOT derive a competing wall-clock timer from it.
      */
     idleTimeoutMs: number;
     reset: boolean;

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

@@ -0,0 +1,27 @@
+/**
+ * Timeout suspension for in-flight host-side eval bridge calls.
+ *
+ * The eval watchdog caps a cell's `timeout` as a budget on the cell runtime's
+ * own work. Host-side `agent()` / `parallel()` / `llm()` bridge calls hand
+ * control to the outer TypeScript process, where the Python kernel or JS VM is
+ * only waiting for a result. While that delegated work is in flight, the cell
+ * timeout must be ignored completely; once the bridge returns and the runtime is
+ * back in control, the watchdog starts a fresh timeout window.
+ *
+ * Bridge helpers express that handoff with synthetic pause/resume status events
+ * on the existing `emitStatus → onStatus` path. Consumers MUST treat these as
+ * timeout-control events only: update the watchdog and drop them from rendered
+ * or persisted cell output.
+ */
+import type { JsStatusEvent } from "./js/shared/types";
+/** Synthetic status op emitted when a bridge call leaves the cell runtime. */
+export declare const EVAL_TIMEOUT_PAUSE_OP = "timeout-pause";
+/** Synthetic status op emitted when a bridge call returns control to the runtime. */
+export declare const EVAL_TIMEOUT_RESUME_OP = "timeout-resume";
+/** Whether a status event is pure eval-timeout control and should not render. */
+export declare function isEvalTimeoutControlEvent(event: JsStatusEvent): boolean;
+/**
+ * Run {@link operation} while suspending the eval watchdog through
+ * {@link emitStatus}. A no-op wrapper when no status sink is wired.
+ */
+export declare function withBridgeTimeoutPause<T>(emitStatus: ((event: JsStatusEvent) => void) | undefined, operation: () => Promise<T>): Promise<T>;

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/modes/components/assistant-message.d.ts

@@ -13,6 +13,22 @@ 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
+     * re-layout, new content only grows the block at the bottom. The transcript
+     * reports this so the renderer may commit scrolled-off head rows of a long
+     * streamed reply to native scrollback instead of dropping them (see
+     * `NativeScrollbackLiveRegion#getNativeScrollbackCommitSafeEnd`). Volatile
+     * blocks (tool previews that collapse) intentionally do not implement this.
+     */
+    isTranscriptBlockAppendOnly(): boolean;
+    markTranscriptBlockFinalized(): void;
     setToolResultImages(toolCallId: string, images: ImageContent[]): void;
     setUsageInfo(usage: Usage): void;
     updateContent(message: AssistantMessage): void;

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

@@ -6,8 +6,10 @@ type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.cl
  */
 export declare class CustomEditor extends Editor {
     #private;
+    imageLinks?: readonly (string | undefined)[];
     /** Gradient-highlight the "ultrathink" / "orchestrate" / "workflow" keywords as the user types
-     *  them, skipping any occurrence inside code spans, fenced blocks, or XML sections. */
+     *  them, skipping any occurrence inside code spans, fenced blocks, or XML sections. Also make
+     *  pasted image placeholders visually distinct and hyperlink them once their blob file exists. */
     decorateText: (text: string) => string;
     onEscape?: () => void;
     onClear?: () => void;

package/dist/types/modes/components/error-banner.d.ts

@@ -0,0 +1,11 @@
+import { Container } from "@oh-my-pi/pi-tui";
+/**
+ * A persistent error banner pinned above the editor. Unlike the transcript
+ * "Error: …" line (which scrolls away as the conversation grows), this stays in
+ * the fixed region directly above the input so a turn that ended on a provider
+ * error — e.g. Anthropic's "Output blocked by content filtering policy" — cannot
+ * be missed. It is cleared when the next turn starts.
+ */
+export declare class ErrorBannerComponent extends Container {
+    constructor(message: string);
+}

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

@@ -52,6 +52,21 @@ export declare class ToolExecutionComponent extends Container {
         details?: any;
         isError?: boolean;
     }, isPartial?: boolean, _toolCallId?: string): void;
+    /**
+     * Whether this block has reached a terminal state for transcript freezing.
+     * Reports `false` while it can still visually change so the
+     * {@link TranscriptContainer} keeps it inside the repaintable live region:
+     * a foreground tool awaiting its result, or one streaming partial output.
+     * A final (non-partial) result, a background-async tool the agent has moved
+     * past, or an explicit {@link seal} flips it to `true`.
+     */
+    isTranscriptBlockFinalized(): 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
+     * transcript live region.
+     */
+    seal(): void;
     /**
      * Stop spinner animation and cleanup resources.
      */

package/dist/types/modes/components/transcript-container.d.ts

@@ -26,6 +26,7 @@ export declare class TranscriptContainer extends Container implements NativeScro
     invalidate(): void;
     clear(): void;
     getNativeScrollbackLiveRegionStart(): number | undefined;
+    getNativeScrollbackCommitSafeEnd(): number | undefined;
     /**
      * Retire all frozen snapshots so the next render reflects each block's current
      * state. Call at reconciliation checkpoints (prompt submit) where the whole

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

@@ -3,6 +3,6 @@ import { Container } from "@oh-my-pi/pi-tui";
  * Component that renders a user message
  */
 export declare class UserMessageComponent extends Container {
-    constructor(text: string, synthetic?: boolean);
+    constructor(text: string, synthetic?: boolean, imageLinks?: readonly (string | undefined)[]);
     render(width: number): string[];
 }

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,6 +35,7 @@ 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>;

package/dist/types/modes/image-references.d.ts

@@ -0,0 +1,17 @@
+import type { ImageContent } from "@oh-my-pi/pi-ai";
+import { type BlobPutResult } from "../session/blob-store";
+type ImageBlobWriter = (data: Buffer, options?: {
+    extension?: string;
+}) => Promise<BlobPutResult>;
+type ImageBlobWriterSync = (data: Buffer, options?: {
+    extension?: string;
+}) => BlobPutResult;
+export interface ImageReferenceRenderers {
+    renderText: (text: string) => string;
+    renderReference: (label: string, index: number) => string;
+}
+export declare function renderImageReferences(text: string, renderers: ImageReferenceRenderers): string;
+export declare function imageReferenceHyperlink(label: string, index: number, imageLinks: readonly (string | undefined)[] | undefined, renderLabel: (text: string) => string): string;
+export declare function materializeImageReferenceLinks(images: readonly ImageContent[] | undefined, putBlob: ImageBlobWriter): Promise<(string | undefined)[] | undefined>;
+export declare function materializeImageReferenceLinksSync(images: readonly ImageContent[] | undefined, putBlob: ImageBlobWriterSync): (string | undefined)[] | undefined;
+export {};

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

@@ -56,6 +56,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     todoContainer: Container;
     btwContainer: Container;
     omfgContainer: Container;
+    errorBannerContainer: Container;
     editor: CustomEditor;
     editorContainer: Container;
     hookWidgetContainerAbove: Container;
@@ -77,6 +78,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     todoPhases: TodoPhase[];
     hideThinkingBlock: boolean;
     pendingImages: ImageContent[];
+    pendingImageLinks: (string | undefined)[];
     compactionQueuedMessages: CompactionQueuedMessage[];
     pendingTools: Map<string, ToolExecutionHandle>;
     pendingBashComponents: BashExecutionComponent[];
@@ -136,6 +138,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     startPendingSubmission(input: {
         text: string;
         images?: ImageContent[];
+        imageLinks?: (string | undefined)[];
         customType?: string;
         display?: boolean;
     }): SubmittedUserInput;
@@ -162,6 +165,8 @@ export declare class InteractiveMode implements InteractiveModeContext {
         dim?: boolean;
     }): void;
     showError(message: string): void;
+    showPinnedError(message: string): void;
+    clearPinnedError(): void;
     showWarning(message: string): void;
     ensureLoadingAnimation(): void;
     setWorkingMessage(message?: string): void;
@@ -177,6 +182,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     isKnownSlashCommand(text: string): boolean;
     addMessageToChat(message: AgentMessage, options?: {
         populateHistory?: boolean;
+        imageLinks?: readonly (string | undefined)[];
     }): Component[];
     renderSessionContext(sessionContext: SessionContext, options?: {
         updateFooter?: boolean;
@@ -184,6 +190,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     }): void;
     renderInitialMessages(prebuiltContext?: SessionContext, options?: {
         preserveExistingChat?: boolean;
+        clearTerminalHistory?: boolean;
     }): void;
     getUserMessageText(message: Message): string;
     findLastAssistantMessage(): AssistantMessage | undefined;
@@ -192,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>;
@@ -229,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>;