@minionry/minion 0.7.36

package/dist/server/services/timeline/assembler.js

@@ -0,0 +1,890 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { applyTimelineEvent, CHAT_TIMELINE_CONTRACT_VERSION, emptyTimelineState, TIMELINE_PROMPT_INDEX_HEAD_ENTRIES, TIMELINE_PROMPT_INDEX_MAX_BYTES, TIMELINE_PROMPT_INDEX_MAX_ENTRIES, TIMELINE_PROMPT_PREVIEW_CHARS, timelineEventEntryId, } from './contract.js';
+const PROMPT_REF_OVERHEAD_BYTES = 64;
+function promptPreview(text) {
+    return text.length > TIMELINE_PROMPT_PREVIEW_CHARS ? `${text.slice(0, TIMELINE_PROMPT_PREVIEW_CHARS)}…` : text;
+}
+export const LEGACY_THINKING_MARKER = '[[MINIONRY_THINKING]]';
+export function legacyThinkingChunk(text) {
+    return `${LEGACY_THINKING_MARKER}${text}`;
+}
+export const DEFAULT_CHAT_TIMELINE_LIMITS = {
+    maxEntries: 50_000,
+    maxBytes: 64 * 1024 * 1024,
+    maxToolResultChars: 128 * 1024,
+    maxToolInputChars: 64 * 1024,
+    pageMaxEntries: 200,
+    pageMaxBytes: 512 * 1024,
+};
+const DEFAULT_PAGE_MAX_ENTRIES = 200;
+const DEFAULT_PAGE_MAX_BYTES = 512 * 1024;
+const SEED_WINDOW_PAGES = 2;
+const ENTRY_OVERHEAD_BYTES = 160;
+const MARKER_PATTERN = /\[\[MINIONRY_([A-Z][A-Z0-9_]*)(?::([A-Za-z0-9_]+))?\]\][ \t]*/;
+const CANCELLED_NOTICE = '⚠ Execution cancelled';
+const WARNING_MARKER_FAMILIES = new Set([
+    'STALL_EXTENDED',
+    'STALL_CONFIRMED',
+    'TOOL_TIMEOUT',
+    'NATIVE_TIMEOUT',
+]);
+function noticeLevelForFamily(family) {
+    if (family === 'ERROR')
+        return 'error';
+    if (WARNING_MARKER_FAMILIES.has(family))
+        return 'warning';
+    return 'info';
+}
+export function classifyEngineOutput(raw) {
+    if (raw === '')
+        return [];
+    if (raw.includes(CANCELLED_NOTICE)) {
+        return [{ kind: 'notice', level: 'warning', code: 'EXECUTION_CANCELLED', text: CANCELLED_NOTICE }];
+    }
+    const out = [];
+    let rest = raw;
+    while (rest !== null && rest !== '') {
+        rest = consumeNextChunk(out, rest);
+    }
+    return out;
+}
+function consumeNextChunk(out, rest) {
+    const match = MARKER_PATTERN.exec(rest);
+    if (!match) {
+        out.push({ kind: 'text', text: rest });
+        return null;
+    }
+    const before = rest.slice(0, match.index);
+    if (before !== '')
+        out.push({ kind: 'text', text: before });
+    const after = rest.slice(match.index + match[0].length);
+    if (match[1] === 'THINKING') {
+        if (after !== '')
+            out.push({ kind: 'thinking', text: after });
+        return null;
+    }
+    const newline = after.indexOf('\n');
+    out.push({
+        kind: 'notice',
+        level: noticeLevelForFamily(match[1]),
+        code: match[2] ?? match[1],
+        text: (newline === -1 ? after : after.slice(0, newline)).trim(),
+    });
+    return newline === -1 ? null : after.slice(newline + 1);
+}
+export function parseErrorMarker(message) {
+    const match = MARKER_PATTERN.exec(message);
+    if (!match || match[1] !== 'ERROR' || !match[2] || message.slice(0, match.index).trim() !== '')
+        return null;
+    return { code: match[2], text: message.slice(match.index + match[0].length).trim() };
+}
+export function formatErrorMarker(code, text) {
+    return `[[MINIONRY_ERROR:${code}]] ${text}`;
+}
+function seedableMovements(movements, executing) {
+    const seedable = [...movements];
+    if (executing && !seedable[seedable.length - 1]?.durationMs)
+        seedable.pop();
+    return seedable;
+}
+export function formatTimelineDuration(totalSeconds) {
+    const seconds = Math.floor(totalSeconds) % 60;
+    const minutes = Math.floor(totalSeconds / 60) % 60;
+    const hours = Math.floor(totalSeconds / 3600) % 24;
+    const days = Math.floor(totalSeconds / 86400);
+    if (days > 0)
+        return `${days}d ${hours}h ${minutes}m ${seconds}s`;
+    if (hours > 0)
+        return `${hours}h ${minutes}m ${seconds}s`;
+    if (minutes > 0)
+        return `${minutes}m ${seconds}s`;
+    return `${seconds}s`;
+}
+const INGESTED_TAB_EVENTS = new Set([
+    'output',
+    'thinking',
+    'toolUse',
+    'movementStart',
+    'movementComplete',
+    'movementError',
+    'streamingTokens',
+    'approvalRequired',
+    'askUserQuestion',
+    'askUserQuestionDismissed',
+    'askUserQuestionAutoAnswered',
+]);
+export function isTimelineTabEvent(type) {
+    return INGESTED_TAB_EVENTS.has(type);
+}
+export class ChatTimeline {
+    limits;
+    state = emptyTimelineState();
+    nextEntryId = 1;
+    approxBytes = 0;
+    entryBytes = new Map();
+    toolEntries = new Map();
+    questionEntries = new Map();
+    seeded = false;
+    archive = { movements: [], prefix: [0] };
+    archiveBaseId = 0;
+    firstLiveId = 1;
+    materializedFromId = 1;
+    turnErrorCodes = new Set();
+    constructor(limits = DEFAULT_CHAT_TIMELINE_LIMITS) {
+        this.limits = limits;
+    }
+    entryCount() {
+        return this.state.entries.length;
+    }
+    byteSize() {
+        return this.approxBytes;
+    }
+    isEmpty() {
+        return this.state.entries.length === 0 && this.state.tokens === null;
+    }
+    snapshot(seq, bounds = {}) {
+        const entries = this.state.entries;
+        const { maxEntries, maxBytes } = this.pageBounds(bounds);
+        let start = entries.length;
+        let bytes = 0;
+        while (start > 0 && entries.length - start < maxEntries) {
+            const cost = estimateEntryBytes(entries[start - 1]);
+            if (entries.length - start > 0 && bytes + cost > maxBytes)
+                break;
+            bytes += cost;
+            start--;
+        }
+        const page = entries.slice(start);
+        const { prompts, truncated: promptsTruncated } = this.promptIndex();
+        return {
+            seq,
+            entries: JSON.parse(JSON.stringify(page)),
+            status: { ...this.state.status },
+            tokens: this.state.tokens ? { ...this.state.tokens } : null,
+            truncated: this.state.truncated,
+            version: CHAT_TIMELINE_CONTRACT_VERSION,
+            page: this.pageInfo(page),
+            prompts,
+            ...(promptsTruncated ? { promptsTruncated: true } : {}),
+        };
+    }
+    page(request) {
+        const { maxEntries, maxBytes } = this.pageBounds(request);
+        const out = [];
+        const before = Number(request.before);
+        if (Number.isFinite(before)) {
+            let cursor = Math.min(Math.floor(before) - 1, this.highestId());
+            let bytes = 0;
+            let derived = null;
+            while (cursor > this.archiveBaseId && out.length < maxEntries) {
+                let entry;
+                if (cursor >= this.materializedFromId) {
+                    entry = this.materializedEntry(cursor);
+                    if (!entry) {
+                        cursor = cursor >= this.firstLiveId ? this.firstLiveId - 1 : cursor - 1;
+                        continue;
+                    }
+                }
+                else {
+                    if (!derived || cursor < derived.firstId)
+                        derived = this.deriveMovementContaining(cursor);
+                    entry = derived.entries[cursor - derived.firstId];
+                }
+                const cost = estimateEntryBytes(entry);
+                if (out.length > 0 && bytes + cost > maxBytes)
+                    break;
+                out.push(entry);
+                bytes += cost;
+                cursor--;
+            }
+            out.reverse();
+        }
+        return {
+            before: request.before,
+            entries: JSON.parse(JSON.stringify(out)),
+            hasOlder: this.hasOlderThan(out),
+            version: CHAT_TIMELINE_CONTRACT_VERSION,
+        };
+    }
+    pageFrom(request) {
+        const { maxEntries, maxBytes } = this.pageBounds(request);
+        const out = [];
+        const highest = this.highestId();
+        const at = Math.floor(Number(request.at));
+        if (Number.isFinite(at) && at >= this.lowestPageableId()) {
+            let cursor = at;
+            let bytes = 0;
+            const cache = { derived: null };
+            while (cursor <= highest && out.length < maxEntries) {
+                const entry = this.entryAt(cursor, cache);
+                if (!entry) {
+                    cursor = this.resumeAfterHole(cursor, highest);
+                    continue;
+                }
+                const cost = estimateEntryBytes(entry);
+                if (out.length > 0 && bytes + cost > maxBytes)
+                    break;
+                out.push(entry);
+                bytes += cost;
+                cursor++;
+            }
+        }
+        const last = out[out.length - 1];
+        return {
+            before: request.at,
+            at: request.at,
+            entries: JSON.parse(JSON.stringify(out)),
+            hasOlder: this.hasOlderThan(out),
+            hasNewer: last !== undefined && Number(last.id) < highest,
+            version: CHAT_TIMELINE_CONTRACT_VERSION,
+        };
+    }
+    promptIndex() {
+        const { tail, opening, total, bounded } = this.walkPromptsNewestFirst();
+        const head = bounded ? opening.filter((ref) => ref.fromEnd > tail.length) : [];
+        const collected = [...tail, ...head].reverse();
+        return {
+            prompts: collected.map(({ fromEnd, ...ref }) => ({ ...ref, turn: total - fromEnd + 1 })),
+            truncated: collected.length < total,
+        };
+    }
+    walkPromptsNewestFirst() {
+        const tail = [];
+        const opening = [];
+        const tailMaxBytes = Math.max(0, TIMELINE_PROMPT_INDEX_MAX_BYTES -
+            TIMELINE_PROMPT_INDEX_HEAD_ENTRIES * (TIMELINE_PROMPT_PREVIEW_CHARS + PROMPT_REF_OVERHEAD_BYTES));
+        let bytes = 0;
+        let bounded = false;
+        let total = 0;
+        const take = (ref) => {
+            const entry = { ...ref, fromEnd: ++total };
+            opening.push(entry);
+            if (opening.length > TIMELINE_PROMPT_INDEX_HEAD_ENTRIES)
+                opening.shift();
+            if (bounded)
+                return;
+            const cost = ref.text.length + PROMPT_REF_OVERHEAD_BYTES;
+            if (tail.length >= TIMELINE_PROMPT_INDEX_MAX_ENTRIES || (tail.length > 0 && bytes + cost > tailMaxBytes)) {
+                bounded = true;
+                return;
+            }
+            bytes += cost;
+            tail.push(entry);
+        };
+        const live = this.state.entries;
+        for (let i = live.length - 1; i >= 0; i--) {
+            const entry = live[i];
+            if (entry.kind === 'user')
+                take({ id: entry.id, at: entry.at, text: promptPreview(entry.text) });
+        }
+        const { movements, prefix } = this.archive;
+        for (let i = movements.length - 1; i >= 0; i--) {
+            const id = this.archiveBaseId + prefix[i] + 1;
+            if (id >= this.materializedFromId)
+                continue;
+            const parsed = Date.parse(movements[i].timestamp);
+            take({
+                id: String(id),
+                at: Number.isFinite(parsed) ? parsed : 0,
+                text: promptPreview(movements[i].userPrompt),
+            });
+        }
+        return { tail, opening, total, bounded };
+    }
+    ensureSeeded(movements, opts = {}) {
+        if (this.seeded)
+            return;
+        if (this.state.entries.length > 0) {
+            this.seeded = true;
+            return;
+        }
+        const settled = seedableMovements(movements, opts.executing === true);
+        if (settled.length === 0)
+            return;
+        const prefix = [0];
+        for (const movement of settled)
+            prefix.push(prefix[prefix.length - 1] + countMovementEntries(movement));
+        this.archive = { movements: settled, prefix };
+        this.archiveBaseId = this.nextEntryId - 1;
+        this.firstLiveId = this.archiveBaseId + prefix[settled.length] + 1;
+        this.nextEntryId = this.firstLiveId;
+        const { maxEntries, maxBytes } = this.pageBounds({});
+        const window = [];
+        let first = settled.length;
+        let entries = 0;
+        let bytes = 0;
+        while (first > 0 &&
+            (window.length === 0 || (entries < maxEntries * SEED_WINDOW_PAGES && bytes < maxBytes * SEED_WINDOW_PAGES))) {
+            first--;
+            const derived = this.deriveMovement(first).entries;
+            window.unshift(derived);
+            entries += derived.length;
+            for (const entry of derived)
+                bytes += estimateEntryBytes(entry);
+        }
+        this.materializedFromId = this.archiveBaseId + prefix[first] + 1;
+        for (const group of window) {
+            for (const entry of group)
+                this.adopt(entry);
+        }
+        this.seeded = true;
+        this.enforceLimits(null, Date.now());
+    }
+    reset(at = Date.now()) {
+        const last = this.state.entries[this.state.entries.length - 1];
+        const out = [];
+        if (last)
+            this.record(out, { kind: 'truncate', at, throughEntryId: last.id });
+        this.state = emptyTimelineState();
+        this.approxBytes = 0;
+        this.entryBytes.clear();
+        this.toolEntries.clear();
+        this.questionEntries.clear();
+        this.turnErrorCodes.clear();
+        this.archive = { movements: [], prefix: [0] };
+        this.archiveBaseId = this.nextEntryId - 1;
+        this.firstLiveId = this.nextEntryId;
+        this.materializedFromId = this.firstLiveId;
+        this.seeded = true;
+        return out;
+    }
+    ingest(type, data, engine, at = Date.now()) {
+        if (!isTimelineTabEvent(type))
+            return [];
+        const raw = asRecord(data);
+        const out = [];
+        const ctx = { out, engine, at };
+        switch (type) {
+            case 'output':
+                this.ingestOutput(ctx, str(raw.text));
+                break;
+            case 'thinking':
+                this.ingestStream(ctx, 'thinking', str(raw.text));
+                break;
+            case 'toolUse':
+                this.ingestToolUse(ctx, raw);
+                break;
+            case 'movementStart':
+                this.ingestMovementStart(ctx, raw);
+                break;
+            case 'movementComplete':
+                this.ingestMovementComplete(ctx, raw);
+                break;
+            case 'movementError':
+                this.ingestFailure(ctx, str(raw.message) || 'Unknown error', 'Error', 'MOVEMENT_ERROR');
+                this.record(out, { kind: 'status', at, executing: false });
+                break;
+            case 'streamingTokens':
+                this.record(out, { kind: 'tokens', at, usage: tokenUsage(raw) });
+                break;
+            case 'approvalRequired':
+                this.ingestNotice(ctx, 'info', 'Approval required to continue', 'APPROVAL_REQUIRED', raw);
+                break;
+            case 'askUserQuestion':
+                this.ingestQuestion(ctx, raw);
+                break;
+            case 'askUserQuestionDismissed':
+                this.ingestQuestionState(ctx, raw, 'dismissed');
+                break;
+            case 'askUserQuestionAutoAnswered':
+                this.ingestQuestionState(ctx, raw, 'auto-answered');
+                break;
+            default:
+                return out;
+        }
+        this.enforceLimits(out, at);
+        return out;
+    }
+    notice(level, text, code, engine, at = Date.now()) {
+        const out = [];
+        this.ingestNotice({ out, engine, at }, level, text, code);
+        this.enforceLimits(out, at);
+        return out;
+    }
+    ingestOutput(ctx, text) {
+        for (const chunk of classifyEngineOutput(text)) {
+            if (chunk.kind === 'notice') {
+                this.ingestNotice(ctx, chunk.level, chunk.text, chunk.code);
+            }
+            else {
+                this.ingestStream(ctx, chunk.kind === 'thinking' ? 'thinking' : 'text', chunk.text);
+            }
+        }
+    }
+    ingestStream(ctx, kind, delta) {
+        if (delta === '')
+            return;
+        const entryId = this.openEntryId(kind) ?? this.allocEntryId();
+        this.record(ctx.out, { kind, at: ctx.at, ...engineField(ctx.engine), entryId, delta });
+    }
+    ingestToolUse(ctx, raw) {
+        const phase = str(raw.type);
+        if (phase === 'tool_input_delta')
+            return;
+        const toolId = str(raw.toolId);
+        if (phase === 'tool_result') {
+            const entryId = this.resolveToolEntry(ctx, toolId, str(raw.toolName) || 'Tool', {});
+            this.record(ctx.out, {
+                kind: 'tool_result',
+                at: ctx.at,
+                entryId,
+                ok: raw.isError !== true,
+                result: clampText(str(raw.result) || 'No output', this.limits.maxToolResultChars),
+            });
+            if (toolId)
+                this.toolEntries.delete(toolId);
+            return;
+        }
+        const input = clampInput(raw.completeInput, this.limits.maxToolInputChars);
+        const existing = toolId ? this.toolEntries.get(toolId) : undefined;
+        const entryId = existing ?? this.allocEntryId();
+        if (toolId)
+            this.toolEntries.set(toolId, entryId);
+        this.record(ctx.out, {
+            kind: 'tool_use',
+            at: ctx.at,
+            ...engineField(ctx.engine),
+            entryId,
+            toolName: str(raw.toolName) || 'Unknown Tool',
+            ...(toolId ? { toolUseId: toolId } : {}),
+            input,
+        });
+    }
+    ingestMovementStart(ctx, raw) {
+        this.turnErrorCodes.clear();
+        const turn = num(raw.sequenceNumber);
+        if (raw.isAutoContinue === true) {
+            this.ingestNotice(ctx, 'info', '⟳ Auto-continuing…', 'AUTO_CONTINUE');
+        }
+        else {
+            this.record(ctx.out, {
+                kind: 'user',
+                at: num(raw.timestamp) ?? ctx.at,
+                ...engineField(ctx.engine),
+                entryId: this.allocEntryId(),
+                text: str(raw.prompt),
+                ...(turn !== undefined ? { turn } : {}),
+            });
+        }
+        this.record(ctx.out, {
+            kind: 'status',
+            at: ctx.at,
+            executing: true,
+            ...(num(raw.executionStartTimestamp) !== undefined
+                ? { startedAt: num(raw.executionStartTimestamp) }
+                : {}),
+            ...(turn !== undefined ? { turn } : {}),
+        });
+    }
+    ingestMovementComplete(ctx, raw) {
+        const errorOutput = str(raw.errorOutput);
+        if (errorOutput && num(raw.tokensUsed) === 0 && errorOutput !== 'Execution cancelled by user') {
+            this.ingestFailure(ctx, errorOutput, 'Execution failed', 'EXECUTION_FAILED');
+        }
+        const durationMs = num(raw.durationMs);
+        this.ingestNotice(ctx, 'info', `${durationMs ? `Completed in ${formatTimelineDuration(durationMs / 1000)}` : 'Completed'}${describeRetrySummary(raw.retrySummary)}`, 'MOVEMENT_COMPLETE');
+        this.record(ctx.out, { kind: 'status', at: ctx.at, executing: false });
+    }
+    ingestQuestion(ctx, raw) {
+        const toolUseId = str(raw.toolUseId);
+        const questions = Array.isArray(raw.questions) ? raw.questions : [];
+        if (!toolUseId || questions.length === 0)
+            return;
+        if (this.questionEntries.has(toolUseId))
+            return;
+        const entryId = this.allocEntryId();
+        this.questionEntries.set(toolUseId, entryId);
+        this.record(ctx.out, {
+            kind: 'question',
+            at: ctx.at,
+            ...engineField(ctx.engine),
+            entryId,
+            toolUseId,
+            questions,
+        });
+    }
+    ingestQuestionState(ctx, raw, state) {
+        const entryId = this.questionEntries.get(str(raw.toolUseId));
+        if (!entryId)
+            return;
+        this.record(ctx.out, { kind: 'question_state', at: ctx.at, entryId, state });
+    }
+    ingestFailure(ctx, message, label, code) {
+        const marker = parseErrorMarker(message);
+        if (this.turnErrorCodes.has(marker?.code ?? code))
+            return;
+        if (!marker) {
+            this.ingestNotice(ctx, 'error', `${label}: ${message}`, code);
+            return;
+        }
+        this.ingestNotice(ctx, 'error', marker.text, marker.code);
+    }
+    ingestNotice(ctx, level, text, code, data) {
+        if (level === 'error' && code)
+            this.turnErrorCodes.add(code);
+        this.record(ctx.out, {
+            kind: 'notice',
+            at: ctx.at,
+            ...engineField(ctx.engine),
+            entryId: this.allocEntryId(),
+            level,
+            text: clampText(text, this.limits.maxToolResultChars),
+            ...(code ? { code } : {}),
+            ...(data ? { data } : {}),
+        });
+    }
+    deriveMovementContaining(id) {
+        const { movements, prefix } = this.archive;
+        const offset = id - this.archiveBaseId;
+        let lo = 0;
+        let hi = movements.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >>> 1;
+            if (prefix[mid] < offset)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        return this.deriveMovement(lo);
+    }
+    deriveMovement(index) {
+        const firstId = this.archiveBaseId + this.archive.prefix[index] + 1;
+        let next = firstId;
+        const scratch = emptyTimelineState();
+        for (const event of movementSeedEvents(this.archive.movements[index], () => String(next++), this.limits)) {
+            applyTimelineEvent(scratch, event);
+        }
+        return { firstId, entries: scratch.entries };
+    }
+    adopt(entry) {
+        this.state.entries.push(entry);
+        const cost = estimateEntryBytes(entry);
+        this.entryBytes.set(entry.id, cost);
+        this.approxBytes += cost;
+    }
+    entryAt(id, cache) {
+        if (id >= this.materializedFromId)
+            return this.materializedEntry(id);
+        const held = cache.derived;
+        if (!held || id < held.firstId || id >= held.firstId + held.entries.length) {
+            cache.derived = this.deriveMovementContaining(id);
+        }
+        const derived = cache.derived;
+        return derived.entries[id - derived.firstId];
+    }
+    resumeAfterHole(cursor, highest) {
+        const firstLive = this.state.entries[0];
+        const resumeAt = firstLive === undefined ? highest + 1 : Number(firstLive.id);
+        return resumeAt > cursor ? resumeAt : cursor + 1;
+    }
+    materializedEntry(id) {
+        const entries = this.state.entries;
+        let lo = 0;
+        let hi = entries.length - 1;
+        while (lo <= hi) {
+            const mid = (lo + hi) >>> 1;
+            const midId = Number(entries[mid].id);
+            if (midId === id)
+                return entries[mid];
+            if (midId < id)
+                lo = mid + 1;
+            else
+                hi = mid - 1;
+        }
+        return undefined;
+    }
+    pageBounds(bounds) {
+        return {
+            maxEntries: Math.max(1, Math.floor(bounds.maxEntries ?? this.limits.pageMaxEntries ?? DEFAULT_PAGE_MAX_ENTRIES)),
+            maxBytes: Math.max(1, Math.floor(bounds.maxBytes ?? this.limits.pageMaxBytes ?? DEFAULT_PAGE_MAX_BYTES)),
+        };
+    }
+    pageInfo(page) {
+        return { hasOlder: this.hasOlderThan(page), oldestEntryId: page[0]?.id ?? null };
+    }
+    hasOlderThan(page) {
+        const oldest = page[0];
+        return oldest !== undefined && Number(oldest.id) > this.lowestPageableId();
+    }
+    lowestPageableId() {
+        if (this.archive.prefix[this.archive.movements.length] > 0)
+            return this.archiveBaseId + 1;
+        const first = this.state.entries[0];
+        return first ? Number(first.id) : Number.POSITIVE_INFINITY;
+    }
+    highestId() {
+        const last = this.state.entries[this.state.entries.length - 1];
+        return last ? Number(last.id) : this.firstLiveId - 1;
+    }
+    allocEntryId() {
+        return String(this.nextEntryId++);
+    }
+    openEntryId(kind) {
+        const last = this.state.entries[this.state.entries.length - 1];
+        return last && last.kind === kind && last.open ? last.id : null;
+    }
+    resolveToolEntry(ctx, toolId, toolName, input) {
+        const known = toolId ? this.toolEntries.get(toolId) : undefined;
+        if (known)
+            return known;
+        const entryId = this.allocEntryId();
+        if (toolId)
+            this.toolEntries.set(toolId, entryId);
+        this.record(ctx.out, {
+            kind: 'tool_use',
+            at: ctx.at,
+            ...engineField(ctx.engine),
+            entryId,
+            toolName,
+            ...(toolId ? { toolUseId: toolId } : {}),
+            input,
+        });
+        return entryId;
+    }
+    record(out, event) {
+        applyTimelineEvent(this.state, event);
+        this.chargeBytes(event);
+        out?.push(event);
+    }
+    chargeBytes(event) {
+        const entryId = timelineEventEntryId(event);
+        if (entryId === null)
+            return;
+        const known = this.entryBytes.get(entryId);
+        const cost = (known === undefined ? ENTRY_OVERHEAD_BYTES : 0) + eventPayloadBytes(event);
+        this.entryBytes.set(entryId, (known ?? 0) + cost);
+        this.approxBytes += cost;
+    }
+    enforceLimits(out, at) {
+        const entries = this.state.entries;
+        let drop = 0;
+        let bytes = this.approxBytes;
+        while (entries.length - drop > 1 &&
+            (entries.length - drop > this.limits.maxEntries || bytes > this.limits.maxBytes)) {
+            bytes -= this.entryBytes.get(entries[drop].id) ?? 0;
+            drop++;
+        }
+        if (drop === 0)
+            return;
+        const throughEntryId = entries[drop - 1].id;
+        for (let i = 0; i < drop; i++) {
+            const id = entries[i].id;
+            this.approxBytes -= this.entryBytes.get(id) ?? 0;
+            this.entryBytes.delete(id);
+        }
+        if (this.approxBytes < 0)
+            this.approxBytes = 0;
+        if (Number(throughEntryId) >= this.firstLiveId) {
+            this.materializedFromId = this.firstLiveId;
+            this.record(out, { kind: 'truncate', at, throughEntryId });
+            return;
+        }
+        entries.splice(0, drop);
+        this.materializedFromId = Number(throughEntryId) + 1;
+    }
+}
+export function countMovementEntries(movement) {
+    return (1 +
+        (movement.thinkingOutput ? 1 : 0) +
+        (movement.toolUseHistory?.length ?? 0) +
+        (movement.assistantResponse ? 1 : 0) +
+        (movement.errorOutput ? 1 : 0) +
+        1
+    );
+}
+function movementSeedEvents(movement, alloc, limits) {
+    const parsed = Date.parse(movement.timestamp);
+    const at = Number.isFinite(parsed) ? parsed : Date.now();
+    const out = [];
+    out.push({
+        kind: 'user',
+        at,
+        entryId: alloc(),
+        text: movement.userPrompt,
+        ...(movement.sequenceNumber !== undefined ? { turn: movement.sequenceNumber } : {}),
+    });
+    if (movement.thinkingOutput) {
+        out.push({ kind: 'thinking', at, entryId: alloc(), delta: movement.thinkingOutput });
+    }
+    for (const tool of movement.toolUseHistory ?? []) {
+        const entryId = alloc();
+        out.push({
+            kind: 'tool_use',
+            at,
+            entryId,
+            toolName: tool.toolName,
+            input: clampInput(tool.toolInput, limits.maxToolInputChars),
+        });
+        if (tool.result !== undefined) {
+            out.push({
+                kind: 'tool_result',
+                at,
+                entryId,
+                ok: tool.isError !== true,
+                result: clampText(tool.result || 'No output', limits.maxToolResultChars),
+            });
+        }
+    }
+    if (movement.assistantResponse) {
+        out.push({ kind: 'text', at, entryId: alloc(), delta: movement.assistantResponse });
+    }
+    if (movement.errorOutput) {
+        const marker = parseErrorMarker(movement.errorOutput);
+        out.push({
+            kind: 'notice',
+            at,
+            entryId: alloc(),
+            level: 'error',
+            text: marker ? marker.text : `Error: ${movement.errorOutput}`,
+            code: marker ? marker.code : 'MOVEMENT_ERROR',
+        });
+    }
+    out.push(movement.durationMs
+        ? {
+            kind: 'notice',
+            at,
+            entryId: alloc(),
+            level: 'info',
+            text: `Completed in ${formatTimelineDuration(movement.durationMs / 1000)}${describeRetrySummary(movement.retrySummary)}`,
+            code: 'MOVEMENT_COMPLETE',
+        }
+        : {
+            kind: 'notice',
+            at,
+            entryId: alloc(),
+            level: 'warning',
+            text: 'Execution interrupted — this turn never finished.',
+            code: 'MOVEMENT_INTERRUPTED',
+        });
+    return out;
+}
+function describeRetrySummary(raw) {
+    if (!raw || typeof raw !== 'object')
+        return '';
+    const summary = raw;
+    const count = typeof summary.count === 'number' ? summary.count : 0;
+    if (count <= 0)
+        return '';
+    const paths = Array.isArray(summary.paths) ? summary.paths.filter((p) => typeof p === 'string') : [];
+    return ` · auto-retried ×${count}${paths.length > 0 ? ` (${paths.join(', ')})` : ''}`;
+}
+function estimateEntryBytes(entry) {
+    return ENTRY_OVERHEAD_BYTES + entryPayloadBytes(entry);
+}
+function entryPayloadBytes(entry) {
+    switch (entry.kind) {
+        case 'user':
+        case 'text':
+        case 'thinking':
+            return entry.text.length;
+        case 'notice':
+            return entry.text.length + (entry.code?.length ?? 0);
+        case 'tool':
+            return entry.toolName.length + approxJsonBytes(entry.input) + (entry.result?.length ?? 0);
+        case 'question':
+            return approxJsonBytes(entry.questions);
+        default:
+            return 0;
+    }
+}
+export class ChatTimelineRegistry {
+    limits;
+    timelines = new Map();
+    constructor(limits = DEFAULT_CHAT_TIMELINE_LIMITS) {
+        this.limits = limits;
+    }
+    getOrCreate(tabId) {
+        let timeline = this.timelines.get(tabId);
+        if (!timeline) {
+            timeline = new ChatTimeline(this.limits);
+            this.timelines.set(tabId, timeline);
+        }
+        return timeline;
+    }
+    get(tabId) {
+        return this.timelines.get(tabId);
+    }
+    delete(tabId) {
+        this.timelines.delete(tabId);
+    }
+    clear() {
+        this.timelines.clear();
+    }
+    usage() {
+        let approxBytes = 0;
+        let entries = 0;
+        for (const timeline of this.timelines.values()) {
+            approxBytes += timeline.byteSize();
+            entries += timeline.entryCount();
+        }
+        return { tabs: this.timelines.size, approxBytes, entries };
+    }
+}
+function asRecord(data) {
+    return typeof data === 'object' && data !== null ? data : {};
+}
+function str(value) {
+    return typeof value === 'string' ? value : '';
+}
+function num(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function engineField(engine) {
+    return engine ? { engine } : {};
+}
+function tokenUsage(raw) {
+    return {
+        inputTokens: num(raw.inputTokens) ?? 0,
+        outputTokens: num(raw.outputTokens) ?? 0,
+        cacheCreationTokens: num(raw.cacheCreationTokens) ?? 0,
+        cacheReadTokens: num(raw.cacheReadTokens) ?? 0,
+        currentTurnInputTokens: num(raw.currentTurnInputTokens) ?? 0,
+        ...(raw.isFinal === true ? { isFinal: true } : {}),
+    };
+}
+function clampText(text, max) {
+    if (text.length <= max)
+        return text;
+    return `${text.slice(0, max)}\n… [truncated ${text.length - max} chars]`;
+}
+function clampInput(value, max) {
+    const input = asRecord(value);
+    let size;
+    try {
+        size = JSON.stringify(input)?.length ?? 0;
+    }
+    catch {
+        return { _truncated: true };
+    }
+    if (size <= max)
+        return input;
+    return { _truncated: true, _bytes: size };
+}
+function eventPayloadBytes(event) {
+    switch (event.kind) {
+        case 'text':
+        case 'thinking':
+            return event.delta.length;
+        case 'user':
+            return event.text.length;
+        case 'notice':
+            return event.text.length + (event.code?.length ?? 0);
+        case 'tool_use':
+            return event.toolName.length + approxJsonBytes(event.input);
+        case 'tool_result':
+            return event.result.length;
+        case 'question':
+            return approxJsonBytes(event.questions);
+        default:
+            return 0;
+    }
+}
+function approxJsonBytes(value) {
+    try {
+        return JSON.stringify(value)?.length ?? 0;
+    }
+    catch {
+        return 256;
+    }
+}