@itookit/dsht 0.2.4 → 0.3.2

package/dist/session/markdown.js

@@ -0,0 +1,255 @@
+/** Markdown becomes terminal rows before viewport indexing; source text remains in the transcript. */
+import { Marked } from 'marked';
+import { renderMermaidASCII, renderMermaidSVG } from 'beautiful-mermaid';
+import stringWidth from 'string-width';
+import wrapAnsi from 'wrap-ansi';
+import { stripVTControlCharacters } from 'node:util';
+import { decodeHTML } from 'entities';
+import { safeText } from "../transport/wire.js";
+import { renderMath } from "./math.js";
+const parser = new Marked({ gfm: true });
+// Math is tokenized before Markdown escapes, but after fenced and inline code have claimed their source.
+function mathToken(source, block) {
+    const match = block
+        ? /^(?:\$\$([\s\S]+?)\$\$|\\\[([\s\S]+?)\\\])(?:[ \t]*\n|$)/.exec(source)
+        : /^(?:\$\$([^\n]+?)\$\$|\$(?![\s$])((?:\\.|[^$\n\\])+?)(?<!\s)\$(?!\d)|\\\(([^\n]+?)\\\)|\\\[([^\n]+?)\\\])/.exec(source);
+    if (!match)
+        return undefined;
+    return { type: 'math', raw: match[0], text: match.slice(1).find(value => value !== undefined),
+        display: block || source.startsWith('$$') || source.startsWith('\\[') };
+}
+for (const level of ['block', 'inline'])
+    parser.use({ extensions: [{
+                name: 'math', level,
+                start: source => { const index = source.search(level === 'block' ? /\$\$|\\\[/ : /\$|\\[([]/); return index < 0 ? undefined : index; },
+                tokenizer: source => mathToken(source, level === 'block'),
+                renderer: token => mathHtml(token),
+            }] });
+const rendered = new Map();
+let cachedChars = 0;
+let cacheHits = 0;
+let cacheMisses = 0;
+function cached(key, render) {
+    const existing = rendered.get(key);
+    if (existing !== undefined) {
+        cacheHits++;
+        return existing;
+    }
+    cacheMisses++;
+    const result = render();
+    const size = key.length + result.length;
+    if (size <= 64 * 1024) {
+        while (rendered.size >= 128 || cachedChars + size > 256 * 1024) {
+            const oldest = rendered.keys().next().value;
+            cachedChars -= oldest.length + rendered.get(oldest).length;
+            rendered.delete(oldest);
+        }
+        rendered.set(key, result);
+        cachedChars += size;
+    }
+    return result;
+}
+/** Report the bounded math and diagram cache, so a memory sample can tell churn from retention.
+ * @returns Cached entries, their accounted characters, and lookup counters.
+ */
+export function markdownCacheStats() {
+    return { entries: rendered.size, chars: cachedChars, hits: cacheHits, misses: cacheMisses };
+}
+function mathText(token) {
+    return cached(`math:${token.display}:${token.text}`, () => renderMath(token.text, token.display)?.text ?? token.raw.trimEnd());
+}
+function mathHtml(token) {
+    return renderMath(token.text, token.display)?.html ?? `<code>${escapeHtml(token.raw)}</code>`;
+}
+function style(text, open, close) {
+    return `\x1b[${open}m${text.replaceAll(`\x1b[${close}m`, `\x1b[${close}m\x1b[${open}m`)}\x1b[${close}m`;
+}
+function plain(text) { return safeText(text).replace(/\t/g, '    '); }
+function inline(tokens) {
+    return tokens.map(token => {
+        switch (token.type) {
+            case 'strong': return style(inline(token.tokens), 1, 22);
+            case 'em': return style(inline(token.tokens), 3, 23);
+            case 'del': return style(inline(token.tokens), 9, 29);
+            case 'codespan': return style(plain(token.text), 7, 27);
+            case 'link': {
+                const label = inline(token.tokens);
+                const href = plain(token.href);
+                return style(label, 4, 24) + (stripVTControlCharacters(label) === href ? '' : ` (${href})`);
+            }
+            case 'image': return `${inline(token.tokens)} (${plain(token.href)})`;
+            case 'br': return '\n';
+            case 'math': return mathText(token);
+            case 'html': return /^<br\s*\/?\s*>$/i.test(token.raw) ? '\n' : plain(token.raw);
+            case 'escape': return plain(token.text);
+            default: return 'tokens' in token && token.tokens ? inline(token.tokens)
+                : plain(decodeHTML('text' in token && typeof token.text === 'string' ? token.text : token.raw));
+        }
+    }).join('');
+}
+function wrap(text, width, trim = true) {
+    return wrapAnsi(text, Math.max(1, width), { hard: true, trim }).split('\n');
+}
+function table(token, width) {
+    const cells = [token.header, ...token.rows].map(row => row.map(cell => inline(cell.tokens)));
+    const count = token.header.length;
+    const available = width - 3 * count - 1;
+    // Narrow screens show each record vertically instead of squeezing columns into unreadable fragments.
+    if (available < 12 * count) {
+        if (cells.length === 1)
+            return cells[0].flatMap(cell => wrap(style(cell, 1, 22), width));
+        return cells.slice(1).flatMap((row, index) => [
+            ...(index ? ['─'.repeat(Math.min(width, 20))] : []),
+            ...row.flatMap((cell, column) => wrap(`${cells[0][column] ? style(cells[0][column], 1, 22) + ': ' : ''}${cell}`, width)),
+        ]);
+    }
+    const widths = Array.from({ length: count }, (_, column) => Math.max(3, ...cells.map(row => Math.max(...row[column].split('\n').map(line => stringWidth(line))))));
+    while (widths.reduce((sum, value) => sum + value, 0) > available) {
+        const column = widths.indexOf(Math.max(...widths));
+        widths[column]--;
+    }
+    const border = (left, middle, right) => left + widths.map(size => '─'.repeat(size + 2)).join(middle) + right;
+    const output = [border('┌', '┬', '┐')];
+    cells.forEach((row, index) => {
+        const lines = row.map((cell, column) => wrap(index === 0 ? style(cell, 1, 22) : cell, widths[column]));
+        for (let line = 0; line < Math.max(...lines.map(cell => cell.length)); line++) {
+            output.push('│ ' + lines.map((cell, column) => {
+                const value = cell[line] ?? '';
+                const padding = widths[column] - stringWidth(value);
+                const align = token.align[column];
+                const before = align === 'right' ? padding : align === 'center' ? Math.floor(padding / 2) : 0;
+                return ' '.repeat(Math.max(0, before)) + value + ' '.repeat(Math.max(0, padding - before));
+            }).join(' │ ') + ' │');
+        }
+        if (index === 0)
+            output.push(border('├', '┼', '┤'));
+    });
+    output.push(border('└', '┴', '┘'));
+    return output;
+}
+function diagram(source, width) {
+    if (source.length > 16 * 1024)
+        return undefined;
+    try {
+        const text = cached(`mermaid:${source}`, () => {
+            // The ASCII renderer measures code units. Reserve one extra cell for each wide BMP character.
+            const padding = Array.from({ length: 256 }, (_, i) => String.fromCharCode(0xe000 + i)).find(c => !source.includes(c));
+            if (!padding)
+                throw new Error('No available diagram padding character');
+            const measured = [...source].map(c => c + padding.repeat(Math.max(0, stringWidth(c) - c.length))).join('');
+            return plain(renderMermaidASCII(measured, { colorMode: 'none' }).replaceAll(padding, ''));
+        });
+        const lines = text.trimEnd().split('\n').map(line => line.trimEnd());
+        return lines.every(line => stringWidth(line) <= width) ? lines : undefined;
+    }
+    catch {
+        return undefined; /* Unsupported or unfinished diagrams retain their source. */
+    }
+}
+function blocks(tokens, width) {
+    return tokens.flatMap(token => {
+        switch (token.type) {
+            case 'space': return [''];
+            case 'def': return [];
+            case 'heading': return wrap(style(inline(token.tokens), 1, 22), width);
+            case 'paragraph':
+            case 'text': return wrap(token.tokens ? inline(token.tokens) : plain(token.text), width);
+            case 'hr': return ['─'.repeat(width)];
+            case 'table': return table(token, width);
+            case 'blockquote': return blocks(token.tokens, Math.max(1, width - 2)).map(line => width > 2 ? `│ ${line}` : line);
+            case 'list': return token.items.flatMap((item, index) => {
+                const marker = item.task ? item.checked ? '[x] ' : '[ ] ' : token.ordered ? `${Number(token.start) + index}. ` : '• ';
+                const prefix = width > marker.length + 1 ? marker : '';
+                return blocks(item.tokens.filter(child => child.type !== 'checkbox'), Math.max(1, width - prefix.length))
+                    .map((line, row) => `${row === 0 ? prefix : ' '.repeat(prefix.length)}${line}`);
+            });
+            case 'code': {
+                const language = plain(token.lang ?? '').split(/\s/)[0];
+                // An open fence is source, even when its current contents form a parseable partial diagram.
+                const closed = /(?:^|\n) {0,3}(`{3,}|~{3,})[ \t]*(?:\n)?$/.test(token.raw);
+                const graph = language === 'mermaid' && closed ? diagram(token.text, width) : undefined;
+                if (graph)
+                    return graph;
+                if (['math', 'latex', 'tex', 'mathjax'].includes(language) && closed) {
+                    return wrap(mathText({ type: 'math', text: token.text, raw: token.text, display: true }), width, false);
+                }
+                return [...wrap(`┌ ${language || 'code'}`, width, false), ...wrap(plain(token.text), width, false), '└'];
+            }
+            case 'math': return wrap(mathText(token), width, false);
+            default: return wrap(plain(token.raw), width);
+        }
+    });
+}
+// Decode only locally generated style codes after wrap-ansi has balanced styles across line breaks.
+function row(text) {
+    const spans = [];
+    let current = {};
+    let start = 0;
+    const properties = { 1: 'bold', 3: 'italic', 4: 'underline', 7: 'inverse', 9: 'strikethrough',
+        22: 'bold', 23: 'italic', 24: 'underline', 27: 'inverse', 29: 'strikethrough' };
+    for (const match of text.matchAll(/\x1b\[(\d+)m/g)) {
+        if (match.index > start)
+            spans.push({ text: text.slice(start, match.index), ...current });
+        const code = Number(match[1]);
+        if (code === 0)
+            current = {};
+        else if (code in properties)
+            current[properties[code]] = code < 20;
+        start = match.index + match[0].length;
+    }
+    if (start < text.length)
+        spans.push({ text: text.slice(start), ...current });
+    return { text: spans.map(span => span.text).join(''), ...(text.includes('\x1b') ? { spans } : {}) };
+}
+/** Whether a source can contain Markdown constructs; false preserves incremental plain-text wrapping.
+ * @param source - Complete text or a delta with its preceding line.
+ * @returns Whether Markdown lexing is required.
+ */
+export function hasMarkdown(source) {
+    return /[*_`~\[\]<>|$\\#&\t]|(?:^|\n)(?: {4}| {0,3}(?:[-+=]{1,}|\d+[.)])(?:\s|$))|\n\s*\n/.test(source);
+}
+/** Parse GFM and TeX into styled rows whose widths match the terminal viewport.
+ * @param source - Model or user message; remote terminal controls are removed.
+ * @param width - Available terminal columns.
+ * @returns Terminal rows, with literal source for invalid or unsupported rich blocks.
+ */
+export function markdownRows(source, width) {
+    width = Math.max(1, width);
+    if (!hasMarkdown(source))
+        return wrap(plain(source), width).map(row);
+    return blocks(parser.lexer(plain(source)), width).map(row);
+}
+function escapeHtml(text) {
+    return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;');
+}
+function safeLink(href) {
+    return /^(?:https?:|mailto:)/i.test(href) && !/[\u0000-\u0020]/.test(href) ? escapeHtml(href) : undefined;
+}
+parser.use({ renderer: {
+        html: token => escapeHtml(token.text),
+        link(token) {
+            const label = this.parser.parseInline(token.tokens);
+            const href = safeLink(token.href);
+            return href ? `<a href="${href}" rel="noreferrer">${label}</a>` : `${label} (${escapeHtml(token.href)})`;
+        },
+        image: token => `${escapeHtml(token.text)} (${escapeHtml(token.href)})`,
+        code(token) {
+            const language = (token.lang ?? '').split(/\s/)[0];
+            if (language === 'mermaid' && token.text.length <= 16 * 1024) {
+                try {
+                    const svg = renderMermaidSVG(token.text);
+                    // SVG image documents cannot run script or load external resources in the exported page.
+                    return `<img alt="Mermaid diagram" src="data:image/svg+xml;base64,${Buffer.from(svg).toString('base64')}">`;
+                }
+                catch { /* Unsupported Mermaid syntax remains readable in a code block. */ }
+            }
+            if (['math', 'latex', 'tex', 'mathjax'].includes(language ?? ''))
+                return mathHtml({ type: 'math', text: token.text, raw: token.text, display: true });
+            return `<pre><code>${escapeHtml(token.text)}</code></pre>`;
+        },
+    } });
+/** Render safe, offline HTML with Mermaid SVG images and MathJax-generated MathML.
+ * @param source - Markdown source, never trusted as executable HTML.
+ * @returns An HTML fragment that requires no scripts or remote assets.
+ */
+export function markdownHtml(source) { return parser.parse(safeText(source), { async: false }); }

package/dist/session/math.d.ts

@@ -0,0 +1,11 @@
+import '@mathjax/src/js/input/tex/base/BaseConfiguration.js';
+import '@mathjax/src/js/input/tex/ams/AmsConfiguration.js';
+/** 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 declare function renderMath(source: string, display: boolean): {
+    text: string;
+    html: string;
+} | undefined;

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/{navigation.d.ts → session/navigation.d.ts}

@@ -1,5 +1,5 @@
 /** Shared display names and unambiguous slash-command target resolution. */
-import { type ObjectValue } from './wire.ts';
+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';

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

@@ -1,5 +1,5 @@
 /** Shared display names and unambiguous slash-command target resolution. */
-import { safeText, string } from "./wire.js";
+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);

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,11 @@
 /** 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;
+    placement: 'queued' | 'steering' | 'context';
+    text: string;
+}
 /** Generation-local projection, inbox and background-job data for every session. */
 export declare class Telemetry {
     private readonly retainedKeys?;
@@ -27,5 +33,10 @@ export declare class Telemetry {
         queued?: number;
         jobs?: number;
     };
+    /** Read the selected session's authoritative pending inputs; absence means no observed queue.
+     * @param id - Session identity.
+     * @returns Pending inputs in host order.
+     */
+    pending(id?: string): readonly QueuedInput[];
     private entry;
 }

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

@@ -1,5 +1,14 @@
 /** 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);
+        if (!['queued', 'steering', 'context'].includes(string(item.placement)))
+            throw new Error('Invalid queue placement');
+        return { id: string(item.id), placement: item.placement,
+            text: array(object(item.message).content).map(object).map(block => block.type === 'text' ? string(block.text) : `[${string(block.type)}]`).join(' ') };
+    });
+}
 /** Generation-local projection, inbox and background-job data for every session. */
 export class Telemetry {
     retainedKeys;
@@ -24,7 +33,7 @@ export class Telemetry {
             for (const [id, projection] of Object.entries(object(baseline.projections)))
                 this.snapshot(id, projection);
             for (const [id, items] of Object.entries(object(baseline.queues)))
-                this.queues.set(id, array(items).length);
+                this.queues.set(id, queuedInputs(items));
             for (const [id, items] of Object.entries(object(baseline.jobs)))
                 this.jobs.set(id, activeJobs(items));
             this.ready = true;
@@ -47,7 +56,7 @@ export class Telemetry {
             entry.revisions.set(key, seq);
         }
         else if (frame.type === 'queue')
-            this.queues.set(id, array(frame.items).length);
+            this.queues.set(id, queuedInputs(frame.items));
         else if (frame.type === 'jobs')
             this.jobs.set(id, activeJobs(frame.items));
         else
@@ -85,8 +94,13 @@ export class Telemetry {
      */
     view(id) {
         return { values: id ? this.entries.get(id)?.values ?? {} : {},
-            queued: id ? this.queues.get(id) : undefined, jobs: id ? this.jobs.get(id) : undefined };
+            queued: id ? this.queues.get(id)?.length : undefined, jobs: id ? this.jobs.get(id) : undefined };
     }
+    /** Read the selected session's authoritative pending inputs; absence means no observed queue.
+     * @param id - Session identity.
+     * @returns Pending inputs in host order.
+     */
+    pending(id) { return id ? this.queues.get(id) ?? [] : []; }
     entry(id) {
         let entry = this.entries.get(id);
         if (!entry) {

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 live work the unfinished attempt is in. */
+export interface LivePhase {
+    /** Which kind of delta last moved the attempt forward. */
+    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 {
@@ -61,6 +72,7 @@ export declare class Transcript {
     private oldestSeq;
     private turnMarker;
     private attempt;
+    private phase;
     private nextIndex;
     private revision;
     private legacyStream;
@@ -97,6 +109,12 @@ 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.
+     *
+     * Its age answers "what is it doing, and for how long" without inferring anything from silence.
+     * @returns Phase kind, the tool name when the phase is a tool call, and when the phase began.
+     */
+    get livePhase(): LivePhase | undefined;
     /** 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 +162,10 @@ export declare class Transcript {
      */
     private foldLegacy;
     private validatePackedTiming;
+    /** Drop the live attempt's blocks and the phase derived from them. */
+    private clearBlocks;
+    /** Record the phase a delta moved the attempt into; the status bar shows its age. */
+    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('{')) {
@@ -77,6 +77,7 @@ export class Transcript {
     oldestSeq;
     turnMarker;
     attempt;
+    phase;
     nextIndex = 0;
     revision = 0;
     legacyStream = false;
@@ -114,7 +115,7 @@ export class Transcript {
                 this.closedBlocks.clear();
                 this.oldestSeq = undefined;
                 this.turnMarker = undefined;
-                this.blocks.clear();
+                this.clearBlocks();
                 this.keysDirty = true;
                 this.projectionRevision++;
                 this.legacyDirty = true;
@@ -157,8 +158,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 +172,7 @@ export class Transcript {
                     }
                     else if (live.type === 'end') {
                         this.attempt = undefined;
-                        this.blocks.clear();
+                        this.clearBlocks();
                     }
                     else
                         throw new Error('Unknown assistant stream frame');
@@ -257,8 +257,7 @@ export class Transcript {
         this.events.clear();
         this.sizes.clear();
         this.storedBytes = 0;
-        this.blocks.clear();
-        this.closedBlocks.clear();
+        this.clearBlocks();
         this.transientSeqs.clear();
         this.sortedSeqs = [];
         this.displayed = [];
@@ -296,6 +295,17 @@ 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.
+     *
+     * Its age answers "what is it doing, and for how long" without inferring anything from silence.
+     * @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)
+            return undefined;
+        const { kind, name, startedAt } = this.phase;
+        return { kind, ...(name === undefined ? {} : { name }), startedAt };
+    }
     /** Start of the open durable turn, when its timestamp is present in the retained window. */
     get activeTurnStartedAt() {
         return this.turnMarker?.start;
@@ -449,6 +459,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 +468,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;
@@ -520,8 +532,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 +544,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 +580,15 @@ 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;
+        if (this.phase?.key === key)
+            return;
+        this.phase = { key, kind, ...(name === undefined ? {} : { name }), startedAt: Date.now() };
+    }
     chunk(chunk) {
         if (chunk.type === 'text-delta' || chunk.type === 'tool-call-delta') {
             for (const [index, block] of this.blocks)
@@ -583,13 +600,14 @@ 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 : '';
+            this.blocks.set(index, { type: 'tool-call', id: string(chunk.id), name, arguments: '' });
+            this.notePhase('tool', name === '' ? undefined : name);
         }
         else if (chunk.type === 'block-end') {
             this.blocks.set(number(chunk.index), object(chunk.block));