@selesai/code 0.13.11 → 0.13.13

package/dist/extensions/pi-zentui/extensions/zentui/interaction-summary.ts

@@ -1,1049 +0,0 @@
-import type { AssistantMessage, AssistantMessageEvent } from "@earendil-works/pi-ai";
-import type { Theme } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-import type { ColorSource, ColorSpec } from "./config";
-import { formatCount, formatElapsedDuration } from "./format";
-import { isSafeSgrStylePrefix } from "./style";
-import { renderWorkingLineHigh } from "./working-line";
-
-export const TURN_SUMMARY_ENTRY_TYPE = "zentui-turn-summary";
-const TURN_SUMMARY_VERSION = 3;
-const SGR_RESET = "\x1b[0m";
-
-export type InteractionTokens = Readonly<{ input: number; output: number }>;
-export type LiveTokenDisplay = Readonly<{
-	input: number;
-	output: number;
-	outputApproximate: boolean;
-}>;
-export type ThoughtSnapshot = Readonly<{ durationMs: number; active: boolean }>;
-
-type SummaryBase = {
-	durationMs: number;
-	input: number;
-	output: number;
-};
-
-export type TurnSummaryDataV1 = SummaryBase & { version: 1 };
-export type TurnSummaryDataV2 = SummaryBase & { version: 2; stylePrefix: string };
-export type TurnSummaryDataV3 = SummaryBase & {
-	version: 3;
-	thoughtDurationMs: number;
-	stylePrefix: string;
-};
-export type TurnSummaryData = TurnSummaryDataV1 | TurnSummaryDataV2 | TurnSummaryDataV3;
-export type TurnSummaryMetrics = SummaryBase & { thoughtDurationMs: number };
-
-type Interval = { start: number; end: number };
-type TaggedInterval = Interval & { sources: number[] };
-type ThoughtCoverage = { intervals: TaggedInterval[]; incomplete: boolean };
-type ThoughtBlock = { startedAt?: number; closed: boolean };
-
-type ContentBlock = {
-	acceptedLength: number;
-	codePoints: number;
-	pendingHighSurrogate: boolean;
-	headHash: number;
-	headUnits: number;
-	tail: string;
-	frozen: boolean;
-};
-
-type ResponseState = {
-	ordinal: number;
-	authorized: boolean;
-	responseIdKey?: string;
-	snapshot: InteractionTokens;
-	hasSnapshot: boolean;
-	thoughtBlocks: Map<number, ThoughtBlock>;
-	contentBlocks: Map<string, ContentBlock>;
-	generatedCodePoints: number;
-	outputAnchor: number;
-	outputAnchorCodePoints: number;
-	liveOutputFloor: number;
-	lastDisplay?: LiveTokenDisplay;
-	estimateIncomplete: boolean;
-	estimateEnabled: boolean;
-};
-
-type RunState = {
-	ordinal: number;
-	startedAt: number;
-	ended: boolean;
-	committed: InteractionTokens;
-	responseOrdinal: number;
-	response?: ResponseState;
-	committedResponseIds: Set<string>;
-	lastClosedResponseId?: string;
-	lastClosedDisplay?: LiveTokenDisplay;
-	responseLessClosed: boolean;
-};
-
-type InteractionState = {
-	startedAt: number;
-	runOrdinal: number;
-	runs: RunState[];
-	activeRun?: RunState;
-	foldedCommitted: InteractionTokens;
-	thoughtCoverage: ThoughtCoverage;
-};
-
-export type MetricsUpdateResult = {
-	displayTokens?: LiveTokenDisplay;
-	usageChanged: boolean;
-	thoughtChanged: boolean;
-};
-
-export type MessageEndResult =
-	| {
-			status: "accepted";
-			tokens: InteractionTokens;
-			displayTokens: LiveTokenDisplay;
-			source: "final" | "last-snapshot" | "no-snapshot";
-	  }
-	| { status: "duplicate" }
-	| { status: "rejected" };
-
-export type SettlementResult = {
-	summary: TurnSummaryMetrics;
-	nextStartedAt?: number;
-	nextTokens?: LiveTokenDisplay;
-	nextThought?: ThoughtSnapshot;
-};
-
-export type InteractionMetricsDiagnostics = Readonly<{
-	runs: number;
-	responseIds: number;
-	activeResponses: number;
-	contentBlocks: number;
-	thoughtBlocks: number;
-	thoughtIntervals: number;
-	maxContentTailUnits: number;
-	retainedContentUnits: number;
-	estimateIncomplete: boolean;
-}>;
-
-const MAX_CONTENT_BLOCKS = 128;
-const MAX_CONTENT_INDEX = 65_535;
-const MAX_DELTA_UNITS = 65_536;
-const MAX_SNAPSHOT_UNITS = 1_048_576;
-const MAX_GENERATED_CODE_POINTS = 4_194_304;
-const MAX_ESTIMATED_RESPONSES = 128;
-const MAX_RUNS = 32;
-const MAX_RESPONSE_IDS = 256;
-const MAX_RESPONSE_ID_UNITS = 128;
-const MAX_THOUGHT_INTERVALS = 256;
-const HEAD_UNITS = 64;
-const TAIL_UNITS = 64;
-const HASH_OFFSET = 0x811c9dc5;
-
-function isNonnegativeSafeInteger(value: unknown): value is number {
-	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-}
-
-function safeAdd(left: number, right: number): number {
-	return Math.min(Number.MAX_SAFE_INTEGER, left + right);
-}
-
-function estimatedTokens(codePoints: number): number {
-	return Math.min(Number.MAX_SAFE_INTEGER, Math.ceil(codePoints / 4));
-}
-
-function addTokens(left: InteractionTokens, right: InteractionTokens): InteractionTokens {
-	return { input: safeAdd(left.input, right.input), output: safeAdd(left.output, right.output) };
-}
-
-type InteractionMessage = { role?: string; usage?: unknown; responseId?: unknown };
-
-export function parseAssistantMessageTokens(
-	message: InteractionMessage,
-): InteractionTokens | undefined {
-	if (message.role !== "assistant") return undefined;
-	const usage = (message as unknown as AssistantMessage).usage;
-	return isNonnegativeSafeInteger(usage?.input) && isNonnegativeSafeInteger(usage?.output)
-		? { input: usage.input, output: usage.output }
-		: undefined;
-}
-
-function responseIdKey(message: InteractionMessage): string | undefined {
-	if (typeof message.responseId !== "string") return undefined;
-	const value = message.responseId;
-	if (value.length > MAX_RESPONSE_ID_UNITS) return undefined;
-	const normalized = value.trim();
-	return normalized.length > 0 ? normalized : undefined;
-}
-
-function safeTime(value: number): number {
-	if (!Number.isFinite(value)) return value > 0 ? Number.MAX_SAFE_INTEGER : 0;
-	return Math.min(Number.MAX_SAFE_INTEGER, Math.max(0, Math.floor(value)));
-}
-
-function durationMs(startedAt: number, now: number): number {
-	const elapsed = Math.floor(now - startedAt);
-	if (Number.isNaN(elapsed) || elapsed <= 0) return 0;
-	return Math.min(Number.MAX_SAFE_INTEGER, elapsed);
-}
-
-function unionIntervals(intervals: readonly Interval[]): Interval[] {
-	const sorted = intervals
-		.filter(({ start, end }) => end > start)
-		.map(({ start, end }) => ({ start: safeTime(start), end: safeTime(end) }))
-		.filter(({ start, end }) => end > start)
-		.sort((left, right) => left.start - right.start || left.end - right.end);
-	const union: Interval[] = [];
-	for (const interval of sorted) {
-		const previous = union.at(-1);
-		if (!previous || interval.start > previous.end) union.push({ ...interval });
-		else previous.end = Math.max(previous.end, interval.end);
-	}
-	return union;
-}
-
-function intervalDuration(intervals: readonly Interval[]): number {
-	return unionIntervals(intervals).reduce(
-		(total, interval) => safeAdd(total, interval.end - interval.start),
-		0,
-	);
-}
-
-function sameSources(left: readonly number[], right: readonly number[]): boolean {
-	return left.length === right.length && left.every((source, index) => source === right[index]);
-}
-
-function normalizeTaggedIntervals(intervals: readonly TaggedInterval[]): TaggedInterval[] {
-	const sanitized = intervals
-		.map(({ start, end, sources }) => ({
-			start: safeTime(start),
-			end: safeTime(end),
-			sources: [...new Set(sources)].sort((left, right) => left - right),
-		}))
-		.filter(({ start, end, sources }) => end > start && sources.length > 0);
-	const boundaries = [...new Set(sanitized.flatMap(({ start, end }) => [start, end]))].sort(
-		(left, right) => left - right,
-	);
-	const result: TaggedInterval[] = [];
-	for (let index = 0; index + 1 < boundaries.length; index++) {
-		const start = boundaries[index];
-		const end = boundaries[index + 1];
-		if (start === undefined || end === undefined || end <= start) continue;
-		const sources = [
-			...new Set(
-				sanitized
-					.filter((interval) => interval.start < end && interval.end > start)
-					.flatMap((interval) => interval.sources),
-			),
-		].sort((left, right) => left - right);
-		if (sources.length === 0) continue;
-		const previous = result.at(-1);
-		if (previous && previous.end === start && sameSources(previous.sources, sources)) {
-			previous.end = end;
-		} else result.push({ start, end, sources });
-	}
-	return result;
-}
-
-function addThoughtInterval(
-	coverage: ThoughtCoverage,
-	interval: Interval,
-	source: number,
-): boolean {
-	if (coverage.incomplete) return false;
-	const candidate = normalizeTaggedIntervals([
-		...coverage.intervals,
-		{ ...interval, sources: [source] },
-	]);
-	if (candidate.length > MAX_THOUGHT_INTERVALS) {
-		coverage.incomplete = true;
-		return false;
-	}
-	coverage.intervals = candidate;
-	return true;
-}
-
-export function subtractThoughtIntervalsWithinCap(
-	source: readonly Interval[],
-	removed: readonly Interval[],
-): { intervals: Interval[]; incomplete: boolean } {
-	let result = unionIntervals(source);
-	for (const cut of unionIntervals(removed)) {
-		result = result.flatMap((part) => {
-			if (cut.end <= part.start || cut.start >= part.end) return [part];
-			return [
-				...(cut.start > part.start ? [{ start: part.start, end: cut.start }] : []),
-				...(cut.end < part.end ? [{ start: cut.end, end: part.end }] : []),
-			];
-		});
-	}
-	return {
-		intervals: result.slice(0, MAX_THOUGHT_INTERVALS),
-		incomplete: result.length > MAX_THOUGHT_INTERVALS,
-	};
-}
-
-function cappedTaggedDifference(
-	source: readonly TaggedInterval[],
-	removed: readonly Interval[],
-): { intervals: TaggedInterval[]; incomplete: boolean } {
-	let incomplete = false;
-	const fragments = source.flatMap((interval) => {
-		const difference = subtractThoughtIntervalsWithinCap([interval], removed);
-		incomplete ||= difference.incomplete;
-		return difference.intervals.map((fragment) => ({
-			...fragment,
-			sources: interval.sources,
-		}));
-	});
-	const normalized = normalizeTaggedIntervals(fragments);
-	return {
-		intervals: normalized.slice(0, MAX_THOUGHT_INTERVALS),
-		incomplete: incomplete || normalized.length > MAX_THOUGHT_INTERVALS,
-	};
-}
-
-function hashUnits(value: string, start: number, end: number, seed = HASH_OFFSET): number {
-	let hash = seed;
-	for (let index = start; index < end; index++)
-		hash = Math.imul(hash ^ value.charCodeAt(index), 0x01000193) >>> 0;
-	return hash;
-}
-
-function appendCodePoints(
-	value: string,
-	pendingHighSurrogate: boolean,
-): { codePoints: number; pendingHighSurrogate: boolean } {
-	let codePoints = 0;
-	let index = 0;
-	if (pendingHighSurrogate) {
-		if (value.length === 0) return { codePoints, pendingHighSurrogate };
-		const first = value.charCodeAt(0);
-		codePoints++;
-		if (first >= 0xdc00 && first <= 0xdfff) index = 1;
-	}
-	for (; index < value.length; index++) {
-		const unit = value.charCodeAt(index);
-		if (unit >= 0xd800 && unit <= 0xdbff) {
-			if (index + 1 === value.length) return { codePoints, pendingHighSurrogate: true };
-			const next = value.charCodeAt(index + 1);
-			codePoints++;
-			if (next >= 0xdc00 && next <= 0xdfff) index++;
-		} else codePoints++;
-	}
-	return { codePoints, pendingHighSurrogate: false };
-}
-
-function contentFingerprintMatches(block: ContentBlock, snapshot: string): boolean {
-	if (block.headUnits > snapshot.length) return false;
-	if (hashUnits(snapshot, 0, block.headUnits) !== block.headHash) return false;
-	const tailStart = block.acceptedLength - block.tail.length;
-	return snapshot.slice(tailStart, block.acceptedLength) === block.tail;
-}
-
-type ValidatedEvent = {
-	type: "text_delta" | "thinking_delta" | "toolcall_delta" | "thinking_start" | "thinking_end";
-	contentIndex: number;
-	delta?: string;
-	cumulative?: string;
-	oversizedDelta: boolean;
-	oversizedSnapshot: boolean;
-};
-
-function validateEvent(
-	event: AssistantMessageEvent | undefined,
-): ValidatedEvent | undefined | false {
-	if (!event) return undefined;
-	if (
-		event.type !== "text_delta" &&
-		event.type !== "thinking_delta" &&
-		event.type !== "toolcall_delta" &&
-		event.type !== "thinking_start" &&
-		event.type !== "thinking_end"
-	)
-		return undefined;
-	const record = event as unknown as Record<string, unknown>;
-	if (
-		!Number.isSafeInteger(record.contentIndex) ||
-		(record.contentIndex as number) < 0 ||
-		(record.contentIndex as number) > MAX_CONTENT_INDEX
-	)
-		return false;
-	const partial = record.partial;
-	if (!partial || typeof partial !== "object" || Array.isArray(partial)) return false;
-	const content = (partial as Record<string, unknown>).content;
-	if (!Array.isArray(content)) return false;
-	const contentIndex = record.contentIndex as number;
-	const isDelta =
-		event.type === "text_delta" ||
-		event.type === "thinking_delta" ||
-		event.type === "toolcall_delta";
-	if (isDelta && typeof record.delta !== "string") return false;
-	const expectedType =
-		event.type === "text_delta"
-			? "text"
-			: event.type === "toolcall_delta"
-				? "toolCall"
-				: "thinking";
-	let cumulative: string | undefined;
-	if (event.type === "toolcall_delta" && !(contentIndex in content)) return false;
-	if (contentIndex in content) {
-		const item = content[contentIndex];
-		if (!item || typeof item !== "object" || Array.isArray(item)) return false;
-		const itemRecord = item as Record<string, unknown>;
-		if (itemRecord.type !== expectedType) return false;
-		if (expectedType === "toolCall") {
-			if (
-				typeof itemRecord.id !== "string" ||
-				typeof itemRecord.name !== "string" ||
-				!itemRecord.arguments ||
-				typeof itemRecord.arguments !== "object" ||
-				Array.isArray(itemRecord.arguments)
-			)
-				return false;
-		} else {
-			const field = expectedType === "text" ? "text" : "thinking";
-			if (typeof itemRecord[field] !== "string") return false;
-			cumulative = itemRecord[field] as string;
-		}
-	}
-	const delta = isDelta ? (record.delta as string) : undefined;
-	return {
-		type: event.type,
-		contentIndex,
-		delta,
-		cumulative,
-		oversizedDelta: (delta?.length ?? 0) > MAX_DELTA_UNITS,
-		oversizedSnapshot: (cumulative?.length ?? 0) > MAX_SNAPSHOT_UNITS,
-	};
-}
-
-/** Owns provider-usage snapshots and thought-time partitioning for one settled interaction. */
-export class InteractionMetricsTracker {
-	private interaction?: InteractionState;
-
-	constructor(private readonly now: () => number = Date.now) {}
-
-	agentStart(now = this.now()): { interactionStarted: boolean } {
-		const at = safeTime(now);
-		const interactionStarted = this.interaction === undefined;
-		if (!this.interaction) {
-			this.interaction = {
-				startedAt: at,
-				runOrdinal: 0,
-				runs: [],
-				foldedCommitted: { input: 0, output: 0 },
-				thoughtCoverage: { intervals: [], incomplete: false },
-			};
-		}
-		const previous = this.interaction.activeRun;
-		if (previous && !previous.ended) {
-			if (previous.response) {
-				this.commitSnapshot(previous, previous.response);
-				this.closeResponse(previous, previous.response, at);
-			}
-			previous.ended = true;
-		}
-		this.makeRunCapacity(this.interaction);
-		const ordinal = safeAdd(this.interaction.runOrdinal, 1);
-		this.interaction.runOrdinal = ordinal;
-		const run: RunState = {
-			ordinal,
-			startedAt: at,
-			ended: false,
-			committed: { input: 0, output: 0 },
-			responseOrdinal: 0,
-			committedResponseIds: new Set(),
-			responseLessClosed: false,
-		};
-		this.interaction.runs.push(run);
-		this.interaction.activeRun = run;
-		return { interactionStarted };
-	}
-
-	turnStart(now = this.now()): void {
-		const run = this.activeRun();
-		if (!run) return;
-		if (run.response) {
-			this.commitSnapshot(run, run.response);
-			this.closeResponse(run, run.response, now);
-		}
-		this.openResponse(run);
-	}
-
-	messageUpdate(
-		message: InteractionMessage,
-		event?: AssistantMessageEvent,
-		now = this.now(),
-	): MetricsUpdateResult {
-		const unchanged: MetricsUpdateResult = {
-			displayTokens: this.currentDisplayTokens(),
-			usageChanged: false,
-			thoughtChanged: false,
-		};
-		const run = this.activeRun();
-		if (!run || message.role !== "assistant") return unchanged;
-		const validated = validateEvent(event);
-		if (validated === false) return unchanged;
-		const tokens = parseAssistantMessageTokens(message);
-		if (!tokens && !validated) return unchanged;
-		const response = this.responseForUpdate(run, message);
-		if (!response) return unchanged;
-		let thoughtChanged = false;
-		let contentChanged = false;
-		if (validated) {
-			if (validated.type.startsWith("thinking"))
-				thoughtChanged = this.applyThoughtEvent(run, response, validated, now);
-			if (
-				validated.type === "text_delta" ||
-				validated.type === "thinking_delta" ||
-				validated.type === "toolcall_delta"
-			)
-				contentChanged = this.applyContentEvent(response, validated);
-		}
-		const usageChanged = tokens ? this.applyLiveUsage(response, tokens) : false;
-		const display = this.liveDisplay(response);
-		const displayChanged = !this.sameDisplay(response.lastDisplay, display);
-		response.lastDisplay = display;
-		return {
-			displayTokens: display,
-			usageChanged: usageChanged || contentChanged || displayChanged,
-			thoughtChanged,
-		};
-	}
-
-	messageEnd(message: InteractionMessage, now = this.now()): MessageEndResult {
-		const run = this.activeRun();
-		if (!run || message.role !== "assistant") return { status: "rejected" };
-		const tokens = parseAssistantMessageTokens(message);
-		const key = responseIdKey(message);
-		const response = run.response;
-		if (!response?.authorized) return { status: "rejected" };
-		if (key && this.isDuplicateId(run, key)) return { status: "duplicate" };
-		if (response.responseIdKey && key && response.responseIdKey !== key)
-			return { status: "rejected" };
-		if (!response.responseIdKey && key) response.responseIdKey = key;
-		const preCloseDisplay = this.liveDisplay(response);
-		let source: "final" | "last-snapshot" | "no-snapshot";
-		if (tokens) {
-			response.snapshot = tokens;
-			response.hasSnapshot = true;
-			source = "final";
-		} else source = response.hasSnapshot ? "last-snapshot" : "no-snapshot";
-		this.commitSnapshot(run, response);
-		const committed = this.totalTokens();
-		const preserveEstimate = source !== "final" && response.lastDisplay?.outputApproximate === true;
-		const displayTokens = preserveEstimate
-			? { ...preCloseDisplay, outputApproximate: true }
-			: { ...committed, outputApproximate: false };
-		run.lastClosedDisplay = preserveEstimate ? displayTokens : undefined;
-		this.closeResponse(run, response, now);
-		return { status: "accepted", tokens: committed, displayTokens, source };
-	}
-
-	agentEnd(now = this.now()): void {
-		const interaction = this.interaction;
-		const run = interaction?.activeRun;
-		if (!interaction || !run) return;
-		if (run.response) {
-			this.commitSnapshot(run, run.response);
-			this.closeResponse(run, run.response, now);
-		}
-		run.ended = true;
-		interaction.activeRun = undefined;
-	}
-
-	currentTokens(): InteractionTokens | undefined {
-		return this.interaction ? this.totalTokens() : undefined;
-	}
-
-	currentDisplayTokens(): LiveTokenDisplay | undefined {
-		if (!this.interaction) return undefined;
-		const run = this.interaction.activeRun;
-		if (run?.response) return this.liveDisplay(run.response);
-		return run?.lastClosedDisplay ?? { ...this.totalTokens(), outputApproximate: false };
-	}
-
-	currentThought(now = this.now()): ThoughtSnapshot | undefined {
-		if (!this.interaction) return undefined;
-		return this.thoughtSnapshot(this.interaction, now);
-	}
-
-	settle(idle: boolean, now = this.now()): SettlementResult | undefined {
-		const interaction = this.interaction;
-		if (!interaction) return undefined;
-		const at = safeTime(now);
-		const splitIndex = idle
-			? interaction.runs.length
-			: interaction.runs.findIndex((run) => !run.ended);
-		const settledCount = splitIndex < 0 ? interaction.runs.length : splitIndex;
-		const hasFolded =
-			interaction.foldedCommitted.input > 0 ||
-			interaction.foldedCommitted.output > 0 ||
-			interaction.thoughtCoverage.intervals.some((interval) => interval.sources.includes(0));
-		if (settledCount === 0 && !hasFolded) return undefined;
-		const settledRuns = interaction.runs.slice(0, settledCount);
-		for (const run of interaction.runs) this.retainOpenThought(run, at);
-		for (const run of settledRuns) {
-			if (run.response) this.closeResponse(run, run.response, at);
-		}
-		const settledSources = new Set([0, ...settledRuns.map((run) => run.ordinal)]);
-		const settledIntervals = interaction.thoughtCoverage.intervals.filter((interval) =>
-			interval.sources.some((source) => settledSources.has(source)),
-		);
-		let tokens = interaction.foldedCommitted;
-		for (const run of settledRuns) tokens = addTokens(tokens, this.runTokens(run));
-		const summary: TurnSummaryMetrics = {
-			durationMs: durationMs(interaction.startedAt, now),
-			thoughtDurationMs: intervalDuration(settledIntervals),
-			input: tokens.input,
-			output: tokens.output,
-		};
-		const remaining = interaction.runs.slice(settledCount);
-		if (remaining.length === 0) {
-			this.interaction = undefined;
-			return { summary };
-		}
-		const remainingSources = new Set(remaining.map((run) => run.ordinal));
-		const remainingCoverage = interaction.thoughtCoverage.intervals
-			.map((interval) => ({
-				...interval,
-				sources: interval.sources.filter((source) => remainingSources.has(source)),
-			}))
-			.filter((interval) => interval.sources.length > 0);
-		const difference = cappedTaggedDifference(remainingCoverage, settledIntervals);
-		for (const run of remaining) {
-			for (const block of run.response?.thoughtBlocks.values() ?? []) {
-				if (block.startedAt !== undefined && !block.closed) block.startedAt = at;
-			}
-		}
-		const nextStartedAt = remaining[0]?.startedAt ?? at;
-		this.interaction = {
-			startedAt: nextStartedAt,
-			runOrdinal: interaction.runOrdinal,
-			runs: remaining,
-			activeRun: remaining.find((run) => !run.ended),
-			foldedCommitted: { input: 0, output: 0 },
-			thoughtCoverage: {
-				intervals: difference.intervals,
-				incomplete: interaction.thoughtCoverage.incomplete || difference.incomplete,
-			},
-		};
-		return {
-			summary,
-			nextStartedAt,
-			nextTokens: this.currentDisplayTokens(),
-			nextThought: this.currentThought(at),
-		};
-	}
-
-	shutdown(): void {
-		this.interaction = undefined;
-	}
-
-	diagnostics(): InteractionMetricsDiagnostics {
-		const interaction = this.interaction;
-		const responses =
-			interaction?.runs.flatMap((run) => (run.response ? [run.response] : [])) ?? [];
-		const blocks = responses.flatMap((response) => [...response.contentBlocks.values()]);
-		return {
-			runs: interaction?.runs.length ?? 0,
-			responseIds:
-				interaction?.runs.reduce((total, run) => total + run.committedResponseIds.size, 0) ?? 0,
-			activeResponses: responses.length,
-			contentBlocks: blocks.length,
-			thoughtBlocks: responses.reduce((total, response) => total + response.thoughtBlocks.size, 0),
-			thoughtIntervals: interaction?.thoughtCoverage.intervals.length ?? 0,
-			maxContentTailUnits: blocks.reduce(
-				(maximum, block) => Math.max(maximum, block.tail.length),
-				0,
-			),
-			retainedContentUnits: blocks.reduce((total, block) => total + block.tail.length, 0),
-			estimateIncomplete: responses.some((response) => response.estimateIncomplete),
-		};
-	}
-
-	private activeRun(): RunState | undefined {
-		const run = this.interaction?.activeRun;
-		return run && !run.ended ? run : undefined;
-	}
-
-	private makeRunCapacity(interaction: InteractionState): void {
-		if (interaction.runs.length < MAX_RUNS) return;
-		const index = interaction.runs.findIndex((run) => run.ended);
-		if (index < 0) return;
-		const [run] = interaction.runs.splice(index, 1);
-		if (!run) return;
-		interaction.foldedCommitted = addTokens(interaction.foldedCommitted, this.runTokens(run));
-		interaction.thoughtCoverage.intervals = normalizeTaggedIntervals(
-			interaction.thoughtCoverage.intervals.map((interval) => ({
-				...interval,
-				sources: interval.sources.map((source) => (source === run.ordinal ? 0 : source)),
-			})),
-		);
-	}
-
-	private openResponse(run: RunState, key?: string): ResponseState {
-		run.responseOrdinal = safeAdd(run.responseOrdinal, 1);
-		run.lastClosedDisplay = undefined;
-		const estimateEnabled =
-			run.ordinal <= MAX_RUNS && run.responseOrdinal <= MAX_ESTIMATED_RESPONSES;
-		const response: ResponseState = {
-			ordinal: run.responseOrdinal,
-			authorized: true,
-			responseIdKey: key,
-			snapshot: { input: 0, output: 0 },
-			hasSnapshot: false,
-			thoughtBlocks: new Map(),
-			contentBlocks: new Map(),
-			generatedCodePoints: 0,
-			outputAnchor: 0,
-			outputAnchorCodePoints: 0,
-			liveOutputFloor: 0,
-			estimateIncomplete: !estimateEnabled,
-			estimateEnabled,
-		};
-		run.response = response;
-		run.responseLessClosed = false;
-		return response;
-	}
-
-	private responseForUpdate(run: RunState, message: InteractionMessage): ResponseState | undefined {
-		const key = responseIdKey(message);
-		const response = run.response;
-		if (!response?.authorized || (key && this.isDuplicateId(run, key))) return undefined;
-		if (response.responseIdKey && key && response.responseIdKey !== key) return undefined;
-		if (!response.responseIdKey && key) response.responseIdKey = key;
-		return response;
-	}
-
-	private isDuplicateId(run: RunState, key: string): boolean {
-		return run.committedResponseIds.has(key) || run.lastClosedResponseId === key;
-	}
-
-	private applyContentEvent(response: ResponseState, event: ValidatedEvent): boolean {
-		if (!response.estimateEnabled) {
-			response.estimateIncomplete = true;
-			return false;
-		}
-		if (event.oversizedDelta || event.oversizedSnapshot) {
-			response.estimateIncomplete = true;
-			const existing = response.contentBlocks.get(
-				`${event.type === "text_delta" ? "text" : event.type === "toolcall_delta" ? "toolcall" : "thinking"}:${event.contentIndex}`,
-			);
-			if (existing) existing.frozen = true;
-			return false;
-		}
-		const contentType =
-			event.type === "text_delta"
-				? "text"
-				: event.type === "toolcall_delta"
-					? "toolcall"
-					: "thinking";
-		const key = `${contentType}:${event.contentIndex}`;
-		let block = response.contentBlocks.get(key);
-		if (!block) {
-			if (response.contentBlocks.size >= MAX_CONTENT_BLOCKS) {
-				response.estimateIncomplete = true;
-				return false;
-			}
-			block = {
-				acceptedLength: 0,
-				codePoints: 0,
-				pendingHighSurrogate: false,
-				headHash: HASH_OFFSET,
-				headUnits: 0,
-				tail: "",
-				frozen: false,
-			};
-			response.contentBlocks.set(key, block);
-		}
-		if (block.frozen) return false;
-		let suffix = event.delta ?? "";
-		if (event.cumulative !== undefined) {
-			const snapshot = event.cumulative;
-			if (snapshot.length < block.acceptedLength) return false;
-			if (!contentFingerprintMatches(block, snapshot)) {
-				block.frozen = true;
-				response.estimateIncomplete = true;
-				return false;
-			}
-			if (snapshot.length === block.acceptedLength) return false;
-			if (snapshot.length - block.acceptedLength > MAX_DELTA_UNITS) {
-				block.frozen = true;
-				response.estimateIncomplete = true;
-				return false;
-			}
-			suffix = snapshot.slice(block.acceptedLength);
-		}
-		if (suffix.length === 0) return false;
-		if (block.acceptedLength + suffix.length > MAX_SNAPSHOT_UNITS) {
-			block.frozen = true;
-			response.estimateIncomplete = true;
-			return false;
-		}
-		const counted = appendCodePoints(suffix, block.pendingHighSurrogate);
-		if (response.generatedCodePoints + counted.codePoints > MAX_GENERATED_CODE_POINTS) {
-			block.frozen = true;
-			response.estimateIncomplete = true;
-			return false;
-		}
-		if (block.headUnits < HEAD_UNITS) {
-			const taken = Math.min(HEAD_UNITS - block.headUnits, suffix.length);
-			block.headHash = hashUnits(suffix, 0, taken, block.headHash);
-			block.headUnits += taken;
-		}
-		block.tail =
-			suffix.length >= TAIL_UNITS
-				? suffix.slice(-TAIL_UNITS)
-				: `${block.tail}${suffix}`.slice(-TAIL_UNITS);
-		block.acceptedLength += suffix.length;
-		block.codePoints += counted.codePoints;
-		block.pendingHighSurrogate = counted.pendingHighSurrogate;
-		response.generatedCodePoints += counted.codePoints;
-		return true;
-	}
-
-	private applyThoughtEvent(
-		run: RunState,
-		response: ResponseState,
-		event: ValidatedEvent,
-		now: number,
-	): boolean {
-		const at = safeTime(now);
-		let block = response.thoughtBlocks.get(event.contentIndex);
-		if (!block) {
-			if (response.thoughtBlocks.size >= MAX_THOUGHT_INTERVALS) return false;
-			block = { closed: false };
-			response.thoughtBlocks.set(event.contentIndex, block);
-		}
-		if (event.type === "thinking_end") {
-			if (block.closed || block.startedAt === undefined) {
-				block.closed = true;
-				return false;
-			}
-			this.closeBlock(run, block, at);
-			return true;
-		}
-		if (block.closed || block.startedAt !== undefined) return false;
-		block.startedAt = at;
-		return true;
-	}
-
-	private closeBlock(run: RunState, block: ThoughtBlock, now: number): void {
-		if (block.closed) return;
-		block.closed = true;
-		if (block.startedAt === undefined) return;
-		const end = safeTime(now);
-		if (end <= block.startedAt || !this.interaction) return;
-		addThoughtInterval(
-			this.interaction.thoughtCoverage,
-			{ start: block.startedAt, end },
-			run.ordinal,
-		);
-	}
-
-	private closeResponse(run: RunState, response: ResponseState, now: number): void {
-		if (run.response !== response) return;
-		for (const block of response.thoughtBlocks.values()) this.closeBlock(run, block, now);
-		if (response.responseIdKey) {
-			if (run.committedResponseIds.size < MAX_RESPONSE_IDS)
-				run.committedResponseIds.add(response.responseIdKey);
-			run.lastClosedResponseId = response.responseIdKey;
-		} else run.responseLessClosed = true;
-		response.authorized = false;
-		response.contentBlocks.clear();
-		response.thoughtBlocks.clear();
-		run.response = undefined;
-	}
-
-	private commitSnapshot(run: RunState, response: ResponseState): void {
-		if (!response.hasSnapshot) return;
-		run.committed = addTokens(run.committed, response.snapshot);
-		response.hasSnapshot = false;
-	}
-
-	private applyLiveUsage(response: ResponseState, tokens: InteractionTokens): boolean {
-		if (tokens.input === 0 && tokens.output === 0) return false;
-		if (
-			response.hasSnapshot &&
-			(tokens.input < response.snapshot.input || tokens.output < response.snapshot.output)
-		)
-			return false;
-		if (
-			response.hasSnapshot &&
-			tokens.input === response.snapshot.input &&
-			tokens.output === response.snapshot.output
-		)
-			return false;
-		const outputAdvanced = !response.hasSnapshot || tokens.output > response.snapshot.output;
-		response.snapshot = tokens;
-		response.hasSnapshot = true;
-		if (outputAdvanced) {
-			response.outputAnchor = tokens.output;
-			response.outputAnchorCodePoints = response.generatedCodePoints;
-		}
-		return true;
-	}
-
-	private liveDisplay(response: ResponseState): LiveTokenDisplay {
-		const committed = this.committedTokens();
-		const postAnchorCodePoints = Math.max(
-			0,
-			response.generatedCodePoints - response.outputAnchorCodePoints,
-		);
-		const candidate = safeAdd(response.outputAnchor, estimatedTokens(postAnchorCodePoints));
-		const responseOutput = Math.max(response.liveOutputFloor, candidate);
-		const exactCoverage =
-			response.hasSnapshot &&
-			postAnchorCodePoints === 0 &&
-			responseOutput === response.outputAnchor &&
-			!response.estimateIncomplete;
-		response.liveOutputFloor = responseOutput;
-		return {
-			input: safeAdd(committed.input, response.hasSnapshot ? response.snapshot.input : 0),
-			output: safeAdd(committed.output, responseOutput),
-			outputApproximate: !exactCoverage,
-		};
-	}
-
-	private runTokens(run: RunState): InteractionTokens {
-		return run.response?.hasSnapshot
-			? addTokens(run.committed, run.response.snapshot)
-			: run.committed;
-	}
-
-	private committedTokens(): InteractionTokens {
-		const interaction = this.interaction;
-		if (!interaction) return { input: 0, output: 0 };
-		let total = interaction.foldedCommitted;
-		for (const run of interaction.runs) total = addTokens(total, run.committed);
-		return total;
-	}
-
-	private totalTokens(): InteractionTokens {
-		const interaction = this.interaction;
-		if (!interaction) return { input: 0, output: 0 };
-		let total = interaction.foldedCommitted;
-		for (const run of interaction.runs) total = addTokens(total, this.runTokens(run));
-		return total;
-	}
-
-	private retainOpenThought(run: RunState, now: number): void {
-		const end = safeTime(now);
-		for (const block of run.response?.thoughtBlocks.values() ?? []) {
-			if (block.startedAt === undefined || block.closed || end <= block.startedAt) continue;
-			if (this.interaction) {
-				addThoughtInterval(
-					this.interaction.thoughtCoverage,
-					{ start: block.startedAt, end },
-					run.ordinal,
-				);
-			}
-			block.startedAt = end;
-		}
-	}
-
-	private thoughtSnapshot(interaction: InteractionState, now: number): ThoughtSnapshot {
-		const coverage: ThoughtCoverage = {
-			intervals: interaction.thoughtCoverage.intervals.map((interval) => ({
-				...interval,
-				sources: [...interval.sources],
-			})),
-			incomplete: interaction.thoughtCoverage.incomplete,
-		};
-		for (const run of interaction.runs) {
-			for (const block of run.response?.thoughtBlocks.values() ?? []) {
-				if (block.startedAt === undefined || block.closed) continue;
-				addThoughtInterval(coverage, { start: block.startedAt, end: safeTime(now) }, run.ordinal);
-			}
-		}
-		return {
-			durationMs: intervalDuration(coverage.intervals),
-			active: interaction.runs.some((run) =>
-				[...(run.response?.thoughtBlocks.values() ?? [])].some(
-					(block) => block.startedAt !== undefined && !block.closed,
-				),
-			),
-		};
-	}
-
-	private sameDisplay(
-		left: LiveTokenDisplay | undefined,
-		right: LiveTokenDisplay | undefined,
-	): boolean {
-		return (
-			left?.input === right?.input &&
-			left?.output === right?.output &&
-			left?.outputApproximate === right?.outputApproximate
-		);
-	}
-}
-
-function hasExactKeys(record: Record<string, unknown>, expected: readonly string[]): boolean {
-	return Object.keys(record).sort().join("\0") === [...expected].sort().join("\0");
-}
-
-export function isTurnSummaryData(value: unknown): value is TurnSummaryData {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
-	const record = value as Record<string, unknown>;
-	if (
-		!isNonnegativeSafeInteger(record.durationMs) ||
-		!isNonnegativeSafeInteger(record.input) ||
-		!isNonnegativeSafeInteger(record.output)
-	)
-		return false;
-	if (record.version === 1) {
-		return hasExactKeys(record, ["version", "durationMs", "input", "output"]);
-	}
-	if (record.version === 2) {
-		return (
-			hasExactKeys(record, ["version", "durationMs", "input", "output", "stylePrefix"]) &&
-			isSafeSgrStylePrefix(record.stylePrefix)
-		);
-	}
-	return (
-		record.version === TURN_SUMMARY_VERSION &&
-		hasExactKeys(record, [
-			"version",
-			"durationMs",
-			"thoughtDurationMs",
-			"input",
-			"output",
-			"stylePrefix",
-		]) &&
-		isNonnegativeSafeInteger(record.thoughtDurationMs) &&
-		isSafeSgrStylePrefix(record.stylePrefix)
-	);
-}
-
-export function formatTurnSummary(data: TurnSummaryData | TurnSummaryMetrics): string {
-	const thought =
-		"thoughtDurationMs" in data && data.thoughtDurationMs > 0
-			? ` · thought for ${formatElapsedDuration(data.thoughtDurationMs)}`
-			: "";
-	return ` Turn took ${formatElapsedDuration(data.durationMs)}${thought} · ↑${formatCount(data.input)} ↓${formatCount(data.output)}`;
-}
-
-export function renderTurnSummaryEntry(
-	entry: { data?: unknown },
-	themeOptions: unknown,
-	theme: Pick<Theme, "fg">,
-): Text | undefined {
-	if (!isTurnSummaryData(entry.data)) return undefined;
-	const text = formatTurnSummary(entry.data);
-	if (entry.data.version === 2 || entry.data.version === 3) {
-		return new Text(`${entry.data.stylePrefix}${text}${SGR_RESET}`, 0, 0);
-	}
-	const options = (themeOptions ?? {}) as {
-		colorSource?: ColorSource;
-		workingLineHigh?: ColorSpec;
-	};
-	return new Text(
-		`${renderWorkingLineHigh(
-			theme,
-			options.colorSource === "terminal" ? "terminal" : "theme",
-			options.workingLineHigh,
-			text,
-		)}${SGR_RESET}`,
-		0,
-		0,
-	);
-}