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

package/dist/types/chat/table-chart.d.ts

@@ -0,0 +1,88 @@
+import type { Tokens } from "@oh-my-pi/pi-utils/marked";
+import { type ChartPlan } from "../charts/chart-plan.js";
+import { type TableAnalysis } from "../charts/table-data.js";
+import type { ImageBudget } from "../components/image.js";
+import type { NativeNode } from "../native/node.js";
+import type { Component } from "../tui.js";
+/**
+ * `smart`: a model picks the kind and columns of multi-series tables;
+ * `always`: the local best guess charts every table it reads as numeric;
+ * `off`: tables stay tables.
+ */
+export type TableChartMode = "smart" | "always" | "off";
+/** A multi-series table the host's planner picks a chart for. */
+export interface TableChartRequest {
+    /** The table's Markdown source. */
+    readonly markdown: string;
+    readonly table: TableAnalysis;
+    /** The local best guess; the planner may keep it. */
+    readonly guess: ChartPlan;
+}
+/**
+ * Picks the chart for a multi-series table under `smart`: a plan, or `null`
+ * for no chart. A rejection falls back to the local guess.
+ */
+export type TableChartPlanner = (request: TableChartRequest) => Promise<ChartPlan | null>;
+/** A drawn chart, ready to resolve against the theme. */
+export interface TableChart {
+    /** SVG colored with figure tokens (`var(--accent)`, …). */
+    readonly svg: string;
+    readonly alt: string;
+    /** Size in SVG user units. */
+    readonly width: number;
+    readonly height: number;
+}
+/** The chart under a table: drawn, none, or a smart pick on its way (the promise settles once the cache holds it). */
+export type ChartLookup = TableChart | null | Promise<void>;
+/** One run of a Markdown block: prose (ending at a charted table), or the chart drawn after that table. */
+export type ChartSegment = {
+    readonly kind: "markdown";
+    readonly text: string;
+} | {
+    readonly kind: "chart";
+    readonly table: Tokens.Table;
+};
+/** Set how tables become charts (the host's `tui.autoGraph`) and its `smart` planner; the host rebuilds the transcript after. */
+export declare function setTableCharts(mode: TableChartMode, planner?: TableChartPlanner): void;
+/** How assistant tables currently become charts. */
+export declare function tableChartMode(): TableChartMode;
+/** Whether `markdown` may hold a table {@link splitTableCharts} would chart. */
+export declare function hasChartTable(markdown: string): boolean;
+/**
+ * Split `markdown` after each top-level table that has (or may get) a chart.
+ * A table still streaming at the block's tail is left whole: rows may follow.
+ */
+export declare function splitTableCharts(markdown: string, streaming: boolean): ChartSegment[];
+/**
+ * The chart for `table` under the current mode, read once per table source.
+ * Under `smart` the first lookup of a multi-series table asks the planner.
+ */
+export declare function lookupTableChart(table: Tokens.Table): ChartLookup;
+/**
+ * A native `image` node drawing `chart` from its SVG — no raster — resolved
+ * against the active theme; rebuilt when the theme changes.
+ */
+export declare function describeTableChart(chart: TableChart, key: string): NativeNode;
+export interface TableChartFigureOptions {
+    /** Shared inline-image budget. */
+    budget?: ImageBudget;
+    /** The chart's rows changed outside a text update: its pick or raster landed. */
+    onChange: () => void;
+}
+/**
+ * The chart under one table, as a terminal image a blank row below it. Looks
+ * the chart up on first render — a block rebuilt mid-stream never asks for a
+ * pick it drops — and renders nothing until it is drawn, or when the table
+ * gets no chart.
+ */
+export declare class TableChartFigure implements Component {
+    #private;
+    constructor(options: TableChartFigureOptions);
+    /** Point the figure at `table`. */
+    update(table: Tokens.Table): void;
+    /** Whether the chart is still being looked up, picked or drawn. */
+    get pending(): boolean;
+    render(width: number): readonly string[];
+    invalidate(): void;
+    dispose(): void;
+}

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;
@@ -285,7 +290,7 @@ export declare class Editor implements Component, Focusable {
      *  Mirrors the transient state the key dispatch tears down before this action so the two
      *  cannot diverge: a pending character jump is cancelled by any other key, and an open
      *  spelling-assist popup is dismissed by anything that is not one of its accept keys (its
-     *  debounced refresh skips assist mode, so a surviving list would hang around forever).
+     *  refresh skips assist mode, so a surviving list would hang around forever).
      *  While Vim owns the buffer (Normal or Visual) the operation is Vim's `x` — deleting the
      *  selection and returning to Normal in Visual mode, the grapheme under the cursor
      *  otherwise. Only Insert mode and Vim-off editors delete straight through. */

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

@@ -29,6 +29,8 @@ export interface ImageOptions {
  * synchronously instead of committing its reserved blank rows.
  */
 export declare function renderForScrollback<T>(render: () => T): T;
+/** Widest an {@link Image} rendered at `width` columns draws; callers sizing a raster for it (`SvgFigure`) match it. */
+export declare function imageMaxColumns(width: number): number;
 /** Default count of inline images kept as live graphics before older ones fall back to text. */
 export declare const DEFAULT_MAX_INLINE_IMAGES = 8;
 /**
@@ -73,6 +75,13 @@ export declare class ImageBudget {
      * gets a fresh id every call.
      */
     acquireId(key?: string): number;
+    /**
+     * Retire the graphic held under `key` as soon as no frame shows it, instead
+     * of when the residency sweep reaches it. For an owner that replaced the
+     * image for good — a streaming SVG figure's earlier raster — so superseded
+     * revisions never push older images (scrollback included) out of the store.
+     */
+    release(key: string): void;
     /**
      * Start an alternate-buffer lifecycle. Call once per `?1049h`, before the
      * first pass of the fullscreen overlay or resize borrow that owns the buffer.

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

@@ -1,10 +1,24 @@
+import { type TokensList } from "@oh-my-pi/pi-utils/marked";
 import type { DescribeContext, NativeNode } from "../native/node.js";
 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). 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,7 +44,21 @@ 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 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.
+ */
+export declare class FuzzyCorpus<T> {
+    #private;
+    constructor(items: readonly T[], getText: (item: T) => string);
+    /** Same results as `fuzzyRank(items, query, getText)` for the prepared items. */
+    rank(query: string): FuzzyFilterResult<T>[];
 }
 /**
  * Filter and sort items by fuzzy match quality (best matches first).

package/dist/types/keybindings.d.ts

@@ -107,7 +107,7 @@ export declare const TUI_KEYBINDINGS: {
         readonly description: "Delete word backward";
     };
     readonly "tui.editor.deleteWordForward": {
-        readonly defaultKeys: ["alt+delete", "alt+d", "super+alt+delete", "super+alt+d"];
+        readonly defaultKeys: ["alt+delete", "alt+d", "ctrl+delete", "super+alt+delete", "super+alt+d"];
         readonly description: "Delete word forward";
     };
     readonly "tui.editor.deleteToLineStart": {

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/agents-hub.d.ts

@@ -60,6 +60,15 @@ export interface AgentsHubDeps {
 export interface AgentsHubCallbacks {
     onCancel: () => void;
 }
+/**
+ * Parse model output into a {@link GeneratedAgentSpec}. Accepts a bare JSON object
+ * (tried first) or one wrapped in a code fence. Returns the spec with trimmed fields.
+ * Throws if the output is not valid JSON or not an object, if `identifier`, `whenToUse`
+ * or `systemPrompt` is missing or not a string, if the identifier is not lowercase
+ * kebab-case with 2+ words, if `whenToUse` does not start with "Use this agent when",
+ * or if `systemPrompt` is empty.
+ */
+export declare function parseGeneratedAgentSpec(raw: string): GeneratedAgentSpec;
 /**
  * The fullscreen agents hub component. Hosted via
  * `ui.showOverlay(..., { fullscreen: true })`; the host must call

package/dist/types/overlays/annotation-overlay.d.ts

@@ -1,4 +1,4 @@
-import { type Component, type TUI } from "../index.js";
+import { type Focusable, type TUI } from "../index.js";
 import { type KeybindingsManager } from "../app-keybindings.js";
 import { type Theme } from "../theme/theme.js";
 import type { CodeReviewAnnotation, CodeReviewOverlayResult, ReviewDiffFile, TextReviewAnnotation, TextReviewOverlayResult, TextReviewSource } from "./annotation-types.js";
@@ -18,10 +18,13 @@ export interface TextReviewOverlayCallbacks extends AnnotationOverlayCallbacks {
     onComplete(result: TextReviewOverlayResult | undefined): void;
 }
 /** A fullscreen, annotated diff picker that only relies on public OMP APIs. */
-export declare class AnnotationOverlay implements Component {
+export declare class AnnotationOverlay implements Focusable {
     #private;
+    focused: boolean;
     constructor(tui: TUI, theme: Theme, keybindings: KeybindingsManager, files: readonly ReviewDiffFile[], mode: string, callbacks: CodeReviewOverlayCallbacks);
     constructor(tui: TUI, theme: Theme, keybindings: KeybindingsManager, source: TextReviewSource, callbacks: TextReviewOverlayCallbacks);
+    /** Keep the nested editor's cursor mode aligned with the overlay focus target. */
+    setUseTerminalCursor(useTerminalCursor: boolean): void;
     invalidate(): void;
     dispose(): void;
     getAnnotations(): CodeReviewAnnotation[];

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

@@ -49,6 +49,12 @@ export interface ModelBrowserSource extends ModelRoleLookup {
     readonly knownRoleIds: readonly string[];
     readonly mruOrder: readonly string[];
     readonly modelPerf: ReadonlyMap<string, ModelBrowserPerf>;
+    /**
+     * Service tier the host would send for `model`, when it runs one. Rows with a
+     * measured tier aggregate (`selector@tier`) then display that tier's numbers
+     * instead of the standard aggregate.
+     */
+    serviceTierFor?(model: Model): string | undefined;
     getRoleInfo(role: string): ModelBrowserRoleInfo;
     defaultRoleChain(role: string): string[];
     resolveRoleValue(value: string | undefined, models: Model[], roleLookup?: ModelRoleLookup): ResolvedModelRoleValue;
@@ -134,12 +140,28 @@ export interface SearchAffinity {
  * policy, not evidence of user preference.
  */
 export declare function buildSearchAffinity(providerOrder: ReadonlyArray<string>, roles: RoleAssignments, mruOrder: ReadonlyArray<string>): SearchAffinity;
-/** Rank picker and mention candidates by text relevance, user affinity, and MRU/version order. */
-export declare function rankModelItems(query: string, items: ReadonlyArray<ModelBrowserItem>, options: {
+/** Inputs to {@link rankModelItems} / {@link ModelItemRanker}. */
+export interface ModelRankOptions {
     roles: RoleAssignments;
     mruOrder: ReadonlyArray<string>;
     affinity: SearchAffinity;
-}): ModelBrowserItem[];
+}
+/**
+ * {@link rankModelItems} prepared for one candidate list: the fuzzy index, the
+ * MRU/version order, and the affinity ranks depend only on the items and options,
+ * so per-keystroke callers (composer mentions, `/switch` arguments, the picker)
+ * hold one ranker and pay only the per-query fuzzy scan.
+ */
+export declare class ModelItemRanker {
+    #private;
+    readonly items: ReadonlyArray<ModelBrowserItem>;
+    readonly options: ModelRankOptions;
+    constructor(items: ReadonlyArray<ModelBrowserItem>, options: ModelRankOptions);
+    /** Rank by text relevance, user affinity, and MRU/version order. */
+    rank(query: string): ModelBrowserItem[];
+}
+/** Rank picker and mention candidates by text relevance, user affinity, and MRU/version order. */
+export declare function rankModelItems(query: string, items: ReadonlyArray<ModelBrowserItem>, options: ModelRankOptions): ModelBrowserItem[];
 /**
  * A slim role chip: `● default ◉` — solid dot for configured assignments,
  * hollow for auto-selected fallbacks, thinking glyph attached when set.
@@ -240,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/overlays/plan-review-overlay.d.ts

@@ -13,8 +13,9 @@
  * Focus regions (`toc`/`body`/`actions`) cycle with Tab/Shift+Tab; arrows move
  * within the focused region and step left into the sidebar. The default focus is
  * `actions`, so the muscle memory of the old single-target overlay carries over:
- * ↑/↓ select options, Enter confirms, ←/→ drives the slider when there is no
- * sidebar, g/G + PgUp/PgDn scroll, and the external-editor key opens the plan.
+ * ↑/↓ select options, Enter confirms, ←/→ drives the slider, g/G + PgUp/PgDn
+ * scroll, and the external-editor key opens the plan. Under Tern the options
+ * are a horizontal bar, so ←/→ select options and Shift+←/→ drive the slider.
  */
 import { type Component } from "../index.js";
 import type { HookSelectorSlider } from "./hook-selector.js";

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

@@ -17,13 +17,16 @@ export interface AssistantMessageHost {
     readonly proseOnlyThinking: boolean;
     readonly expandThinkingBlocks: boolean;
     readonly assistantImagesVisible: boolean;
+    /** Whether the viewed session's tables get charts: the main session's do, a focused subagent's do not. */
+    readonly tableChartsVisible: boolean;
     readonly hideToolActivity: boolean;
     readonly toolOutputExpanded: boolean;
     readonly ui: {
         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/prompt/model-mention-autocomplete.d.ts

@@ -19,7 +19,7 @@ export declare function applyModelMentionCompletion(lines: string[], cursorLine:
 };
 /**
  * Create a session-scoped model candidate lookup using picker ordering. The
- * scope and search affinity are reused across queries until their inputs change.
+ * scope and its prepared ranker are reused across queries until their inputs change.
  */
 export declare function createModelMentionSource(host: {
     source: ModelBrowserSource;

package/dist/types/render/composite.d.ts

@@ -0,0 +1,2 @@
+/** Splice overlay content into a base line at a specific column. Single-pass optimized. */
+export declare function compositeLineAt(baseLine: string, overlayLine: string, startCol: number, overlayWidth: number, totalWidth: number): string;

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

@@ -12,6 +12,10 @@ export interface GlobToolDetails {
     fileCount?: number;
     files?: string[];
     truncated?: boolean;
+    /** The scan hit the tool deadline, so the listed files are an incomplete
+     * set rather than a complete answer. Distinct from `truncated`, which also
+     * covers result-limit and output truncation. */
+    timedOut?: boolean;
     error?: string;
     /** Working directory at search time. Used by the renderer to resolve relative
      * file paths to absolute paths for OSC 8 hyperlinks. */

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/dist/types/utils.d.ts

@@ -26,6 +26,12 @@ export interface TextSizingOptions {
  */
 export declare function encodeTextSized(text: string, options?: TextSizingOptions): string;
 export declare function sliceWithWidth(line: string, startCol: number, length: number, strict?: boolean | null): SliceResult;
+/**
+ * Hard-wrap one literal terminal row without trimming spaces or splitting graphemes.
+ * An oversized grapheme is emitted intact even when it exceeds the requested width.
+ * Zero-cell rows remain one empty row, matching restored-terminal reflow.
+ */
+export declare function wrapLiteralLine(line: string, width: number): string[];
 export declare function truncateToWidth(text: string, maxWidth: number, ellipsisKind?: Ellipsis | null | "", pad?: boolean | null): string;
 export declare function wrapTextWithAnsi(text: string, width: number): string[];
 export declare function extractSegments(line: string, beforeEnd: number, afterStart: number, afterLen: number, strictAfter: boolean): ExtractSegmentsResult;