@itookit/dsht 0.3.2 → 0.3.4

package/dist/ui/app.js

@@ -19,7 +19,7 @@ import { CopyMode } from "./copy-mode.js";
 import { HelpPanel, HistoryDialog, ModelDialog, PickerScreen, QueueDialog, QueuedPreview, RemovalDialog, SearchResultsDialog, ThoughtsDialog } from "./dialogs/index.js";
 import { COMMAND_HINTS, completeCommand as completeDraft, suggestedCommands } from "./commands/registry.js";
 import { classifySubmission } from "./commands/parse.js";
-import { sessionLabel } from "../session/navigation.js";
+import { ROLLUP_LEGEND, sessionLabel, sessionStatus, workspaceCounts, workspaceDetail, workspaceSegments, workspaceStatus } from "../session/navigation.js";
 import { array, errorText, object, safeText, string } from "../transport/wire.js";
 /** Transient notices expire; interactive panels remain open until dismissed. */
 const PANEL_LIFETIME_MS = 10_000;
@@ -125,6 +125,14 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
         const timer = setTimeout(() => setNotice(undefined), panelLifetimeMs);
         return () => clearTimeout(timer);
     }, [notice, panelLifetimeMs, copyMode]);
+    // `/history` is a lookup rather than a panel to read, so it expires with the notice lifetime;
+    // Esc closes it sooner, and its own content search stays open until the reader leaves it.
+    useEffect(() => {
+        if (copyMode || contentSearch || historyQuery === undefined)
+            return;
+        const timer = setTimeout(() => { setHistoryQuery(undefined); setHistoryMatches(undefined); }, panelLifetimeMs);
+        return () => clearTimeout(timer);
+    }, [historyQuery, contentSearch, panelLifetimeMs, copyMode]);
     const pending = state.pending[0];
     const queued = controller.telemetry.pending(state.sessionId).filter(item => item.placement !== 'context');
     useEffect(() => { setQueueOpen(false); }, [state.sessionId, pending?.eventId]);
@@ -185,6 +193,31 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
     // leave the arrows with the history, and Ctrl+P/N reach it from every surface.
     const recallBlocked = !!(removal || models || thoughtList || historyQuery !== undefined || searchResults || (statusExpanded && statusOverflow));
     const questionKeysActive = !!question && options.length > 0 && !choiceState.custom && !copyMode && !panelBlocksKeys;
+    // A dialog that demands an answer owns the keyboard until it is settled: the draft being written is
+    // parked rather than typed into, and comes back when the last one closes. A question switches to
+    // the composer itself for a free-text or "Other" answer, so it keeps the keys then.
+    const answerPending = !!pending && (pending.event === 'approval/request' || options.length > 0 && !choiceState.custom);
+    const parkedDraft = useRef('');
+    useEffect(() => {
+        if (answerPending) {
+            if (draft.current === '')
+                return;
+            parkedDraft.current = draft.current;
+            draft.current = '';
+            updateInput('');
+            setCursor(0);
+            return;
+        }
+        if (pending || parkedDraft.current === '')
+            return;
+        // Restoring writes the states directly: the draft was neither recalled from history nor a new
+        // message, so it must not move a reader's scroll position.
+        const restore = parkedDraft.current;
+        parkedDraft.current = '';
+        draft.current = restore;
+        updateInput(restore);
+        setCursor(restore.length);
+    }, [answerPending, pending]);
     const approvalKeysActive = pending?.event === 'approval/request' && !copyMode && !panelBlocksKeys;
     const approvalIndex = approvalSelection?.eventId === eventId ? approvalSelection.index : -1;
     const answerQuestion = async (selected, custom) => {
@@ -222,13 +255,17 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
         }
         if ((key.escape || key.ctrl && _value === 'c') && historyAbort.current) {
             historyAbort.current.abort();
+            // Esc also leaves a history list that was already on screen when the load was aborted.
+            if (key.escape && historyQuery !== undefined) {
+                setHistoryQuery(undefined);
+                setHistoryMatches(undefined);
+            }
             return;
         }
         if ((key.escape || key.ctrl && _value === 'c') && controller.state.pending.length) {
             if (key.ctrl && draft.current)
                 setInput('');
             if (key.escape) {
-                setOptionState({ ...choiceState, custom: false });
                 setApprovalSelection(undefined);
                 setRemoval(undefined);
                 setModels(undefined);
@@ -239,6 +276,18 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
                 setHelp(false);
                 setCostExpanded(false);
                 setStatusExpanded(false);
+                // A question batch is one request, so Esc leaves the whole set the way the Web client's
+                // close button does. The free-text row keeps its own step back: its first Esc returns to
+                // the options, and only the next one dismisses. Approval keeps every choice explicit.
+                if (pending?.event === 'user-questions/request' && !choiceState.custom) {
+                    if (controller.state.online && !controller.state.busy && controller.state.pending[0]?.eventId === eventId) {
+                        setOptionState(undefined);
+                        setAnswers(previous => { const rest = { ...previous }; delete rest[eventId]; return rest; });
+                        operate(() => controller.dismissQuestion());
+                    }
+                    return;
+                }
+                setOptionState({ ...choiceState, custom: false });
             }
             return;
         }
@@ -335,6 +384,13 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
                 void controller.interrupt(true);
             return;
         }
+        // The typed host path is a screen of its own, so Esc has to leave it: the picker behind it is
+        // disabled while a draft exists, so a leftover path would leave no way back at all.
+        if (key.escape && state.screen === 'path') {
+            setInput('');
+            operate(() => controller.showPicker('workspaces'));
+            return;
+        }
         if (key.ctrl && _value === 'c') {
             // A draft clears first, exactly like a shell prompt; an empty draft still stops or exits.
             if (input !== '') {
@@ -555,6 +611,13 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
                 case 'exportHtml':
                     await historyOperation(async (signal) => { setNotice(`Saved loaded conversation: ${await controller.exportHtml(submission.destination, signal)}`); }, 'Exporting loaded conversation…');
                     return;
+                case 'coredump':
+                    // V8 serializes the heap synchronously, so the client stalls until the file is written;
+                    // the path is reported afterwards so the snapshot can be opened in DevTools.
+                    await historyOperation(async () => {
+                        setNotice(`Heap snapshot saved: ${controller.heapSnapshot(submission.tag)}`);
+                    }, 'Writing heap snapshot…');
+                    return;
                 case 'answer':
                     await answerQuestion(question.multiSelect === true ? choiceState.selected : [], submission.text);
                     return;
@@ -569,22 +632,59 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
         if (accepted)
             setInput('');
     };
+    const width = Math.max(10, (stdout.columns ?? 80) - 2);
+    // The composer never trades the conversation away for input. Its window grows with the body and
+    // is clamped so a few conversation rows always survive; width never buys height, so landscape and
+    // a wide desktop only wrap less instead of showing more input rows. The budget subtracts the one
+    // row the frame, the header, the status bar and a transient notice/suggestion line may each take.
+    const bodyRows = Math.max(4, (stdout.rows ?? 30) - 4 - statusBarRows);
+    const composerRows = Math.max(1, Math.min(Math.min(5, Math.max(2, Math.floor(bodyRows / 3))), bodyRows - 7));
+    const draftWidth = Math.max(1, width - 6);
+    // Session activity is a list-level fact, so both pickers read it without loading any history.
+    const listAge = Date.now();
+    // Unanswered interactions are held per session already; a list only has to read the counts.
+    const pendingCounts = controller.pendingCounts();
+    const isPending = (session) => (pendingCounts.get(string(session.sessionId)) ?? 0) > 0;
+    const sessionsOf = (workspace) => {
+        const ids = new Set(array(workspace.sessionIds).map(string));
+        return state.sessions.filter(session => ids.has(string(session.sessionId)));
+    };
+    // `width` counts only the frame's outer padding, so the list subtracts the composer border and
+    // padding it renders inside; measured against the wider value a long row would still wrap.
+    const pickerWidth = Math.max(16, width - 4);
+    // Words explain themselves. Badges fit a narrow terminal but need the marker key beside them.
+    const rollupStyle = pickerWidth >= 80 ? 'words' : 'badges';
+    // Needs-you is the one state that asks for action, so it outranks working; ready stays quiet.
+    const stateColor = { needs: theme.status.critical, running: theme.status.working, idle: theme.colors.muted };
     const choices = state.screen === 'workspaces' ? [
-        ...state.workspaces.map(workspace => ({ key: string(workspace.workspaceId),
-            label: `${string(workspace.title)}  ${string(workspace.path)}`,
-            remove: () => setRemoval({ kind: 'workspace', id: string(workspace.workspaceId), name: string(workspace.title), path: string(workspace.path) }),
-            action: () => controller.pickWorkspace(string(workspace.workspaceId)) })),
+        ...state.workspaces.map(workspace => {
+            const counts = workspaceCounts(sessionsOf(workspace), new Set(pendingCounts.keys()));
+            const name = string(workspace.title);
+            const title = name || string(workspace.path);
+            // A path only earns a column when words are affordable and the title does not already say it.
+            const detail = rollupStyle === 'words' && name ? workspaceDetail(string(workspace.path), name) : '';
+            return { key: string(workspace.workspaceId),
+                label: [workspaceStatus(counts, rollupStyle), title].filter(Boolean).join('  '), title,
+                cells: workspaceSegments(counts, rollupStyle).map(segment => ({ text: segment.text, color: stateColor[segment.state] })),
+                ...(detail ? { detail } : {}),
+                remove: () => setRemoval({ kind: 'workspace', id: string(workspace.workspaceId), name: string(workspace.title), path: string(workspace.path) }),
+                action: () => controller.pickWorkspace(string(workspace.workspaceId)) };
+        }),
         { key: '@all', label: 'All sessions', action: () => operate(() => controller.switchSession('all')) },
+        // The directory this client runs in is the one case where no path has to be typed, and offering
+        // it only while the host has not registered it keeps the row from repeating itself.
+        ...(state.workspaces.some(workspace => string(workspace.path) === controller.localDirectory) ? []
+            : [{ key: '@here', label: `+ Add workspace (this directory)  ${controller.localDirectory}`,
+                    action: () => operate(() => controller.createWorkspace(controller.localDirectory)) }]),
         { key: '@new', label: '+ Add workspace (host directory)', action: () => controller.enterPath() },
     ] : [
         ...(state.workspaceId && !state.showAllSessions ? [{ key: '@new', label: '+ New session', action: () => operate(() => controller.createSession()) }] : []),
         ...controller.visibleSessions.map(session => ({ key: string(session.sessionId),
-            label: `${session.running ? '● ' : ''}${sessionLabel(session)}  ${session.sessionId}`,
+            label: `${sessionStatus(session, listAge, isPending(session))} ${sessionLabel(session)}  ${session.sessionId}`,
             remove: () => operate(() => requestRemoval('session', string(session.sessionId))),
             action: () => { setScroll(0); operate(() => controller.selectSession(string(session.sessionId))); } })),
         { key: '@back', label: '← Workspaces', action: () => operate(() => controller.showPicker('workspaces')) },
     ];
-    const width = Math.max(10, (stdout.columns ?? 80) - 2);
     const layout = useMemo(() => historyLayout(displayTranscript, width, reasoning, reasoningOverrides, liveReasoning), [displayTranscript, displayTranscript.version, width, reasoning, reasoningOverrides, liveReasoning]);
     const { length, first } = layout;
     const statusNotice = !['Connected', 'Idle', 'Running…', 'Responding…'].includes(state.status);
@@ -720,7 +820,13 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
             : state.screen === 'chat' && position > 0 ? 'history'
                 : undefined;
     const statusFrozen = pauseReason !== undefined;
-    return _jsx(ThemeContext.Provider, { value: theme, children: _jsx(CopyMode.Provider, { value: copyMode, children: _jsx(Frozen, { frozen: copyMode, identity: `${width}:${stdout.rows}`, children: _jsxs(Box, { flexDirection: "column", paddingX: 1, height: Math.max(1, (stdout.rows ?? 30) - 1), overflowY: "hidden", children: [copyMode && _jsx(Text, { color: theme.accent, children: "Copy mode \u00B7 drag to select \u00B7 Esc / Ctrl+S resumes" }), _jsx(ChatHeader, { title: headerTitle, mode: controller.sessionMode, width: width, frozen: displayPaused, identity: `${width}:${state.sessionId}` }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, minHeight: 0, overflowY: "hidden", children: [historyLoading && _jsxs(Text, { dimColor: true, children: [historyLoading, " \u00B7 Esc / Ctrl+C cancel"] }), _jsx(Frozen, { frozen: statusPaused, identity: state.sessionId ?? "", children: statusNotice && _jsx(Text, { dimColor: true, wrap: "truncate-end", children: safeText(state.status) }) }), state.error && _jsx(Text, { color: theme.colors.error, children: state.error }), state.screen === 'chat' && _jsx(ChatViewport, { rows: visible, showHistoryHint: showHistoryHint, dialogOpen: dialogOpen, historyWindow: !!historyWindow, frozen: displayPaused, identity: `${width}:${state.sessionId}:${position}:${pageSize}`, boxRef: conversationBox })] }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [notice && _jsx(Text, { dimColor: true, children: safeText(notice) }), _jsxs(Box, { borderStyle: "round", borderColor: pending ? theme.colors.context : state.online ? theme.accent : theme.border, paddingX: 1, flexDirection: "column", flexShrink: 1, minHeight: 3, children: [_jsx(Box, { flexDirection: "column", flexShrink: 1, minHeight: 0, overflowY: "hidden", children: queueOpen && !pending ? _jsx(QueueDialog, { queued: queued, rows: stdout.rows ?? 30, width: width, unavailable: !!state.controlError, enabled: !input && !state.busy && state.online, canSelect: () => !draft.current && !controller.state.busy && controller.state.online && !controller.state.pending.length, onRemove: id => operate(() => controller.removeQueued(id)) }) : removal ? _jsx(RemovalDialog, { removal: removal, enabled: !input && !state.busy && state.online, canSelect: () => !draft.current && !controller.state.busy && controller.state.online, onCancel: () => setRemoval(undefined), onConfirm: () => operate(async () => { await controller.removeTarget(removal); setRemoval(undefined); }) }) : models ? _jsx(ModelDialog, { models: models, rows: stdout.rows ?? 30, width: width, enabled: !input && !state.busy && state.online, canSelect: () => !draft.current && !controller.state.busy && controller.state.online, onChoose: (provider, model, effort) => operate(async () => { await controller.selectModel(provider, model, effort); setModels(undefined); }), onOpen: (provider, model) => setModels({ catalog: models.catalog, provider, model }), onBack: () => setModels({ catalog: models.catalog }), onClose: () => setModels(undefined) }) : searchResults ? _jsx(SearchResultsDialog, { query: searchResults.query, items: searchResults.items, hasMore: searchResults.hasMore, width: width, enabled: !input && !state.busy, canSelect: () => !draft.current && !controller.state.busy, onOpen: sessionId => operate(() => openSearchSession(sessionId, searchResults.query)), onClose: () => setSearchResults(undefined) }) : state.screen === 'workspaces' || state.screen === 'sessions' ? _jsx(PickerScreen, { title: state.screen === 'workspaces' ? 'Choose workspace' : state.showAllSessions ? 'Choose session · All workspaces' : 'Choose session', identity: `${state.screen}:${state.workspaceId ?? ''}`, choices: choices, enabled: state.online && !state.busy && !input, canSelect: () => !draft.current && controller.state.online && !controller.state.busy }) : _jsxs(_Fragment, { children: [thoughtList && _jsx(ThoughtsDialog, { identity: `thoughts:${state.sessionId}`, options: thoughtOptions, empty: !thoughtEntries?.length && !liveThought, rows: stdout.rows ?? 30, enabled: !input && !state.busy, canSelect: () => !draft.current && !controller.state.busy }), state.screen === 'chat' && historyQuery !== undefined && _jsx(HistoryDialog, { identity: `history:${historyQuery}`, contentSearch: contentSearch, matches: historyMatches, query: historyQuery, messages: layout.messages, width: width, enabled: !input && !state.busy, canSelect: () => !draft.current && !controller.state.busy, onJump: seq => operate(() => jumpHistory(seq)), onClose: () => { setHistoryQuery(undefined); setHistoryMatches(undefined); } }), pending && _jsxs(Box, { flexShrink: 0, flexDirection: "column", children: [_jsx(Text, { bold: true, color: theme.colors.context, children: question ? `Question ${answered.length + 1}/${questions.length}${question.header ? ` · ${safeText(string(question.header))}` : ''}` : 'Approval required' }), _jsx(Text, { children: safeText(question ? string(question.question) : JSON.stringify(pending.request, null, 2)) }), question?.detail && _jsx(Text, { children: safeText(string(question.detail)) }), pending.event === 'approval/request' && _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [['Allow once', 'Deny', 'Stop turn'].map((label, index) => _jsxs(Text, { color: approvalIndex === index ? theme.accent : undefined, children: [approvalIndex === index ? '❯ ' : '  ', index + 1, ". ", label] }, label)), _jsx(Text, { dimColor: true, children: "\u2191 \u2193 / 1\u20133 select \u00B7 Enter confirm" })] }), options.length > 0 && _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [[...options, { label: 'Other answer — type below' }].map((option, index) => ({ option, index }))
+    return _jsx(ThemeContext.Provider, { value: theme, children: _jsx(CopyMode.Provider, { value: copyMode, children: _jsx(Frozen, { frozen: copyMode, identity: `${width}:${stdout.rows}`, children: _jsxs(Box, { flexDirection: "column", paddingX: 1, height: Math.max(1, (stdout.rows ?? 30) - 1), overflowY: "hidden", children: [copyMode && _jsx(Text, { color: theme.accent, children: "Copy mode \u00B7 drag to select \u00B7 Esc / Ctrl+S resumes" }), _jsx(ChatHeader, { title: headerTitle, mode: controller.sessionMode, width: width, frozen: displayPaused, identity: `${width}:${state.sessionId}` }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, minHeight: 0, overflowY: "hidden", children: [historyLoading && _jsxs(Text, { dimColor: true, children: [historyLoading, " \u00B7 Esc / Ctrl+C cancel"] }), _jsx(Frozen, { frozen: statusPaused, identity: state.sessionId ?? "", children: statusNotice && _jsx(Text, { dimColor: true, wrap: "truncate-end", children: safeText(state.status) }) }), state.error && _jsx(Text, { color: theme.colors.error, children: state.error }), state.screen === 'chat' && _jsx(ChatViewport, { rows: visible, showHistoryHint: showHistoryHint, dialogOpen: dialogOpen, historyWindow: !!historyWindow, frozen: displayPaused, identity: `${width}:${state.sessionId}:${position}:${pageSize}`, boxRef: conversationBox })] }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [notice && _jsx(Text, { dimColor: true, children: safeText(notice) }), _jsxs(Box, { borderStyle: "round", borderColor: pending ? theme.colors.context : state.online ? theme.accent : theme.border, paddingX: 1, flexDirection: "column", flexShrink: 1, minHeight: 3, children: [_jsx(Box, { flexDirection: "column", flexShrink: 1, minHeight: 0, overflowY: "hidden", children: queueOpen && !pending ? _jsx(QueueDialog, { queued: queued, rows: stdout.rows ?? 30, width: width, unavailable: !!state.controlError, enabled: !input && !state.busy && state.online, canSelect: () => !draft.current && !controller.state.busy && controller.state.online && !controller.state.pending.length, onRemove: id => operate(() => controller.removeQueued(id)) }) : removal ? _jsx(RemovalDialog, { removal: removal, enabled: !input && !state.busy && state.online, canSelect: () => !draft.current && !controller.state.busy && controller.state.online, onCancel: () => setRemoval(undefined), onConfirm: () => operate(async () => { await controller.removeTarget(removal); setRemoval(undefined); }) }) : models ? _jsx(ModelDialog, { models: models, rows: stdout.rows ?? 30, width: width, enabled: !input && !state.busy && state.online, canSelect: () => !draft.current && !controller.state.busy && controller.state.online, onChoose: (provider, model, effort) => operate(async () => { await controller.selectModel(provider, model, effort); setModels(undefined); }), onOpen: (provider, model) => setModels({ catalog: models.catalog, provider, model }), onBack: () => setModels({ catalog: models.catalog }), onClose: () => setModels(undefined) }) : searchResults ? _jsx(SearchResultsDialog, { query: searchResults.query, items: searchResults.items, hasMore: searchResults.hasMore, width: width, enabled: !input && !state.busy, canSelect: () => !draft.current && !controller.state.busy, onOpen: sessionId => operate(() => openSearchSession(sessionId, searchResults.query)), onClose: () => setSearchResults(undefined) }) : state.screen === 'workspaces' || state.screen === 'sessions' ? _jsx(PickerScreen, { title: state.screen === 'workspaces' ? 'Choose workspace' : state.showAllSessions ? 'Choose session · All workspaces' : 'Choose session', identity: `${state.screen}:${state.workspaceId ?? ''}`, choices: choices, width: pickerWidth, 
+                                                // A rollup of badges is read through the key beside it; spelled-out states need no key, and a
+                                                // terminal too narrow for the whole key gets the badges alone rather than half a legend.
+                                                legend: state.screen === 'workspaces' && rollupStyle === 'badges' && pickerWidth >= 40 ? ROLLUP_LEGEND : undefined, enabled: state.online && !state.busy && !input, canSelect: () => !draft.current && controller.state.online && !controller.state.busy }) : _jsxs(_Fragment, { children: [thoughtList && _jsx(ThoughtsDialog, { identity: `thoughts:${state.sessionId}`, options: thoughtOptions, empty: !thoughtEntries?.length && !liveThought, rows: stdout.rows ?? 30, enabled: !input && !state.busy, canSelect: () => !draft.current && !controller.state.busy }), state.screen === 'chat' && historyQuery !== undefined && _jsx(HistoryDialog, { identity: `history:${historyQuery}`, contentSearch: contentSearch, matches: historyMatches, query: historyQuery, messages: layout.messages, width: width, enabled: !input && !state.busy, canSelect: () => !draft.current && !controller.state.busy, onJump: seq => operate(() => jumpHistory(seq)), onClose: () => { setHistoryQuery(undefined); setHistoryMatches(undefined); } }), pending && _jsxs(Box, { flexShrink: 0, flexDirection: "column", children: [_jsx(Text, { bold: true, color: theme.colors.context, children: question ? `Question ${answered.length + 1}/${questions.length}${question.header ? ` · ${safeText(string(question.header))}` : ''}` : 'Approval required' }), _jsx(Text, { children: safeText(question ? string(question.question) : JSON.stringify(pending.request, null, 2)) }), question?.detail && _jsx(Text, { children: safeText(string(question.detail)) }), pending.event === 'approval/request' && _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [['Allow once', 'Deny', 'Stop turn'].map((label, index) => _jsxs(Text, { color: approvalIndex === index ? theme.accent : undefined, children: [approvalIndex === index ? '❯ ' : '  ', index + 1, ". ", label] }, label)), _jsx(Text, { dimColor: true, children: "\u2191 \u2193 / 1\u20133 select \u00B7 Enter confirm" })] }), options.length > 0 && _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [[...options, { label: 'Other answer — type below' }].map((option, index) => ({ option, index }))
                                                                         .slice(optionStart, optionStart + optionPageSize).map(({ option, index }) => _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsxs(Text, { color: index === optionCursor ? theme.accent : undefined, wrap: "truncate-end", children: [index === optionCursor ? '❯ ' : '  ', index + 1, ". ", question?.multiSelect === true && index < options.length ? choiceState.selected.includes(string(option.label)) ? '[x] ' : '[ ] ' : '', safeText(string(option.label))] }), option.description && _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ['     ', safeText(string(option.description))] })] }, index)), _jsx(Text, { dimColor: true, children: choiceState.custom ? 'Type your answer below · Esc returns to options' : question?.multiSelect === true
-                                                                            ? '↑ ↓ move · Space / 1–9 toggle · Enter confirm' : '↑ ↓ / 1–9 select · Enter confirm' })] }), _jsx(Text, { dimColor: true, children: question ? 'Text answers supported · Ctrl+C clears · /cancel stops' : '/allow approves once · /deny rejects · /cancel stops' })] })] }) }), !queueOpen && !pending && state.screen === 'chat' && queued.length > 0 && _jsx(QueuedPreview, { queued: queued, width: width }), _jsxs(Box, { flexShrink: 0, children: [_jsx(Text, { color: theme.accent, children: "\u276F " }), _jsx(TextInput, { value: input, onChange: setInput, onCursorChange: setCursor, onSubmit: () => { void submit(draft.current); }, reservedKeys: approvalKeysActive ? ['1', '2', '3'] : queueOpen && !pending ? ['d'] : questionKeysActive ? ['1', '2', '3', '4', '5', '6', '7', '8', '9', ...(question?.multiSelect === true ? [' '] : [])] : !removal && !models && !searchResults && (state.screen === 'workspaces' || state.screen === 'sessions') ? ['d'] : undefined, focus: state.online && !state.busy && !copyMode, placeholder: state.screen === 'path' ? 'Absolute directory path on host' : 'Message, @host-file, or /help' })] }), referenceOpen && _jsx(ReferenceMenu, { matches: matches, index: referenceIndex })] }), commandSuggestions && _jsx(Text, { dimColor: true, children: commandSuggestions.join('  ') }), help && _jsx(HelpPanel, { page: currentHelpPage, pages: helpPages, pageSize: helpPageSize }), costExpanded && _jsx(CostPanel, { controller: controller }), _jsx(Frozen, { frozen: statusFrozen, identity: `${width}:${state.sessionId}:${statusExpanded}:${statusScroll}:${pauseReason ?? ''}`, children: _jsx(StatusBar, { controller: controller, width: width, expanded: statusExpanded, scroll: statusScroll, pageSize: statusViewRows, onScroll: setStatusScroll, onOverflow: setStatusOverflow, onRows: setStatusBarRows, pauseReason: pauseReason, revision: state.version }) })] })] }) }) }) });
+                                                                            ? '↑ ↓ move · Space / 1–9 toggle · Enter confirm · Esc dismisses' : '↑ ↓ / 1–9 select · Enter confirm · Esc dismisses' })] }), _jsx(Text, { dimColor: true, children: question ? options.length > 0
+                                                                    ? 'Choose "Other answer" to type · the draft is kept while this is open'
+                                                                    : 'Esc dismisses the question · the draft is kept while this is open'
+                                                                    : 'Esc keeps this pending · the draft is kept while this is open' })] })] }) }), !queueOpen && !pending && state.screen === 'chat' && queued.length > 0 && _jsx(QueuedPreview, { queued: queued, width: width }), _jsx(TextInput, { value: input, onChange: setInput, onCursorChange: setCursor, onSubmit: () => { void submit(draft.current); }, reservedKeys: approvalKeysActive ? ['1', '2', '3'] : queueOpen && !pending ? ['d'] : questionKeysActive ? ['1', '2', '3', '4', '5', '6', '7', '8', '9', ...(question?.multiSelect === true ? [' '] : [])] : !removal && !models && !searchResults && (state.screen === 'workspaces' || state.screen === 'sessions') ? ['d'] : undefined, width: draftWidth, maxRows: composerRows, promptColor: answerPending ? theme.colors.muted : theme.accent, focus: state.online && !state.busy && !copyMode && !answerPending, placeholder: state.screen === 'path' ? 'Absolute directory path on host' : 'Message, @host-file, or /help' }), referenceOpen && _jsx(ReferenceMenu, { matches: matches, index: referenceIndex })] }), commandSuggestions && _jsx(Text, { dimColor: true, children: commandSuggestions.join('  ') }), help && _jsx(HelpPanel, { page: currentHelpPage, pages: helpPages, pageSize: helpPageSize }), costExpanded && _jsx(CostPanel, { controller: controller }), _jsx(Frozen, { frozen: statusFrozen, identity: `${width}:${state.sessionId}:${statusExpanded}:${statusScroll}:${pauseReason ?? ''}`, children: _jsx(StatusBar, { controller: controller, width: width, expanded: statusExpanded, scroll: statusScroll, pageSize: statusViewRows, onScroll: setStatusScroll, onOverflow: setStatusOverflow, onRows: setStatusBarRows, pauseReason: pauseReason, revision: state.version }) })] })] }) }) }) });
 }

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

@@ -1,7 +1,11 @@
 import type { HistoryRow } from '../../session/history.ts';
 /** Render a viewport with role, reasoning, tool and result colors from the selected theme.
+ *
+ * Rows are sibling text nodes rather than lines inside one text node: Ink measures and caches text per
+ * node, so a parent holding the whole viewport is re-measured and retained whenever one row changes.
+ * An empty row renders as a single space because Ink gives an empty text node no height.
  * @param rows - Already wrapped, terminal-safe visible rows.
- * @returns Colored text with unchanged row geometry and plain-text role markers.
+ * @returns Colored rows with unchanged row geometry and plain-text role markers.
  */
 export declare function HistoryViewport({ rows }: {
     rows: HistoryRow[];

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

@@ -1,12 +1,17 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 /** Only visible semantic rows become React nodes; ANSI colors are applied after remote text sanitation. */
-import { Text } from 'ink';
+import { Box, Text } from 'ink';
 import { useTheme } from "../theme/index.js";
 /** Render a viewport with role, reasoning, tool and result colors from the selected theme.
+ *
+ * Rows are sibling text nodes rather than lines inside one text node: Ink measures and caches text per
+ * node, so a parent holding the whole viewport is re-measured and retained whenever one row changes.
+ * An empty row renders as a single space because Ink gives an empty text node no height.
  * @param rows - Already wrapped, terminal-safe visible rows.
- * @returns Colored text with unchanged row geometry and plain-text role markers.
+ * @returns Colored rows with unchanged row geometry and plain-text role markers.
  */
 export function HistoryViewport({ rows }) {
     const theme = useTheme();
-    return _jsx(Text, { children: rows.map((row, index) => _jsxs(Text, { color: theme.colors[row.kind], bold: row.bold, children: [row.spans ? row.spans.map((span, index) => _jsx(Text, { bold: span.bold, italic: span.italic, underline: span.underline, strikethrough: span.strikethrough, inverse: span.inverse, children: span.text }, index)) : row.text, index < rows.length - 1 ? '\n' : ''] }, index)) });
+    return _jsx(Box, { flexDirection: "column", children: rows.map((row, index) => _jsx(Text, { color: theme.colors[row.kind], bold: row.bold, children: row.spans?.length ? row.spans.map((span, position) => _jsx(Text, { bold: span.bold, italic: span.italic, underline: span.underline, strikethrough: span.strikethrough, inverse: span.inverse, children: span.text }, position))
+                : row.text === '' ? ' ' : row.text }, index)) });
 }

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

@@ -28,12 +28,12 @@ export interface StatusGroups {
     phase?: StatusSegment;
     /** How to stop the running turn. */
     stop?: StatusSegment;
-    /** This session's cost, scope-labelled so it cannot read as a share of the day total. */
-    session?: StatusSegment;
+    /** This session's cost with today's spend in parentheses, the only money the bar reports. */
+    cost?: StatusSegment;
     /** Context share, labelled because a bare percentage next to money reads as a budget. */
     context?: StatusSegment;
-    /** Today's cost across sessions; shown only where the width allows it. */
-    day?: StatusSegment;
+    /** The same share drawn as a bar; used only where it still fits beside every other kept group. */
+    contextBar?: StatusSegment;
     /** Model name without its reasoning effort, which is dropped first. */
     model?: StatusSegment;
     /** Reasoning effort, kept only while the model name still fits beside it. */
@@ -42,7 +42,19 @@ export interface StatusGroups {
     turns?: StatusSegment;
     /** Cumulative tokens. */
     tokens?: StatusSegment;
+    /** Cache-hit share of billed prompt input; it restates the token total, so the packer drops it first. */
+    cache?: StatusSegment;
 }
+/** Cache-hit share of billed prompt input, without reporting a partial hit as a full one.
+ *
+ * A prefix served from cache is what the provider charges least for, so the share is the reading
+ * that explains a cheap session; rounding it up to `100%` would instead claim that input stopped
+ * being billed, so the display gains precision until the number it shows is below a full hit.
+ * @param cacheReadTokens - Prompt tokens the provider served from cache.
+ * @param billedInputTokens - Uncached input, cache read and cache write, the prompt tokens that were billed.
+ * @returns Percentage text, or undefined when no prompt input has been billed yet.
+ */
+export declare function cacheHitText(cacheReadTokens: number | undefined, billedInputTokens: number | undefined): string | undefined;
 /** Elapsed time as `m:ss`, adding hours only when they exist.
  * @param milliseconds - Duration to format.
  * @returns Clock text without a leading zero on minutes.

package/dist/ui/chat/status.js

@@ -51,6 +51,27 @@ export function metricLines(values, defaultModel, running) {
         `In ${compact(buckets[0])} · Out ${compact(buckets[1])} · Cache ${compact(buckets[2])}/${compact(buckets[3])}`,
     ];
 }
+/** Cache-hit share of billed prompt input, without reporting a partial hit as a full one.
+ *
+ * A prefix served from cache is what the provider charges least for, so the share is the reading
+ * that explains a cheap session; rounding it up to `100%` would instead claim that input stopped
+ * being billed, so the display gains precision until the number it shows is below a full hit.
+ * @param cacheReadTokens - Prompt tokens the provider served from cache.
+ * @param billedInputTokens - Uncached input, cache read and cache write, the prompt tokens that were billed.
+ * @returns Percentage text, or undefined when no prompt input has been billed yet.
+ */
+export function cacheHitText(cacheReadTokens, billedInputTokens) {
+    if (cacheReadTokens === undefined || billedInputTokens === undefined || billedInputTokens <= 0)
+        return undefined;
+    if (cacheReadTokens >= billedInputTokens)
+        return '100%';
+    for (let digits = 0; digits <= 3; digits++) {
+        const text = (cacheReadTokens / billedInputTokens * 100).toFixed(digits);
+        if (Number(text) < 100)
+            return `${text}%`;
+    }
+    return '<100%';
+}
 /** Elapsed time as `m:ss`, adding hours only when they exist.
  * @param milliseconds - Duration to format.
  * @returns Clock text without a leading zero on minutes.
@@ -84,23 +105,61 @@ export function compactStatusRows(groups, width) {
         return [];
     // Remote text reaches this bar, so every group is stripped of control characters before packing.
     const clean = (group) => group === undefined ? undefined : { ...group, text: safeText(group.text).replace(/[\r\n\t]+/g, ' ') };
-    groups = { state: clean(groups.state), phase: clean(groups.phase), stop: clean(groups.stop), session: clean(groups.session),
-        context: clean(groups.context), day: clean(groups.day), model: clean(groups.model), effort: clean(groups.effort),
-        turns: clean(groups.turns), tokens: clean(groups.tokens) };
+    groups = { state: clean(groups.state), phase: clean(groups.phase), stop: clean(groups.stop), cost: clean(groups.cost),
+        context: clean(groups.context), contextBar: clean(groups.contextBar),
+        model: clean(groups.model), effort: clean(groups.effort), turns: clean(groups.turns), tokens: clean(groups.tokens),
+        cache: clean(groups.cache) };
     const cluster = [groups.state, groups.phase, groups.stop].filter(Boolean);
-    const rest = [groups.session, groups.context, groups.day, groups.model, groups.effort, groups.turns, groups.tokens].filter(Boolean);
-    // One row while enough of the sequence fits; each step drops the least valuable group first.
-    // The cost is never dropped, only moved to the second row, so the search stops above it.
-    const floor = groups.session === undefined ? 0 : 1;
-    for (let keep = rest.length; keep >= floor; keep--) {
-        const row = pack(cluster, rest.slice(0, keep));
+    // The cost is one group carrying two scopes: this session's spend, with today's in parentheses.
+    // Display order reads the model beside its effort and the money after the share it sits next to;
+    // keep order is by value, so a narrow bar holds the cost and the share before a model it cannot
+    // show, and the cache share goes before the token total it restates.
+    const order = [groups.model, groups.effort, groups.context, groups.cost, groups.turns, groups.tokens, groups.cache].filter(Boolean);
+    const rank = [groups.cost, groups.context, groups.model, groups.effort, groups.turns, groups.tokens, groups.cache].filter(Boolean);
+    // One row while enough of the sequence fits; each step drops the least valuable group first. The
+    // cost is never dropped while a row can hold it, only moved to the second one, so the search stops
+    // above it; a second row that cannot hold even the cost is not opened.
+    const floor = groups.cost === undefined ? 0 : 1;
+    for (let keep = rank.length; keep >= floor; keep--) {
+        const kept = new Set(rank.slice(0, keep));
+        const row = pack(cluster, order.filter(group => kept.has(group)));
         if (measure(row) <= width)
-            return [row];
+            return [keep > floor ? widen(row, groups, width) : row];
     }
-    if (groups.session === undefined && measure(pack(cluster, [])) > width)
+    if (groups.cost === undefined && measure(pack(cluster, [])) > width)
         return [fitCluster(cluster, width)];
     // Not even the state cluster and the cost share a row, so the cost opens the second one.
-    return [fitCluster(cluster, width), packGreedy(rest, width)];
+    const first = fitCluster(cluster, width);
+    const second = widen(packGreedy(rank, width), groups, width);
+    return second.length === 0 ? [first] : [first, second];
+}
+/** Offer the clearer reading of a group already on the row: the ten-cell context share.
+ *
+ * The bar is a rendering of the same share the plain percentage reports, not an additional group, so
+ * it never displaces a group that fits: below the width that holds it, the plain form keeps its place.
+ * @param row - A packed row that already fits.
+ * @param groups - Cleaned groups, used to find the pair by identity.
+ * @param width - Available terminal columns.
+ * @returns The row with the reading that fits.
+ */
+function widen(row, groups, width) {
+    return swap(row, groups.context, groups.contextBar, width);
+}
+/** Replace one group with its fuller rendering where the whole row still fits.
+ * @param row - A packed row that already fits.
+ * @param from - Group to replace, matched by identity.
+ * @param to - Fuller rendering of that group.
+ * @param width - Available terminal columns.
+ * @returns The row with the replacement, or the row unchanged where it does not fit.
+ */
+function swap(row, from, to, width) {
+    if (from === undefined || to === undefined)
+        return row;
+    const index = row.indexOf(from);
+    if (index < 0)
+        return row;
+    const replaced = [...row.slice(0, index), to, ...row.slice(index + 1)];
+    return measure(replaced) <= width ? replaced : row;
 }
 /** Fit the state cluster, dropping the phase and then the stop hint before truncating the state.
  * @param cluster - State, phase and stop hint in that order.
@@ -166,9 +225,11 @@ export const StatusBar = memo(function StatusBar({ controller, expanded = false,
     const since = controller.workingSince;
     useEffect(() => {
         setNow(Date.now());
-        if (!running || paused)
+        if (paused)
             return;
-        const timer = setInterval(() => setNow(Date.now()), 1000);
+        // An idle bar still re-reads the clock, so a day rollover reaches the cost it reports without
+        // waiting for an unrelated render; a running bar keeps its per-second clock.
+        const timer = setInterval(() => setNow(Date.now()), running ? 1000 : 60_000);
         return () => clearInterval(timer);
     }, [running, since, paused]);
     const state = controller.state;
@@ -176,7 +237,7 @@ export const StatusBar = memo(function StatusBar({ controller, expanded = false,
     const view = controller.telemetry.view(state.sessionId);
     const costs = controller.costs;
     const sessionCost = costs?.hasSession(state.sessionId) ? costText(costs.total(state.sessionId)) : '?';
-    const todayCost = costs ? costText(costs.total(undefined, 1, Date.now())) : '?';
+    const todayCost = costs ? costText(costs.today()) : '?';
     // `*` belongs to costText alone; incomplete coverage is a separate degradation, reported by `!`.
     const coverage = costs?.coverage ?? 'complete';
     const label = workspace ? `${workspace.title} · ${workspace.path}` : 'none selected';
@@ -192,6 +253,10 @@ export const StatusBar = memo(function StatusBar({ controller, expanded = false,
         const usage = record(view.values.tokenUsage);
         const buckets = [usage.uncachedInputTokens, usage.outputTokens, usage.cacheReadTokens, usage.cacheWriteTokens].map(numeric);
         const total = buckets.every(value => value !== undefined) ? buckets.reduce((a, b) => a + b, 0) : undefined;
+        // Billed prompt input is the three disjoint prompt buckets; a provider that reports no cache
+        // write has not billed one, which is how the ledger reads the same projection.
+        const billed = buckets[0] === undefined || buckets[2] === undefined ? undefined : buckets[0] + buckets[2] + (buckets[3] ?? 0);
+        const hit = cacheHitText(buckets[2], billed);
         const compactCount = (value) => value === undefined ? '?' : compactNumber.format(value);
         const phase = state.transcript.livePhase;
         const clock = running && since !== undefined ? ` ${clockText(now - since)}` : '';
@@ -199,31 +264,44 @@ export const StatusBar = memo(function StatusBar({ controller, expanded = false,
             : phase.kind === 'tool' ? `${phase.name ?? 'tool'} ${phaseText(now - phase.startedAt)}`
                 : `${phase.kind === 'thinking' ? 'think' : 'write'} ${phaseText(now - phase.startedAt)}`;
         // The state token reports a fact and never guesses: a paused clock is named, offline and errors
-        // take the token over, and an unknown phase simply leaves the phase group empty.
+        // take the token over, and an unknown phase simply leaves the phase group empty. An answer this
+        // client still owes outranks the paused reason, because that reason is only why the clock stopped.
         const stateToken = !state.online
             ? { text: '! Offline', color: theme.status.offline }
             : state.controlError || state.modelError
                 ? { text: '⚠ Error', color: theme.status.warning }
-                : pauseReason !== undefined
-                    ? { text: `⏸ ${pauseReason}${clock}`, color: theme.colors.muted }
-                    : running ? { text: `◐${clock}`, color: theme.status.working } : { text: '● Ready', color: theme.status.ready };
-        // The marker names the scope it belongs to: a subtotal is inexact when a record could not be
-        // priced, when it is only estimated, or when the scan has not covered every session yet.
+                : state.pending.length > 0
+                    ? { text: '? Needs you', color: theme.status.critical }
+                    : pauseReason !== undefined
+                        ? { text: `⏸ ${pauseReason}${clock}`, color: theme.colors.muted }
+                        : running ? { text: `◐${clock}`, color: theme.status.working } : { text: '● Ready', color: theme.status.ready };
+        // One marker covers both scopes, because either an unpriceable record or a scan that has not
+        // covered every session makes the pair inexact as a reading.
         const inexact = coverage !== 'complete';
-        const money = (value) => `¥${value.amount.toFixed(2)}${value.unknown || value.estimated || inexact ? '*' : ''}`;
+        const money = (session, today) => `¥: ${session === undefined ? '?' : session.amount.toFixed(2)}(${today.amount.toFixed(2)})${session?.unknown || today.unknown || inexact ? '*' : ''}`;
+        const todayTotal = costs?.today();
         const sessionTotal = costs !== undefined && costs.hasSession(state.sessionId) ? costs.total(state.sessionId) : undefined;
+        const contextColor = percent === undefined ? theme.status.usage
+            : percent >= 95 ? theme.status.critical : percent >= 80 ? theme.status.warning : theme.status.context;
+        // Ten cells resolve context to tenths, the same resolution the percentage beside them reports.
+        const cells = percent === undefined ? 0 : Math.round(percent / 10);
         const groups = {
             state: stateToken,
-            ...(phaseLabel === undefined || pauseReason !== undefined ? {} : { phase: { text: phaseLabel } }),
+            // A paused bar keeps the phase: the reason already says why the clock stopped, and dropping the
+            // running tool would leave the one question this bar exists to answer unanswered. A ready bar
+            // has none: the transcript keeps the last event it saw, and only the host knows the turn ended.
+            ...(phaseLabel === undefined || !running ? {} : { phase: { text: phaseLabel } }),
             ...(running && pauseReason === undefined ? { stop: { text: '^C' } } : {}),
-            ...(sessionTotal === undefined ? {} : { session: { text: `S${money(sessionTotal)}`, color: theme.status.cost } }),
-            ...(percent === undefined ? {} : { context: { text: `ctx ${percent}%`,
-                    color: percent >= 95 ? theme.status.critical : percent >= 80 ? theme.status.warning : theme.status.context } }),
-            ...(costs === undefined ? {} : { day: { text: `D${money(costs.total(undefined, 1, Date.now()))}`, color: theme.status.cost } }),
+            ...(todayTotal === undefined ? {} : { cost: { text: money(sessionTotal, todayTotal), color: theme.status.cost } }),
+            ...(percent === undefined ? {} : {
+                context: { text: `ctx ${percent}%`, color: contextColor },
+                contextBar: { text: `ctx: ${'█'.repeat(cells)}${'░'.repeat(10 - cells)} ~${percent}%`, color: contextColor }
+            }),
             ...(model === undefined ? {} : { model: { text: model, color: theme.status.model } }),
             ...(model === undefined || effort === undefined ? {} : { effort: { text: effort, color: theme.status.model } }),
             ...(numeric(record(view.values.sessionStats).turns) === undefined ? {} : { turns: { text: `${count(numeric(record(view.values.sessionStats).turns))} turns`, color: theme.status.usage } }),
             ...(total === undefined ? {} : { tokens: { text: `${compactCount(total)} tok`, color: theme.status.usage } }),
+            ...(hit === undefined ? {} : { cache: { text: `hit ${hit}`, color: theme.status.usage } }),
         };
         const rows = compactStatusRows(groups, width ?? Math.max(1, (stdout.columns ?? 80) - 2));
         if (rows.length !== reported) {
@@ -248,7 +326,7 @@ const StatusDetails = memo(function StatusDetails({ controller, theme, width, no
     const view = controller.telemetry.view(state.sessionId);
     const costs = controller.costs;
     const sessionCost = costs?.hasSession(state.sessionId) ? costText(costs.total(state.sessionId)) : '?';
-    const todayCost = costs ? costText(costs.total(undefined, 1, Date.now())) : '?';
+    const todayCost = costs ? costText(costs.today()) : '?';
     // `*` belongs to costText alone; incomplete coverage is a separate degradation, reported by `!`.
     const coverage = costs?.coverage ?? 'complete';
     const label = workspace ? `${workspace.title} · ${workspace.path}` : 'none selected';
@@ -259,9 +337,11 @@ const StatusDetails = memo(function StatusDetails({ controller, theme, width, no
     const turns = count(numeric(record(view.values.sessionStats).turns));
     const duration = since === undefined ? 'unknown duration' : elapsedTime(now - since);
     const detail = [
-        { key: 'activity', color: running ? theme.colors.context : theme.colors.muted, text: running
-                ? `◐ Working · ${duration}${state.transcript.activeTurnStartedAt === undefined ? ' (observed)' : ''} · Ctrl+C Stop`
-                : '● Ready · Ctrl+C exit' },
+        { key: 'activity', color: state.pending.length > 0 ? theme.status.critical : running ? theme.colors.context : theme.colors.muted, text: state.pending.length > 0
+                ? '? Needs you · answer the request above to continue'
+                : running
+                    ? `◐ Working · ${duration}${state.transcript.activeTurnStartedAt === undefined ? ' (observed)' : ''} · Ctrl+C Stop`
+                    : '● Ready · Ctrl+C exit' },
         { key: 'host', text: `${safeText(controller.base)} · ${safeText(state.status)}${!state.online ? ' · offline, last known status' : ''}` },
         ...state.sessionId
             ? [{ key: 'session', text: `Session ${safeText(state.sessionId)}${controller.sessionMode ? ` · ${safeText(controller.sessionMode)}` : ''}` }] : [],
@@ -307,5 +387,5 @@ function modelName(value) {
     return safeText(`${model.provider}/${model.model}${typeof model.reasoningEffort === 'string' ? ` (${model.reasoningEffort})` : ''}`);
 }
 function compactCost(total) {
-    return `~¥${total.amount.toFixed(2)}${total.unknown || total.estimated ? '*' : ''}`;
+    return `~¥${total.amount.toFixed(2)}${total.unknown ? '*' : ''}`;
 }

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

@@ -62,6 +62,9 @@ export type Submission = {
 } | {
     kind: 'exportHtml';
     destination?: string;
+} | {
+    kind: 'coredump';
+    tag?: string;
 } | {
     kind: 'answer';
     text: string;

package/dist/ui/commands/parse.js

@@ -109,6 +109,11 @@ export function classifySubmission(raw, context) {
         const destination = value.slice(12).trim().replace(/^(["'])(.*)\1$/, '$2');
         return { kind: 'exportHtml', ...(destination ? { destination } : {}) };
     }
+    if (/^\/coredump(?:\s|$)/.test(value)) {
+        // A diagnostic of this client's own heap needs neither a session nor a connected host.
+        const tag = value.slice(9).trim().replace(/^(["'])(.*)\1$/, '$2');
+        return { kind: 'coredump', ...(tag ? { tag } : {}) };
+    }
     if (context.question)
         return { kind: 'answer', text: value };
     if (context.pending)

package/dist/ui/commands/registry.js

@@ -21,6 +21,7 @@ export const COMMAND_HINTS = [
     { 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: '/coredump', usage: '[tag]', description: 'Write a V8 heap snapshot for memory diagnosis' },
     { command: '/allow', description: 'Approve the pending request once' },
     { command: '/deny', description: 'Reject the pending request' },
     { command: '/status', description: 'Show full session status details' },

package/dist/ui/dialogs/cost.js

@@ -16,10 +16,10 @@ export function CostPanel({ controller }) {
     const id = controller.state.sessionId;
     const rows = [
         ['Session', id && costs.hasSession(id) ? costs.total(id) : undefined],
-        ['Today', costs.total(undefined, 1)], ['3 days (today + previous 2)', costs.total(undefined, 3)],
+        ['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.estimated ? ` · ${total.estimated} estimated` : ''} / ${total.records} requests` : '?'] }, label)), _jsx(Text, { dimColor: true, children: costs.scanning ? 'Refreshing all visible sessions…'
+    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…'
                     : costs.coverage === 'partial' ? 'Partial totals · awaiting a complete scan'
                         : costs.scannedAt ? `Last refresh: ${new Date(costs.scannedAt).toISOString()}`
-                            : 'Cached totals from the previous run' }), _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))] });
 }