@gamegeek-saikel/dsh-cost-meter 0.3.0 → 0.3.1

package/README.md

@@ -47,7 +47,7 @@ Chat costs in DeepSeek pricing change over time (list prices, USD→CNY exchange
 | Peak pricing | 2026-08-17 00:00 Beijing rollout; peak windows apply Monday–Friday only (the zh and en pages may state different timezones; fallback 09:00–12:00 / 14:00–18:00 Beijing), so Saturdays, Sundays, and all other hours are off-peak at half price |
 | Cost formula | Uncached input + cache reads (hit rate) + cache writes (billed at uncached input rate) + output, per 1M tokens, CNY |
 | Account balance | Official `GET /user/balance`, cached 60 s, single in-flight request, trust-fenced route |
-| Subagent support | Enumerates the conversation's durable subagent tree through `subagents.listDescendants` (nested delegations, settled children, and cold subagent sessions included, with no depth cap); falls back to a BFS over the live agent tree when that service is not mounted |
+| Subagent support | Enumerates the conversation's durable subagent tree through `subagents.listDescendants` (nested delegations, settled children, and cold subagent sessions included, with no depth cap); a ledger is read from the resident session's projection when available and otherwise cold-restored from the child's stored log (`sessionQuery.readSession` + `sessionProjections.restore`), so historical subagent spend is also counted after a host restart; falls back to a BFS over the live agent tree when neither service is mounted |
 | Conversation total | Main session + every descendant subagent (any depth); subagent totals still render while the main session's own ledger is not materialized |
 | UI surfaces | Composer dock · Cost tab · per-reply chip · header pill (live estimate) · settings card |
 | Locale | Simplified Chinese (source) + English |

package/README.zh-CN.md

@@ -47,7 +47,7 @@ DeepSeek 的价格随时间变化（官方价目表、USD→CNY 汇率、2026-08
 | 峰值定价 | 2026-08-17 00:00 北京生效；高峰窗口仅周一至周五（中英文页面时区可能不同，缺省 09:00–12:00 / 14:00–18:00 北京），因此周六、周日全天及其余时段均为半价闲时 |
 | 成本公式 | 未命中输入 + 缓存命中（命中价）+ 缓存写入（按未命中输入价计）+ 输出，每百万 tokens，CNY |
 | 账户余额 | 官方 `GET /user/balance`，缓存 60 秒，单飞请求，路由带信任围栏 |
-| 子代理支持 | 沿 `subagents.listDescendants` 枚举本会话持久子代理树（子代理再派生的孙代理、已结束或已冷启动的子会话都计入，无层数上限）；未挂载该服务时回退到活跃代理树 BFS |
+| 子代理支持 | 沿 `subagents.listDescendants` 枚举本会话持久子代理树（子代理再派生的孙代理、已结束或已冷启动的子会话都计入，无层数上限）；账本优先取常驻会话的投影，未常驻的经 `sessionQuery.readSession` + `sessionProjections.restore` 从其持久日志冷读——因此主机重启后，旧会话的历史子代理花费同样会被补算；未挂载该服务时回退到活跃代理树 BFS |
 | 对话总花费 | 主会话 + 全部后代子代理（任意层数）；主会话自身账本尚未就绪时仍展示子代理合计 |
 | UI 表面 | 输入框读数 · 花费标签页 · 回复小标签 · 头部胶囊（实时估算）· 设置卡 |
 | 本地化 | 简体中文（键源）+ 英文 |

package/lib/index.js

@@ -2265,8 +2265,53 @@ const ZERO_TOTALS = {
 	unpricedSteps: 0,
 	steps: 0
 };
-/** Resolve the ledger of one session, or undefined when it carries none yet. */
-function totalsOf(session, projections, projectionKey) {
+/** How long a cold fold is reused before the persisted log is read again. */
+const COLD_LEDGER_TTL_MS = 3e4;
+/** How many cold folds stay cached across requests. */
+const COLD_LEDGER_CACHE_LIMIT = 256;
+/** Cross-request cold-ledger cache, keyed by session id, insertion-ordered. */
+const coldLedgerCache = /* @__PURE__ */ new Map();
+/**
+* Drop every cached cold fold. The cache is process-global and keyed by
+* session id; tests (and any caller that knowingly replaced a session log)
+* use this instead of compensating with synthetic ids.
+*/
+function resetColdLedgerCache() {
+	coldLedgerCache.clear();
+}
+/**
+* Fold one stored subagent log into its ledger totals through the framework's
+* own cold-read recipe: an empty checkpoint at seq 0, every stored event, and
+* the exact inherited cut. Cached briefly so the route's poll cadence does not
+* refold unchanged logs.
+* @param sessionId - the subagent session to read.
+* @param query - the session query service.
+* @param projections - the projection registry (live + restore face).
+* @param projectionKey - the currency-specific ledger key.
+* @returns the restored totals, or undefined without a cold-read seam.
+*/
+async function readColdLedger(sessionId, query, projections, projectionKey) {
+	if (query === void 0 || typeof query.readSession !== "function") return void 0;
+	if (typeof projections.restore !== "function") return void 0;
+	const cached = coldLedgerCache.get(sessionId);
+	if (cached !== void 0 && Date.now() - cached.at < COLD_LEDGER_TTL_MS) return cached.totals;
+	const log = await query.readSession(sessionId);
+	const restored = projections.restore({}, log.events, 0, log.session, log.inheritedEventCount);
+	const totals = restored.snapshot.values[projectionKey]?.totals;
+	if (totals === void 0) return void 0;
+	coldLedgerCache.set(sessionId, {
+		totals,
+		asOfSeq: Number(restored.snapshot.asOfSeq),
+		at: Date.now()
+	});
+	if (coldLedgerCache.size > COLD_LEDGER_CACHE_LIMIT) {
+		const oldest = coldLedgerCache.keys().next();
+		if (!oldest.done) coldLedgerCache.delete(oldest.value);
+	}
+	return totals;
+}
+/** Resolve the ledger of one resident session, or undefined when it carries none. */
+function liveTotalsOf(session, projections, projectionKey) {
 	if (session === void 0) return void 0;
 	let snapshot;
 	try {
@@ -2276,10 +2321,7 @@ function totalsOf(session, projections, projectionKey) {
 	}
 	return snapshot.values[projectionKey]?.totals;
 }
-/**
-* Index the live session store by id. Read once per request so the durable
-* listing resolves every row without a per-child store lookup.
-*/
+/** Index the live session store by id, so the durable walk resolves rows cheaply. */
 function liveSessionsById(sessions) {
 	const index = /* @__PURE__ */ new Map();
 	for (const session of sessions.list()) {
@@ -2289,30 +2331,35 @@ function liveSessionsById(sessions) {
 	return index;
 }
 /**
-* Fold the durable subagent tree into cost rows. A child whose session carries
-* no ledger yet (never used a model, or a cold session the live store does not
-* hold) is skipped, as is a `diagnostic` row, which names no interpreted
-* child.
+* Fold the durable subagent tree into cost rows: the live ledger when the
+* child is resident, else its persisted-log restore. A `diagnostic` row names
+* no interpreted child and is skipped.
 * @param rootSessionId - the root conversation's session id.
 * @param subagents - the subagents service (durable tree enumeration).
 * @param sessions - the sessions service (live session store).
 * @param projections - the sessionProjections service.
 * @param projectionKey - the currency-specific ledger key.
+* @param query - the session query service (cold-ledger source), when mounted.
 * @returns one entry per descendant that has a ledger.
 * @throws whatever the listing throws; the caller decides the fallback.
 */
-async function collectDurableSubagentCosts(rootSessionId, subagents, sessions, projections, projectionKey) {
+async function collectDurableSubagentCosts(rootSessionId, subagents, sessions, projections, projectionKey, query) {
 	const entries = await subagents.listDescendants(rootSessionId);
 	if (entries.length === 0) return [];
 	const live = liveSessionsById(sessions);
 	const result = [];
 	const seen = /* @__PURE__ */ new Set();
 	for (const entry of entries) {
-		if (entry.kind !== "child") continue;
+		if (entry.kind === "diagnostic") continue;
 		const sessionId = String(entry.id);
 		if (sessionId.length === 0 || sessionId === rootSessionId || seen.has(sessionId)) continue;
 		seen.add(sessionId);
-		const totals = totalsOf(live.get(sessionId), projections, projectionKey);
+		let totals = liveTotalsOf(live.get(sessionId), projections, projectionKey);
+		if (totals === void 0) try {
+			totals = await readColdLedger(sessionId, query, projections, projectionKey);
+		} catch {
+			totals = void 0;
+		}
 		if (totals === void 0) continue;
 		result.push({
 			sessionId,
@@ -2350,7 +2397,7 @@ function collectRuntimeSubagentCosts(rootSessionId, agents, sessions, projection
 			if (!agents.isOwnedBy(candidateId, parent)) continue;
 			seen.add(candidateId);
 			queue.push(candidate);
-			const totals = totalsOf(sessions.get(candidateId), projections, projectionKey);
+			const totals = liveTotalsOf(sessions.get(candidateId), projections, projectionKey);
 			if (totals === void 0) continue;
 			result.push({
 				sessionId: candidateId,
@@ -2364,21 +2411,23 @@ function collectRuntimeSubagentCosts(rootSessionId, agents, sessions, projection
 /**
 * Collect every session-backed descendant of `rootSessionId` with its
 * anchored cost totals: the durable subagent tree first (nested, settled, and
-* cold children included), then the live runtime ownership walk for whatever
-* the listing could not reach.
+* cold children included — a resident child through its registered
+* projection, a stored one through the cold restore), then the live runtime
+* ownership walk for whatever the listing could not reach.
 * @param rootSessionId - the root conversation's session id.
 * @param agents - the agents service (live registry).
 * @param sessions - the sessions service (session store).
 * @param projections - the sessionProjections service.
 * @param projectionKey - the currency-specific ledger key.
 * @param subagents - the subagents service; omitted, only the runtime walk runs.
+* @param query - the session query service; omitted, cold children are skipped.
 * @returns one entry per descendant with a priced or unpriced ledger; empty
 *   when the conversation has no subagents.
 */
-async function collectSubagentCosts(rootSessionId, agents, sessions, projections, projectionKey = "sessionCost", subagents) {
+async function collectSubagentCosts(rootSessionId, agents, sessions, projections, projectionKey = "sessionCost", subagents, query) {
 	let durable = [];
 	if (subagents !== void 0) try {
-		durable = await collectDurableSubagentCosts(rootSessionId, subagents, sessions, projections, projectionKey);
+		durable = await collectDurableSubagentCosts(rootSessionId, subagents, sessions, projections, projectionKey, query);
 	} catch {
 		durable = [];
 	}
@@ -2699,9 +2748,10 @@ async function apply(ctx, config) {
 		const agents = ctx.get("agents");
 		const sessionsStore = ctx.get("sessions");
 		const subagentTree = ctx.get("subagents");
+		const sessionQuery = ctx.get("sessionQuery");
 		const pricebook = currency === "USD" ? pricebookUsd : pricebookCny;
 		const projectionKey = currency === "USD" ? "sessionCostUsd" : "sessionCost";
-		const subagents = rootSessionId === void 0 || sessionsStore === void 0 ? [] : await collectSubagentCosts(rootSessionId, agents, sessionsStore, ctx.sessionProjections, projectionKey, subagentTree);
+		const subagents = rootSessionId === void 0 || sessionsStore === void 0 ? [] : await collectSubagentCosts(rootSessionId, agents, sessionsStore, ctx.sessionProjections, projectionKey, subagentTree, sessionQuery);
 		return {
 			balance: await refresh(),
 			pricebook: pricebook.view(),
@@ -2745,4 +2795,4 @@ async function apply(ctx, config) {
 	ctx.effect(() => ctx.webServer.register(route), "cost-meter: /cost-meter route");
 }
 //#endregion
-export { Config, DEFAULT_ALIASES, DEFAULT_API_KEY_ENV, DEFAULT_CACHE_READ_DISCOUNT, DEFAULT_FX_RATE, DEFAULT_PRICING_REFRESH_HOURS, DEFAULT_REFRESH_MS, DEFAULT_SNAPSHOT_HISTORY_LIMIT, FALLBACK_CURRENT, FALLBACK_CURRENT_USD, FALLBACK_PEAK, FALLBACK_PEAK_USD, FX_API_URL, OPENROUTER_MODELS_URL, PEAK_PRICING_START_MS, PEAK_SCHEDULE_EN, PEAK_SCHEDULE_ZH, PRICEBOOK_DOMAIN, PRICEBOOK_DOMAIN_USD, PRICING_URL, PRICING_URL_EN, PUBLIC_BASE_URL, PricebookHandle, SETTINGS_NAMESPACE, apply, bandForTime, bucketOf, collectSubagentCosts, computePricebook, effectiveBucket, effectivePricing, effectiveRate, fetchBalance, fetchFxRate, fetchOpenRouter, fetchPricing, foldSessionCost, foldSessionCostIndex, initialPricebookState, inject, isLoopbackHostname, isPeakHour, isTrustedRequest, modelKeys, name, officialInputOf, parseCurrentTable, parseCurrentTableEn, parsePeakSchedule, parsePeakTable, parsePeakTableEn, pickBalanceInfo, priceAt, pricesEqual, pricingKeyOfModel, resolveApiKey, sessionCostIndexProjection, sessionCostProjection, snapshotForTime, stepCost, stripHtml, sumTotals, usageBuckets, viewSessionCost };
+export { Config, DEFAULT_ALIASES, DEFAULT_API_KEY_ENV, DEFAULT_CACHE_READ_DISCOUNT, DEFAULT_FX_RATE, DEFAULT_PRICING_REFRESH_HOURS, DEFAULT_REFRESH_MS, DEFAULT_SNAPSHOT_HISTORY_LIMIT, FALLBACK_CURRENT, FALLBACK_CURRENT_USD, FALLBACK_PEAK, FALLBACK_PEAK_USD, FX_API_URL, OPENROUTER_MODELS_URL, PEAK_PRICING_START_MS, PEAK_SCHEDULE_EN, PEAK_SCHEDULE_ZH, PRICEBOOK_DOMAIN, PRICEBOOK_DOMAIN_USD, PRICING_URL, PRICING_URL_EN, PUBLIC_BASE_URL, PricebookHandle, SETTINGS_NAMESPACE, apply, bandForTime, bucketOf, collectSubagentCosts, computePricebook, effectiveBucket, effectivePricing, effectiveRate, fetchBalance, fetchFxRate, fetchOpenRouter, fetchPricing, foldSessionCost, foldSessionCostIndex, initialPricebookState, inject, isLoopbackHostname, isPeakHour, isTrustedRequest, modelKeys, name, officialInputOf, parseCurrentTable, parseCurrentTableEn, parsePeakSchedule, parsePeakTable, parsePeakTableEn, pickBalanceInfo, priceAt, pricesEqual, pricingKeyOfModel, resetColdLedgerCache, resolveApiKey, sessionCostIndexProjection, sessionCostProjection, snapshotForTime, stepCost, stripHtml, sumTotals, usageBuckets, viewSessionCost };

package/lib/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

package/lib/types/index.js

@@ -361,11 +361,12 @@ export async function apply(ctx, config) {
         const agents = ctx.get('agents');
         const sessionsStore = ctx.get('sessions');
         const subagentTree = ctx.get('subagents');
+        const sessionQuery = ctx.get('sessionQuery');
         const pricebook = currency === 'USD' ? pricebookUsd : pricebookCny;
         const projectionKey = currency === 'USD' ? 'sessionCostUsd' : 'sessionCost';
         const subagents = rootSessionId === undefined || sessionsStore === undefined
             ? []
-            : await collectSubagentCosts(rootSessionId, agents, sessionsStore, ctx.sessionProjections, projectionKey, subagentTree);
+            : await collectSubagentCosts(rootSessionId, agents, sessionsStore, ctx.sessionProjections, projectionKey, subagentTree, sessionQuery);
         return {
             balance: await refresh(),
             pricebook: pricebook.view(),

package/lib/types/subagent-cost.d.ts

@@ -5,14 +5,19 @@
  * conversation spend (root + every nesting level) and a per-subagent
  * breakdown.
  *
- * Enumeration is the durable, session-backed subagent tree
- * (`subagents.listDescendants`, the same listing the product's own subagent
- * catalog uses): it walks `parentSession` lineage recorded on every session
- * header, so a subagent that delegates further, a one-shot child, and a child
- * that has already settled out of the live agent registry are all counted at
- * any depth. The corpus is live-preferred but persistent-backed, which is why
- * nested and finished children no longer depend on an in-memory Agent
- * surviving.
+ * Two seams, in this order:
+ *
+ * 1. **Enumeration** — the durable, session-backed subagent tree
+ *    (`subagents.listDescendants`, the same listing the product's own subagent
+ *    catalog uses): it walks `parentSession` lineage recorded on every session
+ *    header, so a subagent that delegates further, a one-shot child, and a
+ *    child whose Agent was unloaded are all found at any depth.
+ * 2. **Ledger read** — a resident child's registered projection, otherwise a
+ *    COLD restore over its stored log through the session query service
+ *    (`readSession` + `sessionProjections.restore`: the framework's own
+ *    checkpoint-plus-tail recipe). A freshly restarted process holds no live
+ *    session at all, which is exactly the case where counting only resident
+ *    children reported zero subagents for a conversation full of them.
  *
  * The runtime ownership walk over the live agent registry (`agents.isOwnedBy`
  * + `agents.list`) remains as a fallback for a deployment that mounts no
@@ -21,7 +26,7 @@
  *
  * @module @gamegeek-saikel/dsh-cost-meter/subagent-cost
  */
-import type { Session } from '@deepseek-ai/dsh-session';
+import type { Session, SessionEvent, SessionHeader } from '@deepseek-ai/dsh-session';
 import type { ProjectionSnapshot } from '@deepseek-ai/dsh-session-projection';
 import type { SessionCostTotals, SubagentCost } from './types.ts';
 /** The subset of the agents service the fallback walk needs. */
@@ -41,9 +46,36 @@ export interface SubagentSessionsService {
     get(id: string): Session | undefined;
     list(): Session[];
 }
-/** The subset of the sessionProjections service the aggregation needs. */
+/**
+ * The subset of the sessionProjections service the aggregation needs: the live
+ * read face plus the cold `restore` face when the registry exposes it.
+ */
 export interface SubagentProjectionsService {
     snapshot(session: Session): ProjectionSnapshot;
+    /**
+     * Restore one projection cut from stored events without a live session.
+     * @param checkpoint - persisted rows, or `{}` for a full fold.
+     * @param events - stored events from `baseSeq`, in seq order.
+     * @param baseSeq - the seq `events` starts at.
+     * @param header - the stored session header.
+     * @param inheritedEventCount - exact fork-inherited prefix length.
+     * @returns the restored snapshot.
+     */
+    restore?(checkpoint: Record<string, unknown>, events: readonly SessionEvent[], baseSeq: unknown, header: SessionHeader, inheritedEventCount: unknown): {
+        snapshot: ProjectionSnapshot;
+    };
+}
+/**
+ * The subset of the sessionQuery service the aggregation needs to read one
+ * stored subagent log. Only `readSession` is consulted; a deployment whose
+ * query engine does not answer it simply has no cold-ledger source.
+ */
+export interface SubagentQueryService {
+    readSession(sessionId: string): Promise<{
+        session: SessionHeader;
+        inheritedEventCount: unknown;
+        events: SessionEvent[];
+    }>;
 }
 /** One session-backed descendant row of the product's subagent listing. */
 interface SubagentDescendantEntry {
@@ -56,27 +88,34 @@ interface SubagentDescendantEntry {
 /**
  * The subset of the subagents service the durable enumeration needs. The real
  * service answers with branded `SessionId` values and takes one, so the
- * interface stays permissive at both ends and the module brands only what it
- * hands back into the service.
+ * interface stays permissive at both ends.
  */
 export interface SubagentTreeService {
     listDescendants(rootSessionId: string, signal?: AbortSignal): Promise<readonly SubagentDescendantEntry[]>;
 }
+/**
+ * Drop every cached cold fold. The cache is process-global and keyed by
+ * session id; tests (and any caller that knowingly replaced a session log)
+ * use this instead of compensating with synthetic ids.
+ */
+export declare function resetColdLedgerCache(): void;
 /**
  * Collect every session-backed descendant of `rootSessionId` with its
  * anchored cost totals: the durable subagent tree first (nested, settled, and
- * cold children included), then the live runtime ownership walk for whatever
- * the listing could not reach.
+ * cold children included — a resident child through its registered
+ * projection, a stored one through the cold restore), then the live runtime
+ * ownership walk for whatever the listing could not reach.
  * @param rootSessionId - the root conversation's session id.
  * @param agents - the agents service (live registry).
  * @param sessions - the sessions service (session store).
  * @param projections - the sessionProjections service.
  * @param projectionKey - the currency-specific ledger key.
  * @param subagents - the subagents service; omitted, only the runtime walk runs.
+ * @param query - the session query service; omitted, cold children are skipped.
  * @returns one entry per descendant with a priced or unpriced ledger; empty
  *   when the conversation has no subagents.
  */
-export declare function collectSubagentCosts(rootSessionId: string, agents: SubagentAgentsService | undefined, sessions: SubagentSessionsService, projections: SubagentProjectionsService, projectionKey?: 'sessionCost' | 'sessionCostUsd', subagents?: SubagentTreeService): Promise<SubagentCost[]>;
+export declare function collectSubagentCosts(rootSessionId: string, agents: SubagentAgentsService | undefined, sessions: SubagentSessionsService, projections: SubagentProjectionsService, projectionKey?: 'sessionCost' | 'sessionCostUsd', subagents?: SubagentTreeService, query?: SubagentQueryService): Promise<SubagentCost[]>;
 /** Sum several totals into one (empty list → the zero totals). */
 export declare function sumTotals(totals: readonly SessionCostTotals[]): SessionCostTotals;
 export {};

package/lib/types/subagent-cost.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subagent-cost.d.ts","sourceRoot":"","sources":["../../src/subagent-cost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAA;AACvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAA;AAC7E,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAEjE,gEAAgE;AAChE,MAAM,WAAW,qBAAqB;IACpC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS,CAAA;IACjD,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAA;IAC3D,IAAI,IAAI;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,EAAE,CAAA;CAC/B;AAED,gEAAgE;AAChE,MAAM,WAAW,uBAAuB;IACtC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAA;IACpC,IAAI,IAAI,OAAO,EAAE,CAAA;CAClB;AAED,0EAA0E;AAC1E,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,kBAAkB,CAAA;CAC/C;AAED,2EAA2E;AAC3E,UAAU,uBAAuB;IAC/B,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,YAAY,CAAA;IACrC,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;IACpB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CACxB;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,eAAe,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,uBAAuB,EAAE,CAAC,CAAA;CAC1G;AAgID;;;;;;;;;;;;;GAaG;AACH,wBAAsB,oBAAoB,CACxC,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,qBAAqB,GAAG,SAAS,EACzC,QAAQ,EAAE,uBAAuB,EACjC,WAAW,EAAE,0BAA0B,EACvC,aAAa,GAAE,aAAa,GAAG,gBAAgC,EAC/D,SAAS,CAAC,EAAE,mBAAmB,GAC9B,OAAO,CAAC,YAAY,EAAE,CAAC,CAczB;AAED,kEAAkE;AAClE,wBAAgB,SAAS,CAAC,MAAM,EAAE,SAAS,iBAAiB,EAAE,GAAG,iBAAiB,CAYjF"}
+{"version":3,"file":"subagent-cost.d.ts","sourceRoot":"","sources":["../../src/subagent-cost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AACpF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAA;AAC7E,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAEjE,gEAAgE;AAChE,MAAM,WAAW,qBAAqB;IACpC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS,CAAA;IACjD,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAA;IAC3D,IAAI,IAAI;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,EAAE,CAAA;CAC/B;AAED,gEAAgE;AAChE,MAAM,WAAW,uBAAuB;IACtC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAA;IACpC,IAAI,IAAI,OAAO,EAAE,CAAA;CAClB;AAED;;;GAGG;AACH,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,kBAAkB,CAAA;IAC9C;;;;;;;;OAQG;IACH,OAAO,CAAC,CACN,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,MAAM,EAAE,SAAS,YAAY,EAAE,EAC/B,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,aAAa,EACrB,mBAAmB,EAAE,OAAO,GAC3B;QAAE,QAAQ,EAAE,kBAAkB,CAAA;KAAE,CAAA;CACpC;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,aAAa,CAAC;QAAC,mBAAmB,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,YAAY,EAAE,CAAA;KAAE,CAAC,CAAA;CAC1H;AAED,2EAA2E;AAC3E,UAAU,uBAAuB;IAC/B,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,YAAY,CAAA;IACrC,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;IACpB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CACxB;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,eAAe,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,uBAAuB,EAAE,CAAC,CAAA;CAC1G;AA8BD;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAyKD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,oBAAoB,CACxC,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,qBAAqB,GAAG,SAAS,EACzC,QAAQ,EAAE,uBAAuB,EACjC,WAAW,EAAE,0BAA0B,EACvC,aAAa,GAAE,aAAa,GAAG,gBAAgC,EAC/D,SAAS,CAAC,EAAE,mBAAmB,EAC/B,KAAK,CAAC,EAAE,oBAAoB,GAC3B,OAAO,CAAC,YAAY,EAAE,CAAC,CAczB;AAED,kEAAkE;AAClE,wBAAgB,SAAS,CAAC,MAAM,EAAE,SAAS,iBAAiB,EAAE,GAAG,iBAAiB,CAYjF"}

package/lib/types/subagent-cost.js

@@ -5,14 +5,19 @@
  * conversation spend (root + every nesting level) and a per-subagent
  * breakdown.
  *
- * Enumeration is the durable, session-backed subagent tree
- * (`subagents.listDescendants`, the same listing the product's own subagent
- * catalog uses): it walks `parentSession` lineage recorded on every session
- * header, so a subagent that delegates further, a one-shot child, and a child
- * that has already settled out of the live agent registry are all counted at
- * any depth. The corpus is live-preferred but persistent-backed, which is why
- * nested and finished children no longer depend on an in-memory Agent
- * surviving.
+ * Two seams, in this order:
+ *
+ * 1. **Enumeration** — the durable, session-backed subagent tree
+ *    (`subagents.listDescendants`, the same listing the product's own subagent
+ *    catalog uses): it walks `parentSession` lineage recorded on every session
+ *    header, so a subagent that delegates further, a one-shot child, and a
+ *    child whose Agent was unloaded are all found at any depth.
+ * 2. **Ledger read** — a resident child's registered projection, otherwise a
+ *    COLD restore over its stored log through the session query service
+ *    (`readSession` + `sessionProjections.restore`: the framework's own
+ *    checkpoint-plus-tail recipe). A freshly restarted process holds no live
+ *    session at all, which is exactly the case where counting only resident
+ *    children reported zero subagents for a conversation full of them.
  *
  * The runtime ownership walk over the live agent registry (`agents.isOwnedBy`
  * + `agents.list`) remains as a fallback for a deployment that mounts no
@@ -30,8 +35,58 @@ const ZERO_TOTALS = {
     unpricedSteps: 0,
     steps: 0,
 };
-/** Resolve the ledger of one session, or undefined when it carries none yet. */
-function totalsOf(session, projections, projectionKey) {
+/** How long a cold fold is reused before the persisted log is read again. */
+const COLD_LEDGER_TTL_MS = 30_000;
+/** How many cold folds stay cached across requests. */
+const COLD_LEDGER_CACHE_LIMIT = 256;
+/** Cross-request cold-ledger cache, keyed by session id, insertion-ordered. */
+const coldLedgerCache = new Map();
+/**
+ * Drop every cached cold fold. The cache is process-global and keyed by
+ * session id; tests (and any caller that knowingly replaced a session log)
+ * use this instead of compensating with synthetic ids.
+ */
+export function resetColdLedgerCache() {
+    coldLedgerCache.clear();
+}
+/**
+ * Fold one stored subagent log into its ledger totals through the framework's
+ * own cold-read recipe: an empty checkpoint at seq 0, every stored event, and
+ * the exact inherited cut. Cached briefly so the route's poll cadence does not
+ * refold unchanged logs.
+ * @param sessionId - the subagent session to read.
+ * @param query - the session query service.
+ * @param projections - the projection registry (live + restore face).
+ * @param projectionKey - the currency-specific ledger key.
+ * @returns the restored totals, or undefined without a cold-read seam.
+ */
+async function readColdLedger(sessionId, query, projections, projectionKey) {
+    if (query === undefined || typeof query.readSession !== 'function')
+        return undefined;
+    if (typeof projections.restore !== 'function')
+        return undefined;
+    const cached = coldLedgerCache.get(sessionId);
+    if (cached !== undefined && Date.now() - cached.at < COLD_LEDGER_TTL_MS)
+        return cached.totals;
+    const log = await query.readSession(sessionId);
+    // The stored log starts at its own seq 0, so an empty checkpoint and
+    // `baseSeq` 0 fold every registered unit from `init` across the whole log —
+    // the exact same `apply` path a live session runs.
+    const restored = projections.restore({}, log.events, 0, log.session, log.inheritedEventCount);
+    const value = restored.snapshot.values[projectionKey];
+    const totals = value?.totals;
+    if (totals === undefined)
+        return undefined;
+    coldLedgerCache.set(sessionId, { totals, asOfSeq: Number(restored.snapshot.asOfSeq), at: Date.now() });
+    if (coldLedgerCache.size > COLD_LEDGER_CACHE_LIMIT) {
+        const oldest = coldLedgerCache.keys().next();
+        if (!oldest.done)
+            coldLedgerCache.delete(oldest.value);
+    }
+    return totals;
+}
+/** Resolve the ledger of one resident session, or undefined when it carries none. */
+function liveTotalsOf(session, projections, projectionKey) {
     if (session === undefined)
         return undefined;
     let snapshot;
@@ -44,10 +99,7 @@ function totalsOf(session, projections, projectionKey) {
     }
     return snapshot.values[projectionKey]?.totals;
 }
-/**
- * Index the live session store by id. Read once per request so the durable
- * listing resolves every row without a per-child store lookup.
- */
+/** Index the live session store by id, so the durable walk resolves rows cheaply. */
 function liveSessionsById(sessions) {
     const index = new Map();
     for (const session of sessions.list()) {
@@ -58,19 +110,19 @@ function liveSessionsById(sessions) {
     return index;
 }
 /**
- * Fold the durable subagent tree into cost rows. A child whose session carries
- * no ledger yet (never used a model, or a cold session the live store does not
- * hold) is skipped, as is a `diagnostic` row, which names no interpreted
- * child.
+ * Fold the durable subagent tree into cost rows: the live ledger when the
+ * child is resident, else its persisted-log restore. A `diagnostic` row names
+ * no interpreted child and is skipped.
  * @param rootSessionId - the root conversation's session id.
  * @param subagents - the subagents service (durable tree enumeration).
  * @param sessions - the sessions service (live session store).
  * @param projections - the sessionProjections service.
  * @param projectionKey - the currency-specific ledger key.
+ * @param query - the session query service (cold-ledger source), when mounted.
  * @returns one entry per descendant that has a ledger.
  * @throws whatever the listing throws; the caller decides the fallback.
  */
-async function collectDurableSubagentCosts(rootSessionId, subagents, sessions, projections, projectionKey) {
+async function collectDurableSubagentCosts(rootSessionId, subagents, sessions, projections, projectionKey, query) {
     const entries = await subagents.listDescendants(rootSessionId);
     if (entries.length === 0)
         return [];
@@ -78,13 +130,25 @@ async function collectDurableSubagentCosts(rootSessionId, subagents, sessions, p
     const result = [];
     const seen = new Set();
     for (const entry of entries) {
-        if (entry.kind !== 'child')
+        // A `diagnostic` row names a candidate the product's listing could not
+        // interpret; only interpreted children carry costs.
+        if (entry.kind === 'diagnostic')
             continue;
         const sessionId = String(entry.id);
         if (sessionId.length === 0 || sessionId === rootSessionId || seen.has(sessionId))
             continue;
         seen.add(sessionId);
-        const totals = totalsOf(live.get(sessionId), projections, projectionKey);
+        let totals = liveTotalsOf(live.get(sessionId), projections, projectionKey);
+        if (totals === undefined) {
+            try {
+                totals = await readColdLedger(sessionId, query, projections, projectionKey);
+            }
+            catch {
+                // One unreadable log (damaged, pruned, or a cancelled read) must not
+                // hide the other children's costs.
+                totals = undefined;
+            }
+        }
         if (totals === undefined)
             continue;
         result.push({
@@ -126,7 +190,7 @@ function collectRuntimeSubagentCosts(rootSessionId, agents, sessions, projection
                 continue;
             seen.add(candidateId);
             queue.push(candidate);
-            const totals = totalsOf(sessions.get(candidateId), projections, projectionKey);
+            const totals = liveTotalsOf(sessions.get(candidateId), projections, projectionKey);
             if (totals === undefined)
                 continue;
             result.push({ sessionId: candidateId, depth: -1, totals });
@@ -137,22 +201,24 @@ function collectRuntimeSubagentCosts(rootSessionId, agents, sessions, projection
 /**
  * Collect every session-backed descendant of `rootSessionId` with its
  * anchored cost totals: the durable subagent tree first (nested, settled, and
- * cold children included), then the live runtime ownership walk for whatever
- * the listing could not reach.
+ * cold children included — a resident child through its registered
+ * projection, a stored one through the cold restore), then the live runtime
+ * ownership walk for whatever the listing could not reach.
  * @param rootSessionId - the root conversation's session id.
  * @param agents - the agents service (live registry).
  * @param sessions - the sessions service (session store).
  * @param projections - the sessionProjections service.
  * @param projectionKey - the currency-specific ledger key.
  * @param subagents - the subagents service; omitted, only the runtime walk runs.
+ * @param query - the session query service; omitted, cold children are skipped.
  * @returns one entry per descendant with a priced or unpriced ledger; empty
  *   when the conversation has no subagents.
  */
-export async function collectSubagentCosts(rootSessionId, agents, sessions, projections, projectionKey = 'sessionCost', subagents) {
+export async function collectSubagentCosts(rootSessionId, agents, sessions, projections, projectionKey = 'sessionCost', subagents, query) {
     let durable = [];
     if (subagents !== undefined) {
         try {
-            durable = await collectDurableSubagentCosts(rootSessionId, subagents, sessions, projections, projectionKey);
+            durable = await collectDurableSubagentCosts(rootSessionId, subagents, sessions, projections, projectionKey, query);
         }
         catch {
             // A listing failure (no session query, a cancelled read, corrupt log)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gamegeek-saikel/dsh-cost-meter",
   "description": "Cost tracking plugin for the DeepSeek Harness Web GUI — snapshot-anchored per-turn pricing, account balance, and live cost estimates.",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "type": "module",
   "packageManager": "pnpm@11.7.0",
   "engines": {

package/src/index.ts

@@ -40,6 +40,7 @@ import { sessionCostIndexProjection } from './session-cost-index.ts'
 import {
   collectSubagentCosts,
   type SubagentAgentsService,
+  type SubagentQueryService,
   type SubagentSessionsService,
   type SubagentTreeService,
 } from './subagent-cost.ts'
@@ -460,11 +461,20 @@ export async function apply(ctx: Context, config?: Config): Promise<void> {
     const agents = ctx.get('agents') as SubagentAgentsService | undefined
     const sessionsStore = ctx.get('sessions') as SubagentSessionsService | undefined
     const subagentTree = ctx.get('subagents') as SubagentTreeService | undefined
+    const sessionQuery = ctx.get('sessionQuery') as SubagentQueryService | undefined
     const pricebook = currency === 'USD' ? pricebookUsd : pricebookCny
     const projectionKey = currency === 'USD' ? 'sessionCostUsd' : 'sessionCost'
     const subagents = rootSessionId === undefined || sessionsStore === undefined
       ? []
-      : await collectSubagentCosts(rootSessionId, agents, sessionsStore, ctx.sessionProjections, projectionKey, subagentTree)
+      : await collectSubagentCosts(
+        rootSessionId,
+        agents,
+        sessionsStore,
+        ctx.sessionProjections,
+        projectionKey,
+        subagentTree,
+        sessionQuery,
+      )
     return {
       balance: await refresh(),
       pricebook: pricebook.view(),

package/src/subagent-cost.ts

@@ -5,14 +5,19 @@
  * conversation spend (root + every nesting level) and a per-subagent
  * breakdown.
  *
- * Enumeration is the durable, session-backed subagent tree
- * (`subagents.listDescendants`, the same listing the product's own subagent
- * catalog uses): it walks `parentSession` lineage recorded on every session
- * header, so a subagent that delegates further, a one-shot child, and a child
- * that has already settled out of the live agent registry are all counted at
- * any depth. The corpus is live-preferred but persistent-backed, which is why
- * nested and finished children no longer depend on an in-memory Agent
- * surviving.
+ * Two seams, in this order:
+ *
+ * 1. **Enumeration** — the durable, session-backed subagent tree
+ *    (`subagents.listDescendants`, the same listing the product's own subagent
+ *    catalog uses): it walks `parentSession` lineage recorded on every session
+ *    header, so a subagent that delegates further, a one-shot child, and a
+ *    child whose Agent was unloaded are all found at any depth.
+ * 2. **Ledger read** — a resident child's registered projection, otherwise a
+ *    COLD restore over its stored log through the session query service
+ *    (`readSession` + `sessionProjections.restore`: the framework's own
+ *    checkpoint-plus-tail recipe). A freshly restarted process holds no live
+ *    session at all, which is exactly the case where counting only resident
+ *    children reported zero subagents for a conversation full of them.
  *
  * The runtime ownership walk over the live agent registry (`agents.isOwnedBy`
  * + `agents.list`) remains as a fallback for a deployment that mounts no
@@ -22,7 +27,7 @@
  * @module @gamegeek-saikel/dsh-cost-meter/subagent-cost
  */
 
-import type { Session } from '@deepseek-ai/dsh-session'
+import type { Session, SessionEvent, SessionHeader } from '@deepseek-ai/dsh-session'
 import type { ProjectionSnapshot } from '@deepseek-ai/dsh-session-projection'
 import type { SessionCostTotals, SubagentCost } from './types.ts'
 
@@ -39,9 +44,37 @@ export interface SubagentSessionsService {
   list(): Session[]
 }
 
-/** The subset of the sessionProjections service the aggregation needs. */
+/**
+ * The subset of the sessionProjections service the aggregation needs: the live
+ * read face plus the cold `restore` face when the registry exposes it.
+ */
 export interface SubagentProjectionsService {
   snapshot(session: Session): ProjectionSnapshot
+  /**
+   * Restore one projection cut from stored events without a live session.
+   * @param checkpoint - persisted rows, or `{}` for a full fold.
+   * @param events - stored events from `baseSeq`, in seq order.
+   * @param baseSeq - the seq `events` starts at.
+   * @param header - the stored session header.
+   * @param inheritedEventCount - exact fork-inherited prefix length.
+   * @returns the restored snapshot.
+   */
+  restore?(
+    checkpoint: Record<string, unknown>,
+    events: readonly SessionEvent[],
+    baseSeq: unknown,
+    header: SessionHeader,
+    inheritedEventCount: unknown,
+  ): { snapshot: ProjectionSnapshot }
+}
+
+/**
+ * The subset of the sessionQuery service the aggregation needs to read one
+ * stored subagent log. Only `readSession` is consulted; a deployment whose
+ * query engine does not answer it simply has no cold-ledger source.
+ */
+export interface SubagentQueryService {
+  readSession(sessionId: string): Promise<{ session: SessionHeader; inheritedEventCount: unknown; events: SessionEvent[] }>
 }
 
 /** One session-backed descendant row of the product's subagent listing. */
@@ -56,8 +89,7 @@ interface SubagentDescendantEntry {
 /**
  * The subset of the subagents service the durable enumeration needs. The real
  * service answers with branded `SessionId` values and takes one, so the
- * interface stays permissive at both ends and the module brands only what it
- * hands back into the service.
+ * interface stays permissive at both ends.
  */
 export interface SubagentTreeService {
   listDescendants(rootSessionId: string, signal?: AbortSignal): Promise<readonly SubagentDescendantEntry[]>
@@ -73,8 +105,75 @@ const ZERO_TOTALS: SessionCostTotals = {
   steps: 0,
 }
 
-/** Resolve the ledger of one session, or undefined when it carries none yet. */
-function totalsOf(
+/** One cold session's folded ledger, with the log watermark it describes. */
+interface ColdLedger {
+  /** Totals of the restored cut. */
+  readonly totals: SessionCostTotals
+  /** The restored cut's watermark (never read today; kept for diagnostics). */
+  readonly asOfSeq: number
+  /** Epoch millis when this fold was computed. */
+  readonly at: number
+}
+
+/** How long a cold fold is reused before the persisted log is read again. */
+const COLD_LEDGER_TTL_MS = 30_000
+/** How many cold folds stay cached across requests. */
+const COLD_LEDGER_CACHE_LIMIT = 256
+
+/** Cross-request cold-ledger cache, keyed by session id, insertion-ordered. */
+const coldLedgerCache = new Map<string, ColdLedger>()
+
+/**
+ * Drop every cached cold fold. The cache is process-global and keyed by
+ * session id; tests (and any caller that knowingly replaced a session log)
+ * use this instead of compensating with synthetic ids.
+ */
+export function resetColdLedgerCache(): void {
+  coldLedgerCache.clear()
+}
+
+/**
+ * Fold one stored subagent log into its ledger totals through the framework's
+ * own cold-read recipe: an empty checkpoint at seq 0, every stored event, and
+ * the exact inherited cut. Cached briefly so the route's poll cadence does not
+ * refold unchanged logs.
+ * @param sessionId - the subagent session to read.
+ * @param query - the session query service.
+ * @param projections - the projection registry (live + restore face).
+ * @param projectionKey - the currency-specific ledger key.
+ * @returns the restored totals, or undefined without a cold-read seam.
+ */
+async function readColdLedger(
+  sessionId: string,
+  query: SubagentQueryService | undefined,
+  projections: SubagentProjectionsService,
+  projectionKey: 'sessionCost' | 'sessionCostUsd',
+): Promise<SessionCostTotals | undefined> {
+  if (query === undefined || typeof query.readSession !== 'function') return undefined
+  if (typeof projections.restore !== 'function') return undefined
+
+  const cached = coldLedgerCache.get(sessionId)
+  if (cached !== undefined && Date.now() - cached.at < COLD_LEDGER_TTL_MS) return cached.totals
+
+  const log = await query.readSession(sessionId)
+  // The stored log starts at its own seq 0, so an empty checkpoint and
+  // `baseSeq` 0 fold every registered unit from `init` across the whole log —
+  // the exact same `apply` path a live session runs.
+  const restored = projections.restore({}, log.events, 0, log.session, log.inheritedEventCount)
+  const value = restored.snapshot.values[projectionKey] as { totals?: SessionCostTotals } | undefined
+  const totals = value?.totals
+  if (totals === undefined) return undefined
+
+  coldLedgerCache.set(sessionId, { totals, asOfSeq: Number(restored.snapshot.asOfSeq), at: Date.now() })
+  if (coldLedgerCache.size > COLD_LEDGER_CACHE_LIMIT) {
+    const oldest = coldLedgerCache.keys().next()
+    if (!oldest.done) coldLedgerCache.delete(oldest.value)
+  }
+  return totals
+}
+
+/** Resolve the ledger of one resident session, or undefined when it carries none. */
+function liveTotalsOf(
   session: Session | undefined,
   projections: SubagentProjectionsService,
   projectionKey: 'sessionCost' | 'sessionCostUsd',
@@ -90,10 +189,7 @@ function totalsOf(
   return snapshot.values[projectionKey]?.totals
 }
 
-/**
- * Index the live session store by id. Read once per request so the durable
- * listing resolves every row without a per-child store lookup.
- */
+/** Index the live session store by id, so the durable walk resolves rows cheaply. */
 function liveSessionsById(sessions: SubagentSessionsService): Map<string, Session> {
   const index = new Map<string, Session>()
   for (const session of sessions.list()) {
@@ -104,15 +200,15 @@ function liveSessionsById(sessions: SubagentSessionsService): Map<string, Sessio
 }
 
 /**
- * Fold the durable subagent tree into cost rows. A child whose session carries
- * no ledger yet (never used a model, or a cold session the live store does not
- * hold) is skipped, as is a `diagnostic` row, which names no interpreted
- * child.
+ * Fold the durable subagent tree into cost rows: the live ledger when the
+ * child is resident, else its persisted-log restore. A `diagnostic` row names
+ * no interpreted child and is skipped.
  * @param rootSessionId - the root conversation's session id.
  * @param subagents - the subagents service (durable tree enumeration).
  * @param sessions - the sessions service (live session store).
  * @param projections - the sessionProjections service.
  * @param projectionKey - the currency-specific ledger key.
+ * @param query - the session query service (cold-ledger source), when mounted.
  * @returns one entry per descendant that has a ledger.
  * @throws whatever the listing throws; the caller decides the fallback.
  */
@@ -122,6 +218,7 @@ async function collectDurableSubagentCosts(
   sessions: SubagentSessionsService,
   projections: SubagentProjectionsService,
   projectionKey: 'sessionCost' | 'sessionCostUsd',
+  query: SubagentQueryService | undefined,
 ): Promise<SubagentCost[]> {
   const entries = await subagents.listDescendants(rootSessionId)
   if (entries.length === 0) return []
@@ -130,12 +227,25 @@ async function collectDurableSubagentCosts(
   const result: SubagentCost[] = []
   const seen = new Set<string>()
   for (const entry of entries) {
-    if (entry.kind !== 'child') continue
+    // A `diagnostic` row names a candidate the product's listing could not
+    // interpret; only interpreted children carry costs.
+    if (entry.kind === 'diagnostic') continue
     const sessionId = String(entry.id)
     if (sessionId.length === 0 || sessionId === rootSessionId || seen.has(sessionId)) continue
     seen.add(sessionId)
-    const totals = totalsOf(live.get(sessionId), projections, projectionKey)
+
+    let totals = liveTotalsOf(live.get(sessionId), projections, projectionKey)
+    if (totals === undefined) {
+      try {
+        totals = await readColdLedger(sessionId, query, projections, projectionKey)
+      } catch {
+        // One unreadable log (damaged, pruned, or a cancelled read) must not
+        // hide the other children's costs.
+        totals = undefined
+      }
+    }
     if (totals === undefined) continue
+
     result.push({
       sessionId,
       ...(entry.parentId === undefined ? {} : { parentId: String(entry.parentId) }),
@@ -181,7 +291,7 @@ function collectRuntimeSubagentCosts(
       if (!agents.isOwnedBy(candidateId, parent)) continue
       seen.add(candidateId)
       queue.push(candidate)
-      const totals = totalsOf(sessions.get(candidateId), projections, projectionKey)
+      const totals = liveTotalsOf(sessions.get(candidateId), projections, projectionKey)
       if (totals === undefined) continue
       result.push({ sessionId: candidateId, depth: -1, totals })
     }
@@ -192,14 +302,16 @@ function collectRuntimeSubagentCosts(
 /**
  * Collect every session-backed descendant of `rootSessionId` with its
  * anchored cost totals: the durable subagent tree first (nested, settled, and
- * cold children included), then the live runtime ownership walk for whatever
- * the listing could not reach.
+ * cold children included — a resident child through its registered
+ * projection, a stored one through the cold restore), then the live runtime
+ * ownership walk for whatever the listing could not reach.
  * @param rootSessionId - the root conversation's session id.
  * @param agents - the agents service (live registry).
  * @param sessions - the sessions service (session store).
  * @param projections - the sessionProjections service.
  * @param projectionKey - the currency-specific ledger key.
  * @param subagents - the subagents service; omitted, only the runtime walk runs.
+ * @param query - the session query service; omitted, cold children are skipped.
  * @returns one entry per descendant with a priced or unpriced ledger; empty
  *   when the conversation has no subagents.
  */
@@ -210,11 +322,12 @@ export async function collectSubagentCosts(
   projections: SubagentProjectionsService,
   projectionKey: 'sessionCost' | 'sessionCostUsd' = 'sessionCost',
   subagents?: SubagentTreeService,
+  query?: SubagentQueryService,
 ): Promise<SubagentCost[]> {
   let durable: SubagentCost[] = []
   if (subagents !== undefined) {
     try {
-      durable = await collectDurableSubagentCosts(rootSessionId, subagents, sessions, projections, projectionKey)
+      durable = await collectDurableSubagentCosts(rootSessionId, subagents, sessions, projections, projectionKey, query)
     } catch {
       // A listing failure (no session query, a cancelled read, corrupt log)
       // must not hide the subagents the live registry can still prove.