@itookit/dsht 0.3.2 → 0.3.3

package/dist/session/transcript.d.ts

@@ -28,9 +28,9 @@ export interface MessagePart {
     /** Stable identity of a live part, so its rows can be wrapped incrementally as it grows. */
     key?: string;
 }
-/** The stripe of live work the unfinished attempt is in. */
+/** The stripe of work the live attempt last moved into; the status bar times it until a newer one. */
 export interface LivePhase {
-    /** Which kind of delta last moved the attempt forward. */
+    /** Which kind of work the newest event named. */
     kind: 'thinking' | 'tool' | 'output';
     /** Tool name when `kind` is `tool`, so the bar can name what is running. */
     name?: string;
@@ -71,8 +71,14 @@ export declare class Transcript {
     private closedBlocks;
     private oldestSeq;
     private turnMarker;
+    /** Pending-tool lookup memo, keyed by the revision that produced it. */
+    private runningCache;
     private attempt;
     private phase;
+    /** Whether the newest delta still extends `phase`; attempt boundaries close it without dropping it. */
+    private phaseOpen;
+    /** Set when an added record can change which call the open turn is still waiting on. */
+    private pendingDirty;
     private nextIndex;
     private revision;
     private legacyStream;
@@ -109,12 +115,29 @@ export declare class Transcript {
     private dropProjections;
     private storeEvent;
     private deleteEvent;
-    /** The stripe of work the live attempt is in: the phase of the block that last took a delta.
+    /** The stripe of work the live attempt is in: the newest event the bar can time.
      *
-     * Its age answers "what is it doing, and for how long" without inferring anything from silence.
+     * Its age answers "what is it doing, and for how long" without inferring anything from silence,
+     * so the answer outlives the stream that supplied it: a tool keeps its age while it runs and after
+     * it answers, until the next stripe starts or the turn closes. Only the turn's own boundaries
+     * withdraw the phase, because everything inside a turn is still work the bar should be timing.
      * @returns Phase kind, the tool name when the phase is a tool call, and when the phase began.
      */
     get livePhase(): LivePhase | undefined;
+    /** The tool the open turn asked for that has not answered yet, oldest first.
+     * @returns Call id, tool name and the moment the request was recorded, or undefined when none is in flight.
+     */
+    get runningTool(): {
+        id: string;
+        name: string;
+        startedAt: number;
+    } | undefined;
+    /** Find the open turn's unanswered tool call, which is the work a bar can still be waiting on.
+     *
+     * The host's `tool/call` event is not retained — only user-visible content is — so this reads the
+     * tool-call blocks a retained assistant message carries and the results that answer them.
+     */
+    private findPendingTool;
     /** Start of the open durable turn, when its timestamp is present in the retained window. */
     get activeTurnStartedAt(): number | undefined;
     /** Cached prompt/reasoning summaries, oldest first; stream deltas never invalidate this index. */
@@ -162,9 +185,28 @@ export declare class Transcript {
      */
     private foldLegacy;
     private validatePackedTiming;
-    /** Drop the live attempt's blocks and the phase derived from them. */
+    /** Drop the live attempt's blocks; the phase they named stays until something newer replaces it. */
     private clearBlocks;
-    /** Record the phase a delta moved the attempt into; the status bar shows its age. */
+    /** Withdraw the phase at a turn boundary, where no work is running under it any more. */
+    private clearPhase;
+    /** Move the phase to the call the open turn is still waiting on, which is work in progress.
+     *
+     * A tool runs after the assistant stream that asked for it has ended, so the live block no longer
+     * covers it; the call the host committed but did not answer is what keeps a long command visible
+     * instead of showing an idle bar. While deltas are still arriving they are the newer evidence, and
+     * a turn with nothing unanswered keeps the phase it has rather than dropping back to silence.
+     */
+    private settlePhase;
+    /** Record the stripe a delta moved the attempt into; the status bar shows its age.
+     *
+     * A delta that continues the open stripe keeps the original start, because the phase is one
+     * stretch of work rather than one chunk. A stripe that returns after the attempt closed it — a
+     * second `think` in a later step — starts over, and the call id is what distinguishes a repeated
+     * tool from the call that already ran.
+     * @param kind - Stripe the delta belongs to.
+     * @param name - Tool name, when the stripe is a tool call.
+     * @param id - Tool call id, when the stripe is a tool call.
+     */
     private notePhase;
     private chunk;
 }

package/dist/session/transcript.js

@@ -76,8 +76,14 @@ export class Transcript {
     closedBlocks = new Set();
     oldestSeq;
     turnMarker;
+    /** Pending-tool lookup memo, keyed by the revision that produced it. */
+    runningCache;
     attempt;
     phase;
+    /** Whether the newest delta still extends `phase`; attempt boundaries close it without dropping it. */
+    phaseOpen = false;
+    /** Set when an added record can change which call the open turn is still waiting on. */
+    pendingDirty = false;
     nextIndex = 0;
     revision = 0;
     legacyStream = false;
@@ -116,6 +122,7 @@ export class Transcript {
                 this.oldestSeq = undefined;
                 this.turnMarker = undefined;
                 this.clearBlocks();
+                this.clearPhase();
                 this.keysDirty = true;
                 this.projectionRevision++;
                 this.legacyDirty = true;
@@ -173,6 +180,7 @@ export class Transcript {
                     else if (live.type === 'end') {
                         this.attempt = undefined;
                         this.clearBlocks();
+                        this.settlePhase();
                     }
                     else
                         throw new Error('Unknown assistant stream frame');
@@ -181,6 +189,10 @@ export class Transcript {
             }
             default: throw new Error('Unknown session follow frame');
         }
+        if (this.pendingDirty) {
+            this.pendingDirty = false;
+            this.settlePhase();
+        }
     }
     /** Add an older page without replacing the live tail. */
     addPage(value) {
@@ -190,6 +202,10 @@ export class Transcript {
         const page = object(value);
         this.addRecords(array(page.records));
         this.hasMore = page.hasMore === true;
+        if (this.pendingDirty) {
+            this.pendingDirty = false;
+            this.settlePhase();
+        }
     }
     /** Durable read cutoff includes followed records that were not present in the opening snapshot. */
     get readThrough() { return Math.max(this.cursor, this.throughSeq); }
@@ -258,6 +274,7 @@ export class Transcript {
         this.sizes.clear();
         this.storedBytes = 0;
         this.clearBlocks();
+        this.clearPhase();
         this.transientSeqs.clear();
         this.sortedSeqs = [];
         this.displayed = [];
@@ -295,16 +312,57 @@ export class Transcript {
         this.sizes.delete(seq);
         this.events.delete(seq);
     }
-    /** The stripe of work the live attempt is in: the phase of the block that last took a delta.
+    /** The stripe of work the live attempt is in: the newest event the bar can time.
      *
-     * Its age answers "what is it doing, and for how long" without inferring anything from silence.
+     * Its age answers "what is it doing, and for how long" without inferring anything from silence,
+     * so the answer outlives the stream that supplied it: a tool keeps its age while it runs and after
+     * it answers, until the next stripe starts or the turn closes. Only the turn's own boundaries
+     * withdraw the phase, because everything inside a turn is still work the bar should be timing.
      * @returns Phase kind, the tool name when the phase is a tool call, and when the phase began.
      */
     get livePhase() {
-        if (this.phase === undefined || this.blocks.size === 0)
+        const phase = this.phase;
+        return phase === undefined ? undefined
+            : { kind: phase.kind, ...(phase.name === undefined ? {} : { name: phase.name }), startedAt: phase.startedAt };
+    }
+    /** The tool the open turn asked for that has not answered yet, oldest first.
+     * @returns Call id, tool name and the moment the request was recorded, or undefined when none is in flight.
+     */
+    get runningTool() {
+        if (this.runningCache?.version === this.version)
+            return this.runningCache.value;
+        const value = this.findPendingTool();
+        this.runningCache = { version: this.version, value };
+        return value;
+    }
+    /** Find the open turn's unanswered tool call, which is the work a bar can still be waiting on.
+     *
+     * The host's `tool/call` event is not retained — only user-visible content is — so this reads the
+     * tool-call blocks a retained assistant message carries and the results that answer them.
+     */
+    findPendingTool() {
+        const marker = this.turnMarker;
+        // A turn that ended cannot have a tool in flight, and `turn/end` clears the marker's start.
+        if (marker?.start === undefined)
             return undefined;
-        const { kind, name, startedAt } = this.phase;
-        return { kind, ...(name === undefined ? {} : { name }), startedAt };
+        const calls = [];
+        const answered = new Set();
+        for (const seq of this.sortedKeys()) {
+            if (seq <= marker.seq)
+                continue;
+            const event = this.events.get(seq);
+            if (event.type !== 'assistant/message' && event.type !== 'tool/result')
+                continue;
+            const startedAt = typeof event.time === 'number' ? event.time : marker.start;
+            for (const block of array(object(object(event.data).message).content).map(object)) {
+                if (block.type === 'tool-call')
+                    calls.push({ id: string(block.id), name: string(block.name ?? 'tool'), startedAt });
+                else if (block.type === 'tool-result')
+                    answered.add(string(block.toolCallId));
+            }
+        }
+        const pending = calls.find(call => !answered.has(call.id));
+        return pending === undefined ? undefined : { id: pending.id, name: pending.name, startedAt: pending.startedAt };
     }
     /** Start of the open durable turn, when its timestamp is present in the retained window. */
     get activeTurnStartedAt() {
@@ -490,9 +548,16 @@ export class Transcript {
             this.throughSeq = Math.max(this.throughSeq, seq);
             if ((event.type === 'turn/start' || event.type === 'turn/end') && seq >= (this.turnMarker?.seq ?? -1)) {
                 this.turnMarker = { seq, start: event.type === 'turn/start' && typeof event.time === 'number' && Number.isFinite(event.time) ? event.time : undefined };
+                // A turn is the span a phase belongs to: the closed one has nothing left running and the
+                // opening one has not moved yet, so neither may show the other's last event.
+                this.clearPhase();
             }
             const current = this.events.get(seq);
             this.storeEvent(seq, retainedEvent(event));
+            // Only these records can answer "which call is the open turn still waiting on".
+            if (event.type === 'assistant/message' || event.type === 'tool/result'
+                || event.type === 'turn/start' || event.type === 'turn/end')
+                this.pendingDirty = true;
             if (!DISPLAY_EVENTS.has(string(event.type)))
                 this.transientSeqs.add(seq);
             else
@@ -580,14 +645,47 @@ export class Transcript {
         if (count === 0 || array(data.dt).length !== count - 1)
             throw new Error('Invalid packed history member count');
     }
-    /** Drop the live attempt's blocks and the phase derived from them. */
-    clearBlocks() { this.blocks.clear(); this.closedBlocks.clear(); this.phase = undefined; }
-    /** Record the phase a delta moved the attempt into; the status bar shows its age. */
-    notePhase(kind, name) {
-        const key = kind === 'tool' ? `tool:${name ?? ''}` : kind;
+    /** Drop the live attempt's blocks; the phase they named stays until something newer replaces it. */
+    clearBlocks() { this.blocks.clear(); this.closedBlocks.clear(); this.phaseOpen = false; }
+    /** Withdraw the phase at a turn boundary, where no work is running under it any more. */
+    clearPhase() { this.phase = undefined; this.phaseOpen = false; }
+    /** Move the phase to the call the open turn is still waiting on, which is work in progress.
+     *
+     * A tool runs after the assistant stream that asked for it has ended, so the live block no longer
+     * covers it; the call the host committed but did not answer is what keeps a long command visible
+     * instead of showing an idle bar. While deltas are still arriving they are the newer evidence, and
+     * a turn with nothing unanswered keeps the phase it has rather than dropping back to silence.
+     */
+    settlePhase() {
+        if (this.phaseOpen)
+            return;
+        const tool = this.runningTool;
+        if (tool === undefined)
+            return;
+        const key = toolPhaseKey(tool.id, tool.name);
         if (this.phase?.key === key)
             return;
+        this.phase = { key, kind: 'tool', name: tool.name, startedAt: tool.startedAt };
+    }
+    /** Record the stripe a delta moved the attempt into; the status bar shows its age.
+     *
+     * A delta that continues the open stripe keeps the original start, because the phase is one
+     * stretch of work rather than one chunk. A stripe that returns after the attempt closed it — a
+     * second `think` in a later step — starts over, and the call id is what distinguishes a repeated
+     * tool from the call that already ran.
+     * @param kind - Stripe the delta belongs to.
+     * @param name - Tool name, when the stripe is a tool call.
+     * @param id - Tool call id, when the stripe is a tool call.
+     */
+    notePhase(kind, name, id) {
+        const key = kind === 'tool' ? toolPhaseKey(id ?? '', name) : kind;
+        if (this.phase?.key === key && this.phaseOpen) {
+            if (name !== undefined && this.phase.name !== name)
+                this.phase = { key, kind, name, startedAt: this.phase.startedAt };
+            return;
+        }
         this.phase = { key, kind, ...(name === undefined ? {} : { name }), startedAt: Date.now() };
+        this.phaseOpen = true;
     }
     chunk(chunk) {
         if (chunk.type === 'text-delta' || chunk.type === 'tool-call-delta') {
@@ -606,8 +704,9 @@ export class Transcript {
             const index = number(chunk.index);
             const block = this.blocks.get(index);
             const name = typeof chunk.name === 'string' ? chunk.name : typeof block?.name === 'string' ? block.name : '';
-            this.blocks.set(index, { type: 'tool-call', id: string(chunk.id), name, arguments: '' });
-            this.notePhase('tool', name === '' ? undefined : name);
+            const id = typeof chunk.id === 'string' ? chunk.id : typeof block?.id === 'string' ? block.id : '';
+            this.blocks.set(index, { type: 'tool-call', id, name, arguments: '' });
+            this.notePhase('tool', name === '' ? undefined : name, id);
         }
         else if (chunk.type === 'block-end') {
             this.blocks.set(number(chunk.index), object(chunk.block));
@@ -620,12 +719,16 @@ function number(value) {
         throw new Error('Invalid sequence number');
     return value;
 }
+/** Identity of one tool call, so two calls of the same tool do not share one phase. */
+function toolPhaseKey(id, name) {
+    return `tool:${id === '' ? name ?? '' : id}`;
+}
 /** Keep only user-visible content in durable client memory; the host owns raw tool results. */
 function retainedEvent(event) {
     if (!DISPLAY_EVENTS.has(string(event.type)))
         return event;
     if (event.surfaceOp !== 'append')
-        return { seq: event.seq, type: event.type };
+        return { seq: event.seq, type: event.type, ...(typeof event.time === 'number' ? { time: event.time } : {}) };
     const data = object(event.data);
     const clean = (value) => {
         const block = object(value);
@@ -635,7 +738,7 @@ function retainedEvent(event) {
             return { type: 'tool-result', toolCallId: block.toolCallId, isError: block.isError === true };
         return block;
     };
-    return { seq: event.seq, type: event.type, surfaceOp: 'append', data: event.type === 'user/message'
+    return { seq: event.seq, type: event.type, ...(typeof event.time === 'number' ? { time: event.time } : {}), surfaceOp: 'append', data: event.type === 'user/message'
             ? { content: data.content, ...(data.source ? { source: data.source } : {}) }
             : { message: { content: array(object(data.message).content).filter(block => event.type !== 'tool/result' || object(block).type === 'tool-result').map(clean) } } };
 }

package/dist/storage/files.d.ts

@@ -9,6 +9,14 @@ export declare function readText(path: string): Promise<string | undefined>;
  * @returns File contents, or undefined when the file does not exist.
  */
 export declare function readPrivateFile(path: string, label: string): Promise<string | undefined>;
+/** Move one private file within its directory, ignoring a source that is already gone.
+ *
+ * Used to set an unreadable file aside under a new name without deleting the bytes. A missing source
+ * is not an error: the caller listed the directory earlier and another process may have removed it.
+ * @param from - Existing path.
+ * @param to - Destination path, replaced when it already exists.
+ */
+export declare function renameFile(from: string, to: string): Promise<void>;
 /** Replace a file atomically with owner-only contents, leaving no partial file behind.
  * @param path - Destination path.
  * @param contents - Complete file contents.

package/dist/storage/files.js

@@ -43,6 +43,23 @@ export async function readPrivateFile(path, label) {
         await handle.close();
     }
 }
+/** Move one private file within its directory, ignoring a source that is already gone.
+ *
+ * Used to set an unreadable file aside under a new name without deleting the bytes. A missing source
+ * is not an error: the caller listed the directory earlier and another process may have removed it.
+ * @param from - Existing path.
+ * @param to - Destination path, replaced when it already exists.
+ */
+export async function renameFile(from, to) {
+    try {
+        await rename(from, to);
+    }
+    catch (error) {
+        if (isMissing(error))
+            return;
+        throw error;
+    }
+}
 /** Replace a file atomically with owner-only contents, leaving no partial file behind.
  * @param path - Destination path.
  * @param contents - Complete file contents.

package/dist/storage/heap-snapshot.d.ts

@@ -0,0 +1,19 @@
+/** Build a snapshot filename from a sampling-point tag and a time.
+ *
+ * The tag is a user label such as `after-stress`; everything that could steer the write outside the
+ * destination directory is folded into a dash, so a tag can never become a path.
+ * @param tag - Sampling-point label.
+ * @param time - Epoch milliseconds that keeps repeated snapshots distinct.
+ * @returns A `.heapsnapshot` filename that names one file in one directory.
+ */
+export declare function heapSnapshotName(tag: string, time: number): string;
+/** Write a V8 heap snapshot into one directory.
+ *
+ * V8 serializes the whole heap synchronously, so the client pauses while the file is written; the
+ * result is the artifact DevTools records, meant for offline leak analysis rather than display.
+ * @param directory - Destination directory.
+ * @param tag - Sampling-point label naming the file.
+ * @param write - Snapshot writer; injectable so tests do not have to serialize a heap.
+ * @returns Absolute path of the written snapshot.
+ */
+export declare function writeHeapSnapshot(directory: string, tag?: string, write?: (file: string) => string): string;

package/dist/storage/heap-snapshot.js

@@ -0,0 +1,29 @@
+/** V8 heap snapshots written to the working directory so memory growth can be inspected offline. */
+import { join } from 'node:path';
+import { writeHeapSnapshot as writeV8HeapSnapshot } from 'node:v8';
+/** Longest sampling-point tag kept in a snapshot filename. */
+const TAG_LIMIT = 48;
+/** Build a snapshot filename from a sampling-point tag and a time.
+ *
+ * The tag is a user label such as `after-stress`; everything that could steer the write outside the
+ * destination directory is folded into a dash, so a tag can never become a path.
+ * @param tag - Sampling-point label.
+ * @param time - Epoch milliseconds that keeps repeated snapshots distinct.
+ * @returns A `.heapsnapshot` filename that names one file in one directory.
+ */
+export function heapSnapshotName(tag, time) {
+    const safe = tag.trim().replace(/[^A-Za-z0-9._-]+/g, '-').replace(/^[.-]+/, '').slice(0, TAG_LIMIT).replace(/[.-]+$/, '');
+    return `${safe || 'snapshot'}-${time}.heapsnapshot`;
+}
+/** Write a V8 heap snapshot into one directory.
+ *
+ * V8 serializes the whole heap synchronously, so the client pauses while the file is written; the
+ * result is the artifact DevTools records, meant for offline leak analysis rather than display.
+ * @param directory - Destination directory.
+ * @param tag - Sampling-point label naming the file.
+ * @param write - Snapshot writer; injectable so tests do not have to serialize a heap.
+ * @returns Absolute path of the written snapshot.
+ */
+export function writeHeapSnapshot(directory, tag = 'snapshot', write = writeV8HeapSnapshot) {
+    return write(join(directory, heapSnapshotName(tag, Date.now())));
+}

package/dist/storage/index.d.ts

@@ -1,3 +1,4 @@
 /** Storage domain: every filesystem operation the client performs. */
-export { appendPrivateFile, createPrivateFile, readPrivateFile, readText, removeFile, writeExclusiveStream, writePrivateFile } from './files.ts';
+export { appendPrivateFile, createPrivateFile, readPrivateFile, readText, removeFile, renameFile, writeExclusiveStream, writePrivateFile } from './files.ts';
 export { ensureDirectory, ensurePrivateDirectory, listEntries } from './directories.ts';
+export { heapSnapshotName, writeHeapSnapshot } from './heap-snapshot.ts';

package/dist/storage/index.js

@@ -1,3 +1,4 @@
 /** Storage domain: every filesystem operation the client performs. */
-export { appendPrivateFile, createPrivateFile, readPrivateFile, readText, removeFile, writeExclusiveStream, writePrivateFile } from "./files.js";
+export { appendPrivateFile, createPrivateFile, readPrivateFile, readText, removeFile, renameFile, writeExclusiveStream, writePrivateFile } from "./files.js";
 export { ensureDirectory, ensurePrivateDirectory, listEntries } from "./directories.js";
+export { heapSnapshotName, writeHeapSnapshot } from "./heap-snapshot.js";

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 { sessionLabel, sessionStatus, 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,6 +255,11 @@ 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) {
@@ -335,6 +373,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 +600,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,17 +621,28 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
         if (accepted)
             setInput('');
     };
+    // Session activity is a list-level fact, so both pickers read it without loading any history.
+    const listAge = Date.now();
+    const sessionsOf = (workspace) => {
+        const ids = new Set(array(workspace.sessionIds).map(string));
+        return state.sessions.filter(session => ids.has(string(session.sessionId)));
+    };
     const choices = state.screen === 'workspaces' ? [
         ...state.workspaces.map(workspace => ({ key: string(workspace.workspaceId),
-            label: `${string(workspace.title)}  ${string(workspace.path)}`,
+            label: `${[workspaceStatus(sessionsOf(workspace)), string(workspace.title), string(workspace.path)].filter(Boolean).join('  ')}`,
             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)} ${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')) },
@@ -722,5 +785,6 @@ export function App({ controller, panelLifetimeMs = PANEL_LIFETIME_MS, theme = m
     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 }))
                                                                         .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' : '↑ ↓ / 1–9 select · Enter confirm' })] }), _jsx(Text, { dimColor: true, children: question ? 'Choose "Other answer" to type · 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 }), _jsxs(Box, { flexShrink: 0, children: [_jsx(Text, { color: answerPending ? theme.colors.muted : 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 && !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)) });
 }