@iowarp/clio-coder 0.3.0 → 0.3.2

package/src/interactive/renderers/worker-entry.ts

@@ -0,0 +1,280 @@
+/**
+ * Renderer for a worker's transcript block: the attributed stream a `/run`,
+ * `/delegate`, or model-driven dispatch produces.
+ *
+ * One shape serves every runtime. A local Clio worker, a Claude subprocess, and
+ * a delegated ACP peer differ only in what the header can name about their
+ * route, so the body, the tool line, and the receipt footer are identical and
+ * an operator learns one grammar. The origin glyph is the only thing that says
+ * who asked, which is the same rule the board and the footer chip follow.
+ *
+ *   ◇ coder · node-a/example-coder-model · run 2mkas6s
+ *   │ Hello! I'm the coder worker.
+ *   │ ⚙ read · artifact
+ *   └ ✓ ok · 4.8k tok · 9.6s · contract pass
+ *
+ * Folded (the default for a run the model asked for) is one row shaped like a tool subline,
+ * so a fan-out of five scouts costs five rows until the operator opens one:
+ *
+ *   ◆ scout · node-b/example-scout-model · run 3nc18jo ✓ · 41s (Ctrl+O)
+ *
+ * Pure: no I/O, no module-level mutable state beyond the shared theme handle.
+ */
+
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "../../engine/tui.js";
+import { formatFooterTokens } from "../footer-panel.js";
+import { type ClioToken, clioTheme, fitUnits, formatCompactMs, GLYPH } from "../theme/index.js";
+import { type WorkerEntryState, type WorkerReceiptSummary, workerAskedByModel } from "../worker-stream.js";
+
+const theme = clioTheme();
+const dim = (text: string): string => theme.fg("dim", text);
+
+const RAIL = "│ ";
+const RAIL_WIDTH = 2;
+const FOOTER = "└ ";
+const ATTEMPT = "↻ ";
+const SEPARATOR = " · ";
+
+/** Rows of worker prose an expanded block shows before it defers to `/view`. */
+const BODY_LINE_LIMIT = 80;
+
+export interface WorkerEntryRenderOptions {
+	/** Collapsed to the header line plus outcome. Default for a run the model asked for. */
+	folded: boolean;
+	/** Key hint appended to a folded header, e.g. "Ctrl+O". Omitted when unknown. */
+	expandKey?: string | undefined;
+	/** Render the full body without the line cap; `/export` sets this. */
+	unbounded?: boolean;
+}
+
+function originGlyph(entry: WorkerEntryState): string {
+	return workerAskedByModel(entry) ? theme.fg("action", GLYPH.workerAgent) : theme.fg("accent", GLYPH.workerHuman);
+}
+
+/**
+ * The header's units after the glyph: who ran, where, and which run. A Clio or
+ * Claude worker names its target and model; an ACP peer runs behind someone
+ * else's process and can only name the protocol it was reached through, so it
+ * carries that on the agent instead of a route.
+ */
+function identityUnits(entry: WorkerEntryState): string[] {
+	const { kind, targetId, wireModelId } = entry.runtime;
+	const route =
+		targetId !== undefined && wireModelId !== undefined ? `${targetId}/${wireModelId}` : (targetId ?? wireModelId);
+	return [
+		theme.fg("muted", kind === "acp" ? `${entry.agentId} (acp)` : entry.agentId),
+		...(kind !== "acp" && route !== undefined ? [dim(route)] : []),
+		dim(`run ${entry.runId}`),
+	];
+}
+
+/** Whole header units, closing on a dim ellipsis rather than cutting a unit mid-word. */
+function headerLine(entry: WorkerEntryState, width: number): string {
+	return fitUnits(theme, `${originGlyph(entry)} `, identityUnits(entry), width);
+}
+
+/**
+ * Outcome glyph, with the word on the footer. The folded row uses the glyph
+ * alone, as a tool subline does, so a list of cards reads like a list of calls.
+ * Abandoned names itself rather than falling through to its `stalled`
+ * outcome code, so it reads as a ledger-side finding instead of the ordinary
+ * heartbeat-timeout `stalled` a sealed receipt reports.
+ */
+function outcomeUnit(receipt: WorkerReceiptSummary, word: boolean): string {
+	if (receipt.outcome === "succeeded") return theme.fg("success", word ? `${GLYPH.ok} ok` : GLYPH.ok);
+	if (receipt.outcome === "canceled") return theme.fg("dim", `${GLYPH.cancelled} canceled`);
+	if (receipt.abandonedDetail !== undefined) return theme.fg("error", word ? `${GLYPH.error} abandoned` : GLYPH.error);
+	return theme.fg("error", `${GLYPH.error} ${receipt.outcomeCode ?? receipt.outcome}`);
+}
+
+/** A block with no settled receipt yet: a spinner-free, honest "running". */
+function pendingUnit(entry: WorkerEntryState): string {
+	return theme.fg(
+		"action",
+		entry.attempts.length > 1 ? `${GLYPH.running} attempt ${entry.attempts.length}` : `${GLYPH.running} running`,
+	);
+}
+
+/**
+ * Whether a block should render as still going rather than settled: live,
+ * never yet received a receipt (`entry.receipt === undefined`), or replayed
+ * from a `runs.json` row with no `endedAt` (`stillRunning`) because its
+ * process is still executing in another instance of Clio.
+ */
+function isPending(entry: WorkerEntryState): boolean {
+	return entry.receipt === undefined || entry.receipt.stillRunning === true;
+}
+
+/**
+ * Receipt facts as footer units. A unit is dropped when unknown rather than
+ * rendered as zero: an ACP peer reports no tokens at all, so its footer names
+ * the tool calls it mediated instead of claiming it spent nothing.
+ */
+function footerUnits(receipt: WorkerReceiptSummary): string[] {
+	const units = [outcomeUnit(receipt, true)];
+	if (receipt.exitCode !== undefined && receipt.exitCode !== 0) {
+		units.push(theme.fg("error", `exit=${receipt.exitCode}`));
+	}
+	if (receipt.tokenCount !== undefined && receipt.tokenCount > 0) {
+		units.push(dim(`${formatFooterTokens(receipt.tokenCount)} tok`));
+	} else if (receipt.toolCalls !== undefined && receipt.toolCalls > 0) {
+		units.push(dim(`${receipt.toolCalls} tool call${receipt.toolCalls === 1 ? "" : "s"}`));
+	}
+	if (receipt.durationMs !== undefined) units.push(dim(formatCompactMs(receipt.durationMs)));
+	if (receipt.contract !== undefined) units.push(dim(`contract ${receipt.contract}`));
+	if (receipt.abandonedDetail !== undefined) units.push(theme.fg("warning", receipt.abandonedDetail));
+	else if (receipt.receiptUnavailable === true) units.push(theme.fg("warning", "receipt unavailable"));
+	return units;
+}
+
+/** Wrap one annotation onto the rail, prefixed on its first row and hanging under it after. */
+function railLines(text: string, token: ClioToken, width: number): string[] {
+	const contentWidth = Math.max(1, width - RAIL_WIDTH);
+	return wrapTextWithAnsi(text, contentWidth).map((row) => `${dim(RAIL)}${theme.fg(token, row)}`);
+}
+
+/** A worker's terminal answer when it is one JSON object, as a structured result contract asks for. */
+function structuredAnswer(text: string): Record<string, unknown> | null {
+	const trimmed = text.trim();
+	if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return null;
+	try {
+		const parsed: unknown = JSON.parse(trimmed);
+		return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+			? (parsed as Record<string, unknown>)
+			: null;
+	} catch {
+		return null;
+	}
+}
+
+const isStringArray = (value: unknown): value is string[] =>
+	Array.isArray(value) && value.every((entry) => typeof entry === "string");
+
+/**
+ * A mutation report as prose: the paths it changed, each validation with its
+ * verdict and evidence, then the summary and commit line. Null when the object
+ * is not that shape.
+ */
+function mutationReportLines(value: Record<string, unknown>): string[] | null {
+	if (!isStringArray(value.mutatedPaths) || !Array.isArray(value.validations)) return null;
+	const lines: string[] = [];
+	lines.push(value.mutatedPaths.length === 0 ? "changed nothing" : `changed ${value.mutatedPaths.join(", ")}`);
+	for (const validation of value.validations) {
+		if (typeof validation !== "object" || validation === null) continue;
+		const check = validation as Record<string, unknown>;
+		const name = typeof check.name === "string" ? check.name : "validation";
+		const glyph = check.passed === true ? GLYPH.ok : check.passed === false ? GLYPH.error : GLYPH.queued;
+		const evidence =
+			typeof check.evidence === "string" && check.evidence.trim().length > 0 ? `: ${check.evidence.trim()}` : "";
+		lines.push(`${glyph} ${name}${evidence}`);
+	}
+	if (typeof value.summary === "string" && value.summary.trim().length > 0) lines.push(value.summary.trim());
+	if (typeof value.commitMessage === "string" && value.commitMessage.trim().length > 0) {
+		lines.push(`commit: ${value.commitMessage.trim()}`);
+	}
+	return lines;
+}
+
+/**
+ * The body's source lines. A structured answer (a result-contract JSON object)
+ * never reaches the rail raw: a mutation report reads as prose, and any other
+ * object is pretty-printed so its keys line up instead of wrapping mid-string.
+ * Truncated text is not one object and passes through as the prose it is.
+ */
+function bodySourceLines(entry: WorkerEntryState): string[] {
+	const structured = entry.droppedLines === 0 ? structuredAnswer(entry.text) : null;
+	if (structured === null) return entry.text.split("\n");
+	return mutationReportLines(structured) ?? JSON.stringify(structured, null, 2).split("\n");
+}
+
+function bodyLines(entry: WorkerEntryState, width: number, unbounded: boolean): string[] {
+	// A worker that produced no prose (a pure tool run, a run that failed before
+	// its first token) gets no rail at all rather than one blank rail row.
+	if (entry.text.length === 0) return [];
+	const contentWidth = Math.max(1, width - RAIL_WIDTH);
+	const source = bodySourceLines(entry);
+	const capped = unbounded || source.length <= BODY_LINE_LIMIT ? source : source.slice(0, BODY_LINE_LIMIT);
+	const hiddenLines = entry.droppedLines + (source.length - capped.length);
+	const out: string[] = [];
+	for (const line of capped) {
+		for (const wrapped of wrapTextWithAnsi(line, contentWidth)) out.push(`${dim(RAIL)}${wrapped}`);
+	}
+	if (hiddenLines > 0) {
+		const tail = `${GLYPH.ellipsis} ${hiddenLines} more line${hiddenLines === 1 ? "" : "s"}, /view dispatch:${entry.runId}`;
+		out.push(`${dim(RAIL)}${dim(fitUnits(theme, "", [tail], contentWidth))}`);
+	}
+	return out;
+}
+
+/** Tool names only, coalesced onto one line. Arguments never cross into the transcript. */
+function toolLine(entry: WorkerEntryState, width: number): string | null {
+	if (entry.tools.length === 0) return null;
+	const contentWidth = Math.max(1, width - RAIL_WIDTH);
+	return `${dim(RAIL)}${theme.fg("muted", fitUnits(theme, `${GLYPH.phaseTool} `, entry.tools, contentWidth))}`;
+}
+
+/** One rail line per failover, naming the attempt and the route it moved to. */
+function attemptLines(entry: WorkerEntryState, width: number): string[] {
+	return entry.attempts.flatMap((attempt, index) =>
+		index === 0
+			? []
+			: railLines(`${ATTEMPT}failed over → attempt ${index + 1} on ${attempt.targetLabel}`, "warning", width),
+	);
+}
+
+/**
+ * The failure's first line, on the rail above the footer. The footer stays one
+ * line of facts; the reason is prose and wraps like prose, so a long message
+ * cannot make the receipt line heavier than the answer above it.
+ */
+function failureLines(entry: WorkerEntryState, width: number): string[] {
+	const message = entry.receipt?.failureMessage;
+	if (message === undefined) return [];
+	const first = (message.split("\n", 1)[0] ?? "").trim();
+	return first.length === 0 ? [] : railLines(`${GLYPH.error} ${first}`, "error", width);
+}
+
+/** The receipt line, whole units only; a unit that would not fit is dropped behind a dim ellipsis. */
+function footerLine(entry: WorkerEntryState, width: number): string {
+	const units = isPending(entry) || entry.receipt === undefined ? [pendingUnit(entry)] : footerUnits(entry.receipt);
+	return fitUnits(theme, dim(FOOTER), units, width);
+}
+
+/**
+ * Folded row: everything the operator needs to decide whether to open it, on
+ * one line, shaped like a tool subline. Identity outranks elapsed: when the row
+ * is too narrow for both, the elapsed unit goes first, and the identity is then
+ * cut where the room ends rather than by whole units, because a partial route
+ * still tells two scouts apart and a bare agent id may not. The expand hint
+ * renders only when the caller resolved a key binding for it, so a rebound or
+ * unbound key never advertises a wrong chord.
+ */
+function foldedLine(entry: WorkerEntryState, width: number, expandKey: string | undefined): string {
+	const identity = `${originGlyph(entry)} ${identityUnits(entry).join(dim(SEPARATOR))}`;
+	const status =
+		isPending(entry) || entry.receipt === undefined ? pendingUnit(entry) : outcomeUnit(entry.receipt, false);
+	const elapsed =
+		entry.receipt?.durationMs === undefined ? "" : dim(`${SEPARATOR}${formatCompactMs(entry.receipt.durationMs)}`);
+	const hint = expandKey === undefined || expandKey.length === 0 ? "" : dim(` (${expandKey})`);
+	const full = ` ${status}${elapsed}${hint}`;
+	const tail = visibleWidth(identity) + visibleWidth(full) <= width ? full : ` ${status}${hint}`;
+	return `${truncateToWidth(identity, Math.max(1, width - visibleWidth(tail)), GLYPH.ellipsis, false)}${tail}`;
+}
+
+export function renderWorkerEntryLines(
+	entry: WorkerEntryState,
+	width: number,
+	options: WorkerEntryRenderOptions,
+): string[] {
+	const safeWidth = Math.max(1, Math.floor(width));
+	if (options.folded) return [foldedLine(entry, safeWidth, options.expandKey)];
+	const tools = toolLine(entry, safeWidth);
+	return [
+		headerLine(entry, safeWidth),
+		...bodyLines(entry, safeWidth, options.unbounded === true),
+		...attemptLines(entry, safeWidth),
+		...(tools === null ? [] : [tools]),
+		...failureLines(entry, safeWidth),
+		footerLine(entry, safeWidth),
+	];
+}

package/src/interactive/session-last-turn.ts

@@ -0,0 +1,186 @@
+/**
+ * Rebuild the footer's last-turn line from the newest turn on the active branch.
+ *
+ * The line is a live accumulator: it describes whatever turn this process last
+ * ran. current.jsonl is append-only, so after a `/tree` switch that turn can sit
+ * on a branch the reader just left, and the line kept describing it while the Σ
+ * total and `/cost` beside it had already been rescoped by the usage reseed. One
+ * footer, two branches, no way to tell which line belonged to which.
+ *
+ * The fold reads the same lineage the reseed does, through
+ * `filterEntriesToActivePath`, and reports only what the ledger recorded:
+ * provider usage, the persisted stop reason, the tool result rows the turn
+ * produced, and the wall time between the user message that opened the turn and
+ * the last row it wrote. Fields the ledger does not carry are left at their
+ * neutral value rather than reconstructed: the watchdog peak is zero, and
+ * reasoning tokens appear only when a provider reported them, never estimated
+ * back off replayed thinking text.
+ */
+
+import { rawDurationMs } from "../core/timers.js";
+import { extractReasoningTokens } from "../domains/session/context-accounting.js";
+import type { MessageEntry, SessionEntry, SessionUsageDefaults } from "../domains/session/index.js";
+import { filterEntriesToActivePath } from "../domains/session/tree/active-path.js";
+import type { TurnStopReason, TurnSummary } from "./status/index.js";
+
+function payloadRecord(value: unknown): Record<string, unknown> | null {
+	return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : null;
+}
+
+function positiveNumber(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+
+function nonEmptyString(source: Record<string, unknown>, ...keys: string[]): string | null {
+	for (const key of keys) {
+		const value = source[key];
+		if (typeof value === "string" && value.trim().length > 0) return value;
+	}
+	return null;
+}
+
+function stopReasonOf(value: unknown): TurnStopReason | null {
+	switch (value) {
+		case "stop":
+		case "length":
+		case "toolUse":
+		case "error":
+		case "aborted":
+		case "cancelled":
+			return value;
+		default:
+			return null;
+	}
+}
+
+function millisBetween(startIso: string, endIso: string): number {
+	const start = Date.parse(startIso);
+	const end = Date.parse(endIso);
+	if (!Number.isFinite(start) || !Number.isFinite(end)) return 0;
+	return Math.max(0, rawDurationMs(start, end));
+}
+
+/** The message rows of the newest turn on the branch, plus the target it ran under. */
+interface BranchTurn {
+	rows: MessageEntry[];
+	startedAt: string;
+	targetId: string | null;
+	modelId: string | null;
+}
+
+/**
+ * Everything after the last user message on the active path. That is the same
+ * window the live summary folds: one submit, the assistant calls it took, and
+ * the tool rows between them.
+ */
+function newestTurnOnBranch(entries: ReadonlyArray<SessionEntry>, defaults: SessionUsageDefaults): BranchTurn | null {
+	let target = defaults.target ?? null;
+	let model = defaults.model ?? null;
+	let turn: BranchTurn | null = null;
+	for (const entry of entries) {
+		if (entry.kind === "modelChange") {
+			const change = entry as { target?: unknown; provider?: unknown; modelId?: unknown };
+			if (typeof change.target === "string" && change.target.length > 0) target = change.target;
+			else if (typeof change.provider === "string" && change.provider.length > 0) target = change.provider;
+			if (typeof change.modelId === "string" && change.modelId.length > 0) model = change.modelId;
+			continue;
+		}
+		if (entry.kind !== "message") continue;
+		if (entry.role === "user") {
+			turn = { rows: [], startedAt: entry.timestamp, targetId: target, modelId: model };
+			continue;
+		}
+		if (entry.role !== "assistant" && entry.role !== "tool_call" && entry.role !== "tool_result") continue;
+		// A ledger whose first rows predate any user message (an imported or
+		// repaired session) still has a turn to report; it just starts where the
+		// assistant does.
+		if (!turn) turn = { rows: [], startedAt: entry.timestamp, targetId: target, modelId: model };
+		if (entry.role === "assistant") {
+			turn.targetId = target;
+			turn.modelId = model;
+		}
+		turn.rows.push(entry);
+	}
+	return turn;
+}
+
+/**
+ * The newest turn on the active path, in the shape the footer's last-turn line
+ * renders. Null when the branch holds no assistant reply, which is the honest
+ * answer for a leaf whose turn never produced one.
+ *
+ * `activeLeafTurnId` pins the branch, exactly as it does for the usage reseed.
+ * Omitted, the fold follows the newest message's ancestry.
+ */
+export function lastTurnSummaryFromLedger(
+	entries: ReadonlyArray<SessionEntry>,
+	defaults: SessionUsageDefaults = {},
+	activeLeafTurnId?: string | null,
+): TurnSummary | null {
+	const scoped = filterEntriesToActivePath(entries, activeLeafTurnId ?? undefined);
+	const turn = newestTurnOnBranch(scoped, defaults);
+	if (!turn || turn.rows.length === 0) return null;
+
+	let sawAssistant = false;
+	let stopReason: TurnStopReason = "stop";
+	let inputTokens = 0;
+	let outputTokens = 0;
+	let cacheReadTokens = 0;
+	let cacheWriteTokens = 0;
+	let reasoningTokens = 0;
+	let sawReasoning = false;
+	let toolCount = 0;
+	let toolErrorCount = 0;
+	let targetId = turn.targetId;
+	let modelId = turn.modelId;
+
+	for (const row of turn.rows) {
+		const record = payloadRecord(row.payload);
+		// The live tally counts a tool by its result, so a call still in flight
+		// when the branch was left contributes nothing here either.
+		if (row.role === "tool_result") {
+			toolCount += 1;
+			if (record?.isError === true || record?.error === true) toolErrorCount += 1;
+			continue;
+		}
+		if (row.role !== "assistant" || !record) continue;
+		sawAssistant = true;
+		const reason = stopReasonOf(record.stopReason);
+		if (reason && reason !== "stop") stopReason = reason;
+		targetId = targetId ?? nonEmptyString(record, "provider", "api");
+		modelId = modelId ?? nonEmptyString(record, "responseModel", "model");
+		const usage = payloadRecord(record.usage);
+		if (!usage) continue;
+		inputTokens += positiveNumber(usage.input);
+		outputTokens += positiveNumber(usage.output);
+		cacheReadTokens += positiveNumber(usage.cacheRead);
+		cacheWriteTokens += positiveNumber(usage.cacheWrite);
+		const reasoning = extractReasoningTokens(usage);
+		if (reasoning !== null) {
+			reasoningTokens += reasoning;
+			sawReasoning = true;
+		}
+	}
+	if (!sawAssistant) return null;
+
+	const lastRow = turn.rows[turn.rows.length - 1];
+	const summary: TurnSummary = {
+		elapsedMs: lastRow ? millisBetween(turn.startedAt, lastRow.timestamp) : 0,
+		modelId: modelId ?? "unknown",
+		targetId: targetId ?? "unknown",
+		inputTokens,
+		outputTokens,
+		cacheReadTokens,
+		cacheWriteTokens,
+		toolCount,
+		toolErrorCount,
+		stopReason,
+		watchdogPeak: 0,
+		truncated: false,
+	};
+	if (sawReasoning) {
+		summary.reasoningTokens = reasoningTokens;
+		summary.reasoningTokenProvenance = "provider";
+	}
+	return summary;
+}

package/src/interactive/session-switch-settlement.ts

@@ -0,0 +1,10 @@
+import type { ChatLoop } from "./chat-loop.js";
+
+type SessionSwitchChat = Pick<ChatLoop, "cancel" | "isStreaming" | "whenSettled">;
+
+/** Settle an active turn before its owning session writer can be replaced. */
+export function settleChatBeforeSessionSwitch(chat: SessionSwitchChat): Promise<void> | null {
+	if (!chat.isStreaming()) return null;
+	chat.cancel();
+	return chat.whenSettled();
+}

package/src/interactive/session-transcript.ts

@@ -0,0 +1,105 @@
+import type { ClioSettings } from "../core/config.js";
+import { collectSessionEntries } from "../domains/session/compaction/session-entries.js";
+import type { SessionContract, SessionEntry } from "../domains/session/index.js";
+import { openSession, sessionPaths } from "../engine/session.js";
+import type { ChatLoop } from "./chat-loop.js";
+import { buildReplayAgentMessagesFromTurns } from "./chat-renderer.js";
+
+type SessionOwner = Pick<SessionContract, "create" | "current">;
+type SessionChat = Pick<ChatLoop, "resetForSession">;
+type RoutingSettings = Pick<ClioSettings, "orchestrator">;
+
+export interface SessionTranscriptDeps {
+	session?: SessionOwner;
+	getSessionId?: () => string | null;
+	getSettings?: () => Readonly<RoutingSettings>;
+	readSessionEntries?: () => ReadonlyArray<SessionEntry>;
+	chat: SessionChat;
+	refreshStatus: () => void;
+	getCwd?: () => string;
+	readStructuredEntries?: (sessionId: string) => SessionEntry[];
+}
+
+export interface SessionTranscript {
+	ensureSessionForLocalEntry(): void;
+	readStructuredEntries(sessionId: string): SessionEntry[];
+	refreshChatContextFromSession(leafTurnId: string | null): void;
+	recordSubmittedTurn(): void;
+	liveSessionTurns(): number | null;
+	syncSessionCounter(): void;
+}
+
+function readStructuredEntriesFromDisk(sessionId: string): SessionEntry[] {
+	const reader = openSession(sessionId);
+	return collectSessionEntries(reader.turns(), sessionPaths(reader.meta()).current);
+}
+
+/**
+ * Owns the active session's projected turn count and transcript replay bridge.
+ * The optional readers keep construction independent of a session directory;
+ * disk access occurs only when a caller explicitly asks to read an id.
+ */
+export function createSessionTranscript(deps: SessionTranscriptDeps): SessionTranscript {
+	let sessionCounter = {
+		id: deps.session?.current()?.id ?? deps.getSessionId?.() ?? null,
+		baseTurns: deps.session?.current()?.messageCount ?? 0,
+		submittedTurns: 0,
+	};
+
+	const syncSessionCounter = (): void => {
+		const meta = deps.session?.current();
+		const id = meta?.id ?? deps.getSessionId?.() ?? null;
+		if (id === sessionCounter.id) return;
+		const baseTurns = meta?.messageCount ?? 0;
+		const previousProjected = sessionCounter.baseTurns + sessionCounter.submittedTurns;
+		const carryPending = sessionCounter.id === null ? Math.max(0, previousProjected - baseTurns) : 0;
+		sessionCounter = { id, baseTurns, submittedTurns: carryPending };
+	};
+
+	const recordSubmittedTurn = (): void => {
+		syncSessionCounter();
+		sessionCounter = { ...sessionCounter, submittedTurns: sessionCounter.submittedTurns + 1 };
+	};
+
+	const liveSessionTurns = (): number | null => {
+		syncSessionCounter();
+		const metaTurns = deps.session?.current()?.messageCount;
+		const projected = sessionCounter.baseTurns + sessionCounter.submittedTurns;
+		return typeof metaTurns === "number" ? Math.max(metaTurns, projected) : projected > 0 ? projected : null;
+	};
+
+	const ensureSessionForLocalEntry = (): void => {
+		if (!deps.session || deps.session.current()) return;
+		const settings = deps.getSettings?.();
+		const input: { cwd: string; target?: string; model?: string } = {
+			cwd: deps.getCwd?.() ?? process.cwd(),
+		};
+		if (settings?.orchestrator.target) input.target = settings.orchestrator.target;
+		if (settings?.orchestrator.model) input.model = settings.orchestrator.model;
+		deps.session.create(input);
+	};
+
+	const readStructuredEntries = (sessionId: string): SessionEntry[] =>
+		(deps.readStructuredEntries ?? readStructuredEntriesFromDisk)(sessionId);
+
+	const refreshChatContextFromSession = (leafTurnId: string | null): void => {
+		if (!deps.readSessionEntries) return;
+		const turns = deps.readSessionEntries();
+		deps.chat.resetForSession(
+			leafTurnId,
+			buildReplayAgentMessagesFromTurns(turns, {
+				...(leafTurnId ? { activeLeafTurnId: leafTurnId } : {}),
+			}),
+		);
+		deps.refreshStatus();
+	};
+
+	return {
+		ensureSessionForLocalEntry,
+		readStructuredEntries,
+		refreshChatContextFromSession,
+		recordSubmittedTurn,
+		liveSessionTurns,
+		syncSessionCounter,
+	};
+}

package/src/interactive/session-usage-reseed.ts

@@ -0,0 +1,74 @@
+/**
+ * Rebuild the running usage totals from a session's own ledger.
+ *
+ * The `/cost` overlay and the footer both render one process-lifetime
+ * accumulator, and only `startNewSession` ever reset it. Resuming did not, so a
+ * resumed session showed the *previous* session's numbers under the resumed
+ * session's id: one process, two sessions, byte-identical totals relabelled.
+ * That is misattribution rather than an undercount, and a process that resumed
+ * and sent nothing reported zero for a session holding tens of thousands of
+ * tokens on disk.
+ *
+ * The fold itself is `ledgerUsageCalls` in the session domain, which owns the
+ * ledger and serves `clio-coder usage report` from the same function. This module is
+ * only the sink wiring between that fold and the observability projection.
+ */
+
+import { ledgerUsageCalls, type SessionEntry, type SessionUsageDefaults } from "../domains/session/index.js";
+import { filterEntriesToActivePath } from "../domains/session/tree/active-path.js";
+
+/** The slice of ObservabilityContract a reseed needs. */
+export interface SessionUsageSink {
+	resetSession(): void;
+	recordTokens(
+		providerId: string,
+		modelId: string,
+		tokens: number,
+		costUsd?: number,
+		breakdown?: {
+			input: number;
+			output: number;
+			cacheRead: number;
+			cacheWrite: number;
+			reasoningTokens: number;
+			totalTokens: number;
+			apiCalls?: number;
+		},
+		costProvenance?: never,
+	): void;
+}
+
+/**
+ * Clear the running totals and replay the supplied session's recorded calls
+ * into them. Safe to call with an empty ledger: the totals reset to zero, which
+ * is the honest answer for a session that has spent nothing.
+ *
+ * `activeLeafTurnId` scopes the fold to one branch, through the same
+ * `filterEntriesToActivePath` the transcript replays through. current.jsonl is
+ * append-only, so after a `/tree` switch the abandoned sibling turns are still
+ * in the file: the transcript stopped showing them and `/cost` and the footer Σ
+ * kept counting them, which put a session total on screen for turns the reader
+ * had just been told were not on this branch. Omitted, the fold follows the
+ * newest message's ancestry, the same fallback an offline read of the transcript
+ * takes; a ledger with no branch in it folds whole either way.
+ */
+export function reseedSessionUsageFromLedger(
+	sink: SessionUsageSink,
+	entries: ReadonlyArray<SessionEntry>,
+	defaults: SessionUsageDefaults = {},
+	activeLeafTurnId?: string | null,
+): void {
+	sink.resetSession();
+	const scoped = filterEntriesToActivePath(entries, activeLeafTurnId ?? undefined);
+	for (const call of ledgerUsageCalls(scoped, defaults)) {
+		sink.recordTokens(call.providerId, call.modelId, call.totalTokens, call.costUsd, {
+			input: call.input,
+			output: call.output,
+			cacheRead: call.cacheRead,
+			cacheWrite: call.cacheWrite,
+			reasoningTokens: call.reasoningTokens,
+			totalTokens: call.totalTokens,
+			apiCalls: call.apiCalls ?? 1,
+		});
+	}
+}