@oh-my-pi/pi-tui 18.2.4 → 18.2.5

package/dist/types/chat/transcript-entry.d.ts

@@ -0,0 +1,45 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { MessageAttribution } from "@oh-my-pi/pi-ai";
+import { type CustomMessage, type CustomMessageContent } from "./messages.js";
+/** Persisted message fields consumed by transcript rendering. */
+export interface SessionMessageEntryLike {
+    type: "message";
+    id: string;
+    parentId: string | null;
+    timestamp: string;
+    message: AgentMessage;
+}
+/** Persisted custom-message fields consumed by transcript rendering. */
+export interface CustomMessageEntryLike {
+    type: "custom_message";
+    id: string;
+    parentId: string | null;
+    timestamp: string;
+    customType: string;
+    content: CustomMessageContent;
+    details?: unknown;
+    display: boolean;
+    attribution?: MessageAttribution;
+}
+/** Entries that replay as visible or hidden transcript messages. */
+export type TranscriptEntryLike = SessionMessageEntryLike | CustomMessageEntryLike;
+/** Restore a persisted custom message, rejecting unsendable content. */
+export declare function customMessageEntryMessage(entry: CustomMessageEntryLike): CustomMessage | undefined;
+/** Restore the message represented by a transcript entry. */
+export declare function transcriptEntryMessage(entry: TranscriptEntryLike): AgentMessage | undefined;
+/** Identify user-authored requests among transcript and metadata entries. */
+export declare function isUserRequestEntry(entry: TranscriptEntryLike | {
+    type: string;
+}): boolean;
+/** Editable user request text, preserving skill invocation syntax. */
+export declare function userTurnDraft(entry: TranscriptEntryLike): string | undefined;
+/** Extract text blocks verbatim, optionally separating block boundaries. */
+export declare function textContent(content: string | ReadonlyArray<{
+    type: string;
+    text?: string;
+}>, separator?: string): string;
+/** Join text blocks with spaces and collapse whitespace into a single-line label. */
+export declare function userMessageLabel(content: string | ReadonlyArray<{
+    type: string;
+    text?: string;
+}>): string;

package/dist/types/chat/transcript-outline.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Shared engine for the ephemeral fullscreen transcript selectors (esc-esc
+ * rewind, `/copy`): replay session entries through {@link ChatTranscriptBuilder},
+ * map each rendered turn to a selectable target, and compose gutter-prefixed
+ * columns with a dotted outline around the selected target.
+ */
+import { type Component } from "../tui.js";
+import { type TranscriptEntryLike as TranscriptEntry } from "./transcript-entry.js";
+import type { SessionMessageEntryLike as SessionMessageEntry } from "./transcript-entry.js";
+import { type ThemeColor } from "../theme/index.js";
+import type { ChatTranscriptBuilder } from "./chat-transcript-builder.js";
+/** One selectable transcript item: a message entry plus its rendered block range. */
+export interface OutlineTarget {
+    /** Entry the selection resolves to; extended over trailing componentless tool results. */
+    entryId: string;
+    /** Entry that opened this turn (pre-fold) — anchor for tree lookups. */
+    turnId: string;
+    /** Real user prompt — drives user-turn jumps and role-specific actions. */
+    isUserTurn: boolean;
+    /** First transcript-container child rendered by this entry. */
+    start: number;
+    /** One past the last child rendered by this entry. */
+    end: number;
+    /** Entries this target spans: the turn plus any folded tool results. */
+    entries: TranscriptEntry[];
+}
+/** Composed rows of one column plus the outline's line range within them. */
+export interface ComposedColumn {
+    lines: string[];
+    selStart: number;
+    selEnd: number;
+}
+/** Presentation of the dotted outline: stroke color and an optional caption inset into the top rule. */
+export interface OutlineStyle {
+    color?: ThemeColor;
+    /** Short affordance label (e.g. "3 blocks →") drawn into the top rule's right end. */
+    caption?: string;
+}
+/** Copy-on-write removal of OSC 133 spans from a rendered row array. */
+export declare function stripPromptZones(rows: readonly string[]): readonly string[];
+/**
+ * Prompt-zone-stripped rows for one selector column.
+ *
+ * The selectors recompose their whole column on every keystroke, and stripping
+ * every child's rows again per frame is pure waste on a long session. Per the
+ * {@link Component} render contract a child returns the same array while its
+ * rows are unchanged, so the stripped copy is keyed on that array: a child that
+ * repaints itself asynchronously (Kitty image conversion, todo strike frames)
+ * hands back a new array and is stripped again.
+ */
+export declare class OutlineRowCache {
+    #private;
+    rows(children: readonly Component[], width: number): Array<readonly string[]>;
+}
+/**
+ * Append `entries` to `builder`, returning the selectable targets they
+ * produce. Tool results fold into the previous target (so a turn's rewind
+ * and `/copy` keep its output, including lazily created children such as
+ * the grouped-read card); notices and hidden messages that render nothing
+ * are skipped. Usage rows flushed at the head of an append are attributed
+ * to the turn above.
+ */
+export declare function appendOutlineEntries(builder: ChatTranscriptBuilder, entries: TranscriptEntry[]): OutlineTarget[];
+/** Per-target "renders at least one non-blank row" flags at the given rows. */
+export declare function outlineVisibility(childRows: readonly (readonly string[])[], targets: readonly OutlineTarget[]): boolean[];
+/** Dotted horizontal rule with rounded corners, spanning the outline width. */
+export declare function outlineRule(left: string, right: string, innerWidth: number, color?: ThemeColor, caption?: string): string;
+/** Wrap pre-rendered rows in the dotted outline (rules above/below, `┆` sides). */
+export declare function outlineRows(rows: readonly string[], innerWidth: number, style?: OutlineStyle): string[];
+/**
+ * Compose one column: gutter-prefixed rows for `childRows[from, to)` with a
+ * dotted outline around `targets[selected]`. `header` rows, when given, lead
+ * the column.
+ */
+export declare function composeOutlineColumn(childRows: readonly (readonly string[])[], from: number, to: number, targets: readonly OutlineTarget[], selected: number, columnWidth: number, header: string[] | undefined, style?: OutlineStyle): ComposedColumn;
+/** Centered position rail for horizontally windowed content: `… ○ ◉ ○ …`. */
+export declare function positionRail(count: number, active: number, moreLeft: boolean, moreRight: boolean, width: number): string;
+/**
+ * A turn the user can rewind past and re-edit: a user message with prompt
+ * text, or a user-initiated custom message (skill / collab prompt).
+ */
+export declare function isUserTurnEntry(entry: TranscriptEntry): boolean;
+/** Single-line label for a user turn: its prompt text, or the custom message's draft. */
+export declare function userTurnLabel(entry: TranscriptEntry): string | undefined;
+/** Whether a user message carries prompt text (string or text blocks). */
+export declare function userMessageHasText(message: SessionMessageEntry["message"]): boolean;

package/dist/types/chat/transcript-render-helpers.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Render helpers shared between the live transcript ({@link UiHelpers}) and the
+ * file/remote-backed {@link ChatTranscriptBuilder}. Both surfaces build the same
+ * transcript rows from persisted message entries; holding the row construction
+ * here keeps the two byte-for-byte identical.
+ */
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import { type Component } from "../tui.js";
+import { type FileMentionMessage } from "./messages.js";
+import { ToolActivityContainer } from "../chrome/tool-activity.js";
+import { type TranscriptBlock } from "../chrome/transcript-container.js";
+type CustomOrHookMessage = Extract<AgentMessage, {
+    role: "custom" | "hookMessage";
+}>;
+type AssistantAgentMessage = Extract<AgentMessage, {
+    role: "assistant";
+}>;
+/**
+ * Render an `async-result` custom message (a completed background bash/task job,
+ * or a batch of them) as a transcript block of one "Background job completed"
+ * row per job.
+ */
+export declare function buildAsyncResultBlock(message: CustomOrHookMessage): ToolActivityContainer;
+/**
+ * Render a `launch-completion` custom message (terminal supervised-process
+ * exits from the launch broker) as a transcript block of one compact
+ * "Supervised process ..." row per daemon, matching background-job rows.
+ */
+export declare function buildLaunchCompletionBlock(message: CustomOrHookMessage): ToolActivityContainer;
+/**
+ * Render a live IRC traffic custom message (`irc:incoming` / `irc:autoreply` /
+ * `irc:relay`) as a transcript card. `getExpanded` supplies the live
+ * expanded-state getter for the cached card.
+ */
+export declare function buildIrcMessageCard(message: CustomOrHookMessage, getExpanded: () => boolean): Component;
+/**
+ * Render a `fileMention` message's files as a transcript block of "Read <path>"
+ * rows. `indent` sets the left pad: the live chat renders within an outer gutter
+ * (0), the transcript viewer renders body rows without one so rows own their pad
+ * (1).
+ */
+export declare function buildFileMentionBlock(files: FileMentionMessage["files"], indent: number): TranscriptBlock;
+/**
+ * Whether an assistant turn has visible text, thinking, or image content — i.e.
+ * content that closes the current read-tool run.
+ */
+export declare function assistantHasVisibleContent(message: AssistantAgentMessage): boolean;
+/**
+ * Split mixed assistant turns into visible text before tool execution and
+ * visible text segments that must render immediately after the preceding tool.
+ * Cursor can return intro text, tool calls, progress text, and the final answer
+ * in one assistant message; keeping every text block in the leading assistant
+ * block buries post-tool text above tool results in the transcript.
+ */
+export declare function splitAssistantMessageToolTimeline(message: AssistantAgentMessage): {
+    beforeTools: AssistantAgentMessage;
+    afterToolCalls: ReadonlyMap<string, AssistantAgentMessage>;
+    hasToolCalls: boolean;
+    lastToolCallId?: string;
+};
+/**
+ * Normalize raw tool-call arguments to a plain record, collapsing non-object or
+ * array values to an empty object.
+ */
+export declare function normalizeToolArgs(args: unknown): Record<string, unknown>;
+export type AssistantErrorPresentation = {
+    kind: "none";
+} | {
+    kind: "full";
+    text: string;
+    isError: true;
+} | {
+    kind: "compact-recovered";
+    text: string;
+    isError: false;
+};
+/**
+ * Resolve the turn-ending assistant error presentation, if any.
+ * Silent and user-interrupt aborts yield no label. Recovered retry attempts
+ * render a compact note; attempts superseded by an exhausted budget are hidden
+ * while the final terminal error keeps its full presentation.
+ */
+export declare function resolveAssistantErrorPresentation(message: AssistantAgentMessage, retryAttempt?: number): AssistantErrorPresentation;
+/**
+ * Whether an assistant turn's `usage` reflects work the operator was billed
+ * for. Empty automated turns from providers that emit `usage: 0` collapse to
+ * `false`, but any input, output, cache, or premium request keeps the row so
+ * cost transparency survives — the live path and the resume/rebuild path
+ * agree turn-by-turn.
+ */
+export declare function assistantUsageIsBilled(usage: AssistantAgentMessage["usage"]): boolean;
+export {};

package/dist/types/chat/ttsr-notification.d.ts

@@ -0,0 +1,23 @@
+import { Container } from "../tui.js";
+/** Rule fields shown in rewind notifications. */
+export interface NotificationRule {
+    name: string;
+    description?: string;
+    content?: string;
+}
+/**
+ * Component that renders a TTSR (Time Traveling Stream Rules) notification.
+ * Shows when a rule violation is detected and the stream is being rewound.
+ * One block can carry several rules: a single event may match multiple rules,
+ * and consecutive notifications merge into the previous block via
+ * {@link addRules} while it is still the live transcript tail.
+ */
+export declare class TtsrNotificationComponent extends Container {
+    #private;
+    constructor(rules: NotificationRule[]);
+    setToolActivityVisible(visible: boolean): void;
+    /** Merge additional rules into this block (deduped by rule name). */
+    addRules(rules: NotificationRule[]): void;
+    setExpanded(expanded: boolean): void;
+    isExpanded(): boolean;
+}

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

@@ -0,0 +1,52 @@
+import { type Component, Container } from "../tui.js";
+import type { ReactionTarget } from "./reaction.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. */
+    imageLinks?: readonly (string | undefined)[];
+    /** Agent-attributed input: dim, flat prose. */
+    synthetic?: boolean;
+    /** SKILL.md path for a skill chip by name; `undefined` leaves the chip unlinked. */
+    skillPath?: (name: string) => string | undefined;
+}
+/**
+ * Foreground styling for prose inside a user bubble: the bubble text color with the
+ * magic-keyword glow, attachment chips in their composer identity color, and skill
+ * chips as soft pills (linked to their SKILL.md) — each token restoring the bubble's
+ * own foreground after it. Shared by {@link UserMessageComponent} and the skill
+ * callout so both read as one turn.
+ */
+export declare function userBubbleColor(options?: UserBubbleOptions, tokenRegex?: RegExp): (value: string) => string;
+/**
+ * Component that renders a user message. Accepts an agent reaction badge
+ * (see {@link ReactionTarget}) drawn right-aligned in the bubble's top padding row.
+ */
+export declare class UserMessageComponent extends Container implements ReactionTarget {
+    #private;
+    constructor(text: string, options?: UserBubbleOptions);
+    setReaction(emoji: string): void;
+    render(width: number): readonly string[];
+}
+/**
+ * Collapsed placeholder for a synthetic (agent-attributed) user input in the
+ * file/remote-backed transcript viewer — chiefly the advisor's `Session update`
+ * replay dumps, which can each be hundreds of KiB of Markdown and, on cold open,
+ * blocked the TUI for tens of seconds while every historical body was laid out
+ * before the viewport clip (issue #6308).
+ *
+ * Collapsed by default: renders one dim summary row (label · size · line count ·
+ * expand hint) and builds NO Markdown. The heavy {@link UserMessageComponent} is
+ * constructed lazily only when expanded via `ctrl+o`, so blocks above the
+ * viewport never pay layout cost until the reader asks to see them. The raw
+ * observability data stays intact in `__advisor.jsonl`.
+ */
+export declare class CollapsedSyntheticMessageComponent implements Component {
+    #private;
+    constructor(text: string, imageLinks?: readonly (string | undefined)[]);
+    /** ctrl+o toggle: reveal/hide the full Markdown body. */
+    setExpanded(expanded: boolean): void;
+    setIgnoreTight(ignore: boolean): this;
+    invalidate(): void;
+    dispose(): void;
+    render(width: number): readonly string[];
+}

package/dist/types/chrome/chat-block.d.ts

@@ -0,0 +1,64 @@
+import { Container } from "../tui.js";
+/**
+ * Capabilities a mounted {@link ChatBlock} may use against its host transcript.
+ * Kept minimal so blocks never reach into the full TUI/InteractiveMode surface.
+ */
+export interface ChatBlockHost {
+    /** Schedule a repaint of the transcript. */
+    requestRender(): void;
+}
+/**
+ * Lifecycle-aware transcript block — the "return a block, let the host mount it"
+ * primitive, modelled on React/Svelte component lifecycles.
+ *
+ * Producers build and return a `ChatBlock` instead of poking `chatContainer` and
+ * `ui.requestRender()` directly. The host (`ctx.present`) appends it and calls
+ * {@link mount}, which runs {@link onMount}; effects started there register
+ * teardown via {@link onCleanup}. The block repaints through {@link requestRender}
+ * — never touching the TUI — and tears down exactly once on {@link finish}
+ * (self-complete: stop the animation, keep the final frame in the transcript) or
+ * {@link dispose} (host discards it, e.g. a transcript reset).
+ *
+ * While mounted and unfinished a block reports `isTranscriptBlockFinalized() ===
+ * false` so {@link "../components/transcript-container".TranscriptContainer}
+ * keeps it in the live, repaintable region on ED3-risk terminals; after
+ * `finish()`/`dispose()` it reports `true` and freezes at its final content.
+ */
+export declare abstract class ChatBlock extends Container {
+    #private;
+    /**
+     * Run setup after the block is in the transcript: start timers/subscriptions
+     * and register their teardown with {@link onCleanup}. Default: no-op (a block
+     * whose content is fixed at construction needs no mount work).
+     */
+    protected onMount(): void;
+    /**
+     * Register a teardown to run on {@link finish}/{@link dispose}, à la a
+     * `useEffect` cleanup. If the block is already disposed the cleanup runs
+     * immediately so callers never leak.
+     */
+    protected onCleanup(cleanup: () => void): void;
+    /** Ask the host to repaint. No-op before mount or after dispose. */
+    protected requestRender(): void;
+    /** True between {@link mount} and {@link finish}/{@link dispose}. */
+    protected get active(): boolean;
+    /**
+     * Host-only: attach the host and run {@link onMount}. Idempotent — a second
+     * call (e.g. a transcript rebuild that re-presents the same instance) is a
+     * no-op.
+     */
+    mount(host: ChatBlockHost): void;
+    /**
+     * Self-complete: stop ongoing effects and freeze the block at its current
+     * content, leaving it rendered in the transcript. Use when the operation the
+     * block represents finishes (connection resolved, download done).
+     */
+    finish(): void;
+    /**
+     * Host-only teardown: release everything and propagate to children. Called
+     * when the host permanently discards the block (transcript reset). Idempotent.
+     */
+    dispose(): void;
+    /** Live blocks stay repaintable; finished/disposed ones may freeze. */
+    isTranscriptBlockFinalized(): boolean;
+}

package/dist/types/chrome/collab-qrcode.d.ts

@@ -0,0 +1,28 @@
+import type { Component } from "../tui.js";
+import type { AnimationFrame, TranscriptPresentationTarget } from "./transcript-container.js";
+/** Scheme-less display form of a collab browser deep link, OSC-8 linked. */
+export declare function collabBrowserLink(webLink: string, label?: string): string;
+/**
+ * One-shot transcript block that prints a collab browser-join URL as a
+ * scannable QR code. The symbol is encoded once at construction (byte mode,
+ * EC level M) and rendered as ANSI half-blocks; on terminals too narrow for
+ * the symbol it degrades to a one-line hint that includes the URL.
+ *
+ * The transcript viewport can also clip a live block to a single row under
+ * pressure (many short settled blocks — typical when thinking is a one-line
+ * summary rather than a tall trace). The QR's first/last rows are a white
+ * quiet zone, so a 1-row clip looks like an empty white line. When the
+ * allocated height cannot fit the full symbol, degrade to the same hint.
+ * The sibling `/collab` status heading can also collapse to its first row
+ * under that pressure, so the hint must carry the URL itself — "use the
+ * URL above" is not reachable.
+ */
+export declare class CollabQrCodeComponent implements Component, TranscriptPresentationTarget {
+    #private;
+    readonly url: string;
+    constructor(url: string);
+    setTranscriptAllocation(rows: number, _frame?: AnimationFrame): void;
+    render(width: number): readonly string[];
+    /** Survives emergency 1-row transcript pressure when this block is otherwise hidden. */
+    renderTranscriptBlockEmergencyRow(width: number): string;
+}

package/dist/types/chrome/context-thresholds.d.ts

@@ -0,0 +1,10 @@
+import type { ThemeColor } from "../theme/index.js";
+export type ContextUsageLevel = "normal" | "warning" | "purple" | "error";
+export declare function getContextUsageLevel(contextPercent: number, contextWindow: number): ContextUsageLevel;
+/**
+ * Format context usage as `<percent>%/<window>` when the model window is known.
+ * Unknown windows render as `<tokens>/?`, because `0.0%/0` suggests a real
+ * empty context instead of missing provider metadata.
+ */
+export declare function formatContextUsage(contextPercent: number | null | undefined, contextWindow: number, usedTokens?: number): string;
+export declare function getContextUsageThemeColor(level: ContextUsageLevel): ThemeColor;

package/dist/types/chrome/countdown-timer.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Reusable countdown timer for dialog components.
+ */
+import type { TUI } from "../tui.js";
+export declare class CountdownTimer {
+    #private;
+    private tui;
+    private onTick;
+    private onExpire;
+    constructor(timeoutMs: number, tui: TUI | undefined, onTick: (seconds: number) => void, onExpire: () => void);
+    /** Reset the countdown to its initial value */
+    reset(): void;
+    dispose(): void;
+}

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

@@ -0,0 +1,14 @@
+import { type Theme } from "../theme/index.js";
+export interface RenderDiffOptions {
+    /** File path used to resolve indentation (.editorconfig + defaults) */
+    filePath?: string;
+    /** Theme used for diff colors and syntax highlighting; defaults to the active TUI theme. */
+    theme?: Theme;
+}
+/**
+ * Render a diff string with colored lines and intra-line change highlighting.
+ * - Context lines: dim/gray
+ * - Removed lines: red, with inverse on changed tokens
+ * - Added lines: green, with inverse on changed tokens
+ */
+export declare function renderDiff(diffText: string, options?: RenderDiffOptions): string;

package/dist/types/chrome/dynamic-border.d.ts

@@ -0,0 +1,16 @@
+import type { Component } from "../tui.js";
+/**
+ * Dynamic border component that adjusts to viewport width.
+ *
+ * Note: the module-level `theme` may be `undefined` — when loaded through jiti
+ * (separate module cache) or from a second `src` module graph in npm-package
+ * installs, where the host bundle assigns `theme` but this copy never sees it
+ * (issue #5366). Both the default color and `render()` degrade to plain,
+ * unstyled output instead of crashing the TUI.
+ */
+export declare class DynamicBorder implements Component {
+    #private;
+    constructor(color?: (str: string) => string);
+    invalidate(): void;
+    render(width: number): readonly string[];
+}

package/dist/types/chrome/error-block.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Plain, bounded error text to sanitize before applying terminal styles.
+ * Match embedded home paths (including quoted names with spaces), not URL
+ * paths or home-prefix siblings. Callers retain the original error for logs.
+ */
+export declare function sanitizeErrorLine(error: unknown, maxWidth?: number, homeDir?: string): string;
+/**
+ * Format a provider error into at most `maxRows` wrapped rows for a
+ * `WidthAwareText` of `contentWidth` cells. Lines wrap to the render width
+ * instead of being cut at a fixed column, so a long single-line body — a raw
+ * 400 JSON envelope, a `raw-http-request=` dump path — stays readable. Blank
+ * lines are dropped. When rows are cut, a dim `… +N more lines (<key> to
+ * expand)` row follows; pass `Infinity` to keep every row. `styleLine` colors
+ * logical line `index` and supplies line 0's prefix (`Error: `, the banner
+ * glyph). Shared by the inline transcript error and the pinned banner.
+ */
+export declare function formatErrorBlock(message: string, contentWidth: number, maxRows: number, styleLine: (line: string, index: number) => string): string;

package/dist/types/chrome/form-theme.d.ts

@@ -0,0 +1,3 @@
+import type { FormFieldTheme } from "../components/form.js";
+/** Shared accent form-field theme used by overlay dialogs. */
+export declare const formTheme: FormFieldTheme;

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

@@ -0,0 +1,12 @@
+import { type Theme } from "../theme/theme.js";
+/** Title-case a provider id for display (`openai-codex` → `Openai Codex`). */
+export declare function formatProviderName(provider: string): string;
+/** Format a millisecond duration as a coarse-grained human label. */
+export declare function formatCoarseDuration(ms: number): string;
+type ProgressBarTheme = Pick<Theme, "bold" | "fg" | "getFgAnsi">;
+/**
+ * Render an ASCII progress bar with a trailing percent label.
+ * `fraction` is clamped to `[0, 1]`. `undefined` renders a dotted placeholder.
+ */
+export declare function renderAsciiBar(fraction: number | undefined, width?: number, uiTheme?: ProgressBarTheme): string;
+export {};

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

@@ -0,0 +1,20 @@
+export * from "./chat-block.js";
+export * from "./context-thresholds.js";
+export * from "./countdown-timer.js";
+export * from "./diff.js";
+export * from "./dynamic-border.js";
+export * from "./error-block.js";
+export * from "./keybinding-hints.js";
+export * from "./message-divider.js";
+export * from "./message-frame.js";
+export * from "./message-notice.js";
+export * from "./overlay-box.js";
+export * from "./segment-track.js";
+export * from "./select-list-mouse-routing.js";
+export * from "./selector-helpers.js";
+export * from "./shared.js";
+export * from "./streaming-panel.js";
+export * from "./tool-activity.js";
+export * from "./transcript-container.js";
+export * from "./transcript-status.js";
+export * from "./visual-truncate.js";

package/dist/types/chrome/keybinding-hints.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Utilities for formatting keybinding hints in the UI.
+ */
+import { type Keybinding } from "../keybindings.js";
+import { type AppKeybinding, type KeybindingsManager } from "../app-keybindings.js";
+/**
+ * Get display string for an editor action.
+ */
+export declare function editorKey(action: Keybinding): string;
+/**
+ * Get display string for an app action.
+ */
+export declare function appKey(keybindings: KeybindingsManager, action: AppKeybinding): string;
+/**
+ * Format a keybinding hint with consistent styling: dim key, muted description.
+ * Looks up the key from editor keybindings automatically.
+ *
+ * @param action - Keybinding action name (e.g., "tui.select.confirm", "app.tools.expand")
+ * @param description - Description text (e.g., "to expand", "cancel")
+ * @returns Formatted string with dim key and muted description
+ */
+export declare function keyHint(action: Keybinding, description: string): string;
+/**
+ * Format a keybinding hint for app-level actions.
+ * Requires the KeybindingsManager instance.
+ *
+ * @param keybindings - KeybindingsManager instance
+ * @param action - App keybinding name (e.g., "app.interrupt", "app.editor.external")
+ * @param description - Description text
+ * @returns Formatted string with dim key and muted description
+ */
+export declare function appKeyHint(keybindings: KeybindingsManager, action: AppKeybinding, description: string): string;
+/**
+ * Format a raw key string with description (for non-configurable keys like ↑↓).
+ *
+ * @param key - Raw key string
+ * @param description - Description text
+ * @returns Formatted string with dim key and muted description
+ */
+export declare function rawKeyHint(key: string, description: string): string;

package/dist/types/chrome/live-board.d.ts

@@ -0,0 +1,23 @@
+/** Output contract for the live board (satisfied by `process.stdout`). */
+export interface LiveBoardOutput {
+    isTTY?: boolean;
+    columns?: number;
+    rows?: number;
+    write(text: string): boolean;
+}
+/** Live repaint handle returned by {@link createLiveBoard}. */
+export interface LiveBoard {
+    readonly interactive: boolean;
+    /** Print a permanent line above the board; plain write when non-interactive. */
+    log(text: string): void;
+    /** Repaint immediately after a state change instead of waiting for the next tick. */
+    repaint(): void;
+    /** Clear the board, stop the timer, and restore the cursor. */
+    close(): void;
+}
+/**
+ * Create a live board whose content comes from `render(spinner, width)` on
+ * every tick. An empty render result paints nothing and releases the cursor,
+ * so an idle board never interferes with other terminal UI (e.g. pickers).
+ */
+export declare function createLiveBoard(render: (spinner: string, width: number) => string[], output?: LiveBoardOutput): LiveBoard;

package/dist/types/chrome/local-date.d.ts

@@ -0,0 +1,4 @@
+/** formatLocalCalendarDate formats a Date as YYYY-MM-DD in the host local timezone. */
+export declare function formatLocalCalendarDate(date?: Date): string;
+/** Format a local date and minute with a compact numeric UTC offset. */
+export declare function formatLocalDateTimeWithOffset(date: Date): string;

package/dist/types/chrome/message-divider.d.ts

@@ -0,0 +1,22 @@
+import type { Component } from "../tui.js";
+import { type ThemeColor } from "../theme/index.js";
+/** Presentation policy for a compact message divider. */
+export interface MessageDividerOptions {
+    /** Theme-aware label, recomputed after invalidation. */
+    readonly label: () => string;
+    readonly labelColor: ThemeColor;
+    readonly ruleColor?: ThemeColor;
+    readonly ruleWidth?: number;
+    /** Preserve an intentionally untruncated legacy label at very narrow widths. */
+    readonly truncateWhenNarrow?: boolean;
+}
+/**
+ * A short left-aligned rule and label surrounded by blank transcript rows.
+ * Rendered rows are cached by width and stay reference-stable until invalidated.
+ */
+export declare class MessageDividerComponent implements Component {
+    #private;
+    constructor(options: MessageDividerOptions);
+    invalidate(): void;
+    render(width: number): readonly string[];
+}