@itookit/dsht 0.3.8 → 0.5.2

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

@@ -0,0 +1,69 @@
+/** Reading position, folds and asynchronous navigation belong to this mounted conversation view. */
+import { type SetStateAction } from 'react';
+import type { Reasoning, SessionRender, ShellBlock } from '../../contracts.ts';
+interface HistorySource {
+    readonly version: number;
+    readonly memoryRevision: number;
+    readonly beforeSeq: number | undefined;
+    readonly ready: boolean;
+    readonly hasMore: boolean;
+    readonly liveAttemptKey: string | undefined;
+}
+interface HistoryViewOptions<S extends HistorySource> {
+    sessionId?: string;
+    source: S;
+    display: S;
+    detached: boolean;
+    width: number;
+    rows: number;
+    showHint: boolean;
+    protect: boolean;
+    enabled: boolean;
+    online: boolean;
+    busy: boolean;
+    revision: number;
+    blocks: readonly ShellBlock[];
+    current(source: S): boolean;
+    render(input: {
+        transcript: S;
+        width: number;
+        folds: ReadonlySet<number>;
+        liveReasoning: Reasoning;
+    }): SessionRender;
+    run<T>(work: (signal: AbortSignal) => Promise<T>, label: string): Promise<T | undefined>;
+    older(signal: AbortSignal, source: S): Promise<boolean>;
+    open(target: number, signal: AbortSignal): Promise<boolean>;
+    pin(value: boolean): void;
+    closePanels(): void;
+    notify(message: string): void;
+}
+export declare function useHistoryView<S extends HistorySource>(options: HistoryViewOptions<S>): {
+    layout: {
+        messages: import("../../contracts.ts").Message[];
+        offsets: Map<number, number>;
+        first: number | undefined;
+        length: number;
+        liveOffset: number;
+        viewport: (start: number, end: number) => import("../../contracts.ts").HistoryRow[];
+        readonly cachedRowCount: number;
+        readonly lines: string[];
+    };
+    merged: {
+        total: number;
+        hostRow(row: number): number;
+        sources: ReadonlyMap<number, string>;
+        viewport(start: number, end: number): import("../../contracts.ts").HistoryRow[];
+    };
+    totalRows: number;
+    pageSize: number;
+    position: number;
+    reasoningOverrides: ReadonlySet<number>;
+    liveReasoning: Reasoning;
+    setScroll: (value: SetStateAction<number>) => void;
+    setReasoningOverrides: (value: SetStateAction<ReadonlySet<number>>) => void;
+    setLiveReasoning: (value: SetStateAction<Reasoning>) => void;
+    scrollHistory: (delta: number) => void;
+    jumpHistory: (target: number) => Promise<void>;
+    historyOperation: <T>(work: (signal: AbortSignal) => Promise<T>, label?: string) => Promise<T | undefined>;
+};
+export {};

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

@@ -0,0 +1,123 @@
+/** Reading position, folds and asynchronous navigation belong to this mounted conversation view. */
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
+import { errorText } from "../../text.js";
+import { mergeShellRuns } from "./shell-view.js";
+export function useHistoryView(options) {
+    const [scroll, setScroll] = useState(0);
+    const [folds, setFolds] = useState(new Set());
+    const [liveReasoning, setLive] = useState('row');
+    const [anchor, setAnchor] = useState();
+    const latest = useRef(options);
+    latest.current = options;
+    const mounted = useRef(true);
+    const intent = useRef(0);
+    const jumpAbort = useRef(undefined);
+    const pageAbort = useRef(undefined);
+    const lifetime = useRef(new AbortController());
+    const paging = useRef(false);
+    const invalidate = () => { intent.current++; jumpAbort.current?.abort(); setAnchor(undefined); };
+    useEffect(() => {
+        if (lifetime.current.signal.aborted)
+            lifetime.current = new AbortController();
+        mounted.current = true;
+        return () => {
+            mounted.current = false;
+            intent.current++;
+            lifetime.current.abort();
+            jumpAbort.current?.abort();
+            pageAbort.current?.abort();
+            latest.current.pin(false);
+        };
+    }, []);
+    useEffect(() => {
+        invalidate();
+        pageAbort.current?.abort();
+        setScroll(0);
+    }, [options.source]);
+    useEffect(() => { setFolds(new Set()); setLive('row'); }, [options.sessionId]);
+    useEffect(() => { setLive('row'); }, [options.source, options.source.liveAttemptKey]);
+    useEffect(() => {
+        const first = options.display.beforeSeq;
+        if (first !== undefined)
+            setFolds(previous => {
+                const next = new Set([...previous].filter(seq => seq >= first));
+                return next.size === previous.size ? previous : next;
+            });
+    }, [options.display, options.display.memoryRevision]);
+    const { source, display, width } = options;
+    const layout = useMemo(() => options.render({ transcript: display, width, folds, liveReasoning }), [display, display.version, width, folds, liveReasoning]);
+    const merged = useMemo(() => mergeShellRuns(layout, options.blocks, width), [layout, options.blocks, options.revision, width]);
+    const pageSize = Math.max(1, options.rows - (options.showHint ? 1 : 0));
+    const totalRows = merged.total;
+    const maxScroll = Math.max(0, totalRows - pageSize);
+    const previousView = useRef({ source, display, count: totalRows, first: layout.first, folds, liveReasoning });
+    const previous = previousView.current;
+    const prepended = previous.first !== undefined && layout.first !== undefined && layout.first < previous.first;
+    const adjusted = previous.source !== source ? 0
+        : scroll > 0 && previous.display === display && !prepended && previous.folds === folds && previous.liveReasoning === liveReasoning
+            ? Math.max(0, scroll + totalRows - previous.count) : scroll;
+    const row = anchor?.source === source ? layout.offsets.get(anchor.target) : undefined;
+    const position = Math.max(0, Math.min(row === undefined ? adjusted : totalRows - pageSize - merged.hostRow(row), maxScroll));
+    useLayoutEffect(() => {
+        previousView.current = { source, display, count: totalRows, first: layout.first, folds, liveReasoning };
+        if (position !== scroll)
+            setScroll(position);
+        if (anchor)
+            setAnchor(undefined);
+    }, [source, display, totalRows, position, scroll, folds, liveReasoning, anchor]);
+    useLayoutEffect(() => { options.pin(!options.detached && (position > 0 || options.protect)); }, [options.detached, position, options.protect, source]);
+    function scrollTo(value) { invalidate(); setScroll(value); }
+    function setReasoningOverrides(value) { invalidate(); setFolds(value); }
+    function setLiveReasoning(value) { invalidate(); setLive(value); }
+    function historyOperation(work, label = 'Loading history…') {
+        return options.run(signal => work(AbortSignal.any([signal, lifetime.current.signal])), label);
+    }
+    function scrollHistory(delta) {
+        if (!options.enabled)
+            return;
+        invalidate();
+        const own = intent.current;
+        const next = Math.max(0, Math.min(maxScroll, position + delta));
+        setScroll(next);
+        if (delta <= 0 || next < maxScroll || paging.current || options.busy || !options.online || !display.ready || !display.hasMore)
+            return;
+        paging.current = true;
+        const abort = new AbortController();
+        pageAbort.current = abort;
+        void historyOperation(signal => options.older(AbortSignal.any([signal, abort.signal]), display)).then(accepted => {
+            if (accepted && mounted.current && latest.current.display === display && options.current(source) && intent.current === own) {
+                setScroll(position + delta);
+            }
+        }).catch(error => {
+            if (mounted.current && !(error instanceof Error && error.name === 'AbortError'))
+                latest.current.notify(errorText(error));
+        }).finally(() => { paging.current = false; if (pageAbort.current === abort)
+            pageAbort.current = undefined; });
+    }
+    async function jumpHistory(target) {
+        if (!options.enabled)
+            throw new Error('Select a session first');
+        invalidate();
+        const own = intent.current;
+        const abort = new AbortController();
+        jumpAbort.current = abort;
+        try {
+            await historyOperation(async (foreground) => {
+                const signal = AbortSignal.any([foreground, abort.signal]);
+                if (!await options.open(target, signal))
+                    return;
+                signal.throwIfAborted();
+                if (!mounted.current || intent.current !== own || !options.current(source))
+                    return;
+                setAnchor({ source, target });
+                latest.current.closePanels();
+            }, 'Jumping to a message…');
+        }
+        finally {
+            if (jumpAbort.current === abort)
+                jumpAbort.current = undefined;
+        }
+    }
+    return { layout, merged, totalRows, pageSize, position, reasoningOverrides: folds, liveReasoning,
+        setScroll: scrollTo, setReasoningOverrides, setLiveReasoning, scrollHistory, jumpHistory, historyOperation };
+}

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;