@rayadesu/dsh-llm-billing 0.3.2 → 0.3.4

package/README.i18n.yaml

@@ -2,5 +2,5 @@
 # last confirmed-consistent state. Both languages carry equal authority; after
 # editing either side, bring the other along and re-record both hashes with:
 #   git hash-object README.md README.zh.md
-README.md: 9fc18328397e8824803ad7ed5335ee4b8a1063fe
-README.zh.md: 330b3ae531177a9b934137b4c2d1e32f949c16e0
+README.md: ed1a2bc7ef768d789ae4e6ba55c92254104b3a14
+README.zh.md: 3c84b79a1e1bc48fa43f8577bd81853f658a7087

package/README.md

@@ -29,6 +29,10 @@ After the first resolution per process, steady-state reads cost only the session
 
 Note: the projection path prices a session's history once, at the rates in effect when its events were folded — changing `billing.models` re-prices only events folded after the change (the events path re-prices the whole log).
 
+## Forked sessions
+
+A forked session (DSH's "fork" of a conversation) opens its log with a verbatim copy of its source session's events. Without special handling, the same model outputs would be billed once per copy: the child's session spend would include the inherited prefix, and today's spend would count it a second time alongside the parent's. The plugin prices only a session's OWN events — the durable `header.seedLength` is the fork boundary, and every event with `seq < seedLength` is treated as already billed in the source session. Fork children are therefore billed from their first new exchange onward (a freshly forked session prices to zero), today's spend counts each model output exactly once, and the same lineage-safe rule covers multi-generation forks and subagent forks (spawned with `context: 'fork'`). The boundary is the persisted header value, so a resumed fork child keeps its original boundary, while a session created without a seed — ordinary sessions and cold resumes included — carries no boundary and is billed in full.
+
 ## Configuration
 
 | Field | Default | Meaning |

package/README.zh.md

@@ -29,6 +29,10 @@
 
 注意：投影路径对每个会话的历史只计价一次，按事件被折叠时的费率——修改 `billing.models` 只影响变更后折叠的事件（事件路径会重算整个日志）。
 
+## 分叉会话
+
+分叉会话（DSH 的「分叉会话」）的日志以来源会话事件的逐字节副本开头。若不特殊处理，同一批模型输出会按副本数重复计费：子会话的会话花费会包含继承前缀，今日花费也会在父会话之外再计一次。插件只对会话的**自有事件**计费——持久的 `header.seedLength` 即分叉边界，凡是 `seq < seedLength` 的事件都视为已在来源会话计费。因此分叉子会话从分叉后的第一次新交流开始计费（刚分叉的会话花费为零），今日花费对每个模型输出只计一次，同一血缘规则同样覆盖多代分叉与 subagent 分叉（`context: 'fork'` 生成）。边界取自已持久化的 header 值，所以恢复后的分叉子会话保持原边界；而创建时没有 seed 的会话——包括普通会话与冷恢复——不带边界，正常全额计费。
+
 ## 配置
 
 | 字段 | 默认 | 含义 |

package/lib/index.js

@@ -379,6 +379,22 @@ function beijingParts(time) {
 function beijingDayKey(now) {
 	return beijingParts(now.getTime()).dayKey;
 }
+/**
+* The durable inherited-prefix boundary of one session: its header's
+* `seedLength`, or 0 for a session created without a seed. A forked session
+* (or any seeded replay) carries the number of events it inherited verbatim
+* from its source session in its header; every event with `seq < seedLength`
+* is a copy of an event already billed in that source session, so pricing
+* must skip them or the same model output is counted once per copy.
+* The value is the PERSISTED header field (not the in-memory constructor
+* seed length), so a resumed fork child keeps its original boundary and a
+* resume of an unseeded session stays at 0.
+* @param header - the session's durable header, when available.
+* @returns the inherited-prefix length; 0 for an unseeded session.
+*/
+function forkBoundaryOf(header) {
+	return header?.seedLength ?? 0;
+}
 /** Whether a Beijing (hour, weekday) pair falls inside any peak-hour window. */
 function isPeakParts(billing, hour, weekday) {
 	if (weekday === 0 || weekday === 6) return false;
@@ -554,11 +570,14 @@ function mergeTodaySpend(target, source) {
 * @param billing - resolved pricing with peak-hour windows.
 * @param names - model id → display label.
 * @param dayKey - when provided, only events on this Beijing calendar day contribute.
+* @param startSeq - when provided, only events with `seq >= startSeq` contribute
+*   (a forked session's inherited prefix, `seq < startSeq`, is skipped).
 * @returns the total cost plus one row per priced model.
 */
-function priceEvents(events, billing, names, dayKey) {
+function priceEvents(events, billing, names, dayKey, startSeq = 0) {
 	const accumulator = new SpendAccumulator();
 	for (const event of events) {
+		if (event.seq < startSeq) continue;
 		const priced = priceEvent(event, billing, names);
 		if (priced === void 0 || dayKey !== void 0 && priced.dayKey !== dayKey) continue;
 		accumulator.add(priced);
@@ -570,10 +589,14 @@ function priceEvents(events, billing, names, dayKey) {
 * @param events - one session's complete event log.
 * @param billing - resolved pricing with peak-hour windows.
 * @param catalog - model display rows, in presentation order.
+* @param startSeq - when provided, only events with `seq >= startSeq`
+*   contribute: a forked session's inherited prefix (see {@link forkBoundaryOf})
+*   is skipped, so each model output is billed only in the session that
+*   produced it.
 * @returns the session's total cost plus one row per priced model.
 */
-function computeSessionSpend(events, billing, catalog) {
-	return priceEvents(events, billing, new Map(catalog.map((model) => [model.id, model.name])));
+function computeSessionSpend(events, billing, catalog, startSeq = 0) {
+	return priceEvents(events, billing, new Map(catalog.map((model) => [model.id, model.name])), void 0, startSeq);
 }
 /**
 * Price one completed Turn's billed usage at the official per-model rates,
@@ -715,6 +738,26 @@ function foldBillingUnit(unit, events) {
 	for (const event of events) state = unit.apply(state, event);
 	return state;
 }
+/**
+* Fold a unit from init over one session's OWN events only: the complete log
+* minus its inherited fork prefix (`seq < seedLength`). A forked child's
+* prefix is a verbatim copy of events already billed in its source session,
+* so the detached cold recipe must skip it, or the same model output is
+* priced once per copy.
+* @param unit - the billing unit's fold halves.
+* @param events - the session's complete event log (in seq order).
+* @param seedLength - the durable inherited-prefix boundary
+*   ({@link forkBoundaryOf}); 0 for an unseeded session.
+* @returns the unit state folded over the session's own events.
+*/
+function foldOwnBilling(unit, events, seedLength = 0) {
+	let state = unit.init();
+	for (const event of events) {
+		if (event.seq < seedLength) continue;
+		state = unit.apply(state, event);
+	}
+	return state;
+}
 //#endregion
 //#region lib/types/today-spend.js
 /**
@@ -737,6 +780,16 @@ function foldBillingUnit(unit, events) {
 * 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.
+*
+* Forked sessions never double-count: a fork child's log opens with a
+* verbatim copy of its source session's events (`header.seedLength` of them),
+* so the scanner prices only the child's OWN events (`seq >= seedLength`) 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 header, so a resumed fork child keeps
+* its original boundary and an unseeded session stays at 0.
 * @module @rayadesu/dsh-llm-billing/today-spend
 */
 /**
@@ -835,6 +888,8 @@ var TodaySpendScanner = class {
 	coldResolved = /* @__PURE__ */ 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 = /* @__PURE__ */ new Map();
 	constructor(deps) {
 		this.deps = deps;
 	}
@@ -865,28 +920,34 @@ var TodaySpendScanner = class {
 	* 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.
+	* until the session is inspected again. A SEEDED session (fork child)
+	* skips the ladder entirely: its cached row was folded over the inherited
+	* prefix too, so it always detaches through inspect with the durable
+	* boundary applied to the local fold.
 	* @param id - the cold session's id.
+	* @param seedLength - the durable inherited-prefix boundary (0 for unseeded).
 	* @returns the resolved state and title, or `undefined` when unreadable.
 	*/
-	async resolveCold(id) {
+	async resolveCold(id, seedLength) {
 		const { persistence, projectionCache, unit, logger } = this.deps;
-		const cache = projectionCache?.();
-		if (cache !== void 0) try {
-			const value = (await cache.coldSnapshot(id)).values[BILLING_UNIT_KEY];
-			if (value !== void 0) return {
-				value,
-				title: null
-			};
-		} catch (error) {
-			logger.warn(`llm-billing: projection cold read for session ${id} failed: ${String(error)}`);
-		}
 		const persistenceService = persistence?.();
 		if (persistenceService === void 0) return void 0;
+		if (seedLength <= 0) {
+			const cache = projectionCache?.();
+			if (cache !== void 0) try {
+				const value = (await cache.coldSnapshot(id)).values[BILLING_UNIT_KEY];
+				if (value !== void 0) return {
+					value,
+					title: null
+				};
+			} catch (error) {
+				logger.warn(`llm-billing: projection cold read for session ${id} failed: ${String(error)}`);
+			}
+		}
 		try {
 			const inspection = await persistenceService.inspect(id);
 			return {
-				value: foldBillingUnit(unit, inspection.events),
+				value: foldOwnBilling(unit, inspection.events, seedLength),
 				title: foldSessionTitle(inspection.events)
 			};
 		} catch (error) {
@@ -894,6 +955,33 @@ var TodaySpendScanner = class {
 			return;
 		}
 	}
+	/**
+	* 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.
+	*/
+	ownBillingState(id, events, seedLength) {
+		const cached = this.ownStates.get(id);
+		const ownCount = events.length - seedLength;
+		if (cached !== void 0 && cached.count === ownCount) return cached.state;
+		let state;
+		if (cached !== void 0 && 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);
+			}
+		} 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;
@@ -904,7 +992,8 @@ var TodaySpendScanner = class {
 			const store = sessions();
 			if (store !== void 0) for (const session of store.list()) {
 				liveIds.add(session.id);
-				const state = projectionsService?.stateOf(session, BILLING_UNIT_KEY);
+				const seedLength = forkBoundaryOf(session.header);
+				const state = seedLength > 0 ? this.ownBillingState(session.id, session.events, seedLength) : projectionsService?.stateOf(session, BILLING_UNIT_KEY);
 				if (state !== void 0 && state.dayKey === dayKey) total = mergeTodaySpend(total, state.spend);
 			}
 		}
@@ -914,6 +1003,7 @@ var TodaySpendScanner = class {
 		const pending = [];
 		for (const { header, revision } of snapshots) {
 			if (liveIds.has(header.id)) continue;
+			const seedLength = forkBoundaryOf(header);
 			const resolved = this.coldResolved.get(header.id);
 			if (resolved !== void 0 && resolved.revision === revision) {
 				if (resolved.value.dayKey === dayKey) total = mergeTodaySpend(total, resolved.value.spend);
@@ -921,11 +1011,12 @@ var TodaySpendScanner = class {
 			}
 			pending.push({
 				id: header.id,
-				revision
+				revision,
+				seedLength
 			});
 		}
-		await withConcurrency(pending, 8, async ({ id, revision }) => {
-			const resolved = await this.resolveCold(id);
+		await withConcurrency(pending, 8, async ({ id, revision, seedLength }) => {
+			const resolved = await this.resolveCold(id, seedLength);
 			if (resolved !== void 0) this.coldResolved.set(id, {
 				revision,
 				...resolved
@@ -939,7 +1030,9 @@ var TodaySpendScanner = class {
 	}
 	/**
 	* Events path: price today's events in a single pass (per-event Beijing-day
-	* filter during collection, hard cap), gated by revisions.
+	* 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.
 	*/
 	async scanEvents(dayKey) {
 		const { sessions, persistence, maxEvents, logger, billing, catalog } = this.deps;
@@ -948,8 +1041,9 @@ var TodaySpendScanner = class {
 		const liveIds = /* @__PURE__ */ new Set();
 		let collected = 0;
 		let truncated = false;
-		const collect = (events) => {
+		const collect = (events, seedLength) => {
 			for (const event of events) {
+				if (event.seq < seedLength) continue;
 				if (beijingDayKey(new Date(event.time)) !== dayKey) continue;
 				collected += 1;
 				if (collected > maxEvents) {
@@ -964,7 +1058,7 @@ var TodaySpendScanner = class {
 			const store = sessions();
 			if (store !== void 0) for (const session of store.list()) {
 				liveIds.add(session.id);
-				collect(session.events);
+				collect(session.events, forkBoundaryOf(session.header));
 				if (truncated) break;
 			}
 		}
@@ -975,7 +1069,8 @@ var TodaySpendScanner = class {
 				if (liveIds.has(header.id)) continue;
 				if (this.lastEventsScan?.get(header.id) === revision) continue;
 				try {
-					collect((await persistenceService.inspect(header.id)).events);
+					const inspection = await persistenceService.inspect(header.id);
+					collect(inspection.events, forkBoundaryOf(inspection.meta));
 				} catch (error) {
 					logger.warn(`llm-billing: skipping unreadable session ${header.id}: ${String(error)}`);
 				}
@@ -990,7 +1085,8 @@ var TodaySpendScanner = class {
 	* 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).
+	* `null` when served from the projection cache). A fork child's row prices
+	* its OWN events only (the cell covers the inherited prefix too).
 	* @param dayKey - the Beijing-time calendar-day key to aggregate.
 	* @returns unsorted per-session rows for the day.
 	*/
@@ -1003,7 +1099,8 @@ var TodaySpendScanner = class {
 			const store = sessions();
 			if (store !== void 0) for (const session of store.list()) {
 				liveIds.add(session.id);
-				const state = projectionsService?.stateOf(session, BILLING_UNIT_KEY);
+				const seedLength = forkBoundaryOf(session.header);
+				const state = seedLength > 0 ? this.ownBillingState(session.id, session.events, seedLength) : projectionsService?.stateOf(session, BILLING_UNIT_KEY);
 				if (state !== void 0 && state.dayKey === dayKey) rows.set(session.id, {
 					sessionId: session.id,
 					title: foldSessionTitle(session.events),
@@ -1017,6 +1114,7 @@ var TodaySpendScanner = class {
 		const pending = [];
 		for (const { header, revision } of snapshots) {
 			if (liveIds.has(header.id)) continue;
+			const seedLength = forkBoundaryOf(header);
 			const resolved = this.coldResolved.get(header.id);
 			if (resolved !== void 0 && resolved.revision === revision) {
 				if (resolved.value.dayKey === dayKey) rows.set(header.id, {
@@ -1028,11 +1126,12 @@ var TodaySpendScanner = class {
 			}
 			pending.push({
 				id: header.id,
-				revision
+				revision,
+				seedLength
 			});
 		}
-		await withConcurrency(pending, 8, async ({ id, revision }) => {
-			const resolved = await this.resolveCold(id);
+		await withConcurrency(pending, 8, async ({ id, revision, seedLength }) => {
+			const resolved = await this.resolveCold(id, seedLength);
 			if (resolved !== void 0) this.coldResolved.set(id, {
 				revision,
 				...resolved
@@ -1051,9 +1150,11 @@ var TodaySpendScanner = class {
 	/**
 	* Events-path per-session scan: price today's events in a single pass,
 	* accumulating per session (per-event Beijing-day filter during collection,
-	* hard cap), gated by revisions. Titles fold from each session's complete
-	* log — a `session/title` event can predate today — so a rename is reflected
-	* as soon as the session's log is re-read.
+	* 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.
 	* @param dayKey - the Beijing-time calendar-day key to aggregate.
 	* @returns unsorted per-session rows for the day.
 	*/
@@ -1064,7 +1165,7 @@ var TodaySpendScanner = class {
 		const liveIds = /* @__PURE__ */ new Set();
 		let collected = 0;
 		let truncated = false;
-		const collect = (id, events) => {
+		const collect = (id, events, seedLength) => {
 			let row = rows.get(id);
 			if (row === void 0) {
 				row = {
@@ -1074,6 +1175,7 @@ var TodaySpendScanner = class {
 				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) {
@@ -1088,7 +1190,7 @@ var TodaySpendScanner = class {
 			const store = sessions();
 			if (store !== void 0) for (const session of store.list()) {
 				liveIds.add(session.id);
-				collect(session.id, session.events);
+				collect(session.id, session.events, forkBoundaryOf(session.header));
 				if (truncated) break;
 			}
 		}
@@ -1099,7 +1201,8 @@ var TodaySpendScanner = class {
 				if (liveIds.has(header.id)) continue;
 				if (this.lastEventsScan?.get(header.id) === revision) continue;
 				try {
-					collect(header.id, (await persistenceService.inspect(header.id)).events);
+					const inspection = await persistenceService.inspect(header.id);
+					collect(header.id, inspection.events, forkBoundaryOf(inspection.meta));
 				} catch (error) {
 					logger.warn(`llm-billing: skipping unreadable session ${header.id}: ${String(error)}`);
 				}
@@ -1189,20 +1292,27 @@ const TODAY_SPEND_CACHE_MS = 6e4;
 /** Hard cap on today's events collected by the events scan path. */
 const TODAY_SPEND_MAX_EVENTS = 2e5;
 /**
-* Read one session's event log: the live SessionStore first, then the
-* persistence backend for a flushed session (inspected directly by id — no
-* header listing).
+* Read one session's event log and durable seed boundary: the live
+* SessionStore first, then the persistence backend for a flushed session
+* (inspected directly by id — no header listing).
 * @param ctx - plugin context carrying the SessionStore and optional persistence.
 * @param sessionId - the session to read.
-* @returns the session's complete event log.
+* @returns the session's complete event log plus its inherited-prefix boundary.
 * @throws {@link LlmError} with code `NOT_FOUND` when the session is unknown.
 */
 async function sessionEvents(ctx, sessionId) {
 	const live = ctx.get("sessions")?.get(sessionId);
-	if (live !== void 0) return live.events;
+	if (live !== void 0) return {
+		events: live.events,
+		seedLength: forkBoundaryOf(live.header)
+	};
 	const persistence = ctx.get("sessionPersistence");
 	if (persistence !== void 0) try {
-		return (await persistence.inspect(sessionId)).events;
+		const inspection = await persistence.inspect(sessionId);
+		return {
+			events: inspection.events,
+			seedLength: forkBoundaryOf(inspection.meta)
+		};
 	} catch (error) {
 		throw new LlmError(`llm-billing: session ${sessionId} not found`, "NOT_FOUND", { cause: error });
 	}
@@ -1238,21 +1348,22 @@ function apply(ctx, config) {
 	}));
 	const sessionSpendCache = /* @__PURE__ */ new Map();
 	const fetchSessionSpend = async (sessionId) => {
-		const events = await sessionEvents(ctx, sessionId);
+		const { events, seedLength } = await sessionEvents(ctx, sessionId);
+		const ownCount = events.length - seedLength;
 		const cached = sessionSpendCache.get(sessionId);
-		if (cached !== void 0 && cached.count === events.length) return cached.spend;
-		if (cached !== void 0 && cached.count < events.length) {
-			const spend = mergeTodaySpend(cached.spend, computeSessionSpend(events.slice(cached.count), billing, catalog));
+		if (cached !== void 0 && cached.count === ownCount) return cached.spend;
+		if (cached !== void 0 && cached.count < ownCount) {
+			const spend = mergeTodaySpend(cached.spend, computeSessionSpend(events.slice(seedLength + cached.count), billing, catalog));
 			sessionSpendCache.set(sessionId, {
-				count: events.length,
+				count: ownCount,
 				spend
 			});
 			return spend;
 		}
-		const spend = computeSessionSpend(events, billing, catalog);
+		const spend = computeSessionSpend(events, billing, catalog, seedLength);
 		if (sessionSpendCache.size >= 1024) sessionSpendCache.clear();
 		sessionSpendCache.set(sessionId, {
-			count: events.length,
+			count: ownCount,
 			spend
 		});
 		return spend;
@@ -1283,7 +1394,8 @@ function apply(ctx, config) {
 	const fetchTodaySpend = async (force = false) => todayCache.get(force);
 	const fetchTodaySessionsSpend = async (force = false) => todaySessionsCache.get(force);
 	const fetchTurnSpend = async (sessionId, messageId) => {
-		return computeTurnSpend(await sessionEvents(ctx, sessionId), billing, catalog, messageId);
+		const { events } = await sessionEvents(ctx, sessionId);
+		return computeTurnSpend(events, billing, catalog, messageId);
 	};
 	new DeepSeekBalanceGateway(ctx, {
 		fetchBalance,
@@ -1294,4 +1406,4 @@ function apply(ctx, config) {
 	});
 }
 //#endregion
-export { BILLING_UNIT_KEY, Config, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, DeepSeekBalanceGateway, PUBLIC_BASE_URL, SpendAccumulator, TODAY_SPEND_CACHE_MS, TODAY_SPEND_MAX_EVENTS, TodaySpendCache, TodaySpendScanner, addEventContribution, apply, beijingDayKey, billingTodaySpendDefinition, computeSessionSpend, computeTodaySpend, computeTurnSpend, emptyTodaySpend, fetchDeepSeekBalance, foldBillingUnit, foldSessionTitle, isPeak, mergeTodaySpend, name, parseDeepSeekBalance, priceEvent, resolveBilling };
+export { BILLING_UNIT_KEY, Config, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, DeepSeekBalanceGateway, PUBLIC_BASE_URL, SpendAccumulator, TODAY_SPEND_CACHE_MS, TODAY_SPEND_MAX_EVENTS, TodaySpendCache, TodaySpendScanner, addEventContribution, apply, beijingDayKey, billingTodaySpendDefinition, computeSessionSpend, computeTodaySpend, computeTurnSpend, emptyTodaySpend, fetchDeepSeekBalance, foldBillingUnit, foldOwnBilling, foldSessionTitle, forkBoundaryOf, isPeak, mergeTodaySpend, name, parseDeepSeekBalance, priceEvent, resolveBilling };

package/lib/types/billing.d.ts

@@ -87,6 +87,22 @@ export interface ResolvedBilling {
 export declare function resolveBilling(config: BillingConfig | undefined): ResolvedBilling;
 /** The Beijing (Asia/Shanghai, UTC+8, no DST) calendar-day key of a timestamp. */
 export declare function beijingDayKey(now: Date): string;
+/**
+ * The durable inherited-prefix boundary of one session: its header's
+ * `seedLength`, or 0 for a session created without a seed. A forked session
+ * (or any seeded replay) carries the number of events it inherited verbatim
+ * from its source session in its header; every event with `seq < seedLength`
+ * is a copy of an event already billed in that source session, so pricing
+ * must skip them or the same model output is counted once per copy.
+ * The value is the PERSISTED header field (not the in-memory constructor
+ * seed length), so a resumed fork child keeps its original boundary and a
+ * resume of an unseeded session stays at 0.
+ * @param header - the session's durable header, when available.
+ * @returns the inherited-prefix length; 0 for an unseeded session.
+ */
+export declare function forkBoundaryOf(header: {
+    readonly seedLength?: number;
+} | undefined): number;
 /**
  * Whether a timestamp falls inside any peak-hour window (Beijing time,
  * weekdays Monday–Friday only). Weekends (Saturday and Sunday) are always
@@ -181,12 +197,16 @@ export declare function mergeTodaySpend(target: DeepSeekTodaySpend, source: Deep
  * @param events - one session's complete event log.
  * @param billing - resolved pricing with peak-hour windows.
  * @param catalog - model display rows, in presentation order.
+ * @param startSeq - when provided, only events with `seq >= startSeq`
+ *   contribute: a forked session's inherited prefix (see {@link forkBoundaryOf})
+ *   is skipped, so each model output is billed only in the session that
+ *   produced it.
  * @returns the session's total cost plus one row per priced model.
  */
 export declare function computeSessionSpend(events: readonly SessionEvent[], billing: ResolvedBilling, catalog: readonly {
     id: string;
     name: string;
-}[]): DeepSeekSessionSpend;
+}[], startSeq?: number): DeepSeekSessionSpend;
 /**
  * Price one completed Turn's billed usage at the official per-model rates,
  * identified by its closing assistant message id. The turn's events are those

package/lib/types/billing.js

@@ -80,6 +80,22 @@ function beijingParts(time) {
 export function beijingDayKey(now) {
     return beijingParts(now.getTime()).dayKey;
 }
+/**
+ * The durable inherited-prefix boundary of one session: its header's
+ * `seedLength`, or 0 for a session created without a seed. A forked session
+ * (or any seeded replay) carries the number of events it inherited verbatim
+ * from its source session in its header; every event with `seq < seedLength`
+ * is a copy of an event already billed in that source session, so pricing
+ * must skip them or the same model output is counted once per copy.
+ * The value is the PERSISTED header field (not the in-memory constructor
+ * seed length), so a resumed fork child keeps its original boundary and a
+ * resume of an unseeded session stays at 0.
+ * @param header - the session's durable header, when available.
+ * @returns the inherited-prefix length; 0 for an unseeded session.
+ */
+export function forkBoundaryOf(header) {
+    return header?.seedLength ?? 0;
+}
 /** Whether a Beijing (hour, weekday) pair falls inside any peak-hour window. */
 function isPeakParts(billing, hour, weekday) {
     if (weekday === 0 || weekday === 6)
@@ -249,11 +265,15 @@ export function mergeTodaySpend(target, source) {
  * @param billing - resolved pricing with peak-hour windows.
  * @param names - model id → display label.
  * @param dayKey - when provided, only events on this Beijing calendar day contribute.
+ * @param startSeq - when provided, only events with `seq >= startSeq` contribute
+ *   (a forked session's inherited prefix, `seq < startSeq`, is skipped).
  * @returns the total cost plus one row per priced model.
  */
-function priceEvents(events, billing, names, dayKey) {
+function priceEvents(events, billing, names, dayKey, startSeq = 0) {
     const accumulator = new SpendAccumulator();
     for (const event of events) {
+        if (event.seq < startSeq)
+            continue;
         const priced = priceEvent(event, billing, names);
         if (priced === undefined || (dayKey !== undefined && priced.dayKey !== dayKey))
             continue;
@@ -266,11 +286,15 @@ function priceEvents(events, billing, names, dayKey) {
  * @param events - one session's complete event log.
  * @param billing - resolved pricing with peak-hour windows.
  * @param catalog - model display rows, in presentation order.
+ * @param startSeq - when provided, only events with `seq >= startSeq`
+ *   contribute: a forked session's inherited prefix (see {@link forkBoundaryOf})
+ *   is skipped, so each model output is billed only in the session that
+ *   produced it.
  * @returns the session's total cost plus one row per priced model.
  */
-export function computeSessionSpend(events, billing, catalog) {
+export function computeSessionSpend(events, billing, catalog, startSeq = 0) {
     const names = new Map(catalog.map(model => [model.id, model.name]));
-    return priceEvents(events, billing, names);
+    return priceEvents(events, billing, names, undefined, startSeq);
 }
 /**
  * Price one completed Turn's billed usage at the official per-model rates,

package/lib/types/index.d.ts

@@ -24,10 +24,10 @@ import type { Context } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
 import type { BillingConfig } from './billing.ts';
 export { DeepSeekBalanceGateway, fetchDeepSeekBalance, parseDeepSeekBalance } from './balance.ts';
-export { addEventContribution, beijingDayKey, computeSessionSpend, computeTodaySpend, computeTurnSpend, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, emptyTodaySpend, isPeak, mergeTodaySpend, priceEvent, resolveBilling, SpendAccumulator, } from './billing.ts';
+export { addEventContribution, beijingDayKey, computeSessionSpend, computeTodaySpend, computeTurnSpend, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, emptyTodaySpend, forkBoundaryOf, isPeak, mergeTodaySpend, priceEvent, resolveBilling, SpendAccumulator, } from './billing.ts';
 export type { BillingConfig, BillingConfigModel, BillingEventContribution, DeepSeekModelPricing, DeepSeekTokenPrice, PeakHourWindow, ResolvedBilling, } from './billing.ts';
 export type * from './types.ts';
-export { BILLING_UNIT_KEY, billingTodaySpendDefinition, foldBillingUnit } from './projection.ts';
+export { BILLING_UNIT_KEY, billingTodaySpendDefinition, foldBillingUnit, foldOwnBilling } from './projection.ts';
 export type { BillingUnitState } from './projection.ts';
 export { foldSessionTitle, TodaySpendCache, TodaySpendScanner } from './today-spend.ts';
 export type { ScannerPersistedHeader, ScannerSession, TodaySpendScannerDeps } from './today-spend.ts';

package/lib/types/index.js

@@ -25,12 +25,12 @@ import { assertUsableApiKey, LlmError } from '@deepseek-ai/dsh-llm';
 import { credentialRef } from '@deepseek-ai/dsh-credentials';
 import { launchEnvironmentOf } from '@deepseek-ai/dsh-launch-environment';
 import { DeepSeekBalanceGateway, fetchDeepSeekBalance } from "./balance.js";
-import { computeSessionSpend, computeTurnSpend, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, mergeTodaySpend, resolveBilling, } from "./billing.js";
+import { computeSessionSpend, computeTurnSpend, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, forkBoundaryOf, mergeTodaySpend, resolveBilling, } from "./billing.js";
 import { billingTodaySpendDefinition } from "./projection.js";
 import { TodaySpendCache, TodaySpendScanner } from "./today-spend.js";
 export { DeepSeekBalanceGateway, fetchDeepSeekBalance, parseDeepSeekBalance } from "./balance.js";
-export { addEventContribution, beijingDayKey, computeSessionSpend, computeTodaySpend, computeTurnSpend, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, emptyTodaySpend, isPeak, mergeTodaySpend, priceEvent, resolveBilling, SpendAccumulator, } from "./billing.js";
-export { BILLING_UNIT_KEY, billingTodaySpendDefinition, foldBillingUnit } from "./projection.js";
+export { addEventContribution, beijingDayKey, computeSessionSpend, computeTodaySpend, computeTurnSpend, DEFAULT_MODEL_PRICING, DEFAULT_PEAK_HOURS, emptyTodaySpend, forkBoundaryOf, isPeak, mergeTodaySpend, priceEvent, resolveBilling, SpendAccumulator, } from "./billing.js";
+export { BILLING_UNIT_KEY, billingTodaySpendDefinition, foldBillingUnit, foldOwnBilling } from "./projection.js";
 export { foldSessionTitle, TodaySpendCache, TodaySpendScanner } from "./today-spend.js";
 export const name = 'llm-billing';
 const DEFAULT_API_KEY_ENV = 'DEEPSEEK_API_KEY';
@@ -73,23 +73,24 @@ export const TODAY_SPEND_CACHE_MS = 60_000;
 /** Hard cap on today's events collected by the events scan path. */
 export const TODAY_SPEND_MAX_EVENTS = 200_000;
 /**
- * Read one session's event log: the live SessionStore first, then the
- * persistence backend for a flushed session (inspected directly by id — no
- * header listing).
+ * Read one session's event log and durable seed boundary: the live
+ * SessionStore first, then the persistence backend for a flushed session
+ * (inspected directly by id — no header listing).
  * @param ctx - plugin context carrying the SessionStore and optional persistence.
  * @param sessionId - the session to read.
- * @returns the session's complete event log.
+ * @returns the session's complete event log plus its inherited-prefix boundary.
  * @throws {@link LlmError} with code `NOT_FOUND` when the session is unknown.
  */
 async function sessionEvents(ctx, sessionId) {
     const sessions = ctx.get('sessions');
     const live = sessions?.get(sessionId);
     if (live !== undefined)
-        return live.events;
+        return { events: live.events, seedLength: forkBoundaryOf(live.header) };
     const persistence = ctx.get('sessionPersistence');
     if (persistence !== undefined) {
         try {
-            return (await persistence.inspect(sessionId)).events;
+            const inspection = await persistence.inspect(sessionId);
+            return { events: inspection.events, seedLength: forkBoundaryOf(inspection.meta) };
         }
         catch (error) {
             throw new LlmError(`llm-billing: session ${sessionId} not found`, 'NOT_FOUND', { cause: error });
@@ -130,26 +131,28 @@ export function apply(ctx, config) {
     const catalog = (config.models ?? DEFAULT_MODELS).map(model => ({ id: model.id, name: model.name ?? model.id }));
     // Per-session incremental spend cache: a session log is append-only and
     // chronological (the same assumption the projection unit makes), so a spend
-    // computed for `count` events stays valid while the log length is unchanged,
-    // and only the appended tail needs pricing when it grows. A pricing-table
-    // change does not retroactively reprice (same caveat as the projection
-    // path); the map is capped so an unbounded session-id space cannot grow it
-    // without bound.
+    // computed for `count` EVENTS OF THE SESSION'S OWN WORK (the log minus its
+    // inherited fork prefix) stays valid while the log length is unchanged, and
+    // only the appended tail needs pricing when it grows. A forked child's
+    // inherited prefix (`seq < seedLength`) is priced only in its source
+    // session; the map is capped so an unbounded session-id space cannot grow
+    // it without bound.
     const sessionSpendCache = new Map();
     const fetchSessionSpend = async (sessionId) => {
-        const events = await sessionEvents(ctx, sessionId);
+        const { events, seedLength } = await sessionEvents(ctx, sessionId);
+        const ownCount = events.length - seedLength;
         const cached = sessionSpendCache.get(sessionId);
-        if (cached !== undefined && cached.count === events.length)
+        if (cached !== undefined && cached.count === ownCount)
             return cached.spend;
-        if (cached !== undefined && cached.count < events.length) {
-            const spend = mergeTodaySpend(cached.spend, computeSessionSpend(events.slice(cached.count), billing, catalog));
-            sessionSpendCache.set(sessionId, { count: events.length, spend });
+        if (cached !== undefined && cached.count < ownCount) {
+            const spend = mergeTodaySpend(cached.spend, computeSessionSpend(events.slice(seedLength + cached.count), billing, catalog));
+            sessionSpendCache.set(sessionId, { count: ownCount, spend });
             return spend;
         }
-        const spend = computeSessionSpend(events, billing, catalog);
+        const spend = computeSessionSpend(events, billing, catalog, seedLength);
         if (sessionSpendCache.size >= 1024)
             sessionSpendCache.clear();
-        sessionSpendCache.set(sessionId, { count: events.length, spend });
+        sessionSpendCache.set(sessionId, { count: ownCount, spend });
         return spend;
     };
     // Plan C: register the per-session spend projection unit on the projection
@@ -190,7 +193,7 @@ export function apply(ctx, config) {
     const fetchTodaySpend = async (force = false) => todayCache.get(force);
     const fetchTodaySessionsSpend = async (force = false) => todaySessionsCache.get(force);
     const fetchTurnSpend = async (sessionId, messageId) => {
-        const events = await sessionEvents(ctx, sessionId);
+        const { events } = await sessionEvents(ctx, sessionId);
         return computeTurnSpend(events, billing, catalog, messageId);
     };
     new DeepSeekBalanceGateway(ctx, { fetchBalance, fetchSessionSpend, fetchTodaySpend, fetchTodaySessionsSpend, fetchTurnSpend });

package/lib/types/projection.d.ts

@@ -66,4 +66,17 @@ export declare function billingTodaySpendDefinition(billing: ResolvedBilling, ca
 }[]): BillingUnitDefinition;
 /** Fold a unit from init over one session's event log (the detached cold recipe). */
 export declare function foldBillingUnit(unit: Pick<ProjectionDefinition<'billingTodaySpend', BillingUnitState>, 'init' | 'apply'>, events: readonly SessionEvent[]): BillingUnitState;
+/**
+ * Fold a unit from init over one session's OWN events only: the complete log
+ * minus its inherited fork prefix (`seq < seedLength`). A forked child's
+ * prefix is a verbatim copy of events already billed in its source session,
+ * so the detached cold recipe must skip it, or the same model output is
+ * priced once per copy.
+ * @param unit - the billing unit's fold halves.
+ * @param events - the session's complete event log (in seq order).
+ * @param seedLength - the durable inherited-prefix boundary
+ *   ({@link forkBoundaryOf}); 0 for an unseeded session.
+ * @returns the unit state folded over the session's own events.
+ */
+export declare function foldOwnBilling(unit: Pick<ProjectionDefinition<'billingTodaySpend', BillingUnitState>, 'init' | 'apply'>, events: readonly SessionEvent[], seedLength?: number): BillingUnitState;
 //# sourceMappingURL=projection.d.ts.map

package/lib/types/projection.js

@@ -85,4 +85,25 @@ export function foldBillingUnit(unit, events) {
         state = unit.apply(state, event);
     return state;
 }
+/**
+ * Fold a unit from init over one session's OWN events only: the complete log
+ * minus its inherited fork prefix (`seq < seedLength`). A forked child's
+ * prefix is a verbatim copy of events already billed in its source session,
+ * so the detached cold recipe must skip it, or the same model output is
+ * priced once per copy.
+ * @param unit - the billing unit's fold halves.
+ * @param events - the session's complete event log (in seq order).
+ * @param seedLength - the durable inherited-prefix boundary
+ *   ({@link forkBoundaryOf}); 0 for an unseeded session.
+ * @returns the unit state folded over the session's own events.
+ */
+export function foldOwnBilling(unit, events, seedLength = 0) {
+    let state = unit.init();
+    for (const event of events) {
+        if (event.seq < seedLength)
+            continue;
+        state = unit.apply(state, event);
+    }
+    return state;
+}
 //# sourceMappingURL=projection.js.map

package/lib/types/today-spend.d.ts

@@ -18,6 +18,16 @@
  * 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.
+ *
+ * Forked sessions never double-count: a fork child's log opens with a
+ * verbatim copy of its source session's events (`header.seedLength` of them),
+ * so the scanner prices only the child's OWN events (`seq >= seedLength`) 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 header, so a resumed fork child keeps
+ * its original boundary and an unseeded session stays at 0.
  * @module @rayadesu/dsh-llm-billing/today-spend
  */
 import type { SessionEvent, SessionId } from '@deepseek-ai/dsh-session';
@@ -39,10 +49,16 @@ export declare function foldSessionTitle(events: readonly SessionEvent[]): strin
 export interface ScannerSession {
     readonly id: SessionId;
     readonly events: readonly SessionEvent[];
+    /** Durable header slice; `seedLength` marks a fork child's inherited prefix. */
+    readonly header?: {
+        readonly seedLength?: number;
+    };
 }
-/** Structural slice of a listed persisted session. */
+/** Structural slice of a listed persisted session (the snapshot header is a full SessionHeader). */
 export interface ScannerPersistedHeader {
     readonly id: SessionId;
+    /** Durable fork boundary carried by the snapshot header; absent for an unseeded session. */
+    readonly seedLength?: number;
 }
 /** Structural slices of the optional services the scanner reads through. */
 export interface TodaySpendScannerDeps {
@@ -57,6 +73,9 @@ export interface TodaySpendScannerDeps {
             revision: SessionPersistenceRevision;
         }[]>;
         inspect(id: SessionId): Promise<{
+            meta: {
+                seedLength?: number;
+            };
             events: readonly SessionEvent[];
         }>;
     } | undefined;
@@ -135,6 +154,8 @@ export declare class TodaySpendScanner {
     private readonly coldResolved;
     /** Cold sessions resolved on the events path: id → revision (events were collected). */
     private lastEventsScan;
+    /** Live fork children priced on the projection path: id → own-events count + folded state. */
+    private readonly ownStates;
     constructor(deps: TodaySpendScannerDeps);
     /**
      * Compute today's aggregate for one Beijing day.
@@ -155,23 +176,40 @@ export declare class TodaySpendScanner {
      * 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.
+     * until the session is inspected again. A SEEDED session (fork child)
+     * skips the ladder entirely: its cached row was folded over the inherited
+     * prefix too, so it always detaches through inspect with the durable
+     * boundary applied to the local fold.
      * @param id - the cold session's id.
+     * @param seedLength - the durable inherited-prefix boundary (0 for unseeded).
      * @returns the resolved state and title, or `undefined` when unreadable.
      */
     private resolveCold;
+    /**
+     * 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.
+     */
+    private ownBillingState;
     /** Projection path: eager cells for live sessions, revision-gated cold ladder for the rest. */
     private scanProjections;
     /**
      * Events path: price today's events in a single pass (per-event Beijing-day
-     * filter during collection, hard cap), gated by revisions.
+     * 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.
      */
     private scanEvents;
     /**
      * 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).
+     * `null` when served from the projection cache). A fork child's row prices
+     * its OWN events only (the cell covers the inherited prefix too).
      * @param dayKey - the Beijing-time calendar-day key to aggregate.
      * @returns unsorted per-session rows for the day.
      */
@@ -179,9 +217,11 @@ export declare class TodaySpendScanner {
     /**
      * Events-path per-session scan: price today's events in a single pass,
      * accumulating per session (per-event Beijing-day filter during collection,
-     * hard cap), gated by revisions. Titles fold from each session's complete
-     * log — a `session/title` event can predate today — so a rename is reflected
-     * as soon as the session's log is re-read.
+     * 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.
      * @param dayKey - the Beijing-time calendar-day key to aggregate.
      * @returns unsorted per-session rows for the day.
      */

package/lib/types/today-spend.js

@@ -18,10 +18,20 @@
  * 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.
+ *
+ * Forked sessions never double-count: a fork child's log opens with a
+ * verbatim copy of its source session's events (`header.seedLength` of them),
+ * so the scanner prices only the child's OWN events (`seq >= seedLength`) 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 header, so a resumed fork child keeps
+ * its original boundary and an unseeded session stays at 0.
  * @module @rayadesu/dsh-llm-billing/today-spend
  */
-import { beijingDayKey, emptyTodaySpend, mergeTodaySpend, priceEvent, SpendAccumulator } from "./billing.js";
-import { BILLING_UNIT_KEY, foldBillingUnit } from "./projection.js";
+import { beijingDayKey, emptyTodaySpend, forkBoundaryOf, mergeTodaySpend, priceEvent, SpendAccumulator } from "./billing.js";
+import { BILLING_UNIT_KEY, foldOwnBilling } from "./projection.js";
 /**
  * Fold one session's durable display title: the latest `session/title`
  * event's text (last-wins, matching the `title` projection), or `null` before
@@ -128,6 +138,8 @@ export class TodaySpendScanner {
     coldResolved = 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;
     }
@@ -161,29 +173,35 @@ export class TodaySpendScanner {
      * 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.
+     * until the session is inspected again. A SEEDED session (fork child)
+     * skips the ladder entirely: its cached row was folded over the inherited
+     * prefix too, so it always detaches through inspect with the durable
+     * boundary applied to the local fold.
      * @param id - the cold session's id.
+     * @param seedLength - the durable inherited-prefix boundary (0 for unseeded).
      * @returns the resolved state and title, or `undefined` when unreadable.
      */
-    async resolveCold(id) {
+    async resolveCold(id, seedLength) {
         const { persistence, projectionCache, unit, logger } = this.deps;
-        const cache = projectionCache?.();
-        if (cache !== undefined) {
-            try {
-                const value = (await cache.coldSnapshot(id)).values[BILLING_UNIT_KEY];
-                if (value !== undefined)
-                    return { value, title: null };
-            }
-            catch (error) {
-                logger.warn(`llm-billing: projection cold read for session ${id} failed: ${String(error)}`);
-            }
-        }
         const persistenceService = persistence?.();
         if (persistenceService === undefined)
             return undefined;
+        if (seedLength <= 0) {
+            const cache = projectionCache?.();
+            if (cache !== undefined) {
+                try {
+                    const value = (await cache.coldSnapshot(id)).values[BILLING_UNIT_KEY];
+                    if (value !== undefined)
+                        return { value, title: null };
+                }
+                catch (error) {
+                    logger.warn(`llm-billing: projection cold read for session ${id} failed: ${String(error)}`);
+                }
+            }
+        }
         try {
             const inspection = await persistenceService.inspect(id);
-            return { value: foldBillingUnit(unit, inspection.events), title: foldSessionTitle(inspection.events) };
+            return { value: foldOwnBilling(unit, inspection.events, seedLength), title: foldSessionTitle(inspection.events) };
         }
         catch (error) {
             // One unreadable session must not blank the whole-day aggregate.
@@ -191,6 +209,35 @@ export class TodaySpendScanner {
             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.
+     */
+    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);
+            }
+        }
+        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;
@@ -203,7 +250,12 @@ export class TodaySpendScanner {
             if (store !== undefined) {
                 for (const session of store.list()) {
                     liveIds.add(session.id);
-                    const state = projectionsService?.stateOf(session, BILLING_UNIT_KEY);
+                    const seedLength = forkBoundaryOf(session.header);
+                    // 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, session.events, seedLength)
+                        : projectionsService?.stateOf(session, BILLING_UNIT_KEY);
                     if (state !== undefined && state.dayKey === dayKey) {
                         total = mergeTodaySpend(total, state.spend);
                     }
@@ -218,16 +270,17 @@ export class TodaySpendScanner {
         for (const { header, revision } of snapshots) {
             if (liveIds.has(header.id))
                 continue;
+            const seedLength = forkBoundaryOf(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);
                 continue;
             }
-            pending.push({ id: header.id, revision });
+            pending.push({ id: header.id, revision, seedLength });
         }
-        await withConcurrency(pending, 8, async ({ id, revision }) => {
-            const resolved = await this.resolveCold(id);
+        await withConcurrency(pending, 8, async ({ id, revision, seedLength }) => {
+            const resolved = await this.resolveCold(id, seedLength);
             if (resolved !== undefined)
                 this.coldResolved.set(id, { revision, ...resolved });
         });
@@ -241,7 +294,9 @@ export class TodaySpendScanner {
     }
     /**
      * Events path: price today's events in a single pass (per-event Beijing-day
-     * filter during collection, hard cap), gated by revisions.
+     * 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.
      */
     async scanEvents(dayKey) {
         const { sessions, persistence, maxEvents, logger, billing, catalog } = this.deps;
@@ -250,8 +305,10 @@ export class TodaySpendScanner {
         const liveIds = new Set();
         let collected = 0;
         let truncated = false;
-        const collect = (events) => {
+        const collect = (events, seedLength) => {
             for (const event of events) {
+                if (event.seq < seedLength)
+                    continue;
                 if (beijingDayKey(new Date(event.time)) !== dayKey)
                     continue;
                 collected += 1;
@@ -269,7 +326,7 @@ export class TodaySpendScanner {
             if (store !== undefined) {
                 for (const session of store.list()) {
                     liveIds.add(session.id);
-                    collect(session.events);
+                    collect(session.events, forkBoundaryOf(session.header));
                     if (truncated)
                         break;
                 }
@@ -284,7 +341,8 @@ export class TodaySpendScanner {
                 if (this.lastEventsScan?.get(header.id) === revision)
                     continue;
                 try {
-                    collect((await persistenceService.inspect(header.id)).events);
+                    const inspection = await persistenceService.inspect(header.id);
+                    collect(inspection.events, forkBoundaryOf(inspection.meta));
                 }
                 catch (error) {
                     // One unreadable session must not blank the whole-day aggregate.
@@ -308,7 +366,8 @@ export class TodaySpendScanner {
      * 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).
+     * `null` when served from the projection cache). A fork child's row prices
+     * its OWN events only (the cell covers the inherited prefix too).
      * @param dayKey - the Beijing-time calendar-day key to aggregate.
      * @returns unsorted per-session rows for the day.
      */
@@ -322,7 +381,10 @@ export class TodaySpendScanner {
             if (store !== undefined) {
                 for (const session of store.list()) {
                     liveIds.add(session.id);
-                    const state = projectionsService?.stateOf(session, BILLING_UNIT_KEY);
+                    const seedLength = forkBoundaryOf(session.header);
+                    const state = seedLength > 0
+                        ? this.ownBillingState(session.id, session.events, seedLength)
+                        : projectionsService?.stateOf(session, BILLING_UNIT_KEY);
                     if (state !== undefined && state.dayKey === dayKey) {
                         rows.set(session.id, {
                             sessionId: session.id,
@@ -341,6 +403,7 @@ export class TodaySpendScanner {
         for (const { header, revision } of snapshots) {
             if (liveIds.has(header.id))
                 continue;
+            const seedLength = forkBoundaryOf(header);
             const resolved = this.coldResolved.get(header.id);
             if (resolved !== undefined && resolved.revision === revision) {
                 if (resolved.value.dayKey === dayKey) {
@@ -348,10 +411,10 @@ export class TodaySpendScanner {
                 }
                 continue;
             }
-            pending.push({ id: header.id, revision });
+            pending.push({ id: header.id, revision, seedLength });
         }
-        await withConcurrency(pending, 8, async ({ id, revision }) => {
-            const resolved = await this.resolveCold(id);
+        await withConcurrency(pending, 8, async ({ id, revision, seedLength }) => {
+            const resolved = await this.resolveCold(id, seedLength);
             if (resolved !== undefined)
                 this.coldResolved.set(id, { revision, ...resolved });
         });
@@ -366,9 +429,11 @@ export class TodaySpendScanner {
     /**
      * Events-path per-session scan: price today's events in a single pass,
      * accumulating per session (per-event Beijing-day filter during collection,
-     * hard cap), gated by revisions. Titles fold from each session's complete
-     * log — a `session/title` event can predate today — so a rename is reflected
-     * as soon as the session's log is re-read.
+     * 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.
      * @param dayKey - the Beijing-time calendar-day key to aggregate.
      * @returns unsorted per-session rows for the day.
      */
@@ -379,13 +444,15 @@ export class TodaySpendScanner {
         const liveIds = new Set();
         let collected = 0;
         let truncated = false;
-        const collect = (id, events) => {
+        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;
@@ -403,7 +470,7 @@ export class TodaySpendScanner {
             if (store !== undefined) {
                 for (const session of store.list()) {
                     liveIds.add(session.id);
-                    collect(session.id, session.events);
+                    collect(session.id, session.events, forkBoundaryOf(session.header));
                     if (truncated)
                         break;
                 }
@@ -418,7 +485,8 @@ export class TodaySpendScanner {
                 if (this.lastEventsScan?.get(header.id) === revision)
                     continue;
                 try {
-                    collect(header.id, (await persistenceService.inspect(header.id)).events);
+                    const inspection = await persistenceService.inspect(header.id);
+                    collect(header.id, inspection.events, forkBoundaryOf(inspection.meta));
                 }
                 catch (error) {
                     // One unreadable session must not blank the whole-day aggregate.

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.2",
+  "version": "0.3.4",
   "publishConfig": {
     "access": "public"
   },