dsh-token-total 1.0.0 → 1.0.1

package/lib/index.js

@@ -104,6 +104,8 @@ 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();
@@ -141,6 +143,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
@@ -187,8 +201,8 @@ function aggregateSamples(samples, filter, granularity = "day") {
 			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 +211,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 +220,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 +230,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 +239,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
 /**
@@ -725,6 +758,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 +776,17 @@ 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;
+				}
+			}
+			return usage ? this.replaceSample(ev, usage) : null;
 		}
 		if (ev.type === "compaction/summary") return this.compactionSample(ev);
 		return null;
@@ -749,21 +794,38 @@ 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 `compaction/summary` — the one place a provider call's usage
@@ -1167,6 +1229,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 +1541,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);
@@ -1489,6 +1579,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 +1689,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 +1722,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 +1784,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 +1804,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;

package/lib/types/client/session-usage-core.d.ts

@@ -0,0 +1,10 @@
+/** Pure billing helpers shared by the session-tree hook and composer pills. */
+import type { SessionUsageTotals, SessionUsageTree } from '../wire.ts';
+/** Use the live main-agent projection when available. Never add tree.total to
+ * it: that would count the main agent twice. The log is only the fallback. */
+export declare function combinedTotals(tree: SessionUsageTree, self?: SessionUsageTotals): SessionUsageTotals;
+/** One consistent split for the pill, cache hit rate and every dialog row. */
+export declare function sessionUsageForDisplay(native: SessionUsageTotals | undefined, tree: SessionUsageTree | null): SessionUsageTree;
+export declare function hasAnyTokens(totals: SessionUsageTotals | undefined): boolean;
+export declare function billedTotal(totals: SessionUsageTotals): number;
+export declare function cacheHitPercentOf(totals: SessionUsageTotals): number | null;

package/lib/types/client/use-session-usage.d.ts

@@ -1,24 +1,8 @@
 import type { SessionUsageTotals, SessionUsageTree } from '../wire.ts';
-/** Fold a tree into the flat shape the pill's dialog renders. */
-export declare function combinedTotals(tree: SessionUsageTree): SessionUsageTotals;
-/** Whether a totals record carries any billable token at all. */
-export declare function hasAnyTokens(totals: SessionUsageTotals | undefined): boolean;
-/** Total billed tokens of a flat totals record (prompt side + completion). */
-export declare function billedTotal(totals: SessionUsageTotals): number;
-/** Cache hit rate over the prompt side, or null when nothing was prompted. */
-export declare function cacheHitPercentOf(totals: SessionUsageTotals): number | null;
+export { billedTotal, cacheHitPercentOf, combinedTotals, hasAnyTokens } from './session-usage-core.ts';
 export interface SessionTreeReading {
     tree: SessionUsageTree | null;
-    /** main + subagents, or null before the first successful answer. */
+    /** Log-based main + subagents. The pill substitutes the live main projection. */
     totals: SessionUsageTotals | null;
 }
-/**
- * Subscribe to one session's whole-tree usage.
- *
- * `signature` is any string that changes when the native usage figure moves;
- * passing it in keeps this hook out of the projection seat and lets the caller
- * decide what "a new call settled" means for its own pill. A session that turns
- * out to have subagents additionally re-asks on a slow beat, because subagent
- * spend lands in a different session log and no native figure moves for it.
- */
 export declare function useSessionUsage(sessionId: string | undefined, signature: string): SessionTreeReading;

package/lib/types/collector.d.ts

@@ -3,10 +3,10 @@
  * Two sources feed the same fold:
  *
  * - live: `session/event` subscription — every committed session event
- *   reaches this plugin after the fact. `assistant/message` carries the
- *   step's final `usage` (TokenUsage); `assistant/chunk` carries an early
- *   `usage` sample from the streaming adapter; `request/context` carries the
- *   provider/model route. A completed call's usage is attributed to the model
+ *   reaches this plugin after the fact. Assistant messages expose final usage,
+ *   and modern message/attempt streams retain raw usage even on failed calls.
+ *   Legacy `assistant/chunk` reports an early sample; `request/context` carries
+ *   the provider/model route. A completed call's usage is attributed to the model
  *   the request used — in priority order: the message's own `source`
  *   (authoritative per call), then the session's last-known route, which
  *   comes from observed `request/context` events OR is lazily seeded from
@@ -27,11 +27,10 @@
  *   >= 0.1.2-rc.1, 0 for a non-forked session), and the replay skips it —
  *   the parent's own backfill already counted those events.
  *
- * Idempotence: within ONE session, the same (turn, step) may report usage
- * more than once (a streaming sample then the final assistant/message;
- * compaction replays). The fold emits each (turn, step) key exactly once and
- * keeps the newest values in its own state — see the replaceSample note for
- * why the store observably keeps the FIRST emission. Cross-session
+ * Idempotence: within ONE session, repeated reports for the same (turn, step)
+ * emit only signed bucket corrections: the accumulated usage is last-wins.
+ * A started retry closes that replacement slot because its predecessor was a
+ * separately billed attempt. Cross-session
  * (turn, step) collisions are NOT deduped: two sessions both own a turn 1 /
  * step 1, and each must count. The store's per-day rows accumulate, so
  * re-folding the same log must not add twice: live events are only folded

package/lib/types/context-types.d.ts

@@ -151,6 +151,22 @@ export interface UsageLlmService {
         id: string;
         name: string;
     }[]>;
+    /** The provider catalog: route id -> the display name the model selector
+     *  shows. Synchronous on every host line this plugin supports (the llm
+     *  runtime's own `listProviders`, mirrored by the dsh-llm service). Optional:
+     *  a host without it leaves every ranked provider row labelled by its raw
+     *  historical route id. */
+    listProviders?(): readonly {
+        id: string;
+        name: string;
+    }[];
+    /** The configured-provider view (the models page's own list), whose
+     *  `displayName` is the same label. Read as a fallback for a route that
+     *  `listProviders` omits. */
+    listConfigurableProviders?(): readonly {
+        provider: string;
+        displayName: string;
+    }[];
 }
 /** The route a session's log records for its model calls (mirror of
  *  dsh-agent-loop RequestContext). */
@@ -167,8 +183,13 @@ export interface UsageSessionHandle {
     id: string;
     cwd?: string;
     createdAt?: number;
-    /** The parent session a subagent session was delegated from (mirror of the
-     *  SessionHeader field; absent on a root session). */
+    /** Modern hosts retain creation metadata on Session.header, not as getters. */
+    header?: UsageSessionHeader;
+    /** Exact fork prefix, distinct from the resume/construction seed length. */
+    inheritedEventCount?: number;
+    /** Immutable current live log; avoids the persistence backend's batching lag. */
+    snapshotEvents?(): readonly UsageSessionEvent[];
+    /** Legacy direct parent; modern hosts expose header.parentSession instead. */
     parentSession?: string;
     /** 0 for a root session; the delegation depth for a subagent. */
     delegationDepth?: number;

package/lib/types/model-names.d.ts

@@ -2,6 +2,12 @@
  *  This is query-time metadata: no store wipe/replay is needed, and a provider
  *  rename applies to both the ranking and every trend bucket on refresh. */
 import type { UsageLlmService } from './context-types.ts';
+/** 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. */
+export declare function resolveProviderNames(llm?: UsageLlmService): Record<string, string>;
 /** Resolve each distinct route once per range query. Unknown/deleted providers
  *  fall back to their bare historical model names in aggregateSamples(). */
 export declare function resolveModelNames(modelRefs: Iterable<string>, llm?: UsageLlmService): Promise<Map<string, string>>;

package/lib/types/session-usage.d.ts

@@ -26,18 +26,17 @@ import type { UsageSessionPersistence, UsageSessionStore } from './context-types
 import type { SessionUsageTree } from './wire.ts';
 export type { SessionUsageTotals, SessionUsageTree } from './wire.ts';
 export declare class SessionUsageService {
-    /** 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. */
     private cache;
-    /** 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: string): void;
+    /** Any event can introduce a new descendant while an async read is running. */
+    private generation;
+    /** Invalidate conservatively: an unseen session may be a newly-created child
+     *  of ANY cached root, so membership-only invalidation is not safe. */
+    invalidate(_sessionId: string): void;
     /** 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. */
     tree(persistence: UsageSessionPersistence, sessions: UsageSessionStore | undefined, rootId: string, signal?: AbortSignal): Promise<SessionUsageTree>;
     private listHeaders;
 }

package/lib/types/wire.d.ts

@@ -29,6 +29,13 @@ export interface ModelTokenUsage {
     provider: string;
     /** All source providers; optional for compatibility with older responses. */
     providers?: string[];
+    /** Per-provider token split of this one model, largest first — the ranked
+     *  row's hover detail ("which providers served this model"). Optional so a
+     *  pre-cross-breakdown host still renders. */
+    providerTokens?: Array<{
+        provider: string;
+        tokens: number;
+    }>;
     tokens: number;
     percent: number;
     /** Cached input tokens this model served (rate numerator). */
@@ -43,6 +50,13 @@ export interface ProviderTokenUsage {
     percent: number;
     cacheHit: number;
     cacheMiss: number;
+    /** Per-model token split this provider served, largest first — the ranked
+     *  row's hover detail ("which models this provider served"). Optional so a
+     *  pre-cross-breakdown host still renders. */
+    modelTokens?: Array<{
+        model: string;
+        tokens: number;
+    }>;
 }
 /** The full aggregate the panel renders for one time range. */
 export interface TokenTotalRange {
@@ -68,6 +82,11 @@ export interface TokenTotalRange {
     daily: DailyTokenUsage[];
     models: ModelTokenUsage[];
     providers: ProviderTokenUsage[];
+    /** Provider route id -> the display name the model selector shows. Filled by
+     *  the host route from the llm service metadata; a provider missing here (a
+     *  deleted route, an older host) renders as its raw id. Optional so a host
+     *  that cannot resolve names still serves a valid payload. */
+    providerNames?: Record<string, string>;
 }
 /** The usage statistics panel aggregate request. */
 export interface TokenTotalRequest {
@@ -87,8 +106,11 @@ export interface SessionUsageTotals {
  *  The composer stats row renders this so a delegating session shows its whole
  *  spend (the native `tokenUsage` projection only covers the main agent). */
 export interface SessionUsageTree {
-    /** The root session's own (main agent) usage. */
+    /** The root session's own usage, including logged compaction calls. */
     self: SessionUsageTotals;
+    /** Root-only compaction spend already included in `self`, but absent from
+     *  the native `tokenUsage` projection. Optional for older host responses. */
+    selfCompaction?: SessionUsageTotals;
     /** Sum over every descendant (subagent) session. */
     subagents: SessionUsageTotals;
     /** self + subagents. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-token-total",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "DSH web plugin: token 用量统计看板 + 单会话（主智能体 + 子智能体）用量统计。提供今日/近3天/近7天/近1月/近3月/自定义筛选、六个汇总卡片、活跃热力图、缓存命中率折线与分模型柱状图、按模型/按供应商 Top5 列表。",
   "icon": "./icon.svg",
   "type": "module",