@iowarp/clio-coder 0.4.2 → 0.4.4

package/src/domains/middleware/skills-reminder.ts

@@ -24,7 +24,7 @@ export const SKILLS_REMINDER_REGISTRATION_ID = "observer.skills-reminder";
 
 export { SKILL_SUGGESTION_ANCHOR };
 
-export function skillsReminderMessage(installed: number, installable = 0): string {
+export function skillsReminderMessage(installed: number, installable = 0, modelActivation = false): string {
 	// Unconditional imperative, deliberately: the skill-mastery batteries
 	// showed literal local models comply with "list and check" but never act
 	// on wording that first asks them to classify the task as skill-shaped.
@@ -37,6 +37,17 @@ export function skillsReminderMessage(installed: number, installable = 0): strin
 	// operator" as the whole job, spent a 40-second turn deliberating over the
 	// suggestion, and ended without one repository read. The suggestion is one
 	// line, the task continues in the same turn, and only the operator loads.
+	// At auto-edit and full-auto the model activates installed skills itself,
+	// so the reminder must not repeat "only the operator loads a skill": the
+	// literal models this line exists for act on it over the listing footer.
+	if (modelActivation) {
+		return (
+			`[Skills] ${counts}. Start this task by listing them with context(scope="skills") ` +
+			'and checking for a match; if one matches, load it with context(scope="skills", name="<name>") and ' +
+			"continue the task in the same turn. A marketplace skill is not installed and is offered for install " +
+			"when the operator runs it. If none match, do not mention skills and continue with the task."
+		);
+	}
 	return (
 		`[Skills] ${counts}. Start this task by listing them with context(scope="skills") ` +
 		"and checking for a match; if one matches, open your reply with the line " +
@@ -55,6 +66,12 @@ export interface SkillsReminderDeps {
 	 * zero. Either count above zero arms the reminder.
 	 */
 	countInstallableSkills?(): number;
+	/**
+	 * True when the session's autonomy level lets the model activate an
+	 * installed skill itself. Absent reads as false, the operator-gated wording
+	 * every surface taught before the level became the opt-in.
+	 */
+	modelMayActivateSkills?(): boolean;
 }
 
 const NO_EFFECTS: ReadonlyArray<MiddlewareEffect> = [];
@@ -211,7 +228,19 @@ export function createSkillsReminderRegistration(deps: SkillsReminderDeps): Midd
 				return NO_EFFECTS;
 			}
 			if (installed <= 0 && installable <= 0) return NO_EFFECTS;
-			return [{ kind: "inject_reminder", severity: "info", message: skillsReminderMessage(installed, installable) }];
+			let modelActivation = false;
+			try {
+				modelActivation = deps.modelMayActivateSkills?.() ?? false;
+			} catch {
+				// An unreadable autonomy level falls back to the operator-gated wording.
+			}
+			return [
+				{
+					kind: "inject_reminder",
+					severity: "info",
+					message: skillsReminderMessage(installed, installable, modelActivation),
+				},
+			];
 		},
 	};
 }

package/src/domains/mux/detect.ts

@@ -126,12 +126,9 @@ export async function detectMux(options: DetectMuxOptions = {}): Promise<MuxDete
 		return { detection: none("panes are turned off"), client: null };
 	}
 	if (enabled === "embedded") {
-		// Embedded mode (Clio owning the pane host) is not implemented yet. An
-		// operator who picked it wanted panes, so the rung degrades to guest
-		// detection instead of refusing everything; the notice below says which
-		// mode actually runs. When the guest ladder also fails, that failure is
-		// reported on its own terms.
-		log("info", "interface.panes.enabled=embedded is not implemented yet; detecting a guest pane host instead");
+		const reason = "embedded pane hosting is not implemented; use auto or guest";
+		log("warning", reason);
+		return { detection: none(reason, [], true), client: null };
 	}
 	if (env.HERDR_ENV !== "1") {
 		return { detection: none("HERDR_ENV is not 1, so Clio is not running inside a pane host"), client: null };

package/src/domains/observability/accountability.ts

@@ -27,6 +27,8 @@ export interface AccountabilitySummary {
 	totalRuns: number;
 	firstPassRuns: number;
 	firstPassRate: number;
+	unverifiedSuccesses: number;
+	ungroundedClaims: number;
 	failureCauses: ReadonlyArray<{ tag: EvidenceTag; count: number }>;
 }
 
@@ -38,9 +40,19 @@ export interface AccountabilitySummary {
 export function summarizeEvidenceIndex(rows: ReadonlyArray<EvidenceIndexRow>): AccountabilitySummary {
 	const totalRuns = rows.length;
 	let firstPassRuns = 0;
+	let unverifiedSuccesses = 0;
+	let ungroundedClaims = 0;
 	const counts = new Map<EvidenceTag, number>();
 	for (const row of rows) {
 		if (row.firstPassSuccess) firstPassRuns += 1;
+		if (
+			row.succeeded === true &&
+			(row.tags.includes("no-validation") ||
+				row.tags.includes("proxy-validation") ||
+				row.completionEvidenceWarning === true)
+		)
+			unverifiedSuccesses += 1;
+		ungroundedClaims += row.ungroundedClaims ?? 0;
 		for (const tag of row.tags) {
 			if (!FAILURE_CAUSE_TAGS.has(tag)) continue;
 			counts.set(tag, (counts.get(tag) ?? 0) + 1);
@@ -53,6 +65,8 @@ export function summarizeEvidenceIndex(rows: ReadonlyArray<EvidenceIndexRow>): A
 		totalRuns,
 		firstPassRuns,
 		firstPassRate: totalRuns === 0 ? 0 : firstPassRuns / totalRuns,
+		unverifiedSuccesses,
+		ungroundedClaims,
 		failureCauses,
 	};
 }
@@ -60,7 +74,7 @@ export function summarizeEvidenceIndex(rows: ReadonlyArray<EvidenceIndexRow>): A
 /**
  * Read the sidecar index from the state dir and summarize it. Tolerant by way of
  * `readEvidenceIndex`: a missing or corrupt index yields the empty summary
- * (`{ totalRuns: 0, firstPassRuns: 0, firstPassRate: 0, failureCauses: [] }`).
+ * with zero counters and an empty failure-cause histogram.
  */
 export function readAccountabilitySummary(stateDir: string): AccountabilitySummary {
 	return summarizeEvidenceIndex(readEvidenceIndex(stateDir));

package/src/domains/observability/compaction-usage.ts

@@ -0,0 +1,118 @@
+/** Preserve spending from summary streams that did not produce a checkpoint. */
+
+import type { CompactionCallObservation } from "../session/compaction/compact.js";
+import { extractReasoningTokens } from "../session/context-accounting.js";
+import type { BackgroundMemoryUsageSink } from "./background-memory-usage.js";
+import { appendOutOfTurnUsageRow, type OutOfTurnUsage, type OutOfTurnUsageRow } from "./out-of-turn-usage.js";
+
+export interface CompactionUsageOrigin {
+	stateDir: string;
+	sessionId: string;
+	repoIdentity: string;
+	target: string;
+	model: string;
+}
+
+/** Failed adapter zeros cannot distinguish absent usage from a reported zero. */
+function observedUsage(call: CompactionCallObservation): OutOfTurnUsage {
+	const raw = isRecord(call.usage) ? call.usage : {};
+	const reading = (value: unknown): number | null =>
+		typeof value === "number" && Number.isFinite(value) && value >= 0 && (call.outcome === "success" || value > 0)
+			? value
+			: null;
+	const cost = isRecord(raw.cost) ? reading(raw.cost.total) : null;
+	// Adapter cost is a price estimate, not independent provider billing evidence.
+	const costUsd = cost !== null && cost > 0 ? cost : null;
+	const reasoning = extractReasoningTokens({ ...raw, reasoningTokens: undefined });
+	return {
+		input: reading(raw.input),
+		output: reading(raw.output),
+		cacheRead: reading(raw.cacheRead),
+		cacheWrite: reading(raw.cacheWrite),
+		reasoning: reasoning !== null && reasoning > 0 ? reasoning : null,
+		totalTokens: reading(raw.totalTokens),
+		costUsd,
+		costProvenance: costUsd === null ? "unknown" : "estimated",
+	};
+}
+
+/**
+ * The checkpoint is the sole accounting source on success. Call this only when
+ * no checkpoint exists; each row is one actual stream invocation, not a retry.
+ * Missing amounts remain null on disk. Numeric live counters are known subtotals.
+ */
+export function recordFailedCompactionCalls(
+	origin: CompactionUsageOrigin,
+	calls: ReadonlyArray<CompactionCallObservation>,
+	observability?: BackgroundMemoryUsageSink,
+): void {
+	for (const call of calls) {
+		const usage = observedUsage(call);
+		const row: OutOfTurnUsageRow = {
+			label: "failed-compaction",
+			callOutcome: call.outcome,
+			sessionId: origin.sessionId,
+			repoIdentity: origin.repoIdentity,
+			timestamp: call.timestamp,
+			target: origin.target,
+			attributedModelId: origin.model,
+			usage,
+			timing: { durationMs: call.durationMs },
+		};
+		appendOutOfTurnUsageRow(origin.stateDir, row, { required: true });
+		// Do not create a measured-zero live entry for a wholly unobserved call.
+		if (!Object.values(usage).some((value) => typeof value === "number" && value > 0)) continue;
+		observability?.recordTokens(
+			origin.target,
+			origin.model,
+			usage.totalTokens ?? 0,
+			usage.costUsd ?? 0,
+			{
+				input: usage.input ?? 0,
+				output: usage.output ?? 0,
+				cacheRead: usage.cacheRead ?? 0,
+				cacheWrite: usage.cacheWrite ?? 0,
+				reasoningTokens: usage.reasoning ?? 0,
+				totalTokens: usage.totalTokens ?? 0,
+				apiCalls: 1,
+			},
+			usage.costProvenance,
+			undefined,
+			"failed-compaction",
+		);
+	}
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+const USAGE_FIELDS = ["input", "output", "cacheRead", "cacheWrite", "reasoning", "totalTokens", "costUsd"] as const;
+type UsageField = (typeof USAGE_FIELDS)[number];
+
+/** Known subtotals and missing-field coverage; zero missing values are never inferred. */
+export function summarizeFailedCompactionUsage(rows: ReadonlyArray<OutOfTurnUsageRow>) {
+	const calls = rows.filter((row) => row.label === "failed-compaction");
+	const knownUsage = Object.fromEntries(USAGE_FIELDS.map((field) => [field, null])) as Record<UsageField, number | null>;
+	const erroredKnownUsage = { ...knownUsage };
+	const unobservedUsageCalls = Object.fromEntries(USAGE_FIELDS.map((field) => [field, 0])) as Record<UsageField, number>;
+	for (const row of calls) {
+		for (const field of USAGE_FIELDS) {
+			const value = row.usage[field];
+			if (value === null) unobservedUsageCalls[field] += 1;
+			else {
+				knownUsage[field] = (knownUsage[field] ?? 0) + value;
+				if (row.callOutcome === "error") erroredKnownUsage[field] = (erroredKnownUsage[field] ?? 0) + value;
+			}
+		}
+	}
+	return {
+		calls: calls.length,
+		successfulCalls: calls.filter((row) => row.callOutcome === "success").length,
+		erroredCalls: calls.filter((row) => row.callOutcome === "error").length,
+		abortedCalls: calls.filter((row) => row.callOutcome === "aborted").length,
+		knownUsage,
+		erroredKnownUsage,
+		unobservedUsageCalls,
+	};
+}

package/src/domains/observability/contract.ts

@@ -1,4 +1,10 @@
 import type { ResponseModelIdObservationCounts } from "../../core/response-model-id.js";
+import type { AgentAudience } from "../agents/spec.js";
+import type { RunToolBudgetEnvelope } from "../dispatch/budget-envelope.js";
+import type { DispatchSnapshot } from "../dispatch/contract.js";
+import type { DispatchRequestOrigin, RunKind } from "../dispatch/types.js";
+import type { TrustSummaryProjection } from "../evidence/trust-projection.js";
+import type { CanonicalTrustStatus } from "../evidence/trust-status.js";
 import type { TargetStatus } from "../providers/contract.js";
 import type { CostProvenance } from "../providers/index.js";
 import type { AccountabilitySummary } from "./accountability.js";
@@ -6,6 +12,7 @@ import type { CostAggregate, CostEntry, CostEntryLabel, UsageBreakdown } from ".
 import type { MetricsView } from "./metrics.js";
 import type { TelemetrySnapshot } from "./telemetry.js";
 import type { SessionTurnTrace } from "./trace-store.js";
+import type { WorkerProgressSnapshot } from "./worker-progress.js";
 
 export interface TokenThroughputSnapshot {
 	tokensPerSecond: number;
@@ -41,9 +48,9 @@ export interface ObservabilityNotice {
 
 /**
  * Compact lifecycle summary for a recent dispatch run. Projected from the
- * dispatch bus channels; the raw transcript, tool arguments, and worker output
- * are intentionally absent. `evidence` is populated asynchronously once the
- * forensic bundle for the run finalizes.
+ * dispatch bus channels; raw tool arguments and reasoning are absent. Worker
+ * progress is a bounded, redacted presentation of the live stream. `evidence`
+ * is populated asynchronously once the forensic bundle for the run finalizes.
  */
 export interface ObservabilityRunSummary {
 	runId: string;
@@ -51,8 +58,29 @@ export interface ObservabilityRunSummary {
 	targetId?: string;
 	modelId?: string;
 	runtimeId?: string;
-	runtimeKind?: string;
-	status: "enqueued" | "running" | "completed" | "failed" | "aborted" | "dead" | "stale";
+	runtimeKind?: RunKind;
+	status: "enqueued" | "running" | "completed" | "failed" | "aborted" | "dead" | "stale" | "cancelling" | "retrying";
+	agentAudience?: AgentAudience;
+	requestOrigin?: DispatchRequestOrigin;
+	endpoint?: { key: string; label: string; limit: number };
+	taskSummary?: string;
+	budget?: RunToolBudgetEnvelope;
+	ttftMs?: number | null;
+	node?: string;
+	gate?: { role: string; cycle: number };
+	council?: { group: string; label: string; color?: string; round: number };
+	hostVerification?: "verified" | "rejected" | "skipped" | "not_implicated";
+	trust?: TrustSummaryProjection;
+	rerouteCount?: number;
+	failoverHops?: number;
+	contextWindow?: number;
+	lastContextTokens?: number;
+	progress?: WorkerProgressSnapshot;
+	receiptId?: string;
+	retry?: { attempt: number; dueAtMs: number; reason: string };
+	steerAcknowledgement?: { receivedAtMs: number; chars: number };
+	writeRecordDowngrade?: { reason: "opaque_tool_succeeded"; tool: string; toolCallId: string };
+	phase?: { wave: number; stepId: string };
 	startedAtMs: number;
 	updatedAtMs: number;
 	finishedAtMs: number | null;
@@ -101,7 +129,23 @@ export interface ObservabilitySnapshot {
 	pendingEvidenceBuildRunIds: readonly string[];
 }
 
-export interface ObservabilityContract {
+/** Runtime readers supplied after dispatch is composed, avoiding a domain dependency cycle. */
+export interface ObservabilityRunReaders {
+	dispatchSnapshot?: () => DispatchSnapshot;
+	readReceipt?: (runId: string) => { text?: string; trust?: CanonicalTrustStatus } | null;
+}
+
+/** Run projection controls shared by the contract and the in-memory projection. */
+export interface ObservabilityRunProjection {
+	/** Bind live dispatch and receipt readers; disposal detaches this binding only. */
+	bindRunReaders(readers: ObservabilityRunReaders): () => void;
+	/** Fold retry timers and live counters from the dispatch reader. */
+	reconcileRuns(): void;
+	/** Record an explicit fleet position, including before a run's first event. */
+	setFleetPhase(runId: string, phase: NonNullable<ObservabilityRunSummary["phase"]>): void;
+}
+
+export interface ObservabilityContract extends ObservabilityRunProjection {
 	/** Raw counter + histogram view. */
 	telemetry(): TelemetrySnapshot;
 	/** Aggregated view the TUI consumes. */
@@ -114,7 +158,8 @@ export interface ObservabilityContract {
 	/** Running session cost log entries. */
 	costEntries(): ReadonlyArray<CostEntry>;
 	/**
-	 * Rolling first-pass-success rate and failure-cause histogram, aggregated
+	 * Rolling first-pass-success rate, unverified successes, ungrounded claims,
+	 * and failure-cause histogram, aggregated
 	 * from the sidecar evidence index on call. Read-only: it folds rows Slice 2
 	 * already wrote and recomputes no evidence.
 	 */

package/src/domains/observability/cost.ts

@@ -137,7 +137,7 @@ export interface UsageBreakdown {
  * the usage surfaces separate these out so an operator can see that money was
  * spent beside the session rather than inside it.
  */
-export type CostEntryLabel = "side-question" | "handoff" | "prewarm" | "background-memory";
+export type CostEntryLabel = "side-question" | "handoff" | "prewarm" | "background-memory" | "failed-compaction";
 
 export interface CostEntry {
 	providerId: string;

package/src/domains/observability/evidence-index.ts

@@ -42,6 +42,10 @@ export interface EvidenceIndexRow {
 	tags: EvidenceTag[];
 	firstPassSuccess: boolean;
 	findingCount: number;
+	/** Absent on historical rows; never infer success from firstPassSuccess. */
+	succeeded?: boolean;
+	completionEvidenceWarning?: boolean;
+	ungroundedClaims?: number;
 	/** ISO-8601 timestamp the row was written. */
 	generatedAt: string;
 }
@@ -60,6 +64,12 @@ function isEvidenceIndexRow(value: unknown): value is EvidenceIndexRow {
 		row.tags.every((tag) => typeof tag === "string") &&
 		typeof row.firstPassSuccess === "boolean" &&
 		typeof row.findingCount === "number" &&
+		(row.succeeded === undefined || typeof row.succeeded === "boolean") &&
+		(row.completionEvidenceWarning === undefined || typeof row.completionEvidenceWarning === "boolean") &&
+		(row.ungroundedClaims === undefined ||
+			(typeof row.ungroundedClaims === "number" &&
+				Number.isSafeInteger(row.ungroundedClaims) &&
+				row.ungroundedClaims >= 0)) &&
 		typeof row.generatedAt === "string"
 	);
 }

package/src/domains/observability/extension.ts

@@ -37,6 +37,11 @@ type DispatchTerminalLike = {
 	[K in keyof DispatchCompletedPayload]?: DispatchCompletedPayload[K] | undefined;
 };
 
+/** Pre-admission failures have an announced run id but never create a run ledger. */
+export function dispatchHasEvidenceLedger(payload: DispatchTerminalLike): boolean {
+	return payload.lineage !== undefined;
+}
+
 function recordDispatchCost(
 	telemetry: ReturnType<typeof createTelemetry>,
 	cost: ReturnType<typeof createCostTracker>,
@@ -125,6 +130,11 @@ function evidenceIndexRow(
 		tags: [...tags],
 		firstPassSuccess,
 		findingCount: result.findings.length,
+		succeeded,
+		completionEvidenceWarning: result.findings.some(
+			(finding) => finding.tag === "completion-evidence" && finding.severity === "warn",
+		),
+		ungroundedClaims: result.ungroundedClaims,
 		generatedAt: new Date().toISOString(),
 	};
 }
@@ -173,11 +183,7 @@ export function createObservabilityBundle(
 		projection.evidenceBuildStarted(runId);
 		const build = buildAndIndexEvidence(runId, succeeded, attempt, {
 			onReady: (id, evidence) => {
-				projection.evidenceBuildSucceeded(id, evidence);
-				// The same fact, once, for listeners outside this closure (the ACP
-				// server forwards it as the opt-in `accountability.evidenceReady`
-				// kind). The payload spreads the evidence object the projection just
-				// received rather than rebuilding it, so the two cannot drift.
+				// The projection and ACP consume the same evidence-ready event.
 				context.bus.emit(BusChannels.AccountabilityEvidenceReady, { runId: id, ...evidence });
 			},
 			onFailed: (id, message) => projection.evidenceBuildFailed(id, message),
@@ -222,7 +228,7 @@ export function createObservabilityBundle(
 					recordDispatchCost(telemetry, cost, payload);
 					// A failed run is never a first-pass success; still build the
 					// bundle so its failure-cause tags exist for the index.
-					if (typeof payload.runId === "string" && payload.runId.length > 0) {
+					if (typeof payload.runId === "string" && payload.runId.length > 0 && dispatchHasEvidenceLedger(payload)) {
 						trackBuild(payload.runId, false, payload.lineage?.attempt);
 					}
 				}),
@@ -281,6 +287,9 @@ export function createObservabilityBundle(
 			telemetry.record("histogram", "tokens.ttft_ms", snapshot.ttftMs ?? 0);
 			projection.refresh();
 		},
+		bindRunReaders: (readers) => projection.bindRunReaders(readers),
+		reconcileRuns: () => projection.reconcileRuns(),
+		setFleetPhase: (runId, phase) => projection.setFleetPhase(runId, phase),
 		snapshot: () => projection.snapshot(),
 		subscribe: (listener) => projection.subscribe(listener),
 	};

package/src/domains/observability/out-of-turn-usage.ts

@@ -27,7 +27,7 @@
  * skipped, never fatal.
  */
 
-import { closeSync, mkdirSync, openSync, readFileSync, writeSync } from "node:fs";
+import { closeSync, fsyncSync, mkdirSync, openSync, readFileSync, writeSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { safeResourceWrite } from "../../core/safe-resource-write.js";
 import { withStateFileLockSync } from "../../core/state-file-lock.js";
@@ -74,13 +74,13 @@ export interface OutOfTurnPromptCache {
 
 /** Provider-reported usage for one out-of-turn call. */
 export interface OutOfTurnUsage {
-	input: number;
-	output: number;
-	cacheRead: number;
-	cacheWrite: number;
-	reasoning: number;
-	totalTokens: number;
-	costUsd: number;
+	input: number | null;
+	output: number | null;
+	cacheRead: number | null;
+	cacheWrite: number | null;
+	reasoning: number | null;
+	totalTokens: number | null;
+	costUsd: number | null;
 	costProvenance: CostProvenance;
 }
 
@@ -97,6 +97,8 @@ export interface OutOfTurnUsageRow {
 	target: string;
 	attributedModelId: string;
 	usage: OutOfTurnUsage;
+	/** New failed-compaction rows preserve unknown usage as null. Legacy rows are unchanged. */
+	callOutcome?: "success" | "error" | "aborted";
 	/** Present when the caller measured the call. */
 	timing?: OutOfTurnTiming;
 	/** Present when the serving backend reported prefill facts. */
@@ -115,21 +117,31 @@ export function outOfTurnUsagePath(stateDir: string): string {
 let appendsSinceBoundCheck = BOUND_CHECK_INTERVAL;
 
 /**
- * Append one priced out-of-turn call. Never throws: this runs on the same path
- * that answers an operator's side question, and a failed bookkeeping write must
- * not take the answer down with it.
+ * Append one out-of-turn call. Optional bookkeeping keeps its existing diagnostic
+ * write policy. Required failed-compaction records flush the append and throw on
+ * a failed or incomplete write, so their caller cannot report recorded spending.
  */
-export function appendOutOfTurnUsageRow(stateDir: string, row: OutOfTurnUsageRow): void {
+export function appendOutOfTurnUsageRow(
+	stateDir: string,
+	row: OutOfTurnUsageRow,
+	options: { required?: boolean } = {},
+): void {
 	const path = outOfTurnUsagePath(stateDir);
 	try {
 		mkdirSync(dirname(path), { recursive: true });
 		const fd = openSync(path, "a");
 		try {
-			writeSync(fd, `${JSON.stringify(row)}\n`);
+			const line = `${JSON.stringify(row)}\n`;
+			const written = writeSync(fd, line);
+			if (options.required) {
+				if (written !== Buffer.byteLength(line)) throw new Error("incomplete usage row write");
+				fsyncSync(fd);
+			}
 		} finally {
 			closeSync(fd);
 		}
 	} catch (error) {
+		if (options.required) throw new Error(`compaction usage row not written: ${messageOf(error)}`, { cause: error });
 		process.stderr.write(`[clio-coder:usage] out-of-turn usage row not written: ${messageOf(error)}\n`);
 		return;
 	}
@@ -205,11 +217,25 @@ export function readOutOfTurnUsageRows(stateDir: string): OutOfTurnUsageReadResu
 function asOutOfTurnUsageRow(value: unknown): OutOfTurnUsageRow | null {
 	if (!isRecord(value)) return null;
 	const label = value.label;
-	if (label !== "side-question" && label !== "handoff" && label !== "prewarm" && label !== "background-memory")
+	if (
+		label !== "side-question" &&
+		label !== "handoff" &&
+		label !== "prewarm" &&
+		label !== "background-memory" &&
+		label !== "failed-compaction"
+	)
 		return null;
 	if (typeof value.timestamp !== "string" || value.timestamp.length === 0) return null;
 	if (!isRecord(value.usage)) return null;
 	const usage = value.usage;
+	if (
+		label === "failed-compaction" &&
+		value.callOutcome !== "success" &&
+		value.callOutcome !== "error" &&
+		value.callOutcome !== "aborted"
+	)
+		return null;
+	const reading = label === "failed-compaction" ? nullableNumber : numberOr0;
 	const timing = asTiming(value.timing);
 	const promptCache = asPromptCache(value.promptCache);
 	return {
@@ -223,15 +249,16 @@ function asOutOfTurnUsageRow(value: unknown): OutOfTurnUsageRow | null {
 				? value.attributedModelId
 				: "unknown",
 		usage: {
-			input: numberOr0(usage.input),
-			output: numberOr0(usage.output),
-			cacheRead: numberOr0(usage.cacheRead),
-			cacheWrite: numberOr0(usage.cacheWrite),
-			reasoning: numberOr0(usage.reasoning),
-			totalTokens: numberOr0(usage.totalTokens),
-			costUsd: numberOr0(usage.costUsd),
+			input: reading(usage.input),
+			output: reading(usage.output),
+			cacheRead: reading(usage.cacheRead),
+			cacheWrite: reading(usage.cacheWrite),
+			reasoning: reading(usage.reasoning),
+			totalTokens: reading(usage.totalTokens),
+			costUsd: reading(usage.costUsd),
 			costProvenance: asCostProvenance(usage.costProvenance),
 		},
+		...(label === "failed-compaction" ? { callOutcome: value.callOutcome as "success" | "error" | "aborted" } : {}),
 		...(timing === null ? {} : { timing }),
 		...(promptCache === null ? {} : { promptCache }),
 	};
@@ -259,6 +286,10 @@ function asCostProvenance(value: unknown): CostProvenance {
 	return value === "known" || value === "known_free" || value === "estimated" ? value : "unknown";
 }
 
+function nullableNumber(value: unknown): number | null {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+
 function numberOr0(value: unknown): number {
 	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
 }