@itookit/dsht 0.3.8 → 0.5.2

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/dialogs/use-panels.d.ts

@@ -0,0 +1,53 @@
+/** UI-owned dialog state and the keyboard traits shared by routing and rendering. */
+import { type SetStateAction } from 'react';
+import type { HistoryPanel, ModelState, PanelName, RemovalTarget, SearchPanel } from '../../contracts.ts';
+type SurfaceName = PanelName | 'peek';
+interface PanelState {
+    thoughts: boolean;
+    queue: boolean;
+    prompts: boolean;
+    help: boolean;
+    cost: boolean;
+    status: boolean;
+    model?: ModelState;
+    history?: HistoryPanel;
+    search?: SearchPanel;
+    removal?: RemovalTarget;
+    loop?: {
+        name: string;
+    };
+}
+interface Surface {
+    name: SurfaceName;
+    open: boolean;
+    arrows?: boolean;
+    blocksKeys?: boolean;
+    reserved?: readonly string[];
+}
+/** The externally owned peek view participates in routing without duplicating its state. */
+export declare function usePanels(options: {
+    sessionId: string | undefined;
+    pendingId: string | undefined;
+    peekOpen: boolean;
+    closePeek(): void;
+}): {
+    state: PanelState;
+    openSurfaces: Surface[];
+    close: (name: SurfaceName) => void;
+    closeExcept: (keep?: SurfaceName) => void;
+    reservedKeys: string[];
+    openThoughts: (value: SetStateAction<boolean>) => void;
+    openQueue: (value: SetStateAction<boolean>) => void;
+    openPrompts: (value: SetStateAction<boolean>) => void;
+    setModelPanel: (value: SetStateAction<ModelState | undefined>) => void;
+    setHistoryPanel: (value: SetStateAction<HistoryPanel | undefined>) => void;
+    setSearchPanel: (value: SetStateAction<SearchPanel | undefined>) => void;
+    setRemoval: (value: SetStateAction<RemovalTarget | undefined>) => void;
+    setLoopForm: (value: SetStateAction<{
+        name: string;
+    } | undefined>) => void;
+    setHelp: (value: SetStateAction<boolean>) => void;
+    setCostExpanded: (value: SetStateAction<boolean>) => void;
+    setStatusExpanded: (value: SetStateAction<boolean>) => void;
+};
+export {};

package/dist/ui/dialogs/use-panels.js

@@ -0,0 +1,51 @@
+/** UI-owned dialog state and the keyboard traits shared by routing and rendering. */
+import { useEffect, useState } from 'react';
+const EMPTY = { thoughts: false, queue: false, prompts: false, help: false, cost: false, status: false };
+const TRAITS = [
+    { name: 'queue', reserved: ['d'] },
+    { name: 'prompts', arrows: true, blocksKeys: true, reserved: ['d', 'e'] },
+    ...['removal', 'model', 'loop', 'thoughts', 'history', 'search'].map(name => ({ name, arrows: true, blocksKeys: true })),
+    ...['help', 'cost', 'status'].map(name => ({ name, blocksKeys: true })),
+];
+/** The externally owned peek view participates in routing without duplicating its state. */
+export function usePanels(options) {
+    const [state, setState] = useState(EMPTY);
+    const setter = (key) => (value) => {
+        setState(current => {
+            const next = typeof value === 'function' ? value(current[key]) : value;
+            return current[key] === next ? current : { ...current, [key]: next };
+        });
+    };
+    useEffect(() => {
+        // Read-only client panels and a chosen removal target survive navigation as before.
+        setState(current => ({ ...EMPTY, help: current.help, cost: current.cost, status: current.status, removal: current.removal }));
+    }, [options.sessionId]);
+    useEffect(() => {
+        setState(current => ({ ...current, queue: false, loop: options.pendingId === undefined ? current.loop : undefined }));
+    }, [options.sessionId, options.pendingId]);
+    const surfaces = [
+        { name: 'peek', open: options.peekOpen, arrows: true, blocksKeys: true },
+        ...TRAITS.map(trait => ({ ...trait, open: trait.name === 'queue' ? state.queue && options.pendingId === undefined
+                : !!state[trait.name] })),
+    ];
+    const openSurfaces = surfaces.filter(surface => surface.open);
+    function close(name) {
+        if (name === 'peek')
+            options.closePeek();
+        else
+            setState(current => ({ ...current, [name]: EMPTY[name] }));
+    }
+    function closeExcept(keep) {
+        if (keep !== 'peek')
+            options.closePeek();
+        setState(current => keep === undefined || keep === 'peek' ? EMPTY : { ...EMPTY, [keep]: current[keep] });
+    }
+    return {
+        state, openSurfaces, close, closeExcept,
+        reservedKeys: [...new Set(openSurfaces.flatMap(surface => surface.reserved ?? []))],
+        openThoughts: setter('thoughts'), openQueue: setter('queue'), openPrompts: setter('prompts'),
+        setModelPanel: setter('model'), setHistoryPanel: setter('history'), setSearchPanel: setter('search'),
+        setRemoval: setter('removal'), setLoopForm: setter('loop'),
+        setHelp: setter('help'), setCostExpanded: setter('cost'), setStatusExpanded: setter('status'),
+    };
+}

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/input/use-composer.d.ts

@@ -0,0 +1,35 @@
+/** A local editor borrows Enter until it is saved or dismissed. */
+export interface ComposerIntent {
+    hint: string;
+    emptyNotice: string;
+    successNotice?: string;
+    commit(text: string): Promise<boolean>;
+}
+/** Identity of a submitted draft, even if a later edit has identical text. */
+export interface DraftReceipt {
+    readonly sessionId: string | undefined;
+    readonly revision: number;
+}
+interface ComposerOptions {
+    sessionId: string | undefined;
+    /** Read at completion too, before React necessarily renders a session change. */
+    currentSession(): string | undefined;
+    resetRecall(): void;
+    messageStarted(): void;
+    notify(message: string): void;
+}
+/** Owns editor state only; command interpretation and keyboard routing stay in App. */
+export declare function useComposer(options: ComposerOptions): {
+    input: string;
+    cursor: number;
+    intent: ComposerIntent | undefined;
+    setInput: (value: string, recalled?: boolean) => void;
+    setCursor: import("react").Dispatch<import("react").SetStateAction<number>>;
+    setIntent: (value: ComposerIntent | undefined) => void;
+    capture: () => DraftReceipt;
+    consume: (receipt: DraftReceipt) => void;
+    recallIfCurrent: (receipt: DraftReceipt, read: () => string) => void;
+    commit: (raw: string) => Promise<boolean>;
+    interactionChanged: (answerPending: boolean, pending: boolean) => void;
+};
+export {};

package/dist/ui/input/use-composer.js

@@ -0,0 +1,109 @@
+/** Session-owned draft, temporary editors and async submission ownership. */
+import { useLayoutEffect, useRef, useState } from 'react';
+import { errorText } from "../../text.js";
+/** Owns editor state only; command interpretation and keyboard routing stay in App. */
+export function useComposer(options) {
+    const [input, setInputValue] = useState('');
+    const [cursor, setCursor] = useState(0);
+    const [intent, publishIntent] = useState();
+    const current = useRef({ sessionId: options.sessionId, revision: 0, input: '', parked: '', intent: undefined });
+    const mounted = useRef(false);
+    const saving = useRef(new WeakSet());
+    function replace(value) {
+        current.current.input = value;
+        current.current.revision += 1;
+        setInputValue(value);
+        setCursor(value.length);
+    }
+    function setIntent(value) {
+        current.current.intent = value;
+        publishIntent(value);
+    }
+    useLayoutEffect(() => {
+        mounted.current = true;
+        return () => { mounted.current = false; };
+    }, []);
+    useLayoutEffect(() => {
+        if (current.current.sessionId === options.sessionId)
+            return;
+        current.current.sessionId = options.sessionId;
+        current.current.parked = '';
+        setIntent(undefined);
+        replace('');
+    }, [options.sessionId]);
+    function setInput(value, recalled = false) {
+        if (!recalled)
+            options.resetRecall();
+        if (current.current.input === '' && value !== '' && !value.startsWith('/'))
+            options.messageStarted();
+        replace(value);
+    }
+    function capture() {
+        return { sessionId: current.current.sessionId, revision: current.current.revision };
+    }
+    function owns(receipt) {
+        return mounted.current && receipt.sessionId === options.currentSession()
+            && receipt.sessionId === current.current.sessionId && receipt.revision === current.current.revision;
+    }
+    function consume(receipt) {
+        if (owns(receipt))
+            setInput('');
+    }
+    /** A slow recall must neither replace newer typing nor move its recall cursor. */
+    function recallIfCurrent(receipt, read) {
+        if (owns(receipt))
+            setInput(read(), true);
+    }
+    /** Returns true whenever an editor handled Enter, including an already pending save. */
+    async function commit(raw) {
+        const editor = current.current.intent;
+        if (!editor)
+            return false;
+        if (saving.current.has(editor))
+            return true;
+        const text = raw.trim();
+        if (!text) {
+            options.notify(editor.emptyNotice);
+            return true;
+        }
+        const receipt = capture();
+        const active = () => mounted.current && current.current.intent === editor
+            && receipt.sessionId === options.currentSession() && receipt.sessionId === current.current.sessionId;
+        saving.current.add(editor);
+        try {
+            if (await editor.commit(text) && active()) {
+                if (editor.successNotice)
+                    options.notify(editor.successNotice);
+                // Continued typing remains in edit mode for the next explicit save.
+                if (owns(receipt)) {
+                    setIntent(undefined);
+                    consume(receipt);
+                }
+            }
+        }
+        catch (error) {
+            if (active())
+                options.notify(errorText(error));
+        }
+        finally {
+            saving.current.delete(editor);
+        }
+        return true;
+    }
+    /** Parking/restoring is not a recall or a new message, so it does not move the reader. */
+    function interactionChanged(answerPending, pending) {
+        if (answerPending) {
+            setIntent(undefined);
+            if (current.current.input !== '') {
+                current.current.parked = current.current.input;
+                replace('');
+            }
+        }
+        else if (!pending && current.current.parked !== '') {
+            const parked = current.current.parked;
+            current.current.parked = '';
+            replace(parked);
+        }
+    }
+    return { input, cursor, intent, setInput, setCursor, setIntent, capture, consume, recallIfCurrent, commit, interactionChanged };
+}

package/dist/ui/input/use-deferred-lines.d.ts

@@ -0,0 +1,16 @@
+import { type AuthorizeFacts, type DeferReason, type LineCommand } from '../../slash/index.ts';
+interface DeferredFacts extends AuthorizeFacts {
+    sessionId: string | undefined;
+    /** Both the connection baseline and the selected conversation snapshot must be restored. */
+    ready: boolean;
+}
+interface DeferredOptions {
+    facts(): DeferredFacts;
+    run(command: LineCommand): Promise<void>;
+    notify(message: string): void;
+}
+/** Owns FIFO and in-flight state, independent of Controller and the composer's current draft. */
+export declare function useDeferredLines(options: DeferredOptions): {
+    enqueue(command: LineCommand, defer: DeferReason): void;
+};
+export {};

package/dist/ui/input/use-deferred-lines.js

@@ -0,0 +1,54 @@
+/** Commands explicitly accepted by the operator, waiting for their execution policy. */
+import { useEffect, useRef, useState } from 'react';
+import { authorize } from "../../slash/index.js";
+import { errorText } from "../../text.js";
+/** Owns FIFO and in-flight state, independent of Controller and the composer's current draft. */
+export function useDeferredLines(options) {
+    const [lines, setLines] = useState([]);
+    const draining = useRef(false);
+    const mounted = useRef(false);
+    useEffect(() => {
+        mounted.current = true;
+        return () => { mounted.current = false; };
+    }, []);
+    // Re-evaluate on UI publications, including connection/snapshot readiness and a completed run.
+    // A synchronous reservation prevents a re-render or StrictMode replay from starting it twice.
+    useEffect(() => {
+        const next = lines[0];
+        if (!next || draining.current)
+            return;
+        const facts = options.facts();
+        if (next.sessionId !== facts.sessionId) {
+            setLines(current => current.filter(line => line.sessionId === facts.sessionId));
+            options.notify('Dropped a queued line: the selected session changed');
+            return;
+        }
+        if (!facts.ready || facts.foreground || (next.defer !== 'busy' && facts.during !== 'idle'))
+            return;
+        const verdict = authorize(next.command, facts);
+        if (verdict.allow && verdict.defer !== undefined)
+            return;
+        draining.current = true;
+        setLines(current => current.slice(1));
+        void (async () => {
+            try {
+                await options.run(verdict.allow ? verdict.command : verdict.error);
+            }
+            catch (error) {
+                if (mounted.current)
+                    options.notify(errorText(error));
+            }
+            finally {
+                draining.current = false;
+                if (mounted.current)
+                    setLines(current => [...current]);
+            }
+        })();
+    });
+    return {
+        enqueue(command, defer) {
+            const sessionId = options.facts().sessionId;
+            setLines(current => [...current, { command, defer, sessionId }]);
+        },
+    };
+}

package/dist/ui/input/use-history-recall.d.ts

@@ -0,0 +1,20 @@
+import type { DraftReceipt } from './use-composer.ts';
+interface RecallSource {
+    readonly hasMore: boolean;
+    readonly beforeSeq: number | undefined;
+}
+interface RecallOptions<Source extends RecallSource> {
+    source: Source;
+    draft: string;
+    capture(): DraftReceipt;
+    restore(receipt: DraftReceipt, read: () => string): void;
+    previous(draft: string): string;
+    refill(): boolean;
+    hasPrevious(): boolean;
+    older(signal: AbortSignal, source: Source): Promise<boolean>;
+    run(work: (signal: AbortSignal) => Promise<boolean>): Promise<boolean | undefined>;
+    notify(message: string): void;
+}
+/** No Controller or Transcript dependency: only the paging and recall capabilities it needs. */
+export declare function useHistoryRecall<Source extends RecallSource>(options: RecallOptions<Source>): () => Promise<void>;
+export {};

package/dist/ui/input/use-history-recall.js

@@ -0,0 +1,47 @@
+/** Lazy prompt recall owns its scan; the composer decides whether the result still belongs to it. */
+import { useRef } from 'react';
+import { errorText } from "../../text.js";
+/** Bound one key press even when many tool-only pages separate user messages. */
+const PAGE_SCAN_LIMIT = 20;
+/** No Controller or Transcript dependency: only the paging and recall capabilities it needs. */
+export function useHistoryRecall(options) {
+    const loading = useRef(false);
+    return async () => {
+        if (loading.current)
+            return;
+        const receipt = options.capture();
+        const { source, draft } = options;
+        const restore = () => options.restore(receipt, () => options.previous(draft));
+        if (options.refill() || options.hasPrevious() || !source.hasMore) {
+            restore();
+            return;
+        }
+        loading.current = true;
+        try {
+            const found = await options.run(async (signal) => {
+                for (let page = 0; page < PAGE_SCAN_LIMIT; page++) {
+                    signal.throwIfAborted();
+                    if (source.beforeSeq === undefined || !source.hasMore)
+                        break;
+                    if (!await options.older(signal, source))
+                        break;
+                    signal.throwIfAborted();
+                    // Startup backfill may have inserted the same prompts while this page was in flight.
+                    if (options.refill() || options.hasPrevious())
+                        return true;
+                }
+                return false;
+            });
+            if (found)
+                restore();
+        }
+        catch (error) {
+            // Foreground cancellation is an expected end to a user-triggered scan.
+            if (!(error instanceof Error && error.name === 'AbortError'))
+                options.notify(errorText(error));
+        }
+        finally {
+            loading.current = false;
+        }
+    };
+}

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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itookit/dsht",
-  "version": "0.3.8",
+  "version": "0.5.2",
   "type": "module",
   "description": "Remote-first TUI for DeepSeek Harness with SSH-friendly mobile access and request-level cost tracking",
   "engines": {
@@ -27,7 +27,7 @@
   "scripts": {
     "start": "tsx src/cli/index.ts",
     "start:profile": "node -e \"require('node:fs').mkdirSync('.diagnostics',{recursive:true})\" && NODE_OPTIONS=\"--expose-gc --heapsnapshot-signal=SIGUSR2 --diagnostic-dir=.diagnostics\" tsx src/cli/index.ts",
-    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
+    "build": "npm run build:prompts && node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
     "typecheck": "tsc --noEmit && tsc -p tsconfig.tests.json",
     "test": "tsx --test tests/*/*.test.ts tests/*/*.test.tsx",
     "test:terminal": "node scripts/test/terminal.mjs",
@@ -35,7 +35,8 @@
     "prepack": "npm run build",
     "prepublishOnly": "npm run typecheck && npm run test:terminal",
     "bench:input": "tsx scripts/benchmarks/input.tsx",
-    "bench:history": "node --import tsx scripts/benchmarks/history.tsx"
+    "bench:history": "node --import tsx scripts/benchmarks/history.tsx",
+    "build:prompts": "tsx scripts/build/loop-prompts.mts"
   },
   "keywords": [
     "deepseek",
@@ -84,6 +85,7 @@
     "@types/ws": "^8.18.1",
     "ink-testing-library": "^4.0.0",
     "tsx": "^4.22.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "yaml": "^2.9.1"
   }
 }