@itookit/dsht 0.3.8 → 0.5.1

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

@@ -1,7 +1,7 @@
 /** Measured conversation viewport: only visible rows become React nodes. */
 import { type DOMElement } from 'ink';
 import type { RefObject } from 'react';
-import type { HistoryRow } from '../../session/history.ts';
+import type { HistoryRow } from '../../contracts.ts';
 /** Visible conversation rows plus the scroll hint.
  * @param props - Rows, hint state, freeze identity and the measured box.
  * @returns The scrollable conversation area.

package/dist/ui/dialogs/cost.d.ts

@@ -1,8 +1,25 @@
-import type { Controller } from '../../controller/index.ts';
+import type { Coverage } from '../../contracts.ts';
+/** One formatted cost line: what to show, and how exact it is. */
+export interface CostLine {
+    text: string;
+    unknown: number;
+    records: number;
+}
+/** The billing panel's plain input, assembled by the composition root. */
+export interface CostSource {
+    session?: CostLine;
+    today: CostLine;
+    scanning: boolean;
+    coverage: Coverage;
+    scannedAt?: number;
+    customPrices: boolean;
+    error?: string;
+    missing: readonly string[];
+}
 /** Render cached totals while the independent HTTP cost scan refreshes.
- * @param controller - Selected session and origin-scoped cost ledger.
+ * @param source - Plain billing summary, absent when this run has no ledger.
  * @returns Billing panel, including unpriced models and refresh errors.
  */
-export declare function CostPanel({ controller }: {
-    controller: Controller;
+export declare function CostPanel({ source }: {
+    source?: CostSource;
 }): import("react").JSX.Element;

package/dist/ui/dialogs/cost.js

@@ -2,24 +2,19 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /** Billing estimates with explicit coverage, calendar and unknown-price indicators. */
 import { useTheme } from "../theme/index.js";
 import { Box, Text } from 'ink';
-import { costText } from "../../cost/index.js";
-import { safeText } from "../../transport/wire.js";
+import { safeText } from "../../text.js";
 /** Render cached totals while the independent HTTP cost scan refreshes.
- * @param controller - Selected session and origin-scoped cost ledger.
+ * @param source - Plain billing summary, absent when this run has no ledger.
  * @returns Billing panel, including unpriced models and refresh errors.
  */
-export function CostPanel({ controller }) {
+export function CostPanel({ source }) {
     const theme = useTheme();
-    const costs = controller.costs;
+    const costs = source;
     if (!costs)
         return _jsx(Text, { children: "Cost tracking is unavailable" });
-    const id = controller.state.sessionId;
-    const rows = [
-        ['Session', id && costs.hasSession(id) ? costs.total(id) : undefined],
-        ['Today', costs.today()],
-    ];
-    return _jsxs(Box, { flexDirection: "column", borderStyle: "single", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Cost \u00B7 CNY estimate \u00B7 Asia/Shanghai \u00B7 /cost closes" }), rows.map(([label, total]) => _jsxs(Text, { children: [label, ": ", total ? `${costText(total)} · ${total.unknown} unpriced / ${total.records} requests` : '?'] }, label)), _jsx(Text, { dimColor: true, children: costs.scanning ? 'Refreshing all visible sessions…'
+    const rows = [['Session', costs.session], ['Today', costs.today]];
+    return _jsxs(Box, { flexDirection: "column", borderStyle: "single", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Cost \u00B7 CNY estimate \u00B7 Asia/Shanghai \u00B7 /cost closes" }), rows.map(([label, total]) => _jsxs(Text, { children: [label, ": ", total ? `${total.text} · ${total.unknown} unpriced / ${total.records} requests` : '?'] }, label)), _jsx(Text, { dimColor: true, children: costs.scanning ? 'Refreshing all visible sessions…'
                     : costs.coverage === 'partial' ? 'Partial totals · awaiting a complete scan'
                         : costs.scannedAt ? `Last refresh: ${new Date(costs.scannedAt).toISOString()}`
-                            : 'Cached totals from the previous run' }), costs.customPrices && _jsx(Text, { color: theme.colors.context, children: "Rates come from prices.json, not the shipped table." }), _jsx(Text, { dimColor: true, children: "Recorded settlement time determines tariff; * means a subtotal is not exact. Provider invoices are authoritative." }), costs.error && _jsxs(Text, { color: theme.colors.context, children: ["Partial totals: ", safeText(costs.error)] }), costs.missing().slice(0, 6).map(reason => _jsx(Text, { color: theme.colors.context, children: safeText(reason) }, reason))] });
+                            : 'Cached totals from the previous run' }), costs.customPrices && _jsx(Text, { color: theme.colors.context, children: "Rates come from prices.json, not the shipped table." }), _jsx(Text, { dimColor: true, children: "Recorded settlement time determines tariff; * means a subtotal is not exact. Provider invoices are authoritative." }), costs.error && _jsxs(Text, { color: theme.colors.context, children: ["Partial totals: ", safeText(costs.error)] }), costs.missing.slice(0, 6).map(reason => _jsx(Text, { color: theme.colors.context, children: safeText(reason) }, reason))] });
 }

package/dist/ui/dialogs/index.d.ts

@@ -1,7 +1,7 @@
-import { type ObjectValue } from '../../transport/wire.ts';
-import { type Message } from '../../session/transcript.ts';
-import type { HistorySearch, RemovalTarget } from '../../session/types.ts';
-import type { QueuedInput } from '../../session/telemetry.ts';
+import { type ObjectValue } from '../../json.ts';
+import { type Message, type SavedPrompt } from '../../contracts.ts';
+import type { HistorySearch, RemovalTarget } from '../../contracts.ts';
+import type { QueuedInput } from '../../contracts.ts';
 import { type Choice } from './picker.tsx';
 /** Pending host input with explicit removal.
  * @param props - Queue contents, geometry and availability.
@@ -16,6 +16,23 @@ export declare function QueueDialog({ queued, rows, width, unavailable, enabled,
     canSelect(): boolean;
     onRemove(id: string): void;
 }): import("react").JSX.Element;
+/** Operator-saved shortcut prompts with choose, edit and delete.
+ *
+ * Enter hands the text to the composer rather than sending it, so the reader can adjust it first.
+ * @param props - Saved entries, their load error, geometry and the three row actions.
+ * @returns The saved-prompt picker.
+ */
+export declare function PromptsDialog({ identity, prompts, error, width, enabled, canSelect, onChoose, onEdit, onRemove }: {
+    identity: string;
+    prompts: readonly SavedPrompt[];
+    error?: string;
+    width: number;
+    enabled: boolean;
+    canSelect(): boolean;
+    onChoose(text: string): void;
+    onEdit(prompt: SavedPrompt): void;
+    onRemove(id: string): void;
+}): import("react").JSX.Element;
 /** Confirmation for workspace removal or session archival.
  * @param props - Reviewed target and its confirmation actions.
  * @returns The confirmation dialog.
@@ -27,7 +44,7 @@ export declare function RemovalDialog({ removal, enabled, canSelect, onCancel, o
     onCancel(): void;
     onConfirm(): void;
 }): import("react").JSX.Element;
-import type { ModelState } from '../../session/index.ts';
+import type { ModelState } from '../../contracts.ts';
 /** Two-step model and reasoning-effort selector; the state shape is shared with the session. */
 export type { ModelState };
 /** Model routes and adapter-owned reasoning efforts.

package/dist/ui/dialogs/index.js

@@ -1,9 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /** Modal panels and list screens rendered inside the shared composer frame. */
 import { Box, Text } from 'ink';
-import { array, object, safeText, string } from "../../transport/wire.js";
-import { toolLine } from "../../session/transcript.js";
-import { COMMAND_HINTS, COMMAND_LABELS, COMMAND_LABEL_WIDTH } from "../commands/registry.js";
+import { array, object, string } from "../../json.js";
+import { safeText } from "../../text.js";
+import { toolLine } from "../../text.js";
+import { COMMAND_HINTS, COMMAND_LABELS, COMMAND_LABEL_WIDTH } from "../../slash/registry.js";
 import { useTheme } from "../theme/index.js";
 import { Picker } from "./picker.js";
 /** Pending host input with explicit removal.
@@ -17,6 +18,21 @@ export function QueueDialog({ queued, rows, width, unavailable, enabled, canSele
                     remove: () => onRemove(item.id),
                 })), pageSize: Math.max(1, Math.min(6, rows - 12)), hint: "\u2191 \u2193 select \u00B7 Enter / d / Delete remove \u00B7 Esc close", enabled: enabled, canSelect: canSelect })] });
 }
+/** Operator-saved shortcut prompts with choose, edit and delete.
+ *
+ * Enter hands the text to the composer rather than sending it, so the reader can adjust it first.
+ * @param props - Saved entries, their load error, geometry and the three row actions.
+ * @returns The saved-prompt picker.
+ */
+export function PromptsDialog({ identity, prompts, error, width, enabled, canSelect, onChoose, onEdit, onRemove }) {
+    const theme = useTheme();
+    return _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Text, { bold: true, children: "Saved prompts \u00B7 Esc close" }), error !== undefined && _jsx(Text, { color: theme.colors.error, wrap: "truncate-end", children: safeText(error) }), !prompts.length && _jsx(Text, { dimColor: true, children: "No saved prompts \u00B7 add one with /prompt TEXT" }), _jsx(Picker, { choices: prompts.map(prompt => ({
+                    key: prompt.id, label: toolLine(prompt.text, width - 6),
+                    action: () => onChoose(prompt.text),
+                    edit: () => onEdit(prompt),
+                    remove: () => onRemove(prompt.id),
+                })), hint: "\u2191 \u2193 select \u00B7 Enter use \u00B7 e edit \u00B7 d/Delete delete \u00B7 Esc close", enabled: enabled, canSelect: canSelect }, identity)] });
+}
 /** Confirmation for workspace removal or session archival.
  * @param props - Reviewed target and its confirmation actions.
  * @returns The confirmation dialog.

package/dist/ui/dialogs/loop.d.ts

@@ -0,0 +1,43 @@
+import type { LoopLimits, LoopRecord } from '../../contracts.ts';
+/** The numeric fields the form edits, in the order a run reads them. */
+export type LoopField = 'from' | 'to' | 'score' | 'tries';
+/** What the form hands to the runner: the four numbers and the record's variables as confirmed. */
+export interface LoopRun {
+    limits: LoopLimits;
+    vars: Readonly<Record<string, string>>;
+}
+/** The values a run from one record would start with, which the form shows before anything is typed.
+ * @param record - Chosen record.
+ * @returns Its first round, last round and declared score and attempt budgets.
+ */
+export declare function loopRecordDefaults(record: LoopRecord): LoopLimits;
+/** The record list shown under the composer while `/loop` is being typed.
+ *
+ * It offers the same names and defaults the runner reads, so choosing from it cannot start a run
+ * other than the one the row describes.
+ * @param props - Matching records and the highlighted row.
+ * @returns The key line and up to six record rows.
+ */
+export declare function LoopMenu({ records, index }: {
+    records: readonly LoopRecord[];
+    index: number;
+}): import("react").JSX.Element;
+/** The loop parameter form: one record's variables and defaults, editable in place, then a Start.
+ *
+ * Values are replaced by typing over them, so no flag has to be remembered and every default stays
+ * visible until it is changed. A record variable is free text because it is a path or a target, not a
+ * number; the four limits share the command line's own validation. Leaving a row — with Enter or with
+ * an arrow — commits what was typed, so no box needs its own confirmation and Start reads the values
+ * as displayed. The run starts only from the Start row, so no keystroke that edits a value can launch
+ * it by accident. The form stays readable and escapable even when the host is busy or gone; only Start
+ * is unavailable then.
+ * @param props - The chosen record, whether a run may start now, and the three row actions.
+ * @returns The form.
+ */
+export declare function LoopDialog({ record, enabled, onStart, onBack, onClose }: {
+    record: LoopRecord;
+    enabled: boolean;
+    onStart(run: LoopRun): void;
+    onBack(): void;
+    onClose(): void;
+}): import("react").JSX.Element;

package/dist/ui/dialogs/loop.js

@@ -0,0 +1,224 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** The `/loop` record list and the parameter form that confirms a chosen record's defaults. */
+import { useMemo, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { validLoopOption } from "../../slash/parse.js";
+import { safeText } from "../../text.js";
+import { useCopyMode } from "../copy-mode.js";
+import { useTheme } from "../theme/index.js";
+const FIELDS = [
+    { field: 'from', label: 'From', hint: 'first round, 1 or more' },
+    { field: 'to', label: 'To', hint: 'last round, at least From' },
+    { field: 'score', label: 'Pass', hint: 'passing score, 0–10' },
+    { field: 'tries', label: 'Tries', hint: 'attempts per round, 1 or more' },
+];
+/** The values a run from one record would start with, which the form shows before anything is typed.
+ * @param record - Chosen record.
+ * @returns Its first round, last round and declared score and attempt budgets.
+ */
+export function loopRecordDefaults(record) {
+    return { from: 1, to: record.steps, score: record.defaultScore, tries: record.defaultTries };
+}
+/** The form's rows for one record: its own variables first, then the shared run limits.
+ *
+ * The record's variables lead because they are why this record's form was opened at all: the document
+ * under review is the decision that matters most, and it is not something the command line spells out.
+ * @param record - Chosen record.
+ * @returns The ordered rows.
+ */
+function rowsFor(record) {
+    return [
+        { kind: 'start' },
+        ...Object.keys(record.vars).map(name => ({ kind: 'var', name })),
+        ...FIELDS.map(spec => ({ kind: 'field', spec })),
+        { kind: 'back' },
+    ];
+}
+/** Columns the label occupies, so the values line up whatever names a record declares.
+ * @param rows - Rows being rendered.
+ * @returns One past the longest label.
+ */
+function labelWidth(rows) {
+    const longest = Math.max(0, ...rows.map(row => row.kind === 'field' ? row.spec.label.length
+        : row.kind === 'var' ? row.name.length : 0));
+    return Math.max(5, longest) + 1;
+}
+/** The record list shown under the composer while `/loop` is being typed.
+ *
+ * It offers the same names and defaults the runner reads, so choosing from it cannot start a run
+ * other than the one the row describes.
+ * @param props - Matching records and the highlighted row.
+ * @returns The key line and up to six record rows.
+ */
+export function LoopMenu({ records, index }) {
+    const theme = useTheme();
+    const start = Math.max(0, index - 5);
+    return _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Loop records \u00B7 \u2191 \u2193 select \u00B7 Enter confirm defaults \u00B7 Tab finish the name \u00B7 Esc close" }), records.slice(start, start + 6).map((record, offset) => {
+                const current = start + offset === index;
+                // The record's own inputs come before the artifact file: they are what the form will edit, and
+                // the first thing a narrow row must not lose.
+                const vars = Object.entries(record.vars).map(([name, value]) => `${name} ${value}`).join(' · ');
+                const target = vars === '' ? '' : ` · ${vars}`;
+                const artifact = record.artifact === undefined ? '' : ` · ${record.artifact}`;
+                return _jsxs(Text, { color: current ? theme.accent : undefined, wrap: "truncate-end", children: [current ? '❯ ' : '  ', record.name, " \u00B7 ", record.title, " \u00B7 ", record.steps, " rounds \u00B7 pass ", record.defaultScore, " \u00B7 \u2264", record.defaultTries, " tries", target, artifact] }, record.name);
+            })] });
+}
+/** The loop parameter form: one record's variables and defaults, editable in place, then a Start.
+ *
+ * Values are replaced by typing over them, so no flag has to be remembered and every default stays
+ * visible until it is changed. A record variable is free text because it is a path or a target, not a
+ * number; the four limits share the command line's own validation. Leaving a row — with Enter or with
+ * an arrow — commits what was typed, so no box needs its own confirmation and Start reads the values
+ * as displayed. The run starts only from the Start row, so no keystroke that edits a value can launch
+ * it by accident. The form stays readable and escapable even when the host is busy or gone; only Start
+ * is unavailable then.
+ * @param props - The chosen record, whether a run may start now, and the three row actions.
+ * @returns The form.
+ */
+export function LoopDialog({ record, enabled, onStart, onBack, onClose }) {
+    const theme = useTheme();
+    const copyMode = useCopyMode();
+    const defaults = loopRecordDefaults(record);
+    const rows = useMemo(() => rowsFor(record), [record]);
+    const width = useMemo(() => labelWidth(rows), [rows]);
+    const [row, setRow] = useState(0);
+    const [values, setValues] = useState(defaults);
+    const [vars, setVars] = useState({ ...record.vars });
+    const [edit, setEdit] = useState();
+    const [error, setError] = useState();
+    const current = rows[Math.min(row, rows.length - 1)];
+    /** Validate and apply the selected editable row's buffer.
+     *
+     * Leaving a row takes its value with it, so no box needs its own Enter: an arrow to the next row
+     * commits what was typed, and Start then reads the committed values. A value that cannot be used
+     * keeps the cursor on its row and says why, so nothing is dropped silently.
+     * @returns True when it is safe to leave the row.
+     */
+    const applyEdit = () => {
+        if (edit === undefined || current.kind === 'start' || current.kind === 'back')
+            return true;
+        if (current.kind === 'var') {
+            const value = edit.trim();
+            if (value === '') {
+                setError(`${current.name}: a value is required`);
+                return false;
+            }
+            if (value !== vars[current.name])
+                setVars({ ...vars, [current.name]: value });
+            setEdit(undefined);
+            setError(undefined);
+            return true;
+        }
+        // Nothing typed (or the value erased) leaves the field as it was rather than reading `''` as 0.
+        if (edit === '') {
+            setEdit(undefined);
+            setError(undefined);
+            return true;
+        }
+        const parsed = Number(edit);
+        if (!validLoopOption(current.spec.field, parsed)) {
+            setError(`${current.spec.label}: ${current.spec.hint}`);
+            return false;
+        }
+        const next = { ...values, [current.spec.field]: parsed };
+        if (next.to < next.from) {
+            setError('To must be at least From');
+            return false;
+        }
+        setValues(next);
+        setEdit(undefined);
+        setError(undefined);
+        return true;
+    };
+    const move = (next) => {
+        if (!applyEdit())
+            return;
+        setRow(Math.max(0, Math.min(rows.length - 1, next)));
+        setEdit(undefined);
+        setError(undefined);
+    };
+    useInput((input, key) => {
+        if (key.eventType === 'release')
+            return;
+        if (key.escape) {
+            if (edit !== undefined) {
+                setEdit(undefined);
+                setError(undefined);
+            }
+            else
+                onClose();
+            return;
+        }
+        if (key.upArrow) {
+            move(row - 1);
+            return;
+        }
+        if (key.downArrow) {
+            move(row + 1);
+            return;
+        }
+        if (current.kind === 'var') {
+            const { name } = current;
+            if (key.backspace || key.delete) {
+                setEdit((edit ?? vars[name] ?? '').slice(0, -1));
+                setError(undefined);
+                return;
+            }
+            // A variable is a path or a target, so anything printable goes in; control bytes never do.
+            const typed = input.replace(/[\u0000-\u001f\u007f]/g, '');
+            if (typed !== '' && !key.ctrl && !key.meta) {
+                setEdit(edit === undefined ? typed : edit + typed);
+                setError(undefined);
+                return;
+            }
+            if (key.return)
+                move(row + 1);
+            return;
+        }
+        if (current.kind === 'field') {
+            const { field } = current.spec;
+            if (key.backspace || key.delete) {
+                setEdit((edit ?? String(values[field])).slice(0, -1));
+                setError(undefined);
+                return;
+            }
+            if (/^[0-9.]$/.test(input)) {
+                setEdit(edit === undefined ? input : edit + input);
+                setError(undefined);
+                return;
+            }
+            if (key.return)
+                move(row + 1);
+            return;
+        }
+        if (!key.return)
+            return;
+        if (current.kind === 'back') {
+            onBack();
+            return;
+        }
+        if (!enabled) {
+            setError('Cannot start: the host is busy or offline');
+            return;
+        }
+        if (values.to < values.from) {
+            setError('To must be at least From');
+            return;
+        }
+        onStart({ limits: values, vars });
+    }, { isActive: !copyMode });
+    return _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsxs(Text, { bold: true, children: ["Run loop record \u00B7 ", safeText(record.name), " \u00B7 Esc close"] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [record.steps, " rounds", record.artifact === undefined ? '' : ` · ${safeText(record.artifact)}`, " \u00B7 \u2191 \u2193 to a row, then type"] }), rows.map((item, index) => {
+                const selected = index === row;
+                const cursor = selected ? '❯ ' : '  ';
+                if (item.kind === 'start' || item.kind === 'back')
+                    return _jsxs(Text, { color: selected ? theme.accent : undefined, children: [cursor, item.kind === 'start' ? 'Start run' : '← Choose another record'] }, item.kind);
+                if (item.kind === 'var') {
+                    const value = vars[item.name] ?? '';
+                    const shown = selected && edit !== undefined ? edit : value;
+                    return _jsxs(Text, { color: selected ? theme.accent : undefined, children: [cursor, item.name.padEnd(width), selected && edit !== undefined ? _jsx(Text, { inverse: true, children: shown || ' ' }) : shown, value === record.vars[item.name] ? null : _jsxs(Text, { dimColor: true, children: [" \u00B7 default ", record.vars[item.name]] })] }, `var:${item.name}`);
+                }
+                const { field, label } = item.spec;
+                const shown = selected && edit !== undefined ? edit : String(values[field]);
+                return _jsxs(Text, { color: selected ? theme.accent : undefined, children: [cursor, label.padEnd(width), selected && edit !== undefined ? _jsx(Text, { inverse: true, children: shown || ' ' }) : shown, values[field] === defaults[field] ? null : _jsxs(Text, { dimColor: true, children: [" \u00B7 default ", defaults[field]] })] }, `field:${field}`);
+            }), error !== undefined && _jsx(Text, { color: theme.colors.error, children: safeText(error) }), _jsx(Text, { dimColor: true, children: "Enter edit a value / start \u00B7 type to replace \u00B7 Esc close" })] });
+}

package/dist/ui/dialogs/peek.d.ts

@@ -0,0 +1,25 @@
+/** The full-screen read-only view of one output source.
+ *
+ * A reader opens this to watch work that is not their conversation — a verifier's session, a subagent
+ * child, a local `!` run — without selecting it. The application follows the source and hands over laid
+ * out rows; this only draws them, so nothing here can write to what it is showing.
+ */
+import { type DOMElement } from 'ink';
+import type { RefObject } from 'react';
+import type { HistoryRow, OutputSource } from '../../contracts.ts';
+/** Draw one read-only source: its header, its content viewport, and the scroll line.
+ * @param props - The source, its already-laid-out rows and the reader's position in them.
+ * @returns The panel, filling the body area it is given.
+ */
+export declare function PeekPanel({ source, error, rows, position, total, width, now, boxRef }: {
+    source: OutputSource;
+    error?: string;
+    rows: HistoryRow[];
+    /** Rows scrolled back from the newest row; 0 is the live end. */
+    position: number;
+    /** Rows the source has in total, so the footer can place the window. */
+    total: number;
+    width: number;
+    now: number;
+    boxRef: RefObject<DOMElement | null>;
+}): import("react").JSX.Element;

package/dist/ui/dialogs/peek.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** The full-screen read-only view of one output source.
+ *
+ * A reader opens this to watch work that is not their conversation — a verifier's session, a subagent
+ * child, a local `!` run — without selecting it. The application follows the source and hands over laid
+ * out rows; this only draws them, so nothing here can write to what it is showing.
+ */
+import { Box, Text } from 'ink';
+import { HistoryViewport } from "../chat/history-view.js";
+import { elapsedTime } from "../chat/status.js";
+import { useTheme } from "../theme/index.js";
+/** One source's identity line: what it is, who made it, how it is doing. */
+function metaLine(source, now) {
+    const parts = [
+        source.detail ?? (source.kind === 'session' ? 'session' : 'local process'),
+        source.state,
+        source.parentSessionId === undefined ? undefined : `from ${source.parentSessionId}`,
+        source.startedAt === undefined ? undefined
+            : source.state === 'running' ? `started ${new Date(source.startedAt).toLocaleTimeString()}`
+                : `ran ${elapsedTime((source.endedAt ?? now) - source.startedAt)}`,
+    ];
+    return parts.filter((part) => part !== undefined).join(' · ');
+}
+/** Draw one read-only source: its header, its content viewport, and the scroll line.
+ * @param props - The source, its already-laid-out rows and the reader's position in them.
+ * @returns The panel, filling the body area it is given.
+ */
+export function PeekPanel({ source, error, rows, position, total, width, now, boxRef }) {
+    const theme = useTheme();
+    const end = Math.max(0, total - position);
+    const first = Math.max(1, end - rows.length + 1);
+    return _jsxs(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, minHeight: 0, overflowY: "hidden", marginY: 1, children: [_jsx(Text, { bold: true, color: theme.accent, wrap: "truncate-end", children: source.label }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [source.id, " \u00B7 ", metaLine(source, now)] }), error !== undefined && _jsx(Text, { color: theme.colors.error, wrap: "truncate-end", children: error }), _jsx(Text, { dimColor: true, children: '─'.repeat(Math.max(0, width - 4)) }), _jsx(Box, { ref: boxRef, flexDirection: "column", flexGrow: 1, flexShrink: 1, minHeight: 0, overflowY: "hidden", children: rows.length === 0
+                    ? _jsx(Text, { color: theme.colors.muted, children: source.state === 'running' ? 'No output yet.' : 'This source has no output.' })
+                    : _jsx(HistoryViewport, { rows: rows }) }), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: total === 0 ? 'Esc closes' : `Esc closes · ↑ ↓ / PgUp PgDn / wheel scroll · lines ${first}–${end} of ${total}` })] });
+}

package/dist/ui/dialogs/picker.d.ts

@@ -19,6 +19,8 @@ export interface Choice {
     /** Trailing column, right-aligned and truncated from its start so a path keeps its tail. */
     detail?: string;
     action(): void;
+    /** `e` edits the row's own content, on surfaces that keep editable entries. */
+    edit?(): void;
     remove?(): void;
 }
 /** Keyboard-driven list with paging and optional removal.

package/dist/ui/dialogs/picker.js

@@ -3,7 +3,7 @@ import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useRef, useState } from 'react';
 import { Box, Text, useInput, useStdin, useStdout } from 'ink';
 import stringWidth from 'string-width';
-import { safeText } from "../../transport/wire.js";
+import { safeText } from "../../text.js";
 import { useCopyMode } from "../copy-mode.js";
 import { useTheme } from "../theme/index.js";
 /** Display width of one cell list, so wide characters count as two columns. */
@@ -34,6 +34,8 @@ export function Picker({ choices, enabled, canSelect, pageSize = 12, hint, width
             setSelected(Math.max(0, current - 1));
         else if (key.downArrow)
             setSelected(Math.min(choices.length - 1, current + 1));
+        else if (_input === 'e' && !key.ctrl && !key.meta)
+            choices[current]?.edit?.();
         else if (_input === 'd' && !key.ctrl && !key.meta || key.delete && /^\x1b\[3(?:;\d+)?~$/.test(rawKey.current))
             choices[current]?.remove?.();
         else if (key.return)
@@ -66,5 +68,5 @@ export function Picker({ choices, enabled, canSelect, pageSize = 12, hint, width
                 if (!table || !isTableRow)
                     return _jsxs(Text, { color: isCurrent ? theme.accent : undefined, wrap: "truncate-end", children: [cursor, safeText(choice.label)] }, choice.key);
                 return _jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { width: titleColumn, flexShrink: 0, children: _jsxs(Text, { color: isCurrent ? theme.accent : undefined, wrap: "truncate-end", children: [cursor, safeText(choice.title ?? choice.label)] }) }), _jsx(Box, { width: cellColumn, flexShrink: 0, children: _jsx(Text, { wrap: "truncate-end", children: choice.cells?.map((cell, position) => _jsx(Text, { color: cell.color, bold: cell.bold, children: safeText(cell.text) }, position)) }) }), detailShown && choice.detail !== undefined && _jsx(Box, { width: detailColumn, flexShrink: 0, justifyContent: "flex-end", children: _jsx(Text, { dimColor: true, wrap: "truncate-start", children: safeText(choice.detail) }) })] }, choice.key);
-            }), _jsx(Text, { dimColor: true, children: hint ?? `↑ ↓ select · Enter open${choices.some(choice => choice.remove) ? ' · d/Delete remove / archive' : ''} · Ctrl+C stop / exit` })] });
+            }), _jsx(Text, { dimColor: true, children: hint ?? `↑ ↓ select · Enter open${choices.some(choice => choice.edit) ? ' · e edit' : ''}${choices.some(choice => choice.remove) ? ' · d/Delete remove / archive' : ''} · Ctrl+C stop / exit` })] });
 }

package/dist/ui/input/mouse.d.ts

@@ -8,9 +8,19 @@ export declare function isMouseReport(raw: string): boolean;
  * @returns Positive for older history, negative for newer history, or zero.
  */
 export declare function wheelDirection(raw: string): number;
+/** One unmodified left press, in the terminal's own 1-based cells. */
+export interface MousePress {
+    column: number;
+    row: number;
+}
+/** Decode an unmodified left press; releases, motion and modified presses are ignored.
+ * @param raw - One complete SGR mouse report.
+ * @returns The pressed cell, or undefined.
+ */
+export declare function mousePress(raw: string): MousePress | undefined;
 /** Enable cell-based mouse reports for this mount and restore normal terminal behavior on exit.
  * @param scroll - Current transcript scrolling callback.
  * @param enabled - False restores native terminal selection while display updates are paused.
- * @param select - Left press callback that can freeze the display and release mouse capture.
+ * @param press - Left-press callback, given the terminal cell it landed on.
  */
-export declare function useMouseWheel(scroll: (direction: number) => void, enabled?: boolean, select?: () => void): void;
+export declare function useMouseWheel(scroll: (direction: number) => void, enabled?: boolean, press?: (cell: MousePress) => void): void;

package/dist/ui/input/mouse.js

@@ -1,4 +1,4 @@
-/** SGR mouse reporting, shared by transcript scrolling and input suppression. */
+/** SGR mouse reporting, shared by transcript scrolling, row clicks and input suppression. */
 import { useEffect, useRef } from 'react';
 import { useStdin, useStdout } from 'ink';
 /** Recognize complete SGR reports so clicks and wheel bytes never become prompt text.
@@ -18,18 +18,28 @@ export function wheelDirection(raw) {
     const base = button & ~28;
     return base === 64 ? 1 : base === 65 ? -1 : 0;
 }
+/** Decode an unmodified left press; releases, motion and modified presses are ignored.
+ * @param raw - One complete SGR mouse report.
+ * @returns The pressed cell, or undefined.
+ */
+export function mousePress(raw) {
+    const match = /^\x1b\[<0;(\d+);(\d+)M$/.exec(raw);
+    if (!match)
+        return undefined;
+    return { column: Number(match[1]), row: Number(match[2]) };
+}
 /** Enable cell-based mouse reports for this mount and restore normal terminal behavior on exit.
  * @param scroll - Current transcript scrolling callback.
  * @param enabled - False restores native terminal selection while display updates are paused.
- * @param select - Left press callback that can freeze the display and release mouse capture.
+ * @param press - Left-press callback, given the terminal cell it landed on.
  */
-export function useMouseWheel(scroll, enabled = true, select) {
+export function useMouseWheel(scroll, enabled = true, press) {
     const { internal_eventEmitter } = useStdin();
     const { stdout } = useStdout();
     const callback = useRef(scroll);
     callback.current = scroll;
-    const selection = useRef(select);
-    selection.current = select;
+    const onPress = useRef(press);
+    onPress.current = press;
     useEffect(() => {
         if (!enabled)
             return;
@@ -37,8 +47,11 @@ export function useMouseWheel(scroll, enabled = true, select) {
             const direction = wheelDirection(raw);
             if (direction)
                 callback.current(direction);
-            else if (/^\x1b\[<0;\d+;\d+M$/.test(raw))
-                selection.current?.();
+            else {
+                const cell = mousePress(raw);
+                if (cell !== undefined)
+                    onPress.current?.(cell);
+            }
         };
         internal_eventEmitter.on('input', onInput);
         if (stdout.isTTY)

package/dist/ui/input/references.d.ts

@@ -1,4 +1,4 @@
-import type { FileReference } from '../../session/references.ts';
+import type { FileReference } from '../../contracts.ts';
 /** Candidates for the unfinished reference at the end of the draft.
  * @param props - Lookup result and the highlighted candidate.
  * @returns The completion menu.

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

@@ -0,0 +1,7 @@
+/** Presentation helpers for the status and cost panels. */
+import type { CostTotal } from '../../contracts.ts';
+/** Render a cost total with a marker while any record behind it is unpriced.
+ * @param total - Folded session or day total.
+ * @returns The estimate, prefixed `~` because it is derived from usage, not an invoice.
+ */
+export declare function costText(total: CostTotal): string;

package/dist/ui/status/model.js

@@ -0,0 +1,5 @@
+/** Render a cost total with a marker while any record behind it is unpriced.
+ * @param total - Folded session or day total.
+ * @returns The estimate, prefixed `~` because it is derived from usage, not an invoice.
+ */
+export function costText(total) { return `~¥${total.amount.toFixed(4)}${total.unknown ? '*' : ''}`; }

package/dist/ui/theme/index.d.ts

@@ -1,4 +1,4 @@
-import type { RowKind } from '../../session/history.ts';
+import type { RowKind } from '../../contracts.ts';
 /** Themes provide semantic roles so components never depend on palette-specific color names. */
 export interface Theme {
     name: string;