@rayadesu/dsh-llm-billing 0.3.8 → 0.3.9

package/lib/types/today-spend.js

@@ -4,11 +4,13 @@
  * compute the aggregate behind a cache miss:
  *
  * - projection path (plan C): live sessions read their eagerly folded
- *   `billingTodaySpend` projection cell; cold sessions resolve through the
- *   projection-cache ladder (cached row + tail replay + registry restore,
- *   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.
+ *   `billingTodaySpend` projection cell; cold sessions are answered from the
+ *   zero-I/O projection-cache row whenever that row's own day is not the
+ *   queried one, and otherwise resolved through 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 — and a
+ *   failed resolution is remembered by revision instead of being retried on
+ *   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
@@ -20,14 +22,15 @@
  * unchanged log provably cannot change the aggregate.
  *
  * 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 the scanner prices only the child's OWN events on every path — the
- * projection path bypasses the eager cell for a seeded session and folds its
- * own events instead (the cell covers the inherited prefix too), and the cold
- * ladder skips the projection cache for a seeded session (its cached row
- * predates the boundary and covers inherited events). The boundary is the
- * durable session state, read across both DSH runtime families — a resumed
- * fork child keeps its original boundary and an unseeded session stays at 0.
+ * verbatim copy of its source session's events (its inherited boundary), so
+ * the scanner prices only the child's OWN events on every path. The
+ * `billingTodaySpend` unit is boundary-aware (its state carries the inherited
+ * cut, and `apply` skips events below it), so the eager cell is correct for a
+ * fork child; the cold path skips the projection cache for a seeded session
+ * (its cached row may predate the boundary) and folds its own events with the
+ * durable cut instead. The boundary is the durable session state, read across
+ * both DSH runtime families — a resumed fork child keeps its original
+ * boundary and an unseeded session stays at 0.
  *
  * The live `Session` log surface changed in 0.1.2-alpha.4: `Session.events`
  * was removed and replaced by `Session.snapshotEvents()` / `ownEvents()`, and
@@ -38,7 +41,7 @@
  * and on the newer runtime.
  * @module @rayadesu/dsh-llm-billing/today-spend
  */
-import { beijingDayKey, emptyTodaySpend, forkBoundaryOf, isSeededSession, mergeTodaySpend, priceEvent, SpendAccumulator } from "./billing.js";
+import { beijingDayKey, beijingPartsOf, BillingFolder, emptyTodaySpend, forkBoundaryOf, isSeededSession, mergeTodaySpend } from "./billing.js";
 import { BILLING_UNIT_KEY, foldOwnBilling } from "./projection.js";
 /**
  * Fold one session's durable display title: the latest `session/title`
@@ -75,6 +78,18 @@ export function liveSessionEvents(session) {
         return session.snapshotEvents();
     throw new Error('llm-billing: session log surface is neither Session.events nor Session.snapshotEvents');
 }
+/**
+ * Unwrap a handle read across both return shapes.
+ * @param read - the handle's read result.
+ * @returns the event array.
+ */
+export function handleReadEvents(read) {
+    // `Array.isArray` does not narrow readonly arrays out of a union, so the
+    // branches are asserted explicitly.
+    if (Array.isArray(read))
+        return read;
+    return read.events;
+}
 function isHandlePersistence(persistence) {
     return typeof persistence.open === 'function';
 }
@@ -102,7 +117,7 @@ export async function persistenceInspect(persistence, id) {
     if (isHandlePersistence(persistence)) {
         const handle = await persistence.open(id, 'read');
         try {
-            return { events: await handle.read(), seedLength: forkBoundaryOf(handle) };
+            return { events: handleReadEvents(await handle.read()), seedLength: forkBoundaryOf(handle) };
         }
         finally {
             await handle.close();
@@ -165,7 +180,9 @@ export class TodaySpendCache {
             && now.getTime() - this.cachedAt < this.ttlMs) {
             return Promise.resolve(this.cachedValue);
         }
-        if (!force && this.inFlight !== undefined)
+        // A scan already in flight is fresh by definition, so a forced caller
+        // joins it instead of starting a second pass.
+        if (this.inFlight !== undefined)
             return this.inFlight;
         const run = (async () => {
             try {
@@ -179,11 +196,28 @@ export class TodaySpendCache {
                 this.inFlight = undefined;
             }
         })();
-        if (!force)
-            this.inFlight = run;
+        this.inFlight = run;
         return run;
     }
 }
+/** Max session-ids kept in the scanner's cold-resolution cache before eviction. */
+export const COLD_RESOLVE_CACHE_LIMIT = 1024;
+/** Max session-ids kept in the scanner's cold-failure cache before eviction. */
+export const COLD_FAILED_CACHE_LIMIT = 1024;
+/** Bounded parallel fan-out for cold-session resolution. */
+export const COLD_RESOLVE_CONCURRENCY = 8;
+/**
+ * Bounded-map eviction: drop the oldest inserted entry once `size` reached
+ * `limit`. Evicting one entry (instead of clearing) keeps the other sessions'
+ * resolved state warm across scans.
+ */
+function evictOldest(map, limit) {
+    if (map.size < limit)
+        return;
+    const oldest = map.keys().next().value;
+    if (oldest !== undefined)
+        map.delete(oldest);
+}
 /**
  * The aggregate computation behind a cache miss. Chooses the projection path
  * when the projection registry is composed, the events path otherwise; both
@@ -194,10 +228,10 @@ export class TodaySpendScanner {
     deps;
     /** Cold sessions resolved on the projection path: id → revision + unit state + title. */
     coldResolved = new Map();
+    /** Cold sessions whose resolution failed: id → revision (retried only when the log changes). */
+    coldFailed = new Map();
     /** Cold sessions resolved on the events path: id → revision (events were collected). */
     lastEventsScan;
-    /** Live fork children priced on the projection path: id → own-events count + folded state. */
-    ownStates = new Map();
     constructor(deps) {
         this.deps = deps;
     }
@@ -207,10 +241,7 @@ export class TodaySpendScanner {
      * @returns today's spend across every session.
      */
     async scan(dayKey) {
-        if (this.deps.projections?.() === undefined)
-            return this.scanEvents(dayKey);
-        this.deps.ensureUnit?.();
-        return this.scanProjections(dayKey);
+        return (await this.scanDetail(dayKey)).aggregate;
     }
     /**
      * Compute today's per-session spend for one Beijing day, sorted by cost
@@ -220,48 +251,64 @@ export class TodaySpendScanner {
      * @returns today's per-session rows, highest first.
      */
     async scanSessions(dayKey) {
-        const rows = this.deps.projections?.() === undefined
-            ? await this.scanSessionsEvents(dayKey)
-            : await this.scanSessionsProjections(dayKey);
-        rows.sort((left, right) => right.total - left.total);
-        return { sessions: rows };
+        return { sessions: (await this.scanDetail(dayKey)).sessions };
     }
     /**
-     * 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. A SEEDED session (fork child)
-     * skips the ladder entirely: its cached row was folded over the inherited
+     * Compute the day's aggregate AND its per-session ranking in ONE pass: the
+     * aggregate is the sum of the rows, so the two reads share every session
+     * read, unit fold, and title fold instead of scanning twice. Chooses the
+     * projection path when the projection registry is composed, the events path
+     * otherwise.
+     * @param dayKey - the Beijing-time calendar-day key to aggregate.
+     * @returns the aggregate plus per-session rows sorted by cost descending.
+     */
+    async scanDetail(dayKey) {
+        if (this.deps.projections?.() === undefined)
+            return this.scanDetailEvents(dayKey);
+        this.deps.ensureUnit?.();
+        return this.scanDetailProjections(dayKey);
+    }
+    /**
+     * Resolve one cold session's billing unit 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
+     * session contributed nothing to the queried day, so the log is never read.
+     * When the row IS the queried day (or no usable row exists) the session is
+     * inspected and folded locally, because the row may trail the log (a crash
+     * between the last checkpoint and the session's last event).
+     *
+     * A cache-served value carries no title (the ladder only stores projection
+     * values), so such rows report `title: null`. A SEEDED session (fork child)
+     * skips the cache entirely: its cached row was folded over the inherited
      * prefix too, so it always detaches through inspect with the durable
      * boundary (the inspect result's inherited count or `meta.seedLength`,
      * depending on the runtime family) applied to the local fold.
-     * @param id - the cold session's id.
-     * @param seeded - whether the session carries a fork-inherited prefix
-     *   (from the snapshot header: `isSeeded` on 0.1.2-alpha.4+, `seedLength`
-     *   at and before the 0.1.1-rc.2 baseline).
+     * @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.
      */
-    async resolveCold(id, seeded) {
+    async resolveCold(header, seeded, dayKey) {
         const { persistence, projectionCache, logger } = this.deps;
-        const persistenceService = persistence?.();
-        if (persistenceService === undefined)
-            return undefined;
         if (!seeded) {
             const cache = projectionCache?.();
             if (cache !== undefined) {
                 try {
-                    const value = (await cache.coldSnapshot(id)).values[BILLING_UNIT_KEY];
-                    if (value !== undefined)
+                    const value = cache.cachedSnapshot(header, 0, [BILLING_UNIT_KEY])?.values[BILLING_UNIT_KEY];
+                    if (value !== undefined && value.dayKey !== dayKey)
                         return { value, title: null };
                 }
                 catch (error) {
-                    logger.warn(`llm-billing: projection cold read for session ${id} failed: ${String(error)}`);
+                    logger.warn(`llm-billing: projection cache read for session ${header.id} failed: ${String(error)}`);
                 }
             }
         }
+        const persistenceService = persistence?.();
+        if (persistenceService === undefined)
+            return undefined;
         try {
-            const read = await persistenceInspect(persistenceService, id);
+            const read = await persistenceInspect(persistenceService, header.id);
             return {
                 value: foldOwnBilling(this.deps.unit, read.events, read.seedLength),
                 title: foldSessionTitle(read.events),
@@ -269,67 +316,36 @@ export class TodaySpendScanner {
         }
         catch (error) {
             // One unreadable session must not blank the whole-day aggregate.
-            logger.warn(`llm-billing: skipping unreadable session ${id}: ${String(error)}`);
+            logger.warn(`llm-billing: skipping unreadable session ${header.id}: ${String(error)}`);
             return undefined;
         }
     }
     /**
-     * Fold one fork child's OWN events (its log minus the inherited prefix)
-     * with the billing unit, incrementally: the fold is reused while the log
-     * length is unchanged and only the new tail is applied when it grows.
-     * @param id - the session id (the own-state cache key).
-     * @param events - the session's complete log.
-     * @param seedLength - the inherited-prefix boundary.
-     * @returns the unit state over the session's own events.
+     * Live-session entries of one projection-path scan: each session with its
+     * eager `billingTodaySpend` cell. The cell is boundary-aware (the unit skips
+     * a fork child's inherited prefix), so a fork child reads the same own-event
+     * spend a non-fork session does.
      */
-    ownBillingState(id, events, seedLength) {
-        const cached = this.ownStates.get(id);
-        const ownCount = events.length - seedLength;
-        if (cached !== undefined && cached.count === ownCount)
-            return cached.state;
-        let state;
-        if (cached !== undefined && cached.count < ownCount) {
-            state = cached.state;
-            for (const event of events) {
-                if (event.seq < seedLength + cached.count)
-                    continue;
-                state = this.deps.unit.apply(state, event);
-            }
+    *liveBillingEntries(store, projections) {
+        for (const session of store.list()) {
+            yield { session, state: projections?.stateOf(session, BILLING_UNIT_KEY) };
         }
-        else {
-            state = foldOwnBilling(this.deps.unit, events, seedLength);
-        }
-        this.ownStates.set(id, { count: ownCount, state });
-        return state;
     }
-    /** Projection path: eager cells for live sessions, revision-gated cold ladder for the rest. */
-    async scanProjections(dayKey) {
-        const { sessions, persistence, projections } = this.deps;
-        // Services resolve once per scan, not per session / per cold task.
-        const projectionsService = projections?.();
-        let total = emptyTodaySpend();
-        const liveIds = new Set();
-        if (sessions !== undefined) {
-            const store = sessions();
-            if (store !== undefined) {
-                for (const session of store.list()) {
-                    liveIds.add(session.id);
-                    const seedLength = forkBoundaryOf(session);
-                    // A fork child's eager cell covers its inherited prefix too; price
-                    // its own events directly instead.
-                    const state = seedLength > 0
-                        ? this.ownBillingState(session.id, liveSessionEvents(session), seedLength)
-                        : projectionsService?.stateOf(session, BILLING_UNIT_KEY);
-                    if (state !== undefined && state.dayKey === dayKey) {
-                        total = mergeTodaySpend(total, state.spend);
-                    }
-                }
-            }
-        }
-        const persistenceService = persistence?.();
-        if (persistenceService === undefined)
-            return total;
-        const snapshots = await persistenceListSnapshots(persistenceService);
+    /**
+     * 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.
+     * @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.
+     * @param adopt - fold one resolved cold session into the scan's result.
+     */
+    async coldAdopt(liveIds, snapshots, dayKey, adopt) {
+        const persistenceAvailable = this.deps.persistence?.() !== undefined;
         const pending = [];
         for (const { header, revision } of snapshots) {
             if (liveIds.has(header.id))
@@ -337,60 +353,72 @@ export class TodaySpendScanner {
             const seeded = isSeededSession(header);
             const resolved = this.coldResolved.get(header.id);
             if (resolved !== undefined && resolved.revision === revision) {
-                if (resolved.value.dayKey === dayKey)
-                    total = mergeTodaySpend(total, resolved.value.spend);
+                adopt(header.id, resolved);
                 continue;
             }
-            pending.push({ id: header.id, revision, seeded });
+            if (this.coldFailed.get(header.id) === revision)
+                continue;
+            pending.push({ header, revision, seeded });
         }
-        await withConcurrency(pending, 8, async ({ id, revision, seeded }) => {
-            const resolved = await this.resolveCold(id, seeded);
-            if (resolved !== undefined)
-                this.coldResolved.set(id, { revision, ...resolved });
-        });
-        for (const { id } of pending) {
-            const resolved = this.coldResolved.get(id);
-            if (resolved !== undefined && resolved.value.dayKey === dayKey) {
-                total = mergeTodaySpend(total, resolved.value.spend);
+        await withConcurrency(pending, COLD_RESOLVE_CONCURRENCY, async ({ header, revision, seeded }) => {
+            const resolved = await this.resolveCold(header, seeded, dayKey);
+            if (resolved !== undefined) {
+                this.coldFailed.delete(header.id);
+                evictOldest(this.coldResolved, COLD_RESOLVE_CACHE_LIMIT);
+                this.coldResolved.set(header.id, { revision, ...resolved });
             }
+            else if (persistenceAvailable) {
+                evictOldest(this.coldFailed, COLD_FAILED_CACHE_LIMIT);
+                this.coldFailed.set(header.id, revision);
+            }
+        });
+        for (const { header } of pending) {
+            const resolved = this.coldResolved.get(header.id);
+            if (resolved !== undefined)
+                adopt(header.id, resolved);
         }
-        return total;
     }
     /**
-     * Events path: price today's events in a single pass (per-event Beijing-day
-     * filter during collection, hard cap), gated by revisions. A fork child's
-     * inherited prefix (`seq < seedLength`) is skipped, so each model output is
-     * priced only in its source session.
+     * 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.
+     * @param dayKey - the Beijing-time calendar-day key to aggregate.
+     * @param onSession - fold one session's state plus its complete log.
+     * @returns whether the hard cap truncated the scan.
      */
-    async scanEvents(dayKey) {
+    async collectTodayEvents(dayKey, onSession) {
         const { sessions, persistence, maxEvents, logger, billing, catalog } = this.deps;
-        const names = new Map(catalog.map(model => [model.id, model.name]));
-        const accumulator = new SpendAccumulator();
         const liveIds = new Set();
         let collected = 0;
         let truncated = false;
-        const collect = (events, seedLength) => {
+        const collect = (id, events, seedLength) => {
+            const folder = new BillingFolder(billing, catalog, seedLength);
             for (const event of events) {
-                if (event.seq < seedLength)
-                    continue;
-                if (beijingDayKey(new Date(event.time)) !== dayKey)
-                    continue;
-                collected += 1;
-                if (collected > maxEvents) {
-                    truncated = true;
-                    return;
+                // The cap counts the queried day's events; the fold still sees every
+                // event up to the cap (model tracking and attempt replacement need
+                // the surrounding events).
+                if (beijingPartsOf(event.time).dayKey === dayKey) {
+                    collected += 1;
+                    if (collected > maxEvents) {
+                        truncated = true;
+                        break;
+                    }
                 }
-                const priced = priceEvent(event, billing, names);
-                if (priced !== undefined)
-                    accumulator.add(priced);
+                folder.add(event);
             }
+            onSession(id, folder.fold, events);
         };
         if (sessions !== undefined) {
             const store = sessions();
             if (store !== undefined) {
                 for (const session of store.list()) {
                     liveIds.add(session.id);
-                    collect(liveSessionEvents(session), forkBoundaryOf(session));
+                    collect(session.id, liveSessionEvents(session), forkBoundaryOf(session));
                     if (truncated)
                         break;
                 }
@@ -406,7 +434,7 @@ export class TodaySpendScanner {
                     continue;
                 try {
                     const read = await persistenceInspect(persistenceService, header.id);
-                    collect(read.events, read.seedLength);
+                    collect(header.id, read.events, read.seedLength);
                 }
                 catch (error) {
                     // One unreadable session must not blank the whole-day aggregate.
@@ -424,154 +452,74 @@ export class TodaySpendScanner {
         }
         if (truncated)
             logger.warn(`llm-billing: today's events exceeded ${maxEvents}; result truncated`);
-        return accumulator.finish();
+        return truncated;
     }
     /**
-     * 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). A fork child's row prices
-     * its OWN events only (the cell covers the inherited prefix too).
+     * Projection path, one pass for both outputs: 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 answered from the projection cache). A fork child's cell covers its
+     * inherited prefix, so its own-events fold supplies both outputs.
      * @param dayKey - the Beijing-time calendar-day key to aggregate.
-     * @returns unsorted per-session rows for the day.
+     * @returns the aggregate plus per-session rows, sorted by cost descending.
      */
-    async scanSessionsProjections(dayKey) {
+    async scanDetailProjections(dayKey) {
         const { sessions, persistence, projections } = this.deps;
+        // Services resolve once per scan, not per session / per cold task.
         const projectionsService = projections?.();
+        let aggregate = emptyTodaySpend();
         const rows = new Map();
         const liveIds = new Set();
         if (sessions !== undefined) {
             const store = sessions();
             if (store !== undefined) {
-                for (const session of store.list()) {
+                for (const { session, state } of this.liveBillingEntries(store, projectionsService)) {
                     liveIds.add(session.id);
-                    const seedLength = forkBoundaryOf(session);
-                    const events = liveSessionEvents(session);
-                    const state = seedLength > 0
-                        ? this.ownBillingState(session.id, events, seedLength)
-                        : projectionsService?.stateOf(session, BILLING_UNIT_KEY);
-                    if (state !== undefined && state.dayKey === dayKey) {
-                        rows.set(session.id, {
-                            sessionId: session.id,
-                            title: foldSessionTitle(events),
-                            total: state.spend.total,
-                        });
-                    }
+                    if (state === undefined || state.dayKey !== dayKey)
+                        continue;
+                    aggregate = mergeTodaySpend(aggregate, state.spend);
+                    // The eager cell carries no title; fold it from the live log.
+                    rows.set(session.id, { sessionId: session.id, title: foldSessionTitle(liveSessionEvents(session)), total: state.spend.total });
                 }
             }
         }
         const persistenceService = persistence?.();
-        if (persistenceService === undefined)
-            return [...rows.values()];
-        const snapshots = await persistenceListSnapshots(persistenceService);
-        const pending = [];
-        for (const { header, revision } of snapshots) {
-            if (liveIds.has(header.id))
-                continue;
-            const seeded = isSeededSession(header);
-            const resolved = this.coldResolved.get(header.id);
-            if (resolved !== undefined && 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, seeded });
-        }
-        await withConcurrency(pending, 8, async ({ id, revision, seeded }) => {
-            const resolved = await this.resolveCold(id, seeded);
-            if (resolved !== undefined)
-                this.coldResolved.set(id, { revision, ...resolved });
-        });
-        for (const { id } of pending) {
-            const resolved = this.coldResolved.get(id);
-            if (resolved !== undefined && resolved.value.dayKey === dayKey) {
+        if (persistenceService !== undefined) {
+            const snapshots = await persistenceListSnapshots(persistenceService);
+            await this.coldAdopt(liveIds, snapshots, dayKey, (id, resolved) => {
+                if (resolved.value.dayKey !== dayKey)
+                    return;
+                aggregate = mergeTodaySpend(aggregate, resolved.value.spend);
                 rows.set(id, { sessionId: id, title: resolved.title, total: resolved.value.spend.total });
-            }
+            });
         }
-        return [...rows.values()];
+        return { aggregate, sessions: sortRows(rows) };
     }
     /**
-     * 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. A fork child's inherited prefix
-     * (`seq < seedLength`) is skipped, so each row is the session's OWN spend.
-     * 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.
+     * Events path, one pass for both outputs: price today's events (per-event
+     * Beijing-day filter during collection, hard cap), gated by revisions. 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.
      * @param dayKey - the Beijing-time calendar-day key to aggregate.
-     * @returns unsorted per-session rows for the day.
+     * @returns the aggregate plus per-session rows, sorted by cost descending.
      */
-    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 = new Map();
-        const liveIds = new Set();
-        let collected = 0;
-        let truncated = false;
-        const collect = (id, events, seedLength) => {
-            let row = rows.get(id);
-            if (row === undefined) {
-                row = { title: foldSessionTitle(events), total: 0 };
-                rows.set(id, row);
-            }
-            for (const event of events) {
-                if (event.seq < seedLength)
-                    continue;
-                if (beijingDayKey(new Date(event.time)) !== dayKey)
-                    continue;
-                collected += 1;
-                if (collected > maxEvents) {
-                    truncated = true;
-                    return;
-                }
-                const priced = priceEvent(event, billing, names);
-                if (priced !== undefined)
-                    row.total += priced.cost;
-            }
-        };
-        if (sessions !== undefined) {
-            const store = sessions();
-            if (store !== undefined) {
-                for (const session of store.list()) {
-                    liveIds.add(session.id);
-                    collect(session.id, liveSessionEvents(session), forkBoundaryOf(session));
-                    if (truncated)
-                        break;
-                }
-            }
-        }
-        const persistenceService = persistence?.();
-        if (!truncated && persistenceService !== undefined) {
-            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;
-                try {
-                    const read = await persistenceInspect(persistenceService, header.id);
-                    collect(header.id, read.events, read.seedLength);
-                }
-                catch (error) {
-                    // One unreadable session must not blank the whole-day aggregate.
-                    logger.warn(`llm-billing: skipping unreadable session ${header.id}: ${String(error)}`);
-                }
-                if (truncated)
-                    break;
-            }
-            // Only a complete pass may advance the revision watermark: a truncated
-            // pass left sessions unread, and recording them would skip their events
-            // on the next scan.
-            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 [...rows.entries()]
-            .filter(([, row]) => row.total > 0)
-            .map(([sessionId, row]) => ({ sessionId, title: row.title, total: row.total }));
+    async scanDetailEvents(dayKey) {
+        let aggregate = emptyTodaySpend();
+        const sessions = [];
+        await this.collectTodayEvents(dayKey, (id, fold, events) => {
+            if (fold.dayKey !== dayKey)
+                return;
+            aggregate = mergeTodaySpend(aggregate, fold.spend);
+            sessions.push({ sessionId: id, title: foldSessionTitle(events), total: fold.spend.total });
+        });
+        sessions.sort((left, right) => right.total - left.total);
+        return { aggregate, sessions };
     }
 }
+/** Per-session rows from the map, highest total first. */
+function sortRows(rows) {
+    return [...rows.values()].sort((left, right) => right.total - left.total);
+}
 //# sourceMappingURL=today-spend.js.map