@itookit/dsht 0.3.7 → 0.5.1

package/dist/ui/chat/header.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /** Fixed conversation header: session title, workspace, and the agent-preset label. */
 import { Box, Text } from 'ink';
-import { toolLine } from "../../session/transcript.js";
+import { toolLine } from "../../text.js";
 import { Frozen } from "../frozen.js";
 import { useTheme } from "../theme/index.js";
 /** Session title and optional preset label above the divider.

package/dist/ui/chat/history-view.d.ts

@@ -1,4 +1,4 @@
-import type { HistoryRow } from '../../session/history.ts';
+import type { HistoryRow } from '../../contracts.ts';
 /** Render a viewport with role, reasoning, tool and result colors from the selected theme.
  *
  * Rows are sibling text nodes rather than lines inside one text node: Ink measures and caches text per

package/dist/ui/chat/history-view.js

@@ -12,6 +12,6 @@ import { useTheme } from "../theme/index.js";
  */
 export function HistoryViewport({ rows }) {
     const theme = useTheme();
-    return _jsx(Box, { flexDirection: "column", children: rows.map((row, index) => _jsx(Text, { color: theme.colors[row.kind], bold: row.bold, children: row.spans?.length ? row.spans.map((span, position) => _jsx(Text, { bold: span.bold, italic: span.italic, underline: span.underline, strikethrough: span.strikethrough, inverse: span.inverse, children: span.text }, position))
+    return _jsx(Box, { flexDirection: "column", children: rows.map((row, index) => _jsx(Text, { bold: row.bold, color: row.highlight ? theme.shell.foreground : theme.colors[row.kind], backgroundColor: row.highlight ? theme.shell.background : undefined, children: row.spans?.length ? row.spans.map((span, position) => _jsx(Text, { bold: span.bold, italic: span.italic, underline: span.underline, strikethrough: span.strikethrough, inverse: span.inverse, children: span.text }, position))
                 : row.text === '' ? ' ' : row.text }, index)) });
 }

package/dist/ui/chat/loop-status.d.ts

@@ -0,0 +1,11 @@
+import type { LoopProgress } from '../../contracts.ts';
+/** Progress line shown above the composer.
+ *
+ * It names no command: the protocol supplies `title`, and the remaining fields are the generic
+ * step/attempt score shape, so a new loop protocol renders here without a UI change.
+ * @param props - The application-produced loop snapshot.
+ * @returns One dim line, brightened while the loop is still running.
+ */
+export declare function LoopStatus({ progress }: {
+    progress: LoopProgress;
+}): import("react").JSX.Element;

package/dist/ui/chat/loop-status.js

@@ -0,0 +1,28 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+/** One-line progress of a client-driven agent loop, for whichever protocol is running. */
+import { Text } from 'ink';
+import { useTheme } from "../theme/index.js";
+/** Progress line shown above the composer.
+ *
+ * It names no command: the protocol supplies `title`, and the remaining fields are the generic
+ * step/attempt score shape, so a new loop protocol renders here without a UI change.
+ * @param props - The application-produced loop snapshot.
+ * @returns One dim line, brightened while the loop is still running.
+ */
+export function LoopStatus({ progress }) {
+    const theme = useTheme();
+    const running = progress.phase === 'running';
+    // A paused run is waiting for the operator, not finished: the line says what to do about it.
+    const paused = progress.active && progress.phase === 'needs-human';
+    // A run stopped on a host request shows what the host is waiting for, not just the phase name.
+    const interaction = progress.interaction === undefined ? '' : ` · ${progress.interaction.kind}: ${progress.interaction.text}`;
+    // A run a verifier ended early says why: the reason is the only part of that verdict a reader acts on.
+    const exit = progress.exit === undefined ? '' : ` · ${progress.exit.reason}`;
+    // `passed` only claims the rounds that ran, so the line says which ones it covered.
+    const scope = progress.phase === 'passed' ? ` · ${progress.scope}` : '';
+    // What the live run waits on is controller data, not a note: a work turn is already visible as the
+    // session working, so only the states without a host turn of their own are named here.
+    const activity = running && progress.activity !== undefined && progress.activity !== 'turn'
+        ? ` · ${progress.activity}` : '';
+    return _jsxs(Text, { color: progress.active ? theme.colors.context : theme.colors.muted, children: [progress.title, progress.stepLabel === undefined ? '' : ` · ${progress.stepLabel}`, " \u00B7 step ", progress.step, "/", progress.to, " \u00B7 attempt ", progress.attempt, "/", progress.tries, " \u00B7 best ", progress.best, "/", progress.score, running ? '' : paused ? ' · needs you · /loop answer' : ` · ${progress.phase}`, activity, scope, exit, interaction, progress.note === undefined ? '' : ` · ${progress.note}`] });
+}

package/dist/ui/chat/navigation-model.d.ts

@@ -0,0 +1,86 @@
+/** Presentation model for the workspace and session lists.
+ *
+ * Marker, label and rollup text are the list screens' vocabulary, so they live next to the screens
+ * that render them. `session/navigation.ts` keeps only target resolution, which the domain needs.
+ */
+import { type ObjectValue } from '../../json.ts';
+/** User-visible activity of one session, most actionable first.
+ *
+ * `needs` is the only state that asks the user to do something, and it outranks the host's running
+ * flag because a turn waiting on an answer is running only in the mechanical sense. `blank` stays a
+ * marker for a session that never sent a turn, but it is not a status and never enters a rollup.
+ */
+export type SessionState = 'needs' | 'running' | 'idle' | 'blank';
+/** Classify one session from the host's list summary; nothing is inferred from silence.
+ * @param session - Session summary from `session/list`.
+ * @param pending - Whether this client holds an unanswered interaction for that session.
+ * @returns Needs-you while an answer is owed, running while its agent works, otherwise idle or blank.
+ */
+export declare function sessionState(session: ObjectValue, pending?: boolean): SessionState;
+/** Leading marker per state: a question mark, a working clock, a filled dot, and an unused circle. */
+export declare const SESSION_MARKERS: Record<SessionState, string>;
+/** One word per state, so every screen names the same state the same way. */
+export declare const STATE_LABELS: Record<SessionState, string>;
+/** Coarse age of a session's last activity, so the column stays steady between list refreshes.
+ * @param time - Epoch milliseconds of the last activity, when the summary reported one.
+ * @param now - Current epoch milliseconds.
+ * @returns `now`, minutes, hours or days.
+ */
+export declare function activityAge(time: number | undefined, now: number): string;
+/** Status cell for one session row: its state marker and the age of its last activity.
+ * @param session - Session summary from `session/list`.
+ * @param now - Current epoch milliseconds.
+ * @param pending - Whether this client holds an unanswered interaction for that session.
+ * @returns Marker with an optional age, without a trailing space when unknown.
+ */
+export declare function sessionStatus(session: ObjectValue, now: number, pending?: boolean): string;
+/** States a workspace rollup reports, most actionable first. */
+export declare const ROLLUP_STATES: readonly ["needs", "running", "idle"];
+/** One state a workspace rollup reports. */
+export type RollupState = (typeof ROLLUP_STATES)[number];
+/** One counted state of a workspace rollup. */
+export interface RollupCount {
+    state: RollupState;
+    count: number;
+}
+/** How much room a rollup has for words. */
+export type RollupStyle = 'words' | 'badges';
+/** Count the sessions of one workspace by the state each reports.
+ *
+ * Blank sessions are counted by neither a badge nor a word: a session that never sent a turn is the
+ * absence of activity, and listing it beside real work only makes the rollup harder to read.
+ * @param sessions - Sessions whose `sessionIds` belong to the workspace.
+ * @param pending - Session IDs this client holds an unanswered interaction for.
+ * @returns One count per state that occurs, most actionable first, or an empty list.
+ */
+export declare function workspaceCounts(sessions: readonly ObjectValue[], pending?: ReadonlySet<string>): RollupCount[];
+/** Render one rollup as separately coloured cells.
+ *
+ * Each cell after the first carries the separator that joins it to the previous one, so a caller can
+ * colour the cells independently without losing the text {@link workspaceStatus} would produce.
+ * @param counts - Counts from {@link workspaceCounts}.
+ * @param style - `words` spells each state out; `badges` keeps only the marker and the count.
+ * @returns The cells in the order given, with their separators.
+ */
+export declare function workspaceSegments(counts: readonly RollupCount[], style?: RollupStyle): {
+    state: RollupState;
+    text: string;
+}[];
+/** Render one rollup as plain text, the same way every screen and test reads it.
+ * @param counts - Counts from {@link workspaceCounts}.
+ * @param style - `words` spells each state out; `badges` keeps only the marker and the count.
+ * @returns The joined cell text, empty when nothing was counted.
+ */
+export declare function workspaceStatus(counts: readonly RollupCount[], style?: RollupStyle): string;
+/** Marker key for the compact rollup, which has no room for the words. */
+export declare const ROLLUP_LEGEND: string;
+/** Secondary path text for one workspace row.
+ *
+ * The title is usually the last path segment, so repeating it wastes the row; the parent directory
+ * is what distinguishes two checkouts. A title that does not name the last segment keeps the full
+ * path, because dropping it would hide where the workspace actually lives.
+ * @param path - Registered host directory.
+ * @param title - Workspace title as the row already shows it.
+ * @returns The path to show beside the row, or an empty string when nothing is left.
+ */
+export declare function workspaceDetail(path: string, title: string): string;

package/dist/ui/chat/navigation-model.js

@@ -0,0 +1,107 @@
+/** Classify one session from the host's list summary; nothing is inferred from silence.
+ * @param session - Session summary from `session/list`.
+ * @param pending - Whether this client holds an unanswered interaction for that session.
+ * @returns Needs-you while an answer is owed, running while its agent works, otherwise idle or blank.
+ */
+export function sessionState(session, pending = false) {
+    if (pending)
+        return 'needs';
+    if (session.running === true)
+        return 'running';
+    return session.blank === true ? 'blank' : 'idle';
+}
+/** Leading marker per state: a question mark, a working clock, a filled dot, and an unused circle. */
+export const SESSION_MARKERS = { needs: '?', running: '◐', idle: '●', blank: '○' };
+/** One word per state, so every screen names the same state the same way. */
+export const STATE_LABELS = { needs: 'needs you', running: 'working', idle: 'ready', blank: 'empty' };
+/** Coarse age of a session's last activity, so the column stays steady between list refreshes.
+ * @param time - Epoch milliseconds of the last activity, when the summary reported one.
+ * @param now - Current epoch milliseconds.
+ * @returns `now`, minutes, hours or days.
+ */
+export function activityAge(time, now) {
+    if (time === undefined || !Number.isFinite(time))
+        return '';
+    const seconds = Math.max(0, Math.floor((now - time) / 1000));
+    if (seconds < 60)
+        return 'now';
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    return hours < 24 ? `${hours}h` : `${Math.floor(hours / 24)}d`;
+}
+/** Status cell for one session row: its state marker and the age of its last activity.
+ * @param session - Session summary from `session/list`.
+ * @param now - Current epoch milliseconds.
+ * @param pending - Whether this client holds an unanswered interaction for that session.
+ * @returns Marker with an optional age, without a trailing space when unknown.
+ */
+export function sessionStatus(session, now, pending = false) {
+    const age = activityAge(typeof session.updatedAt === 'number' ? session.updatedAt : undefined, now);
+    return `${SESSION_MARKERS[sessionState(session, pending)]}${age === '' ? '' : ` ${age}`}`;
+}
+/** States a workspace rollup reports, most actionable first. */
+export const ROLLUP_STATES = ['needs', 'running', 'idle'];
+/** Count the sessions of one workspace by the state each reports.
+ *
+ * Blank sessions are counted by neither a badge nor a word: a session that never sent a turn is the
+ * absence of activity, and listing it beside real work only makes the rollup harder to read.
+ * @param sessions - Sessions whose `sessionIds` belong to the workspace.
+ * @param pending - Session IDs this client holds an unanswered interaction for.
+ * @returns One count per state that occurs, most actionable first, or an empty list.
+ */
+export function workspaceCounts(sessions, pending = new Set()) {
+    const counts = { needs: 0, running: 0, idle: 0 };
+    for (const session of sessions) {
+        const id = session.sessionId;
+        const state = sessionState(session, typeof id === 'string' && pending.has(id));
+        if (state !== 'blank')
+            counts[state] += 1;
+    }
+    return ROLLUP_STATES.filter(state => counts[state] > 0).map(state => ({ state, count: counts[state] }));
+}
+/** Render one rollup as separately coloured cells.
+ *
+ * Each cell after the first carries the separator that joins it to the previous one, so a caller can
+ * colour the cells independently without losing the text {@link workspaceStatus} would produce.
+ * @param counts - Counts from {@link workspaceCounts}.
+ * @param style - `words` spells each state out; `badges` keeps only the marker and the count.
+ * @returns The cells in the order given, with their separators.
+ */
+export function workspaceSegments(counts, style = 'words') {
+    const separator = style === 'words' ? ' · ' : ' ';
+    return counts.map(({ state, count }, index) => ({ state,
+        text: `${index === 0 ? '' : separator}${style === 'words' ? `${SESSION_MARKERS[state]} ${count} ${STATE_LABELS[state]}` : `${SESSION_MARKERS[state]}${count}`}` }));
+}
+/** Render one rollup as plain text, the same way every screen and test reads it.
+ * @param counts - Counts from {@link workspaceCounts}.
+ * @param style - `words` spells each state out; `badges` keeps only the marker and the count.
+ * @returns The joined cell text, empty when nothing was counted.
+ */
+export function workspaceStatus(counts, style = 'words') {
+    return workspaceSegments(counts, style).map(segment => segment.text).join('');
+}
+/** Marker key for the compact rollup, which has no room for the words. */
+export const ROLLUP_LEGEND = `${SESSION_MARKERS.idle} ${STATE_LABELS.idle} · ${SESSION_MARKERS.running} ${STATE_LABELS.running} · ${SESSION_MARKERS.needs} ${STATE_LABELS.needs}`;
+/** Secondary path text for one workspace row.
+ *
+ * The title is usually the last path segment, so repeating it wastes the row; the parent directory
+ * is what distinguishes two checkouts. A title that does not name the last segment keeps the full
+ * path, because dropping it would hide where the workspace actually lives.
+ * @param path - Registered host directory.
+ * @param title - Workspace title as the row already shows it.
+ * @returns The path to show beside the row, or an empty string when nothing is left.
+ */
+export function workspaceDetail(path, title) {
+    if (!path)
+        return '';
+    const trimmed = path.replace(/\/+$/u, '');
+    const cut = trimmed.lastIndexOf('/');
+    const base = cut < 0 ? trimmed : trimmed.slice(cut + 1);
+    if (base !== title)
+        return path;
+    if (cut > 0)
+        return trimmed.slice(0, cut);
+    return cut === 0 ? '/' : '';
+}

package/dist/ui/chat/shell-view.d.ts

@@ -0,0 +1,47 @@
+import type { HistoryRow, RowKind } from '../../contracts.ts';
+import type { ShellBlock } from '../../contracts.ts';
+/** The part of a transcript layout this module needs to place a block. */
+export interface RowSource {
+    /** Number of host rows, live tail included. */
+    length: number;
+    /** Host rows in a range. */
+    viewport(start: number, end: number): HistoryRow[];
+    /** Projected messages in ascending sequence order. */
+    messages: readonly {
+        seq: number;
+    }[];
+    /** Row index where each visible message starts. */
+    offsets: ReadonlyMap<number, number>;
+}
+/** Rows for one run: the command bar, then its wrapped and indented output.
+ * @param run - Block from the shell controller.
+ * @param width - Available terminal columns.
+ * @returns Rows in display order.
+ */
+export declare function blockRows(run: ShellBlock, width: number): HistoryRow[];
+/** Splice every retained block into a transcript layout.
+ *
+ * Equal anchors keep creation order, and an anchor older than a block already placed is clamped to
+ * it, so the merged stream stays ordered even as history is paged in behind the reader.
+ * @param layout - Transcript layout to merge with.
+ * @param runs - Blocks from the shell controller, oldest first.
+ * @param width - Available terminal columns.
+ * @returns The merged row count and a reader over a merged range.
+ */
+export declare function mergeShellRuns(layout: RowSource, runs: readonly ShellBlock[], width: number): {
+    total: number;
+    /** Merged row index of each block bar that opens a readable source, to its source id. */
+    sources: ReadonlyMap<number, string>;
+    viewport(start: number, end: number): HistoryRow[];
+};
+/** Wrap plain local text into terminal rows, preserving its own whitespace.
+ *
+ * Command output is aligned by spaces and indented by stack traces, so this never collapses runs of
+ * whitespace the way tool summaries do; only the terminal width decides where a row breaks.
+ * @param text - Raw text, possibly containing newlines.
+ * @param width - Available terminal columns.
+ * @param kind - Row kind used for coloring.
+ * @param highlight - Whether the rows are a local command line drawn on the command bar.
+ * @returns One row per wrapped terminal line; empty text yields one empty row.
+ */
+export declare function plainRows(text: string, width: number, kind: RowKind, highlight?: boolean): HistoryRow[];

package/dist/ui/chat/shell-view.js

@@ -0,0 +1,145 @@
+/** Local `!` blocks as transcript rows: a highlighted command bar, then its indented output.
+ *
+ * A block is spliced into the conversation where it happened — after the newest record the session
+ * had when the command started — so it scrolls away like any message instead of sitting pinned to
+ * the bottom of the screen.
+ */
+import stringWidth from 'string-width';
+import wrapAnsi from 'wrap-ansi';
+/** First output row's marker, so a block reads as the command's result. */
+const MARKER = '  ⎿  ';
+/** Rows after the first, aligned under the marker. */
+const GUTTER = '   ';
+/** Rows for one run: the command bar, then its wrapped and indented output.
+ * @param run - Block from the shell controller.
+ * @param width - Available terminal columns.
+ * @returns Rows in display order.
+ */
+export function blockRows(run, width) {
+    const reserve = Math.max(stringWidth(MARKER), stringWidth(GUTTER));
+    const rows = [{ text: run.kind === 'note' ? run.command : `! ${run.command}`,
+            kind: 'shell', bold: true, highlight: true }];
+    // A note produced nothing to show, so its second row is the action itself. The label is the whole
+    // affordance — a sentence saying "click this bar" left the reader clicking a row that was not the
+    // bar — and every row of a note opens the source (see `mergeShellRuns`).
+    if (run.kind === 'note') {
+        rows.push({ text: run.source === undefined ? `${MARKER}no readable session yet` : `${MARKER}view`,
+            kind: 'shell', bold: true });
+        return rows;
+    }
+    const body = [
+        ...(run.dropped > 0 ? [`… ${run.dropped} earlier lines dropped …`] : []),
+        ...run.lines,
+    ];
+    if (!body.length)
+        body.push(run.status === 'running' ? 'running…' : '(no output)');
+    body.forEach((line, index) => {
+        const wrapped = plainRows(line, Math.max(8, width - reserve), 'shell');
+        wrapped.forEach((row, position) => {
+            rows.push({ ...row, text: `${index === 0 && position === 0 ? MARKER : GUTTER}${row.text}` });
+        });
+    });
+    if (run.status === 'exited' && (run.signal != null || (run.code ?? 0) !== 0)) {
+        rows.push({ text: `${GUTTER}exit ${run.signal ?? run.code}`, kind: 'muted' });
+    }
+    return rows;
+}
+/** Host row index where a block anchored at `anchor` belongs.
+ *
+ * It goes after every row of the newest message it followed, which is the start of the next message,
+ * or the end of the layout when nothing newer is loaded.
+ * @param layout - Transcript layout to place into.
+ * @param anchor - Durable sequence the command followed.
+ * @returns Host row index.
+ */
+function rowAfter(layout, anchor) {
+    let low = 0, high = layout.messages.length;
+    while (low < high) {
+        const mid = (low + high) >> 1;
+        if (layout.messages[mid].seq <= anchor)
+            low = mid + 1;
+        else
+            high = mid;
+    }
+    if (low >= layout.messages.length)
+        return layout.length;
+    return layout.offsets.get(layout.messages[low].seq) ?? layout.length;
+}
+/** Splice every retained block into a transcript layout.
+ *
+ * Equal anchors keep creation order, and an anchor older than a block already placed is clamped to
+ * it, so the merged stream stays ordered even as history is paged in behind the reader.
+ * @param layout - Transcript layout to merge with.
+ * @param runs - Blocks from the shell controller, oldest first.
+ * @param width - Available terminal columns.
+ * @returns The merged row count and a reader over a merged range.
+ */
+export function mergeShellRuns(layout, runs, width) {
+    const placements = [];
+    const sources = new Map();
+    let cursor = 0;
+    for (const run of runs) {
+        const at = Math.max(cursor, Math.min(layout.length, rowAfter(layout, run.anchor)));
+        placements.push({ at, rows: blockRows(run, width), ...(run.source === undefined ? {} : { source: run.source }),
+            ...(run.kind === 'note' ? { whole: true } : {}) });
+        cursor = at;
+    }
+    // Segments alternate host rows and block rows in merged index order.
+    const segments = [];
+    let merged = 0, host = 0;
+    for (const placement of placements) {
+        if (placement.at > host) {
+            segments.push({ from: merged, count: placement.at - host, host });
+            merged += placement.at - host;
+            host = placement.at;
+        }
+        // Only a `!` block's first row is its bar; the rows under it are its output, not its identity.
+        // A note has no output, so all of its rows open what it points at.
+        if (placement.source !== undefined) {
+            const opening = placement.whole === true ? placement.rows.length : 1;
+            for (let offset = 0; offset < opening; offset += 1)
+                sources.set(merged + offset, placement.source);
+        }
+        segments.push({ from: merged, count: placement.rows.length, rows: placement.rows });
+        merged += placement.rows.length;
+    }
+    if (host < layout.length)
+        segments.push({ from: merged, count: layout.length - host, host });
+    const total = merged + Math.max(0, layout.length - host);
+    return {
+        total,
+        sources,
+        viewport(start, end) {
+            const rows = [];
+            for (const segment of segments) {
+                const segmentStart = segment.from, segmentEnd = segment.from + segment.count;
+                if (segmentEnd <= start || segmentStart >= end)
+                    continue;
+                const from = Math.max(0, start - segmentStart);
+                const to = Math.min(segment.count, end - segmentStart);
+                if (to <= from)
+                    continue;
+                if (segment.rows)
+                    rows.push(...segment.rows.slice(from, to));
+                else
+                    rows.push(...layout.viewport(segment.host + from, segment.host + to));
+            }
+            return rows;
+        },
+    };
+}
+/** Wrap plain local text into terminal rows, preserving its own whitespace.
+ *
+ * Command output is aligned by spaces and indented by stack traces, so this never collapses runs of
+ * whitespace the way tool summaries do; only the terminal width decides where a row breaks.
+ * @param text - Raw text, possibly containing newlines.
+ * @param width - Available terminal columns.
+ * @param kind - Row kind used for coloring.
+ * @param highlight - Whether the rows are a local command line drawn on the command bar.
+ * @returns One row per wrapped terminal line; empty text yields one empty row.
+ */
+export function plainRows(text, width, kind, highlight = false) {
+    const columns = Math.max(1, width);
+    const wrapped = wrapAnsi(text === '' ? ' ' : text, columns, { hard: true, trim: false });
+    return wrapped.split('\n').map(line => ({ text: line, kind, ...(highlight ? { highlight: true } : {}) }));
+}

package/dist/ui/chat/status.d.ts

@@ -1,5 +1,49 @@
-import type { Controller } from '../../controller/controller.ts';
-import { type ObjectValue } from '../../transport/wire.ts';
+import type { ClientActivity, Coverage, LivePhase } from '../../contracts.ts';
+/** One formatted cost scope, with the raw totals the money column needs. */
+export interface StatusCostLine {
+    text: string;
+    amount: number;
+    unknown: number;
+}
+/** Everything the status bar renders, as plain data the composition root assembles. */
+export interface StatusSource {
+    /** Host origin, so a reader can tell which deployment the numbers describe. */
+    host: string;
+    online: boolean;
+    status: string;
+    running: boolean;
+    /** What the client is working on now, merged by the controller: a host turn or a running loop.
+     *
+     * The bar renders this and never merges sources itself, so "busy", its clock and the loop's
+     * sub-state all come from one controller-owned answer.
+     */
+    activity?: ClientActivity;
+    sessionId?: string;
+    sessionMode?: string;
+    workspaceLabel: string;
+    activeTurnStartedAt?: number;
+    pendingCount: number;
+    /** What the live attempt is doing now, straight from the record. */
+    livePhase?: LivePhase;
+    /** Retained host projections for the selected session. */
+    values: ObjectValue;
+    queued?: number;
+    jobs?: number;
+    defaultModel?: ObjectValue;
+    /** Billing summary; absent when this run has no ledger. */
+    cost?: {
+        sessionText: string;
+        /** Read on every render, so a day rollover reaches the bar without an application re-render. */
+        today(): StatusCostLine;
+        session(): StatusCostLine | undefined;
+        coverage: Coverage;
+        error?: string;
+    };
+    controlError?: string;
+    presetError?: string;
+    modelError?: string;
+}
+import type { ObjectValue } from '../../json.ts';
 /** Format elapsed wall time, clamping clock skew instead of displaying negative durations.
  * @param milliseconds - Elapsed duration.
  * @returns Minute/second display, with hours when needed.
@@ -77,7 +121,7 @@ export declare function phaseText(milliseconds: number): string;
 export declare function compactStatusRows(groups: StatusGroups, width: number): StatusSegment[][];
 /** Render a live clock and selected-session metadata; the timer belongs to this mounted bar. */
 export declare const StatusBar: import("react").NamedExoticComponent<{
-    controller: Controller;
+    source: StatusSource;
     expanded?: boolean;
     width?: number;
     revision?: number;