dsh-token-total 1.0.1 → 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,
@@ -111,6 +112,7 @@ function aggregateSamples(samples, filter, granularity = "day") {
 	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();
@@ -123,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;
@@ -196,6 +203,7 @@ 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
@@ -293,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()
 });
@@ -305,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()
 });
@@ -330,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: {
@@ -538,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).
@@ -565,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);
@@ -622,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) {
@@ -699,6 +805,7 @@ function emptyCounters(provider, model) {
 		cacheReadTokens: 0,
 		cacheWriteTokens: 0,
 		requests: 0,
+		failures: 0,
 		turns: 0,
 		lastSeen: Date.now()
 	};
@@ -719,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,
@@ -786,6 +894,7 @@ var UsageFold = class {
 					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);
@@ -828,6 +937,32 @@ var UsageFold = class {
 		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
 	* reaches the log OUTSIDE the agent loop. The summarization call produces no
 	* `assistant/message` (its summary enters the surface as a `user/message`,
@@ -968,6 +1103,9 @@ var UsageCollector = class UsageCollector {
 				this.store.markHoursLiveSequences(batch).catch(() => {
 					this.status.recordFailures++;
 				});
+				this.store.markFailuresLiveSequences(batch).catch(() => {
+					this.status.recordFailures++;
+				});
 			}
 		});
 	}
@@ -1091,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;
@@ -1105,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);
@@ -1122,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 (;;) {
@@ -1204,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;
 		}
@@ -1565,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,
@@ -1953,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) => {
@@ -1963,6 +2147,7 @@ function apply(ctx, config = {}) {
 		(async () => {
 			await rescan();
 			await ensureHourHistory();
+			await ensureFailureHistory();
 		})();
 		return () => {
 			scanController?.abort();

package/lib/types/client/ContextUsageEntry.d.ts

@@ -0,0 +1,22 @@
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import { type ContextBreakdownLike, type ContextPressureLike } from './context-meter-core.ts';
+export declare const CONTEXT_LOCALE_NS = "tokenTotalContext";
+declare const keys: readonly ["label", "used", "system", "tools", "messages", "aria", "thousand", "million"];
+export type ContextLocaleKey = typeof keys[number];
+export declare const CONTEXT_LOCALES: Record<string, Record<ContextLocaleKey, string>>;
+type ProjectionMap = {
+    contextPressure: ContextPressureLike;
+    contextBreakdown: ContextBreakdownLike;
+};
+type UseContextProjection = <K extends keyof ProjectionMap & string>(key: K) => ProjectionMap[K] | undefined;
+export interface ContextUsageEntryProps extends PropsLocale<typeof CONTEXT_LOCALE_NS> {
+    useProjection: UseContextProjection;
+    installContextTakeover?: (anchor: HTMLElement) => () => void;
+}
+export declare function ContextUsageEntry({ useProjection, t, installContextTakeover }: ContextUsageEntryProps): JSX.Element | null;
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        tokenTotalContext: ContextLocaleKey;
+    }
+}
+export {};

package/lib/types/client/context-meter-core.d.ts

@@ -0,0 +1,26 @@
+export interface ContextPressureLike {
+    projectedTokens?: number;
+    pressureTokens?: number;
+    contextWindow?: number;
+}
+export interface ContextBreakdownLike {
+    systemTokens: number;
+    toolsTokens: number;
+    messageTokens: number;
+}
+export interface ContextOccupancy {
+    percent: number;
+    usedTokens: number;
+    contextWindow: number;
+}
+/** Mirrors the host meter's occupancy calculation exactly. */
+export declare function contextOccupancy(pressure: ContextPressureLike | undefined): ContextOccupancy | null;
+export declare function contextBreakdownTotal(breakdown: ContextBreakdownLike | undefined): number;
+export declare function contextBreakdownSegments(percent: number, breakdown: ContextBreakdownLike | undefined): Array<{
+    key: string;
+    width: number;
+}>;
+export declare function formatContextTokens(value: number, units: {
+    thousand: string;
+    million: string;
+}): string;

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

@@ -0,0 +1,4 @@
+/** The host ContextMeter is hard-coded beside composer.dock, not a slot.
+ * Suppress only that recognizable sibling while our replacement is mounted;
+ * never hide a whole dock, slot wrapper, or another plugin's readout. */
+export declare function installContextTakeover(anchor: HTMLElement): () => void;

package/lib/types/client/locales.d.ts

@@ -7,7 +7,7 @@
 /** The locale namespace this plugin owns. */
 export declare const LOCALE_NS = "tokenTotal";
 /** The typed translator key union for the panel's locale seat. */
-export type TokenTotalKey = 'nav' | 'back' | 'range' | 'rangePreset.today' | 'rangePreset.3' | 'rangePreset.7' | 'rangePreset.30' | 'rangePreset.90' | 'rangeCustom' | 'from' | 'to' | 'refresh' | 'loading' | 'tokens' | 'tokensHint' | 'tokensUnit' | 'inputTokens' | 'outputTokens' | 'cacheTokens' | 'cachedTokens' | 'sessions' | 'requests' | 'activeDays' | 'cacheRate' | 'cacheRateHint' | 'cacheHitRate' | 'hitRateLegend' | 'topModel' | 'topModelHint' | 'heatmap' | 'heatLess' | 'heatMore' | 'dailyTrend' | 'hourlyTrend' | 'trendLimited' | 'usageRanking' | 'byModel' | 'byProvider' | 'tokensColumn' | 'cacheRateColumn' | 'providerModels' | 'other' | 'total' | 'percent' | 'asOf' | 'empty' | 'stats.counts' | 'stats.tokensPerSecond' | 'stats.cacheHit' | 'stats.cacheMiss' | 'stats.dialog.title' | 'stats.dialog.usageTitle' | 'stats.dialog.llmTime' | 'stats.dialog.toolTime' | 'stats.dialog.ttft' | 'stats.dialog.speed' | 'stats.dialog.main' | 'stats.dialog.subagents' | 'stats.dialog.subagentCount' | 'stats.dialog.treeTotal' | 'message.turnUsage.count' | 'message.turnUsage.cacheHit' | 'message.turnUsage.input' | 'message.turnUsage.cacheRead' | 'message.turnUsage.cacheWrite' | 'message.turnUsage.output';
+export type TokenTotalKey = 'nav' | 'back' | 'range' | 'rangePreset.today' | 'rangePreset.3' | 'rangePreset.7' | 'rangePreset.30' | 'rangePreset.90' | 'rangeCustom' | 'from' | 'to' | 'refresh' | 'loading' | 'tokens' | 'tokensHint' | 'tokensUnit' | 'inputTokens' | 'outputTokens' | 'cacheTokens' | 'cachedTokens' | 'sessions' | 'requests' | 'requestsFailed' | 'activeDays' | 'cacheRate' | 'cacheRateHint' | 'cacheHitRate' | 'hitRateLegend' | 'topModel' | 'topModelHint' | 'heatmap' | 'heatLess' | 'heatMore' | 'dailyTrend' | 'hourlyTrend' | 'trendLimited' | 'usageRanking' | 'byModel' | 'byProvider' | 'tokensColumn' | 'cacheRateColumn' | 'providerModels' | 'other' | 'total' | 'percent' | 'asOf' | 'empty' | 'stats.counts' | 'stats.tokensPerSecond' | 'stats.cacheHit' | 'stats.cacheMiss' | 'stats.dialog.title' | 'stats.dialog.usageTitle' | 'stats.dialog.llmTime' | 'stats.dialog.toolTime' | 'stats.dialog.ttft' | 'stats.dialog.speed' | 'stats.dialog.main' | 'stats.dialog.subagents' | 'stats.dialog.subagentCount' | 'stats.dialog.treeTotal' | 'message.turnUsage.count' | 'message.turnUsage.cacheHit' | 'message.turnUsage.input' | 'message.turnUsage.cacheRead' | 'message.turnUsage.cacheWrite' | 'message.turnUsage.output';
 export declare const en: Record<TokenTotalKey, string>;
 export declare const zh: Record<TokenTotalKey, string>;
 export declare const zhTW: Record<TokenTotalKey, string>;

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

@@ -1,7 +1,6 @@
 /** 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. */
+/** Add the root and descendants once; tree.total is already that sum. */
 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;

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

@@ -2,7 +2,7 @@ import type { SessionUsageTotals, SessionUsageTree } from '../wire.ts';
 export { billedTotal, cacheHitPercentOf, combinedTotals, hasAnyTokens } from './session-usage-core.ts';
 export interface SessionTreeReading {
     tree: SessionUsageTree | null;
-    /** Log-based main + subagents. The pill substitutes the live main projection. */
+    /** Authoritative log-based main + all descendant usage after the tree loads. */
     totals: SessionUsageTotals | null;
 }
 export declare function useSessionUsage(sessionId: string | undefined, signature: string): SessionTreeReading;

package/lib/types/collector.d.ts

@@ -74,6 +74,17 @@ export declare class UsageFold {
      *  carries no (new) usage or turn marker. */
     fold(ev: UsageSessionEvent): UsageSample | null;
     private replaceSample;
+    /**
+     * 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.
+     */
+    private attemptSample;
     /**
      * Fold one `compaction/summary` — the one place a provider call's usage
      * reaches the log OUTSIDE the agent loop. The summarization call produces no
@@ -200,8 +211,13 @@ export declare class UsageCollector {
      *  untouched, so a user who upgraded never loses day history because a
      *  session log was pruned. */
     backfillHours(persistence: UsageSessionPersistence, sessions: UsageSessionStore, signal?: AbortSignal): Promise<void>;
-    /** 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. */
+    backfillFailures(persistence: UsageSessionPersistence, sessions: UsageSessionStore, signal?: AbortSignal): Promise<void>;
+    /** 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. */
     private scan;
 }

package/lib/types/query.d.ts

@@ -41,6 +41,14 @@ export interface UsageSample {
     cacheWriteTokens: number;
     turn?: boolean;
     request?: boolean;
+    /** True when this sample also counts one FAILED provider call. The host
+     *  appends `assistant/attempt` (instead of `assistant/message`) when a
+     *  call's stream ends with an error or is cancelled before any content is
+     *  committed, so that event is the exact boundary of a failed call. The
+     *  marker is ORTHOGONAL to `request` and to the buckets: a failed call was
+     *  still opened by its own `step/start` (so it is already one request) and
+     *  a stream that died mid-flight may still report usage. */
+    failed?: boolean;
 }
 export interface RangeFilter {
     from: string;

package/lib/types/store.d.ts

@@ -23,6 +23,11 @@ export interface UsageCounters {
     cacheReadTokens: number;
     cacheWriteTokens: number;
     requests: number;
+    /** Provider calls in the bucket that FAILED (error / cancelled before any
+     *  content): a subset of `requests`, never larger than it. Rows persisted
+     *  before the counter existed may lack it; the schema normalizes that to 0
+     *  and every subsequent fold writes the number back. */
+    failures: number;
     turns: number;
     lastSeen: number;
 }
@@ -43,6 +48,7 @@ export declare const usageDayRowSchema: z.ZodObject<{
     cacheReadTokens: z.ZodNumber;
     cacheWriteTokens: z.ZodNumber;
     requests: z.ZodNumber;
+    failures: z.ZodDefault<z.ZodNumber>;
     turns: z.ZodNumber;
     lastSeen: z.ZodNumber;
 }, z.core.$strip>;
@@ -55,6 +61,7 @@ export declare const usageHourRowSchema: z.ZodObject<{
     cacheReadTokens: z.ZodNumber;
     cacheWriteTokens: z.ZodNumber;
     requests: z.ZodNumber;
+    failures: z.ZodDefault<z.ZodNumber>;
     turns: z.ZodNumber;
     lastSeen: z.ZodNumber;
 }, z.core.$strip>;
@@ -81,12 +88,17 @@ export declare const usageHistoryDomain: {
             hoursBackfilledSessions: z.ZodOptional<z.ZodArray<z.ZodString>>;
             hoursLiveFirstSeq: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
             hoursReady: z.ZodOptional<z.ZodBoolean>;
+            failuresBackfilledSessions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            failuresLiveFirstSeq: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+            failuresReady: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>;
         initial: {
             backfilledSessions: string[];
             liveFirstSeq: {};
             hoursBackfilledSessions: string[];
             hoursLiveFirstSeq: {};
+            failuresBackfilledSessions: string[];
+            failuresLiveFirstSeq: {};
         };
     };
     tables: {
@@ -160,6 +172,21 @@ export declare class UsageStore {
     hoursReady(): Promise<boolean>;
     /** Mark the hour history complete; the upgrade pass then never reruns. */
     markHoursReady(): Promise<void>;
+    /** 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). */
+    failuresSeenSessions(): Promise<Set<string>>;
+    /** Per-session seq of the first LIVE-observed event, failure-counter share. */
+    failuresLiveSequences(): Promise<Map<string, number>>;
+    /** Persist failure-pass replay progress (merges; serialized on the same
+     *  chain as every other cursor write). */
+    markFailuresSeenSessions(ids: Iterable<string>): Promise<void>;
+    /** Record the failure-pass live boundary per session (earliest wins). */
+    markFailuresLiveSequences(entries: Iterable<readonly [string, number]>): Promise<void>;
+    /** Whether the failure counter covers every replayable session. */
+    failuresReady(): Promise<boolean>;
+    /** Mark the failure history complete; the upgrade pass then never reruns. */
+    markFailuresReady(): Promise<void>;
     /** 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).
@@ -198,6 +225,11 @@ export declare class UsageStore {
      *  day cursors are already advanced, so replaying through `record()` would
      *  double every day row. */
     recordHours(sample: UsageSample): Promise<void>;
+    /** 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. */
+    recordFailure(sample: UsageSample): Promise<void>;
     /** The row identity a sample lands on: turn markers use the synthetic
      *  (turns) model, unlabelled calls the (unknown) one. */
     private targetsOf;

package/lib/types/wire.d.ts

@@ -17,6 +17,7 @@ export interface DailyTokenUsage {
     byModel: Record<string, number>;
     byProvider: Record<string, number>;
     requests: number;
+    failures: number;
     turns: number;
     cacheHit: number;
     cacheMiss: number;
@@ -70,6 +71,12 @@ export interface TokenTotalRange {
     /** Cached prompt tokens: cache reads + cache writes (the cache bucket of `tokens`). */
     cacheTokens: number;
     requests: number;
+    /** Provider calls in the range that FAILED: the stream ended with an error
+     *  or the call was cancelled before any content was committed. A subset of
+     *  `requests` (a failed call was still one call), and — like `requests` —
+     *  independent of the token buckets: a stream that died mid-flight may
+     *  still have reported usage. */
+    failures: number;
     turns: number;
     cacheHit: number;
     cacheMiss: number;

package/package.json

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

package/src/client/ContextUsageEntry.module.css

@@ -0,0 +1,20 @@
+.root { display: inline-flex; align-items: center; min-width: 0; font: inherit; font-variant-numeric: tabular-nums; line-height: inherit; }
+.trigger { display: inline-flex; align-items: center; gap: 6px; box-sizing: border-box; max-width: 100%; padding: 1px 8px; border: 0; border-radius: 24px; background: transparent; color: var(--dsw-alias-label-tertiary); font: inherit; line-height: inherit; white-space: nowrap; cursor: pointer; }
+.trigger svg { flex: none; }
+.track { fill: none; stroke: var(--dsw-alias-separator-primary); stroke-width: 1.5; }
+.fill { fill: none; stroke: var(--dsw-alias-label-tertiary); stroke-width: 2; stroke-linecap: round; }
+.trigger:hover, .trigger[aria-expanded='true'] { background: var(--dsw-alias-interactive-bg-hover); color: var(--dsw-alias-label-secondary); }
+.panel { position: fixed; z-index: 1100; box-sizing: border-box; width: max-content; min-width: min(300px, calc(100vw - 24px)); max-width: min(440px, calc(100vw - 24px)); padding: 16px; border-radius: 12px; background: var(--dsw-specific-menu); backdrop-filter: var(--dsw-menu-backdrop-filter); box-shadow: var(--dsw-elevation-prominent); color: var(--dsw-alias-label-secondary); font-size: 12px; line-height: 18px; }
+.header { display: flex; align-items: center; gap: 8px; margin-bottom: 8px; color: var(--dsw-alias-label-primary); font-weight: 500; }
+.percent { font-variant-numeric: tabular-nums; }
+.figures { margin-left: auto; color: var(--dsw-alias-label-tertiary); font-variant-numeric: tabular-nums; white-space: nowrap; }
+.bar { display: flex; width: 100%; height: 8px; overflow: hidden; border-radius: 4px; background: var(--dsw-alias-separator-primary); }
+.segment { height: 100%; }
+.systemTokens { background: var(--dsw-alias-label-primary); }
+.toolsTokens { background: var(--dsw-alias-label-secondary); }
+.messageTokens { background: var(--dsw-alias-label-tertiary); }
+.rows { display: grid; gap: 6px; margin: 12px 0 0; color: var(--dsw-alias-label-tertiary); }
+.row { display: flex; align-items: center; justify-content: space-between; gap: 16px; }
+.row dt { display: flex; align-items: center; gap: 8px; }
+.row dd { margin: 0; color: var(--dsw-alias-label-secondary); font-variant-numeric: tabular-nums; }
+.swatch { width: 8px; height: 8px; border-radius: 2px; }