@oh-my-pi/pi-tui 18.7.0 → 18.8.0

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## [Unreleased]
 
+## [18.8.0] - 2026-10-07
+
+### Added
+
+- SVG and Mermaid files now render as images or diagrams beneath their file cards, with SVG previews updating while the file streams and Mermaid previews appearing when the file is complete.
+- Native tool cards can open expanded regardless of the transcript’s expansion state; the todo checklist uses this behavior.
+
+### Changed
+
+- TSP composer placeholders now appear as the composer title in italicized curly quotes, with “What are we cooking?” used when no title is provided.
+- TSP image transfers are more efficient across reconnects and multiple surfaces: images are sent once per connection, existing terminal blobs are detected before upload, and images in the Tern blob cache can be reused without crossing the terminal pty.
+- Improved performance and responsiveness across the TUI, including large TSP messages and Markdown documents, streaming output, tool-result cards, debug logs, raw SSE and Git diff views, path and model searches, session and settings lists, plan review, agent transcripts, status updates, assistant links, Kitty images, and large prompt or evaluation content.
+- Large debug logs and plan-review histories now retain bounded history to keep the interface responsive, while preserving the newest log entries.
+
+### Fixed
+
+- Fixed slow Markdown processing for certain LaTeX environments and incomplete delimiters.
+- Fixed excessive slowdown when formatting long semicolon-free JavaScript evaluations.
+- Fixed prompt-editor lag in large drafts containing magic keywords.
+
 ## [18.7.0] - 2026-10-06
 
 ### Added
@@ -2972,55 +2992,4 @@ Initial release under @oh-my-pi scope. See previous releases at [badlogic/pi-mon
 
 - **Experimental:** Overlay compositing for `ctx.ui.custom()` with `{ overlay: true }` option ([#558](https://github.com/badlogic/pi-mono/pull/558) by [@nicobailon](https://github.com/nicobailon))
 
-## [0.38.0] - 2026-01-08
-
-### Added
-
-- `EditorComponent` interface for custom editor implementations
-- `StdinBuffer` class to split batched stdin into individual sequences (adapted from [OpenTUI](https://github.com/anomalyco/opentui), MIT license)
-
-### Fixed
-
-- Key presses no longer dropped when batched with other events over SSH ([#538](https://github.com/badlogic/pi-mono/pull/538))
-
-## [0.37.8] - 2026-01-07
-
-### Added
-
-- `Component.wantsKeyRelease` property to opt-in to key release events (default false)
-
-### Fixed
-
-- TUI now filters out key release events by default, preventing double-processing of keys in editors and other components
-
-## [0.37.7] - 2026-01-07
-
-### Fixed
-
-- `matchesKey()` now correctly matches Kitty protocol sequences for unmodified letter keys (needed for key release events)
-
-## [0.37.6] - 2026-01-06
-
-### Added
-
-- Kitty keyboard protocol flag 2 support for key release events. New exports: `isKeyRelease(data)`, `isKeyRepeat(data)`, `KeyEventType` type. Terminals supporting Kitty protocol (Kitty, Ghostty, WezTerm) now send proper key-up events.
-
-## [0.37.0] - 2026-01-05
-
-### Fixed
-
-- Crash when pasting text with trailing whitespace exceeding terminal width through Markdown rendering ([#457](https://github.com/badlogic/pi-mono/pull/457) by [@robinwander](https://github.com/robinwander))
-
-## [0.34.1] - 2026-01-04
-
-### Added
-
-- Symbol key support in keybinding system: `SymbolKey` type with 32 symbol keys, `Key` constants (e.g., `Key.backtick`, `Key.comma`), updated `matchesKey()` and `parseKey()` to handle symbol input ([#450](https://github.com/badlogic/pi-mono/pull/450) by [@kaofelix](https://github.com/kaofelix))
-
-## [0.34.0] - 2026-01-04
-
-### Added
-
-- `Editor.getExpandedText()` method that returns text with paste markers expanded to their actual content ([#444](https://github.com/badlogic/pi-mono/pull/444) by [@aliou](https://github.com/aliou))
-
-Older entries are archived in [packages/tui/CHANGELOG.md@58141d4e5fa8](https://github.com/can1357/oh-my-pi/blob/58141d4e5fa892166024e2168866c45e0baacde3/packages/tui/CHANGELOG.md).
+Older entries are archived in [packages/tui/CHANGELOG.md@fa14205f838f](https://github.com/can1357/oh-my-pi/blob/fa14205f838f282fcea048c64fca74026789a492/packages/tui/CHANGELOG.md).

package/dist/types/apps/debug/log-viewer.d.ts

@@ -15,6 +15,8 @@ type DebugLogViewerModelOptions = {
     processPid?: number;
     hasOlderLogs?: () => boolean;
     loadOlderLogs?: (limitDays?: number) => Promise<string>;
+    /** Most entries kept; older history beyond it is not loaded. Defaults to {@link MAX_LOG_ENTRIES}. */
+    maxLogEntries?: number;
 };
 type ViewerRow = {
     kind: "warning";
@@ -33,6 +35,8 @@ export declare class DebugLogViewerModel {
     #private;
     constructor(logText: string, options?: DebugLogViewerModelOptions);
     get logCount(): number;
+    /** True once the entry cap is reached, so older history no longer loads. */
+    get historyLimitReached(): boolean;
     get visibleLogCount(): number;
     get rows(): readonly ViewerRow[];
     get cursorRowIndex(): number | undefined;

package/dist/types/apps/debug/raw-sse-buffer.d.ts

@@ -41,6 +41,8 @@ export declare function rawSseRecordLines(record: RawSseDebugRecord): string[];
 /** Bounded, observable capture of raw provider responses and SSE frames. */
 export declare class RawSseDebugBuffer {
     #private;
+    /** Bumped on every change to the captured window (append, eviction, clear); equal revisions mean equal snapshots. */
+    get revision(): number;
     subscribe(listener: () => void): () => void;
     recordResponse(response: ProviderResponseMetadata, model?: Model): void;
     recordEvent(event: RawSseEvent, model?: Model): void;

package/dist/types/chat/fence-figure.d.ts

@@ -0,0 +1,42 @@
+/**
+ * A tool call's {@link ToolFigure} drawn under its card, the way assistant
+ * Markdown draws that fence: ```svg as an inline image ({@link SvgFigure}),
+ * redrawn as the body streams; ```mermaid as ASCII art once the body is
+ * final. The card already shows the source, so unlike the assistant's fence
+ * it never falls back to code: {@link FenceFigure.draws} turns down fences
+ * this terminal shows as code, and an svg that does not rasterize stays blank.
+ */
+import type { ImageBudget } from "../components/image.js";
+import type { ToolFigure } from "../tools/renderer.js";
+import type { Component } from "../tui.js";
+/** Fence languages a {@link FenceFigure} draws. */
+export type FenceFigureLang = "svg" | "mermaid";
+export interface FenceFigureOptions {
+    /** Shared inline-image budget for an svg's rasters. */
+    budget?: ImageBudget;
+    /** The figure's rows changed outside a render: a raster landed. */
+    onChange: () => void;
+}
+export declare class FenceFigure implements Component {
+    #private;
+    /**
+     * Whether this terminal draws `figure` now: an svg where inline images show
+     * (`showImages` and a graphics protocol), a closed mermaid fence when
+     * diagram rendering is on and the source renders.
+     */
+    static draws(figure: ToolFigure, options: {
+        showImages: boolean;
+    }): figure is ToolFigure & {
+        readonly lang: FenceFigureLang;
+    };
+    readonly lang: FenceFigureLang;
+    constructor(lang: FenceFigureLang, options: FenceFigureOptions);
+    /** Feed the fence as it stands; its `lang` is this figure's. */
+    update(figure: ToolFigure): void;
+    /** Whether a closed svg's raster is still on its way. */
+    get pending(): boolean;
+    /** The drawing; no rows while an svg draws, or when it does not. */
+    render(width: number): readonly string[];
+    invalidate(): void;
+    dispose(): void;
+}

package/dist/types/chat/svg-figure.d.ts

@@ -1,5 +1,5 @@
 import { type ImageBudget } from "../components/image.js";
-import type { Markdown } from "../components/markdown.js";
+import { type Markdown } from "../components/markdown.js";
 import type { Component } from "../tui.js";
 /** The active theme's color per figure token, for resolving a figure with `prepareSvg`. */
 export declare function svgFigurePalette(): Record<string, string>;

package/dist/types/chat/tool-execution.d.ts

@@ -90,6 +90,8 @@ export declare class ToolExecutionComponent extends Container {
      * component-scoped so the TUI reuses every other root subtree (issue #4377).
      */
     tickSpinner(frame: number): void;
+    /** Whether the result's figure still waits for its raster; the transcript holds retirement meanwhile. */
+    isTranscriptBlockPending(): boolean;
     /**
      * Whether this block is ready to retire as immutable history. Partial
      * results, including detached background tasks, remain active and mutable

package/dist/types/components/editor.d.ts

@@ -1,5 +1,5 @@
 import { type AutocompleteProvider } from "../autocomplete.js";
-import type { TspEditorDecoration, TspTone } from "@oh-my-pi/pi-wire";
+import type { TspEditorDecoration, TspText, TspTone } from "@oh-my-pi/pi-wire";
 import { type DescribeContext, type NativeChild, type NativeNode, type NativeTextEdit, type NativeUiEvent } from "../native/node.js";
 import type { SymbolTheme } from "../symbols.js";
 import { type Component, type Focusable } from "../tui.js";
@@ -106,8 +106,11 @@ export declare class Editor implements Component, Focusable {
      * dialog's text field; only the prompt composer claims `omp.editor`).
      */
     describeLayout: ((input: NativeNode, cx: DescribeContext) => NativeEditorLayout) | undefined;
-    /** TSP placeholder for the empty buffer; natively it replaces the rotating ANSI {@link placeholder} hints. */
-    describePlaceholder: (() => string) | undefined;
+    /**
+     * TSP placeholder for the empty buffer; natively it replaces the rotating ANSI {@link placeholder} hints.
+     * Return a stable value (the same spans array) while it is unchanged: the editor node is reused by identity.
+     */
+    describePlaceholder: (() => TspText) | undefined;
     /** Called with the selected text when Visual mode yanks, so hosts can reach the system
      *  clipboard — `packages/tui` deliberately has no clipboard dependency of its own. */
     onYank?: (text: string) => void;
@@ -250,6 +253,8 @@ export declare class Editor implements Component, Focusable {
     get atoms(): ReadonlyMap<string, string>;
     /** Monotonic buffer-content revision for render caches. Cursor-only movement does not advance it. */
     get textRevision(): number;
+    /** Monotonic atom-table revision for render caches: advances whenever {@link atoms} is mutated or replaced. */
+    get atomsRevision(): number;
     /** Whether the buffer text equals `value`, without `getText()`'s full join —
      *  O(1) for the hot per-keystroke probes against short single-line values. */
     textEquals(value: string): boolean;

package/dist/types/components/markdown.d.ts

@@ -4,16 +4,21 @@ import type { SymbolTheme } from "../symbols.js";
 import type { Component } from "../tui.js";
 /** @internal exported for tests — the grown-line block-kind gate. */
 export declare function fastLineStartHazard(grownLine: string): boolean;
-/** @internal exported for tests — the windowed lexer's first-probe window size. */
-export declare const LEX_WINDOW_BYTES: number;
 /**
  * Lex a whole document with the renderer's rules (math, custom rules,
- * strikethrough), windowing anything large enough for the quadratic scan to
- * bite. `links` holds every reference definition, at any nesting depth. Callers
- * that split a document along its blocks (table charts) lex through this so
- * they see the blocks Markdown renders.
+ * strikethrough). Callers that split a document along its blocks (table
+ * charts) lex through this so they see the blocks Markdown renders.
  */
 export declare function lexDocument(text: string): TokensList;
+/**
+ * `source` as a fenced code block in `lang`: the fence is one backtick longer
+ * than any backtick run in the source (at least three), so the block always
+ * closes where intended. `open` leaves it unclosed, the source verbatim, for
+ * a body that is still arriving.
+ */
+export declare function fencedCode(lang: string, source: string, options?: {
+    open?: boolean;
+}): string;
 /** A hyperlink as the renderer sees it: inline `[text](href)`, `<autolink>`, bare GFM URL, or reference link. */
 export interface MarkdownLink {
     /** Flattened visible label with whitespace collapsed to one row; falls back to `href` when empty. */

package/dist/types/fuzzy.d.ts

@@ -16,6 +16,20 @@ export interface FuzzyFilterResult<T> {
     score: number;
 }
 export declare function fuzzyMatch(query: string, text: string): FuzzyMatch;
+/**
+ * A query normalized and tokenized once for matching against many texts.
+ *
+ * `fuzzyMatch(query, text)` re-normalizes `query` (and rebuilds its
+ * alphanumeric-swap variants) on every call; filters that test one query
+ * against every row should build one `FuzzyQuery` per keystroke instead.
+ * `query.match(text)` returns exactly what `fuzzyMatch(query, text)` returns.
+ */
+export declare class FuzzyQuery {
+    #private;
+    constructor(query: string);
+    /** Same result as `fuzzyMatch(query, text)`; `text` may be a prepared {@link FuzzyText}. */
+    match(text: string | FuzzyText): FuzzyMatch;
+}
 /**
  * A text prepared once for repeated fuzzy matching.
  *
@@ -30,13 +44,13 @@ export declare class FuzzyText {
     #private;
     constructor(text: string);
     /** Match `query` (space-separated tokens; all must match) against the prepared text. */
-    match(query: string): FuzzyMatch;
+    match(query: string | FuzzyQuery): FuzzyMatch;
 }
 /**
  * Items prepared once for repeated {@link fuzzyRank}-equivalent ranking.
  *
- * `fuzzyRank` resolves each candidate's search index through the module cache,
- * which stops admitting entries at {@link INDEX_CACHE_MAX}; larger candidate
+ * `fuzzyRank` resolves each candidate's search index through the bounded module
+ * cache, which holds at most {@link INDEX_CACHE_MAX} entries; larger candidate
  * lists (the full model catalog) rebuild the overflow on every query. Hold one
  * corpus per stable candidate list and call {@link rank} per keystroke instead.
  */

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

@@ -49,7 +49,8 @@ export interface NativeBackendOptions {
  * The reply a v1 terminal is assumed to give before its real `hello` arrives
  * (the `TERM_PROGRAM=tern` optimistic start): the whole vocabulary, the
  * default APC limit and credits, the terminal's width, the appearance omp
- * already detected, and full motion.
+ * already detected, full motion, and `blobs`, so a resumed session's images
+ * are asked about rather than resent before the reply comes.
  */
 export declare function assumedTspHello(terminal: Terminal): TspHello;
 export declare class NativeBackend {

package/dist/types/native/blobs.d.ts

@@ -2,8 +2,10 @@
  * Content-addressed binary blobs (images) for `image` nodes.
  *
  * `describe()` registers the bytes and puts the returned id in `image.p.blob`;
- * the native backend uploads each referenced blob once per surface with verb
- * `b` before the frame that first references it.
+ * the native backend delivers each referenced blob once per terminal
+ * connection (asking the terminal first which it holds, or through its blob
+ * cache), else uploads it with verb `b` before the frame that first
+ * references it.
  */
 import type { TspProps } from "@oh-my-pi/pi-wire";
 import type { NativeNode } from "./node.js";

package/dist/types/native/encode.d.ts

@@ -15,11 +15,10 @@ export type TspIncoming = {
 };
 /** Message parameters (`k=v`, ASCII, never containing `;`). */
 export type TspParams = Readonly<Record<string, string | number>>;
-/** Split `body` into pieces of at most `limit` UTF-8 bytes, never inside a code point. */
-export declare function splitUtf8(body: string, limit: number): string[];
 /**
- * Encode one logical message, chunked when `body` exceeds `limit` UTF-8 bytes.
- * Returns the complete byte string to write (all chunks, in order).
+ * Encode one logical message, chunked when `body` exceeds `limit` UTF-8 bytes:
+ * the first chunk carries `params`, every chunk `c=<id>` and all but the last
+ * `m=1`. Returns the complete byte string to write (all chunks, in order).
  */
 export declare function encodeTspMessage(verb: TspVerb, body: string, params?: TspParams, limit?: number): string;
 /** Encode a JSON message body. */

package/dist/types/overlays/agent-transcript-viewer.d.ts

@@ -31,7 +31,14 @@ export type AgentTranscriptEntry = SessionMessageEntryLike | {
 };
 /** Local filesystem and session parsing capabilities supplied by the host. */
 export interface AgentTranscriptSource {
-    fs: Pick<typeof fs, "openSync" | "closeSync" | "readSync" | "readFileSync" | "statSync">;
+    /**
+     * Sync primitives drive the first paint and the incremental tail. When the
+     * host also supplies `promises.readFile` (e.g. passes `node:fs` itself), full
+     * reloads after rotation/rewrite read the file off the UI thread.
+     */
+    fs: Pick<typeof fs, "openSync" | "closeSync" | "readSync" | "readFileSync" | "statSync"> & {
+        promises?: Pick<typeof fs.promises, "readFile">;
+    };
     parseEntries(text: string): AgentTranscriptEntry[];
 }
 export interface AgentTranscriptViewerDeps {

package/dist/types/overlays/history-search.d.ts

@@ -15,6 +15,13 @@ import type { DescribeContext, NativeNode, NativeUiEvent } from "../native/node.
 export declare class HistorySearchComponent extends OverlayPanel {
     #private;
     constructor(historyStorage: HistorySource, onSelect: (prompt: string) => void, onCancel: () => void);
+    /**
+     * Repaint hook for debounced result updates. Once set, query edits search
+     * storage after a {@link SEARCH_DEBOUNCE_MS} quiet period instead of on
+     * every key; without it every edit searches synchronously.
+     */
+    setOnRequestRender(callback: () => void): void;
+    dispose(): void;
     handleInput(keyData: string): void;
     /**
      * With the `picker` kind: a `size:"md"` sheet of past prompts (first line
@@ -29,6 +36,9 @@ export declare class HistorySearchComponent extends OverlayPanel {
      * Picker: a row click highlights, a second click or `Insert` inserts it
      * (Enter), `Close` cancels (Esc), `Clear search` empties the query.
      * List: picking a result does what highlighting it and pressing Enter does.
+     * A row picked while a debounced search is pending belongs to the previous
+     * query: results are refreshed first and the pick only lands if that entry
+     * is still among them.
      */
     handleNativeEvent(event: NativeUiEvent): void;
 }

package/dist/types/overlays/model-browser.d.ts

@@ -262,6 +262,12 @@ export declare class ModelBrowser implements Component {
     setQuery(query: string): void;
     getSelected(): ModelBrowserItem | undefined;
     get visibleCount(): number;
+    /**
+     * Base items matching the live query, best first, without the separator
+     * row; undefined while the query is blank. Reuses the ranking the list
+     * already ran, so hosts can derive match counts without ranking again.
+     */
+    get queryMatches(): readonly ModelBrowserItem[] | undefined;
     /** Move selection to `selector`; false when it is not in the current view. */
     selectSelector(selector: string): boolean;
     /** True when `item`'s context window is smaller than the live session token count (grayed row; hosts compact before switching). */

package/dist/types/prompt/custom-editor.d.ts

@@ -7,7 +7,7 @@ import type { AppKeybinding } from "../app-keybindings.js";
 import type { DescribeContext, NativeNode, NativeUiEvent } from "../native/node.js";
 import type { ComposerFactsSource } from "../status-line/types.js";
 import { type MacOSSpellingFeatures } from "./macos-spelling.js";
-import type { TspEditorDecoration } from "@oh-my-pi/pi-wire";
+import type { TspEditorDecoration, TspText } from "@oh-my-pi/pi-wire";
 import { type WordCompletionMethod } from "./word-completion.js";
 /** Live composer state the TSP layout shows; the interactive host wires {@link CustomEditor.composerState}. */
 export interface ComposerNativeState {
@@ -26,6 +26,8 @@ export interface ComposerNativeState {
     readonly running: boolean;
     /** The viewed subagent's lineage, outermost first and the viewed agent last; undefined on the main session. */
     readonly viewing?: readonly string[];
+    /** The session's title, quoted in italics as the TSP placeholder; undefined until it has one. */
+    readonly title?: string;
 }
 /** Independently switchable prose-assistance features of the composer. */
 export interface SpellingFeatures extends MacOSSpellingFeatures {
@@ -191,7 +193,8 @@ export declare class CustomEditor extends Editor {
     static readonly SHIMMER_PERIOD_MS = 1800;
     /** Decorate magic keywords, attachments, and the queue-composer header/list markers.
      *  Queue shorthand reserves its first logical line as a dim `Queueing` label; sequential
-     *  item markers use the accent color so separate follow-ups remain visible while composing. */
+     *  item markers use the accent color so separate follow-ups remain visible while composing.
+     *  Called once per layout segment, so whole-buffer inputs are computed once per text revision. */
     decorateText: (text: string, context: EditorTextDecorationContext) => string;
     /**
      * TSP decorations: magic keywords shimmer (terminal-clocked) in the accent
@@ -219,8 +222,8 @@ export declare class CustomEditor extends Editor {
     setShimmerRepaintHandler(handler: (() => void) | undefined): void;
     /** Editing is available during bootstrap; atomic sends wait until submission is wired and enabled. */
     protected get nativeSendable(): boolean;
-    /** Viewing a subagent, the draft goes to it: the placeholder names it. */
-    describePlaceholder: () => string;
+    /** Viewing a subagent, the draft goes to it: the placeholder names it; else the session's title, quoted in italics. */
+    describePlaceholder: () => TspText;
     /** A shell-mode draft highlights as its language. */
     describeLanguage: () => string | undefined;
     /** Host-owned live state for the TSP composer (shell mode, effort chip, send/stop). */

package/dist/types/prompt/interactive-context-helpers.d.ts

@@ -25,7 +25,8 @@ export interface AssistantMessageHost {
         requestRender(): void;
         readonly imageBudget: ImageBudget;
     };
-    resolveAssistantMessageLinks(texts: readonly string[]): Promise<ReadonlyMap<string, string>>;
+    /** Resolve already-extracted Markdown link destinations to local targets. */
+    resolveAssistantMessageLinkHrefs(hrefs: readonly string[]): Promise<ReadonlyMap<string, string>>;
 }
 /**
  * Resolve and cache the current session's model-authored prose links. Existing

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

@@ -39,6 +39,18 @@ export interface ToolRenderResult<TDetails = unknown> {
     details?: TDetails;
     isError?: boolean;
 }
+/**
+ * A fence a tool call draws under its card, as assistant Markdown draws that
+ * fence. Any fence language may be named (`svg`, `mermaid`, `obj`); the
+ * transcript draws only those it draws as figures in assistant text.
+ */
+export interface ToolFigure {
+    readonly lang: string;
+    /** The body so far. */
+    readonly source: string;
+    /** No more of the body arrives. */
+    readonly closed: boolean;
+}
 /**
  * Per-renderer opt-in for a full viewport replay when the first result
  * replaces a painted pending-call render. A predicate receives the painted
@@ -103,6 +115,8 @@ export interface NativeToolView {
     readonly preview?: TspPreview | {
         readonly tail: number;
     } | "none";
+    /** Starts expanded whatever the transcript's expand state (the todo checklist); the user can still fold it. */
+    readonly open?: boolean;
     /** Render frameless (`frame:"inline"`): a head line plus a disclosed body. */
     readonly inline?: boolean;
     /** Head actions offered on hover (`copy`, `retry`). */
@@ -125,6 +139,14 @@ export interface ToolRenderer<TArgs = unknown, TDetails = unknown> {
     /** Semantic result view for TSP terminals; merged with the call view when {@link mergeCallAndResult}. */
     describeResult?(result: ToolRenderResult<TDetails>, options: RenderResultContextOptions, args?: TArgs): NativeToolView | undefined;
     mergeCallAndResult?: boolean;
+    /**
+     * The fence a call draws under its card (a `.svg` being written, as its
+     * image): growing while the args stream, closed once they are final; none
+     * after an error. `result` is undefined until the call has one. Rendered
+     * TUI only, and only fences the terminal draws as figures; native views put
+     * their drawing in their describe hooks.
+     */
+    figure?(args: TArgs, result: ToolRenderResult<TDetails> | undefined, options: RenderResultOptions): ToolFigure | undefined;
     /** Describes current activity without coupling a renderer to terminal layout. */
     activitySummary?(args: TArgs, context: ToolActivityContext): ToolActivitySummary;
     /** Render without background box, inline in the response flow */

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

@@ -236,7 +236,8 @@ export declare class OutputSink {
     constructor(options?: OutputSinkOptions);
     /**
      * Push a chunk of output. The buffer management and onChunk callback run
-     * synchronously. File sink writes are deferred and serialized internally.
+     * synchronously; onChunk fires after the chunk is stored, so {@link preview}
+     * already includes it. File sink writes are deferred and serialized internally.
      *
      * `inline` substitutes a bounded representation for the in-memory buffer and
      * live preview while the complete chunk is mirrored to the artifact.
@@ -260,6 +261,15 @@ export declare class OutputSink {
      * branch in `dump()` against stale totals.
      */
     replace(text: string): void;
+    /**
+     * Current inline view without finalizing: the body {@link dump} would
+     * return right now (head + elision marker + rolling tail), minus any notice
+     * and minus the newline `dump()` appends after output that ends in a bare
+     * carriage return. Each call trims the rolling tail to its budget (a copy
+     * of the tail window once it overflowed), so call it from a throttled
+     * onChunk (`chunkThrottleMs`), not once per raw chunk.
+     */
+    preview(): string;
     dump(notice?: string): Promise<OutputSummary>;
     /**
      * Release the artifact spill descriptor on an exit path that skips

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

@@ -6,7 +6,7 @@ import { type ProcWriteDetails } from "./proc-render.js";
 import { type CfgWriteDetails } from "./cfg-render.js";
 import type { FileDiagnosticsResult } from "./lsp.js";
 import type { OutputMeta } from "./output-meta.js";
-import type { NativeToolView, RenderResultOptions, ToolActivityContext, ToolActivitySummary } from "./renderer.js";
+import type { NativeToolView, RenderResultOptions, ToolActivityContext, ToolActivitySummary, ToolFigure } from "./renderer.js";
 import { type XdevRenderDispatch, type XdevMountedRenderer } from "./xdev.js";
 /** Details returned by the write tool for transcript rendering. */
 export interface WriteToolDetails {
@@ -37,6 +37,12 @@ interface WriteResult {
     details?: WriteToolDetails;
     isError?: boolean;
 }
+/**
+ * The fence a file write draws as while its content streams and after: its
+ * extension names a figure language and it has content, closed once the args
+ * are final. None for URL-card writes, or after an error.
+ */
+declare function writeFigure(args: WriteRenderArgs | undefined, result: WriteResult | undefined, options: RenderResultOptions): ToolFigure | undefined;
 declare const writeStreamingPreviewStateKey: unique symbol;
 /**
  * Per-component state for incrementally rendering a streamed write.
@@ -84,6 +90,7 @@ export declare const writeToolRenderer: {
     describeResult(result: WriteResult, options: RenderResultOptions & {
         renderContext?: WriteRenderContext;
     }, args?: WriteRenderArgs): NativeToolView | undefined;
+    figure: typeof writeFigure;
     mergeCallAndResult: true;
     forceFirstResultViewportRepaint: (args: unknown, options: RenderResultOptions) => boolean;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-tui",
-	"version": "18.7.0",
+	"version": "18.8.0",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://omp.sh",
 	"author": {
@@ -41,14 +41,14 @@
 		"gen:glyphs": "bun scripts/gen-glyphs.ts"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.7.0",
-		"@oh-my-pi/pi-agent-core": "18.7.0",
-		"@oh-my-pi/pi-ai": "18.7.0",
-		"@oh-my-pi/pi-catalog": "18.7.0",
-		"@oh-my-pi/pi-natives": "18.7.0",
-		"@oh-my-pi/pi-utils": "18.7.0",
-		"@oh-my-pi/pi-wire": "18.7.0",
-		"@oh-my-pi/snapcompact": "18.7.0"
+		"@oh-my-pi/omptype": "18.8.0",
+		"@oh-my-pi/pi-agent-core": "18.8.0",
+		"@oh-my-pi/pi-ai": "18.8.0",
+		"@oh-my-pi/pi-catalog": "18.8.0",
+		"@oh-my-pi/pi-natives": "18.8.0",
+		"@oh-my-pi/pi-utils": "18.8.0",
+		"@oh-my-pi/pi-wire": "18.8.0",
+		"@oh-my-pi/snapcompact": "18.8.0"
 	},
 	"devDependencies": {
 		"kitty-vt-wasm": "^0.2.0"