@iowarp/clio-coder 0.3.4 → 0.3.6

package/src/entry/orchestrator.ts

@@ -183,6 +183,7 @@ import { isGitRepository, recoverCleanupReadyCompeteGroups } from "../tools/comp
 import { createDispatchBackgroundRegistry } from "../tools/dispatch-background.js";
 import { createFileMutationObserver, createSkillActivationObserver } from "../tools/observers.js";
 import { createRegistry } from "../tools/registry.js";
+import { sweepExpiredToolOffloads } from "../tools/result-shaping.js";
 
 export interface BootResult {
 	exitCode: number;
@@ -726,6 +727,7 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 	termination.installSignalHandlers();
 
 	ensureClioState();
+	sweepExpiredToolOffloads();
 	timer.mark("install check");
 
 	// A hard-killed coordinator cannot run domain drains. Reconcile its compete
@@ -1553,8 +1555,13 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 		getMemorySection: () => {
 			try {
 				const records = loadMemoryRecordsSync(clioDataDir());
+				const settings = getCurrentSettings();
+				const targetId = session?.current()?.target ?? settings.orchestrator?.target;
+				const runtimeId = targetId ? providers.getTarget(targetId)?.runtime : undefined;
 				return buildMemoryPromptSection(records, {
+					scopes: ["global", "repo", "runtime"],
 					activeRepository: canonicalMemoryRepositoryIdentity(process.cwd()),
+					activeRuntime: runtimeId === undefined ? null : { kind: "runtime", key: runtimeId },
 				}).section;
 			} catch {
 				return "";
@@ -1562,7 +1569,17 @@ export async function bootOrchestrator(options: BootOptions = {}): Promise<BootR
 		},
 		getTaskMemoryHandoffSource: () => {
 			ensureTaskMemorySession();
-			return renderTaskMemoryHandoffSource(taskMemoryBank.snapshot());
+			const meta = session?.current();
+			if (!meta) throw new Error("task memory handoff requires an active session");
+			const settings = getCurrentSettings();
+			const targetId = meta.target ?? settings.orchestrator?.target;
+			const runtimeId = targetId ? providers.getTarget(targetId)?.runtime : undefined;
+			return renderTaskMemoryHandoffSource(taskMemoryBank.snapshot(), {
+				sessionId: meta.id,
+				evidenceRefs: [`session-${meta.id}`],
+				runtimeIds: runtimeId === undefined ? [] : [runtimeId],
+				agentIds: [],
+			});
 		},
 		registerDeferredReminderSink: (sink) => {
 			deferredMemoryReminderSink = sink;

package/src/interactive/chat-loop-messages.ts

@@ -7,6 +7,13 @@
 
 import { randomUUID } from "node:crypto";
 import { settingsPath } from "../core/config.js";
+import {
+	addResponseModelIdObservationCount,
+	emptyResponseModelIdObservationCounts,
+	type ResponseModelIdObservation,
+	type ResponseModelIdObservationCounts,
+	responseModelIdObservationFromRecord,
+} from "../core/response-model-id.js";
 import type { PendingSkillRequest, PendingSkillToolPolicy, SkillDeclaredToolPolicy } from "../core/skill-activation.js";
 import { ToolNames } from "../core/tool-names.js";
 import { canonicalJson, sha256 } from "../domains/prompts/hash.js";
@@ -334,6 +341,7 @@ export function createAskUserToolPolicy(activeTools: ReadonlyArray<{ name: strin
 		status: "idle",
 		startedAt: now,
 		updatedAt: now,
+		exposure: "local",
 		rounds: [],
 		decisions: [],
 		inFlight: false,
@@ -356,6 +364,9 @@ export interface RunUsageSummary {
 	apiCalls: number;
 	hadReasoning: boolean;
 	hadUsage: boolean;
+	responseModelIdObservationCounts: ResponseModelIdObservationCounts;
+	lastResponseModelIdObservation: ResponseModelIdObservation;
+	lastDifferingResponseModelId: string | null;
 }
 
 /**
@@ -380,6 +391,9 @@ export function sumRunUsage(messages: ReadonlyArray<AgentMessage>): RunUsageSumm
 		apiCalls: 0,
 		hadReasoning: false,
 		hadUsage: false,
+		responseModelIdObservationCounts: emptyResponseModelIdObservationCounts(),
+		lastResponseModelIdObservation: { state: "not-observed" },
+		lastDifferingResponseModelId: null,
 	};
 	for (const raw of messages) {
 		const message = raw as
@@ -397,8 +411,15 @@ export function sumRunUsage(messages: ReadonlyArray<AgentMessage>): RunUsageSumm
 			  };
 		if (!message || typeof message !== "object") continue;
 		if (message.role !== "assistant") continue;
+		const record = message as unknown as Record<string, unknown>;
 		const usage = message.usage;
 		if (!usage || typeof usage !== "object") continue;
+		summary.lastResponseModelIdObservation = responseModelIdObservationFromRecord(record, "not-observed");
+		addResponseModelIdObservationCount(summary.responseModelIdObservationCounts, summary.lastResponseModelIdObservation);
+		summary.lastDifferingResponseModelId =
+			typeof record.responseModel === "string" && record.responseModel.trim().length > 0
+				? record.responseModel.trim()
+				: null;
 		summary.hadUsage = true;
 		summary.apiCalls += 1;
 		const input = typeof usage.input === "number" ? usage.input : 0;
@@ -459,6 +480,7 @@ export function assistantSessionPayload(
 	const raw = message as unknown as Record<string, unknown>;
 	if (Array.isArray(raw.content)) payload.content = raw.content;
 	if (thinking.length > 0) payload.thinking = thinking;
+	payload.responseModelIdObservation = responseModelIdObservationFromRecord(raw, "not-observed");
 	for (const key of ["usage", "api", "provider", "model", "responseModel", "responseId", "diagnostics"]) {
 		if (raw[key] !== undefined) payload[key] = raw[key];
 	}

package/src/interactive/chat-loop.ts

@@ -549,6 +549,12 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		emitNotice,
 		toolStartTimes,
 	});
+	// A fresh ledger and footer render before the first submit. Start the same
+	// live capability probe that submit and resume use so those boot surfaces
+	// refresh to the probed model window as soon as provider discovery lands.
+	// The turn runtime coalesces the first submit onto this request, then its
+	// target and model TTL keeps later submits from repeating it.
+	void turnRuntime.ensureLiveCapabilitiesForSelectedModel().catch(() => {});
 
 	// --- bus subscriptions --------------------------------------------------
 
@@ -664,6 +670,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			// 1. Accept the prompt: reset per-turn accounting, freeze the tool
 			// surface, fire turn_start, and assemble the submitted text.
 			state.turnToolCalls = 0;
+			state.turnToolNames = [];
 			state.turnSharedWorkerNote = isWorkerShareNote(text);
 			middlewareToolChoice.reset();
 			if (options.requestContinuation !== true) state.stalledTurnNudgeSpent = false;
@@ -988,6 +995,12 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			middlewareToolChoice.reset();
 			state.lastTurnId = leafTurnId;
 			context.resetForSession();
+			// The resumed ledger renders before the first new turn (issue #189),
+			// and the window it renders against should be the probed one rather
+			// than the catalog's, so the live capability probe the first submit
+			// would run runs now, under the same TTL; the footer refreshes on the
+			// provider-health event the probe publishes.
+			void turnRuntime.ensureLiveCapabilitiesForSelectedModel().catch(() => {});
 			state.replayedContextMessages = replayMessages ? [...replayMessages] : [];
 			if (state.runtime) {
 				state.runtime.agent.state.messages = [...state.replayedContextMessages];

package/src/interactive/chat-renderer.ts

@@ -13,6 +13,7 @@
  * `isTransparentAssistantWrapper`.
  */
 
+import { existsSync } from "node:fs";
 import { ToolNames } from "../core/tool-names.js";
 import { foldWorkingSet } from "../domains/context/working-set/fold.js";
 import { compactionCut } from "../domains/context/working-set/visible.js";
@@ -44,7 +45,7 @@ import type { AgentMessage } from "../engine/types.js";
 import { toolPresentationPolicy } from "../tools/presentation.js";
 import { toolResultPresentationText } from "../tools/result-disposition.js";
 import type { ChatLoopEvent, RetryStatusPayload } from "./chat-loop.js";
-import { isSelfExplainingAbort } from "./chat-loop-messages.js";
+import { isSelfExplainingAbort, toolResultSummary } from "./chat-loop-messages.js";
 import type { ChatPanel } from "./chat-panel.js";
 import { renderBranchSummaryEntry } from "./renderers/branch-summary.js";
 import { renderCompactionSummaryEntry } from "./renderers/compaction-summary.js";
@@ -440,6 +441,7 @@ function richMessageFromEntry(entry: MessageEntry, maxTextChars?: number): Agent
 			"api",
 			"provider",
 			"model",
+			"responseModelIdObservation",
 			"responseModel",
 			"responseId",
 			"diagnostics",
@@ -671,6 +673,19 @@ interface ReplayToolResult {
 	blockReason?: string;
 }
 
+/**
+ * Resolve a replayed offload pointer once, when the ledger row becomes a
+ * display event. Terminal repaints consume the recorded fact and never touch
+ * the filesystem.
+ */
+function replayResultSummary(result: ReplayToolResult): Record<string, unknown> | undefined {
+	const summary = result.resultSummary ?? toolResultSummary(result.result);
+	const offloadPath =
+		typeof summary.offloadPath === "string" && summary.offloadPath.length > 0 ? summary.offloadPath : null;
+	if (offloadPath === null) return result.resultSummary;
+	return { ...summary, offloadFileMissing: !existsSync(offloadPath) };
+}
+
 function extractToolResult(entry: MessageEntry): ReplayToolResult {
 	const payload = entry.payload;
 	const obj = payloadObject(payload);
@@ -1131,6 +1146,7 @@ export function rehydrateChatPanelFromTurns(
 				}
 				if (entry.role === "tool_result") {
 					const result = extractToolResult(entry);
+					const resultSummary = replayResultSummary(result);
 					const evictedReason = workingSet.evicted.get(entry.turnId)?.reason;
 					const fallbackId = result.id ?? pendingToolIds.pop() ?? null;
 					if (fallbackId) {
@@ -1143,7 +1159,7 @@ export function rehydrateChatPanelFromTurns(
 							result: displayReplayToolResult(result.result, options.unboundedToolBodies === true),
 							isError: result.isError,
 							...(result.durationMs !== undefined ? { durationMs: result.durationMs } : {}),
-							...(result.resultSummary !== undefined ? { resultSummary: result.resultSummary } : {}),
+							...(resultSummary !== undefined ? { resultSummary } : {}),
 							...(result.outcome !== undefined ? { outcome: result.outcome } : {}),
 							...(result.blockReason !== undefined ? { blockReason: result.blockReason } : {}),
 							...(evictedReason !== undefined ? { evictedReason } : {}),
@@ -1157,7 +1173,7 @@ export function rehydrateChatPanelFromTurns(
 									result: displayReplayToolResult(result.result, options.unboundedToolBodies === true),
 									isError: result.isError,
 									...(result.durationMs !== undefined ? { durationMs: result.durationMs } : {}),
-									...(result.resultSummary !== undefined ? { resultSummary: result.resultSummary } : {}),
+									...(resultSummary !== undefined ? { resultSummary } : {}),
 									...(result.outcome === "blocked" ? { outcome: "blocked" as const } : {}),
 									...(result.blockReason !== undefined ? { blockReason: result.blockReason } : {}),
 									...(evictedReason !== undefined ? { evictedReason } : {}),

package/src/interactive/clio-editor.ts

@@ -1,9 +1,12 @@
 import { Editor, stripTerminalSequences, type TUI, truncateToWidth, visibleWidth } from "../engine/tui.js";
+import { fitHintEntries } from "./overlay-frame.js";
+import { permissionHintEntries } from "./permission-hint.js";
 import type { ClioTheme } from "./theme/index.js";
 import { clioTheme, editorTheme, GLYPH, rule } from "./theme/index.js";
 
 const REVERSE_VIDEO_BLANK = `${String.fromCharCode(27)}[7m ${String.fromCharCode(27)}[0m`;
 const EMPTY_PROMPT = "Ask Clio…  / for commands";
+const CONFIRM_PROMPT = "A parked call is waiting for your decision";
 const MIN_HINT_WIDTH = 60;
 
 function hasScrollIndicator(line: string): boolean {
@@ -18,6 +21,13 @@ export interface EditorChrome {
 	getThinkingLabel: () => string;
 	/** Whether Enter currently targets the active Clio response. */
 	isStreaming?: () => boolean;
+	/**
+	 * Whether a permission prompt owns the keyboard. The dialog once sat at the
+	 * vertical center of a tall viewport, far from the composer. It now anchors
+	 * above that composer, while the rail still says CONFIRM and carries the
+	 * dialog's keys whenever the prompt owns input (issues #186 and #194).
+	 */
+	isAwaitingApproval?: () => boolean;
 	/** Whether the current draft will actually steer Clio or live dispatch work on Enter. */
 	willEnterSteer?: (text: string) => boolean;
 	/** Resolved submit binding, formatted for display. */
@@ -26,7 +36,7 @@ export interface EditorChrome {
 	getNewlineKeyLabel?: () => string;
 }
 
-type ComposerMode = "MESSAGE" | "FOLLOW-UP" | "STEER";
+type ComposerMode = "MESSAGE" | "FOLLOW-UP" | "STEER" | "CONFIRM";
 
 function normalizeThinkingHint(value: string): string {
 	return value
@@ -61,6 +71,7 @@ function styledRailLabel(theme: ClioTheme, chrome: EditorChrome): string {
 }
 
 function composerMode(chrome: EditorChrome, text: string): ComposerMode {
+	if (chrome.isAwaitingApproval?.() ?? false) return "CONFIRM";
 	if (!(chrome.isStreaming?.() ?? false)) return "MESSAGE";
 	const willSteer = chrome.willEnterSteer?.(text) ?? text.trim().length > 0;
 	return willSteer ? "STEER" : "FOLLOW-UP";
@@ -73,12 +84,27 @@ function lowerRailHint(theme: ClioTheme, chrome: EditorChrome): string {
 	);
 }
 
-function renderEmptyPrompt(line: string, width: number, theme: ClioTheme): string {
+/**
+ * The permission keys on the composer rail, fitted like the dialog footer so
+ * both surfaces narrow in the same order and never drop allow or stop first.
+ * The rule spends three columns around a right label, hence the subtraction.
+ */
+function confirmRailHint(theme: ClioTheme, width: number, hasDraft: boolean): string {
+	return theme.fg("warning", fitHintEntries(permissionHintEntries(hasDraft), Math.max(1, width - 3)));
+}
+
+function modeToken(mode: ComposerMode): "action" | "accentDeep" | "warning" {
+	if (mode === "STEER") return "action";
+	if (mode === "CONFIRM") return "warning";
+	return "accentDeep";
+}
+
+function renderEmptyPrompt(line: string, width: number, theme: ClioTheme, text = EMPTY_PROMPT): string {
 	const cursorAt = line.indexOf(REVERSE_VIDEO_BLANK);
 	if (cursorAt < 0) return line;
 	const afterCursorAt = cursorAt + REVERSE_VIDEO_BLANK.length;
 	const available = Math.max(0, width - 1);
-	const prompt = truncateToWidth(theme.fg("dim", EMPTY_PROMPT), available, "…", false);
+	const prompt = truncateToWidth(theme.fg("dim", text), available, "…", false);
 	const consumed = visibleWidth(prompt);
 	return `${line.slice(0, afterCursorAt)}${prompt}${line.slice(afterCursorAt + consumed)}`;
 }
@@ -111,12 +137,12 @@ export class ClioEditor extends Editor {
 			// The base editor has already fitted the scroll indicator to this width.
 			// Prefix the mode and trim only the indicator rail's trailing fill, keeping
 			// its direction/count text and its own narrow-width fallback intact.
-			const modeLabel = theme.style(mode === "STEER" ? "action" : "accentDeep", mode, { bold: true });
+			const modeLabel = theme.style(modeToken(mode), mode, { bold: true });
 			lines[0] = truncateToWidth(`${modeLabel} ${lines[0] ?? ""}`, safeWidth, "", true);
 		} else {
 			lines[0] = rule(theme, safeWidth, {
 				left: mode,
-				leftToken: mode === "STEER" ? "action" : "accentDeep",
+				leftToken: modeToken(mode),
 				right: styledRailLabel(theme, this.chrome),
 				fillToken: "frameStrong",
 				rightRaw: true,
@@ -124,10 +150,21 @@ export class ClioEditor extends Editor {
 			});
 		}
 
-		if (text.length === 0 && lines[1]) lines[1] = renderEmptyPrompt(lines[1], safeWidth, theme);
+		if (text.length === 0 && lines[1]) {
+			lines[1] = renderEmptyPrompt(lines[1], safeWidth, theme, mode === "CONFIRM" ? CONFIRM_PROMPT : EMPTY_PROMPT);
+		}
 
 		const bottomRail = findBottomRail(lines, safeWidth);
-		if (bottomRail >= 0 && safeWidth >= MIN_HINT_WIDTH) {
+		// The confirm keys render at every width: the send hint is a convenience
+		// that a narrow composer can drop, the allow and deny keys are not.
+		if (bottomRail >= 0 && mode === "CONFIRM") {
+			lines[bottomRail] = rule(theme, safeWidth, {
+				right: confirmRailHint(theme, safeWidth, text.length > 0),
+				fillToken: "frameStrong",
+				rightRaw: true,
+				rightTail: theme.style("frameStrong", "─", { bold: true }),
+			});
+		} else if (bottomRail >= 0 && safeWidth >= MIN_HINT_WIDTH) {
 			lines[bottomRail] = rule(theme, safeWidth, {
 				right: lowerRailHint(theme, this.chrome),
 				fillToken: "frameStrong",

package/src/interactive/context-overlay.ts

@@ -3,6 +3,7 @@ import { relative } from "node:path";
 import { BusChannels } from "../core/bus-events.js";
 import type { SafeEventBus } from "../core/event-bus.js";
 import type { WorkingSetView } from "../domains/context/working-set/contract.js";
+import { formatContextWindowSlots } from "../domains/providers/index.js";
 import type { ContextLedger, ContextLedgerGroup } from "../domains/session/context-ledger.js";
 import { type OverlayHandle, Text, type TUI, visibleWidth } from "../engine/tui.js";
 import { contextCategorySwatch, renderContextMeterGrid, renderEvictedTokensLine } from "./context-meter.js";
@@ -112,12 +113,34 @@ function coldReasonLabel(reason: string): string {
 	}
 }
 
+/** The operator's working-set configuration, as `/context` states it. */
+export interface WorkingSetConfigView {
+	enabled: boolean;
+	policy: string;
+}
+
 /**
  * The working-set section: what the projection has taken out of the window
  * and how often the model has asked for it back. Churn is recalls over items
  * evicted; a high number means the policy evicts what is still needed.
  */
-function renderWorkingSetLines(view: WorkingSetView): string[] {
+/**
+ * The policy line names what is configured, not what last ran. `lastPolicyId`
+ * is stamped by the first applied event, and eviction runs only when pressure
+ * crosses `compaction.threshold`, so a whole session at the shipped default
+ * read `policy none` (issue #190). With no configuration in hand (older
+ * callers) the last applied policy is still the best available claim.
+ */
+function workingSetPolicyLabel(view: WorkingSetView, config: WorkingSetConfigView | null | undefined): string {
+	if (config === null || config === undefined) return `policy ${view.lastPolicyId ?? "none"}`;
+	if (!config.enabled) return "disabled";
+	const state = view.evictionEvents === 0 ? " · no events yet" : "";
+	const lastRan =
+		view.lastPolicyId !== null && view.lastPolicyId !== config.policy ? ` (last event by ${view.lastPolicyId})` : "";
+	return `policy ${config.policy}${lastRan}${state}`;
+}
+
+function renderWorkingSetLines(view: WorkingSetView, config: WorkingSetConfigView | null | undefined): string[] {
 	const theme = clioTheme();
 	const items = view.evicted.size;
 	const summary = [
@@ -128,7 +151,7 @@ function renderWorkingSetLines(view: WorkingSetView): string[] {
 		`churn ${formatChurn(view)}`,
 	].join(" · ");
 	return [
-		`${theme.fg("muted", "working set")} ${theme.fg("dim", "·")} ${theme.fg("accent", `policy ${view.lastPolicyId ?? "none"}`)}`,
+		`${theme.fg("muted", "working set")} ${theme.fg("dim", "·")} ${theme.fg("accent", workingSetPolicyLabel(view, config))}`,
 		theme.fg("dim", summary),
 	];
 }
@@ -137,6 +160,7 @@ export function renderContextLedgerLines(
 	ledger: ContextLedger,
 	contentWidth: number,
 	workingSet?: WorkingSetView | null,
+	workingSetConfig?: WorkingSetConfigView | null,
 ): string[] {
 	const theme = clioTheme();
 	const lines: string[] = [];
@@ -154,7 +178,14 @@ export function renderContextLedgerLines(
 
 	if (ledger.contextWindow > 0) {
 		const source = ledger.measured ? "measured" : "≈ estimated";
-		const summary = `${formatTokens(ledger.usedTokens)} / ${formatTokens(ledger.contextWindow)} tokens (${formatContextPercent(ledger.percent)})`;
+		// `196,608 (786,432 / 4 slots)`: a llama.cpp window that is one slot's
+		// share of the server's KV budget names the split, because the bare
+		// number reads as the whole server and the meter is measured against
+		// the share (issue #187).
+		const window = ledger.contextWindowSlots
+			? formatContextWindowSlots(ledger.contextWindow, ledger.contextWindowSlots)
+			: formatTokens(ledger.contextWindow);
+		const summary = `${formatTokens(ledger.usedTokens)} / ${window} tokens (${formatContextPercent(ledger.percent)})`;
 		const provenance = contextWindowProvenanceLabel(ledger.contextWindowSource);
 		const trailer = provenance ? `${provenance} window · ${source}` : source;
 		lines.push(`${theme.fg("title", summary)} ${theme.fg("dim", "·")} ${theme.fg("muted", trailer)}`);
@@ -170,7 +201,7 @@ export function renderContextLedgerLines(
 
 	lines.push("");
 	if (workingSet) {
-		for (const line of renderWorkingSetLines(workingSet)) lines.push(line);
+		for (const line of renderWorkingSetLines(workingSet, workingSetConfig)) lines.push(line);
 		lines.push("");
 	}
 	if (ledger.projectPreload && ledger.groups.some((group) => group.category === "project")) {
@@ -243,6 +274,8 @@ export interface OpenContextOverlayOptions {
 	};
 	/** Working-set fold at the live leaf; null or absent hides the section. */
 	getWorkingSet?: () => WorkingSetView | null;
+	/** The configured `context.workingSet` block, so the policy line states what is set. */
+	getWorkingSetConfig?: () => WorkingSetConfigView | null;
 }
 
 /**
@@ -257,7 +290,12 @@ export function openContextOverlay(
 	options?: OpenContextOverlayOptions,
 ): OverlayHandle {
 	const render = (): string =>
-		renderContextLedgerLines(getLedger(), DEFAULT_CONTENT_WIDTH, options?.getWorkingSet?.() ?? null).join("\n");
+		renderContextLedgerLines(
+			getLedger(),
+			DEFAULT_CONTENT_WIDTH,
+			options?.getWorkingSet?.() ?? null,
+			options?.getWorkingSetConfig?.() ?? null,
+		).join("\n");
 	const text = new Text(render(), 0, 0);
 	const handle = showClioOverlayFrame(tui, text, {
 		anchor: "center",

package/src/interactive/cost-overlay.ts

@@ -1,3 +1,8 @@
+import {
+	addResponseModelIdObservationCounts,
+	type ResponseModelIdObservationCounts,
+	responseModelIdObservationCountsLabel,
+} from "../core/response-model-id.js";
 import {
 	aggregateCostAmounts,
 	type CostAggregate,
@@ -16,7 +21,9 @@ export const COST_OVERLAY_WIDTH = DEFAULT_CONTENT_WIDTH + 4;
 
 export interface CostRow {
 	providerId: string;
-	modelId: string;
+	attributedModelId: string;
+	requestedModelIds: string[];
+	responseModelIdObservationCounts: ResponseModelIdObservationCounts;
 	runs: number;
 	tokens: number;
 	input: number;
@@ -33,9 +40,17 @@ function formatTokens(n: number): string {
 }
 
 export function aggregateCostEntries(entries: ReadonlyArray<CostEntry>): CostRow[] {
-	const grouped = new Map<string, { row: Omit<CostRow, "cost">; entries: CostEntry[] }>();
+	const grouped = new Map<
+		string,
+		{
+			row: Omit<CostRow, "cost" | "requestedModelIds" | "responseModelIdObservationCounts">;
+			requestedModelIds: Set<string>;
+			responseModelIdObservationCounts: ResponseModelIdObservationCounts;
+			entries: CostEntry[];
+		}
+	>();
 	for (const entry of entries) {
-		const key = `${entry.providerId}::${entry.modelId}`;
+		const key = `${entry.providerId}::${entry.attributedModelId}`;
 		const existing = grouped.get(key);
 		if (existing) {
 			existing.row.runs += 1;
@@ -46,13 +61,18 @@ export function aggregateCostEntries(entries: ReadonlyArray<CostEntry>): CostRow
 			existing.row.cacheWrite += entry.cacheWrite;
 			existing.row.reasoningTokens += entry.reasoningTokens;
 			existing.row.apiCalls += entry.apiCalls ?? 1;
+			for (const requestedModelId of entry.requestedModelIds) existing.requestedModelIds.add(requestedModelId);
+			addResponseModelIdObservationCounts(
+				existing.responseModelIdObservationCounts,
+				entry.responseModelIdObservationCounts,
+			);
 			existing.entries.push(entry);
 			continue;
 		}
 		grouped.set(key, {
 			row: {
 				providerId: entry.providerId,
-				modelId: entry.modelId,
+				attributedModelId: entry.attributedModelId,
 				runs: 1,
 				tokens: entry.tokens,
 				input: entry.input,
@@ -62,22 +82,31 @@ export function aggregateCostEntries(entries: ReadonlyArray<CostEntry>): CostRow
 				reasoningTokens: entry.reasoningTokens,
 				apiCalls: entry.apiCalls ?? 1,
 			},
+			requestedModelIds: new Set(entry.requestedModelIds),
+			responseModelIdObservationCounts: { ...entry.responseModelIdObservationCounts },
 			entries: [entry],
 		});
 	}
-	const rows = Array.from(grouped.values(), ({ row, entries }) => ({
+	const rows = Array.from(grouped.values(), ({ row, entries, requestedModelIds, responseModelIdObservationCounts }) => ({
 		...row,
+		requestedModelIds: [...requestedModelIds].sort(),
+		responseModelIdObservationCounts,
 		cost: aggregateCostAmounts(entries.map((entry) => ({ usd: entry.usd, provenance: entry.provenance }))),
 	}));
 	rows.sort((a, b) => {
 		if (a.providerId !== b.providerId) return a.providerId < b.providerId ? -1 : 1;
-		if (a.modelId !== b.modelId) return a.modelId < b.modelId ? -1 : 1;
+		if (a.attributedModelId !== b.attributedModelId) return a.attributedModelId < b.attributedModelId ? -1 : 1;
 		return 0;
 	});
 	return rows;
 }
 
-function sumRows(rows: ReadonlyArray<CostRow>): Omit<CostRow, "providerId" | "modelId" | "cost"> {
+function sumRows(
+	rows: ReadonlyArray<CostRow>,
+): Omit<
+	CostRow,
+	"providerId" | "attributedModelId" | "requestedModelIds" | "responseModelIdObservationCounts" | "cost"
+> {
 	return rows.reduce(
 		(acc, row) => ({
 			runs: acc.runs + row.runs,
@@ -156,6 +185,8 @@ function modelBlock(row: CostRow): string[] {
 	// block with token rows and no cost row.
 	const cost = formatCostAggregate(row.cost);
 	return kvBlock([
+		["requested model ids", row.requestedModelIds.join(", ")],
+		["response model id observation", responseModelIdObservationCountsLabel(row.responseModelIdObservationCounts)],
 		["turns", formatTokens(row.runs)],
 		["model calls", formatTokens(row.apiCalls)],
 		...(cost === null ? [] : [["cost", cost] as const]),
@@ -185,7 +216,7 @@ export function formatCostOverlayBodyLines(
 	} else {
 		for (const [index, row] of rows.entries()) {
 			if (index > 0) lines.push("");
-			lines.push(theme.style("accent", `${row.providerId} · ${row.modelId}`, { bold: true }));
+			lines.push(theme.style("accent", `${row.providerId} · attributed model ${row.attributedModelId}`, { bold: true }));
 			for (const line of modelBlock(row)) {
 				lines.push(line);
 			}