@oh-my-pi/pi-tui 18.6.1 → 18.7.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/user-message.d.ts

@@ -1,7 +1,7 @@
 import { type Component, Container } from "../tui.js";
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 import type { ReactionTarget } from "./reaction.js";
-import { type NativeNode, type NativeUiEvent } from "../native/node.js";
+import { type DescribeContext, type NativeNode, type NativeUiEvent } from "../native/node.js";
 /** How a user bubble styles its prose and chips (see {@link userBubbleColor}). */
 export interface UserBubbleOptions {
     /** Materialized `file://` targets per attached image, indexed by chip number. */
@@ -42,7 +42,7 @@ export declare class UserMessageComponent extends Container implements ReactionT
      * agent's reaction are chips at the bottom-right, so a reaction landing
      * later updates the frame in place, even deep in scrollback.
      */
-    describe(): NativeNode;
+    describe(cx?: DescribeContext): NativeNode;
     /** Hover toolbar clicks: omp's own copy and rewind commands. */
     handleNativeEvent(event: NativeUiEvent): void;
     render(width: number): readonly string[];

package/dist/types/chrome/status-notice.d.ts

@@ -1,14 +1,26 @@
 import type { NativeNode } from "../native/node.js";
 import { Container } from "../tui.js";
+/** How a {@link StatusNotice} shows. */
+export interface StatusNoticeOptions {
+    /** Styles the ANSI line; resolved at render so a theme change re-shapes it. */
+    styleFn?: (text: string) => string;
+    /**
+     * Whether a native terminal toasts it (default). False keeps the notice to
+     * the ANSI transcript: background chatter such as MCP connection progress,
+     * which would otherwise re-toast on every server that connects or fails.
+     */
+    toast?: boolean;
+}
 /**
  * A transient status notice (`showStatus`: "Thinking blocks: hidden", "Copied
  * to clipboard"). The ANSI render appends a blank row and the dim line to the
  * transcript; a native terminal shows it as a toast instead, so notices never
- * pile up in the history. Updating the text re-shows the toast.
+ * pile up in the history. Updating the text re-shows the toast; a notice
+ * with `toast: false` describes nothing natively.
  */
 export declare class StatusNotice extends Container {
     #private;
-    constructor(message: string, styleFn?: (text: string) => string);
-    setMessage(message: string, styleFn?: (text: string) => string): void;
+    constructor(message: string, options?: StatusNoticeOptions);
+    setMessage(message: string, options?: StatusNoticeOptions): void;
     describe(): NativeNode;
 }

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

@@ -285,7 +285,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. */
@@ -330,6 +330,10 @@ export declare class Editor implements Component, Focusable {
      *  {@link getExpandedText}). Hosts that intercept large pastes through {@link onLargePaste} use
      *  this to re-insert a (possibly transformed) paste without re-triggering the interception hook. */
     insertPaste(content: string): void;
+    /** Whether a character-jump hotkey is waiting for its target character. */
+    get isJumpPending(): boolean;
+    /** Type literal text through the character-editing pipeline without keybinding dispatch. */
+    typeCharacter(text: string): void;
     /**
      * Whether an autocomplete popup is on screen. An `@` list narrowed to no match
      * while its refresh is pending stays open internally but is hidden, so it does

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

@@ -16,7 +16,21 @@ export interface ImageOptions {
      * repaint replaces the placement instead of stacking a duplicate.
      */
     imageKey?: string;
+    /**
+     * Schedules a repaint once this image's off-thread SIXEL encode lands.
+     * Defaults to the budget's repaint; a host without a budget must pass one,
+     * or the image's reserved rows stay blank until an unrelated repaint.
+     */
+    requestRender?: () => void;
 }
+/**
+ * Run `render` for rows bound for native scrollback. Those rows are never
+ * repainted, so an image whose off-thread SIXEL encode has not landed encodes
+ * 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;
 /**
@@ -52,6 +66,8 @@ export declare class ImageBudget {
     get cap(): number;
     get enabled(): boolean;
     setRequestRender(requestRender: () => void): void;
+    /** Ask for a repaint, e.g. once an image's off-thread encode settles. */
+    requestRender(): void;
     setCap(cap: number): void;
     /**
      * Stable graphics id for a logical image. A non-empty `key` maps to the same
@@ -59,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/input.d.ts

@@ -28,6 +28,7 @@ export declare class Input implements Component, Focusable {
     setValue(value: string): void;
     setUseTerminalCursor(useTerminalCursor: boolean): void;
     getUseTerminalCursor(): boolean;
+    capturesInput(data: string): boolean;
     /**
      * Apply one key: the editor's text bindings (motion, deletion, kill ring,
      * undo), pastes and printable text. Returns whether the key was the

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

@@ -1,3 +1,4 @@
+import type { KeyId } from "../keys.js";
 import type { DescribeContext, NativeNode, NativeUiEvent } from "../native/node.js";
 import { type ShimmerPalette } from "../theme/shimmer.js";
 import type { TUI } from "../tui.js";
@@ -23,16 +24,14 @@ export interface WorkingRowSpec {
     readonly variant?: WorkingRowVariant;
     /** Shimmer palette of the label (a session-accented intent). */
     readonly palette?: ShimmerPalette;
-    /** Live tok/s, docked before the stop control. */
-    readonly rate?: number;
     /** Key id that interrupts (`escape`); undefined hides the stop control (Esc would not cancel). */
-    readonly interruptKey?: string;
+    readonly interruptKey?: KeyId;
 }
 /**
  * The dock's working row: `starburst` spinner (or a retry countdown ring),
- * the intent shimmering, `·`, the elapsed time, a grow spacer, then the stop
- * control whose click sends `interrupt`. Compaction adds an indeterminate
- * `progress` before the stop control; a retry says "Cancel".
+ * the elapsed time, the `·` divider, the intent shimmering, a grow spacer,
+ * then the stop control whose click sends `interrupt`. Compaction adds an
+ * indeterminate `progress` before the stop control; a retry says "Cancel".
  */
 export declare function describeWorkingRow(spec: WorkingRowSpec, cx: DescribeContext, now?: number): NativeNode;
 type ColorFn = (str: string) => string;

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

@@ -1,3 +1,4 @@
+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";
@@ -5,6 +6,14 @@ import type { Component } from "../tui.js";
 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.
+ */
+export declare function lexDocument(text: string): TokensList;
 /** 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

@@ -32,6 +32,20 @@ export declare class FuzzyText {
     /** Match `query` (space-separated tokens; all must match) against the prepared text. */
     match(query: string): 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
+ * 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).
  * Supports space-separated tokens: all tokens must match.

package/dist/types/key-hint-format.d.ts

@@ -23,6 +23,14 @@ export type KeyName = KeyId | ModifierName;
  * is capitalized. Other keys are capitalized (`f5` → `F5`).
  */
 export declare function formatKeyHint(key: KeyName): string;
+/**
+ * Format one key for a native tooltip (a TSP `title`): unicode keycap glyphs
+ * whatever the theme's symbol preset (`shift+tab` → `⇧⇥`), which Tern's
+ * tooltip splits into keycaps, and `esc` as Tern's own keycaps read. The nerd
+ * preset's icons are missing from Tern's UI font, and its spaced chords would
+ * not parse as keys.
+ */
+export declare function formatTooltipKey(key: KeyName): string;
 /** Format alternative keys as a slash-separated hint (`["f5", "alt+r"]` → `F5/⌥R`). */
 export declare function formatKeyHints(keys: KeyName | readonly KeyName[]): string;
 /** Format a double-tap gesture: `←←` with glyphs, `Left Left` with words. */

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

@@ -83,8 +83,8 @@ export declare class NativeBackend {
      * The terminal's real `hello` reply after an optimistic start: adopt its
      * APC limit, credits, cell size, kinds, appearance and motion preference.
      * A width the terminal already reported in a `resize` event wins over the
-     * reply's. A different vocabulary or motion preference re-describes every
-     * component, so kinds the terminal lacks fall back.
+     * reply's. A different vocabulary, motion preference or clock re-describes
+     * every component, so kinds the terminal lacks fall back.
      */
     confirm(hello: TspHello): void;
     /** SIGWINCH: refresh the width used for `rows` fallback until the terminal reports one. */

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

@@ -71,6 +71,12 @@ export interface DescribeContext {
     readonly reduceMotion: boolean;
     /** The terminal's appearance is dark. */
     readonly dark: boolean;
+    /**
+     * The user's system reads a 12-hour clock (`false`: 24-hour); `undefined`
+     * when the terminal doesn't say. Pass it as `hour12` when formatting times:
+     * the process's own default locale may not know.
+     */
+    readonly hour12?: boolean;
     /** Whether the terminal renders `kind` natively (else describe something simpler or let it fall back). */
     supports(kind: TspKind): boolean;
     /**

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

@@ -7,7 +7,7 @@
  * component's root is a `card` whose `head` carries the title.
  */
 import type { TspProps, TspSpan, TspText } from "@oh-my-pi/pi-wire";
-import type { KeyName } from "../key-hint-format.js";
+import { type KeyName } from "../key-hint-format.js";
 import { type Keybinding } from "../keybindings.js";
 import type { NativeChild, NativeNode } from "./node.js";
 /** One footer hint: the keys that trigger it and what it does. */
@@ -44,10 +44,10 @@ export interface ActionButtonOptions {
     /** Sibling identity key (defaults to the action id); `leafKey(event.key)` reports it back. */
     readonly key?: string;
     /** Key id of the keyboard path the button mirrors, drawn as a keycap inside it (`"r"`, `"ctrl+g"`). */
-    readonly keys?: string;
+    readonly keys?: KeyName;
     /** `accent` = the view's hero action, `error` = destructive. */
     readonly tone?: "accent" | "error";
-    /** Tooltip; defaults to the label plus the keycap (`"Refresh  r"`). */
+    /** Tooltip; defaults to the label plus the keycap (`"Refresh  r"`, see {@link formatTooltipKey}). */
     readonly title?: string;
     /** Target of an `open` action (URL or `file://` path). */
     readonly href?: string;

package/dist/types/overlays/agent-hub.d.ts

@@ -73,6 +73,7 @@ export interface AgentHubDeps<TRecord extends AgentRecordLike = AgentRecordLike>
     /** Mirrors the main transcript's thinking-block visibility. */
     hideThinkingBlock?: () => boolean;
     proseOnlyThinking?: () => boolean;
+    expandThinkingBlocks?: () => boolean;
     /** Keys toggling tool output expansion (app.tools.expand). */
     expandKeys?: KeyId[];
     /** Focus the main view on this agent's live session (ctx.focusAgentSession). When absent (collab guest, tests), Enter opens the in-hub chat view instead. */

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

@@ -54,6 +54,7 @@ export interface AgentTranscriptViewerDeps {
     cwd: string;
     hideThinkingBlock?: () => boolean;
     proseOnlyThinking?: () => boolean;
+    expandThinkingBlocks?: () => boolean;
     expandKeys: KeyId[];
     /** Keys that toggle the whole hub closed (app.agents.hub + app.session.observe). */
     hubKeys: KeyId[];

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/btw-history-panel.d.ts

@@ -1,6 +1,7 @@
 import { type Component, type Focusable, Input } from "../index.js";
 import { type BtwHistoryRecord } from "./btw-history.js";
 import type { SpaceHoldHandler } from "../space-hold.js";
+import { type KeyId } from "../app-keybindings.js";
 import type { NativeNode, NativeUiEvent } from "../native/node.js";
 interface BtwHistoryPanelOptions {
     records: readonly BtwHistoryRecord[];
@@ -9,7 +10,8 @@ interface BtwHistoryPanelOptions {
     onCancel: (record: BtwHistoryRecord) => void;
     canFollowUp?: (record: BtwHistoryRecord) => boolean;
     onFollowUp?: (record: BtwHistoryRecord, question: string, signal: AbortSignal) => Promise<boolean>;
-    /** Space-bar push-to-talk for a follow-up composer: dictates into `input` while Space is held. */
+    /** Configured push-to-talk keys for a follow-up composer. */
+    spaceHoldKeys?: readonly KeyId[];
     spaceHold?: (input: Input) => SpaceHoldHandler;
     requestRender: () => void;
     getHeight: () => number;
@@ -33,6 +35,8 @@ export declare class BtwHistoryPanel implements Component, Focusable {
     openFollowUp(recordId: string): boolean;
     /** Select a record with its answer pane focused, read from the top (a just-asked /btw). */
     showRecord(recordId: string): void;
+    /** Only an active follow-up composer can claim its configured push-to-talk keys. */
+    capturesInput(data: string): boolean;
     /** Enhanced clipboard pastes belong only to the active composer. */
     pasteText(text: string): void;
     handleInput(data: string): void;

package/dist/types/overlays/copy-selector.d.ts

@@ -31,6 +31,7 @@ export interface CopySelectorDeps {
     cwd: string;
     hideThinkingBlock?: () => boolean;
     proseOnlyThinking?: () => boolean;
+    expandThinkingBlocks?: () => boolean;
     linkTargets?: ReadonlyMap<string, string>;
     requestRender: () => void;
     /** Replaces the "Copy" header when the picker is reused for another purpose. */

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.

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/overlays/rewind-selector.d.ts

@@ -48,6 +48,7 @@ export interface RewindSelectorDeps {
     cwd: string;
     hideThinkingBlock?: () => boolean;
     proseOnlyThinking?: () => boolean;
+    expandThinkingBlocks?: () => boolean;
     linkTargets?: ReadonlyMap<string, string>;
     requestRender: () => void;
     /** Sibling branch paths of `entryId`'s turn (excluding the turn itself). */

package/dist/types/overlays/usage-dashboard.d.ts

@@ -121,12 +121,12 @@ export declare class UsageDashboardComponent implements Component {
      * The sheet body (the terminal's `lg` overlay is the frame): a head row
      * (checked ago, Overview/Details tabs, Refresh), then either the provider
      * grid of frames with window meters and the activity heatmap, or the
-     * per-provider detail tables. `meter`/`chart` fall back to
-     * `progress`/`table` on terminals without them. Rebuilt only when its
-     * inputs change.
+     * per-provider detail tables, then Close like the other report sheets.
+     * `meter`/`chart` fall back to `progress`/`table` on terminals without
+     * them. Rebuilt only when its inputs change.
      */
     describe(cx: DescribeContext): NativeNode;
-    /** Tab clicks switch views like Enter/Esc; the Refresh button runs `r`. */
+    /** Tab clicks switch views like Enter/Esc; the Refresh button runs `r`; Close closes from either view. */
     handleNativeEvent(event: NativeUiEvent): void;
     handleInput(data: string): void;
 }

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

@@ -18,6 +18,10 @@ export interface ComposerNativeState {
     };
     /** Thinking effort word (`high`, `off`, `auto`); undefined when the model has no thinking. */
     readonly thinking?: string;
+    /** The thinking level draws as the model chip's icon instead of its own chip (where the terminal has `effort`). */
+    readonly thinkingInModel?: boolean;
+    /** Generation tok/s after the thinking level (live while running, else the last reading); undefined hides it. */
+    readonly rate?: number;
     /** A turn is running: the send keycap becomes a Stop button. */
     readonly running: boolean;
     /** The viewed subagent's lineage, outermost first and the viewed agent last; undefined on the main session. */
@@ -229,7 +233,8 @@ export declare class CustomEditor extends Editor {
      * The TSP composer: role `omp.editor[.bash|.python]` (tone `pending` while
      * a turn runs) over the context hairline, the viewing header while a
      * subagent is focused, the attachment chips, a `line` row of the
-     * shell-mode chip and the input, and the `bar`: model chip, effort chip,
+     * shell-mode chip and the input, and the `bar`: model chip, effort chip
+     * (or the effort glyph as the model chip's icon), the generation rate,
      * the other status facts, usage, then send (Stop while a turn runs).
      * Clicks come back as `status.model`, `thinking.cycle`, `submit`,
      * `interrupt` and `focus:<id>` actions.
@@ -271,9 +276,9 @@ export declare class CustomEditor extends Editor {
     onLeftAtStart?: () => void;
     /** Called when the viewing header asks to view agent `id` ({@link MAIN_AGENT_ID}: the main session). */
     onFocusAgent?: (id: string) => void;
-    /** Space-bar push-to-talk; set its `handler` to enable it. It is a text-composition gesture, so it
-     *  stays out of Vim's Normal/Visual modes (where the space bar is the `l` motion) and away from an
-     *  open autocomplete menu. */
+    /** Configurable push-to-talk; set its `handler` to enable it. It is a text-composition gesture, so
+     *  it stays out of Vim's Normal/Visual modes (where the space bar is the `l` motion), away from an
+     *  open autocomplete menu, and out of a pending character jump (whose target may be the key). */
     readonly spaceHold: SpaceHoldGesture;
     setActionKeys(action: ConfigurableEditorAction, keys: KeyId[]): void;
     /**
@@ -288,6 +293,7 @@ export declare class CustomEditor extends Editor {
      * Clear all custom key handlers.
      */
     clearCustomKeyHandlers(): void;
+    capturesInput(data: string): boolean;
     handleInput(data: string): void;
     /**
      * Route a keystroke through the base text-editor pipeline only, skipping the

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

@@ -15,7 +15,10 @@ export interface AssistantMessageHost {
     readonly viewSession: AssistantMessageSession;
     readonly effectiveHideThinkingBlock: boolean;
     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: {

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;