@iowarp/clio-coder 0.3.3 → 0.3.6

package/src/cli/index.ts

@@ -52,17 +52,20 @@ Usage:
   clio-coder context wiki [--update] [--status] [--depth auto|simple|medium|detailed] [--target <id>] [--model <id>]
   clio-coder context reset [--all] [--yes]  clear accumulated project context artifacts
   clio-coder context index [--json]  build the codewiki index without model calls
+  clio-coder context replay --sessions <path>...  compare working-set policies over Clio ledgers
+  clio-coder context working-set --session <id|path>  inspect one session's working-set state
   clio-coder uninstall            remove all Clio Coder state; --remove-binary also unlinks the launcher
   clio-coder upgrade              upgrade Clio Coder and run pending migrations
   clio-coder agents               list discovered agent recipes
   clio-coder fleet list|run|status|drain|resume  fleet contracts, status, and admission control
   clio-coder evidence             build, list, or inspect evidence artifacts
   clio-coder eval                 run, report, or compare local eval task files
-  clio-coder memory               list, propose, approve, reject, or prune memory
+  clio-coder memory               list, propose, promote, approve, reject, or prune memory
   clio-coder usage report         cross-session usage facts and opportunities (experimental)
   clio-coder trace                query or view the durable dispatch trace mirror
   clio-coder extensions           install, list, enable, disable, or remove extension packages
   clio-coder skills               list, inspect, validate, or install skills
+  clio-coder verifiers            discover, author, validate, edit, or dry-run project checks
   clio-coder docs [topic]         serve the HTML docs of a source checkout on 127.0.0.1 (--no-open to skip browser)
   clio-coder dev <command>        harness instruments; run 'clio-coder dev' for the list
   clio-coder --help, -h           this message
@@ -243,6 +246,7 @@ const COMMAND_HANDLERS = new Map<string, CommandHandler>([
 	["ext", extensionsCommand],
 	["fleet", async (subArgs) => (await import("./fleet.js")).runFleetCommand(subArgs)],
 	["skills", async (subArgs) => (await import("./skills.js")).runSkillsCommand(subArgs)],
+	["verifiers", async (subArgs) => (await import("./verifiers.js")).runVerifiersCommand(subArgs)],
 	["docs", async (subArgs) => (await import("./docs.js")).runDocsCommand(subArgs)],
 	["share", async (subArgs) => (await import("./share.js")).runShareCommand(subArgs)],
 	["export", async (subArgs) => (await import("./share.js")).runExportCommand(subArgs)],

package/src/cli/memory.ts

@@ -1,36 +1,62 @@
+import { readFile, stat } from "node:fs/promises";
 import { clioDataDir } from "../core/xdg.js";
 import {
 	approveMemoryRecord,
+	canonicalMemoryRepositoryIdentity,
 	loadMemoryRecords,
 	type MemoryRecord,
+	type MemoryScopeSelection,
+	memoryAgentIdentity,
+	memoryRuntimeIdentity,
 	memoryStatus,
+	parseTaskMemoryHandoffSnapshot,
 	proposeMemoryFromEvidence,
+	proposeMemoryPromotion,
 	pruneStaleMemory,
+	type ReviewedTaskMemoryHandoffSnapshot,
 	rejectMemoryRecord,
+	type TaskMemoryHandoffEntry,
 } from "../domains/memory/index.js";
 import { printError, printOk } from "./shared.js";
 
 const HELP = `clio-coder memory list
-clio-coder memory propose --from-evidence <evidenceId>
+clio-coder memory propose --from-evidence <evidenceId> [scope options]
+clio-coder memory promote --from-handoff <path> [--entry <id>...] --scope <scope> [scope options]
 clio-coder memory approve <memoryId>
 clio-coder memory reject <memoryId>
 clio-coder memory prune --stale
 
 Manage scoped, approved, evidence-linked local memory records.
+
+Scope options:
+  --scope repo --repository <canonical-absolute-path>
+  --scope global --acknowledge-global
+  --scope runtime --runtime <source-runtime-id>
+  --scope agent --agent <source-agent-id>
+
+Omit scope options from propose to preserve evidence-inferred scope. Promotion
+always requires an explicit scope and creates unapproved records for review.
 `;
 
-type MemoryCommand = "list" | "propose" | "approve" | "reject" | "prune";
+type MemoryCommand = "list" | "propose" | "promote" | "approve" | "reject" | "prune";
 
 interface ParsedMemoryArgs {
 	command?: MemoryCommand;
 	evidenceId?: string;
+	handoffPath?: string;
+	entryIds: string[];
 	memoryId?: string;
+	scope?: "repo" | "global" | "runtime" | "agent";
+	repositoryPath?: string;
+	acknowledgeGlobal: boolean;
+	runtimeId?: string;
+	agentId?: string;
 	stale: boolean;
 	help: boolean;
 }
 
 function parseMemoryArgs(args: ReadonlyArray<string>): ParsedMemoryArgs {
-	const parsed: ParsedMemoryArgs = { stale: false, help: false };
+	const parsed: ParsedMemoryArgs = { entryIds: [], acknowledgeGlobal: false, stale: false, help: false };
 	for (let index = 0; index < args.length; index += 1) {
 		const arg = args[index];
 		if (arg === undefined) continue;
@@ -39,21 +65,70 @@ function parseMemoryArgs(args: ReadonlyArray<string>): ParsedMemoryArgs {
 			continue;
 		}
 		if (parsed.command === undefined) {
-			if (arg === "list" || arg === "propose" || arg === "approve" || arg === "reject" || arg === "prune") {
+			if (
+				arg === "list" ||
+				arg === "propose" ||
+				arg === "promote" ||
+				arg === "approve" ||
+				arg === "reject" ||
+				arg === "prune"
+			) {
 				parsed.command = arg;
 				continue;
 			}
 			throw new Error(`unknown memory command: ${arg}`);
 		}
-		if (parsed.command === "propose") {
+		if (parsed.command === "propose" || parsed.command === "promote") {
 			if (arg === "--from-evidence") {
+				if (parsed.command !== "propose") throw new Error("--from-evidence is valid only for memory propose");
 				const value = args[index + 1];
 				if (value === undefined || value.startsWith("-")) throw new Error("--from-evidence requires an evidence id");
 				parsed.evidenceId = value;
 				index += 1;
 				continue;
 			}
-			throw new Error(`unknown memory propose argument: ${arg}`);
+			if (arg === "--from-handoff") {
+				if (parsed.command !== "promote") throw new Error("--from-handoff is valid only for memory promote");
+				const value = requireOptionValue(args, index, "--from-handoff", "a path");
+				parsed.handoffPath = value;
+				index += 1;
+				continue;
+			}
+			if (arg === "--entry") {
+				if (parsed.command !== "promote") throw new Error("--entry is valid only for memory promote");
+				parsed.entryIds.push(requireOptionValue(args, index, "--entry", "an entry id"));
+				index += 1;
+				continue;
+			}
+			if (arg === "--scope") {
+				const value = requireOptionValue(args, index, "--scope", "repo, global, runtime, or agent");
+				if (value !== "repo" && value !== "global" && value !== "runtime" && value !== "agent") {
+					throw new Error("--scope requires repo, global, runtime, or agent");
+				}
+				parsed.scope = value;
+				index += 1;
+				continue;
+			}
+			if (arg === "--repository") {
+				parsed.repositoryPath = requireOptionValue(args, index, "--repository", "a canonical absolute path");
+				index += 1;
+				continue;
+			}
+			if (arg === "--acknowledge-global") {
+				parsed.acknowledgeGlobal = true;
+				continue;
+			}
+			if (arg === "--runtime") {
+				parsed.runtimeId = requireOptionValue(args, index, "--runtime", "a runtime id");
+				index += 1;
+				continue;
+			}
+			if (arg === "--agent") {
+				parsed.agentId = requireOptionValue(args, index, "--agent", "an agent id");
+				index += 1;
+				continue;
+			}
+			throw new Error(`unknown memory ${parsed.command} argument: ${arg}`);
 		}
 		if (parsed.command === "approve" || parsed.command === "reject") {
 			if (parsed.memoryId === undefined && !arg.startsWith("-")) {
@@ -72,20 +147,79 @@ function parseMemoryArgs(args: ReadonlyArray<string>): ParsedMemoryArgs {
 		throw new Error(`unexpected memory argument: ${arg}`);
 	}
 	if (parsed.help) return parsed;
-	if (parsed.command === undefined) throw new Error("memory requires list, propose, approve, reject, or prune");
+	if (parsed.command === undefined) throw new Error("memory requires list, propose, promote, approve, reject, or prune");
 	if (parsed.command === "propose" && parsed.evidenceId === undefined) {
 		throw new Error("propose requires --from-evidence <evidenceId>");
 	}
+	if (parsed.command === "promote" && parsed.handoffPath === undefined) {
+		throw new Error("promote requires --from-handoff <path>");
+	}
 	if ((parsed.command === "approve" || parsed.command === "reject") && parsed.memoryId === undefined) {
 		throw new Error(`${parsed.command} requires a memory id`);
 	}
 	if (parsed.command === "prune" && !parsed.stale) throw new Error("prune requires --stale");
-	if (parsed.command === "list" && (parsed.evidenceId !== undefined || parsed.memoryId !== undefined || parsed.stale)) {
+	if (parsed.command === "promote" && parsed.scope === undefined) {
+		throw new Error("promote requires --scope <repo|global|runtime|agent>");
+	}
+	validateScopeArguments(parsed);
+	if (
+		parsed.command === "list" &&
+		(parsed.evidenceId !== undefined ||
+			parsed.handoffPath !== undefined ||
+			parsed.entryIds.length > 0 ||
+			parsed.memoryId !== undefined ||
+			parsed.stale ||
+			parsed.scope !== undefined)
+	) {
 		throw new Error("list does not accept extra arguments");
 	}
 	return parsed;
 }
 
+function requireOptionValue(args: ReadonlyArray<string>, index: number, option: string, expected: string): string {
+	const value = args[index + 1];
+	if (value === undefined || value.startsWith("-")) throw new Error(`${option} requires ${expected}`);
+	return value;
+}
+
+function validateScopeArguments(parsed: ParsedMemoryArgs): void {
+	const hasIdentityOption =
+		parsed.repositoryPath !== undefined ||
+		parsed.acknowledgeGlobal ||
+		parsed.runtimeId !== undefined ||
+		parsed.agentId !== undefined;
+	if (parsed.scope === undefined) {
+		if (hasIdentityOption) throw new Error("scope identity options require --scope");
+		return;
+	}
+	if (parsed.scope === "repo") {
+		if (parsed.repositoryPath === undefined)
+			throw new Error("repo scope requires --repository <canonical-absolute-path>");
+		if (parsed.acknowledgeGlobal || parsed.runtimeId !== undefined || parsed.agentId !== undefined) {
+			throw new Error("repo scope accepts only --repository");
+		}
+		return;
+	}
+	if (parsed.scope === "global") {
+		if (!parsed.acknowledgeGlobal) throw new Error("global scope requires --acknowledge-global");
+		if (parsed.repositoryPath !== undefined || parsed.runtimeId !== undefined || parsed.agentId !== undefined) {
+			throw new Error("global scope accepts only --acknowledge-global");
+		}
+		return;
+	}
+	if (parsed.scope === "runtime") {
+		if (parsed.runtimeId === undefined) throw new Error("runtime scope requires --runtime <source-runtime-id>");
+		if (parsed.repositoryPath !== undefined || parsed.acknowledgeGlobal || parsed.agentId !== undefined) {
+			throw new Error("runtime scope accepts only --runtime");
+		}
+		return;
+	}
+	if (parsed.agentId === undefined) throw new Error("agent scope requires --agent <source-agent-id>");
+	if (parsed.repositoryPath !== undefined || parsed.acknowledgeGlobal || parsed.runtimeId !== undefined) {
+		throw new Error("agent scope accepts only --agent");
+	}
+}
+
 export async function runMemoryCommand(args: ReadonlyArray<string>): Promise<number> {
 	let parsed: ParsedMemoryArgs;
 	try {
@@ -114,10 +248,40 @@ export async function runMemoryCommand(args: ReadonlyArray<string>): Promise<num
 				printError("propose requires --from-evidence <evidenceId>");
 				return 2;
 			}
-			const result = await proposeMemoryFromEvidence(dataDir, evidenceId);
+			const result = await proposeMemoryFromEvidence(dataDir, evidenceId, scopeSelection(parsed));
 			renderProposal(result.record, result.created);
 			return 0;
 		}
+		if (parsed.command === "promote") {
+			const handoffPath = parsed.handoffPath;
+			const selection = scopeSelection(parsed);
+			if (handoffPath === undefined || selection === undefined) {
+				printError("promote requires a handoff and explicit scope");
+				return 2;
+			}
+			const snapshot = await readReviewedHandoff(handoffPath);
+			const entries = selectHandoffEntries(snapshot, parsed.entryIds);
+			for (const entry of entries) {
+				const result = await proposeMemoryPromotion(
+					dataDir,
+					{
+						kind: "handoff-snapshot",
+						sessionId: snapshot.source.sessionId,
+						evidenceRefs: snapshot.source.evidenceRefs,
+						runtimeIds: snapshot.source.runtimeIds,
+						agentIds: snapshot.source.agentIds,
+						entry: handoffTaskEntry(entry),
+						redaction: {
+							replacementCount: snapshot.redaction.replacementCount,
+							sourceFields: snapshot.redaction.sourceFields,
+						},
+					},
+					selection,
+				);
+				renderProposal(result.record, result.created);
+			}
+			return 0;
+		}
 		if (parsed.command === "approve") {
 			const memoryId = parsed.memoryId;
 			if (memoryId === undefined) {
@@ -143,7 +307,7 @@ export async function runMemoryCommand(args: ReadonlyArray<string>): Promise<num
 			printOk(`pruned ${pruned.length} stale memory record${pruned.length === 1 ? "" : "s"}`);
 			return 0;
 		}
-		printError("memory requires list, propose, approve, reject, or prune");
+		printError("memory requires list, propose, promote, approve, reject, or prune");
 		return 2;
 	} catch (error) {
 		printError(error instanceof Error ? error.message : String(error));
@@ -151,14 +315,112 @@ export async function runMemoryCommand(args: ReadonlyArray<string>): Promise<num
 	}
 }
 
+function scopeSelection(parsed: ParsedMemoryArgs): MemoryScopeSelection | undefined {
+	if (parsed.scope === undefined) return undefined;
+	if (parsed.scope === "repo") {
+		const repositoryPath = parsed.repositoryPath;
+		if (repositoryPath === undefined) throw new Error("repo scope requires --repository");
+		const repository = canonicalMemoryRepositoryIdentity(repositoryPath);
+		if (repository === null || repository.key !== repositoryPath) {
+			throw new Error("--repository must be an existing canonical absolute repository path");
+		}
+		return { scope: "repo", repository };
+	}
+	if (parsed.scope === "global") {
+		if (!parsed.acknowledgeGlobal) throw new Error("global scope requires --acknowledge-global");
+		return { scope: "global", acknowledgeGlobal: true };
+	}
+	if (parsed.scope === "runtime") {
+		if (parsed.runtimeId === undefined) throw new Error("runtime scope requires --runtime");
+		return { scope: "runtime", runtime: memoryRuntimeIdentity(parsed.runtimeId) };
+	}
+	if (parsed.agentId === undefined) throw new Error("agent scope requires --agent");
+	return { scope: "agent", agent: memoryAgentIdentity(parsed.agentId) };
+}
+
+async function readReviewedHandoff(path: string): Promise<ReviewedTaskMemoryHandoffSnapshot> {
+	const info = await stat(path);
+	if (!info.isFile()) throw new Error(`task-memory handoff is not a file: ${path}`);
+	if (info.size > 1_000_000) throw new Error(`task-memory handoff exceeds 1000000 bytes: ${path}`);
+	const snapshot = parseTaskMemoryHandoffSnapshot(await readFile(path, "utf8"));
+	if (snapshot === null) throw new Error(`task-memory handoff is invalid: ${path}`);
+	if (snapshot.version !== 2) {
+		throw new Error("task-memory handoff lacks source session and evidence provenance; create a new redacted handoff");
+	}
+	return snapshot;
+}
+
+interface SelectedHandoffEntry {
+	kind: "knowledge" | "procedural";
+	entry: TaskMemoryHandoffEntry;
+}
+
+function selectHandoffEntries(
+	snapshot: ReviewedTaskMemoryHandoffSnapshot,
+	entryIds: ReadonlyArray<string>,
+): SelectedHandoffEntry[] {
+	const entries: SelectedHandoffEntry[] = [
+		...snapshot.knowledge.map((entry) => ({ kind: "knowledge" as const, entry })),
+		...snapshot.procedural.map((entry) => ({ kind: "procedural" as const, entry })),
+	];
+	if (entries.length === 0) throw new Error("task-memory handoff contains no promotable entries");
+	if (entryIds.length === 0) return entries;
+	const requested = new Set(entryIds);
+	const selected = entries.filter(({ entry }) => requested.has(entry.id));
+	const missing = [...requested].filter((id) => !selected.some(({ entry }) => entry.id === id));
+	if (missing.length > 0) throw new Error(`task-memory handoff entry not found: ${missing.join(", ")}`);
+	return selected;
+}
+
+function handoffTaskEntry(selected: SelectedHandoffEntry): {
+	id: string;
+	kind: "knowledge" | "procedural";
+	content: string;
+	createdAt: string;
+	lastTouchedAt: string;
+	injectionCount: number;
+} {
+	const createdAt = selected.entry.createdAt;
+	const lastTouchedAt = selected.entry.lastTouchedAt;
+	if (createdAt === undefined || lastTouchedAt === undefined) {
+		throw new Error(`task-memory handoff entry lacks timestamps: ${selected.entry.id}`);
+	}
+	return {
+		id: selected.entry.id,
+		kind: selected.kind,
+		content: selected.entry.content,
+		createdAt,
+		lastTouchedAt,
+		injectionCount: selected.entry.injectionCount,
+	};
+}
+
 function renderProposal(record: MemoryRecord, created: boolean): void {
 	process.stdout.write(`memory: ${record.id}\n`);
 	process.stdout.write(`status: ${created ? "proposed" : memoryStatus(record)}\n`);
 	process.stdout.write(`scope: ${record.scope}\n`);
+	if (record.repository !== undefined) process.stdout.write(`repository: ${record.repository.key}\n`);
+	if (record.runtime !== undefined) process.stdout.write(`runtime: ${record.runtime.key}\n`);
+	if (record.agent !== undefined) process.stdout.write(`agent: ${record.agent.key}\n`);
 	process.stdout.write(`key: ${record.key}\n`);
 	process.stdout.write(`evidence: ${record.evidenceRefs.join(", ")}\n`);
 	process.stdout.write(`confidence: ${record.confidence.toFixed(2)}\n`);
 	process.stdout.write(`lesson: ${record.lesson}\n`);
+	if (record.provenance !== undefined) {
+		process.stdout.write(`source: ${record.provenance.sourceKind}\n`);
+		if (record.provenance.sourceSessionId !== undefined) {
+			process.stdout.write(`source-session: ${record.provenance.sourceSessionId}\n`);
+		}
+		if (record.provenance.sourceEntryId !== undefined) {
+			process.stdout.write(`source-entry: ${record.provenance.sourceEntryId}\n`);
+		}
+		if (record.provenance.redaction !== undefined) {
+			process.stdout.write(
+				`redaction: ${record.provenance.redaction.replacementCount} replacement${record.provenance.redaction.replacementCount === 1 ? "" : "s"}; fields=${record.provenance.redaction.sourceFields.join(",") || "none"}\n`,
+			);
+		}
+	}
+	process.stdout.write(`review: clio-coder memory approve ${record.id}\n`);
 }
 
 function renderMemoryList(records: ReadonlyArray<MemoryRecord>): void {

package/src/cli/modes/json-stream.ts

@@ -4,8 +4,8 @@
  * The stream is append-oriented: it carries each piece of content exactly
  * once, as an increment while it streams and as one completed message when it
  * lands. It never repeats the growing snapshot of an in-progress message,
- * because that is quadratic in a long turn. One tool-heavy SciCode sub-step
- * wrote 802 MB of stdout, 99.3% of it `message_update` snapshots of a message
+ * because that is quadratic in a long turn. One tool-heavy headless turn wrote
+ * 802 MB of stdout, 99.3% of it `message_update` snapshots of a message
  * whose final form is 44 KB.
  *
  * The rules, in one place:

package/src/cli/modes/print.ts

@@ -1,4 +1,8 @@
 import { readClioVersion, readPiMonoVersion } from "../../core/package-root.js";
+import {
+	addResponseModelIdObservationCounts,
+	emptyResponseModelIdObservationCounts,
+} from "../../core/response-model-id.js";
 import { withRunOverrides } from "../../core/run-overrides.js";
 import {
 	type PendingSkillRequest,
@@ -187,6 +191,10 @@ function recordToolEnd(stats: HeadlessMainAgentReceiptStats, event: ChatLoopEven
 }
 
 function addRunUsage(left: RunUsageSummary, right: RunUsageSummary): RunUsageSummary {
+	const responseModelIdObservationCounts = emptyResponseModelIdObservationCounts();
+	addResponseModelIdObservationCounts(responseModelIdObservationCounts, left.responseModelIdObservationCounts);
+	addResponseModelIdObservationCounts(responseModelIdObservationCounts, right.responseModelIdObservationCounts);
+	const last = right.hadUsage ? right : left;
 	return {
 		tokens: left.tokens + right.tokens,
 		costUsd: left.costUsd + right.costUsd,
@@ -197,7 +205,10 @@ function addRunUsage(left: RunUsageSummary, right: RunUsageSummary): RunUsageSum
 		reasoning: left.reasoning + right.reasoning,
 		apiCalls: left.apiCalls + right.apiCalls,
 		hadReasoning: left.hadReasoning || right.hadReasoning,
-		hadUsage: true,
+		hadUsage: left.hadUsage || right.hadUsage,
+		responseModelIdObservationCounts,
+		lastResponseModelIdObservation: last.lastResponseModelIdObservation,
+		lastDifferingResponseModelId: last.lastDifferingResponseModelId,
 	};
 }
 

package/src/cli/run.ts

@@ -28,7 +28,7 @@ import { SafetyDomainModule } from "../domains/safety/index.js";
 import { SchedulingDomainModule } from "../domains/scheduling/index.js";
 import { SessionDomainModule } from "../domains/session/index.js";
 import type { ImageContent } from "../engine/types.js";
-import { assistantTextFromEvent } from "../tools/dispatch-event-text.js";
+import { assistantTextFromEvent, receiptResponseModelIdObservationLabel } from "../tools/dispatch-event-text.js";
 import { isToolProfileName } from "../tools/profiles.js";
 import { parseRunCliArgs, type RunCliArgs } from "./args.js";
 import { runClioCommand } from "./clio.js";
@@ -393,8 +393,27 @@ async function runDispatch(
 	let memorySection = "";
 	try {
 		const records = loadMemoryRecordsSync(clioDataDir());
+		const boundProfileName = parsed.agentProfile ?? effectiveSettings.workers.agentBindings[parsed.agentId];
+		const boundProfile = boundProfileName ? effectiveSettings.workers.profiles[boundProfileName] : undefined;
+		const configuredRuntime = (targetId: string | null | undefined): string | undefined =>
+			effectiveSettings.targets.find((target) => target.id === targetId)?.runtime;
+		const profileRuntimeId = configuredRuntime(boundProfile?.target);
+		// The memory section is compiled before fleet routing settles. Admit a
+		// runtime-scoped record only when every permitted initial and fallback
+		// route is constrained to the same runtime.
+		const memoryRuntimeId =
+			parsed.target !== undefined
+				? configuredRuntime(parsed.target)
+				: boundProfileName !== undefined
+					? parsed.agentRuntime === profileRuntimeId
+						? profileRuntimeId
+						: undefined
+					: parsed.agentRuntime;
 		memorySection = buildMemoryPromptSection(records, {
+			scopes: ["global", "repo", "runtime", "agent"],
 			activeRepository: canonicalMemoryRepositoryIdentity(process.cwd()),
+			activeRuntime: memoryRuntimeId === undefined ? null : { kind: "runtime", key: memoryRuntimeId },
+			activeAgent: { kind: "agent", key: parsed.agentId },
 		}).section;
 	} catch (err) {
 		process.stderr.write(
@@ -488,7 +507,8 @@ function formatReceipt(r: RunReceipt): string {
 	const reasoning =
 		typeof r.reasoningTokenCount === "number" && r.reasoningTokenCount > 0 ? ` reasoning=${r.reasoningTokenCount}` : "";
 	const failure = r.failureMessage ? ` error=${r.failureMessage}` : "";
-	return `receipt: ${r.runId} agent=${r.agentId} exit=${r.exitCode} target=${r.targetId} model=${r.wireModelId} tokens=${r.tokenCount}${reasoning}${failure} start=${r.startedAt} end=${r.endedAt}`;
+	const responseModelIdObservation = receiptResponseModelIdObservationLabel(r);
+	return `receipt: ${r.runId} agent=${r.agentId} exit=${r.exitCode} target=${r.targetId} requested_model_id=${r.wireModelId}${responseModelIdObservation ? ` ${responseModelIdObservation}` : ""} tokens=${r.tokenCount}${reasoning}${failure} start=${r.startedAt} end=${r.endedAt}`;
 }
 
 function mapExitCode(r: RunReceipt): number {

package/src/cli/targets.ts

@@ -1028,10 +1028,19 @@ export function residentModelsSummary(states: TargetStatus["discoveredModelState
  * capability the target reported. Saying so is the difference between a number
  * a user can plan against and one they cannot.
  */
-export function formatContextWindow(status: Pick<TargetStatus, "capabilities" | "contextWindowProvenance">): string {
+export function formatContextWindow(
+	status: Pick<TargetStatus, "capabilities" | "contextWindowProvenance"> &
+		Partial<Pick<TargetStatus, "target" | "discoveredModelStates">>,
+): string {
 	const window = status.capabilities.contextWindow;
-	return status.contextWindowProvenance === "runtime-default"
-		? `ctx ${window} (unverified runtime default)`
+	if (status.contextWindowProvenance === "runtime-default") return `ctx ${window} (unverified runtime default)`;
+	// A llama.cpp window that is one slot's share of `--ctx-size` names the
+	// split, so `ctx 196608` is not mistaken for the whole server (issue #187).
+	const slots = status.target?.defaultModel
+		? status.discoveredModelStates?.[status.target.defaultModel]?.contextSlots
+		: undefined;
+	return slots && Math.floor(slots.totalContextSize / slots.slots) === window
+		? `ctx ${window} (${slots.totalContextSize} / ${slots.slots} slots)`
 		: `ctx ${window}`;
 }
 

package/src/cli/usage.ts

@@ -1,5 +1,11 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import { join, resolve } from "node:path";
+import {
+	addResponseModelIdObservationCount,
+	emptyResponseModelIdObservationCounts,
+	type ResponseModelIdObservationCounts,
+	responseModelIdObservationCountsLabel,
+} from "../core/response-model-id.js";
 import { clioDataDir, clioStateDir } from "../core/xdg.js";
 import { loadMemoryRecordsSync, type MemoryRecord } from "../domains/memory/index.js";
 import { readEvidenceIndex } from "../domains/observability/evidence-index.js";
@@ -88,6 +94,10 @@ function emptyUsageTotals(): UsageTotals {
 	};
 }
 
+function addResponseModelIdObservation(counts: ResponseModelIdObservationCounts, call: LedgerUsageCall): void {
+	addResponseModelIdObservationCount(counts, call.responseModelIdObservation, call.apiCalls ?? 1);
+}
+
 function addUsageCall(totals: UsageTotals, call: LedgerUsageCall): void {
 	totals.apiCalls += call.apiCalls ?? 1;
 	totals.input += call.input;
@@ -321,17 +331,33 @@ export async function runUsageCommand(argv: ReadonlyArray<string>): Promise<numb
 	// Token and cost facts fold the same per-call usage the `/cost` overlay
 	// reseeds from, through the same session-domain function, so the report and
 	// the overlay cannot disagree about what a session spent.
-	const usageByModel = new Map<string, { providerId: string; modelId: string; totals: UsageTotals }>();
+	// Keyed by the model id accounting attributes the call to. A reported LM
+	// Link peer id gets its own row, while an observed omission becomes unknown.
+	// Requested ids and observation-state counts remain alongside that row.
+	const usageByModel = new Map<
+		string,
+		{
+			providerId: string;
+			attributedModelId: string;
+			requestedModelIds: Set<string>;
+			responseModelIdObservationCounts: ResponseModelIdObservationCounts;
+			totals: UsageTotals;
+		}
+	>();
 	const usageTotals = emptyUsageTotals();
 	for (const session of sessions) {
 		for (const call of session.usageCalls) {
 			addUsageCall(usageTotals, call);
-			const key = `${call.providerId}::${call.modelId}`;
+			const key = `${call.providerId}::${call.attributedModelId}`;
 			const entry = usageByModel.get(key) ?? {
 				providerId: call.providerId,
-				modelId: call.modelId,
+				attributedModelId: call.attributedModelId,
+				requestedModelIds: new Set<string>(),
+				responseModelIdObservationCounts: emptyResponseModelIdObservationCounts(),
 				totals: emptyUsageTotals(),
 			};
+			entry.requestedModelIds.add(call.requestedModelId);
+			addResponseModelIdObservation(entry.responseModelIdObservationCounts, call);
 			addUsageCall(entry.totals, call);
 			usageByModel.set(key, entry);
 		}
@@ -420,7 +446,15 @@ export async function runUsageCommand(argv: ReadonlyArray<string>): Promise<numb
 		if (presence.sessionsPresent) {
 			emit({ kind: "fact", fact: "tokens", ...usageTotals });
 			for (const row of usageRows) {
-				emit({ kind: "fact", fact: "model-usage", providerId: row.providerId, modelId: row.modelId, ...row.totals });
+				emit({
+					kind: "fact",
+					fact: "model-usage",
+					providerId: row.providerId,
+					attributedModelId: row.attributedModelId,
+					requestedModelIds: [...row.requestedModelIds].sort(),
+					responseModelIdObservationCounts: row.responseModelIdObservationCounts,
+					...row.totals,
+				});
 			}
 		}
 		for (const [tool, totals] of topTools) emit({ kind: "fact", fact: "top-tool", tool, ...totals });
@@ -479,14 +513,28 @@ export async function runUsageCommand(argv: ReadonlyArray<string>): Promise<numb
 	}
 	if (usageRows.length > 0) {
 		out("");
-		out("  tokens by model (from session ledgers, provider-reported)");
+		out("  tokens by attributed model (from session ledgers and provider-reported usage)");
 		process.stdout.write(
 			indent(
 				formatColumns([
-					["provider", "model", "calls", "input", "output", "cache read", "reasoning", "tokens", "cost"],
+					[
+						"provider",
+						"attributed model",
+						"requested model ids",
+						"response model id observation",
+						"calls",
+						"input",
+						"output",
+						"cache read",
+						"reasoning",
+						"tokens",
+						"cost",
+					],
 					...usageRows.map((row) => [
 						row.providerId,
-						row.modelId,
+						row.attributedModelId,
+						[...row.requestedModelIds].sort().join(","),
+						responseModelIdObservationCountsLabel(row.responseModelIdObservationCounts),
 						String(row.totals.apiCalls),
 						String(row.totals.input),
 						String(row.totals.output),