@rayadesu/dsh-llm-billing 0.3.11 → 0.3.13

package/lib/index.js

@@ -136,6 +136,7 @@ let DeepSeekBalanceGateway = (() => {
 	let _getSessionSpend_decorators;
 	let _getTodaySpend_decorators;
 	let _getTodaySessionsSpend_decorators;
+	let _getDelegatedSpend_decorators;
 	let _getTurnSpend_decorators;
 	let _getSessionTurnSpends_decorators;
 	return class DeepSeekBalanceGateway extends _classSuper {
@@ -145,6 +146,7 @@ let DeepSeekBalanceGateway = (() => {
 			_getSessionSpend_decorators = [Remote("getSessionSpend")];
 			_getTodaySpend_decorators = [Remote("getTodaySpend")];
 			_getTodaySessionsSpend_decorators = [Remote("getTodaySessionsSpend")];
+			_getDelegatedSpend_decorators = [Remote("getDelegatedSpend")];
 			_getTurnSpend_decorators = [Remote("getTurnSpend")];
 			_getSessionTurnSpends_decorators = [Remote("getSessionTurnSpends")];
 			__esDecorate(this, null, _getBalance_decorators, {
@@ -191,6 +193,17 @@ let DeepSeekBalanceGateway = (() => {
 				},
 				metadata: _metadata
 			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _getDelegatedSpend_decorators, {
+				kind: "method",
+				name: "getDelegatedSpend",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "getDelegatedSpend" in obj,
+					get: (obj) => obj.getDelegatedSpend
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
 			__esDecorate(this, null, _getTurnSpend_decorators, {
 				kind: "method",
 				name: "getTurnSpend",
@@ -263,7 +276,9 @@ let DeepSeekBalanceGateway = (() => {
 		/**
 		* Read today's billed spend per session, restricted to the queried Beijing
 		* day. Rows carry the session's durable title and sort by cost descending;
-		* sessions with no priced usage on the day are omitted.
+		* sessions with no priced usage on the day are omitted, and every subagent
+		* session is merged into the row of the top-level session that delegated it,
+		* so the ranking lists conversations rather than delegations.
 		* @param force - bypass the host-side 60s cache (manual refresh); omitted
 		*   means a cached read.
 		* @returns today's per-session rows, highest first.
@@ -272,6 +287,19 @@ let DeepSeekBalanceGateway = (() => {
 			return this.options.fetchTodaySessionsSpend(force ?? false);
 		}
 		/**
+		* Read the subagent part of one conversation's billed spend: every subagent
+		* session the given session delegated, transitively, across every day (a
+		* session's own log cannot price its delegation children). `isSubagent`
+		* reports whether the queried session is itself a delegated child.
+		* @param sessionId - the session whose delegated subtree to sum.
+		* @param force - bypass the host-side 60s cache (manual refresh); omitted
+		*   means a cached read.
+		* @returns the delegated subtotal plus its per-model rows.
+		*/
+		getDelegatedSpend(sessionId, force) {
+			return this.options.fetchDelegatedSpend(sessionId, force ?? false);
+		}
+		/**
 		* Read one completed Turn's billed spend (same per-event pricing as
 		* {@link priceEvent}).
 		* @param sessionId - the session owning the Turn.
@@ -1298,13 +1326,23 @@ function foldOwnBilling(unit, events, seedLength = 0) {
 *   every 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.
+*   adopting the fold it already priced for a session whose persisted revision
+*   is unchanged since the last pass.
 *
 * Both strategies run behind the same {@link TodaySpendCache}, so a miss
 * happens at most once per 60 seconds per process, and a manual refresh
 * (`force`) bypasses the time window but keeps the revision caches — an
-* unchanged log provably cannot change the aggregate.
+* unchanged log provably cannot change the aggregate. That proof is what makes
+* a revision gate a CACHE: both strategies therefore adopt the resolution they
+* remember for an unchanged revision instead of skipping the session, so an
+* unchanged log costs no I/O and still contributes its full spend (and title)
+* to the aggregate and the ranking on every scan.
+*
+* The per-session ranking is a per-CONVERSATION ranking: a subagent child is
+* work the delegating conversation paid for, not a session the user opened, so
+* every subagent row is folded into the row of the top-level session at the
+* root of its `parentSession` chain (see {@link rollUpSubagentSpend}). The
+* aggregate is unaffected — it sums the same sessions either way.
 *
 * Forked sessions never double-count: a fork child's log opens with a
 * verbatim copy of its source session's events (its inherited boundary), so
@@ -1344,6 +1382,79 @@ function foldSessionTitle(events) {
 	return null;
 }
 /**
+* Whether one session's durable header marks it as a subagent child. Either
+* marker is enough: `origin` is DSH's navigation classification and
+* `delegationDepth` is its persisted recursion budget, so a header carrying
+* only the depth (or only the origin) is still a delegation child. A session
+* created without either — an ordinary session, a user fork, or a cold resume
+* — is top-level.
+* @param header - the session's lineage slice; `undefined` reads as top-level.
+* @returns true when the session was created as a subagent child.
+*/
+function isSubagentSession(header) {
+	if (header === void 0) return false;
+	return header.origin === "subagent" || (header.delegationDepth ?? 0) > 0;
+}
+/**
+* The top-level session one session's ranking row belongs to: the session
+* itself for a top-level session, and for a subagent child the first ancestor
+* up the `parentSession` chain that is not itself a subagent child. A
+* multi-generation delegation (a subagent that spawned subagents) therefore
+* lands on the same root row as its parent, and a child whose parent header is
+* unknown is attributed to the parent id its own header names — the parent is
+* authoritative even when its log is not part of this scan.
+* @param id - the session whose row is being attributed.
+* @param lineage - lineage of every session this scan saw, by id.
+* @returns the session id whose ranking row the input belongs to.
+*/
+function topLevelSessionOf(id, lineage) {
+	let current = id;
+	const seen = /* @__PURE__ */ new Set([current]);
+	for (;;) {
+		const header = lineage.get(current);
+		if (!isSubagentSession(header)) return current;
+		const parent = header?.parentSession;
+		if (parent === void 0 || seen.has(parent)) return current;
+		seen.add(parent);
+		current = parent;
+	}
+}
+/**
+* Fold every subagent child's row into the top-level row it belongs to
+* ({@link topLevelSessionOf}), so the ranking lists conversations rather than
+* every delegation a conversation started. A child's spend is added to its
+* ancestor's `total`; the ancestor's `ownTotal` keeps its own spend only. A
+* top-level session whose own day was empty but whose subagents priced
+* something still gets a row (with `ownTotal` 0), carrying the title the scan
+* resolved for it in `titles`.
+* @param rows - one row per session that priced something today (own spends).
+* @param lineage - lineage of every session this scan saw, by id.
+* @param titles - resolved display titles by session id; a session absent from
+*   the map has no resolved title and its created row reports `null`.
+* @returns the merged rows, sorted by `total` descending.
+*/
+function rollUpSubagentSpend(rows, lineage, titles = /* @__PURE__ */ new Map()) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const target = topLevelSessionOf(row.sessionId, lineage);
+		const carried = merged.get(target);
+		if (carried === void 0) {
+			merged.set(target, target === row.sessionId ? row : {
+				sessionId: target,
+				title: titles.get(target) ?? null,
+				total: row.total,
+				ownTotal: 0
+			});
+			continue;
+		}
+		merged.set(target, {
+			...carried,
+			total: carried.total + row.total
+		});
+	}
+	return [...merged.values()].sort((left, right) => right.total - left.total);
+}
+/**
 * Read one live session's complete event log across both runtime families.
 * @throws when the session exposes neither the legacy `events` snapshot nor
 *   the newer `snapshotEvents()` reader — an unknown runtime surface must
@@ -1484,23 +1595,78 @@ function evictOldest$1(map, limit) {
 	if (oldest !== void 0) map.delete(oldest);
 }
 /**
+* The merged whole-session spend of every subagent session delegated FROM one
+* session, transitively: the subagent subtotal a conversation's own log cannot
+* price. Only sessions DSH marked as delegation children count, so a user fork
+* (which names a `parentSession` too) is never billed into its source. A
+* malformed lineage that points back at the queried session is ignored rather
+* than counted twice.
+* @param id - the session whose delegated subtree to sum.
+* @param ownSpend - whole-session own spend per session, from one scan pass.
+* @param lineage - lineage per session, from the same pass.
+* @returns the merged subtree spend; empty when the session delegated nothing priced.
+*/
+function delegatedSpendOf(id, ownSpend, lineage) {
+	const children = /* @__PURE__ */ new Map();
+	for (const [childId, header] of lineage) {
+		const parent = header.parentSession;
+		if (parent === void 0 || !isSubagentSession(header)) continue;
+		const siblings = children.get(parent);
+		if (siblings === void 0) children.set(parent, [childId]);
+		else siblings.push(childId);
+	}
+	const seen = /* @__PURE__ */ new Set([id]);
+	const pending = [...children.get(id) ?? []];
+	for (const child of pending) seen.add(child);
+	let total = emptyTodaySpend();
+	while (pending.length > 0) {
+		const current = pending.pop();
+		total = mergeTodaySpend(total, ownSpend.get(current) ?? emptyTodaySpend());
+		for (const child of children.get(current) ?? []) {
+			if (seen.has(child)) continue;
+			seen.add(child);
+			pending.push(child);
+		}
+	}
+	return total;
+}
+/**
 * The aggregate computation behind a cache miss. Chooses the projection path
 * when the projection registry is composed, the events path otherwise; both
-* gate cold reads on persisted revisions so steady-state scans touch only
-* sessions whose logs actually changed.
+* gate cold reads on persisted revisions AND adopt the fold they already hold
+* for an unchanged log, so steady-state scans re-read only sessions whose logs
+* actually changed while every unchanged session keeps contributing.
 */
 var TodaySpendScanner = class {
 	deps;
-	/** Cold sessions resolved on the projection path: id → revision + unit state + title. */
+	/**
+	* Cold sessions resolved by either strategy: id → the persisted revision the
+	* resolution saw, the session's OWN-events fold, and its folded title.
+	*
+	* The two strategies differ in how they PRICE a cold log (an eager projection
+	* cell plus the cache ladder, or a local fold over the read log), never in
+	* what an unchanged log contributes to the day — so one memory serves both.
+	* The projection path reuses the resolved unit; the events path reuses the
+	* fold it priced on the previous pass. A strategy that skipped an unchanged
+	* log WITHOUT adopting its remembered fold would silently drop that session
+	* from the aggregate and the ranking on every scan after the first.
+	*/
 	coldResolved = /* @__PURE__ */ new Map();
 	/** Cold sessions whose resolution failed: id → revision (retried only when the log changes). */
 	coldFailed = /* @__PURE__ */ new Map();
-	/** Cold sessions resolved on the events path: id → revision (events were collected). */
-	lastEventsScan;
 	constructor(deps) {
 		this.deps = deps;
 	}
 	/**
+	* Remember one cold session's resolution, bounded by
+	* {@link COLD_RESOLVE_CACHE_LIMIT}: evicting the oldest entry (instead of
+	* clearing) keeps the other sessions' resolved state warm across scans.
+	*/
+	rememberCold(id, resolution) {
+		evictOldest$1(this.coldResolved, COLD_RESOLVE_CACHE_LIMIT);
+		this.coldResolved.set(id, resolution);
+	}
+	/**
 	* Compute today's aggregate for one Beijing day.
 	* @param dayKey - the Beijing-time calendar-day key to aggregate.
 	* @returns today's spend across every session.
@@ -1510,8 +1676,11 @@ var TodaySpendScanner = class {
 	}
 	/**
 	* 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.
+	* descending. One row per top-level session: sessions with no priced usage
+	* on the day are omitted (unless their subagents priced something, which the
+	* roll-up merges into their row), every subagent session is folded into the
+	* top-level session that delegated it, and 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.
 	*/
@@ -1524,6 +1693,9 @@ var TodaySpendScanner = class {
 	* read, unit fold, and title fold instead of scanning twice. Chooses the
 	* projection path when the projection registry is composed, the events path
 	* otherwise.
+	*
+	* The aggregate sums every priced session, subagents included — the ranking's
+	* subagent roll-up only regroups rows, so neither total moves.
 	* @param dayKey - the Beijing-time calendar-day key to aggregate.
 	* @returns the aggregate plus per-session rows sorted by cost descending.
 	*/
@@ -1533,7 +1705,7 @@ var TodaySpendScanner = class {
 		return this.scanDetailProjections(dayKey);
 	}
 	/**
-	* Resolve one cold session's billing unit state and display title.
+	* Resolve one cold session's billing fold state and display title.
 	*
 	* The zero-I/O projection-cache row answers the query directly whenever its
 	* own latest priced day is NOT the queried day: the row then proves the
@@ -1551,7 +1723,7 @@ var TodaySpendScanner = class {
 	* @param header - the listed session header (the cache identity witness).
 	* @param seeded - whether the session carries a fork-inherited prefix.
 	* @param dayKey - the Beijing-time day being aggregated.
-	* @returns the resolved state and title, or `undefined` when unreadable.
+	* @returns the resolved fold state and title, or `undefined` when unreadable.
 	*/
 	async resolveCold(header, seeded, dayKey) {
 		const { persistence, projectionCache, logger } = this.deps;
@@ -1560,7 +1732,7 @@ var TodaySpendScanner = class {
 			if (cache !== void 0) try {
 				const value = cache.cachedSnapshot(header, 0, [BILLING_UNIT_KEY])?.values[BILLING_UNIT_KEY];
 				if (value !== void 0 && value.dayKey !== dayKey) return {
-					value,
+					fold: value,
 					title: null
 				};
 			} catch (error) {
@@ -1572,7 +1744,7 @@ var TodaySpendScanner = class {
 		try {
 			const read = await persistenceInspect(persistenceService, header.id);
 			return {
-				value: foldOwnBilling(this.deps.unit, read.events, read.seedLength),
+				fold: foldOwnBilling(this.deps.unit, read.events, read.seedLength),
 				title: foldSessionTitle(read.events)
 			};
 		} catch (error) {
@@ -1595,11 +1767,11 @@ var TodaySpendScanner = class {
 	/**
 	* Cold-ladder adopt: for every stored session not live, either the
 	* revision-gated resolution already in {@link coldResolved} is adopted
-	* (unchanged log costs nothing) or the session is queued behind a bounded
-	* parallel fan-out, resolved, remembered, and then adopted. A session whose
-	* resolution failed is remembered too (by revision), so an unreadable log
-	* is not re-read on every scan; a changed revision retries it. One
-	* unreadable session never blanks the whole-day aggregate.
+	* (unchanged log costs nothing and still counts) or the session is queued
+	* behind a bounded parallel fan-out, resolved, remembered, and then adopted.
+	* A session whose resolution failed is remembered too (by revision), so an
+	* unreadable log is not re-read on every scan; a changed revision retries it.
+	* One unreadable session never blanks the whole-day aggregate.
 	* @param liveIds - ids of sessions already folded from the live store.
 	* @param snapshots - stored snapshot list (either runtime family).
 	* @param dayKey - the Beijing-time day being aggregated.
@@ -1627,8 +1799,7 @@ var TodaySpendScanner = class {
 			const resolved = await this.resolveCold(header, seeded, dayKey);
 			if (resolved !== void 0) {
 				this.coldFailed.delete(header.id);
-				evictOldest$1(this.coldResolved, COLD_RESOLVE_CACHE_LIMIT);
-				this.coldResolved.set(header.id, {
+				this.rememberCold(header.id, {
 					revision,
 					...resolved
 				});
@@ -1645,14 +1816,17 @@ var TodaySpendScanner = class {
 	/**
 	* Events-path collection shared by both aggregate and per-session scans:
 	* fold each session's log with the shared pricing fold (attempt samples with
-	* same-step replacement) and announce the session's latest-day spend, gated
-	* by revisions — a persisted session whose log did not change since the last
-	* scan is skipped. A fork child's inherited prefix (`seq < seedLength`) is
-	* skipped, so each model output is priced only in its source session. The
-	* hard cap counts the queried day's events; the revision watermark only
-	* advances on a complete pass.
+	* same-step replacement) and announce the session's latest-day spend. A
+	* persisted session whose log did not change since it was last resolved is
+	* answered from {@link coldResolved} instead of being re-read: it keeps
+	* counting toward the aggregate and the ranking at zero cost, which is what
+	* makes the revision gate a cache rather than a way to lose sessions. A fork
+	* child's inherited prefix (`seq < seedLength`) is skipped, so each model
+	* output is priced only in its source session. The hard cap counts the
+	* queried day's events; a truncated pass remembers nothing it read, so the
+	* next one re-reads whatever this one cut short.
 	* @param dayKey - the Beijing-time calendar-day key to aggregate.
-	* @param onSession - fold one session's state plus its complete log.
+	* @param onSession - adopt one session's fold, title, and lineage.
 	* @returns whether the hard cap truncated the scan.
 	*/
 	async collectTodayEvents(dayKey, onSession) {
@@ -1660,7 +1834,8 @@ var TodaySpendScanner = class {
 		const liveIds = /* @__PURE__ */ new Set();
 		let collected = 0;
 		let truncated = false;
-		const collect = (id, events, seedLength) => {
+		/** Price one complete log, announce it, and return what to remember. */
+		const collect = (id, events, seedLength, lineage) => {
 			const folder = new BillingFolder(billing, catalog, seedLength);
 			for (const event of events) {
 				if (beijingPartsOf(event.time).dayKey === dayKey) {
@@ -1672,13 +1847,19 @@ var TodaySpendScanner = class {
 				}
 				folder.add(event);
 			}
-			onSession(id, folder.fold, events);
+			const fold = folder.fold;
+			const title = foldSessionTitle(events);
+			onSession(id, fold, title, lineage);
+			return {
+				fold,
+				title
+			};
 		};
 		if (sessions !== void 0) {
 			const store = sessions();
 			if (store !== void 0) for (const session of store.list()) {
 				liveIds.add(session.id);
-				collect(session.id, liveSessionEvents(session), forkBoundaryOf(session));
+				collect(session.id, liveSessionEvents(session), forkBoundaryOf(session), session.header ?? {});
 				if (truncated) break;
 			}
 		}
@@ -1687,16 +1868,23 @@ var TodaySpendScanner = class {
 			const snapshots = await persistenceListSnapshots(persistenceService);
 			for (const { header, revision } of snapshots) {
 				if (liveIds.has(header.id)) continue;
-				if (this.lastEventsScan?.get(header.id) === revision) continue;
+				const resolved = this.coldResolved.get(header.id);
+				if (resolved !== void 0 && resolved.revision === revision) {
+					onSession(header.id, resolved.fold, resolved.title, header);
+					continue;
+				}
 				try {
 					const read = await persistenceInspect(persistenceService, header.id);
-					collect(header.id, read.events, read.seedLength);
+					const priced = collect(header.id, read.events, read.seedLength, header);
+					if (!truncated) this.rememberCold(header.id, {
+						revision,
+						...priced
+					});
 				} 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 truncated;
@@ -1706,7 +1894,9 @@ var TodaySpendScanner = class {
 	* (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 answered from the projection cache). A fork child's cell covers its
-	* inherited prefix, so its own-events fold supplies both outputs.
+	* inherited prefix, so its own-events fold supplies both outputs. Lineage
+	* (which session delegated which) comes from the same headers the boundary
+	* does, so the ranking's subagent roll-up costs no extra read.
 	* @param dayKey - the Beijing-time calendar-day key to aggregate.
 	* @returns the aggregate plus per-session rows, sorted by cost descending.
 	*/
@@ -1715,71 +1905,107 @@ var TodaySpendScanner = class {
 		const projectionsService = projections?.();
 		let aggregate = emptyTodaySpend();
 		const rows = /* @__PURE__ */ new Map();
+		const lineage = /* @__PURE__ */ new Map();
+		const titles = /* @__PURE__ */ new Map();
+		const ownSpend = /* @__PURE__ */ new Map();
+		const createdAt = /* @__PURE__ */ new Map();
 		const liveIds = /* @__PURE__ */ new Set();
 		if (sessions !== void 0) {
 			const store = sessions();
 			if (store !== void 0) for (const { session, state } of this.liveBillingEntries(store, projectionsService)) {
 				liveIds.add(session.id);
-				if (state === void 0 || state.dayKey !== dayKey) continue;
+				lineage.set(session.id, session.header ?? {});
+				const born = session.header?.createdAt;
+				if (born !== void 0) createdAt.set(session.id, born);
+				const title = foldSessionTitle(liveSessionEvents(session));
+				titles.set(session.id, title);
+				if (state === void 0) continue;
+				ownSpend.set(session.id, state.session);
+				if (state.dayKey !== dayKey) continue;
 				aggregate = mergeTodaySpend(aggregate, state.spend);
 				rows.set(session.id, {
 					sessionId: session.id,
-					title: foldSessionTitle(liveSessionEvents(session)),
-					total: state.spend.total
+					title,
+					total: state.spend.total,
+					ownTotal: state.spend.total
 				});
 			}
 		}
 		const persistenceService = persistence?.();
 		if (persistenceService !== void 0) {
 			const snapshots = await persistenceListSnapshots(persistenceService);
+			for (const { header } of snapshots) {
+				if (liveIds.has(header.id)) continue;
+				lineage.set(header.id, header);
+				if (header.createdAt !== void 0) createdAt.set(header.id, header.createdAt);
+			}
 			await this.coldAdopt(liveIds, snapshots, dayKey, (id, resolved) => {
-				if (resolved.value.dayKey !== dayKey) return;
-				aggregate = mergeTodaySpend(aggregate, resolved.value.spend);
+				if (resolved.title !== null && !titles.has(id)) titles.set(id, resolved.title);
+				ownSpend.set(id, resolved.fold.session);
+				if (resolved.fold.dayKey !== dayKey) return;
+				aggregate = mergeTodaySpend(aggregate, resolved.fold.spend);
 				rows.set(id, {
 					sessionId: id,
 					title: resolved.title,
-					total: resolved.value.spend.total
+					total: resolved.fold.spend.total,
+					ownTotal: resolved.fold.spend.total
 				});
 			});
 		}
 		return {
 			aggregate,
-			sessions: sortRows(rows)
+			sessions: rollUpSubagentSpend([...rows.values()], lineage, titles),
+			dayKey,
+			ownSpend,
+			lineage,
+			createdAt
 		};
 	}
 	/**
 	* Events path, one pass for both outputs: price today's events (per-event
-	* Beijing-day filter during collection, hard cap), gated by revisions. A
+	* Beijing-day filter during collection, hard cap), revision-gated so an
+	* unchanged log is adopted from {@link coldResolved} instead of re-read. A
 	* fork child's inherited prefix (`seq < seedLength`) is skipped, so each
 	* model output is priced only in its source session. 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.
+	* rename is reflected as soon as the session's log is re-read, and an
+	* unchanged session keeps the title its earlier read folded. Lineage comes
+	* from the same headers, which the ranking roll-up needs.
 	* @param dayKey - the Beijing-time calendar-day key to aggregate.
 	* @returns the aggregate plus per-session rows, sorted by cost descending.
 	*/
 	async scanDetailEvents(dayKey) {
 		let aggregate = emptyTodaySpend();
-		const sessions = [];
-		await this.collectTodayEvents(dayKey, (id, fold, events) => {
+		const rows = [];
+		const lineage = /* @__PURE__ */ new Map();
+		const titles = /* @__PURE__ */ new Map();
+		const ownSpend = /* @__PURE__ */ new Map();
+		const createdAt = /* @__PURE__ */ new Map();
+		await this.collectTodayEvents(dayKey, (id, fold, title, sessionLineage) => {
+			lineage.set(id, sessionLineage);
+			titles.set(id, title);
+			const born = sessionLineage.createdAt;
+			if (born !== void 0) createdAt.set(id, born);
+			ownSpend.set(id, fold.session);
 			if (fold.dayKey !== dayKey) return;
 			aggregate = mergeTodaySpend(aggregate, fold.spend);
-			sessions.push({
+			rows.push({
 				sessionId: id,
-				title: foldSessionTitle(events),
-				total: fold.spend.total
+				title,
+				total: fold.spend.total,
+				ownTotal: fold.spend.total
 			});
 		});
-		sessions.sort((left, right) => right.total - left.total);
 		return {
 			aggregate,
-			sessions
+			sessions: rollUpSubagentSpend(rows, lineage, titles),
+			dayKey,
+			ownSpend,
+			lineage,
+			createdAt
 		};
 	}
 };
-/** Per-session rows from the map, highest total first. */
-function sortRows(rows) {
-	return [...rows.values()].sort((left, right) => right.total - left.total);
-}
 //#endregion
 //#region lib/types/index.js
 /**
@@ -2021,11 +2247,15 @@ function createUnitRegistrar(ctx, unit) {
 *   events path serves today's spend.
 * - plans A1–A3: the scanner chooses the projection path when the registry
 *   is composed, the events path otherwise.
+* All three reads come from ONE cached pass: the day's aggregate, its
+* per-session ranking, and the delegated-subagent subtree of a conversation
+* (the same pass folds each session's whole-session total, so the subtree read
+* costs no second scan).
 * @param ctx - plugin context.
 * @param facts - resolved endpoint, credential, pricing, and catalog facts.
 * @param unit - the shared projection unit definition.
 * @param ensureUnit - idempotent unit registrar (last-resort registration).
-* @returns the two today-spend loaders.
+* @returns the three today-spend loaders.
 */
 function createTodaySpendLoaders(ctx, facts, unit, ensureUnit) {
 	const scanner = new TodaySpendScanner({
@@ -2043,7 +2273,18 @@ function createTodaySpendLoaders(ctx, facts, unit, ensureUnit) {
 	const todayCache = new TodaySpendCache((dayKey) => scanner.scanDetail(dayKey), TODAY_SPEND_CACHE_MS);
 	return {
 		fetchTodaySpend: async (force = false) => (await todayCache.get(force)).aggregate,
-		fetchTodaySessionsSpend: async (force = false) => ({ sessions: (await todayCache.get(force)).sessions })
+		fetchTodaySessionsSpend: async (force = false) => ({ sessions: (await todayCache.get(force)).sessions }),
+		fetchDelegatedSpend: async (sessionId, force = false) => {
+			const detail = await todayCache.get(force);
+			const spend = delegatedSpendOf(sessionId, detail.ownSpend, detail.lineage);
+			const createdAt = detail.createdAt.get(sessionId);
+			return {
+				total: spend.total,
+				models: spend.models,
+				isSubagent: isSubagentSession(detail.lineage.get(sessionId)),
+				crossedDay: createdAt !== void 0 && beijingDayKey(new Date(createdAt)) !== detail.dayKey
+			};
+		}
 	};
 }
 /** One completed Turn's spend loader, located by its closing message id. */
@@ -2128,7 +2369,7 @@ function apply(ctx, config) {
 	ctx.on("session/created", ensureUnit);
 	const fetchBalance = createBalanceFetcher(ctx, facts);
 	const fetchSessionSpend = createSessionSpendFetcher(ctx, facts);
-	const { fetchTodaySpend, fetchTodaySessionsSpend } = createTodaySpendLoaders(ctx, facts, unit, ensureUnit);
+	const { fetchTodaySpend, fetchTodaySessionsSpend, fetchDelegatedSpend } = createTodaySpendLoaders(ctx, facts, unit, ensureUnit);
 	const fetchTurnSpend = createTurnSpendFetcher(ctx, facts);
 	const fetchTurnSpends = createTurnSpendsFetcher(ctx, facts);
 	new DeepSeekBalanceGateway(ctx, {
@@ -2136,9 +2377,10 @@ function apply(ctx, config) {
 		fetchSessionSpend,
 		fetchTodaySpend,
 		fetchTodaySessionsSpend,
+		fetchDelegatedSpend,
 		fetchTurnSpend,
 		fetchTurnSpends
 	});
 }
 //#endregion
-export { BALANCE_CACHE_MS, BALANCE_TIMEOUT_MS, BILLING_UNIT_KEY, BillingFolder, Config, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, DeepSeekBalanceGateway, FLASH_SERIES_RATE_CHANGE_AT, PUBLIC_BASE_URL, SESSION_SPEND_CACHE_LIMIT, SESSION_TURN_SPEND_CACHE_LIMIT, SessionTurnSpendFolder, SpendAccumulator, TODAY_SPEND_CACHE_MS, TODAY_SPEND_MAX_EVENTS, TodaySpendCache, TodaySpendScanner, V4_PRO_ROUTE_SWITCH_AT, addEventContribution, apply, applyBillingEvent, beijingDayKey, billingTodaySpendDefinition, computeSessionSpend, computeSessionTurnSpends, computeTodaySpend, computeTurnSpend, emptyBillingFoldState, emptyTodaySpend, fetchDeepSeekBalance, foldBillingUnit, foldOwnBilling, foldSessionTitle, forkBoundaryOf, isPeak, isSeededSession, liveSessionEvents, mergeTodaySpend, name, negateSpend, parseDeepSeekBalance, persistenceInspect, persistenceListSnapshots, priceEvent, priceUsage, resolveBilling, subtractSpend };
+export { BALANCE_CACHE_MS, BALANCE_TIMEOUT_MS, BILLING_UNIT_KEY, BillingFolder, Config, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, DeepSeekBalanceGateway, FLASH_SERIES_RATE_CHANGE_AT, PUBLIC_BASE_URL, SESSION_SPEND_CACHE_LIMIT, SESSION_TURN_SPEND_CACHE_LIMIT, SessionTurnSpendFolder, SpendAccumulator, TODAY_SPEND_CACHE_MS, TODAY_SPEND_MAX_EVENTS, TodaySpendCache, TodaySpendScanner, V4_PRO_ROUTE_SWITCH_AT, addEventContribution, apply, applyBillingEvent, beijingDayKey, billingTodaySpendDefinition, computeSessionSpend, computeSessionTurnSpends, computeTodaySpend, computeTurnSpend, delegatedSpendOf, emptyBillingFoldState, emptyTodaySpend, fetchDeepSeekBalance, foldBillingUnit, foldOwnBilling, foldSessionTitle, forkBoundaryOf, isPeak, isSeededSession, isSubagentSession, liveSessionEvents, mergeTodaySpend, name, negateSpend, parseDeepSeekBalance, persistenceInspect, persistenceListSnapshots, priceEvent, priceUsage, resolveBilling, rollUpSubagentSpend, subtractSpend, topLevelSessionOf };