@itookit/dsht 0.2.4 → 0.3.2

package/dist/ui/commands/parse.js

@@ -0,0 +1,121 @@
+/** Classify one submitted composer line into the action the terminal performs. */
+import { navigationCommand } from "../../session/navigation.js";
+/** Classify one composer draft without performing any of its effects.
+ *
+ * The order of the checks is the command precedence: reference completion, copy mode, the panels
+ * that toggle in place, navigation and removal, then the session and host commands, then answers,
+ * then a plain prompt.
+ * @param raw - Draft exactly as submitted.
+ * @param context - Current UI facts.
+ * @returns The action to perform.
+ */
+export function classifySubmission(raw, context) {
+    if (context.referenceOpen)
+        return { kind: 'reference' };
+    if (context.copyMode)
+        return { kind: 'ignore' };
+    const value = raw.trim();
+    if (!value)
+        return { kind: 'ignore' };
+    if (value === '/copy')
+        return { kind: 'copy' };
+    if (value === '/quit')
+        return { kind: 'quit' };
+    if (value === '/cost')
+        return { kind: 'panel', panel: 'cost' };
+    if (value === '/status')
+        return { kind: 'panel', panel: 'status' };
+    if (value === '/help')
+        return { kind: 'panel', panel: 'help' };
+    const navigation = navigationCommand(value);
+    if (navigation && /^--(?:delete|archive)(?:\s|$)/.test(navigation.query ?? '')) {
+        const query = navigation.query.replace(/^--(?:delete|archive)\s*/, '');
+        if (!query)
+            return { kind: 'error', message: 'Specify the name or ID to remove' };
+        return { kind: 'remove', target: navigation.kind, query };
+    }
+    if (navigation)
+        return { kind: 'navigate', target: navigation.kind, query: navigation.query };
+    if (context.screen === 'path')
+        return { kind: 'path', value };
+    if (value === '/latest')
+        return { kind: 'latest' };
+    if (/^\/model(?: |$)/.test(value)) {
+        if (context.screen !== 'chat')
+            return { kind: 'error', message: 'Select a session first' };
+        const args = value.split(/\s+/).slice(1);
+        if (args.length && (args.length < 2 || args.length > 3))
+            return { kind: 'error', message: 'Use /model [provider model [effort]]' };
+        return { kind: 'models', args };
+    }
+    if (value === '/queue') {
+        if (context.screen !== 'chat')
+            return { kind: 'error', message: 'Select a session first' };
+        if (context.pending)
+            return { kind: 'error', message: 'Answer the pending question or approval first' };
+        return { kind: 'queue' };
+    }
+    if (value === '/new')
+        return { kind: 'newSession' };
+    if (value === '/history' || value.startsWith('/history ')) {
+        if (context.screen !== 'chat')
+            return { kind: 'error', message: 'Select a session first' };
+        return { kind: 'history', query: value.slice(8).trim() };
+    }
+    if (/^\/(?:search|ssearch|wsearch)(?: |$)/.test(value)) {
+        const [command, ...words] = value.split(' ');
+        const query = words.join(' ').trim();
+        if (!query)
+            return { kind: 'error', message: `Use ${command} <text>` };
+        return command === '/search' ? { kind: 'historySearch', query }
+            : { kind: 'sessionSearch', command: command, query };
+    }
+    if (/^\/think(?: |$)/.test(value)) {
+        if (context.screen !== 'chat')
+            return { kind: 'error', message: 'Select a session first' };
+        return { kind: 'think', target: value.slice(6).trim() };
+    }
+    if (value === '/older')
+        return { kind: 'older' };
+    if (/^\/compact(?: |$)/.test(value)) {
+        if (context.screen !== 'chat')
+            return { kind: 'error', message: 'Select a session first' };
+        if (value !== '/compact')
+            return { kind: 'error', message: 'Use /compact (no arguments)' };
+        return { kind: 'compact' };
+    }
+    if (value === '/cancel')
+        return { kind: 'cancel' };
+    if (value === '/allow')
+        return { kind: 'approval', allowed: true };
+    if (value === '/deny')
+        return { kind: 'approval', allowed: false };
+    if (/^\/(?:plan|goal|permission|feedback)(?:\s|$)/.test(value)) {
+        if (context.screen !== 'chat')
+            return { kind: 'error', message: 'Select a session first' };
+        if (context.pending)
+            return { kind: 'error', message: 'Answer the pending question or approval first' };
+        return { kind: 'hostCommand', line: value };
+    }
+    if (/^\/export(?:\s|$)/.test(value)) {
+        if (context.screen !== 'chat')
+            return { kind: 'error', message: 'Select a session first' };
+        const destination = value.slice(7).trim().replace(/^(["'])(.*)\1$/, '$2');
+        return { kind: 'export', ...(destination ? { destination } : {}) };
+    }
+    if (/^\/export-html(?:\s|$)/.test(value)) {
+        if (context.screen !== 'chat')
+            return { kind: 'error', message: 'Select a session first' };
+        const destination = value.slice(12).trim().replace(/^(["'])(.*)\1$/, '$2');
+        return { kind: 'exportHtml', ...(destination ? { destination } : {}) };
+    }
+    if (context.question)
+        return { kind: 'answer', text: value };
+    if (context.pending)
+        return { kind: 'error', message: 'Answer the approval with /allow or /deny' };
+    if (value.startsWith('/'))
+        return { kind: 'error', message: 'Unknown command. Use /help.' };
+    if (context.screen !== 'chat')
+        return { kind: 'error', message: 'Choose a session or type /ws or /resume' };
+    return { kind: 'prompt', text: value };
+}

package/dist/ui/commands/registry.d.ts

@@ -0,0 +1,33 @@
+/** Slash-command catalog shared by completion, `/help` and the submission router. */
+/** One slash command advertised by completion and `/help`. */
+export interface CommandHint {
+    /** Slash command as typed without arguments. */
+    command: string;
+    /** Argument hint shown after the command; absent when it takes none. */
+    usage?: string;
+    /** One-line action description shown by `/help`. */
+    description: string;
+}
+/** Command discovery catalog shared by Tab completion and the `/help` panel. */
+export declare const COMMAND_HINTS: readonly CommandHint[];
+/** Command names only, in catalog order. */
+export declare const COMMANDS: string[];
+/** Command column text per hint, aligned in the `/help` panel. */
+export declare const COMMAND_LABELS: string[];
+/** Widest command column, so descriptions start on one column. */
+export declare const COMMAND_LABEL_WIDTH: number;
+/** Longest common prefix of the candidate commands, so Tab can extend an ambiguous draft.
+ * @param values - Command candidates.
+ * @returns The shared leading prefix.
+ */
+export declare function commonPrefix(values: string[]): string;
+/** Complete the leading slash command; an ambiguous draft extends to the shared prefix.
+ * @param input - Current composer draft.
+ * @returns The completed draft, or undefined when nothing can be completed.
+ */
+export declare function completeCommand(input: string): string | undefined;
+/** Commands matching the current draft, shown under the composer.
+ * @param input - Current composer draft.
+ * @returns Candidate command names.
+ */
+export declare function suggestedCommands(input: string): string[];

package/dist/ui/commands/registry.js

@@ -0,0 +1,72 @@
+/** Slash-command catalog shared by completion, `/help` and the submission router. */
+/** Command discovery catalog shared by Tab completion and the `/help` panel. */
+export const COMMAND_HINTS = [
+    { command: '/ws', usage: '[name or ID]', description: 'List/switch workspaces; --delete name removes registration' },
+    { command: '/resume', usage: '[title or ID]', description: 'List/switch sessions; --delete ID archives with confirmation' },
+    { command: '/model', usage: '[provider model [effort]]', description: 'Choose a model and reasoning effort for subsequent requests' },
+    { command: '/new', description: 'Create a session in the selected workspace' },
+    { command: '/copy', description: 'Freeze for native selection; Esc resumes (Ctrl+S shortcut)' },
+    { command: '/latest', description: 'Return to the live conversation' },
+    { command: '/older', description: 'Load earlier history' },
+    { command: '/history', usage: '[text]', description: 'List your prompts, optionally filtered' },
+    { command: '/search', usage: 'text', description: 'Search history page by page and open a match' },
+    { command: '/ssearch', usage: 'text', description: 'Search sessions in the current workspace' },
+    { command: '/wsearch', usage: 'text', description: 'Search sessions across all workspaces' },
+    { command: '/compact', description: 'Compact older history while the session is idle' },
+    { command: '/cancel', description: 'Cancel the active turn' },
+    { command: '/queue', description: 'View and remove pending input' },
+    { command: '/plan', usage: '[off|message]', description: 'Enter or leave host plan mode' },
+    { command: '/goal', usage: '[action|objective]', description: 'View or manage the host task goal' },
+    { command: '/permission', usage: '[preset]', description: 'View or switch the host permission preset' },
+    { command: '/feedback', usage: 'text', description: 'Record feedback about the session' },
+    { command: '/export', usage: '[local.zip]', description: 'Save the session log ZIP to a new local file' },
+    { command: '/export-html', usage: '[local.html]', description: 'Save loaded conversation with diagrams and math as offline HTML' },
+    { command: '/allow', description: 'Approve the pending request once' },
+    { command: '/deny', description: 'Reject the pending request' },
+    { command: '/status', description: 'Show full session status details' },
+    { command: '/cost', description: 'Show cost estimates and refresh usage' },
+    { command: '/think', usage: '[seq or live]', description: 'Inspect reasoning with user prompt summaries' },
+    { command: '/help', description: 'Show this command list' },
+    { command: '/quit', description: 'Exit dsht' },
+];
+/** Command names only, in catalog order. */
+export const COMMANDS = COMMAND_HINTS.map(hint => hint.command);
+/** Command column text per hint, aligned in the `/help` panel. */
+export const COMMAND_LABELS = COMMAND_HINTS.map(hint => hint.usage === undefined ? hint.command : `${hint.command} ${hint.usage}`);
+/** Widest command column, so descriptions start on one column. */
+export const COMMAND_LABEL_WIDTH = Math.max(...COMMAND_LABELS.map(label => label.length)) + 2;
+/** Longest common prefix of the candidate commands, so Tab can extend an ambiguous draft.
+ * @param values - Command candidates.
+ * @returns The shared leading prefix.
+ */
+export function commonPrefix(values) {
+    let prefix = values[0] ?? '';
+    for (const value of values) {
+        let index = 0;
+        while (index < prefix.length && index < value.length && prefix[index] === value[index])
+            index++;
+        prefix = prefix.slice(0, index);
+    }
+    return prefix;
+}
+/** Complete the leading slash command; an ambiguous draft extends to the shared prefix.
+ * @param input - Current composer draft.
+ * @returns The completed draft, or undefined when nothing can be completed.
+ */
+export function completeCommand(input) {
+    if (!input.startsWith('/') || input.includes(' '))
+        return undefined;
+    const matches = COMMANDS.filter(command => command.startsWith(input));
+    const only = matches.length === 1 ? matches[0] : undefined;
+    if (only !== undefined)
+        return `${only} `;
+    const prefix = commonPrefix(matches);
+    return prefix.length > input.length ? prefix : undefined;
+}
+/** Commands matching the current draft, shown under the composer.
+ * @param input - Current composer draft.
+ * @returns Candidate command names.
+ */
+export function suggestedCommands(input) {
+    return COMMANDS.filter(command => input.startsWith('/') && !input.includes(' ') && command.startsWith(input));
+}

package/dist/ui/copy-mode.d.ts

@@ -0,0 +1,4 @@
+/** True while copy mode keeps pickers and the composer inactive. */
+export declare const CopyMode: import("react").Context<boolean>;
+/** @returns Whether the surrounding application is in copy mode. */
+export declare function useCopyMode(): boolean;

package/dist/ui/copy-mode.js

@@ -0,0 +1,6 @@
+/** Whether copy mode froze the display for native terminal selection. */
+import { createContext, useContext } from 'react';
+/** True while copy mode keeps pickers and the composer inactive. */
+export const CopyMode = createContext(false);
+/** @returns Whether the surrounding application is in copy mode. */
+export function useCopyMode() { return useContext(CopyMode); }

package/dist/{cost-view.d.ts → ui/dialogs/cost.d.ts}

@@ -1,4 +1,4 @@
-import type { Controller } from './controller.ts';
+import type { Controller } from '../../controller/index.ts';
 /** Render cached totals while the independent HTTP cost scan refreshes.
  * @param controller - Selected session and origin-scoped cost ledger.
  * @returns Billing panel, including unpriced models and refresh errors.

package/dist/{cost-view.js → ui/dialogs/cost.js}

@@ -1,9 +1,9 @@
 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.js";
+import { useTheme } from "../theme/index.js";
 import { Box, Text } from 'ink';
-import { costText } from "./cost.js";
-import { safeText } from "./wire.js";
+import { costText } from "../../cost/index.js";
+import { safeText } from "../../transport/wire.js";
 /** Render cached totals while the independent HTTP cost scan refreshes.
  * @param controller - Selected session and origin-scoped cost ledger.
  * @returns Billing panel, including unpriced models and refresh errors.

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

@@ -0,0 +1,120 @@
+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 Choice } from './picker.tsx';
+/** Pending host input with explicit removal.
+ * @param props - Queue contents, geometry and availability.
+ * @returns The pending-input picker.
+ */
+export declare function QueueDialog({ queued, rows, width, unavailable, enabled, canSelect, onRemove }: {
+    queued: readonly QueuedInput[];
+    rows: number;
+    width: number;
+    unavailable: boolean;
+    enabled: boolean;
+    canSelect(): boolean;
+    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.
+ */
+export declare function RemovalDialog({ removal, enabled, canSelect, onCancel, onConfirm }: {
+    removal: RemovalTarget;
+    enabled: boolean;
+    canSelect(): boolean;
+    onCancel(): void;
+    onConfirm(): void;
+}): import("react").JSX.Element;
+/** Two-step model and reasoning-effort selector. */
+export interface ModelState {
+    catalog: ObjectValue;
+    provider?: string;
+    model?: ObjectValue;
+}
+/** Model routes and adapter-owned reasoning efforts.
+ * @param props - Catalog, current step and its selection actions.
+ * @returns The model or effort picker.
+ */
+export declare function ModelDialog({ models, rows, width, enabled, canSelect, onChoose, onOpen, onBack, onClose }: {
+    models: ModelState;
+    rows: number;
+    width: number;
+    enabled: boolean;
+    canSelect(): boolean;
+    onChoose(provider: string, model: string, effort?: string): void;
+    onOpen(provider: string, model: ObjectValue): void;
+    onBack(): void;
+    onClose(): void;
+}): import("react").JSX.Element;
+/** Bounded host session-search results.
+ * @param props - Query, results and their opening action.
+ * @returns The session-search picker.
+ */
+export declare function SearchResultsDialog({ query, items, hasMore, width, enabled, canSelect, onOpen, onClose }: {
+    query: string;
+    items: readonly ObjectValue[];
+    hasMore: boolean;
+    width: number;
+    enabled: boolean;
+    canSelect(): boolean;
+    onOpen(sessionId: string): void;
+    onClose(): void;
+}): import("react").JSX.Element;
+/** Title, current selection and confirm action for a picker screen.
+ * @param props - Screen title, list identity and navigation state.
+ * @returns The picker screen.
+ */
+export declare function PickerScreen({ title, identity, choices, enabled, canSelect }: {
+    title: string;
+    identity: string;
+    choices: Choice[];
+    enabled: boolean;
+    canSelect(): boolean;
+}): import("react").JSX.Element;
+/** Newest-first reasoning summaries with the preceding user prompt.
+ * @param props - Loaded entries and lazy paging action.
+ * @returns The reasoning list.
+ */
+export declare function ThoughtsDialog({ identity, options, empty, rows, enabled, canSelect }: {
+    identity: string;
+    options: Choice[];
+    empty: boolean;
+    rows: number;
+    enabled: boolean;
+    canSelect(): boolean;
+}): import("react").JSX.Element;
+/** Loaded prompts or bounded content matches with a jump action.
+ * @param props - Query mode, matches and the selected record.
+ * @returns The history or search picker.
+ */
+export declare function HistoryDialog({ identity, contentSearch, matches, query, messages, width, enabled, canSelect, onJump, onClose }: {
+    identity: string;
+    contentSearch: boolean;
+    matches?: HistorySearch;
+    query: string;
+    messages: readonly Message[];
+    width: number;
+    enabled: boolean;
+    canSelect(): boolean;
+    onJump(seq: number): void;
+    onClose(): void;
+}): import("react").JSX.Element;
+/** Paged slash-command reference.
+ * @param props - Current page, page count and rows per page.
+ * @returns The help panel.
+ */
+export declare function HelpPanel({ page, pages, pageSize }: {
+    page: number;
+    pages: number;
+    pageSize: number;
+}): import("react").JSX.Element;
+/** Compact preview of host-owned pending input above the composer.
+ * @param props - Pending items and available columns.
+ * @returns Up to two pending-input rows.
+ */
+export declare function QueuedPreview({ queued, width }: {
+    queued: readonly QueuedInput[];
+    width: number;
+}): import("react").JSX.Element;

package/dist/ui/dialogs/index.js

@@ -0,0 +1,113 @@
+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 { useTheme } from "../theme/index.js";
+import { Picker } from "./picker.js";
+/** Pending host input with explicit removal.
+ * @param props - Queue contents, geometry and availability.
+ * @returns The pending-input picker.
+ */
+export function QueueDialog({ queued, rows, width, unavailable, enabled, canSelect, onRemove }) {
+    return _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Pending input \u00B7 Esc close" }), !queued.length && _jsx(Text, { dimColor: true, children: unavailable ? 'Host queue unavailable' : 'No pending input' }), _jsx(Picker, { choices: queued.map(item => ({
+                    key: item.id, label: toolLine(item.text, width - 6),
+                    action: () => onRemove(item.id),
+                    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 })] });
+}
+/** Confirmation for workspace removal or session archival.
+ * @param props - Reviewed target and its confirmation actions.
+ * @returns The confirmation dialog.
+ */
+export function RemovalDialog({ removal, enabled, canSelect, onCancel, onConfirm }) {
+    const theme = useTheme();
+    return _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Text, { bold: true, color: theme.colors.context, children: removal.kind === 'workspace' ? 'Remove workspace registration?' : 'Archive session?' }), _jsx(Text, { wrap: "truncate-end", children: safeText(removal.name) }), _jsxs(Text, { wrap: "truncate-end", children: ["ID: ", safeText(removal.id)] }), removal.path && _jsxs(Text, { wrap: "truncate-end", children: ["Path: ", safeText(removal.path)] }), _jsx(Text, { children: removal.kind === 'workspace' ? 'Removes the workspace from the list. Directory and sessions are kept.' : 'Hides the session from lists. History is kept; /resume ID can reopen it.' }), _jsx(Text, { dimColor: true, children: "Running tasks continue. Esc cancels this dialog." }), _jsx(Picker, { choices: [
+                    { key: 'cancel', label: 'Cancel', action: onCancel },
+                    { key: 'confirm', label: removal.kind === 'workspace' ? 'Remove workspace' : 'Archive session', action: onConfirm },
+                ], enabled: enabled, canSelect: canSelect }, `${removal.kind}:${removal.id}`)] });
+}
+/** Model routes and adapter-owned reasoning efforts.
+ * @param props - Catalog, current step and its selection actions.
+ * @returns The model or effort picker.
+ */
+export function ModelDialog({ models, rows, width, enabled, canSelect, onChoose, onOpen, onBack, onClose }) {
+    const theme = useTheme();
+    return _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Text, { bold: true, children: models.model ? 'Choose reasoning effort' : 'Choose model' }), _jsx(Text, { dimColor: true, children: "Applies to subsequent requests; host also saves the default." }), array(models.catalog.failures).map(object).map(failure => _jsx(Text, { color: theme.colors.error, children: safeText(`${failure.name}: ${failure.message}`) }, string(failure.id))), _jsx(Picker, { pageSize: Math.max(1, Math.min(8, rows - 15)), choices: models.model ? [
+                    { key: 'default', label: `Default effort${object(models.model.reasoning).defaultEffort ? ` · ${string(object(models.model.reasoning).defaultEffort)}` : ''}`,
+                        action: () => onChoose(models.provider, string(models.model.id)) },
+                    ...array(object(models.model.reasoning).efforts).map(object).map(effort => ({ key: string(effort.id), label: toolLine(`${effort.name} (${effort.id})${effort.description ? ` · ${effort.description}` : ''}`, width - 2),
+                        action: () => onChoose(models.provider, string(models.model.id), string(effort.id)) })),
+                    { key: 'back', label: '← Models', action: onBack },
+                ] : [
+                    ...array(models.catalog.groups).map(object).flatMap(group => array(group.models).map(object).map(model => ({
+                        key: `${group.id}:${model.id}`, label: toolLine(`${group.name} · ${model.name} (${model.id})`, width - 2),
+                        action: () => {
+                            if (array(object(model.reasoning ?? { efforts: [] }).efforts).length)
+                                onOpen(string(group.id), model);
+                            else
+                                onChoose(string(group.id), string(model.id));
+                        },
+                    }))),
+                    { key: 'close', label: '← Back to conversation', action: onClose },
+                ], enabled: enabled, canSelect: canSelect }, models.model ? `${models.provider}:${models.model.id}` : 'models')] });
+}
+/** Bounded host session-search results.
+ * @param props - Query, results and their opening action.
+ * @returns The session-search picker.
+ */
+export function SearchResultsDialog({ query, items, hasMore, width, enabled, canSelect, onOpen, onClose }) {
+    const theme = useTheme();
+    return _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsxs(Text, { bold: true, children: ["Session search \u00B7 ", safeText(query)] }), hasMore && _jsx(Text, { color: theme.colors.context, children: "Host returned only the first 20 global matches; workspace results may be incomplete. Refine your query." }), !items.length && _jsx(Text, { children: "No sessions in the returned results" }), _jsx(Picker, { choices: [...items.map(item => ({ key: string(item.sessionId),
+                        label: toolLine(`${item.sessionId} · ${item.snippet}`, width - 2),
+                        action: () => onOpen(string(item.sessionId)) })), { key: 'close', label: '← Back', action: onClose }], enabled: enabled, canSelect: canSelect })] });
+}
+/** Title, current selection and confirm action for a picker screen.
+ * @param props - Screen title, list identity and navigation state.
+ * @returns The picker screen.
+ */
+export function PickerScreen({ title, identity, choices, enabled, canSelect }) {
+    return _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Text, { bold: true, children: title }), _jsx(Picker, { choices: choices, enabled: enabled, canSelect: canSelect }, identity)] });
+}
+/** Newest-first reasoning summaries with the preceding user prompt.
+ * @param props - Loaded entries and lazy paging action.
+ * @returns The reasoning list.
+ */
+export function ThoughtsDialog({ identity, options, empty, rows, enabled, canSelect }) {
+    const theme = useTheme();
+    return _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Text, { bold: true, color: theme.colors.reasoning, children: "Reasoning history \u00B7 User prompts \u00B7 Esc close" }), empty && _jsx(Text, { dimColor: true, children: "No reasoning in loaded history" }), _jsx(Picker, { choices: options, pageSize: Math.max(1, Math.min(6, Math.floor((rows - 14) / 2))), enabled: enabled, canSelect: canSelect }, identity)] });
+}
+/** Loaded prompts or bounded content matches with a jump action.
+ * @param props - Query mode, matches and the selected record.
+ * @returns The history or search picker.
+ */
+export function HistoryDialog({ identity, contentSearch, matches, query, messages, width, enabled, canSelect, onJump, onClose }) {
+    const theme = useTheme();
+    const needle = query.toLowerCase();
+    return _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsxs(Text, { bold: true, children: [contentSearch ? 'Search · session history' : 'History · loaded records', " \u00B7 Esc close"] }), contentSearch && matches?.truncated && _jsx(Text, { color: theme.colors.context, children: "Showing the first 200 matches \u00B7 Refine your search" }), _jsx(Picker, { choices: [
+                    ...(contentSearch && matches ? matches.items.map(message => ({
+                        key: String(message.seq), label: toolLine(`#${message.seq} ${message.role} · ${message.preview}`, width - 2),
+                        action: () => onJump(message.seq),
+                    })) : messages.filter(message => message.role === 'You' && `${message.seq} ${message.text}`.toLowerCase().includes(needle)).map(message => ({
+                        key: String(message.seq), label: toolLine(`#${message.seq} ${message.role} · ${message.text}`, width - 2),
+                        action: () => onJump(message.seq),
+                    }))),
+                    { key: 'close', label: '← Back to conversation', action: onClose },
+                ], enabled: enabled, canSelect: canSelect }, identity)] });
+}
+/** Paged slash-command reference.
+ * @param props - Current page, page count and rows per page.
+ * @returns The help panel.
+ */
+export function HelpPanel({ page, pages, pageSize }) {
+    const theme = useTheme();
+    return _jsxs(Box, { flexDirection: "column", flexShrink: 1, minHeight: 0, overflowY: "hidden", children: [COMMAND_HINTS.slice(page * pageSize, (page + 1) * pageSize).map((hint, index) => _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [_jsx(Text, { color: theme.accent, children: COMMAND_LABELS[page * pageSize + index].padEnd(COMMAND_LABEL_WIDTH) }), hint.description] }, hint.command)), _jsxs(Text, { dimColor: true, children: ["Help ", page + 1, "/", pages, " \u00B7 PgUp/PgDn pages \u00B7 Esc close"] }), _jsx(Text, { dimColor: true, children: "Enter send \u00B7 Tab complete \u00B7 Esc cancel \u00B7 Wheel/PgUp/PgDn scroll \u00B7 Ctrl+C clear / stop / exit" }), _jsx(Text, { dimColor: true, children: "History: \u2191/\u2193 or Ctrl+P/N recall \u00B7 Editing: Ctrl+A/E start/end \u00B7 Ctrl+K/U kill right/left \u00B7 Ctrl+W kill word \u00B7 Ctrl+Y restore" })] });
+}
+/** Compact preview of host-owned pending input above the composer.
+ * @param props - Pending items and available columns.
+ * @returns Up to two pending-input rows.
+ */
+export function QueuedPreview({ queued, width }) {
+    return _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsxs(Text, { dimColor: true, children: ["Waiting: ", queued.length, " \u00B7 /queue to remove"] }), queued.slice(0, 2).map(item => _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [item.placement === 'steering' ? '↳ ' : '· ', safeText(toolLine(item.text, width - 6))] }, item.id))] });
+}

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

@@ -0,0 +1,18 @@
+/** One selectable row; a `remove` action adds the archive/delete affordance. */
+export interface Choice {
+    key: string;
+    label: string;
+    action(): void;
+    remove?(): void;
+}
+/** Keyboard-driven list with paging and optional removal.
+ * @param props - Choices, availability, page size and hint text.
+ * @returns The rendered list rows and its navigation hint.
+ */
+export declare function Picker({ choices, enabled, canSelect, pageSize, hint }: {
+    choices: Choice[];
+    enabled: boolean;
+    canSelect(): boolean;
+    pageSize?: number;
+    hint?: string;
+}): import("react").JSX.Element;

package/dist/ui/dialogs/picker.js

@@ -0,0 +1,38 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/** Shared list selector used by every picker and dialog. */
+import { useEffect, useRef, useState } from 'react';
+import { Box, Text, useInput, useStdin } from 'ink';
+import { safeText } from "../../transport/wire.js";
+import { useCopyMode } from "../copy-mode.js";
+import { useTheme } from "../theme/index.js";
+/** Keyboard-driven list with paging and optional removal.
+ * @param props - Choices, availability, page size and hint text.
+ * @returns The rendered list rows and its navigation hint.
+ */
+export function Picker({ choices, enabled, canSelect, pageSize = 12, hint }) {
+    const theme = useTheme();
+    const copyMode = useCopyMode();
+    const [selected, setSelected] = useState(0);
+    const current = Math.min(selected, choices.length - 1);
+    const { internal_eventEmitter } = useStdin();
+    const rawKey = useRef('');
+    useEffect(() => {
+        const remember = (raw) => { rawKey.current = raw; };
+        internal_eventEmitter.prependListener('input', remember);
+        return () => { internal_eventEmitter.removeListener('input', remember); };
+    }, [internal_eventEmitter]);
+    useInput((_input, key) => {
+        if (!canSelect() || key.eventType === 'release')
+            return;
+        if (key.upArrow)
+            setSelected(Math.max(0, current - 1));
+        else if (key.downArrow)
+            setSelected(Math.min(choices.length - 1, current + 1));
+        else if (_input === 'd' && !key.ctrl && !key.meta || key.delete && /^\x1b\[3(?:;\d+)?~$/.test(rawKey.current))
+            choices[current]?.remove?.();
+        else if (key.return)
+            choices[current]?.action();
+    }, { isActive: enabled && !copyMode });
+    const start = Math.max(0, current - Math.max(0, pageSize - 1));
+    return _jsxs(Box, { flexDirection: "column", children: [choices.slice(start, start + pageSize).map((choice, index) => _jsxs(Text, { color: start + index === current ? theme.accent : undefined, children: [start + index === current ? '❯ ' : '  ', safeText(choice.label)] }, choice.key)), _jsx(Text, { dimColor: true, children: hint ?? `↑ ↓ select · Enter open${choices.some(choice => choice.remove) ? ' · d/Delete remove / archive' : ''} · Ctrl+C stop / exit` })] });
+}

package/dist/ui/frozen.d.ts

@@ -0,0 +1,8 @@
+/** Retain rendered subtrees while the display is paused for reading or selection. */
+import { type ReactNode } from 'react';
+/** Retain rendered children while frozen; local dialog interactions remain outside this wrapper. */
+export declare const Frozen: import("react").NamedExoticComponent<{
+    children: ReactNode;
+    frozen: boolean;
+    identity: string;
+}>;

package/dist/ui/frozen.js

@@ -0,0 +1,7 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+/** Retain rendered subtrees while the display is paused for reading or selection. */
+import { memo } from 'react';
+/** Retain rendered children while frozen; local dialog interactions remain outside this wrapper. */
+export const Frozen = memo(function Frozen({ children }) {
+    return _jsx(_Fragment, { children: children });
+}, (previous, next) => previous.frozen && next.frozen && previous.identity === next.identity);

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

@@ -0,0 +1,12 @@
+import type { FileReference } from '../../session/references.ts';
+/** Candidates for the unfinished reference at the end of the draft.
+ * @param props - Lookup result and the highlighted candidate.
+ * @returns The completion menu.
+ */
+export declare function ReferenceMenu({ matches, index }: {
+    matches?: {
+        items: FileReference[];
+        error?: string;
+    };
+    index: number;
+}): import("react").JSX.Element;

package/dist/ui/input/references.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** Trailing `@` host-path completion menu. */
+import { Box, Text } from 'ink';
+import { useTheme } from "../theme/index.js";
+/** Candidates for the unfinished reference at the end of the draft.
+ * @param props - Lookup result and the highlighted candidate.
+ * @returns The completion menu.
+ */
+export function ReferenceMenu({ matches, index }) {
+    const theme = useTheme();
+    const start = Math.max(0, index - 5);
+    return _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Host files \u00B7 \u2191 \u2193 select \u00B7 Tab/Enter insert \u00B7 Esc close" }), !matches ? _jsx(Text, { dimColor: true, children: "Searching\u2026" }) : matches.error ? _jsx(Text, { color: theme.colors.error, children: matches.error })
+                : matches.items.length === 0 ? _jsx(Text, { dimColor: true, children: "No matching host files" })
+                    : matches.items.slice(start, start + 6).map((item, offset) => _jsxs(Text, { color: offset + start === index ? theme.accent : undefined, children: [offset + start === index ? '❯ ' : '  ', item.path, item.kind === 'directory' ? '/' : ''] }, `${item.kind}:${item.path}`))] });
+}

package/dist/ui/mount.d.ts

@@ -0,0 +1,6 @@
+import type { Controller } from '../controller/index.ts';
+/** Render the application and return the Ink instance that owns its lifetime.
+ * @param controller - Application controller.
+ * @returns The mounted Ink instance.
+ */
+export declare function mount(controller: Controller): import("ink").Instance;

package/dist/ui/mount.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/** The only module that touches Ink's renderer; the CLI mounts the interface through it. */
+import { render } from 'ink';
+import { App } from "./app.js";
+/** Render the application and return the Ink instance that owns its lifetime.
+ * @param controller - Application controller.
+ * @returns The mounted Ink instance.
+ */
+export function mount(controller) {
+    return render(_jsx(App, { controller: controller }), { exitOnCtrlC: false });
+}

package/dist/{theme.d.ts → ui/theme/index.d.ts}

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