dsh-token-total 1.0.0 → 1.0.2

package/lib/index.js

@@ -89,6 +89,7 @@ function aggregateSamples(samples, filter, granularity = "day") {
 		outputTokens: 0,
 		cacheTokens: 0,
 		requests: 0,
+		failures: 0,
 		turns: 0,
 		cacheHit: 0,
 		cacheMiss: 0,
@@ -104,11 +105,14 @@ function aggregateSamples(samples, filter, granularity = "day") {
 	const providerTotals = /* @__PURE__ */ new Map();
 	const modelCache = /* @__PURE__ */ new Map();
 	const providerCache = /* @__PURE__ */ new Map();
+	const modelProviderTotals = /* @__PURE__ */ new Map();
+	const providerModelTotals = /* @__PURE__ */ new Map();
 	const active = /* @__PURE__ */ new Set();
 	const bucketByModel = /* @__PURE__ */ new Map();
 	const bucketByProvider = /* @__PURE__ */ new Map();
 	const bucketTotals = /* @__PURE__ */ new Map();
 	const bucketRequests = /* @__PURE__ */ new Map();
+	const bucketFailures = /* @__PURE__ */ new Map();
 	const bucketTurns = /* @__PURE__ */ new Map();
 	const bucketCacheHit = /* @__PURE__ */ new Map();
 	const bucketCacheMiss = /* @__PURE__ */ new Map();
@@ -121,11 +125,16 @@ function aggregateSamples(samples, filter, granularity = "day") {
 			continue;
 		}
 		const total = sample.inputTokens + sample.outputTokens + sample.cacheReadTokens + sample.cacheWriteTokens;
+		const hasTokenDelta = sample.inputTokens !== 0 || sample.outputTokens !== 0 || sample.cacheReadTokens !== 0 || sample.cacheWriteTokens !== 0;
+		if (sample.failed) {
+			out.failures++;
+			bucketFailures.set(bucket, (bucketFailures.get(bucket) ?? 0) + 1);
+		}
 		if (sample.request) {
 			out.requests++;
 			bucketRequests.set(bucket, (bucketRequests.get(bucket) ?? 0) + 1);
-			if (total <= 0) continue;
 		}
+		if (!hasTokenDelta) continue;
 		out.tokens += total;
 		out.inputTokens += sample.inputTokens;
 		out.outputTokens += sample.outputTokens;
@@ -141,6 +150,18 @@ function aggregateSamples(samples, filter, granularity = "day") {
 		modelProviders.set(model, sources);
 		modelTotals.set(model, (modelTotals.get(model) ?? 0) + total);
 		providerTotals.set(provider, (providerTotals.get(provider) ?? 0) + total);
+		let modelSplitMap = modelProviderTotals.get(model);
+		if (!modelSplitMap) {
+			modelSplitMap = /* @__PURE__ */ new Map();
+			modelProviderTotals.set(model, modelSplitMap);
+		}
+		modelSplitMap.set(provider, (modelSplitMap.get(provider) ?? 0) + total);
+		let providerSplitMap = providerModelTotals.get(provider);
+		if (!providerSplitMap) {
+			providerSplitMap = /* @__PURE__ */ new Map();
+			providerModelTotals.set(provider, providerSplitMap);
+		}
+		providerSplitMap.set(model, (providerSplitMap.get(model) ?? 0) + total);
 		const mc = modelCache.get(model) ?? {
 			hit: 0,
 			miss: 0
@@ -182,13 +203,14 @@ function aggregateSamples(samples, filter, granularity = "day") {
 			byModel: byModelObj,
 			byProvider: byProviderObj,
 			requests: bucketRequests.get(bucket) ?? 0,
+			failures: bucketFailures.get(bucket) ?? 0,
 			turns: bucketTurns.get(bucket) ?? 0,
 			cacheHit: bucketCacheHit.get(bucket) ?? 0,
 			cacheMiss: bucketCacheMiss.get(bucket) ?? 0
 		});
 	}
-	out.models = modelsSorted(modelTotals, modelCache, modelProviders);
-	out.providers = providersSorted(providerTotals, providerCache);
+	out.models = modelsSorted(modelTotals, modelCache, modelProviders, modelProviderTotals);
+	out.providers = providersSorted(providerTotals, providerCache, providerModelTotals);
 	out.topModel = out.models[0]?.model ?? "";
 	out.topProvider = out.providers[0]?.provider ?? "";
 	if (out.tokens > 0) {
@@ -197,7 +219,7 @@ function aggregateSamples(samples, filter, granularity = "day") {
 	}
 	return out;
 }
-function modelsSorted(totals, cache, sources) {
+function modelsSorted(totals, cache, sources, splits) {
 	const out = [];
 	for (const [model, tokens] of totals) {
 		const c = cache.get(model);
@@ -206,6 +228,7 @@ function modelsSorted(totals, cache, sources) {
 			model,
 			provider: providers.length === 1 ? providers[0] : "",
 			providers,
+			providerTokens: providerSplit(splits.get(model)),
 			tokens,
 			percent: 0,
 			cacheHit: c?.hit ?? 0,
@@ -215,7 +238,7 @@ function modelsSorted(totals, cache, sources) {
 	out.sort((a, b) => b.tokens - a.tokens || a.model.localeCompare(b.model));
 	return out;
 }
-function providersSorted(totals, cache) {
+function providersSorted(totals, cache, splits) {
 	const out = [];
 	for (const [provider, tokens] of totals) {
 		const c = cache.get(provider);
@@ -224,12 +247,30 @@ function providersSorted(totals, cache) {
 			tokens,
 			percent: 0,
 			cacheHit: c?.hit ?? 0,
-			cacheMiss: c?.miss ?? 0
+			cacheMiss: c?.miss ?? 0,
+			modelTokens: modelSplit(splits.get(provider))
 		});
 	}
 	out.sort((a, b) => b.tokens - a.tokens);
 	return out;
 }
+/** One model's per-provider split, largest first (ties by id for a stable
+*  order across refreshes). Empty when the response carries no cross data. */
+function providerSplit(split) {
+	if (split === void 0) return [];
+	return [...split].map(([provider, tokens]) => ({
+		provider,
+		tokens
+	})).sort((a, b) => b.tokens - a.tokens || a.provider.localeCompare(b.provider));
+}
+/** One provider's per-model split, largest first (ties by name). */
+function modelSplit(split) {
+	if (split === void 0) return [];
+	return [...split].map(([model, tokens]) => ({
+		model,
+		tokens
+	})).sort((a, b) => b.tokens - a.tokens || a.model.localeCompare(b.model));
+}
 //#endregion
 //#region src/store.ts
 /**
@@ -260,6 +301,7 @@ const usageDayRowSchema = z.object({
 	cacheReadTokens: z.number(),
 	cacheWriteTokens: z.number(),
 	requests: z.number(),
+	failures: z.number().default(0),
 	turns: z.number(),
 	lastSeen: z.number()
 });
@@ -272,6 +314,7 @@ const usageHourRowSchema = z.object({
 	cacheReadTokens: z.number(),
 	cacheWriteTokens: z.number(),
 	requests: z.number(),
+	failures: z.number().default(0),
 	turns: z.number(),
 	lastSeen: z.number()
 });
@@ -297,13 +340,18 @@ const usageHistoryDomain = defineDomain({
 			liveFirstSeq: z.record(z.string(), z.number()).optional(),
 			hoursBackfilledSessions: z.array(z.string()).optional(),
 			hoursLiveFirstSeq: z.record(z.string(), z.number()).optional(),
-			hoursReady: z.boolean().optional()
+			hoursReady: z.boolean().optional(),
+			failuresBackfilledSessions: z.array(z.string()).optional(),
+			failuresLiveFirstSeq: z.record(z.string(), z.number()).optional(),
+			failuresReady: z.boolean().optional()
 		}),
 		initial: {
 			backfilledSessions: [],
 			liveFirstSeq: {},
 			hoursBackfilledSessions: [],
-			hoursLiveFirstSeq: {}
+			hoursLiveFirstSeq: {},
+			failuresBackfilledSessions: [],
+			failuresLiveFirstSeq: {}
 		}
 	},
 	tables: {
@@ -505,6 +553,78 @@ var UsageStore = class {
 		this.markChain = write.then(() => void 0, () => void 0);
 		return write;
 	}
+	/** Session ids already replayed into the FAILURE counter (third cursor
+	*  pair, same reason as the hour pair: the day and hour cursors were
+	*  already full when the counter arrived). */
+	async failuresSeenSessions() {
+		await this.ready;
+		return new Set(this.cursor()?.failuresBackfilledSessions ?? []);
+	}
+	/** Per-session seq of the first LIVE-observed event, failure-counter share. */
+	async failuresLiveSequences() {
+		await this.ready;
+		return new Map(Object.entries(this.cursor()?.failuresLiveFirstSeq ?? {}));
+	}
+	/** Persist failure-pass replay progress (merges; serialized on the same
+	*  chain as every other cursor write). */
+	async markFailuresSeenSessions(ids) {
+		const write = this.markChain.then(async () => {
+			await this.ready;
+			const value = this.requireCursor();
+			const seen = new Set(value.failuresBackfilledSessions ?? []);
+			for (const id of ids) seen.add(id);
+			await this.domainHandle?.global?.set({
+				...value,
+				backfilledSessions: value.backfilledSessions ?? [],
+				failuresBackfilledSessions: [...seen]
+			});
+		});
+		this.markChain = write.then(() => void 0, () => void 0);
+		return write;
+	}
+	/** Record the failure-pass live boundary per session (earliest wins). */
+	async markFailuresLiveSequences(entries) {
+		const write = this.markChain.then(async () => {
+			await this.ready;
+			const value = this.requireCursor();
+			const merged = { ...value.failuresLiveFirstSeq ?? {} };
+			let changed = false;
+			for (const [id, seq] of entries) {
+				const prev = merged[id];
+				if (prev === void 0 || seq < prev) {
+					merged[id] = seq;
+					changed = true;
+				}
+			}
+			if (!changed) return;
+			await this.domainHandle?.global?.set({
+				...value,
+				backfilledSessions: value.backfilledSessions ?? [],
+				failuresLiveFirstSeq: merged
+			});
+		});
+		this.markChain = write.then(() => void 0, () => void 0);
+		return write;
+	}
+	/** Whether the failure counter covers every replayable session. */
+	async failuresReady() {
+		await this.ready;
+		return this.cursor()?.failuresReady === true;
+	}
+	/** Mark the failure history complete; the upgrade pass then never reruns. */
+	async markFailuresReady() {
+		const write = this.markChain.then(async () => {
+			await this.ready;
+			const value = this.requireCursor();
+			await this.domainHandle?.global?.set({
+				...value,
+				backfilledSessions: value.backfilledSessions ?? [],
+				failuresReady: true
+			});
+		});
+		this.markChain = write.then(() => void 0, () => void 0);
+		return write;
+	}
 	/** Drop every row and the whole cursor, re-bounding each named session at
 	*  its WIPE-TIME WATERMARK (the store-rebuild escape hatch for corrupted
 	*  history or attribution-logic upgrades).
@@ -532,7 +652,10 @@ var UsageStore = class {
 				liveFirstSeq,
 				hoursBackfilledSessions: [],
 				hoursLiveFirstSeq: { ...liveFirstSeq },
-				hoursReady: false
+				hoursReady: false,
+				failuresBackfilledSessions: [],
+				failuresLiveFirstSeq: { ...liveFirstSeq },
+				failuresReady: false
 			});
 			for (const key of [...table.keys()]) await table.delete(key);
 			for (const key of [...hourTable.keys()]) await hourTable.delete(key);
@@ -589,6 +712,22 @@ var UsageStore = class {
 		const target = this.targetsOf(sample);
 		await this.recordInto(this.requireHourTable(), hourRowKey(hour, target.provider, target.model), emptyHourRow(hour, target.provider, target.model), sample);
 	}
+	/** Fold ONLY the failure count of a sample into the day and hour rows. The
+	*  failure upgrade pass uses this: its replay walks logs the token passes
+	*  already consumed, so the tokens and the request marker must not be added
+	*  a second time — only the failed-call counter may move. */
+	async recordFailure(sample) {
+		await this.record({
+			day: sample.day,
+			hour: sample.hour,
+			model: sample.model,
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			cacheWriteTokens: 0,
+			failed: true
+		});
+	}
 	/** The row identity a sample lands on: turn markers use the synthetic
 	*  (turns) model, unlabelled calls the (unknown) one. */
 	targetsOf(sample) {
@@ -666,6 +805,7 @@ function emptyCounters(provider, model) {
 		cacheReadTokens: 0,
 		cacheWriteTokens: 0,
 		requests: 0,
+		failures: 0,
 		turns: 0,
 		lastSeen: Date.now()
 	};
@@ -686,6 +826,7 @@ function accumulate(base, sample) {
 	return {
 		...base,
 		requests: base.requests + (sample.request ? 1 : 0),
+		failures: (base.failures ?? 0) + (sample.failed ? 1 : 0),
 		inputTokens: base.inputTokens + sample.inputTokens,
 		outputTokens: base.outputTokens + sample.outputTokens,
 		cacheReadTokens: base.cacheReadTokens + sample.cacheReadTokens,
@@ -725,6 +866,10 @@ var UsageFold = class {
 			cacheWriteTokens: 0,
 			turn: true
 		};
+		if (ev.type === "llm/retry-started") {
+			const key = this.keyOf(ev);
+			if (key !== null) this.seen.delete(key);
+		}
 		if (ev.type === "step/start" || ev.type === "llm/retry-started") return {
 			day: dayKey(ev.time),
 			hour: hourKey(ev.time),
@@ -739,9 +884,18 @@ var UsageFold = class {
 			const usage = data.chunk?.type === "usage" ? data.chunk.usage : void 0;
 			return usage ? this.replaceSample(ev, usage) : null;
 		}
-		if (ev.type === "assistant/message") {
+		if (ev.type === "assistant/message" || ev.type === "assistant/attempt") {
 			const data = ev.data;
-			return data.usage ? this.replaceSample(ev, data.usage) : null;
+			let usage = ev.type === "assistant/message" ? data.usage : void 0;
+			if (usage === void 0 && Array.isArray(data.stream)) for (let i = data.stream.length - 1; i >= 0; i--) {
+				const record = data.stream[i];
+				if (record?.type === "chunk" && record.chunk?.type === "usage") {
+					usage = record.chunk.usage;
+					break;
+				}
+			}
+			if (ev.type === "assistant/attempt") return this.attemptSample(ev, usage);
+			return usage ? this.replaceSample(ev, usage) : null;
 		}
 		if (ev.type === "compaction/summary") return this.compactionSample(ev);
 		return null;
@@ -749,21 +903,64 @@ var UsageFold = class {
 	replaceSample(ev, usage) {
 		const usage2 = usage;
 		if (!usage2) return null;
-		if ((usage2.inputTokens ?? 0) + (usage2.outputTokens ?? 0) + (usage2.cacheReadTokens ?? 0) + (usage2.cacheWriteTokens ?? 0) <= 0) return null;
 		const key = this.keyOf(ev);
 		const sample = {
 			day: dayKey(ev.time),
 			hour: hourKey(ev.time),
-			inputTokens: usage2.inputTokens,
-			outputTokens: usage2.outputTokens,
+			inputTokens: usage2.inputTokens ?? 0,
+			outputTokens: usage2.outputTokens ?? 0,
 			cacheReadTokens: usage2.cacheReadTokens ?? 0,
 			cacheWriteTokens: usage2.cacheWriteTokens ?? 0
 		};
+		const prev = key === null ? void 0 : this.seen.get(key);
+		if (!prev && sample.inputTokens + sample.outputTokens + sample.cacheReadTokens + sample.cacheWriteTokens <= 0) return null;
 		if (key === null) return sample;
-		const prev = this.seen.get(key);
 		this.seen.set(key, sample);
-		if (prev) return null;
-		return { ...sample };
+		if (prev) {
+			const correction = {
+				day: prev.day,
+				hour: prev.hour,
+				model: prev.model,
+				inputTokens: sample.inputTokens - prev.inputTokens,
+				outputTokens: sample.outputTokens - prev.outputTokens,
+				cacheReadTokens: sample.cacheReadTokens - prev.cacheReadTokens,
+				cacheWriteTokens: sample.cacheWriteTokens - prev.cacheWriteTokens
+			};
+			sample.day = prev.day;
+			sample.hour = prev.hour;
+			sample.model = prev.model;
+			if (correction.inputTokens === 0 && correction.outputTokens === 0 && correction.cacheReadTokens === 0 && correction.cacheWriteTokens === 0) return null;
+			return correction;
+		}
+		const emitted = { ...sample };
+		this.seen.set(key, emitted);
+		return emitted;
+	}
+	/**
+	* Fold one `assistant/attempt` — a provider call that failed. Tokens follow
+	* the same last-report-wins rule as a committed message (the attempt's
+	* stream is the call's final word, so a usage chunk seen mid-stream is
+	* replaced or corrected, never added twice), but the call must ALWAYS be
+	* counted as one failure: `replaceSample` drops an all-zero first report,
+	* which is correct for the token buckets and would silently lose the
+	* failure. A failed call that reported no usage therefore contributes a
+	* zero-token failure marker instead of a null.
+	*/
+	attemptSample(ev, usage) {
+		const sample = this.replaceSample(ev, usage);
+		if (sample) {
+			sample.failed = true;
+			return sample;
+		}
+		return {
+			day: dayKey(ev.time),
+			hour: hourKey(ev.time),
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			cacheWriteTokens: 0,
+			failed: true
+		};
 	}
 	/**
 	* Fold one `compaction/summary` — the one place a provider call's usage
@@ -906,6 +1103,9 @@ var UsageCollector = class UsageCollector {
 				this.store.markHoursLiveSequences(batch).catch(() => {
 					this.status.recordFailures++;
 				});
+				this.store.markFailuresLiveSequences(batch).catch(() => {
+					this.status.recordFailures++;
+				});
 			}
 		});
 	}
@@ -1029,9 +1229,16 @@ var UsageCollector = class UsageCollector {
 	async backfillHours(persistence, sessions, signal) {
 		await this.scan(persistence, sessions, signal, "hours");
 	}
-	/** Shared replay engine behind {@link backfill} and {@link backfillHours}.
-	*  `target` selects the cursor pair, the write function, and the cursor
-	*  the completed sessions land in. */
+	/** The failure upgrade pass: replay every session the FAILURE cursors have
+	*  not seen, counting only failed calls. Neither the day nor the hour
+	*  cursor covers this counter (both were full when it arrived), and the
+	*  replay must not re-add tokens or requests. */
+	async backfillFailures(persistence, sessions, signal) {
+		await this.scan(persistence, sessions, signal, "failures");
+	}
+	/** Shared replay engine behind {@link backfill}, {@link backfillHours} and
+	*  {@link backfillFailures}. `target` selects the cursor pair, the write
+	*  function, and the cursor the completed sessions land in. */
 	async scan(persistence, sessions, signal, target) {
 		if (this.status.running) return;
 		if (signal?.aborted) return;
@@ -1043,16 +1250,16 @@ var UsageCollector = class UsageCollector {
 				if (snap !== null && typeof snap === "object" && "header" in snap && snap.header !== null && typeof snap.header === "object" && typeof snap.header.id === "string") return snap.header;
 				return item;
 			}).filter((h) => typeof h?.id === "string" && h.id !== "");
-			const seen = target === "hours" ? await this.store.hoursSeenSessions() : await this.store.seenSessions();
+			const seen = target === "hours" ? await this.store.hoursSeenSessions() : target === "failures" ? await this.store.failuresSeenSessions() : await this.store.seenSessions();
 			const dayCursorWasEmpty = seen.size === 0;
-			const liveSeq = target === "hours" ? await this.store.hoursLiveSequences() : await this.store.liveSequences();
+			const liveSeq = target === "hours" ? await this.store.hoursLiveSequences() : target === "failures" ? await this.store.failuresLiveSequences() : await this.store.liveSequences();
 			const targets = headers.filter((h) => !seen.has(h.id));
 			this.status.total = targets.length;
 			this.status.done = 0;
 			const concurrency = this.options.backfillConcurrency ?? 4;
 			let next = 0;
 			const completed = [];
-			const writeSample = target === "hours" ? (sample) => this.store.recordHours(sample) : (sample) => this.store.record(sample);
+			const writeSample = target === "hours" ? (sample) => this.store.recordHours(sample) : target === "failures" ? (sample) => this.store.recordFailure(sample) : (sample) => this.store.record(sample);
 			const flushCompleted = async () => {
 				if (completed.length === 0) return;
 				const batch = completed.splice(0, completed.length);
@@ -1060,8 +1267,13 @@ var UsageCollector = class UsageCollector {
 					await this.store.markHoursSeenSessions(batch);
 					return;
 				}
+				if (target === "failures") {
+					await this.store.markFailuresSeenSessions(batch);
+					return;
+				}
 				await this.store.markSeenSessions(batch);
 				await this.store.markHoursSeenSessions(batch);
+				await this.store.markFailuresSeenSessions(batch);
 			};
 			const worker = async () => {
 				for (;;) {
@@ -1142,7 +1354,9 @@ var UsageCollector = class UsageCollector {
 			};
 			await Promise.all(Array.from({ length: Math.min(concurrency, Math.max(1, targets.length)) }, worker));
 			await flushCompleted();
-			if ((target === "hours" || dayCursorWasEmpty) && !signal?.aborted && this.status.error === void 0) await this.store.markHoursReady();
+			const clean = !signal?.aborted && this.status.error === void 0;
+			if ((target === "hours" || dayCursorWasEmpty) && clean) await this.store.markHoursReady();
+			if ((target === "failures" || dayCursorWasEmpty) && clean) await this.store.markFailuresReady();
 		} finally {
 			this.status.running = false;
 		}
@@ -1167,6 +1381,34 @@ async function lookup(read, timeoutMs) {
 		clearTimeout(timer);
 	}
 }
+/** Resolve provider route ids to the labels the model selector shows. Both
+*  catalogs are presentational and synchronous on the host runtime, so this is
+*  a plain in-process read rather than a per-request lookup: a missing service,
+*  a throwing adapter, or an unexpected promise all resolve to an empty map and
+*  every surface falls back to the raw historical route id. */
+function resolveProviderNames(llm) {
+	const names = Object.create(null);
+	if (!llm) return names;
+	try {
+		for (const provider of catalog(llm.listProviders?.())) {
+			const name = provider.name?.trim();
+			if (provider.id && name) names[provider.id] = name;
+		}
+	} catch {}
+	try {
+		for (const entry of catalog(llm.listConfigurableProviders?.())) {
+			const name = entry.displayName?.trim();
+			if (entry.provider && name && names[entry.provider] === void 0) names[entry.provider] = name;
+		}
+	} catch {}
+	return names;
+}
+/** Both catalogs are declared synchronous, but a host that publishes them over
+*  a remote face would hand back a promise; treat anything that is not an array
+*  as "no metadata" instead of throwing mid-query. */
+function catalog(value) {
+	return Array.isArray(value) ? value : [];
+}
 /** Resolve each distinct route once per range query. Unknown/deleted providers
 *  fall back to their bare historical model names in aggregateSamples(). */
 async function resolveModelNames(modelRefs, llm) {
@@ -1451,7 +1693,7 @@ function granularityOf(range) {
 async function aggregateRange(store, from, to, granularity = "day", llm) {
 	const rows = granularity === "hour" ? await store.rangeHourRows(from, to) : await store.rangeRows(from, to);
 	const names = await resolveModelNames(rows.filter((row) => row.inputTokens + row.outputTokens + row.cacheReadTokens + row.cacheWriteTokens > 0).map((row) => row.model), llm);
-	return aggregateSamples((function* () {
+	const stats = aggregateSamples((function* () {
 		for (const row of rows) {
 			const hour = "hour" in row ? row.hour : void 0;
 			const day = hour === void 0 ? row.day : hour.slice(0, 10);
@@ -1475,6 +1717,16 @@ async function aggregateRange(store, from, to, granularity = "day", llm) {
 				cacheWriteTokens: 0,
 				request: true
 			};
+			for (let i = 0; i < (row.failures ?? 0); i++) yield {
+				day,
+				hour,
+				model: row.model,
+				inputTokens: 0,
+				outputTokens: 0,
+				cacheReadTokens: 0,
+				cacheWriteTokens: 0,
+				failed: true
+			};
 			for (let i = 0; i < row.turns; i++) yield {
 				day,
 				hour,
@@ -1489,6 +1741,14 @@ async function aggregateRange(store, from, to, granularity = "day", llm) {
 		from,
 		to
 	}, granularity);
+	const resolved = resolveProviderNames(llm);
+	const providerNames = Object.create(null);
+	for (const provider of stats.providers) {
+		const label = resolved[provider.provider];
+		if (label !== void 0) providerNames[provider.provider] = label;
+	}
+	if (Object.keys(providerNames).length > 0) stats.providerNames = providerNames;
+	return stats;
 }
 /** Build the single fenced prefix route serving the /token-total/api JSON RPC.
 *  The host mounts it via `ctx.webServer.register` (which takes ONE WebRoute,
@@ -1591,19 +1851,21 @@ function headerOf(item) {
 	const row = item;
 	return typeof row?.id === "string" && row.id !== "" ? row : null;
 }
+function inheritedCount(cut) {
+	return typeof cut === "number" && Number.isSafeInteger(cut) && cut >= 0 ? cut : 0;
+}
 /** Read one stored session's events through whichever persistence seam the
 *  host line exposes (alpha open/read/close wins; rc.1 inspect is the tail). */
 async function readEvents(persistence, id, signal) {
 	if (typeof persistence.open === "function") {
 		const handle = await persistence.open(id, "read", signal === void 0 ? void 0 : { signal });
 		try {
-			const cut = handle.inheritedEventCount;
-			const inheritedCut = typeof cut === "number" && Number.isSafeInteger(cut) && cut >= 0 ? cut : 0;
+			const inheritedCut = inheritedCount(handle.inheritedEventCount);
 			const collected = [];
 			let offset = 0;
 			const PAGE = 500;
 			for (;;) {
-				if (signal?.aborted) break;
+				signal?.throwIfAborted();
 				const slice = await handle.read(offset, PAGE, signal === void 0 ? void 0 : { signal });
 				const page = slice && slice.events ? slice.events : [];
 				if (page.length === 0) break;
@@ -1622,45 +1884,59 @@ async function readEvents(persistence, id, signal) {
 		const inspection = await persistence.inspect(id, signal);
 		return {
 			events: inspection.events,
-			inheritedCut: inspection.inheritedEventCount ?? 0
+			inheritedCut: inheritedCount(inspection.inheritedEventCount)
 		};
 	}
 	throw new Error("no readable persistence seam (need open or inspect)");
 }
 /** Sum one session's own usage (its main agent) from its log. */
-async function sumOneSession(persistence, id, signal) {
-	const { events, inheritedCut } = await readEvents(persistence, id, signal);
+async function sumOneSession(persistence, id, signal, live) {
+	signal?.throwIfAborted();
+	const { events, inheritedCut } = typeof live?.snapshotEvents === "function" && typeof live.inheritedEventCount === "number" ? {
+		events: live.snapshotEvents(),
+		inheritedCut: inheritedCount(live.inheritedEventCount)
+	} : await readEvents(persistence, id, signal);
 	const fold = new UsageFold();
 	const totals = { ...ZERO };
+	const compaction = { ...ZERO };
 	for (const ev of events) {
 		if (inheritedCut > 0 && typeof ev.seq === "number" && ev.seq < inheritedCut) continue;
 		const sample = fold.fold(ev);
 		if (sample === null || sample.turn) continue;
-		totals.uncachedInputTokens += sample.inputTokens;
-		totals.outputTokens += sample.outputTokens;
-		totals.cacheReadTokens += sample.cacheReadTokens;
-		totals.cacheWriteTokens += sample.cacheWriteTokens;
+		const buckets = {
+			uncachedInputTokens: sample.inputTokens,
+			outputTokens: sample.outputTokens,
+			cacheReadTokens: sample.cacheReadTokens,
+			cacheWriteTokens: sample.cacheWriteTokens
+		};
+		add(totals, buckets);
+		if (ev.type === "compaction/summary") add(compaction, buckets);
 	}
-	return totals;
+	return {
+		totals,
+		compaction
+	};
 }
 var SessionUsageService = class {
-	/** Cached trees, each remembering every session id it was built from, so a
-	*  live event on ANY of them (a subagent's own event changes its ancestors'
-	*  totals too) can invalidate exactly the affected trees. */
+	/** Short-lived tree reads; any live event can invalidate tree membership. */
 	cache = /* @__PURE__ */ new Map();
-	/** Drop every cached tree that counted `sessionId` (its own tree, or any
-	*  ancestor's tree that folded it in as a subagent). Called by the collector
-	*  on each live session event. */
-	invalidate(sessionId) {
-		for (const [rootId, entry] of this.cache) if (entry.members.has(sessionId)) this.cache.delete(rootId);
+	/** Any event can introduce a new descendant while an async read is running. */
+	generation = 0;
+	/** Invalidate conservatively: an unseen session may be a newly-created child
+	*  of ANY cached root, so membership-only invalidation is not safe. */
+	invalidate(_sessionId) {
+		this.generation++;
+		this.cache.clear();
 	}
 	/** Resolve the whole session tree rooted at `rootId` and sum its usage.
 	*  `self` is the root's own usage, `subagents` every descendant's, `total`
-	*  the sum. Unknown roots answer zeroed totals rather than throwing: the pill
-	*  must never break the composer. */
+	*  the sum. Unreadable logs reject rather than publishing partial totals;
+	*  callers can retain their last good display while surfacing the error. */
 	async tree(persistence, sessions, rootId, signal) {
+		signal?.throwIfAborted();
 		const hit = this.cache.get(rootId);
 		if (hit !== void 0 && Date.now() - hit.at < CACHE_TTL_MS) return hit.value;
+		const generation = this.generation;
 		const headers = await this.listHeaders(persistence, signal);
 		const children = /* @__PURE__ */ new Map();
 		for (const header of headers) {
@@ -1670,10 +1946,10 @@ var SessionUsageService = class {
 			if (bucket === void 0) children.set(parent, [header.id]);
 			else bucket.push(header.id);
 		}
-		for (const handle of sessions?.list() ?? []) {
-			const parent = handle.parentSession;
+		const live = new Map((sessions?.list() ?? []).map((handle) => [handle.id, handle]));
+		for (const handle of live.values()) {
+			const parent = handle.header?.parentSession ?? handle.parentSession;
 			if (typeof parent !== "string" || parent === "" || parent === handle.id) continue;
-			if (headers.some((h) => h.id === handle.id)) continue;
 			const bucket = children.get(parent);
 			if (bucket === void 0) children.set(parent, [handle.id]);
 			else if (!bucket.includes(handle.id)) bucket.push(handle.id);
@@ -1690,23 +1966,25 @@ var SessionUsageService = class {
 				queue.push(child);
 			}
 		}
-		const self = await sumOneSession(persistence, rootId, signal).catch(() => ({ ...ZERO }));
+		const root = await sumOneSession(persistence, rootId, signal, live.get(rootId));
+		const self = root.totals;
 		const subagents = { ...ZERO };
-		for (const id of descendants) add(subagents, await sumOneSession(persistence, id, signal).catch(() => ({ ...ZERO })));
+		for (const id of descendants) add(subagents, (await sumOneSession(persistence, id, signal, live.get(id))).totals);
 		const total = { ...self };
 		add(total, subagents);
 		const value = {
 			self,
+			selfCompaction: root.compaction,
 			subagents,
 			total,
 			subagentSessions: descendants.length
 		};
-		if (signal?.aborted !== true) {
+		signal?.throwIfAborted();
+		if (generation === this.generation) {
 			if (this.cache.size >= CACHE_MAX) this.cache.clear();
 			this.cache.set(rootId, {
 				at: Date.now(),
-				value,
-				members: /* @__PURE__ */ new Set([rootId, ...descendants])
+				value
 			});
 		}
 		return value;
@@ -1837,6 +2115,28 @@ function apply(ctx, config = {}) {
 		scanController = controller;
 		await collector.backfillHours(ctx.sessionPersistence, ctx.sessions, controller.signal);
 	};
+	const ensureFailureHistory = async () => {
+		await store.readyPromise();
+		if (await store.failuresReady()) return;
+		if (!await store.hasAnyDayRows()) return;
+		if (collector.status.error !== void 0) return;
+		const previous = await store.failuresLiveSequences();
+		const boundaries = /* @__PURE__ */ new Map();
+		for (const handle of ctx.sessions.list()) {
+			const seq = handle.seq;
+			if (typeof seq === "number" && Number.isFinite(seq) && seq >= 0) {
+				boundaries.set(handle.id, seq);
+				continue;
+			}
+			const old = previous.get(handle.id);
+			boundaries.set(handle.id, typeof old === "number" ? old : -1);
+		}
+		await store.markFailuresLiveSequences(boundaries);
+		scanController?.abort();
+		const controller = new AbortController();
+		scanController = controller;
+		await collector.backfillFailures(ctx.sessionPersistence, ctx.sessions, controller.signal);
+	};
 	ctx.effect(() => {
 		collector.start();
 		const onEvent = (session) => {
@@ -1847,6 +2147,7 @@ function apply(ctx, config = {}) {
 		(async () => {
 			await rescan();
 			await ensureHourHistory();
+			await ensureFailureHistory();
 		})();
 		return () => {
 			scanController?.abort();