@rayadesu/dsh-llm-billing 0.3.12 → 0.3.13

package/lib/types/today-spend.js

@@ -13,13 +13,23 @@
  *   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
@@ -64,6 +74,80 @@ export 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.
+ */
+export function isSubagentSession(header) {
+    if (header === undefined)
+        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.
+ */
+export function topLevelSessionOf(id, lineage) {
+    let current = id;
+    // A malformed log could claim a delegation cycle; each step visits a
+    // distinct ancestor, so a repeat ends the walk instead of spinning.
+    const seen = new Set([current]);
+    for (;;) {
+        const header = lineage.get(current);
+        if (!isSubagentSession(header))
+            return current;
+        const parent = header?.parentSession;
+        if (parent === undefined || 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.
+ */
+export function rollUpSubagentSpend(rows, lineage, titles = new Map()) {
+    const merged = new Map();
+    for (const row of rows) {
+        const target = topLevelSessionOf(row.sessionId, lineage);
+        const carried = merged.get(target);
+        if (carried === undefined) {
+            // A row's own session keeps its own total as `ownTotal`; a row created
+            // for an ancestor that priced nothing today carries zero there.
+            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
@@ -218,23 +302,85 @@ function evictOldest(map, limit) {
     if (oldest !== undefined)
         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.
+ */
+export function delegatedSpendOf(id, ownSpend, lineage) {
+    const children = new Map();
+    for (const [childId, header] of lineage) {
+        const parent = header.parentSession;
+        if (parent === undefined || !isSubagentSession(header))
+            continue;
+        const siblings = children.get(parent);
+        if (siblings === undefined)
+            children.set(parent, [childId]);
+        else
+            siblings.push(childId);
+    }
+    // The queried session is pre-visited: a cycle that leads back to it must not
+    // add its own spend to its delegated subtotal.
+    const seen = 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.
  */
 export class TodaySpendScanner {
     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 = 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;
     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(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.
@@ -245,8 +391,11 @@ export class TodaySpendScanner {
     }
     /**
      * 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.
      */
@@ -259,6 +408,9 @@ export class TodaySpendScanner {
      * 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.
      */
@@ -269,7 +421,7 @@ export class TodaySpendScanner {
         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
@@ -287,7 +439,7 @@ export class TodaySpendScanner {
      * @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;
@@ -297,7 +449,7 @@ export class TodaySpendScanner {
                 try {
                     const value = cache.cachedSnapshot(header, 0, [BILLING_UNIT_KEY])?.values[BILLING_UNIT_KEY];
                     if (value !== undefined && value.dayKey !== dayKey)
-                        return { value, title: null };
+                        return { fold: value, title: null };
                 }
                 catch (error) {
                     logger.warn(`llm-billing: projection cache read for session ${header.id} failed: ${String(error)}`);
@@ -310,7 +462,7 @@ export class TodaySpendScanner {
         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),
             };
         }
@@ -334,11 +486,11 @@ export class TodaySpendScanner {
     /**
      * 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.
@@ -364,8 +516,7 @@ export class TodaySpendScanner {
             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 });
+                this.rememberCold(header.id, { revision, ...resolved });
             }
             else if (persistenceAvailable) {
                 evictOldest(this.coldFailed, COLD_FAILED_CACHE_LIMIT);
@@ -381,14 +532,17 @@ export class TodaySpendScanner {
     /**
      * 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) {
@@ -396,7 +550,8 @@ export class TodaySpendScanner {
         const liveIds = 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) {
                 // The cap counts the queried day's events; the fold still sees every
@@ -411,14 +566,17 @@ export class TodaySpendScanner {
                 }
                 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 !== undefined) {
             const store = sessions();
             if (store !== undefined) {
                 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;
                 }
@@ -430,11 +588,20 @@ export class TodaySpendScanner {
             for (const { header, revision } of snapshots) {
                 if (liveIds.has(header.id))
                     continue;
-                if (this.lastEventsScan?.get(header.id) === revision)
+                const resolved = this.coldResolved.get(header.id);
+                if (resolved !== undefined && resolved.revision === revision) {
+                    // Unchanged log: adopt the fold (and title) already priced for this
+                    // exact revision — the session still counts, at zero I/O.
+                    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);
+                    // A MAXED pass folds one log only partially: remembering it (or its
+                    // revision) would pin the partial result, so the next pass re-reads.
+                    if (!truncated)
+                        this.rememberCold(header.id, { revision, ...priced });
                 }
                 catch (error) {
                     // One unreadable session must not blank the whole-day aggregate.
@@ -443,12 +610,6 @@ export class TodaySpendScanner {
                 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`);
@@ -459,7 +620,9 @@ export class TodaySpendScanner {
      * (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.
      */
@@ -469,57 +632,106 @@ export class TodaySpendScanner {
         const projectionsService = projections?.();
         let aggregate = emptyTodaySpend();
         const rows = new Map();
+        const lineage = new Map();
+        const titles = new Map();
+        const ownSpend = new Map();
+        const createdAt = new Map();
         const liveIds = new Set();
         if (sessions !== undefined) {
             const store = sessions();
             if (store !== undefined) {
                 for (const { session, state } of this.liveBillingEntries(store, projectionsService)) {
                     liveIds.add(session.id);
-                    if (state === undefined || state.dayKey !== dayKey)
+                    lineage.set(session.id, session.header ?? {});
+                    const born = session.header?.createdAt;
+                    if (born !== undefined)
+                        createdAt.set(session.id, born);
+                    // The eager cell carries no title; fold it from the live log for
+                    // every live session, not just today's payers, so a parent that
+                    // delegated but priced nothing itself still titles its merged row.
+                    const title = foldSessionTitle(liveSessionEvents(session));
+                    titles.set(session.id, title);
+                    if (state === undefined)
+                        continue;
+                    // The cell's whole-session total feeds the conversation read even
+                    // when the session priced nothing on the queried day.
+                    ownSpend.set(session.id, state.session);
+                    if (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 });
+                    rows.set(session.id, {
+                        sessionId: session.id,
+                        title,
+                        total: state.spend.total,
+                        ownTotal: state.spend.total,
+                    });
                 }
             }
         }
         const persistenceService = persistence?.();
         if (persistenceService !== undefined) {
             const snapshots = await persistenceListSnapshots(persistenceService);
+            for (const { header } of snapshots) {
+                if (liveIds.has(header.id))
+                    continue;
+                lineage.set(header.id, header);
+                if (header.createdAt !== undefined)
+                    createdAt.set(header.id, header.createdAt);
+            }
             await this.coldAdopt(liveIds, snapshots, dayKey, (id, resolved) => {
-                if (resolved.value.dayKey !== dayKey)
+                // A resolved title is worth keeping even when the session priced
+                // nothing today: its subagents' rows merge into this session's row.
+                if (resolved.title !== null && !titles.has(id))
+                    titles.set(id, resolved.title);
+                // Same for the whole-session total: it is the conversation read's
+                // material whether or not the queried day is the one it last priced.
+                ownSpend.set(id, resolved.fold.session);
+                if (resolved.fold.dayKey !== dayKey)
                     return;
-                aggregate = mergeTodaySpend(aggregate, resolved.value.spend);
-                rows.set(id, { sessionId: id, title: resolved.title, total: resolved.value.spend.total });
+                aggregate = mergeTodaySpend(aggregate, resolved.fold.spend);
+                rows.set(id, { sessionId: id, title: resolved.title, total: resolved.fold.spend.total, ownTotal: resolved.fold.spend.total });
             });
         }
-        return { aggregate, sessions: sortRows(rows) };
+        return { aggregate, 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 = new Map();
+        const titles = new Map();
+        const ownSpend = new Map();
+        const createdAt = new Map();
+        await this.collectTodayEvents(dayKey, (id, fold, title, sessionLineage) => {
+            lineage.set(id, sessionLineage);
+            // Titles cover every session the pass accounted for (not only today's
+            // payers), so a parent that delegated without pricing anything itself is
+            // titled even when its own row comes from the roll-up.
+            titles.set(id, title);
+            const born = sessionLineage.createdAt;
+            if (born !== undefined)
+                createdAt.set(id, born);
+            // The whole-session total is the conversation read's material even when
+            // the session priced nothing on the queried day.
+            ownSpend.set(id, fold.session);
             if (fold.dayKey !== dayKey)
                 return;
             aggregate = mergeTodaySpend(aggregate, fold.spend);
-            sessions.push({ sessionId: id, title: foldSessionTitle(events), total: fold.spend.total });
+            rows.push({ sessionId: id, title, total: fold.spend.total, ownTotal: fold.spend.total });
         });
-        sessions.sort((left, right) => right.total - left.total);
-        return { aggregate, sessions };
+        return { aggregate, 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);
-}
 //# sourceMappingURL=today-spend.js.map

package/lib/types/types.d.ts

@@ -82,14 +82,61 @@ export interface DeepSeekTodaySessionSpend {
      * `null` when the session has no title (or the title could not be resolved).
      */
     title: string | null;
-    /** Billed cost in CNY on the queried Beijing day. */
+    /**
+     * Billed cost in CNY on the queried Beijing day for the whole conversation:
+     * the top-level session's own spend plus every subagent session it delegated
+     * (transitively), since a subagent child is the same conversation's work, not
+     * a session the user opened. A subagent row is therefore never reported on
+     * its own — its spend rides this total.
+     */
     total: number;
+    /**
+     * The session's own billed cost in CNY on the queried day, before its
+     * subagent descendants were merged into {@link total}; they are equal when no
+     * descendant priced anything that day. The row's decomposition fact: `total`
+     * is the conversation's day, this is the session's own share of it.
+     */
+    ownTotal: number;
 }
-/** Today's per-session billed spend across every session with a non-zero cost. */
+/**
+ * Today's per-session billed spend. One row per top-level session that priced
+ * something today, with every subagent session's spend already folded into the
+ * row of the session that delegated it (so no subagent appears as its own row).
+ */
 export interface DeepSeekTodaySessionsSpend {
-    /** Sessions with today's spend, sorted by `total` descending. */
+    /** Top-level sessions with today's spend, sorted by `total` descending. */
     sessions: readonly DeepSeekTodaySessionSpend[];
 }
+/**
+ * The subagent part of one conversation's billed spend: every subagent session
+ * the queried session delegated (transitively), summed across every day its log
+ * covers. A session's own log cannot price its delegation children, so the
+ * browser adds this subtotal to the live own-session value to show what the
+ * conversation actually cost.
+ */
+export interface DeepSeekDelegatedSpend {
+    /** Merged billed cost in CNY across every delegated subagent session. */
+    total: number;
+    /** One row per model priced in those sessions; empty when the session delegated nothing priced. */
+    models: readonly DeepSeekSessionSpendModel[];
+    /**
+     * Whether the QUERIED session is itself a delegated subagent child. Its own
+     * spend then rides the ranking row of the top-level session that delegated
+     * it, so the panel has no row of its own to read a today share from.
+     */
+    isSubagent: boolean;
+    /**
+     * Whether the queried session was created BEFORE the current Beijing day, so
+     * its billed spend can span more than today. This — not a comparison of two
+     * amounts — is what decides whether the panel renders the parenthesized today
+     * share: the live session amount and the 60-second-cached ranking row drift
+     * apart mid-turn, which would otherwise conjure a parenthesis for a session
+     * that started today. `false` when the session started on the current day or
+     * when its creation instant could not be resolved (an unproven crossing must
+     * not conjure one either).
+     */
+    crossedDay: boolean;
+}
 /** The billed cost of one completed Turn. */
 export interface DeepSeekTurnSpend {
     /** Total billed cost in CNY across every priced model in the Turn. */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rayadesu/dsh-llm-billing",
   "description": "Standalone DeepSeek account-balance and session-spend provider exposed through the billing Remote",
-  "version": "0.3.12",
+  "version": "0.3.13",
   "publishConfig": {
     "access": "public"
   },
@@ -56,29 +56,29 @@
   },
   "license": "MIT",
   "peerDependencies": {
-    "@deepseek-ai/dsh-credentials": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-launch-environment": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-invariants": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-llm": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-session": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-session-persistence": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-session-projection": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-typert-protocol": "^0.1.2-alpha.5",
-    "@deepseek-ai/cordis": "^4.0.1"
+    "@deepseek-ai/dsh-credentials": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-launch-environment": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-invariants": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-llm": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-session": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-session-persistence": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-session-projection": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.6-alpha.1",
+    "@deepseek-ai/cordis": "^4.0.2"
   },
   "dependencies": {
-    "@deepseek-ai/schemastery": "^3.18.1",
+    "@deepseek-ai/schemastery": "^3.18.2",
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@deepseek-ai/dsh-credentials": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-launch-environment": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-invariants": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-llm": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-session": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-session-persistence": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-session-projection": "^0.1.2-alpha.5",
-    "@deepseek-ai/dsh-typert-protocol": "^0.1.2-alpha.5",
-    "@deepseek-ai/cordis": "^4.0.1"
+    "@deepseek-ai/dsh-credentials": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-launch-environment": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-invariants": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-llm": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-session": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-session-persistence": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-session-projection": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.6-alpha.1",
+    "@deepseek-ai/cordis": "^4.0.2"
   }
 }