@rayadesu/dsh-llm-billing 0.2.2 → 0.2.4

package/lib/index.js

@@ -135,12 +135,16 @@ let DeepSeekBalanceGateway = (() => {
 	let _getBalance_decorators;
 	let _getSessionSpend_decorators;
 	let _getTodaySpend_decorators;
+	let _getTodaySessionsSpend_decorators;
+	let _getTurnSpend_decorators;
 	return class DeepSeekBalanceGateway extends _classSuper {
 		static {
 			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
 			_getBalance_decorators = [Remote("getBalance")];
 			_getSessionSpend_decorators = [Remote("getSessionSpend")];
 			_getTodaySpend_decorators = [Remote("getTodaySpend")];
+			_getTodaySessionsSpend_decorators = [Remote("getTodaySessionsSpend")];
+			_getTurnSpend_decorators = [Remote("getTurnSpend")];
 			__esDecorate(this, null, _getBalance_decorators, {
 				kind: "method",
 				name: "getBalance",
@@ -174,6 +178,28 @@ let DeepSeekBalanceGateway = (() => {
 				},
 				metadata: _metadata
 			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _getTodaySessionsSpend_decorators, {
+				kind: "method",
+				name: "getTodaySessionsSpend",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "getTodaySessionsSpend" in obj,
+					get: (obj) => obj.getTodaySessionsSpend
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _getTurnSpend_decorators, {
+				kind: "method",
+				name: "getTurnSpend",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "getTurnSpend" in obj,
+					get: (obj) => obj.getTurnSpend
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
 			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
 				enumerable: true,
 				configurable: true,
@@ -218,6 +244,29 @@ let DeepSeekBalanceGateway = (() => {
 		getTodaySpend(force) {
 			return this.options.fetchTodaySpend(force ?? false);
 		}
+		/**
+		* Read today's billed spend per session, priced per event by its
+		* Beijing-time calendar day, hour, and weekday (weekends are always
+		* off-peak). Rows carry the session's durable title and sort by cost
+		* descending; sessions with no priced usage on the day are omitted.
+		* @param force - bypass the host-side 60s cache (manual refresh); omitted
+		*   means a cached read.
+		* @returns today's per-session rows, highest first.
+		*/
+		getTodaySessionsSpend(force) {
+			return this.options.fetchTodaySessionsSpend(force ?? false);
+		}
+		/**
+		* Read one completed Turn's billed spend, priced per event by its
+		* Beijing-time hour and weekday (weekends are always off-peak).
+		* @param sessionId - the session owning the Turn.
+		* @param messageId - the closing assistant message's durable id, which
+		*   locates the Turn in the session log.
+		* @returns the Turn's total cost in CNY.
+		*/
+		getTurnSpend(sessionId, messageId) {
+			return this.options.fetchTurnSpend(sessionId, messageId);
+		}
 	};
 })();
 //#endregion
@@ -228,11 +277,12 @@ let DeepSeekBalanceGateway = (() => {
 * Remote gateway stays transport-free and the whole spend is testable without
 * a key.
 *
-* The per-event pricing lives in {@link priceEvent}, the one shared fold
-* primitive: the events-scan paths ({@link computeSessionSpend},
-* {@link computeTodaySpend}) and the session-projection unit
-* (`billingTodaySpend` in projection.ts) all fold the same contribution, so a
-* pricing-table change cannot drift one path from the others.
+* The per-event pricing lives in {@link priceEvent} and the fold in the
+* {@link SpendAccumulator}: the events-scan paths ({@link computeSessionSpend},
+* {@link computeTodaySpend}), the session-projection unit (`billingTodaySpend`
+* in projection.ts), and the scanner's single-pass events path all price
+* through the same primitives, so a pricing-table change cannot drift one path
+* from the others.
 * @module @rayadesu/dsh-llm-billing/billing
 */
 /**
@@ -311,20 +361,28 @@ function resolveBilling(config) {
 		models
 	};
 }
-/** The Beijing (Asia/Shanghai, UTC+8, no DST) hour of a timestamp. */
-function beijingHour(now) {
-	return new Date(now.getTime() + 288e5).getUTCHours();
-}
 /**
-* The Beijing (Asia/Shanghai, UTC+8, no DST) weekday of a timestamp, as
-* `getUTCDay()`: `0` is Sunday, `6` is Saturday.
+* Derive the Beijing hour, weekday, and calendar-day key of one timestamp from
+* a single shifted `Date` — every timezone-sensitive read shares this one
+* implementation, so the pieces cannot drift apart.
+* @param time - epoch milliseconds.
 */
-function beijingWeekday(now) {
-	return new Date(now.getTime() + 288e5).getUTCDay();
+function beijingParts(time) {
+	const shifted = new Date(time + 288e5);
+	return {
+		hour: shifted.getUTCHours(),
+		weekday: shifted.getUTCDay(),
+		dayKey: shifted.toISOString().slice(0, 10)
+	};
 }
 /** The Beijing (Asia/Shanghai, UTC+8, no DST) calendar-day key of a timestamp. */
 function beijingDayKey(now) {
-	return new Date(now.getTime() + 288e5).toISOString().slice(0, 10);
+	return beijingParts(now.getTime()).dayKey;
+}
+/** Whether a Beijing (hour, weekday) pair falls inside any peak-hour window. */
+function isPeakParts(billing, hour, weekday) {
+	if (weekday === 0 || weekday === 6) return false;
+	return billing.peakHours.some(({ start, end }) => hour >= start && hour < end);
 }
 /**
 * Whether a timestamp falls inside any peak-hour window (Beijing time,
@@ -335,10 +393,8 @@ function beijingDayKey(now) {
 * @returns true during a weekday peak hour.
 */
 function isPeak(billing, now) {
-	const weekday = beijingWeekday(now);
-	if (weekday === 0 || weekday === 6) return false;
-	const hour = beijingHour(now);
-	return billing.peakHours.some(({ start, end }) => hour >= start && hour < end);
+	const { hour, weekday } = beijingParts(now.getTime());
+	return isPeakParts(billing, hour, weekday);
 }
 /**
 * Price one event at the official per-model rates, applying the peak/off-peak
@@ -360,8 +416,8 @@ function priceEvent(event, billing, names) {
 	const model = event.data.message.source.model;
 	const pricing = billing.models.get(model);
 	if (pricing === void 0) return void 0;
-	const time = new Date(event.time);
-	const peak = isPeak(billing, time);
+	const { hour, weekday, dayKey } = beijingParts(event.time);
+	const peak = isPeakParts(billing, hour, weekday);
 	const price = peak ? pricing.peak : pricing.offPeak;
 	const hit = reported.cacheReadTokens ?? 0;
 	const miss = reported.inputTokens + (reported.cacheWriteTokens ?? 0);
@@ -371,7 +427,7 @@ function priceEvent(event, billing, names) {
 	const outputCost = output * price.output / 1e6;
 	const cost = hitCost + missCost + outputCost;
 	return {
-		dayKey: beijingDayKey(time),
+		dayKey,
 		model,
 		displayName: names.get(model) ?? model,
 		cost,
@@ -408,6 +464,48 @@ function contributionModel(priced) {
 		outputCost: priced.outputCost
 	};
 }
+/** Sum two model rows of the same model (pure). */
+function mergeModelRows(left, right) {
+	return {
+		model: left.model,
+		displayName: left.displayName,
+		cost: left.cost + right.cost,
+		peakCost: left.peakCost + right.peakCost,
+		offPeakCost: left.offPeakCost + right.offPeakCost,
+		cacheHitInputTokens: left.cacheHitInputTokens + right.cacheHitInputTokens,
+		cacheMissInputTokens: left.cacheMissInputTokens + right.cacheMissInputTokens,
+		outputTokens: left.outputTokens + right.outputTokens,
+		cacheHitInputCost: left.cacheHitInputCost + right.cacheHitInputCost,
+		cacheMissInputCost: left.cacheMissInputCost + right.cacheMissInputCost,
+		outputCost: left.outputCost + right.outputCost
+	};
+}
+/**
+* Mutable model-row accumulator behind every spend fold. Rows keep first-seen
+* model order — the same shape a pure `addEventContribution` chain produces —
+* so the single-pass scan path and the pure public paths cannot diverge. One
+* `Map` lookup per contribution instead of a per-event array copy: the huge
+* event-log folds allocate one row object per model, not one intermediate
+* array per event.
+*/
+var SpendAccumulator = class {
+	rows = /* @__PURE__ */ new Map();
+	total = 0;
+	/** Add one priced contribution. */
+	add(priced) {
+		const row = contributionModel(priced);
+		const existing = this.rows.get(priced.model);
+		this.rows.set(priced.model, existing === void 0 ? row : mergeModelRows(existing, row));
+		this.total += priced.cost;
+	}
+	/** The folded spend; the accumulator stays usable afterwards. */
+	finish() {
+		return {
+			total: this.total,
+			models: [...this.rows.values()]
+		};
+	}
+};
 /**
 * Merge one priced event's contribution into an accumulator spend (pure:
 * returns a new spend, never mutates its input).
@@ -416,19 +514,9 @@ function contributionModel(priced) {
 * @returns the merged spend.
 */
 function addEventContribution(spend, priced) {
-	const rows = spend.models.map((row) => row.model === priced.model ? {
-		...row,
-		cost: row.cost + priced.cost,
-		peakCost: row.peakCost + priced.peakCost,
-		offPeakCost: row.offPeakCost + priced.offPeakCost,
-		cacheHitInputTokens: row.cacheHitInputTokens + priced.cacheHitInputTokens,
-		cacheMissInputTokens: row.cacheMissInputTokens + priced.cacheMissInputTokens,
-		outputTokens: row.outputTokens + priced.outputTokens,
-		cacheHitInputCost: row.cacheHitInputCost + priced.cacheHitInputCost,
-		cacheMissInputCost: row.cacheMissInputCost + priced.cacheMissInputCost,
-		outputCost: row.outputCost + priced.outputCost
-	} : row);
-	if (!rows.some((row) => row.model === priced.model)) rows.push(contributionModel(priced));
+	const row = contributionModel(priced);
+	const rows = spend.models.map((existing) => existing.model === priced.model ? mergeModelRows(existing, row) : existing);
+	if (!rows.some((existing) => existing.model === priced.model)) rows.push(row);
 	return {
 		total: spend.total + priced.cost,
 		models: rows
@@ -442,22 +530,16 @@ function addEventContribution(spend, priced) {
 * @returns the summed spend.
 */
 function mergeTodaySpend(target, source) {
-	let merged = target;
-	for (const row of source.models) merged = addEventContribution(merged, {
-		dayKey: "",
-		model: row.model,
-		displayName: row.displayName,
-		cost: row.cost,
-		peakCost: row.peakCost,
-		offPeakCost: row.offPeakCost,
-		cacheHitInputTokens: row.cacheHitInputTokens,
-		cacheMissInputTokens: row.cacheMissInputTokens,
-		outputTokens: row.outputTokens,
-		cacheHitInputCost: row.cacheHitInputCost,
-		cacheMissInputCost: row.cacheMissInputCost,
-		outputCost: row.outputCost
-	});
-	return merged;
+	const rows = /* @__PURE__ */ new Map();
+	for (const row of target.models) rows.set(row.model, row);
+	for (const row of source.models) {
+		const existing = rows.get(row.model);
+		rows.set(row.model, existing === void 0 ? row : mergeModelRows(existing, row));
+	}
+	return {
+		total: target.total + source.total,
+		models: [...rows.values()]
+	};
 }
 /**
 * Price a set of billed events at the official per-model rates, applying the
@@ -470,21 +552,18 @@ function mergeTodaySpend(target, source) {
 * published table prices only the two V4 rows).
 * @param events - the events to price.
 * @param billing - resolved pricing with peak-hour windows.
-* @param catalog - model display rows, in presentation order.
+* @param names - model id → display label.
+* @param dayKey - when provided, only events on this Beijing calendar day contribute.
 * @returns the total cost plus one row per priced model.
 */
-function priceEvents(events, billing, catalog) {
-	const names = new Map(catalog.map((model) => [model.id, model.name]));
-	let spend = {
-		total: 0,
-		models: []
-	};
+function priceEvents(events, billing, names, dayKey) {
+	const accumulator = new SpendAccumulator();
 	for (const event of events) {
 		const priced = priceEvent(event, billing, names);
-		if (priced === void 0) continue;
-		spend = addEventContribution(spend, priced);
+		if (priced === void 0 || dayKey !== void 0 && priced.dayKey !== dayKey) continue;
+		accumulator.add(priced);
 	}
-	return spend;
+	return accumulator.finish();
 }
 /**
 * Price one session's complete event log at the official per-model rates.
@@ -494,7 +573,45 @@ function priceEvents(events, billing, catalog) {
 * @returns the session's total cost plus one row per priced model.
 */
 function computeSessionSpend(events, billing, catalog) {
-	return priceEvents(events, billing, catalog);
+	return priceEvents(events, billing, new Map(catalog.map((model) => [model.id, model.name])));
+}
+/**
+* Price one completed Turn's billed usage at the official per-model rates,
+* identified by its closing assistant message id. The turn's events are those
+* between its `turn/start` and `turn/end` (both matched by the message's own
+* turn coordinate); each priced event applies the peak/off-peak table by its
+* Beijing-time hour and weekday. A message that cannot be located, a turn
+* without bracketing `turn/start` / `turn/end` events (for example after
+* compaction), or a session with no priced usage prices to zero.
+* @param events - one session's complete event log.
+* @param billing - resolved pricing with peak-hour windows.
+* @param catalog - model display rows, in presentation order.
+* @param messageId - the closing assistant message's durable id.
+* @returns the turn's total cost in CNY.
+*/
+function computeTurnSpend(events, billing, catalog, messageId) {
+	const names = new Map(catalog.map((model) => [model.id, model.name]));
+	let turn;
+	for (const event of events) {
+		if (event.type !== "assistant/message") continue;
+		if (event.data.message.id !== messageId) continue;
+		turn = event.data.turn;
+		break;
+	}
+	if (turn === void 0) return { total: 0 };
+	const accumulator = new SpendAccumulator();
+	let active = false;
+	for (const event of events) {
+		if (event.type === "turn/start" && event.data.turn === turn) {
+			active = true;
+			continue;
+		}
+		if (event.type === "turn/end" && event.data.turn === turn) break;
+		if (!active) continue;
+		const priced = priceEvent(event, billing, names);
+		if (priced !== void 0) accumulator.add(priced);
+	}
+	return { total: accumulator.finish().total };
 }
 /**
 * Price every event whose Beijing-time calendar day is the day of `now`,
@@ -508,14 +625,7 @@ function computeSessionSpend(events, billing, catalog) {
 */
 function computeTodaySpend(events, billing, catalog, now = /* @__PURE__ */ new Date()) {
 	const day = beijingDayKey(now);
-	const names = new Map(catalog.map((model) => [model.id, model.name]));
-	let spend = emptyTodaySpend();
-	for (const event of events) {
-		const priced = priceEvent(event, billing, names);
-		if (priced === void 0 || priced.dayKey !== day) continue;
-		spend = addEventContribution(spend, priced);
-	}
-	return spend;
+	return priceEvents(events, billing, new Map(catalog.map((model) => [model.id, model.name])), day);
 }
 //#endregion
 //#region lib/types/projection.js
@@ -618,9 +728,10 @@ function foldBillingUnit(unit, events) {
 *   with write-back) or, without the cache service, one detached local fold
 *   over a full `inspect`. Persisted revisions gate every cold read, so a
 *   session whose log did not change since the last resolution costs nothing.
-* - events path (plans A2/A3): collect only today's events (per-event
-*   Beijing-day filter during collection) with a hard cap, skipping sessions
-*   whose persisted revision is unchanged since the last scan.
+* - events path (plans A2/A3): collect and price only today's events in one
+*   pass (per-event Beijing-day filter during collection) with a hard cap,
+*   skipping sessions whose persisted revision is unchanged since the last
+*   scan.
 *
 * Both strategies run behind the same {@link TodaySpendCache}, so a miss
 * happens at most once per 60 seconds per process, and a manual refresh
@@ -628,11 +739,36 @@ function foldBillingUnit(unit, events) {
 * unchanged log provably cannot change the aggregate.
 * @module @rayadesu/dsh-llm-billing/today-spend
 */
-/** Bounded parallel fan-out: run `run` over `items` with at most `limit` in flight. */
+/**
+* Fold one session's durable display title: the latest `session/title`
+* event's text (last-wins, matching the `title` projection), or `null` before
+* the first title lands. The fold runs over the complete log, so an explicit
+* user rename is picked up as soon as its event commits.
+* @param events - one session's complete event log.
+* @returns the session's current title, or `null` when untitled.
+*/
+function foldSessionTitle(events) {
+	for (let index = events.length - 1; index >= 0; index--) {
+		const event = events[index];
+		if (event.type !== "session/title") continue;
+		const data = event.data;
+		return typeof data.title === "string" ? data.title : null;
+	}
+	return null;
+}
+/**
+* Bounded parallel fan-out: run `run` over `items` with at most `limit` in
+* flight. A shared index counter hands each worker its next job, so the
+* dispatch is O(n) overall (array `shift()` would be O(n) per pop).
+*/
 async function withConcurrency(items, limit, run) {
-	const queue = [...items];
-	await Promise.all(Array.from({ length: Math.min(limit, queue.length) }, async () => {
-		for (let job = queue.shift(); job !== void 0; job = queue.shift()) await run(job);
+	const total = items.length;
+	let next = 0;
+	await Promise.all(Array.from({ length: Math.min(limit, total) }, async () => {
+		for (let job = next; job < total; job = next) {
+			next += 1;
+			await run(items[job]);
+		}
 	}));
 }
 /**
@@ -640,6 +776,8 @@ async function withConcurrency(items, limit, run) {
 * coalesces concurrent misses, and a `force` bypass for the manual refresh
 * path. Cross-day invalidation is automatic (the day key changes); a failed
 * scan leaves the previous value in place and retries on the next call.
+* @typeParam T - the cached aggregate's value shape (the spend or its
+*   per-session breakdown).
 */
 var TodaySpendCache = class {
 	scan;
@@ -650,9 +788,9 @@ var TodaySpendCache = class {
 	cachedAt = 0;
 	inFlight;
 	/**
+	* @param scan - the aggregate computation behind a miss.
 	* @param ttlMs - time window in milliseconds (default 60 000).
 	* @param now - clock source (injectable for tests).
-	* @param scan - the aggregate computation behind a miss.
 	*/
 	constructor(scan, ttlMs = 6e4, now = () => /* @__PURE__ */ new Date()) {
 		this.scan = scan;
@@ -693,7 +831,7 @@ var TodaySpendCache = class {
 */
 var TodaySpendScanner = class {
 	deps;
-	/** Cold sessions resolved on the projection path: id → revision + unit state. */
+	/** Cold sessions resolved on the projection path: id → revision + unit state + title. */
 	coldResolved = /* @__PURE__ */ new Map();
 	/** Cold sessions resolved on the events path: id → revision (events were collected). */
 	lastEventsScan;
@@ -710,16 +848,63 @@ var TodaySpendScanner = class {
 		this.deps.ensureUnit?.();
 		return this.scanProjections(dayKey);
 	}
+	/**
+	* Compute today's per-session spend for one Beijing day, sorted by cost
+	* descending. Sessions with no priced usage on the day are omitted; each
+	* row carries the session's durable title folded from its log.
+	* @param dayKey - the Beijing-time calendar-day key to aggregate.
+	* @returns today's per-session rows, highest first.
+	*/
+	async scanSessions(dayKey) {
+		const rows = this.deps.projections?.() === void 0 ? await this.scanSessionsEvents(dayKey) : await this.scanSessionsProjections(dayKey);
+		rows.sort((left, right) => right.total - left.total);
+		return { sessions: rows };
+	}
+	/**
+	* Resolve one cold session's billing unit state and display title through
+	* the projection-cache ladder (cached row first, then a detached local
+	* fold over a full inspect). A cache-served value carries no title (the
+	* ladder only stores projection values), so such rows report `title: null`
+	* until the session is inspected again.
+	* @param id - the cold session's id.
+	* @returns the resolved state and title, or `undefined` when unreadable.
+	*/
+	async resolveCold(id) {
+		const { persistence, projectionCache, unit, logger } = this.deps;
+		const cache = projectionCache?.();
+		if (cache !== void 0) try {
+			const value = (await cache.coldSnapshot(id)).values[BILLING_UNIT_KEY];
+			if (value !== void 0) return {
+				value,
+				title: null
+			};
+		} catch (error) {
+			logger.warn(`llm-billing: projection cold read for session ${id} failed: ${String(error)}`);
+		}
+		const persistenceService = persistence?.();
+		if (persistenceService === void 0) return void 0;
+		try {
+			const inspection = await persistenceService.inspect(id);
+			return {
+				value: foldBillingUnit(unit, inspection.events),
+				title: foldSessionTitle(inspection.events)
+			};
+		} catch (error) {
+			logger.warn(`llm-billing: skipping unreadable session ${id}: ${String(error)}`);
+			return;
+		}
+	}
 	/** Projection path: eager cells for live sessions, revision-gated cold ladder for the rest. */
 	async scanProjections(dayKey) {
-		const { sessions, persistence, projections, projectionCache, unit, logger } = this.deps;
+		const { sessions, persistence, projections } = this.deps;
+		const projectionsService = projections?.();
 		let total = emptyTodaySpend();
 		const liveIds = /* @__PURE__ */ new Set();
 		if (sessions !== void 0) {
 			const store = sessions();
 			if (store !== void 0) for (const session of store.list()) {
 				liveIds.add(session.id);
-				const state = projections?.()?.stateOf(session, BILLING_UNIT_KEY);
+				const state = projectionsService?.stateOf(session, BILLING_UNIT_KEY);
 				if (state !== void 0 && state.dayKey === dayKey) total = mergeTodaySpend(total, state.spend);
 			}
 		}
@@ -740,22 +925,10 @@ var TodaySpendScanner = class {
 			});
 		}
 		await withConcurrency(pending, 8, async ({ id, revision }) => {
-			let value;
-			const cache = projectionCache?.();
-			if (cache !== void 0) try {
-				value = (await cache.coldSnapshot(id)).values[BILLING_UNIT_KEY];
-			} catch (error) {
-				logger.warn(`llm-billing: projection cold read for session ${id} failed: ${String(error)}`);
-			}
-			if (value === void 0) try {
-				const inspection = await persistenceService.inspect(id);
-				value = foldBillingUnit(unit, inspection.events);
-			} catch (error) {
-				logger.warn(`llm-billing: skipping unreadable session ${id}: ${String(error)}`);
-			}
-			if (value !== void 0) this.coldResolved.set(id, {
+			const resolved = await this.resolveCold(id);
+			if (resolved !== void 0) this.coldResolved.set(id, {
 				revision,
-				value
+				...resolved
 			});
 		});
 		for (const { id } of pending) {
@@ -764,24 +937,158 @@ var TodaySpendScanner = class {
 		}
 		return total;
 	}
-	/** Events path: collect only today's events (capped), gated by revisions. */
+	/**
+	* Events path: price today's events in a single pass (per-event Beijing-day
+	* filter during collection, hard cap), gated by revisions.
+	*/
 	async scanEvents(dayKey) {
 		const { sessions, persistence, maxEvents, logger, billing, catalog } = this.deps;
-		const events = [];
+		const names = new Map(catalog.map((model) => [model.id, model.name]));
+		const accumulator = new SpendAccumulator();
 		const liveIds = /* @__PURE__ */ new Set();
+		let collected = 0;
 		let truncated = false;
+		const collect = (events) => {
+			for (const event of events) {
+				if (beijingDayKey(new Date(event.time)) !== dayKey) continue;
+				collected += 1;
+				if (collected > maxEvents) {
+					truncated = true;
+					return;
+				}
+				const priced = priceEvent(event, billing, names);
+				if (priced !== void 0) accumulator.add(priced);
+			}
+		};
 		if (sessions !== void 0) {
 			const store = sessions();
 			if (store !== void 0) for (const session of store.list()) {
 				liveIds.add(session.id);
-				for (const event of session.events) {
-					if (beijingDayKey(new Date(event.time)) !== dayKey) continue;
-					events.push(event);
-					if (events.length >= maxEvents) {
-						truncated = true;
-						break;
-					}
+				collect(session.events);
+				if (truncated) break;
+			}
+		}
+		const persistenceService = persistence?.();
+		if (!truncated && persistenceService !== void 0) {
+			const snapshots = await persistenceService.listSnapshots();
+			for (const { header, revision } of snapshots) {
+				if (liveIds.has(header.id)) continue;
+				if (this.lastEventsScan?.get(header.id) === revision) continue;
+				try {
+					collect((await persistenceService.inspect(header.id)).events);
+				} catch (error) {
+					logger.warn(`llm-billing: skipping unreadable session ${header.id}: ${String(error)}`);
+				}
+				if (truncated) break;
+			}
+			if (!truncated) this.lastEventsScan = new Map(snapshots.map((snapshot) => [snapshot.header.id, snapshot.revision]));
+		}
+		if (truncated) logger.warn(`llm-billing: today's events exceeded ${maxEvents}; result truncated`);
+		return accumulator.finish();
+	}
+	/**
+	* Projection-path per-session scan: eager cells for live sessions (title
+	* folded from the live log, so a rename is reflected immediately),
+	* revision-gated cold ladder for the rest (title resolved on inspect,
+	* `null` when served from the projection cache).
+	* @param dayKey - the Beijing-time calendar-day key to aggregate.
+	* @returns unsorted per-session rows for the day.
+	*/
+	async scanSessionsProjections(dayKey) {
+		const { sessions, persistence, projections } = this.deps;
+		const projectionsService = projections?.();
+		const rows = /* @__PURE__ */ new Map();
+		const liveIds = /* @__PURE__ */ new Set();
+		if (sessions !== void 0) {
+			const store = sessions();
+			if (store !== void 0) for (const session of store.list()) {
+				liveIds.add(session.id);
+				const state = projectionsService?.stateOf(session, BILLING_UNIT_KEY);
+				if (state !== void 0 && state.dayKey === dayKey) rows.set(session.id, {
+					sessionId: session.id,
+					title: foldSessionTitle(session.events),
+					total: state.spend.total
+				});
+			}
+		}
+		const persistenceService = persistence?.();
+		if (persistenceService === void 0) return [...rows.values()];
+		const snapshots = await persistenceService.listSnapshots();
+		const pending = [];
+		for (const { header, revision } of snapshots) {
+			if (liveIds.has(header.id)) continue;
+			const resolved = this.coldResolved.get(header.id);
+			if (resolved !== void 0 && resolved.revision === revision) {
+				if (resolved.value.dayKey === dayKey) rows.set(header.id, {
+					sessionId: header.id,
+					title: resolved.title,
+					total: resolved.value.spend.total
+				});
+				continue;
+			}
+			pending.push({
+				id: header.id,
+				revision
+			});
+		}
+		await withConcurrency(pending, 8, async ({ id, revision }) => {
+			const resolved = await this.resolveCold(id);
+			if (resolved !== void 0) this.coldResolved.set(id, {
+				revision,
+				...resolved
+			});
+		});
+		for (const { id } of pending) {
+			const resolved = this.coldResolved.get(id);
+			if (resolved !== void 0 && resolved.value.dayKey === dayKey) rows.set(id, {
+				sessionId: id,
+				title: resolved.title,
+				total: resolved.value.spend.total
+			});
+		}
+		return [...rows.values()];
+	}
+	/**
+	* Events-path per-session scan: price today's events in a single pass,
+	* accumulating per session (per-event Beijing-day filter during collection,
+	* hard cap), gated by revisions. Titles fold from each session's complete
+	* log — a `session/title` event can predate today — so a rename is reflected
+	* as soon as the session's log is re-read.
+	* @param dayKey - the Beijing-time calendar-day key to aggregate.
+	* @returns unsorted per-session rows for the day.
+	*/
+	async scanSessionsEvents(dayKey) {
+		const { sessions, persistence, maxEvents, logger, billing, catalog } = this.deps;
+		const names = new Map(catalog.map((model) => [model.id, model.name]));
+		const rows = /* @__PURE__ */ new Map();
+		const liveIds = /* @__PURE__ */ new Set();
+		let collected = 0;
+		let truncated = false;
+		const collect = (id, events) => {
+			let row = rows.get(id);
+			if (row === void 0) {
+				row = {
+					title: foldSessionTitle(events),
+					total: 0
+				};
+				rows.set(id, row);
+			}
+			for (const event of events) {
+				if (beijingDayKey(new Date(event.time)) !== dayKey) continue;
+				collected += 1;
+				if (collected > maxEvents) {
+					truncated = true;
+					return;
 				}
+				const priced = priceEvent(event, billing, names);
+				if (priced !== void 0) row.total += priced.cost;
+			}
+		};
+		if (sessions !== void 0) {
+			const store = sessions();
+			if (store !== void 0) for (const session of store.list()) {
+				liveIds.add(session.id);
+				collect(session.id, session.events);
 				if (truncated) break;
 			}
 		}
@@ -792,15 +1099,7 @@ var TodaySpendScanner = class {
 				if (liveIds.has(header.id)) continue;
 				if (this.lastEventsScan?.get(header.id) === revision) continue;
 				try {
-					const inspection = await persistenceService.inspect(header.id);
-					for (const event of inspection.events) {
-						if (beijingDayKey(new Date(event.time)) !== dayKey) continue;
-						events.push(event);
-						if (events.length >= maxEvents) {
-							truncated = true;
-							break;
-						}
-					}
+					collect(header.id, (await persistenceService.inspect(header.id)).events);
 				} catch (error) {
 					logger.warn(`llm-billing: skipping unreadable session ${header.id}: ${String(error)}`);
 				}
@@ -809,7 +1108,11 @@ var TodaySpendScanner = class {
 			if (!truncated) this.lastEventsScan = new Map(snapshots.map((snapshot) => [snapshot.header.id, snapshot.revision]));
 		}
 		if (truncated) logger.warn(`llm-billing: today's events exceeded ${maxEvents}; result truncated`);
-		return computeTodaySpend(events, billing, catalog, /* @__PURE__ */ new Date(`${dayKey}T00:00:00Z`));
+		return [...rows.entries()].filter(([, row]) => row.total > 0).map(([sessionId, row]) => ({
+			sessionId,
+			title: row.title,
+			total: row.total
+		}));
 	}
 };
 //#endregion
@@ -829,6 +1132,11 @@ var TodaySpendScanner = class {
 * session-projection registry is composed, the plugin additionally registers
 * the `billingTodaySpend` projection unit, which folds each session's spend
 * eagerly and lets cold reads ride the projection-cache ladder.
+*
+* A per-session spend cache makes the badge's turn-settled recompute
+* incremental: session logs are append-only and chronological (the same
+* assumption the projection unit makes), so the spend is reused while the log
+* length is unchanged, and only the appended tail is priced when it grows.
 * @module @rayadesu/dsh-llm-billing
 */
 const name = "llm-billing";
@@ -928,8 +1236,26 @@ function apply(ctx, config) {
 		id: model.id,
 		name: model.name ?? model.id
 	}));
+	const sessionSpendCache = /* @__PURE__ */ new Map();
 	const fetchSessionSpend = async (sessionId) => {
-		return computeSessionSpend(await sessionEvents(ctx, sessionId), billing, catalog);
+		const events = await sessionEvents(ctx, sessionId);
+		const cached = sessionSpendCache.get(sessionId);
+		if (cached !== void 0 && cached.count === events.length) return cached.spend;
+		if (cached !== void 0 && cached.count < events.length) {
+			const spend = mergeTodaySpend(cached.spend, computeSessionSpend(events.slice(cached.count), billing, catalog));
+			sessionSpendCache.set(sessionId, {
+				count: events.length,
+				spend
+			});
+			return spend;
+		}
+		const spend = computeSessionSpend(events, billing, catalog);
+		if (sessionSpendCache.size >= 1024) sessionSpendCache.clear();
+		sessionSpendCache.set(sessionId, {
+			count: events.length,
+			spend
+		});
+		return spend;
 	};
 	const unit = billingTodaySpendDefinition(billing, catalog);
 	let unitRegistered = false;
@@ -953,12 +1279,19 @@ function apply(ctx, config) {
 		catalog
 	});
 	const todayCache = new TodaySpendCache((dayKey) => scanner.scan(dayKey), TODAY_SPEND_CACHE_MS);
+	const todaySessionsCache = new TodaySpendCache((dayKey) => scanner.scanSessions(dayKey), TODAY_SPEND_CACHE_MS);
 	const fetchTodaySpend = async (force = false) => todayCache.get(force);
+	const fetchTodaySessionsSpend = async (force = false) => todaySessionsCache.get(force);
+	const fetchTurnSpend = async (sessionId, messageId) => {
+		return computeTurnSpend(await sessionEvents(ctx, sessionId), billing, catalog, messageId);
+	};
 	new DeepSeekBalanceGateway(ctx, {
 		fetchBalance,
 		fetchSessionSpend,
-		fetchTodaySpend
+		fetchTodaySpend,
+		fetchTodaySessionsSpend,
+		fetchTurnSpend
 	});
 }
 //#endregion
-export { BILLING_UNIT_KEY, Config, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, DeepSeekBalanceGateway, PUBLIC_BASE_URL, TODAY_SPEND_CACHE_MS, TODAY_SPEND_MAX_EVENTS, TodaySpendCache, TodaySpendScanner, addEventContribution, apply, beijingDayKey, billingTodaySpendDefinition, computeSessionSpend, computeTodaySpend, emptyTodaySpend, fetchDeepSeekBalance, foldBillingUnit, isPeak, mergeTodaySpend, name, parseDeepSeekBalance, priceEvent, resolveBilling };
+export { BILLING_UNIT_KEY, Config, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, DeepSeekBalanceGateway, PUBLIC_BASE_URL, SpendAccumulator, TODAY_SPEND_CACHE_MS, TODAY_SPEND_MAX_EVENTS, TodaySpendCache, TodaySpendScanner, addEventContribution, apply, beijingDayKey, billingTodaySpendDefinition, computeSessionSpend, computeTodaySpend, computeTurnSpend, emptyTodaySpend, fetchDeepSeekBalance, foldBillingUnit, foldSessionTitle, isPeak, mergeTodaySpend, name, parseDeepSeekBalance, priceEvent, resolveBilling };