@glbgpt/cli 0.1.0-test.5 → 0.1.1

package/dist/src/tui/chatController.d.ts

@@ -3,6 +3,15 @@ import { type AttachmentContext } from './attachments.js';
 import { Session } from '../core/session.js';
 import type { TurnLoop } from '../core/turnLoop.js';
 import type { TaskEvent } from '../media/taskManager.js';
+/**
+ * A styled fragment of one rich-note line. Styles are SEMANTIC (what the text is),
+ * not visual — the view maps them to colors in one place, so the whole TUI restyles
+ * by editing a single table.
+ */
+export interface RichSpan {
+    text: string;
+    style?: 'header' | 'accent' | 'dim' | 'warn';
+}
 /** One rendered entry in the conversation timeline. */
 export type TimelineItem = {
     kind: 'user';
@@ -20,6 +29,9 @@ export type TimelineItem = {
 } | {
     kind: 'note';
     text: string;
+} | {
+    kind: 'rich';
+    lines: RichSpan[][];
 } | {
     kind: 'media';
     taskId: string;
@@ -42,6 +54,8 @@ export interface ViewState {
     queued: QueuedMessage[];
     /** Cumulative session usage (chat tokens are informational; billing is server-side). */
     sessionUsage: SessionUsage;
+    /** Tool calls dispatched so far THIS turn (reset to 0 at each turn start); drives the footer counter. */
+    toolCallsUsed: number;
 }
 /** A message resolved at Enter time and waiting for the current turn to finish. */
 export interface QueuedMessage {
@@ -79,10 +93,21 @@ export interface ControllerExtras {
     }>>;
     /** One extra status line for `/status` (e.g. plan/balance from the account API). */
     fetchAccountLine?: () => Promise<string | null>;
+    /** Known newer published version, when the update check has one (run.tsx wires it). */
+    updateNotice?: () => {
+        latest: string;
+        command: string;
+    } | null;
+    /** Non-default API base URL in effect, if any (run.tsx wires it) — shown by `/status`. */
+    baseUrlOverride?: () => string | null;
     /** Full multi-line account summary for `/account` (email · plan · balance). */
     fetchAccount?: () => Promise<string>;
-    /** Recent spend lines for `/transactions` (authoritative billing). */
-    fetchTransactions?: () => Promise<string>;
+    /** Recent spend rows for `/transactions` (authoritative billing). */
+    fetchTransactions?: () => Promise<Array<{
+        createdAt: string;
+        credits: number;
+        model: string;
+    }>>;
     /** Re-authenticate in place (`/login`), hot-swapping the token everywhere; returns a status line. */
     reauth?: (mode: 'browser' | 'no-browser') => Promise<string>;
     /** Sign out (`/logout`): clear stored credentials; returns a status line. */
@@ -103,6 +128,8 @@ export declare class ChatController {
     private readonly subscribers;
     /** Index of the assistant item currently collecting deltas, or -1 if none is open. */
     private openAssistant;
+    /** The upstream-reported prompt size of the LATEST model call — the pruning trigger signal. */
+    private lastPromptTokens;
     /** Abort controller for the in-flight turn (null when idle). */
     private turnAbort;
     /** Serializes busy-time enqueues so rapid submits keep keystroke order. */
@@ -130,6 +157,17 @@ export declare class ChatController {
      * undefined only when `last` was asked for but nothing has been generated yet.
      */
     resolveMediaReference(ref: string): string | undefined;
+    /**
+     * Every media reference this session knows about (generated local paths + hosted URLs), for the
+     * generate tools' prompt sanitizer: a reference the model pasted into the prompt TEXT is moved
+     * back into the reference parameter. Exact-match source of truth — nothing else is ever touched.
+     */
+    getKnownMediaRefs(): string[];
+    /**
+     * Reverse-map a hosted output URL to the local file name the user already knows from the
+     * "image ready" line. Display-only: the internal storage hostname must never reach the user.
+     */
+    localNameForUrl(url: string): string | undefined;
     /** The session currently being edited (swapped by `/new`); used for persistence. */
     getSession(): Session;
     /**
@@ -169,6 +207,15 @@ export declare class ChatController {
     /** `/resume`: swap in a previously saved session and rebuild the timeline. */
     replaceSession(session: Session, persistedTimeline?: unknown[]): void;
     note(text: string): void;
+    /** A loud one-line warning (yellow) — for things that must not blend into gray notes. */
+    warn(text: string): void;
+    private rich;
+    /** One `label:  value` row — dim label column, optionally styled value. */
+    private static kvRow;
+    /** Style a `label: value · label: value` summary line without changing its text. */
+    private static kvInline;
+    /** A value with a trailing parenthetical (e.g. a balance breakdown) renders the detail dim. */
+    private static valueSpans;
     /**
      * Submit a user message and run one turn to completion, updating the timeline as events
      * arrive. `displayText` (when given) is what the transcript shows — e.g. "[Image #1]"
@@ -182,6 +229,13 @@ export declare class ChatController {
     /** Resolve `@…` attachments into a queueable message; null → error already noted. */
     private resolveForSubmit;
     /** Run one turn whose attachments are already resolved. Caller owns the busy flag. */
+    /**
+     * Trigger-based microcompact (spec 2026-07-19-context-pruning-design.md): runs
+     * only at turn boundaries, only when the last model call's prompt size crossed
+     * the threshold. Batch-clears in one event so the request prefix stays
+     * byte-stable between triggers (upstream prompt-cache friendliness).
+     */
+    private maybePruneContext;
     private runResolvedTurn;
     /** Reference-usable images the user attached to the current turn (for auto-reference in generation). */
     getPendingReferenceImages(): string[];
@@ -199,5 +253,7 @@ export declare class ChatController {
     private setState;
     private emit;
 }
+/** Validate a persisted transcript; returns null when absent/unusable (→ derive instead). */
+export declare function restoreTimeline(persisted: unknown[] | undefined): TimelineItem[] | null;
 /** Convert a stored message history into renderable timeline items (for resume). */
 export declare function timelineFromMessages(messages: ChatMessage[]): TimelineItem[];

package/dist/src/tui/chatController.js

@@ -1,10 +1,14 @@
 import { resolveAttachments } from './attachments.js';
 import { parseSlashMedia } from './slashMedia.js';
 import { availableModels } from '../media/manifest.js';
-import { getChatModels, modelDisplay } from './models.js';
+import { getChatModels, modelDescription, modelSupportsTools } from './models.js';
 import { SLASH_COMMANDS } from './commands.js';
 import { Session } from '../core/session.js';
 import { newId } from '../core/id.js';
+import { selectPrunable } from '../core/contextPrune.js';
+import { MAX_TOOL_CALLS_PER_TURN } from '../fs/index.js';
+import { PRUNE_TRIGGER_TOKENS } from '../fs/limits.js';
+import { getConfigValueSync } from '../config/configFile.js';
 import path from 'node:path';
 import os from 'node:os';
 /** A saved media path is a video when its extension is a known video container. */
@@ -17,15 +21,17 @@ function resolveTokenPath(token) {
     return path.resolve(expanded);
 }
 // Generated from the single command source so /help can never drift from the popup.
-const HELP_TEXT = [
-    'Commands:',
+const HELP_LINES = [
+    [{ text: 'Commands', style: 'header' }],
     ...SLASH_COMMANDS.map((c) => {
-        const left = `/${c.name}${c.args ? ` ${c.args}` : ''}`;
-        return `  ${left.padEnd(24)}${c.description}`;
+        const cmd = `  /${c.name}${c.args ? ` ${c.args}` : ''}`;
+        // Align descriptions; a command longer than the column still gets breathing room.
+        return [{ text: cmd.length >= 26 ? `${cmd}  ` : cmd.padEnd(26), style: 'accent' }, { text: c.description }];
     }),
-    'Attach images: @image (last generated) · @clipboard or Ctrl+V (clipboard) · @<path>.',
-    'Type anything else to chat. The model replies in your language.',
-].join('\n');
+    [],
+    [{ text: 'Attach images: @image (last generated) · @clipboard or Ctrl+V (clipboard) · @<path>.', style: 'dim' }],
+    [{ text: 'Type anything else to chat. The model replies in your language.', style: 'dim' }],
+];
 /**
  * Headless controller for the chat TUI: owns the view state and maps the engine's
  * EngineEvent stream into a renderable timeline. Contains no Ink/React so it can be
@@ -39,6 +45,8 @@ export class ChatController {
     subscribers = new Set();
     /** Index of the assistant item currently collecting deltas, or -1 if none is open. */
     openAssistant = -1;
+    /** The upstream-reported prompt size of the LATEST model call — the pruning trigger signal. */
+    lastPromptTokens = 0;
     /** Abort controller for the in-flight turn (null when idle). */
     turnAbort = null;
     /** Serializes busy-time enqueues so rapid submits keep keystroke order. */
@@ -62,6 +70,7 @@ export class ChatController {
             runningTasks: [],
             queued: [],
             sessionUsage: { promptTokens: 0, completionTokens: 0, turns: 0, mediaCreditsEstimated: 0, mediaSubmits: 0 },
+            toolCallsUsed: 0,
         };
     }
     getState() {
@@ -89,6 +98,32 @@ export class ChatController {
             return r;
         return this.generatedUrls.get(resolveTokenPath(r)) ?? r;
     }
+    /**
+     * Every media reference this session knows about (generated local paths + hosted URLs), for the
+     * generate tools' prompt sanitizer: a reference the model pasted into the prompt TEXT is moved
+     * back into the reference parameter. Exact-match source of truth — nothing else is ever touched.
+     */
+    getKnownMediaRefs() {
+        const refs = new Set();
+        for (const [p, url] of this.generatedUrls) {
+            refs.add(p);
+            refs.add(url);
+        }
+        if (this.lastMediaUrl)
+            refs.add(this.lastMediaUrl);
+        return [...refs];
+    }
+    /**
+     * Reverse-map a hosted output URL to the local file name the user already knows from the
+     * "image ready" line. Display-only: the internal storage hostname must never reach the user.
+     */
+    localNameForUrl(url) {
+        for (const [p, u] of this.generatedUrls) {
+            if (u === url)
+                return path.basename(p);
+        }
+        return undefined;
+    }
     /** The session currently being edited (swapped by `/new`); used for persistence. */
     getSession() {
         return this.session;
@@ -131,10 +166,11 @@ export class ChatController {
         // A new id so persistence writes a new file instead of overwriting the prior conversation.
         this.session = new Session({ id: newId(), model: this.session.model });
         this.openAssistant = -1;
+        this.lastPromptTokens = 0; // the pruning trigger must not carry across sessions
         this.setState({ items: [] });
     }
     showHelp() {
-        this.addItem({ kind: 'note', text: HELP_TEXT });
+        this.rich(HELP_LINES);
     }
     /** Track background generation tasks: progress updates the summary bar; completion hits the timeline. */
     handleTaskEvent(e) {
@@ -160,7 +196,11 @@ export class ChatController {
             // so a follow-up question would truthfully get "I can't see it".
             this.session.addSystemNote(`[background task update] Generation task ${e.taskId} completed. ` +
                 `Saved locally at ${e.localPath}. Output URL: ${e.outputUrl}.` +
-                (isVideo ? '' : ' The user can attach it to a message with @image so you can view it.'));
+                (isVideo
+                    ? ''
+                    : ' The user can attach it to a message with @image so you can view it. To reuse it ' +
+                        'as a reference in a NEW generation, pass reference_images: ["last"] (image) or ' +
+                        'start_image: "last" (video) — never paste this URL or path into the prompt text.'));
         }
         else if (e.type === 'task_failed') {
             this.state = { ...this.state, runningTasks };
@@ -223,7 +263,11 @@ export class ChatController {
     async showTasks() {
         const lines = [];
         for (const t of this.state.runningTasks) {
-            lines.push(`⏳ ${t.taskId} · ${t.status} · ${Math.round(t.elapsedMs / 1000)}s`);
+            lines.push([
+                { text: '⏳ ', style: 'warn' },
+                { text: t.taskId, style: 'accent' },
+                { text: ` · ${t.status} · ${Math.round(t.elapsedMs / 1000)}s`, style: 'dim' },
+            ]);
         }
         if (this.extras.listRecentTasks) {
             try {
@@ -231,27 +275,44 @@ export class ChatController {
                 for (const r of recent.slice(0, 5)) {
                     if (this.state.runningTasks.some((t) => t.taskId === r.taskId))
                         continue;
-                    lines.push(`   ${r.taskId} · ${r.model} · ${r.prompt.slice(0, 40)}`);
+                    lines.push([
+                        { text: '   ' },
+                        { text: r.taskId, style: 'accent' },
+                        { text: ` · ${r.model} · ${r.prompt.slice(0, 40)}`, style: 'dim' },
+                    ]);
                 }
             }
             catch {
                 // Recent history is best-effort.
             }
         }
-        this.note(lines.length ? lines.join('\n') : 'No tasks yet. Try /image or /video.');
+        if (lines.length) {
+            this.rich([[{ text: 'Tasks', style: 'header' }, { text: '   running and recent', style: 'dim' }], ...lines]);
+        }
+        else {
+            this.note('No tasks yet. Try /image or /video.');
+        }
     }
     /** `/status`: session/model basics immediately, account line when it arrives. */
     async showStatus() {
-        this.note([
-            `model: ${this.state.model}`,
-            `conversation: ${this.session.id} (${this.session.messages.length} messages)`,
-            `running tasks: ${this.state.runningTasks.length}`,
-        ].join('\n'));
+        const lines = [
+            ChatController.kvRow('model', this.state.model, 'accent'),
+            ChatController.kvRow('conversation', `${this.session.id} (${this.session.messages.length} messages)`),
+            ChatController.kvRow('context', `~${this.lastPromptTokens} tokens, ${this.session.prunedToolCallIds.size} old tool results pruned`),
+            ChatController.kvRow('running tasks', String(this.state.runningTasks.length)),
+        ];
+        const override = this.extras.baseUrlOverride?.();
+        if (override)
+            lines.push(ChatController.kvRow('API base URL', `${override} (override — not the default)`, 'warn'));
+        const update = this.extras.updateNotice?.();
+        if (update)
+            lines.push(ChatController.kvRow('update', `${update.latest} available — ${update.command}`, 'accent'));
+        this.rich(lines);
         if (this.extras.fetchAccountLine) {
             try {
                 const line = await this.extras.fetchAccountLine();
                 if (line)
-                    this.note(line);
+                    this.rich([ChatController.kvInline(line)]);
             }
             catch {
                 // Account info is best-effort; the basics above are already shown.
@@ -260,17 +321,33 @@ export class ChatController {
     }
     /** `/models`: list chat + image/video models available (server-driven catalog applied). */
     showModels() {
-        const chat = getChatModels().map((m) => `  ${modelDisplay(m)}`);
-        const image = availableModels().filter((m) => m.type === 'image').map((m) => `  ${m.id} — ${m.displayName}`);
-        const video = availableModels().filter((m) => m.type === 'video').map((m) => `  ${m.id} — ${m.displayName}`);
-        this.note([
-            `chat (${chat.length}) — /model to switch:`,
-            ...chat,
-            `image (${image.length}) — /image <prompt> -m <id>:`,
-            ...image,
-            `video (${video.length}) — /video <prompt> -m <id>:`,
-            ...video,
-        ].join('\n'));
+        const lines = [];
+        const section = (title, hint) => {
+            if (lines.length > 0)
+                lines.push([]);
+            lines.push([{ text: title, style: 'header' }, { text: `   ${hint}`, style: 'dim' }]);
+        };
+        const entry = (id, desc, current) => {
+            lines.push([
+                { text: current ? '  ▸ ' : '    ', style: 'accent' },
+                { text: id, style: 'accent' },
+                ...(desc ? [{ text: ` — ${desc}`, style: 'dim' }] : []),
+                ...(current ? [{ text: '  (current)', style: 'dim' }] : []),
+            ]);
+        };
+        const chat = getChatModels();
+        section(`Chat models (${chat.length})`, '/model to switch');
+        for (const m of chat)
+            entry(m.id, modelDescription(m), m.id === this.state.model);
+        const image = availableModels().filter((m) => m.type === 'image');
+        section(`Image models (${image.length})`, '/image <prompt> -m <id>');
+        for (const m of image)
+            entry(m.id, m.displayName, false);
+        const video = availableModels().filter((m) => m.type === 'video');
+        section(`Video models (${video.length})`, '/video <prompt> -m <id>');
+        for (const m of video)
+            entry(m.id, m.displayName, false);
+        this.addItem({ kind: 'rich', lines });
     }
     /** `/account`: full account summary (email · plan · balance). */
     async showAccount() {
@@ -279,7 +356,13 @@ export class ChatController {
             return;
         }
         try {
-            this.note(await this.extras.fetchAccount());
+            const text = await this.extras.fetchAccount();
+            this.rich(text.split('\n').map((line) => {
+                const m = /^([^:]+): (.*)$/.exec(line);
+                return m
+                    ? [{ text: `${m[1]}: `.padEnd(11), style: 'dim' }, ...ChatController.valueSpans(m[2])]
+                    : [{ text: line }];
+            }));
         }
         catch (err) {
             this.note(err instanceof Error ? err.message : String(err));
@@ -292,7 +375,19 @@ export class ChatController {
             return;
         }
         try {
-            this.note(await this.extras.fetchTransactions());
+            const rows = await this.extras.fetchTransactions();
+            if (rows.length === 0) {
+                this.note('No transactions yet.');
+                return;
+            }
+            this.rich([
+                [{ text: 'Recent transactions', style: 'header' }, { text: '   authoritative billing', style: 'dim' }],
+                ...rows.map((r) => [
+                    { text: `  ${(r.createdAt || '').padEnd(20)}`, style: 'dim' },
+                    { text: `${String(r.credits).padStart(6)} cr`, style: 'accent' },
+                    { text: `  ${r.model}` },
+                ]),
+            ]);
         }
         catch (err) {
             this.note(err instanceof Error ? err.message : String(err));
@@ -328,6 +423,7 @@ export class ChatController {
     replaceSession(session, persistedTimeline) {
         this.session = session;
         this.openAssistant = -1;
+        this.lastPromptTokens = 0; // the pruning trigger must not carry across sessions
         this.setState({ model: session.model });
         this.hydrateFromSession(persistedTimeline);
         this.note(`Resumed conversation ${session.id}.`);
@@ -335,6 +431,39 @@ export class ChatController {
     note(text) {
         this.addItem({ kind: 'note', text });
     }
+    /** A loud one-line warning (yellow) — for things that must not blend into gray notes. */
+    warn(text) {
+        this.addItem({ kind: 'rich', lines: [[{ text, style: 'warn' }]] });
+    }
+    rich(lines) {
+        this.addItem({ kind: 'rich', lines });
+    }
+    /** One `label:  value` row — dim label column, optionally styled value. */
+    static kvRow(label, value, valueStyle) {
+        return [
+            { text: `${label}: `.padEnd(16), style: 'dim' },
+            { text: value, ...(valueStyle ? { style: valueStyle } : {}) },
+        ];
+    }
+    /** Style a `label: value · label: value` summary line without changing its text. */
+    static kvInline(text) {
+        const spans = [];
+        text.split(' · ').forEach((part, i) => {
+            if (i > 0)
+                spans.push({ text: ' · ', style: 'dim' });
+            const m = /^([^:]+): (.*)$/.exec(part);
+            if (m)
+                spans.push({ text: `${m[1]}: `, style: 'dim' }, ...ChatController.valueSpans(m[2]));
+            else
+                spans.push({ text: part });
+        });
+        return spans;
+    }
+    /** A value with a trailing parenthetical (e.g. a balance breakdown) renders the detail dim. */
+    static valueSpans(value) {
+        const m = /^(.*?)( \(.+\))$/.exec(value);
+        return m ? [{ text: m[1] }, { text: m[2], style: 'dim' }] : [{ text: value }];
+    }
     /**
      * Submit a user message and run one turn to completion, updating the timeline as events
      * arrive. `displayText` (when given) is what the transcript shows — e.g. "[Image #1]"
@@ -394,15 +523,48 @@ export class ChatController {
         return { content, display, refs: attachments.kind === 'parts' ? attachments.refs : undefined };
     }
     /** Run one turn whose attachments are already resolved. Caller owns the busy flag. */
+    /**
+     * Trigger-based microcompact (spec 2026-07-19-context-pruning-design.md): runs
+     * only at turn boundaries, only when the last model call's prompt size crossed
+     * the threshold. Batch-clears in one event so the request prefix stays
+     * byte-stable between triggers (upstream prompt-cache friendliness).
+     */
+    maybePruneContext() {
+        // Cheapest checks first: the in-memory threshold gate skips the sync config
+        // read (a disk hit) on every under-threshold turn — the common case.
+        if (this.lastPromptTokens <= PRUNE_TRIGGER_TOKENS)
+            return;
+        if (process.env.GLBGPT_CONTEXT_PRUNING === 'false')
+            return;
+        if (getConfigValueSync('context-pruning') === 'false')
+            return;
+        const ids = selectPrunable(this.session.messages, this.session.prunedToolCallIds);
+        if (ids.length === 0)
+            return;
+        const idSet = new Set(ids);
+        const clearedBytes = this.session.messages
+            .filter((m) => m.role === 'tool' && m.tool_call_id && idSet.has(m.tool_call_id))
+            .reduce((sum, m) => sum + (typeof m.content === 'string' ? Buffer.byteLength(m.content, 'utf8') : 0), 0);
+        for (const id of ids)
+            this.session.prunedToolCallIds.add(id);
+        const savedTokens = Math.round(clearedBytes / 4 / 1000);
+        this.addItem({
+            kind: 'note',
+            text: `⚙ Context trimmed: cleared ${ids.length} old tool result${ids.length === 1 ? '' : 's'} (~${savedTokens}k tokens). Re-run tools if that content is needed again.`,
+        });
+    }
     async runResolvedTurn(msg) {
         // A same-message generate_* call auto-uses these when the model gives no explicit reference.
         this.pendingReferenceImages = msg.refs ?? [];
+        this.maybePruneContext();
         try {
             this.addItem({ kind: 'user', text: msg.display });
             this.openAssistant = -1;
             this.turnAbort = new AbortController();
+            this.state = { ...this.state, toolCallsUsed: 0 };
             await this.turnLoop.runTurn(this.session, msg.content, (event) => this.onEvent(event), {
                 signal: this.turnAbort.signal,
+                includeGatedTools: modelSupportsTools(this.session.model),
             });
         }
         catch (err) {
@@ -445,13 +607,13 @@ export class ChatController {
     /** `/cost`: session usage breakdown. Authoritative spend lives in `glbgpt account transactions`. */
     showCost() {
         const u = this.state.sessionUsage;
-        this.note([
-            `this session: ${u.turns} turn${u.turns === 1 ? '' : 's'} · ${u.promptTokens.toLocaleString()} in / ${u.completionTokens.toLocaleString()} out tokens`,
-            u.mediaSubmits > 0
-                ? `media: ${u.mediaSubmits} task${u.mediaSubmits === 1 ? '' : 's'} submitted · ~${u.mediaCreditsEstimated.toLocaleString()} credits (estimated)`
-                : 'media: none',
-            'authoritative spend: `glbgpt account transactions`',
-        ].join('\n'));
+        this.rich([
+            ChatController.kvRow('this session', `${u.turns} turn${u.turns === 1 ? '' : 's'} · ${u.promptTokens.toLocaleString()} in / ${u.completionTokens.toLocaleString()} out tokens`),
+            ChatController.kvRow('media', u.mediaSubmits > 0
+                ? `${u.mediaSubmits} task${u.mediaSubmits === 1 ? '' : 's'} submitted · ~${u.mediaCreditsEstimated.toLocaleString()} credits (estimated)`
+                : 'none'),
+            ChatController.kvRow('authoritative spend', 'glbgpt account transactions', 'accent'),
+        ]);
     }
     /** Interrupt the in-flight turn (Esc). Partial output is kept; no-op when idle. */
     interrupt() {
@@ -472,6 +634,13 @@ export class ChatController {
             case 'tool_call_begin': {
                 // Close any open assistant bubble so post-tool text starts a fresh one.
                 this.openAssistant = -1;
+                // Past the turn's budget, TurnLoop still emits begin/end for stub calls (it feeds the
+                // model a budget-exhausted error instead of dispatching) — clamp so the footer never
+                // shows more than the cap it displays (e.g. "18/15").
+                this.state = {
+                    ...this.state,
+                    toolCallsUsed: Math.min(this.state.toolCallsUsed + 1, MAX_TOOL_CALLS_PER_TURN),
+                };
                 this.addItem({ kind: 'tool', id: event.id, name: event.name, status: 'running', args: event.args });
                 break;
             }
@@ -484,6 +653,7 @@ export class ChatController {
                 break;
             }
             case 'usage': {
+                this.lastPromptTokens = event.promptTokens;
                 const u = this.state.sessionUsage;
                 this.setState({
                     sessionUsage: {
@@ -546,6 +716,27 @@ function restoreTimelineItem(it) {
         case 'note':
         case 'error':
             return typeof o.text === 'string' ? { kind: o.kind, text: o.text } : null;
+        case 'rich': {
+            if (!Array.isArray(o.lines))
+                return null;
+            const lines = [];
+            for (const line of o.lines) {
+                if (!Array.isArray(line))
+                    return null;
+                const spans = [];
+                for (const s of line) {
+                    if (typeof s !== 'object' || s === null || typeof s.text !== 'string')
+                        return null;
+                    const style = s.style;
+                    spans.push({
+                        text: s.text,
+                        ...(style === 'header' || style === 'accent' || style === 'dim' || style === 'warn' ? { style } : {}),
+                    });
+                }
+                lines.push(spans);
+            }
+            return { kind: 'rich', lines };
+        }
         case 'tool':
             if (typeof o.id !== 'string' || typeof o.name !== 'string')
                 return null;
@@ -573,7 +764,7 @@ function restoreTimelineItem(it) {
     }
 }
 /** Validate a persisted transcript; returns null when absent/unusable (→ derive instead). */
-function restoreTimeline(persisted) {
+export function restoreTimeline(persisted) {
     if (!persisted || persisted.length === 0)
         return null;
     const items = persisted.map(restoreTimelineItem).filter((it) => it !== null);