dsh-plugin-cost-meter 0.5.2 → 0.6.0

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to this project are documented here.
 
+## 0.6.0
+
+- **Historical costs are now frozen.** An amount is computed and stored when
+  its usage sample is folded, and `wire.view` only sums the stored amounts.
+  Previously the view re-priced the whole token history with the live table,
+  so a price update (or a catalog refresh) rewrote past sessions' totals.
+  Price updates now apply to samples folded after them only.
+- Replacing a duplicated sample (`chunk` → `message`) subtracts the frozen
+  amount of the sample it replaces, so dedup stays exact.
+- The currency a session is counted in is stored with the state, so a later
+  `currency` change does not silently reinterpret old amounts.
+- Projection state bumped to `stateVersion 4`. The persisted projection cache
+  is invalidated once on upgrade, so every session is re-folded against the
+  current table at that moment (the same table the badge already displayed),
+  then frozen from there on.
+- Two regression tests: a price swap leaves counted samples untouched, and a
+  sample replacement subtracts exactly.
+
 ## 0.5.2
 
 - The remote catalog's `peakSchedule` now overrides the bundled snapshot, so a

package/README.md

@@ -99,7 +99,8 @@ A timer re-reads the remote catalog and `pricingUrl` every `refreshMinutes` (def
 
 - a failed refresh **keeps the last successful data**;
 - a source that never loaded does not clear anything;
-- a price change applies to the whole session on the **next event**, and immediately on a page reload.
+- **historical amounts are frozen**: a sample is priced when it is folded and the amount is stored, so a price change applies only to samples folded after it — a past session's total is never rewritten;
+- the frozen amounts ride the persisted projection cache, so they survive restarts; only a cold replay without a checkpoint prices the log at the then-current table.
 
 This makes the catalog the single place to maintain rates: **edit and push `catalog/prices.json`, and installed copies update themselves** — no new plugin release. Forks get their own update channel automatically because the default URL is derived from `package.json.repository`.
 

package/README.zh.md

@@ -100,7 +100,8 @@ dsh web
 
 - 刷新失败**保留上一次成功的数据**；
 - 从未成功过的源不会清空任何已有数据；
-- 价格变更会在**下一次会话事件**时对整个会话重新计价；刷新页面则立即生效。
+- **历史金额已冻结**：每条用量在折叠时按当时的价格表计价并存入状态，因此改价只影响其后折叠的样本——过去会话的总额不会被重写；
+- 冻结的金额随持久化投影缓存保存，重启后仍在；只有完全没有检查点的冷回放才会按当时价格表重新计价。
 
 因此价格只需维护**一处**：**改并推送 `catalog/prices.json`，已安装的插件自动更新**，不用发版。默认地址由 `package.json.repository` 推导，fork 出来的仓库自动拥有自己的更新通道。
 

package/lib/index.js

@@ -16,8 +16,13 @@
  * Silent updates: a timer re-reads the remote catalog / pricingUrl on an
  * interval (`config.refreshMinutes`, default 360) and swaps the live table.
  * A failed refresh keeps the last successful data; a failed source never
- * clears data it did not create. The badge reflects a price change on the
- * next session event (the whole session is re-priced) or a page reload.
+ * clears data it did not create.
+ *
+ * Historical costs are immutable: an amount is frozen when its sample is
+ * folded, so a price change only affects samples folded after it. A past
+ * session is never re-priced (the projection cache persists the frozen
+ * amounts; a cold replay without a checkpoint necessarily prices the log at
+ * the then-current table).
  *
  * Peak / off-peak
  * ---------------
@@ -390,7 +395,11 @@ async function loadSources(config, warn, previous) {
 
 /**
  * Build the `costUsage` projection unit over a live source ref.
- * State is pure token accounting per (route × tier); `wire.view` prices it.
+ *
+ * Money is **frozen at fold time**: a usage sample is priced with the table in
+ * effect the moment it enters the fold, and the amount is stored in the state.
+ * `wire.view` only sums those stored amounts, so a later price update changes
+ * future samples only and never rewrites an already-counted session.
  */
 function buildProjection(live) {
   const bucketsSchema = zod.object({
@@ -404,12 +413,18 @@ function buildProjection(live) {
     provider: zod.string().nullable(),
     model: zod.string().nullable(),
     off: bucketsSchema,
-    peak: bucketsSchema
+    peak: bucketsSchema,
+    /** Frozen amount contributed by this route, in `state.currency`. */
+    cost: zod.number().nonnegative(),
+    /** Count of folded samples this route had no price for. */
+    unpriced: zod.number().int().nonnegative()
   }).strict();
 
   const stateSchema = zod.object({
     provider: zod.string().nullable(),
     model: zod.string().nullable(),
+    /** Currency the frozen amounts are expressed in (null before the first priced sample). */
+    currency: zod.string().nullable(),
     perRoute: zod.record(zod.string(), routeSchema),
     last: zod.union([
       zod.null(),
@@ -418,7 +433,10 @@ function buildProjection(live) {
         step: zod.number().int(),
         route: zod.string(),
         tier: zod.enum(["off", "peak"]),
-        buckets: bucketsSchema
+        buckets: bucketsSchema,
+        /** Frozen amount of this sample, so a replacement can subtract it exactly. */
+        cost: zod.number().nonnegative(),
+        unpriced: zod.number().int().nonnegative()
       }).strict()
     ])
   }).strict();
@@ -441,7 +459,7 @@ function buildProjection(live) {
   return {
     key: "costUsage",
     stateSchema,
-    init: () => ({ provider: null, model: null, perRoute: {}, last: null }),
+    init: () => ({ provider: null, model: null, currency: null, perRoute: {}, last: null }),
     apply(state, event) {
       const liveNow = live.current;
       let provider = state.provider;
@@ -471,47 +489,57 @@ function buildProjection(live) {
       const route = `${provider ?? ""}\u0000${model ?? ""}`;
       const buckets = bucketsFrom(usage);
 
+      // Freeze the amount now, with the table in effect when this sample is
+      // folded. Later price updates must never rewrite this contribution.
+      const matched = lookupPrice(liveNow.table, provider, model);
+      const contribution = matched === undefined ? 0 : costOf(buckets, matched.rates[tier]);
+      const unpricedContribution = matched === undefined ? 1 : 0;
+      const currency = state.currency ?? (matched === undefined ? null : liveNow.table.currency);
+
       const previous = state.last !== null && state.last.turn === turn && state.last.step === step ? state.last : undefined;
       if (previous !== undefined && previous.route === route && previous.tier === tier && bucketsEqual(previous.buckets, buckets)) {
-        return provider === state.provider && model === state.model ? state : { ...state, provider, model };
+        return provider === state.provider && model === state.model && currency === state.currency
+          ? state
+          : { ...state, provider, model, currency };
       }
 
       const perRoute = { ...state.perRoute };
       if (previous !== undefined) {
-        const replaced = { ...(perRoute[previous.route] ?? { provider: null, model: null, off: ZERO_BUCKETS(), peak: ZERO_BUCKETS() }) };
+        const replaced = { ...(perRoute[previous.route] ?? { provider: null, model: null, off: ZERO_BUCKETS(), peak: ZERO_BUCKETS(), cost: 0, unpriced: 0 }) };
         replaced[previous.tier] = subBuckets(replaced[previous.tier], previous.buckets);
+        replaced.cost = Math.max(0, replaced.cost - previous.cost);
+        replaced.unpriced = Math.max(0, replaced.unpriced - previous.unpriced);
         perRoute[previous.route] = replaced;
       }
-      const entry = { ...(perRoute[route] ?? { provider, model, off: ZERO_BUCKETS(), peak: ZERO_BUCKETS() }) };
+      const entry = { ...(perRoute[route] ?? { provider, model, off: ZERO_BUCKETS(), peak: ZERO_BUCKETS(), cost: 0, unpriced: 0 }) };
       entry.provider = provider;
       entry.model = model;
       entry[tier] = addBuckets(entry[tier], buckets);
+      entry.cost += contribution;
+      entry.unpriced += unpricedContribution;
       perRoute[route] = entry;
 
-      return { provider, model, perRoute, last: { turn, step, route, tier, buckets } };
+      return { provider, model, currency, perRoute, last: { turn, step, route, tier, buckets, cost: contribution, unpriced: unpricedContribution } };
     },
     wire: {
       viewSchema,
       view(state) {
         const liveNow = live.current;
-        const table = liveNow.table;
         const totals = ZERO_BUCKETS();
         const unpriced = [];
         let cost = 0;
         for (const entry of Object.values(state.perRoute)) {
-          const matched = lookupPrice(table, entry.provider, entry.model);
-          if (matched === undefined) {
-            unpriced.push(`${entry.provider ?? "?"}/${entry.model ?? "?"}`);
-          } else {
-            cost += costOf(entry.off, matched.rates.off) + costOf(entry.peak, matched.rates.peak);
-          }
+          // Sum frozen amounts only. Re-pricing here would let a later price
+          // update rewrite a past session's total, which this plugin forbids.
+          cost += entry.cost;
+          if (entry.unpriced > 0) unpriced.push(`${entry.provider ?? "?"}/${entry.model ?? "?"}`);
           totals.uncachedInputTokens += entry.off.uncachedInputTokens + entry.peak.uncachedInputTokens;
           totals.outputTokens += entry.off.outputTokens + entry.peak.outputTokens;
           totals.cacheReadTokens += entry.off.cacheReadTokens + entry.peak.cacheReadTokens;
           totals.cacheWriteTokens += entry.off.cacheWriteTokens + entry.peak.cacheWriteTokens;
         }
         return {
-          currency: table.currency,
+          currency: state.currency ?? liveNow.table.currency,
           cost,
           priced: unpriced.length === 0,
           provider: state.provider,
@@ -523,7 +551,7 @@ function buildProjection(live) {
         };
       }
     },
-    stateVersion: 3
+    stateVersion: 4
   };
 }
 
@@ -571,6 +599,6 @@ async function apply(ctx, config) {
 }
 
 /** Internal helpers exported for the contract tests. */
-const internals = { buildPriceTable, catalogEntries, isPeakAt, lookupPrice, parseRates, resolveSchedule };
+const internals = { buildPriceTable, buildProjection, catalogEntries, isPeakAt, lookupPrice, parseRates, resolveSchedule };
 
 export { apply, inject, internals, name };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-cost-meter",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "Live per-session cost badge in the DeepSeek Harness conversation header (top-right), with peak/off-peak (峰谷分时) pricing.",
   "keywords": [
     "dsh-plugin",