@chantier/tui 0.3.0 → 0.5.0

package/dist/index.d.mts

@@ -1,3 +1,4 @@
+import { ReactNode } from "react";
 import { ApprovalDecision, ApprovalRequest } from "@chantier/permissions";
 //#region ../../node_modules/cli-boxes/index.d.ts
 /**
@@ -176,6 +177,66 @@ const petWithAutoComplete: Pet2 = '';
 */
 type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
 //#endregion
+//#region src/items.d.ts
+/**
+ * Frozen v0.5 contract shared by both TUI build workers (spec
+ * local://chantier-tui-v05-spec.md §1). Types only — Worker A implements the
+ * runtime store against these; Worker B consumes them from widgets/input code.
+ */
+/** Finalized transcript item; rendered once via ink Static, never re-rendered. */
+type TuiItem = {
+  kind: "markdown";
+  text: string;
+} | {
+  kind: "tool";
+  toolName: string;
+  argsSummary: string;
+  outcome: "done" | "error";
+  durationMs?: number;
+  /** 1–2 line output preview (first non-empty line of the result content). */
+  detail?: string;
+  subagent?: {
+    sessionId: string;
+    summary: string;
+  };
+} | {
+  kind: "divider";
+  text: string;
+} | {
+  kind: "info";
+  text: string;
+} | {
+  kind: "error";
+  text: string;
+};
+/** Status-widget state; null hides the widget. */
+interface RunningState {
+  /** Date.now() when the run started (elapsed clock source). */
+  sinceMs: number;
+  detail?: string;
+}
+interface UsageTotals {
+  inputTokens: number;
+  outputTokens: number;
+}
+/** Additions to TuiStore for v0.5 (Worker A implements; TuiState gains the fields). */
+interface TuiStoreV5 {
+  readonly items: readonly TuiItem[];
+  pushItem(item: TuiItem): void;
+  setRunning(running: RunningState | null): void;
+  readonly running: RunningState | null;
+  readonly queued: readonly string[];
+  pushQueued(text: string): void;
+  /** Replaces the LAST queued text (the ↑-edit path). */
+  editQueued(text: string): void;
+  dropQueued(): void;
+  readonly usage: UsageTotals | undefined;
+  setUsage(usage: UsageTotals | undefined): void;
+  readonly statusFlash: string;
+  /** 4–6s transient status flash that falls back to the persistent status (Hermes restoreStatusAfter). */
+  flashStatus(text: string): void;
+}
+//#endregion
 //#region src/store.d.ts
 type TuiMode = "input" | "running";
 /** Optional attachment for an approval ask; pre-wired for diff previews. */
@@ -184,12 +245,20 @@ interface TuiPromptDetail {
 }
 interface TuiState {
   readonly mode: TuiMode;
-  /** Finalized transcript lines (rendered once, never re-rendered). */
-  readonly lines: readonly string[];
-  /** In-progress model text, replaced by lines once finalized. */
+  /** Finalized transcript items (rendered once via Static, never re-rendered). */
+  readonly items: readonly TuiItem[];
+  /** In-progress model text (the live region), replaced by items once finalized. */
   readonly streamText: string;
   /** Transient status line (e.g. "thinking…"); "" hides it. */
   readonly status: string;
+  /** Status-widget state (spinner + elapsed); null hides the widget. */
+  readonly running: RunningState | null;
+  /** Tasks queued while a run is in flight; drained when the run settles. */
+  readonly queued: readonly string[];
+  /** Cumulative token usage for the footer; undefined until the first result. */
+  readonly usage: UsageTotals | undefined;
+  /** Transient flash message that falls back to the persistent status after a few seconds. */
+  readonly statusFlash: string;
   /** Pending approval request; null while the model is streaming. */
   readonly prompt: ApprovalRequest | null;
   /** Optional diff attachment for the pending ask; null when absent. */
@@ -201,16 +270,41 @@ interface TuiState {
 }
 type TuiStore = {
   readonly state: TuiState;
+  get items(): readonly TuiItem[];
+  get running(): RunningState | null;
+  get queued(): readonly string[];
+  get usage(): UsageTotals | undefined;
+  get statusFlash(): string;
   /** React-side subscription; returns an unsubscribe function. */
   subscribe(listener: () => void): () => void;
-  /** Appends one finalized transcript line. */
-  pushLine(line: string): void;
+  /** Appends one finalized transcript item (rendered once, never re-rendered). */
+  pushItem(item: TuiItem): void;
   /** Appends in-flight model text; flushStream() finalizes it. */
   appendStream(text: string): void;
-  /** Moves buffered stream text (if any) into finalized lines. */
-  flushStream(): void;
+  /**
+   * Finalizes buffered stream text as a markdown item (spec §1). Without
+   * options, everything buffered becomes one item. With `{ safe: true }`, the
+   * buffer splits at its last safe paragraph boundary (takeSafeFlush): the
+   * flushed prefix becomes a markdown item and the remainder stays the live
+   * region — a half-open code fence is never finalized mid-stream.
+   */
+  flushStream(options?: {
+    safe?: boolean;
+  }): void;
   /** Shows a transient status (e.g. "thinking…"); "" hides it. */
   setStatus(status: string): void;
+  /** Shows/clears the status-widget running state (spinner + elapsed). */
+  setRunning(running: RunningState | null): void;
+  /** Queues a task typed while a run is in flight. */
+  pushQueued(text: string): void;
+  /** Replaces the LAST queued text (the ↑-edit path); no-op when empty. */
+  editQueued(text: string): void;
+  /** Removes the LAST queued text; no-op when empty. */
+  dropQueued(): void;
+  /** Replaces the footer usage totals; undefined clears them. */
+  setUsage(usage: UsageTotals | undefined): void;
+  /** Transient flash message; falls back to the persistent status after ~5s. */
+  flashStatus(text: string): void;
   /** Enters task-input mode; resolves the previous task signal if still open. */
   awaitTask(defaultText?: string): Promise<string | null>;
   /** Submits the typed task text; null = user quit. */
@@ -224,7 +318,7 @@ type TuiStore = {
   decide(decision: ApprovalDecision): void;
   /**
    * Esc aborts the current work (deny pending prompt + notify); Ctrl-C quits
-   * the app with a nonzero exit signal.
+   * the app with a nonzero exit signal. The queue survives aborts.
    */
   abort(kind: AbortKind): void;
   /** Marks the store finished; App unmounts on the next render. */
@@ -235,9 +329,85 @@ export declare function createTuiStore(handlers: {
   onAbort: (kind: AbortKind) => void;
 }, isQuitCommand?: (text: string) => boolean): TuiStore;
 //#endregion
+//#region src/keys.d.ts
+/**
+ * Namespaced action-id key map (spec §6a): every chord maps to a namespaced
+ * action id and components ask `matches(event, "app.interrupt")` instead of
+ * comparing raw key fields. This kills the BUG-3 class — any Ctrl-modified
+ * key quit (app.ts:23-25 in v0.4) — because ctrl-c is the ONLY quit chord,
+ * and it keeps dispatch as pure data + pure functions that unit-test without
+ * mounting ink (the Hermes approvalAction pattern, matching the existing
+ * keypressToDecision).
+ */
+/**
+ * Structural subset of ink's `useInput` Key that the matcher needs. Declared
+ * here (instead of importing ink) so keys.ts stays a pure, runtime-free
+ * module; ink's Key is structurally compatible by construction.
+ */
+interface Keychord {
+  /** Raw chunk bytes; a PTY can bundle the key with its Enter ("y\r"). */
+  readonly input?: string;
+  readonly ctrl?: boolean;
+  readonly escape?: boolean;
+  readonly upArrow?: boolean;
+  readonly downArrow?: boolean;
+  readonly return?: boolean;
+  readonly backspace?: boolean;
+  readonly delete?: boolean;
+}
+type ActionId =
+/** Esc while a run streams: interrupt, keep completed work. */
+"app.interrupt" |
+/** Ctrl-C: the ONLY quit chord; the ×2 window lives in the caller. */
+"app.quit" |
+/** Approval card: y / a / n / esc. */
+"app.decide.allow" | "app.decide.always" | "app.decide.deny" | "app.decide.abort" |
+/** Enter at the task prompt (submit or queue while running). */
+"app.submit" |
+/** ↑ / ↓ history recall at an empty-ish editor. */
+"app.history.prev" | "app.history.next" |
+/** ↑ while queued rows exist: pop the last queued row into the editor. */
+"app.queue.edit" |
+/** Emacs set (§6f). */
+"app.editor.home" | "app.editor.end" | "app.editor.char.back" | "app.editor.char.forward" | "app.editor.kill.to-end" | "app.editor.kill.line" | "app.editor.kill.word" | "app.editor.backspace" |
+/** Ctrl-L clears + redraws; ink repaints from state, so this is a no-op
+ * hook point today — but it must stay OUT of app.quit's chord set. */
+"app.redraw";
+/**
+ * The chord table. "app.queue.edit" and "app.history.prev" share the
+ * up-arrow chord on purpose: callers disambiguate by state (queued rows
+ * exist vs history recall), which is how OMP treats Alt+Up vs plain Up.
+ */
+export declare const ACTION_CHORDS: Readonly<Record<ActionId, readonly Keychord[]>>;
+/**
+ * Whether the keypress resolves to the action id. Input chunks are
+ * normalized by stripping CR/LF first: a PTY can deliver "y\r" as one chunk
+ * while ink sets key.return only for a lone CR.
+ */
+export declare function matches(event: Keychord, id: ActionId): boolean;
+/** Hint line for the approval card, verbatim spec §7 mockup. */
+export declare const APPROVAL_HINT_PARTS: readonly ["y allow", "a always", "n deny", "esc abort"];
+/**
+ * Maps a prompt keypress to a decision; null = key not handled by the
+ * prompt. Moved here unchanged from app.ts (spec §7): this stays the pure
+ * dispatch surface, unit-tested without mounting ink.
+ */
+export declare function keypressToDecision(key: string): ApprovalDecision | null;
+//#endregion
 //#region src/app.d.ts
-export declare function TuiApp({ store }: {
+/** Footer data computed by the caller per render (context estimate + compact gate). */
+interface FooterData {
+  readonly ctxFraction?: number;
+  readonly compactSoon?: boolean;
+}
+export declare function TuiApp({ store, footer }: {
   store: TuiStore;
+  footer?: {
+    readonly model: string;
+    readonly sessionId: string;
+    readonly contextWindow?: number;
+    readonly data?: () => FooterData;
+  };
 }): import("react").FunctionComponentElement<{
   readonly position?: "absolute" | "relative" | "static" | undefined;
   readonly top?: number | string | undefined;
@@ -322,16 +492,20 @@ export declare function TuiApp({ store }: {
 } & import("react").RefAttributes<import("ink").DOMElement>>;
 /** Screen-reader label for the approval card (ink serializes it as the button name). */
 export declare function approvalLabel(tool: string, input: unknown): string;
-/** Maps a prompt keypress to a decision; null = key not handled by the prompt. */
-export declare function keypressToDecision(key: string): ApprovalDecision | null;
 interface TuiOptions {
   /** Opt-in screen-reader rendering (also honored: CHANTIER_SCREEN_READER=1). */
   readonly screenReader?: boolean;
+  /** Footer segments; session id + model come from the CLI, contextWindow gates the ctx segment. */
+  readonly footer?: {
+    readonly model: string;
+    readonly sessionId: string;
+    readonly contextWindow?: number;
+    readonly data?: () => FooterData;
+  };
 }
 interface TuiInstance {
   waitUntilExit(): Promise<void>;
 }
-/** Mounts the TUI. The store drives everything; the caller drives the agent. */
 export declare function startTui(store: TuiStore, options?: TuiOptions): TuiInstance;
 //#endregion
 //#region src/diff.d.ts
@@ -355,15 +529,6 @@ interface DiffPreview {
 /** Counts add/del lines across the whole diff and caps the displayed lines. */
 export declare function summarizeUnifiedDiff(diff: string, maxLines?: number): DiffPreview;
 //#endregion
-//#region src/screen-reader.d.ts
-/**
- * Screen-reader mode: ink serializes the tree to plain linear text (no
- * borders, no colors), keeps `<Static>` append-only, and rewrites the dynamic
- * region only when it changes. Enabled by the `--screen-reader` flag or the
- * CHANTIER_SCREEN_READER=1 environment alias.
- */
-export declare function resolveScreenReader(flag: boolean | undefined, env: string | undefined): boolean;
-//#endregion
 //#region src/symbols.d.ts
 /**
  * Decorative characters and box borders used by the TUI. Screen readers skip
@@ -379,9 +544,310 @@ interface TuiSymbols {
   readonly hintSeparator: string;
   /** Truncation ellipsis: "…" normally, "..." in ASCII mode. */
   readonly ellipsis: string;
+  /**
+   * Spinner animation frames (v0.5 status widget, spec §4a): the 10-frame
+   * braille cycle normally, the 4-glyph `|/-\` cycle in ASCII mode.
+   * `spinnerFrame` wraps per set, so no timing code depends on the count.
+   */
+  readonly spinnerFrames: readonly string[];
+  /** Tool/task row bullet: "▸" normally, ">" in ASCII mode (§8 parity). */
+  readonly runGlyph: string;
+  /** Tree corner for detail and summary blocks: "└" normally, "+" in ASCII. */
+  readonly subGlyph: string;
+  /** Failed-tool glyph: "✗" normally, "x" in ASCII mode. */
+  readonly errorGlyph: string;
+  /** Divider rule cell: "─" normally, "-" in ASCII mode (§2d). */
+  readonly rule: string;
+  /** Context-bar cells: filled "▮" / empty "▯", ASCII "#" / "-" (§5). */
+  readonly barFilled: string;
+  readonly barEmpty: string;
+  /** Forward arrow: "→" normally, "->" in ASCII mode (divider text, §2d). */
+  readonly arrow: string;
+  /** Recall hint arrow: "↑" normally, "^" in ASCII mode (queue preview §6d). */
+  readonly arrowUp: string;
+  /** Minus sign in diff counts: "−" normally, "-" in ASCII mode (§7). */
+  readonly minus: string;
 }
 export declare function resolveSymbols(ascii: boolean): TuiSymbols;
 /** CHANTIER_ASCII=1 requests the ASCII-safe rendering. */
 export declare function isAsciiEnv(env: string | undefined): boolean;
 //#endregion
-export type { AbortKind, DiffLineKind, DiffPreview, TuiInstance, TuiOptions, TuiPromptDetail, TuiState, TuiStore, TuiSymbols };
+//#region src/input.d.ts
+/**
+ * v0.5 input surface (spec §6c-f): editor keys, paste, history. The emacs
+ * transforms and the paste thresholds are pure functions (testable without
+ * mounting ink); `TaskInput` is the props-driven ink component the app
+ * mounts at integration. Paste travels ink's separate usePaste channel —
+ * bracketed paste content never reaches useInput (verified in ink 7.1.1),
+ * which is exactly the fix for the v0.4 paste-destruction bug.
+ */
+interface EditorState {
+  readonly text: string;
+  /** Insertion point, 0..text.length. */
+  readonly cursor: number;
+}
+export declare function emptyEditor(): EditorState;
+export declare function editorInsert(state: EditorState, insert: string): EditorState;
+export declare function editorBackspace(state: EditorState): EditorState;
+type EditorAction = "home" | "end" | "char.back" | "char.forward" | "kill.to-end" | "kill.line" | "kill.word";
+/**
+ * Emacs set (§6f) as pure (text, cursor) transforms: ctrl+a/e home/end,
+ * ctrl+b/f char moves, ctrl+k kill to end, ctrl+u clear, ctrl+w kill word
+ * back. Single-line editor only; multiline ctrl+j is v0.6.
+ */
+export declare function applyEditorAction(state: EditorState, action: EditorAction): EditorState;
+interface PasteResult {
+  /** Chip text when the paste exceeds the thresholds; null = insert verbatim. */
+  readonly chip: string | null;
+  readonly lines: number;
+}
+/**
+ * Chip thresholds (§6e): >3 lines or >800 chars chips; under 12 terminal
+ * rows the CC narrow rule applies (1 line / 200 chars).
+ */
+export declare function pasteChip(text: string, rows?: number): PasteResult;
+/** Restores full paste text from its chip markers before submit. */
+export declare function expandPasteChips(text: string, chunks: ReadonlyMap<string, string>): string;
+/** File-backed history; the path is injectable so tests never touch $HOME. */
+export declare function historyPath(home?: string): string;
+interface HistoryStore {
+  readonly entries: readonly string[];
+  /** Appends unless it duplicates the last entry; silent on file failure. */
+  record(text: string): Promise<void>;
+  /** ↑: empty editor → last → older. */
+  prev(): string | null;
+  /** ↓: forward; past the newest entry → null (empty editor). */
+  next(): string | null;
+  /** Typed input ends a browse sequence. */
+  reset(): void;
+}
+export declare function createHistoryStore(opts?: {
+  entries?: readonly string[];
+  file?: string;
+}): HistoryStore;
+/** Reads the JSONL history; silent failure yields an empty list. */
+export declare function loadHistory(file: string): Promise<string[]>;
+export declare const QUIT_HINT = "press ctrl-c again to quit";
+interface TaskInputProps {
+  /** Controlled editor state; the host owns the single source of truth. */
+  readonly editor: EditorState;
+  readonly onEditorChange: (next: EditorState) => void;
+  /** Enter: the host routes to submitTask (idle) or pushQueued (running). */
+  readonly onSubmit: (text: string) => void;
+  /** True while a run streams: submit queues, ↑ edits the queue. */
+  readonly running: boolean;
+  readonly queuedCount: number;
+  /** Pops the last queued row back into the editor (§6d, OMP Alt+Up). */
+  readonly onQueueEdit: () => void;
+  /** Approval pending: every editor key is inert (input lock). */
+  readonly locked?: boolean;
+  /** Terminal rows for paste thresholds; undefined = standard thresholds. */
+  readonly rows?: number;
+  /** ↑/↓ recall + esc-saves-draft. */
+  readonly history?: HistoryStore;
+  /** Ctrl-C: host aborts the store (single-press idle, second stage running). */
+  readonly onQuit: () => void;
+  /** First ctrl-c while running: host flashes "press ctrl-c again to quit". */
+  readonly onQuitArm: () => void;
+  /** Two-stage window override for tests. */
+  readonly quitWindowMs?: number;
+  readonly symbols: TuiSymbols;
+  readonly screenReader?: boolean;
+}
+export declare function TaskInput({ editor, onEditorChange, onSubmit, running, queuedCount, onQueueEdit, locked, rows, history, onQuit, onQuitArm, quitWindowMs, symbols, screenReader }: TaskInputProps): ReactNode;
+//#endregion
+//#region src/markdown.d.ts
+/**
+ * The v0.5 reading surface (spec local://chantier-tui-v05-spec.md §2): a
+ * dependency-free line-based markdown block parser plus the streaming flush
+ * splitter. Everything here is pure so the fence/flush rules can be tested
+ * without mounting ink.
+ */
+/** Result of splitting a stream buffer at its last safe paragraph boundary. */
+interface SafeFlush {
+  /** Text that is safe to finalize (balanced blocks only); "" when nothing is. */
+  readonly flushed: string;
+  /** Text that must stay in the live region (may end inside an open fence). */
+  readonly rest: string;
+}
+/**
+ * Splits a stream buffer at its last safe split point: the final `\n\n`
+ * outside an open fence. When the buffer ends inside an open fence and no
+ * outside boundary exists, it splits BEFORE the fence start instead, so a
+ * half-open code block is never emitted into the finalized transcript. With
+ * neither a boundary nor an open fence, nothing flushes.
+ */
+export declare function takeSafeFlush(buffer: string): SafeFlush;
+export declare function hasMarkdownSyntax(text: string): boolean;
+/** A dim rule wrapped around `text`; screen readers get the plain text only. */
+export declare function markdownDivider(text: string, symbols: TuiSymbols, screenReader: boolean): ReactNode;
+/**
+ * Renders markdown text into ink elements (spec §2b): headings bold, lists
+ * indented, fences dim + 2-space indented, rules as divider rows, tables as
+ * space-aligned rows. Screen-reader mode renders the same rows unstyled, with
+ * decorative rows replaced by their label, and plain input takes the fast
+ * path and skips parsing entirely. Tolerant streaming: an unclosed fence
+ * renders as plain text until closed, so the strict styling only ever
+ * applies to balanced blocks.
+ */
+export declare function markdownToElements(text: string, symbols: TuiSymbols, screenReader: boolean): ReactNode[];
+//#endregion
+//#region src/screen-reader.d.ts
+/**
+ * Screen-reader mode: ink serializes the tree to plain linear text (no
+ * borders, no colors), keeps `<Static>` append-only, and rewrites the dynamic
+ * region only when it changes. Enabled by the `--screen-reader` flag or the
+ * CHANTIER_SCREEN_READER=1 environment alias.
+ */
+export declare function resolveScreenReader(flag: boolean | undefined, env: string | undefined): boolean;
+//#endregion
+//#region src/widgets.d.ts
+/**
+ * v0.5 activity + status widgets (spec §2c/§2d/§4/§5/§7). These are
+ * standalone, props-driven components: the parallel worker's app.ts mounts
+ * them at integration, and tests feed plain data — nothing here imports the
+ * store runtime. Every glyph routes through the provided `symbols`, and
+ * screen-reader parity renders finalized labeled lines only (§8 matrix).
+ */
+interface RowSpec {
+  readonly text: string;
+  readonly color?: string;
+  readonly bold?: boolean;
+  readonly dim?: boolean;
+}
+/** First non-empty line of a tool result, capped for the row preview. */
+export declare function previewLine(content: string, ellipsis: string, cap?: number): string;
+export declare function formatDuration(ms: number | undefined): string;
+/** "24k"-style token counts for the compaction divider (§2d mockup). */
+export declare function formatTokens(tokens: number): string;
+type ToolItem = Extract<TuiItem, {
+  kind: "tool";
+}>;
+interface ToolRowProps {
+  readonly item: ToolItem;
+  readonly symbols: TuiSymbols;
+  readonly screenReader?: boolean;
+}
+/**
+ * Collapse ladder: task/read/edit render two lines (args + detail preview);
+ * everything else renders one line. Errors turn the glyph red (§2c). The
+ * full output stays in the transcript log; expand/collapse is v0.6.
+ */
+export declare function toolRowLines(item: ToolItem, symbols: TuiSymbols): Array<RowSpec>;
+/** SR parity (§8): `tool: read(src/config.ts) done`. */
+export declare function toolRowSrText(item: ToolItem): string;
+export declare function ToolRow({ item, symbols, screenReader }: ToolRowProps): ReactNode;
+interface SubagentCardProps {
+  readonly item: ToolItem & {
+    subagent: {
+      sessionId: string;
+      summary: string;
+    };
+  };
+  readonly symbols: TuiSymbols;
+}
+/** Summary block cap: 8 dim lines, then the tail pointer to the child session. */
+export declare const SUBAGENT_SUMMARY_MAX_LINES = 8;
+export declare function subagentLines(item: SubagentCardProps["item"], symbols: TuiSymbols): Array<RowSpec>;
+export declare function SubagentCard({ item, symbols }: SubagentCardProps): ReactNode;
+interface StatusWidgetProps {
+  readonly running: RunningState | null;
+  /** Persistent status text (e.g. "thinking…"); "" = none. */
+  readonly status: string;
+  readonly symbols: TuiSymbols;
+  /** Injectable clock source; defaults to Date.now (tests pass a stub). */
+  readonly now?: () => number;
+  readonly screenReader?: boolean;
+}
+export declare const STATUS_VERB_WIDTH: number;
+/** Elapsed clock with a bounded tail: s → "1m 12s" → "1h 2m" → "99h+". */
+export declare function formatElapsed(ms: number): string;
+export declare function spinnerFrame(frame: number, symbols: TuiSymbols): string;
+/**
+ * The one-line running status: spinner + anti-jitter-padded verb + elapsed +
+ * interrupt hint, with the detail line underneath. The verb padding is the
+ * Hermes trick: the tail never shifts while the spinner cycles because the
+ * verb column width is pinned to the widest verb the widget can show.
+ */
+export declare function statusLines(frame: number, running: RunningState, status: string, symbols: TuiSymbols, elapsedMs: number): Array<RowSpec>;
+export declare function StatusWidget({ running, status, symbols, now, screenReader }: StatusWidgetProps): ReactNode;
+interface FooterBarProps {
+  readonly model: string;
+  /** 0..1 context estimate; undefined (no declared window) hides the segment. */
+  readonly ctxFraction?: number;
+  /** Auto-compact reserve would trigger for this task (§5 "compaction soon"). */
+  readonly compactSoon?: boolean;
+  readonly usage?: UsageTotals;
+  readonly sessionId: string;
+  readonly columns: number;
+  readonly symbols: TuiSymbols;
+  /** Hidden entirely while an approval prompt is pending (§5). */
+  readonly hidden?: boolean;
+}
+export declare function formatTokenCount(tokens: number): string;
+/** 8-cell context bar; filled cells round to nearest, clamped to [0, 8]. */
+export declare function ctxBar(fraction: number, symbols: TuiSymbols): string;
+/**
+ * Segment list under the width breakpoints: <64 → model + ctx%; <80 → +
+ * session; ≥80 → all four. Whole segments only — never mid-truncate.
+ */
+export declare function footerSegments(props: Omit<FooterBarProps, "hidden">): Array<RowSpec>;
+export declare function FooterBar({ model, ctxFraction, compactSoon, usage, sessionId, columns, symbols, hidden }: FooterBarProps): ReactNode;
+interface QueuePreviewProps {
+  readonly queued: readonly string[];
+  readonly symbols: TuiSymbols;
+}
+export declare const QUEUE_PREVIEW_MAX_ROWS = 2;
+/** ≤2 dimmed rows + "+N more"; collapses runs of whitespace per row. */
+export declare function queuePreviewLines(queued: readonly string[], symbols: TuiSymbols): Array<RowSpec>;
+export declare function QueuePreview({ queued, symbols }: QueuePreviewProps): ReactNode;
+interface ApprovalCardDetail {
+  readonly diff?: string;
+}
+interface ApprovalCardV2Props {
+  readonly request: ApprovalRequest;
+  readonly detail: ApprovalCardDetail | null;
+  readonly symbols: TuiSymbols;
+  /** cwd for the ~-shortened path display (CC label-shortening). */
+  readonly cwd?: string;
+  readonly screenReader?: boolean;
+}
+/**
+ * Humanized subject per tool (§7): edit/write → ~-shortened path + ±counts
+ * from the diff detail; bash → command (80 cap); read/grep → the pattern,
+ * glob → its pattern; task → first line of the prompt.
+ */
+export declare function humanizeApproval(tool: string, input: unknown, detail: ApprovalCardDetail | null, symbols: TuiSymbols, cwd?: string): string;
+/** SR parity (§8): `edit src/x.ts: +3 -1`. */
+export declare function approvalSrLabel(tool: string, input: unknown, detail: ApprovalCardDetail | null, symbols: TuiSymbols, cwd?: string): string;
+interface ApprovalCardV2Spec {
+  readonly title: string;
+  readonly subject: RowSpec | null;
+  readonly diffLines: Array<RowSpec>;
+  readonly hiddenLines: number;
+  readonly hints: string;
+  readonly srLabel: string;
+}
+/** Pure card spec so tests assert content without mounting ink. */
+export declare function approvalCardSpec(props: {
+  request: ApprovalRequest;
+  detail: ApprovalCardDetail | null;
+  symbols: TuiSymbols;
+  cwd?: string;
+}): ApprovalCardV2Spec;
+export declare function ApprovalCardV2({ request, detail, symbols, cwd, screenReader }: ApprovalCardV2Props): ReactNode;
+interface DividerProps {
+  readonly text: string;
+  readonly symbols: TuiSymbols;
+  readonly screenReader?: boolean;
+}
+/** `── {text} ──` with the ASCII `--` fallback. */
+export declare function dividerLine(text: string, symbols: TuiSymbols): string;
+export declare function Divider({ text, symbols, screenReader }: DividerProps): ReactNode;
+/**
+ * Hermes mechanism: when no tool item survives a visibility filter, the last
+ * error item is forced back into view — quiet mode must never hide failures.
+ */
+export declare function withErrorBackstop(items: readonly TuiItem[], isVisible: (item: TuiItem) => boolean): readonly TuiItem[];
+//#endregion
+export type { AbortKind, ActionId, ApprovalCardDetail, ApprovalCardV2Props, ApprovalCardV2Spec, DiffLineKind, DiffPreview, DividerProps, EditorAction, EditorState, FooterBarProps, HistoryStore, Keychord, PasteResult, QueuePreviewProps, RowSpec, RunningState, SafeFlush, StatusWidgetProps, SubagentCardProps, TaskInputProps, ToolItem, ToolRowProps, TuiInstance, TuiItem, TuiOptions, TuiPromptDetail, TuiState, TuiStore, TuiStoreV5, TuiSymbols, UsageTotals };