@oh-my-pi/pi-tui 18.8.8 → 18.9.0

package/dist/types/charts/chart-svg.d.ts

@@ -6,13 +6,39 @@
  * so the host resolves them against the live theme (`prepareSvg`) for both
  * the rasterized terminal image and the native TSP blob.
  *
- * Geometry follows the terminal: 16 user units per row and a monospace face,
- * so 13-unit labels land near the terminal's own glyph size. Marks are flat
- * and square (no rounding, gradients or shadows); bolded table cells draw at
- * full strength while their neighbours recede.
+ * Styled after Apple's charts and Tern's UI: a UI sans (Geist where Tern
+ * provides it), muted labels, hairline gridlines that recede behind the
+ * marks, bars and cells with rounded corners, smooth lines (over a soft area
+ * fill where the axis starts at zero), dot legends, one hue across small
+ * multiples' columns with gray for context. 13-unit labels land near the terminal's own glyph size
+ * at 16 user units per row; bolded table cells draw at full strength while
+ * their neighbours recede. Grouped categories ({@link ChartSpec.groups}) name
+ * each group once beside its members, the groups parted by a gap; a name too
+ * long for its column wraps to two lines ({@link categoryLabels}). A few
+ * outliers far above the rest break a bar axis instead of flattening it
+ * ({@link outlierTier}); reference rows ({@link ChartSpec.reference}) draw a
+ * dashed rule through their group.
+ *
+ * Every chart opens with a header ({@link drawHeader}): the semibold title a
+ * planner set ({@link ChartSpec.title}, the one fact worth stating; its key
+ * figure in the accent), a muted
+ * note on how the data is encoded, and the series key right-aligned on the
+ * title's line when it fits. Marks size to
+ * the row count ({@link barMetrics}); strong heat cells and share segments
+ * print their figures in a theme-adaptive dark {@link ink}. Reusable
+ * annotation primitives — {@link band}, {@link referenceRule},
+ * {@link callout} — draw the {@link ChartSpec.annotations} a planner lays on.
+ *
+ * Axes tick on round steps in one unit (`0, 2, 4` for counts, `50s, 100s`,
+ * `25 GiB` where the table wrote binary sizes, thousands separated). Meaning
+ * layers on top: each contest's best value carries a quiet `best` tag (an
+ * outline in a heatmap), estimates (`~15`) among measured figures draw as
+ * dashed, faint bars ({@link barRect}), moves of a measure with a polarity read in `success`
+ * or `error` (transitions, factors, signed deltas), and status cells badge
+ * their row's name with a colored dot keyed under the chart.
  */
-import type { ChartSpec } from "./chart-plan.js";
-import type { Dimension } from "./table-data.js";
+import { type ChartSpec } from "./chart-plan.js";
+import { type Dimension } from "./table-data.js";
 /** A drawn chart: the SVG document and its size in user units. */
 export interface ChartSvg {
     readonly svg: string;
@@ -24,7 +50,10 @@ export declare function renderChartSvg(spec: ChartSpec): ChartSvg;
 /** One-line description of the chart, for screen readers and terminals that show the alt text. */
 export declare function chartAlt(spec: ChartSpec): string;
 /**
- * A value in base units as an axis label: durations and sizes in the unit
- * their magnitude reads best in, counts compacted (`12k`, `3.4M`).
+ * A value in base units as an axis label: durations and sizes in the unit,
+ * counts compacted under the suffix (`12k`, `3.4M`), that `magnitude` reads
+ * best in — the value's own size by default, an axis' largest tick to keep
+ * its labels in one unit. Sizes read in decimal units (`20 GB`), or binary
+ * ones (`16 GiB`) when `unit` is `iB`.
  */
-export declare function formatValue(value: number, dim: Dimension, unit: string): string;
+export declare function formatValue(value: number, dim: Dimension, unit: string, magnitude?: number): string;

package/dist/types/charts/table-data.d.ts

@@ -42,8 +42,23 @@ export interface NumberCell {
     readonly toFigure?: string;
     /** `a–b`: `b`, in the same base units. */
     readonly upper?: number;
-    /** `a/b`: `b`. */
+    /**
+     * `a/b`: `b`. {@link analyzeTable} reads a score (`12/12`, `154/160`, a mean
+     * like `0.6/4`) as the percent of `b` reached, unless its column also holds a
+     * plain fraction; a pair (`85 / 147` under `Edit / read calls`) keeps `a`.
+     */
     readonly denominator?: number;
+    /**
+     * `a ± e` (`3.67s ± 0.69`, `~404ms ± 60`, `$0.72 (±0.16)`): `e`, in the same base units — the
+     * spread the table states around the value; {@link figure} then writes both (`3.67s ± 0.69`).
+     */
+    readonly error?: number;
+    /**
+     * A slash list of measurements in one unit (`79 / 124 µs`, `1,864 ms /
+     * 2,678 ms`, `**675ms** / 680ms`): every listed value, the first included,
+     * in base units, 2–4 of them. `value` is the first.
+     */
+    readonly values?: readonly number[];
 }
 /** A cell that is not a quantity. */
 export interface OtherCell {
@@ -70,17 +85,49 @@ export interface TableColumn {
     readonly unit: string;
     /** Numeric cells disagree on dimension (a metric-per-row table). */
     readonly mixed: boolean;
+    /** Numeric cells are mostly scores out of a total (`12/12`), read as percent of it. */
+    readonly scores: boolean;
+    /**
+     * Per row, the status its cell leads with ({@link cellStatus}), when most
+     * of the column's cells lead with one: a pass/fail or progress column.
+     */
+    readonly statuses?: readonly (Status | undefined)[];
     /** Every numeric data cell holds the same value: an echoed setting, not a measure. */
     readonly constant: boolean;
     /** Share of numeric cells written with an explicit sign. */
     readonly signedShare: number;
     /** Share of numeric cells written as `a → b`. */
     readonly arrowShare: number;
+    /**
+     * Index of the measure column this one restates, read from the values: a
+     * proportional copy (`pass` 33/38 beside `pass%` 87%, `Samples` beside `% of
+     * Total`, `Leverage vs $200` beside the cost) or a running total of it
+     * (`Offset` summing `Verts`). Such a column is never a measure of its own.
+     */
+    readonly restates?: number;
+}
+/**
+ * Measure columns that add up, read from the values: leaf `parts` summing to
+ * `whole` in every row (`Cached + Uncached input = Input`, `Input + Output =
+ * Total` → parts Cached, Uncached input, Output of Total), or — when not
+ * `exact` — parts falling within a `Total` column, the rest unlisted (`New +
+ * Edited ≤ Prose total`).
+ */
+export interface Composition {
+    /** Column the parts make up; absent when only a judge says the parts form a whole. */
+    readonly whole: number | undefined;
+    /** Leaf part columns, in table order. */
+    readonly parts: readonly number[];
+    /** The parts sum to the whole within the written precision in every row. */
+    readonly exact: boolean;
 }
 /** A table read for charting. */
 export interface TableAnalysis {
     readonly columns: readonly TableColumn[];
-    /** Category labels: the first text or temporal column, else a sequence or index column. */
+    /**
+     * Category labels: the first text or temporal column not made only of codes
+     * (`#2233`, `00`), else the first text column, else a sequence or index column.
+     */
     readonly label: TableColumn | undefined;
     /** Plottable measure columns, constant ones excluded. */
     readonly measures: readonly TableColumn[];
@@ -88,7 +135,21 @@ export interface TableAnalysis {
     readonly rows: readonly number[];
     /** Total/summary rows (`Total`, `Average`, …), kept out of the scale. */
     readonly totals: readonly number[];
+    /** Measure columns adding up to a whole, when the values show it. */
+    readonly composition?: Composition;
 }
+/**
+ * What a status cell (`ok`, `FAIL`, `pending`, ✅) says about its row: `good`
+ * passed or landed, `bad` failed or broke, `warn` partly or flaky, `pending`
+ * not settled yet.
+ */
+export type Status = "good" | "bad" | "warn" | "pending";
+/**
+ * The status a cell's text leads with (`FAIL`, `✓ via mmdc`, `**pending**`,
+ * `1 ok`), or `undefined` for any other text. A count before the word
+ * (`3 ok`) still reads as the word's status.
+ */
+export declare function cellStatus(text: string): Status | undefined;
 /**
  * Strip inline Markdown from a cell: links keep their text; bold, italics,
  * strikethrough, code spans and `<br>` keep their content.
@@ -101,6 +162,13 @@ export declare function plainCell(markdown: string): {
 export declare function parseCell(markdown: string): Cell;
 /** Read a table's columns and rows for charting. Cells are the raw Markdown of each cell. */
 export declare function analyzeTable(header: readonly string[], rows: readonly (readonly string[])[]): TableAnalysis;
+/**
+ * Half the last written digit of `cell`, in base units (`6,313k` → 500,
+ * `38.5%` → 0.05): how far its value may sit from the exact quantity it
+ * rounds. A score (`33/38` read as percent) and a whole count written in full
+ * (`46`, `1,980`) are exact.
+ */
+export declare function writtenSlack(cell: NumberCell): number;
 /** Strictly increasing or strictly decreasing. */
 export declare function isMonotonic(values: readonly number[]): boolean;
 /** Whether `cell` reads as a number. */

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

@@ -5,12 +5,13 @@ 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;
+ * `smart`: a model refines the local guess where meaning decides (kind,
+ * columns, row names, ordering, polarity, focus, title; see {@link shouldJudge});
  * `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. */
+/** A table the host's planner picks a chart for ({@link shouldJudge}). */
 export interface TableChartRequest {
     /** The table's Markdown source. */
     readonly markdown: string;

package/dist/types/chat/user-message.d.ts

@@ -1,3 +1,4 @@
+import type { AnimationFrame, TranscriptPresentationTarget } from "../chrome/transcript-container.js";
 import { type Component, Container } from "../tui.js";
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 import type { ReactionTarget } from "./reaction.js";
@@ -30,7 +31,7 @@ export declare function userBubbleColor(options?: UserBubbleOptions, tokenRegex?
  * (see {@link ReactionTarget}) drawn right-aligned in the bubble's top padding row;
  * a live-steered message carries a `*` marker left-aligned in the same row.
  */
-export declare class UserMessageComponent extends Container implements ReactionTarget {
+export declare class UserMessageComponent extends Container implements ReactionTarget, TranscriptPresentationTarget {
     #private;
     constructor(text: string, options?: UserBubbleOptions);
     releaseRenderCaches(): void;
@@ -46,6 +47,16 @@ export declare class UserMessageComponent extends Container implements ReactionT
     describe(cx?: DescribeContext): NativeNode;
     /** Hover toolbar clicks: omp's own copy and rewind commands. */
     handleNativeEvent(event: NativeUiEvent): void;
+    /** Apply the transcript allocator's current viewport reservation. */
+    setTranscriptAllocation(rows: number, _frame?: AnimationFrame): void;
+    isTranscriptBlockFinalized(): boolean;
+    /**
+     * Single-row emergency representation for the overflow transcript layout:
+     * renders the first content line instead of the blank top padding row, and
+     * omits OSC 133 shell integration markers so moving live blocks across the
+     * viewport does not leave stale prompt marks on lines it no longer occupies.
+     */
+    renderTranscriptBlockEmergencyRow(width: number): string | undefined;
     render(width: number): readonly string[];
 }
 /**

package/dist/types/chrome/shared.d.ts

@@ -1,5 +1,14 @@
 import type { TabBarTheme } from "../components/tab-bar.js";
 /** Compact single-line display text for statuses; unlike titles, collapse padding and trim. */
 export declare function sanitizeStatusText(text: string): string;
+/**
+ * Like {@link sanitizeStatusText}, but keeps 7-bit SGR so extensions can colour
+ * `ctx.ui.setStatus` text. Every other escape (OSC links/titles, DCS/PM/APC,
+ * 7- and 8-bit CSI), C0/C1, lone surrogates, newlines and tabs are sanitized at
+ * least as strictly as in `sanitizeStatusText`; space runs collapse and edges
+ * trim (`String#trim` whitespace) by visible text, regardless of SGR placement.
+ * A styled result always ends with `\x1b[0m`.
+ */
+export declare function sanitizeHookStatusText(input: string): string;
 /** Shared tab bar theme used by fullscreen overlays (settings, agent hub). */
 export declare function getTabBarTheme(): TabBarTheme;

package/dist/types/chrome/transcript-container.d.ts

@@ -63,6 +63,7 @@ export interface TranscriptViewportSpan {
 export declare class TranscriptContainer extends Container {
     #private;
     addChild(component: Component): void;
+    /** Removes `component` if {@link canRemoveBlock} allows it; otherwise does nothing. */
     removeChild(component: Component): void;
     clear(): void;
     setToolActivityVisible(visible: boolean): void;

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

@@ -149,6 +149,12 @@ export declare class Editor implements Component, Focusable {
      *  cursor. The host styles it (ANSI allowed). Re-evaluated on every render, so hosts can derive
      *  it from live state. */
     placeholder?: () => string | undefined;
+    /** Whole-message prediction for the next prompt, painted as ghost text after the cursor while
+     *  the single-line buffer is a strict prefix of it, the cursor sits at its end, and no
+     *  autocomplete is open. A shown prediction replaces the {@link placeholder}; Tab or Right inserts
+     *  the rest without submitting. Must be a single line. Re-evaluated on every render, so hosts can
+     *  derive it from live state. */
+    prediction?: () => string | undefined;
     constructor(theme: EditorTheme);
     /** Return bounded editor content, cursor, and transient child state for debug inspection. */
     debugState(): Record<string, unknown>;

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

@@ -44,6 +44,7 @@ export declare class FormField implements Component, Focusable, MouseRoutable {
     /** Label, description, details, preview, the control, error, summary, hint and footer as one column. */
     describe(_cx: DescribeContext): NativeNode;
     get focused(): boolean;
+    get hasError(): boolean;
     get debugChildren(): readonly Component[];
     set focused(value: boolean);
     setUseTerminalCursor(useTerminalCursor: boolean): void;

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

@@ -53,6 +53,13 @@ export declare function clearRenderCache(): void;
 export interface DefaultTextStyle {
     /** Foreground color function */
     color?: (text: string) => string;
+    /**
+     * The `color` foreground is prose-level: semantically-themed markdown spans
+     * (headings, links) keep their own `md*` theme colors instead of being
+     * painted over by it, while plain text runs still use `color`. Unset keeps
+     * the historical behavior where `color` paints every run.
+     */
+    proseFg?: boolean;
     /** Background color function */
     bgColor?: (text: string) => string;
     /** Bold text */

package/dist/types/components/tree-view.d.ts

@@ -34,6 +34,13 @@ export interface FlattenTreeOptions<T, K extends TreeKey> {
     rootDepth?: number;
     /** Override the display depth inherited by direct children. */
     getChildDepth?: (item: T, row: TreeRow<T, K>, children: readonly T[]) => number;
+    /**
+     * Reuse the parent ancestor list when a child keeps the same display depth
+     * and the current item has no siblings (`siblingCount === 1`). Otherwise
+     * retain the current item as an ancestor so connector gutters remain
+     * accurate, including when the item has multiple children.
+     */
+    compactSameDepthAncestors?: boolean;
     /** Stop projection after this many structural items. Omit for no traversal cap. */
     maxItems?: number;
 }

package/dist/types/kitty-graphics.d.ts

@@ -30,8 +30,8 @@ export interface KittyGraphicsFeatures {
  * cannot use cursor-positioned placements because the outer terminal does not
  * know pane scroll/reflow state. An explicit `PI_FORCE_IMAGE_PROTOCOL=kitty`
  * opts into placeholders under any multiplexer — matching `timg -pk`.
- * Automatic Herdr fallback stays off because its pane marker does not prove
- * that the experimental Kitty renderer is enabled.
+ * Automatic fallback stays off inside multiplexers whose pane marker does not
+ * prove that a Kitty renderer is enabled (Herdr's is experimental).
  *
  * `PI_NO_KITTY_PLACEHOLDERS=1` and `PI_KITTY_PLACEHOLDERS=0` remain hard
  * opt-outs; `PI_KITTY_PLACEHOLDERS=1` explicitly opts in anywhere else.

package/dist/types/loop-watchdog.d.ts

@@ -21,13 +21,14 @@ interface LoopWatchdogTimer {
     cancel?(): void;
 }
 /**
- * Always-on event-loop lag probe. Each tick is scheduled `intervalMs` ahead of
- * a recorded deadline; a tick that fires `thresholdMs` past its deadline means
- * the loop was blocked that long. The overshoot is logged once on the rising
- * edge (one block ⇒ one line, deduped via `#wasBlocked`), tagged with the phase
- * active during the elapsed interval via {@link takeRecentLoopPhase} — which
- * survives the synchronous push/pop the instrumented hot paths do before this
- * delayed tick can run — so the stall names its cause instead of "unknown".
+ * Always-on event-loop lag probe. Each tick is scheduled `intervalMs` ahead,
+ * with that target recorded as its deadline; a tick that fires `thresholdMs`
+ * past its deadline means the loop was blocked that long. The overshoot is
+ * logged once on the rising edge (one block ⇒ one line, deduped via
+ * `#wasBlocked`). Attribution via
+ * {@link takeLoopPhaseAttribution} totals each innermost phase only after the tick's
+ * deadline. A phase is named, with `phaseMs`, only when its total outweighs all
+ * unlabeled time in that late window; otherwise the block remains "unknown".
  *
  * The handle is `unref`'d so the probe never keeps the process alive, and stop()
  * cancels the armed timer when the handle exposes `cancel` (the default

package/dist/types/multiplexers/cmux.d.ts

@@ -0,0 +1,16 @@
+export declare const cmuxMultiplexer: {
+    readonly id: "cmux";
+    readonly precedence: "session";
+    readonly sessionEnvKeys: readonly ["CMUX_WORKSPACE_ID", "CMUX_SURFACE_ID", "CMUX_REMOTE_TRANSPORT"];
+    readonly ownsScreenGrid: true;
+    readonly isInside: (env?: NodeJS.ProcessEnv) => boolean;
+    /**
+     * Workspace/socket state alone is not enough: only the injected surface UUID
+     * identifies the pane that should receive the notification. Without a valid
+     * surface, or without the binary, delivery falls through unchanged.
+     */
+    readonly notifier: {
+        readonly tier: "surface";
+        readonly send: ({ message, env }: import("./types.js").TerminalMultiplexerNotificationRequest) => boolean;
+    };
+};

package/dist/types/multiplexers/herdr.d.ts

@@ -0,0 +1,26 @@
+export declare const herdrMultiplexer: {
+    readonly id: "herdr";
+    readonly precedence: "session";
+    readonly sessionEnvKeys: readonly ["HERDR_ENV", "HERDR_PANE_ID", "HERDR_TAB_ID", "HERDR_WORKSPACE_ID"];
+    readonly ownsScreenGrid: true;
+    readonly isInside: (env?: NodeJS.ProcessEnv) => boolean;
+    /**
+     * Herdr multiplexes panes like tmux but swallows bare OSC 9 / OSC 99 and has
+     * no DCS passthrough envelope, and its bell relay does not flag a
+     * backgrounded tab — so without its CLI a backgrounded pane gets no signal
+     * at all that the agent finished or is waiting for input.
+     *
+     * `sound` maps the notification kind onto what Herdr offers: a question
+     * waiting on the user and a turn that stopped with an error both need the
+     * human and ring `request`, a settled turn rings `done`, anything else stays
+     * silent. The exact pane ID addresses the CLI call; without a valid one, or
+     * without the binary, delivery falls through.
+     */
+    readonly notifier: {
+        readonly tier: "pane";
+        readonly send: ({ message, env }: import("./types.js").TerminalMultiplexerNotificationRequest) => boolean;
+    };
+    readonly hyperlinks: "render";
+    readonly honorsSynchronizedOutput: true;
+    readonly imagesRequireOverride: true;
+};

package/dist/types/multiplexers/notify.d.ts

@@ -0,0 +1,13 @@
+import type { TerminalNotification } from "../terminal-capabilities.js";
+/** Title for out-of-band multiplexer notifications that carry none of their own. */
+export declare const DEFAULT_NOTIFICATION_TITLE = "omp";
+/** Title and body for an out-of-band multiplexer notification (cmux, Herdr). */
+export declare function notificationTitleAndBody(message: string | TerminalNotification): {
+    title: string;
+    body: string;
+};
+/**
+ * Start a notifier CLI without waiting for or pinning it. Returns false when
+ * the binary cannot be spawned, which leaves delivery to the terminal fallback.
+ */
+export declare function spawnNotifier(cmd: string[]): boolean;

package/dist/types/multiplexers/orca.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Orca is an xterm.js-based IDE whose terminals expose paired pane/worktree IDs.
+ * It is recognized for launches, but it ranks below nested multiplexers and keeps
+ * the direct-terminal render path it used before it was recognized.
+ */
+export declare const orcaMultiplexer: {
+    readonly id: "orca";
+    readonly precedence: "outerApp";
+    readonly sessionEnvKeys: readonly ["ORCA_PANE_KEY", "ORCA_WORKTREE_ID"];
+    readonly ownsScreenGrid: false;
+    readonly isInside: (env?: NodeJS.ProcessEnv) => boolean;
+};

package/dist/types/multiplexers/screen.d.ts

@@ -0,0 +1,9 @@
+export declare const screenMultiplexer: {
+    readonly id: "screen";
+    readonly precedence: "session";
+    readonly sessionEnvKeys: readonly ["STY"];
+    readonly termPrefix: "screen";
+    readonly ownsScreenGrid: true;
+    readonly isInside: (env?: NodeJS.ProcessEnv) => boolean;
+    readonly hyperlinks: "drop";
+};

package/dist/types/multiplexers/tmux.d.ts

@@ -0,0 +1,29 @@
+/** Wrap a control sequence in tmux's DCS passthrough envelope. */
+export declare function wrapTmuxPassthrough(payload: string): string;
+export declare const tmuxMultiplexer: {
+    readonly id: "tmux";
+    readonly precedence: "session";
+    readonly sessionEnvKeys: readonly ["TMUX"];
+    readonly termPrefix: "tmux";
+    readonly ownsScreenGrid: true;
+    readonly isInside: (env?: NodeJS.ProcessEnv) => boolean;
+    readonly notifier: {
+        readonly tier: "inBand";
+        readonly send: ({ sequence, write }: import("./types.js").TerminalMultiplexerNotificationRequest) => boolean;
+    };
+    readonly hyperlinks: {
+        readonly forward: {
+            readonly termProgram: "tmux";
+            readonly major: 3;
+            readonly minor: 4;
+        };
+    };
+    readonly backgroundColorCache: {
+        readonly passthrough: typeof wrapTmuxPassthrough;
+        readonly settleMs: 100;
+    };
+    readonly expandsRepPadding: true;
+    readonly expiresSynchronizedOutput: true;
+    readonly altRestoreEndsSynchronizedOutput: true;
+    readonly growsBeforeSigwinch: true;
+};

package/dist/types/multiplexers/types.d.ts

@@ -0,0 +1,100 @@
+import type { TerminalNotification } from "../terminal-capabilities.js";
+/**
+ * Classification tier. `session` markers outrank the TERM fallback; `outerApp`
+ * hosts rank below it so a multiplexer nested inside them still wins.
+ */
+export type TerminalMultiplexerPrecedence = "session" | "outerApp";
+/**
+ * Notification delivery tier, tried in this order so the innermost target wins:
+ * a `pane` notifier addresses the exact pane through the multiplexer's CLI, a
+ * `surface` notifier addresses the containing app surface, and an `inBand`
+ * notifier rewrites the terminal's own notification sequence.
+ */
+export type TerminalMultiplexerNotificationTier = "pane" | "surface" | "inBand";
+/** One notification offered to a multiplexer notifier. */
+export interface TerminalMultiplexerNotificationRequest {
+    readonly message: string | TerminalNotification;
+    readonly env: NodeJS.ProcessEnv;
+    /** The host terminal's formatted OSC notification, or `null` when it notifies with a bare BEL. */
+    readonly sequence: string | null;
+    /** Write a sequence through the active terminal. */
+    write(data: string): void;
+}
+export interface TerminalMultiplexerNotifier {
+    readonly tier: TerminalMultiplexerNotificationTier;
+    /** Deliver the notification. `false` leaves it to the next notifier and then the terminal fallback. */
+    send(request: TerminalMultiplexerNotificationRequest): boolean;
+}
+/**
+ * OSC 8 handling inside a multiplexer session:
+ * - `render`: the multiplexer draws and opens links itself, so links work
+ *   whatever the outer terminal supports, unless another session with a
+ *   hyperlink policy sits in the path.
+ * - `drop`: never forwards OSC 8; its session anywhere in the path disables links.
+ * - `forward`: forwards OSC 8 once it self-reports (`TERM_PROGRAM`/`TERM_PROGRAM_VERSION`)
+ *   at least `major.minor`; older or unreported versions stay off.
+ */
+export type TerminalMultiplexerHyperlinks = "render" | "drop" | {
+    readonly forward: {
+        /** Lowercase `TERM_PROGRAM` the multiplexer sets inside its panes. */
+        readonly termProgram: string;
+        readonly major: number;
+        readonly minor: number;
+    };
+};
+/** A multiplexer that answers OSC 11 from a cached copy of the outer terminal's background color. */
+export interface TerminalMultiplexerBackgroundColorCache {
+    /** Wrap a query so it reaches the outer terminal and refreshes the cache. */
+    passthrough(query: string): string;
+    /** How long the multiplexer needs to store the outer reply before the cache is re-read. */
+    readonly settleMs: number;
+}
+/** Everything omp needs to recognize one terminal multiplexer and adapt to it. */
+export interface TerminalMultiplexerModule<Id extends string = string> {
+    readonly id: Id;
+    readonly precedence: TerminalMultiplexerPrecedence;
+    /** Every environment variable `isInside()` reads. */
+    readonly sessionEnvKeys: readonly string[];
+    /** Lowercase TERM prefix that identifies the multiplexer when its session markers were stripped. */
+    readonly termPrefix?: string;
+    /**
+     * Whether the multiplexer owns the screen grid. When true, rendering takes the
+     * multiplexer path (no scrollback rebuild, anchored resize, skipped probes).
+     */
+    readonly ownsScreenGrid: boolean;
+    isInside(env?: NodeJS.ProcessEnv): boolean;
+    /** Routes notifications the multiplexer would otherwise swallow. */
+    readonly notifier?: TerminalMultiplexerNotifier;
+    /** OSC 8 policy inside a session; unset defers to the outer terminal. */
+    readonly hyperlinks?: TerminalMultiplexerHyperlinks;
+    /**
+     * The pane's VTE honors DEC 2026 even when DECRQM is unanswered or reports
+     * the mode unrecognized (status 0): synchronized output starts on inside a
+     * session, and an unrecognized report does not turn it off.
+     */
+    readonly honorsSynchronizedOutput?: boolean;
+    /**
+     * The session does not reveal whether its client renders graphics while
+     * outer-terminal identity variables leak in, so images and Kitty
+     * placeholders stay off unless the user forces them.
+     */
+    readonly imagesRequireOverride?: boolean;
+    /** Platforms where the multiplexer breaks OSC 11 passthrough, so host appearance is used instead. */
+    readonly backgroundQueryBrokenOn?: readonly NodeJS.Platform[];
+    /** Present when OSC 11 replies come from a cache an explicit refresh must update first. */
+    readonly backgroundColorCache?: TerminalMultiplexerBackgroundColorCache;
+    /** Expands REP into identical styled cells, so destructive replays REP-encode their padding. */
+    readonly expandsRepPadding?: boolean;
+    /** Expires a synchronized update after a deadline, so large rebuild replays renew DEC 2026 as they stream. */
+    readonly expiresSynchronizedOutput?: boolean;
+    /**
+     * Restoring the alternate buffer schedules a redraw that ends a synchronized
+     * update early, so a synchronized resize rebuild stays on the main buffer.
+     */
+    readonly altRestoreEndsSynchronizedOutput?: boolean;
+    /**
+     * May grow its grid before SIGWINCH reaches the app, so a rebuild-mode grow
+     * whose full viewport no longer reaches the bottom replays history.
+     */
+    readonly growsBeforeSigwinch?: boolean;
+}

package/dist/types/multiplexers/wmux.d.ts

@@ -0,0 +1,12 @@
+/**
+ * wmux is a Windows multiplexer (Electron + xterm.js) modeled on cmux/herdr that
+ * repaints its pane in place. WMUX_CLI / WMUX_PIPE are CLI path overrides and can
+ * be set outside a wmux terminal.
+ */
+export declare const wmuxMultiplexer: {
+    readonly id: "wmux";
+    readonly precedence: "session";
+    readonly sessionEnvKeys: readonly ["WMUX", "WMUX_SURFACE_ID"];
+    readonly ownsScreenGrid: true;
+    readonly isInside: (env?: NodeJS.ProcessEnv) => boolean;
+};

package/dist/types/multiplexers/zellij.d.ts

@@ -0,0 +1,12 @@
+export declare const zellijMultiplexer: {
+    readonly id: "zellij";
+    readonly precedence: "session";
+    readonly sessionEnvKeys: readonly ["ZELLIJ"];
+    readonly ownsScreenGrid: true;
+    readonly isInside: (env?: NodeJS.ProcessEnv) => boolean;
+    readonly notifier: {
+        readonly tier: "inBand";
+        readonly send: ({ sequence, write }: import("./types.js").TerminalMultiplexerNotificationRequest) => boolean;
+    };
+    readonly backgroundQueryBrokenOn: readonly ["darwin"];
+};

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

@@ -15,11 +15,12 @@ interface AgentTreeProjection<TRecord extends AgentRecordLike> {
 export declare const STATUS_ORDER: Record<AgentStatus, number>;
 /** Exact observer usage for one roster entry. */
 export declare function progressMetrics(observed: ObservableSession | undefined): AgentMetrics | undefined;
-/** Live session whose own messages back a row's metrics when no observer progress exists. */
+/** Live session used to cache a row's direct assistant usage, including with observer progress. */
 export declare function hubFallbackStatsSession<TRecord extends AgentRecordLike>(ref: TRecord, observed: ObservableSession | undefined): NonNullable<TRecord["session"]> | undefined;
 /**
- * One roster row's usage: live observer progress, then persisted history, then
- * the cached fallback read of a live session (populated by {@link aggregateMetrics}).
+ * Preserve progress/history for non-cost metrics, overlaying cumulative direct-session cost.
+ * Persisted `history.metrics.cost` is a leaf-scoped snapshot, so it never overrides live
+ * progress; only the cumulative direct-cost sources do.
  */
 export declare function hubRowMetrics<TRecord extends AgentRecordLike>(ref: TRecord, observed: ObservableSession | undefined, sessionMetrics: WeakMap<object, {
     metrics: AgentMetrics | undefined;

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

@@ -28,6 +28,13 @@ export interface AgentHubSession {
             messages: AgentMessage[];
         };
     };
+    /** Existing session ledger includes off-transcript model usage and nested-task attribution. */
+    readonly sessionManager?: {
+        getUsageStatistics(): {
+            cost: number;
+            subagentCost: number;
+        };
+    };
     getSessionStats(): {
         tokens: {
             input: number;
@@ -64,6 +71,8 @@ export interface AgentRecordLike {
         resolvedModel?: string;
         resolvedModelIsFallback?: boolean;
         metrics?: AgentMetricsSummary;
+        /** Cumulative own-session assistant and model_usage cost, excluding nested task results. */
+        directCost?: number;
         readOnly?: boolean;
         outputPath?: string;
         patchPath?: string;

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

@@ -19,6 +19,8 @@ export interface CodeReviewOverlayCallbacks extends AnnotationOverlayCallbacks {
 export interface TextReviewOverlayCallbacks extends AnnotationOverlayCallbacks {
     onComplete(result: TextReviewOverlayResult | undefined): void;
 }
+/** Splits a text source into the overlay's 1-based annotatable lines. */
+export declare function splitTextLines(text: string): string[];
 /** A fullscreen, annotated diff picker that only relies on public OMP APIs. */
 export declare class AnnotationOverlay implements Focusable {
     #private;