@itookit/dsht 0.3.0 → 0.3.3

package/dist/session/math.js

@@ -0,0 +1,82 @@
+/** MathJax compiles TeX locally; terminal output keeps explicit grouping when Unicode cannot express it. */
+import { mathjax } from '@mathjax/src/js/mathjax.js';
+import { TeX } from '@mathjax/src/js/input/tex.js';
+import { liteAdaptor } from '@mathjax/src/js/adaptors/liteAdaptor.js';
+import { RegisterHTMLHandler } from '@mathjax/src/js/handlers/html.js';
+import { STATE } from '@mathjax/src/js/core/MathItem.js';
+import { TextNode } from '@mathjax/src/js/core/MmlTree/MmlNode.js';
+import { SerializedMmlVisitor } from '@mathjax/src/js/core/MmlTree/SerializedMmlVisitor.js';
+import '@mathjax/src/js/input/tex/base/BaseConfiguration.js';
+import '@mathjax/src/js/input/tex/ams/AmsConfiguration.js';
+import { safeText } from "../transport/wire.js";
+RegisterHTMLHandler(liteAdaptor());
+const superscripts = Object.fromEntries([...('0123456789+-=()ni')].map((c, i) => [c, [...'⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ⁿⁱ'][i]]));
+const subscripts = Object.fromEntries([...'0123456789+-=()aehijklmnoprstuvx'].map((c, i) => [c, [...'₀₁₂₃₄₅₆₇₈₉₊₋₌₍₎ₐₑₕᵢⱼₖₗₘₙₒₚᵣₛₜᵤᵥₓ'][i]]));
+function script(text, sub) {
+    const alphabet = sub ? subscripts : superscripts;
+    return [...text].every(c => alphabet[c]) ? [...text].map(c => alphabet[c]).join('') : `${sub ? '_' : '^'}(${text})`;
+}
+function readable(node) {
+    if (node instanceof TextNode)
+        return node.getText();
+    const children = node.childNodes.map(readable);
+    const [a = '', b = '', c = ''] = children;
+    let base = node.childNodes[0];
+    while (base && ['TeXAtom', 'mrow', 'inferredMrow', 'mstyle'].includes(base.kind) && base.childNodes.length === 1)
+        base = base.childNodes[0];
+    const grouped = base && !base.isToken && base.childNodes.length > 1 ? `(${a})` : a;
+    switch (node.kind) {
+        case 'mfrac': return `(${a})/(${b})`;
+        case 'msqrt': return `√(${children.join('')})`;
+        case 'mroot': return `root(${b}, ${a})`;
+        case 'msup': return `${grouped}${script(b, false)}`;
+        case 'msub': return `${grouped}${script(b, true)}`;
+        case 'msubsup': return `${grouped}${script(b, true)}${script(c, false)}`;
+        case 'munder': return `${a}_(${b})`;
+        case 'mover': return `${a}^(${b})`;
+        case 'munderover': return `${a}_(${b})^(${c})`;
+        case 'mtable': return `[${children.join('; ')}]`;
+        case 'mtr':
+        case 'mlabeledtr': return children.join(', ');
+        case 'mspace': return ' ';
+        case 'mphantom': return '';
+        case 'math':
+        case 'mrow':
+        case 'inferredMrow':
+        case 'TeXAtom':
+        case 'mstyle':
+        case 'mi':
+        case 'mn':
+        case 'mo':
+        case 'mtext':
+        case 'mtd': return children.join('');
+        default: throw new Error(`Unsupported terminal math node: ${node.kind}`);
+    }
+}
+/** Convert one TeX expression, without extension autoloads, network access or shared macro state.
+ * @param source - TeX without delimiters.
+ * @param display - Block rather than inline mathematics.
+ * @returns Unicode approximation and MathJax-generated MathML, or undefined for invalid TeX.
+ */
+export function renderMath(source, display) {
+    if (source.length > 16 * 1024)
+        return undefined;
+    try {
+        const tex = new TeX({ packages: ['base', 'ams'], maxBuffer: 16 * 1024,
+            formatError(_jax, error) { throw error; } });
+        const document = mathjax.document('', { InputJax: tex });
+        const node = document.convert(source, { display, end: STATE.CONVERT });
+        const html = new SerializedMmlVisitor().visitTree(node);
+        let text;
+        try {
+            text = readable(node);
+        }
+        catch {
+            text = source; /* Valid MathML with no faithful terminal notation retains its TeX. */
+        }
+        return { text: safeText(text), html };
+    }
+    catch {
+        return undefined; /* Incomplete or invalid model-authored TeX remains visible as source. */
+    }
+}

package/dist/session/navigation.d.ts

@@ -0,0 +1,37 @@
+/** Shared display names and unambiguous slash-command target resolution. */
+import { type ObjectValue } from '../transport/wire.ts';
+/** Parse workspace and resume navigation, including their long aliases. */
+export declare function navigationCommand(value: string): {
+    kind: 'workspace' | 'session';
+    query?: string;
+} | undefined;
+/** Resolve the host's title projection, falling back to the session ID. */
+export declare function sessionLabel(session: ObjectValue): string;
+/** Match an exact ID or name before a unique ID prefix; never choose an ambiguous target. */
+export declare function resolveTarget(items: ObjectValue[], query: string, id: string, names: (item: ObjectValue) => string[]): ObjectValue;
+/** Activity a session summary reports on its own, without loading that session's history. */
+export type SessionState = 'running' | 'idle' | 'blank';
+/** Classify one session from the host's list summary; nothing is inferred from silence.
+ * @param session - Session summary from `session/list`.
+ * @returns Running while its agent works, blank before its first turn, otherwise idle.
+ */
+export declare function sessionState(session: ObjectValue): SessionState;
+/** Leading marker per state: a working clock, a filled idle dot, and an empty unused circle. */
+export declare const SESSION_MARKERS: Record<SessionState, string>;
+/** Coarse age of a session's last activity, so the column stays steady between list refreshes.
+ * @param time - Epoch milliseconds of the last activity, when the summary reported one.
+ * @param now - Current epoch milliseconds.
+ * @returns `now`, minutes, hours or days.
+ */
+export declare function activityAge(time: number | undefined, now: number): string;
+/** Status cell for one session row: its state marker and the age of its last activity.
+ * @param session - Session summary from `session/list`.
+ * @param now - Current epoch milliseconds.
+ * @returns Marker with an optional age, without a trailing space when unknown.
+ */
+export declare function sessionStatus(session: ObjectValue, now: number): string;
+/** Count the sessions of one workspace by the state each reports.
+ * @param sessions - Sessions whose `sessionIds` belong to the workspace.
+ * @returns One `marker count` cell per state that occurs, running first, or an empty string.
+ */
+export declare function workspaceStatus(sessions: readonly ObjectValue[]): string;

package/dist/session/navigation.js

@@ -0,0 +1,84 @@
+/** Shared display names and unambiguous slash-command target resolution. */
+import { safeText, string } from "../transport/wire.js";
+/** Parse workspace and resume navigation, including their long aliases. */
+export function navigationCommand(value) {
+    const match = /^\/(ws|workspace|workspaces|resume|session|sessions)(?:\s+(.+))?$/.exec(value);
+    if (!match)
+        return undefined;
+    return { kind: match[1] === 'ws' || match[1].startsWith('workspace') ? 'workspace' : 'session', query: match[2] };
+}
+/** Resolve the host's title projection, falling back to the session ID. */
+export function sessionLabel(session) {
+    const projections = session.projections;
+    if (projections && typeof projections === 'object' && !Array.isArray(projections)) {
+        const values = projections.values;
+        const title = values && typeof values === 'object' && !Array.isArray(values) ? values.title : undefined;
+        if (typeof title === 'string' && safeText(title).trim())
+            return safeText(title).trim();
+        if (title && typeof title === 'object' && !Array.isArray(title) && typeof title.title === 'string' && safeText(title.title).trim())
+            return safeText(title.title).trim();
+    }
+    return string(session.sessionId);
+}
+/** Match an exact ID or name before a unique ID prefix; never choose an ambiguous target. */
+export function resolveTarget(items, query, id, names) {
+    const target = query.replace(/^(["'])(.*)\1$/, '$2');
+    const exactId = items.find(item => item[id] === target);
+    if (exactId)
+        return exactId;
+    const exactNames = items.filter(item => names(item).includes(target));
+    const matches = exactNames.length ? exactNames : items.filter(item => string(item[id]).startsWith(target));
+    if (matches.length === 1)
+        return matches[0];
+    if (matches.length > 1)
+        throw new Error(`Ambiguous target: ${target}. Use a full ID.`);
+    throw new Error(`Target not found: ${target}`);
+}
+/** Classify one session from the host's list summary; nothing is inferred from silence.
+ * @param session - Session summary from `session/list`.
+ * @returns Running while its agent works, blank before its first turn, otherwise idle.
+ */
+export function sessionState(session) {
+    if (session.running === true)
+        return 'running';
+    return session.blank === true ? 'blank' : 'idle';
+}
+/** Leading marker per state: a working clock, a filled idle dot, and an empty unused circle. */
+export const SESSION_MARKERS = { running: '◐', idle: '●', blank: '○' };
+/** Coarse age of a session's last activity, so the column stays steady between list refreshes.
+ * @param time - Epoch milliseconds of the last activity, when the summary reported one.
+ * @param now - Current epoch milliseconds.
+ * @returns `now`, minutes, hours or days.
+ */
+export function activityAge(time, now) {
+    if (time === undefined || !Number.isFinite(time))
+        return '';
+    const seconds = Math.max(0, Math.floor((now - time) / 1000));
+    if (seconds < 60)
+        return 'now';
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    return hours < 24 ? `${hours}h` : `${Math.floor(hours / 24)}d`;
+}
+/** Status cell for one session row: its state marker and the age of its last activity.
+ * @param session - Session summary from `session/list`.
+ * @param now - Current epoch milliseconds.
+ * @returns Marker with an optional age, without a trailing space when unknown.
+ */
+export function sessionStatus(session, now) {
+    const age = activityAge(typeof session.updatedAt === 'number' ? session.updatedAt : undefined, now);
+    return `${SESSION_MARKERS[sessionState(session)]}${age === '' ? '' : ` ${age}`}`;
+}
+/** Count the sessions of one workspace by the state each reports.
+ * @param sessions - Sessions whose `sessionIds` belong to the workspace.
+ * @returns One `marker count` cell per state that occurs, running first, or an empty string.
+ */
+export function workspaceStatus(sessions) {
+    const counts = { running: 0, idle: 0, blank: 0 };
+    for (const session of sessions)
+        counts[sessionState(session)] += 1;
+    return ['running', 'idle', 'blank'].filter(state => counts[state] > 0)
+        .map(state => `${SESSION_MARKERS[state]} ${counts[state]}`).join('  ');
+}

package/dist/{references.js → session/references.js}

@@ -1,5 +1,5 @@
 /** Independent adapter for Harness path-only @ references; no file bytes are read. */
-import { array, object, string } from "./wire.js";
+import { array, object, string } from "../transport/wire.js";
 /** Find the unfinished reference at the end of the draft; email addresses do not trigger it.
  * @param text - Complete composer draft.
  * @returns The replaceable token and host query, or undefined outside a reference.

package/dist/{telemetry.d.ts → session/telemetry.d.ts}

@@ -1,5 +1,5 @@
 /** Host projection values with per-key watermarks; snapshots never roll back newer updates. */
-import { type ObjectValue } from './wire.ts';
+import { type ObjectValue } from '../transport/wire.ts';
 /** One host-owned pending input, removable only while its occurrence remains queued. */
 export interface QueuedInput {
     id: string;

package/dist/{telemetry.js → session/telemetry.js}

@@ -1,5 +1,5 @@
 /** Host projection values with per-key watermarks; snapshots never roll back newer updates. */
-import { array, object, string } from "./wire.js";
+import { array, object, string } from "../transport/wire.js";
 function queuedInputs(value) {
     return array(value).map(value => {
         const item = object(value);

package/dist/{transcript.d.ts → session/transcript.d.ts}

@@ -1,5 +1,5 @@
 import type { HistoryLimits } from './memory.ts';
-import { type Json } from './wire.ts';
+import { type Json } from '../transport/wire.ts';
 interface ToolSummary {
     name: string;
     operation?: string;
@@ -25,6 +25,17 @@ export interface MessagePart {
     text: string;
     /** Closed live reasoning can fold before the assistant message is committed. */
     closed?: boolean;
+    /** Stable identity of a live part, so its rows can be wrapped incrementally as it grows. */
+    key?: string;
+}
+/** 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 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;
+    /** Epoch milliseconds when this phase began. */
+    startedAt: number;
 }
 /** A displayed message retains the durable sequence for stable reconciliation. */
 export interface Message {
@@ -60,7 +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;
@@ -97,6 +115,29 @@ export declare class Transcript {
     private dropProjections;
     private storeEvent;
     private deleteEvent;
+    /** 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,
+     * 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. */
@@ -144,6 +185,29 @@ export declare class Transcript {
      */
     private foldLegacy;
     private validatePackedTiming;
+    /** Drop the live attempt's blocks; the phase they named stays until something newer replaces it. */
+    private clearBlocks;
+    /** 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;
 }
 export {};

package/dist/{transcript.js → session/transcript.js}

@@ -1,6 +1,6 @@
 /** Human transcript projection from durable events and ephemeral assistant chunks. */
 import sliceAnsi from 'slice-ansi';
-import { array, object, safeText, string } from "./wire.js";
+import { array, object, safeText, string } from "../transport/wire.js";
 function toolSummary(block) {
     let args = {};
     if (typeof block.arguments === 'string' && block.arguments.trimStart().startsWith('{')) {
@@ -76,7 +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;
@@ -114,7 +121,8 @@ export class Transcript {
                 this.closedBlocks.clear();
                 this.oldestSeq = undefined;
                 this.turnMarker = undefined;
-                this.blocks.clear();
+                this.clearBlocks();
+                this.clearPhase();
                 this.keysDirty = true;
                 this.projectionRevision++;
                 this.legacyDirty = true;
@@ -157,8 +165,7 @@ export class Transcript {
                     throw new Error('Assistant stream revision gap');
                 this.revision = number(live.revision);
                 if (live.type === 'start') {
-                    this.blocks.clear();
-                    this.closedBlocks.clear();
+                    this.clearBlocks();
                     this.attempt = string(live.attemptId);
                     this.nextIndex = 0;
                 }
@@ -172,7 +179,8 @@ export class Transcript {
                     }
                     else if (live.type === 'end') {
                         this.attempt = undefined;
-                        this.blocks.clear();
+                        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); }
@@ -257,8 +273,8 @@ export class Transcript {
         this.events.clear();
         this.sizes.clear();
         this.storedBytes = 0;
-        this.blocks.clear();
-        this.closedBlocks.clear();
+        this.clearBlocks();
+        this.clearPhase();
         this.transientSeqs.clear();
         this.sortedSeqs = [];
         this.displayed = [];
@@ -296,6 +312,58 @@ export class Transcript {
         this.sizes.delete(seq);
         this.events.delete(seq);
     }
+    /** 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,
+     * 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() {
+        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 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() {
         return this.turnMarker?.start;
@@ -449,6 +517,7 @@ export class Transcript {
      * @returns Ordered blocks without terminal style escapes.
      */
     liveParts(width) {
+        const attempt = this.liveAttemptKey ?? 'live';
         return [...this.blocks].sort(([a], [b]) => a - b).map(([index, block]) => {
             const closed = this.closedBlocks.has(index);
             const cached = this.liveProjection.get(block);
@@ -457,6 +526,7 @@ export class Transcript {
             const part = {
                 kind: block.type === 'reasoning' ? 'reasoning' : block.type === 'tool-call' ? 'tool' : 'text',
                 text: cached?.width === width ? cached.part.text : contentText([block], undefined, width), closed,
+                key: `${attempt}:${index}`,
             };
             this.liveProjection.set(block, { width, part });
             return part;
@@ -478,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
@@ -520,8 +597,7 @@ export class Transcript {
     foldLegacy(added) {
         let events;
         if (this.legacyDirty) {
-            this.blocks.clear();
-            this.closedBlocks.clear();
+            this.clearBlocks();
             this.legacyPosition = '';
             this.legacySeq = -1;
             this.legacyDirty = false;
@@ -533,17 +609,14 @@ export class Transcript {
         for (const event of events) {
             this.legacySeq = Math.max(this.legacySeq, number(event.seq));
             if (['step/start', 'step/end', 'turn/end', 'assistant/message', 'assistant/attempt'].includes(string(event.type))) {
-                this.blocks.clear();
-                this.closedBlocks.clear();
+                this.clearBlocks();
                 this.legacyPosition = '';
             }
             else if (event.type === 'assistant/chunk' || string(event.type).startsWith('chunkrow/')) {
                 const data = object(event.data);
                 const nextPosition = `${number(data.turn)}:${number(data.step)}`;
-                if (this.legacyPosition !== nextPosition) {
-                    this.blocks.clear();
-                    this.closedBlocks.clear();
-                }
+                if (this.legacyPosition !== nextPosition)
+                    this.clearBlocks();
                 this.legacyPosition = nextPosition;
                 switch (event.type) {
                     case 'assistant/chunk':
@@ -572,6 +645,48 @@ 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; 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') {
             for (const [index, block] of this.blocks)
@@ -583,13 +698,15 @@ export class Transcript {
             const block = this.blocks.get(index);
             this.blocks.set(index, { type: chunk.type === 'text-delta' ? 'text' : 'reasoning',
                 text: (block ? string(block.text) : '') + string(chunk.text) });
+            this.notePhase(chunk.type === 'text-delta' ? 'output' : 'thinking');
         }
         else if (chunk.type === 'tool-call-delta') {
             const index = number(chunk.index);
             const block = this.blocks.get(index);
-            this.blocks.set(index, { type: 'tool-call', id: string(chunk.id),
-                name: typeof chunk.name === 'string' ? chunk.name : block?.name ?? '',
-                arguments: '' });
+            const name = typeof chunk.name === 'string' ? chunk.name : typeof block?.name === 'string' ? block.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));
@@ -602,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);
@@ -617,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/session/types.d.ts

@@ -0,0 +1,18 @@
+/** Session-domain result types shared by the controller facade and the terminal UI. */
+/** Resolved navigation-removal identity; empty marks a fresh blank, idle session eligible for immediate archival. */
+export interface RemovalTarget {
+    kind: 'workspace' | 'session';
+    id: string;
+    name: string;
+    path?: string;
+    empty?: boolean;
+}
+/** Bounded search results contain navigation summaries, never complete message bodies. */
+export interface HistorySearch {
+    items: {
+        seq: number;
+        role: string;
+        preview: string;
+    }[];
+    truncated: boolean;
+}

package/dist/session/types.js

@@ -0,0 +1,2 @@
+/** Session-domain result types shared by the controller facade and the terminal UI. */
+export {};