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

package/CHANGELOG.md

@@ -2,7 +2,41 @@
 
 ## [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.
@@ -31,6 +65,7 @@
 - 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

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

@@ -1027,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[]>;
@@ -2186,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": {
@@ -3902,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,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/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/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/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>;
@@ -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/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,6 +234,7 @@ export interface InteractiveModeContext {
     }): void;
     showPluginSelector(mode?: "install" | "uninstall"): void;
     showUserMessageSelector(): void;
+    showCopySelector(): void;
     showTreeSelector(): void;
     showSessionSelector(): void;
     handleResumeSession(sessionPath: string): Promise<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/tools/eval-render.d.ts

@@ -13,6 +13,14 @@ import type { EvalStatusEvent, EvalToolDetails } from "../eval/types";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
 export declare const EVAL_DEFAULT_PREVIEW_LINES = 10;
+/**
+ * Rows of source kept in the *pending* eval preview. The window follows the
+ * streaming edge (newest lines pinned to the bottom) so you can watch the code
+ * being written, while staying bounded — a volatile tool block taller than the
+ * viewport would otherwise strand its scrolled-off head out of native scrollback
+ * on ED3-risk terminals. Matches the streaming windows used by edit/write.
+ */
+export declare const EVAL_STREAMING_PREVIEW_LINES = 12;
 interface EvalRenderCellArg {
     language?: string;
     code?: string;

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

@@ -76,6 +76,31 @@ 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;
 export declare function formatEmptyMessage(message: string, theme: Theme): string;

package/dist/types/tui/code-cell.d.ts

@@ -11,6 +11,12 @@ export interface CodeCellOptions {
     output?: string;
     outputMaxLines?: number;
     codeMaxLines?: number;
+    /**
+     * Show the LAST `codeMaxLines` rows (the live streaming edge) instead of the
+     * first, with a "… N earlier lines" marker on top. Lets a pending preview
+     * follow code as it is written while staying bounded. Ignored when `expanded`.
+     */
+    codeTail?: boolean;
     expanded?: boolean;
     /** Animate the cell border with a sweeping segment while pending/running. */
     animate?: boolean;

package/dist/types/tui/output-block.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Bordered output container with optional header and sections.
+ */
+import type { Component } from "@oh-my-pi/pi-tui";
 import type { Theme } from "../modes/theme/theme";
 import type { State } from "./types";
 export interface OutputBlockOptions {
@@ -13,6 +17,12 @@ export interface OutputBlockOptions {
     /** Animate the border with a sweeping dark segment (pending/running state). */
     animate?: boolean;
 }
+declare const FRAMED_BLOCK_COMPONENT: unique symbol;
+export type FramedBlockComponent = Component & {
+    [FRAMED_BLOCK_COMPONENT]?: true;
+};
+export declare function markFramedBlockComponent<T extends Component>(component: T): T & FramedBlockComponent;
+export declare function isFramedBlockComponent(component: Component): boolean;
 /**
  * Monotonic frame counter for animated borders, quantized to the TUI's ~16ms
  * render cap so the cache key advances once per ~60fps frame — fine enough for a
@@ -44,3 +54,4 @@ export declare class CachedOutputBlock {
     /** Invalidate the cache, forcing a rebuild on next render. */
     invalidate(): void;
 }
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "15.9.5",
+	"version": "15.9.67",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -47,14 +47,14 @@
 		"@agentclientprotocol/sdk": "0.22.1",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "15.9.5",
-		"@oh-my-pi/omp-stats": "15.9.5",
-		"@oh-my-pi/pi-agent-core": "15.9.5",
-		"@oh-my-pi/pi-ai": "15.9.5",
-		"@oh-my-pi/pi-mnemopi": "15.9.5",
-		"@oh-my-pi/pi-natives": "15.9.5",
-		"@oh-my-pi/pi-tui": "15.9.5",
-		"@oh-my-pi/pi-utils": "15.9.5",
+		"@oh-my-pi/hashline": "15.9.67",
+		"@oh-my-pi/omp-stats": "15.9.67",
+		"@oh-my-pi/pi-agent-core": "15.9.67",
+		"@oh-my-pi/pi-ai": "15.9.67",
+		"@oh-my-pi/pi-mnemopi": "15.9.67",
+		"@oh-my-pi/pi-natives": "15.9.67",
+		"@oh-my-pi/pi-tui": "15.9.67",
+		"@oh-my-pi/pi-utils": "15.9.67",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/autoresearch/dashboard.ts

@@ -1,4 +1,4 @@
-import { matchesKey, replaceTabs, Text, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
+import { matchesKey, replaceTabs, ScrollView, Text, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
 import type { Theme } from "../modes/theme/theme";
 import { formatElapsed, formatNum, isBetter } from "./helpers";
 import { currentResults, findBaselineMetric, findBaselineRunNumber, findBaselineSecondary } from "./state";
@@ -76,14 +76,14 @@ export function createDashboardController(): DashboardController {
 							const viewportRows = Math.max(4, terminalRows - 4);
 							const maxScroll = Math.max(0, body.length - viewportRows);
 							if (scrollOffset > maxScroll) scrollOffset = maxScroll;
-							const visible = body.slice(scrollOffset, scrollOffset + viewportRows);
-							const footer = renderOverlayFooter(width, scrollOffset, viewportRows, body.length, theme);
-							return [
-								header,
-								...visible,
-								...Array.from({ length: Math.max(0, viewportRows - visible.length) }, () => ""),
-								footer,
-							];
+							const sv = new ScrollView(body.slice(scrollOffset, scrollOffset + viewportRows), {
+								height: viewportRows,
+								scrollbar: "auto",
+								totalRows: body.length,
+								theme: { track: t => theme.fg("dim", t), thumb: t => theme.fg("accent", t) },
+							});
+							sv.setScrollOffset(scrollOffset);
+							return [header, ...sv.render(width), renderOverlayFooter(width, theme)];
 						},
 						handleInput(data: string): void {
 							const totalRows =
@@ -406,18 +406,8 @@ function renderOverlayRunningLine(
 	);
 }
 
-function renderOverlayFooter(
-	width: number,
-	scrollOffset: number,
-	viewportRows: number,
-	totalRows: number,
-	theme: Theme,
-): string {
-	const position =
-		totalRows > viewportRows
-			? ` ${scrollOffset + 1}-${Math.min(totalRows, scrollOffset + viewportRows)}/${totalRows}`
-			: "";
-	const hint = theme.fg("dim", ` up/down j/k pageup pagedown g G esc${position} `);
+function renderOverlayFooter(width: number, theme: Theme): string {
+	const hint = theme.fg("dim", " up/down j/k pageup pagedown g G esc ");
 	const fill = Math.max(0, width - visibleWidth(hint));
 	return theme.fg("borderMuted", "-".repeat(fill)) + hint;
 }