dsh-context 0.58.0 → 0.59.0

package/lib/index.d.ts

@@ -8,7 +8,13 @@ interface ActivityState {
   days: Record<string, {
     tokens: number;
     requests: number;
+    cost?: SessionCostUsage;
   }>;
+  /** The route in force (last `request/header`'s config wins) — prices each settlement. */
+  model?: string;
+  provider?: string;
+  /** The open step's start instant (armed by `step/start`, cleared by `step/end`). */
+  stepStart?: number;
 }
 //#endregion
 //#region src/host/headers.d.ts
@@ -299,6 +305,16 @@ interface ActivityDay {
   tokens: number;
   /** Completed model calls (assistant settlements) that day. */
   requests: number;
+  /**
+   * The day's billed buckets keyed provider → model → pricing period — the
+   * same SessionCostUsage raw material the timeline's session-cost totals
+   * carry, scoped to the day the requests INITIATED in, so the client prices
+   * each day off the same model-price book as the KPI band. ADDITIVE-OPTIONAL:
+   * absent on rows folded before the field existed (older plugin builds), on
+   * days whose settlements predate any model header, and on settlements the
+   * provider left unmetered — the usage chart degrades to tokens-only bars.
+   */
+  cost?: SessionCostUsage;
 }
 /**
  * The per-session daily activity ledger (`contextActivity` wire value):

package/lib/index.js

@@ -1056,6 +1056,10 @@ function tokenCountOf(value) {
 * DeepSeek's peak windows (the official list: UTC 01:00–04:00 and 06:00–10:00,
 * Monday through Friday — Beijing Time 09:00–12:00 and 14:00–18:00). All other
 * hours, plus entire weekends, bill at the half-price off-peak rate.
+*
+* Exported for the activity unit (host/activity.ts): the daily ledger prices
+* each day's buckets with the same split, so its per-day fees sum to the
+* session-cost totals the timeline fold books.
 */
 function isPeakUtc(time) {
 	const at = new Date(time);
@@ -1744,7 +1748,8 @@ function dayKeyOf(time) {
 //#region src/host/activity.ts
 /**
 * The `contextActivity` session projection unit — the per-day activity
-* ledger behind the Context Dashboard's heatmap.
+* ledger behind the Context Dashboard's heatmap and its last-7-days usage
+* chart.
 *
 * The timeline unit (fold.ts) is a "current snapshot" fold: it prices the
 * context as it stands NOW, which cannot draw a per-day chart. This unit
@@ -1753,75 +1758,165 @@ function dayKeyOf(time) {
 * completed request to its day and, when the provider reported a usage
 * object, the day's billed-token figure grows by the disjoint buckets
 * (uncached input + cache read + cache write + output — the same semantics
-* the timeline's request records and the official token meter use). The
-* overview merges every listed session's ledger off the session list's
-* projection column (no per-session open needed) and colors its heatmap.
+* the timeline's request records and the official token meter use). Each
+* metered settlement also books its buckets into the day's per-(provider,
+* model, period) pricing record — the same raw material the timeline's
+* session-cost totals carry (SessionCostUsage), so the client prices every
+* day off the SAME model-price book and estimator it prices the KPI band
+* with. Buckets attribute to the day the open STEP STARTED (the turn's
+* initiation, armed by `step/start` and cleared by `step/end` — the
+* timeline fold's own pending-slot protocol), falling back to the
+* settlement instant when no stamp is armed; the peak/off split prices the
+* same instant, so a fee always lands on one day at one rate.
 *
-* One wire contract, one small state: a day entry is two integers and the
-* retention cap keeps at most {@link MAX_KEPT_DAYS} keys, so the value
-* riding every session-list row stays trivial next to the timeline head.
-* Same projection contract as the sibling units: pure init/apply/view,
-* unknown or malformed events return the state unchanged, and no
-* `undefined`-valued property ever materializes (the plain-JSON persisted-
-* state precondition).
+* One wire contract, one small state: a day entry is two integers plus the
+* optional pricing record, the route in force rides the state (last
+* `request/header` wins), and the retention cap keeps at most
+* {@link MAX_KEPT_DAYS} keys, so the value riding every session-list row
+* stays trivial next to the timeline head. Same projection contract as the
+* sibling units: pure init/apply/view, unknown or malformed events return
+* the state unchanged, and no `undefined`-valued property ever materializes
+* (the plain-JSON persisted-state precondition).
 */
 /**
 * Retention cap on ledger days. A little over a year of daily-active
 * sessions; the oldest keys drop first (key order IS chronological order).
 */
 const MAX_KEPT_DAYS = 400;
+const costBucketSchema = z.object({
+	uncached: z.number().int().nonnegative(),
+	cacheRead: z.number().int().nonnegative(),
+	cacheWrite: z.number().int().nonnegative(),
+	output: z.number().int().nonnegative()
+}).strict();
+const costModelSchema$1 = z.object({
+	peak: costBucketSchema.optional(),
+	off: costBucketSchema.optional()
+}).strict();
+const costUsageSchema$1 = z.record(z.string(), z.record(z.string(), costModelSchema$1));
 const activityDaySchema = z.object({
 	tokens: z.number().int().nonnegative(),
-	requests: z.number().int().nonnegative()
+	requests: z.number().int().nonnegative(),
+	cost: costUsageSchema$1.optional()
 }).strict();
 /** Validate the wire payload before it leaves the host (strict: no drift). */
 const contextActivitySchema = z.object({ days: z.record(z.string(), activityDaySchema) }).strict();
-/** The persisted fold-state schema — identical shape, validated before a checkpoint row seeds a fold. */
-const activityStateSchema = z.object({ days: z.record(z.string(), activityDaySchema) });
-/**
-* The day's billed increment from one durable usage object: the four
-* disjoint buckets summed after the shared per-bucket sanitizer
-* ({@link tokenCountOf} — fractions round, negatives clamp, garbage reads
-* absent). A usage object with NO readable bucket contributes nothing, so a
-* settlement that carried no usage still counts its request without
-* fabricating tokens.
-*/
-function billedOfUsage(value) {
-	if (value === null || typeof value !== "object") return 0;
+/** The persisted fold-state schema — validated before a checkpoint row seeds a fold. */
+const activityStateSchema = z.object({
+	days: z.record(z.string(), activityDaySchema),
+	model: z.string().optional(),
+	provider: z.string().optional(),
+	stepStart: z.number().optional()
+});
+/**
+* One durable usage object's billed buckets, or null when NO bucket is
+* readable (the same rule the timeline fold bills by: a settlement that
+* carried no usage still counts its request without fabricating tokens).
+* Every bucket passes the shared per-bucket sanitizer ({@link tokenCountOf}
+* — fractions round, negatives clamp, garbage reads absent).
+*/
+function billedBucketsOf(value) {
+	if (value === null || typeof value !== "object") return null;
 	const usage = value;
-	let any = false;
-	let total = 0;
-	for (const bucket of [
-		usage.inputTokens,
-		usage.cacheReadTokens,
-		usage.cacheWriteTokens,
-		usage.outputTokens
-	]) {
-		const count = tokenCountOf(bucket);
-		if (count !== null) {
-			total += count;
-			any = true;
+	const input = tokenCountOf(usage.inputTokens);
+	const cacheRead = tokenCountOf(usage.cacheReadTokens);
+	const cacheWrite = tokenCountOf(usage.cacheWriteTokens);
+	const output = tokenCountOf(usage.outputTokens);
+	if (input === null && cacheRead === null && cacheWrite === null && output === null) return null;
+	return {
+		input: input ?? 0,
+		cacheRead: cacheRead ?? 0,
+		cacheWrite: cacheWrite ?? 0,
+		output: output ?? 0
+	};
+}
+/**
+* Add one settlement's billed buckets to a day's pricing record — the same
+* clone-along-the-mutated-path walk the timeline fold's accumulateCost
+* prices by, so the two folds' records share one shape and one semantics.
+* The pricing period splits off the SAME instant the day bucket does: a fee
+* can never land on one day at the neighbouring window's rate.
+*/
+function pricedDayOf(prev, provider, model, period, usage) {
+	const models = prev?.[provider] ?? {};
+	const periods = models[model] ?? {};
+	const b = periods[period] ?? {
+		uncached: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		output: 0
+	};
+	return {
+		...prev,
+		[provider]: {
+			...models,
+			[model]: {
+				...periods,
+				[period]: {
+					uncached: b.uncached + usage.input,
+					cacheRead: b.cacheRead + usage.cacheRead,
+					cacheWrite: b.cacheWrite + usage.cacheWrite,
+					output: b.output + usage.output
+				}
+			}
 		}
-	}
-	return any ? total : 0;
+	};
 }
 /**
-* Fold one committed event into the ledger. Only `assistant/message` (the
-* step settlement — both supported log generations) advances a day; every
-* other type returns the state reference unchanged, as does a settlement
-* with an unreadable time. The next state is a copy along the mutated path
-* only — the persisted previous state is never mutated in place.
+* Fold one committed event into the ledger. Four event types advance it:
+* `request/header` tracks the route in force (the timeline fold's rule —
+* last header wins), `step/start`/`step/end` maintain the initiation stamp,
+* and `assistant/message` (the step settlement — both supported log
+* generations) books the day. Everything else returns the state reference
+* unchanged, as does a settlement with no attributable instant. The next
+* state is a copy along the mutated path only — the persisted previous
+* state is never mutated in place.
 */
 function applyActivity(state, event) {
+	if (event.type === "request/header") {
+		const config = event.data?.header?.config;
+		if (config === null || typeof config !== "object") return state;
+		const model = typeof config.model === "string" ? config.model : void 0;
+		const provider = typeof config.provider === "string" ? config.provider : void 0;
+		const nextModel = model !== void 0 ? model : state.model;
+		const nextProvider = provider !== void 0 ? provider : state.provider;
+		if (nextModel === state.model && nextProvider === state.provider) return state;
+		return {
+			...state,
+			...nextModel !== void 0 ? { model: nextModel } : {},
+			...nextProvider !== void 0 ? { provider: nextProvider } : {}
+		};
+	}
+	if (event.type === "step/start") {
+		if (!Number.isFinite(event.time)) return state;
+		return state.stepStart === event.time ? state : {
+			...state,
+			stepStart: event.time
+		};
+	}
+	if (event.type === "step/end") {
+		if (state.stepStart === void 0) return state;
+		const next = { ...state };
+		delete next.stepStart;
+		return next;
+	}
 	if (event.type !== "assistant/message") return state;
-	const key = dayKeyOf(event.time);
+	const initiated = state.stepStart !== void 0 ? state.stepStart : event.time;
+	const key = dayKeyOf(initiated);
 	if (key === null) return state;
 	const data = event.data;
-	const tokens = billedOfUsage(data?.usage);
+	const buckets = billedBucketsOf(data?.usage);
 	const prev = state.days[key];
+	let cost = prev?.cost;
+	if (buckets !== null && state.model !== void 0) {
+		const provider = state.provider ?? "";
+		const period = isDeepSeekProvider(provider) && !isPeakUtc(initiated) ? "off" : "peak";
+		cost = pricedDayOf(cost, provider, state.model, period, buckets);
+	}
 	const entry = {
-		tokens: prev === void 0 ? tokens : prev.tokens + tokens,
-		requests: prev === void 0 ? 1 : prev.requests + 1
+		tokens: (prev === void 0 ? 0 : prev.tokens) + (buckets === null ? 0 : buckets.input + buckets.cacheRead + buckets.cacheWrite + buckets.output),
+		requests: (prev === void 0 ? 0 : prev.requests) + 1,
+		...cost !== void 0 ? { cost } : {}
 	};
 	let days = {
 		...state.days,
@@ -1833,12 +1928,19 @@ function applyActivity(state, event) {
 		const drop = new Set(keys.slice(0, keys.length - MAX_KEPT_DAYS));
 		days = Object.fromEntries(Object.entries(days).filter(([k]) => !drop.has(k)));
 	}
-	return { days };
+	return {
+		...state,
+		days
+	};
 }
 /**
 * The daily-activity projection unit, registered alongside the timeline and
 * headers units (host/index.ts); the overview reads it through the session
-* list's projection column. `stateVersion` 1: the ledger's first shape.
+* list's projection column. `stateVersion` 2: the ledger gained the per-day
+* pricing records (and the fold the route/step-start tracking behind them),
+* so on upgrade every cached row reads version-stale — the dashboard's
+* warm-up cold-refolds it from the durable log, rebuilding the fees for the
+* whole corpus exactly.
 */
 function createContextActivityDefinition() {
 	return {
@@ -1850,7 +1952,7 @@ function createContextActivityDefinition() {
 			viewSchema: contextActivitySchema,
 			view: (state) => ({ days: Object.fromEntries(Object.entries(state.days).map(([k, v]) => [k, { ...v }])) })
 		},
-		stateVersion: 1
+		stateVersion: 2
 	};
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-context",
-  "version": "0.58.0",
+  "version": "0.59.0",
   "description": "A DeepSeek Harness plugin for context insight and management, with context dashboard and context command, for understanding how the context is made of, and how it evolves.",
   "icon": "icon.svg",
   "author": "bowenliang123",
@@ -92,7 +92,8 @@
     "@deepseek-ai/dsh-session": ">=0.1.5-rc.1",
     "@deepseek-ai/dsh-settings": ">=0.1.5-rc.1",
     "@deepseek-ai/schemastery": "^3.18.2",
-    "react": "^18.3.1"
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/dsh-client-ui-primitives": {
@@ -100,13 +101,14 @@
     },
     "react": {
       "optional": true
+    },
+    "react-dom": {
+      "optional": true
     }
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
     "@deepseek-ai/dsh-client-ui-primitives": "0.1.5-rc.1",
-    "@deepseek-ai/dsh-invariants": "0.1.5-rc.1",
-    "@deepseek-ai/dsh-scope": "0.1.5-rc.1",
     "@deepseek-ai/dsh-session": "0.1.5-rc.1",
     "@deepseek-ai/dsh-session-projection": "0.1.5-rc.1",
     "@deepseek-ai/dsh-settings": "0.1.5-rc.1",
@@ -117,15 +119,15 @@
     "@stylistic/eslint-plugin": "^5.10.0",
     "@tailwindcss/node": "4.3.3",
     "@tailwindcss/oxide": "4.3.3",
-    "@types/node": "^26.2.0",
+    "@types/node": "^26.6.3",
     "@types/react": "^18.3.31",
     "@types/react-dom": "^18.3.7",
     "@vitest/coverage-v8": "^4.1.11",
     "anser": "^2.3.5",
     "clsx": "^2.0.0",
-    "eslint-plugin-sonarjs": "^4.2.0",
+    "eslint-plugin-sonarjs": "^4.2.1",
     "husky": "^9.1.7",
-    "jsdom": "^30.0.1",
+    "jsdom": "^30.1.1",
     "katex": "^0.16.47",
     "lightningcss": "1.32.0",
     "mdast-util-from-markdown": "^2.0.3",
@@ -139,17 +141,16 @@
     "micromark-util-classify-character": "^2.0.1",
     "micromark-util-sanitize-uri": "^2.0.1",
     "micromark-util-symbol": "^2.0.1",
-    "oxlint": "1.82.0",
-    "oxlint-tsgolint": "7.0.2001",
-    "playwright-core": "^1.62.1",
+    "oxlint": "1.85.0",
+    "oxlint-tsgolint": "7.0.2003",
+    "playwright-core": "^1.63.0",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "shiki": "^4.3.1",
-    "simple-icons": "16.31.0",
+    "simple-icons": "16.32.0",
     "tailwindcss": "4.3.3",
     "tsdown": "^0.23.0",
     "typescript": "^7.0.2",
-    "vitest": "^4.1.11",
-    "zod": "^4.4.3"
+    "vitest": "^4.1.11"
   }
 }