dsh-claude-style 0.15.0-dev.22 → 0.16.0-dev.27

package/lib/host/brand.js

@@ -23,7 +23,7 @@ var PEAKRATE_PATH = `${ROUTE_PREFIX}/peakrate`;
 // packages/host/src/brand.ts
 import { mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { harnessPath } from "./harness-home.js";
+import { pluginPath } from "./harness-home.js";
 import { fenceRefused, methodRefused, readRequestBody, sendJson } from "./http.js";
 var IMAGE_PATHS = { mark: BRAND_MARK_PATH, wordmark: BRAND_WORDMARK_PATH };
 var IMAGE_HEADERS = {
@@ -36,7 +36,7 @@ var SIGNATURES = {
   "image/webp": [{ offset: 0, bytes: Buffer.from("RIFF", "latin1") }, { offset: 8, bytes: Buffer.from("WEBP", "latin1") }]
 };
 function createBrandStore(ctx) {
-  const dir = () => harnessPath(ctx, "dsh-claude-style", "brand");
+  const dir = () => pluginPath(ctx, "brand");
   const find = (kind) => {
     for (const [type, extension] of Object.entries(BRAND_IMAGE_TYPES)) {
       const path = join(dir(), `${kind}.${extension}`);

package/lib/host/cache-file.js

@@ -20,8 +20,10 @@ function writeJsonDocument(ctx, path, label, document) {
     mkdirSync(dirname(path), { recursive: true });
     writeFileSync(temporary, JSON.stringify(document), "utf8");
     renameSync(temporary, path);
+    return true;
   } catch (error) {
     ctx.logger?.warn?.(`dsh-claude-style: ${label} not written: ${error.message}`);
+    return false;
   }
 }
 export {

package/lib/host/harness-home.js

@@ -6,6 +6,10 @@ function harnessPath(ctx, ...segments) {
   if (typeof resolvePath === "function") return resolvePath(...segments);
   return join(process.env.DSH_HOME ?? join(homedir(), ".dsh"), ...segments);
 }
+function pluginPath(ctx, ...segments) {
+  return harnessPath(ctx, "dsh-claude-style", ...segments);
+}
 export {
-  harnessPath
+  harnessPath,
+  pluginPath
 };

package/lib/host/routes.js

@@ -17,7 +17,7 @@ import { userInfo } from "node:os";
 import { join, resolve, sep } from "node:path";
 import { brotliDecompressSync } from "node:zlib";
 import { brandRoutes } from "./brand.js";
-import { harnessPath } from "./harness-home.js";
+import { harnessPath, pluginPath } from "./harness-home.js";
 import { fenceRefused, methodRefused, readRequestBody, refusalOf, sendJson } from "./http.js";
 import { createHdslAccount } from "./hdsl.js";
 import { packageRoot } from "./package-root.js";
@@ -110,7 +110,7 @@ function registerRoutes(ctx, scope) {
   const root = packageRoot();
   const file = join(root, "lib", COPY_FILE);
   const fontsDir = join(root, "lib", "fonts");
-  const userFontsDir = () => harnessPath(ctx, "dsh-claude-style", "fonts");
+  const userFontsDir = () => pluginPath(ctx, "fonts");
   const assetsDir = join(root, "lib", "assets");
   const unpressed = /* @__PURE__ */ new Map();
   const sendFile = (res, method, path, headers, body = null) => {

package/lib/host/usage-record.js

@@ -0,0 +1,235 @@
+// packages/host/src/usage-record.ts
+import { existsSync, renameSync, unlinkSync } from "node:fs";
+import { cachePath, readJsonDocument, writeJsonDocument } from "./cache-file.js";
+import { pluginPath } from "./harness-home.js";
+import { BUCKET_KEYS, addBuckets, emptyBuckets } from "./usage-ledger.js";
+var RECORD_VERSION = 1;
+var RECORD_FILE = "usage.json";
+var LEGACY_CACHE_VERSION = 4;
+var NO_ROUTE = "";
+var CELL_KEYS = [...BUCKET_KEYS, "calls"];
+function bucketsFromCell(cell) {
+  if (!Array.isArray(cell)) return null;
+  const buckets = emptyBuckets();
+  for (let at = 0; at < CELL_KEYS.length; at += 1) {
+    const value = Number(cell[at]);
+    if (Number.isFinite(value)) buckets[CELL_KEYS[at]] = value;
+  }
+  return buckets;
+}
+function cellFromBuckets(buckets) {
+  return CELL_KEYS.map((key) => buckets[key]);
+}
+function hoursFromSlots(raw) {
+  if (raw === null || typeof raw !== "object") return null;
+  const hours = new Array(24).fill(0);
+  let settled = false;
+  for (const [slot, count] of Object.entries(raw)) {
+    const hour = Number(slot);
+    const value = Number(count);
+    if (!Number.isInteger(hour) || hour < 0 || hour > 23 || !Number.isFinite(value) || value === 0) continue;
+    hours[hour] += value;
+    settled = true;
+  }
+  return settled ? hours : null;
+}
+function slotsFromHours(hours) {
+  if (!Array.isArray(hours)) return null;
+  const slots = {};
+  let settled = false;
+  for (let hour = 0; hour < 24; hour += 1) {
+    const count = Number(hours[hour]) || 0;
+    if (count === 0) continue;
+    slots[String(hour)] = count;
+    settled = true;
+  }
+  return settled ? slots : null;
+}
+function isEmptyDay(buckets, hours) {
+  if (hours !== null) return false;
+  return BUCKET_KEYS.every((key) => buckets[key] === 0) && buckets.calls === 0;
+}
+function storedDay(raw) {
+  return raw !== null && typeof raw === "object" ? raw : null;
+}
+function daysFromStored(raw) {
+  const days = /* @__PURE__ */ new Map();
+  if (raw === null || typeof raw !== "object") return days;
+  for (const [day, value] of Object.entries(raw)) {
+    const stored = storedDay(value);
+    if (stored === null) continue;
+    const buckets = emptyBuckets();
+    const models = /* @__PURE__ */ new Map();
+    if (stored.m !== null && typeof stored.m === "object") {
+      for (const [route, cell] of Object.entries(stored.m)) {
+        const counts = bucketsFromCell(cell);
+        if (counts === null) continue;
+        addBuckets(buckets, counts, 1);
+        if (route !== NO_ROUTE) models.set(route, counts);
+      }
+    }
+    const hours = hoursFromSlots(stored.h);
+    if (isEmptyDay(buckets, hours)) continue;
+    if (models.size > 0) buckets.models = models;
+    if (hours !== null) buckets.hours = hours;
+    days.set(day, buckets);
+  }
+  return days;
+}
+function dayToStored(buckets) {
+  const rest = emptyBuckets();
+  addBuckets(rest, buckets, 1);
+  const routes = {};
+  if (buckets.models !== void 0) {
+    for (const [model, cell] of buckets.models) {
+      routes[model] = cellFromBuckets(cell);
+      addBuckets(rest, cell, -1);
+    }
+  }
+  if (CELL_KEYS.some((key) => rest[key] !== 0)) routes[NO_ROUTE] = cellFromBuckets(rest);
+  const stored = { m: routes };
+  const hours = slotsFromHours(buckets.hours);
+  if (hours !== null) stored.h = hours;
+  return stored;
+}
+function sessionToStored(entry) {
+  const stored = {};
+  if (entry.fingerprint !== void 0) {
+    stored.size = entry.fingerprint.size;
+    stored.mtimeMs = entry.fingerprint.mtimeMs;
+  }
+  if (entry.days.size === 0) return stored;
+  const days = {};
+  for (const [day, buckets] of entry.days) days[day] = dayToStored(buckets);
+  stored.days = days;
+  return stored;
+}
+function sessionFromStored(value) {
+  if (value === null || typeof value !== "object") return null;
+  const stored = value;
+  const days = daysFromStored(stored.days);
+  if (!Number.isFinite(stored.size) || !Number.isFinite(stored.mtimeMs)) {
+    return days.size === 0 ? null : { days };
+  }
+  return { fingerprint: { size: Number(stored.size), mtimeMs: Number(stored.mtimeMs) }, days };
+}
+function hoursFromArray(raw) {
+  if (!Array.isArray(raw) || raw.length !== 24) return null;
+  const hours = new Array(24).fill(0);
+  let settled = false;
+  for (let hour = 0; hour < 24; hour += 1) {
+    const count = Number(raw[hour]) || 0;
+    hours[hour] = count;
+    if (count !== 0) settled = true;
+  }
+  return settled ? hours : null;
+}
+function legacyDays(raw) {
+  const days = /* @__PURE__ */ new Map();
+  if (raw === null || typeof raw !== "object") return days;
+  for (const [day, value] of Object.entries(raw)) {
+    const stored = storedDay(value);
+    if (stored === null) continue;
+    const buckets = emptyBuckets();
+    addBuckets(buckets, stored, 1);
+    if (stored.models !== null && typeof stored.models === "object") {
+      const models = /* @__PURE__ */ new Map();
+      for (const [model, cell] of Object.entries(stored.models)) {
+        if (cell === null || typeof cell !== "object") continue;
+        const counts = emptyBuckets();
+        addBuckets(counts, cell, 1);
+        models.set(model, counts);
+      }
+      if (models.size > 0) buckets.models = models;
+    }
+    const hours = hoursFromArray(stored.hours);
+    if (isEmptyDay(buckets, hours)) continue;
+    if (hours !== null) buckets.hours = hours;
+    days.set(day, buckets);
+  }
+  return days;
+}
+function legacyCachePath(ctx) {
+  return cachePath(ctx, RECORD_FILE);
+}
+function legacyRecord(ctx) {
+  const path = legacyCachePath(ctx);
+  if (!existsSync(path)) return null;
+  const sessions = /* @__PURE__ */ new Map();
+  const parsed = readJsonDocument(ctx, path, "usage cache");
+  if (parsed === null || typeof parsed !== "object") return sessions;
+  const document = parsed;
+  if (document.version !== LEGACY_CACHE_VERSION) return sessions;
+  if (document.sessions === null || typeof document.sessions !== "object") return sessions;
+  for (const [id, value] of Object.entries(document.sessions)) {
+    if (value === null || typeof value !== "object") continue;
+    const entry = value;
+    if (!Number.isFinite(entry.size) || !Number.isFinite(entry.mtimeMs)) continue;
+    const days = legacyDays(entry.days);
+    if (days.size === 0) continue;
+    sessions.set(id, { fingerprint: { size: Number(entry.size), mtimeMs: Number(entry.mtimeMs) }, days });
+  }
+  return sessions;
+}
+function readStored(ctx) {
+  const path = pluginPath(ctx, RECORD_FILE);
+  const parsed = readJsonDocument(ctx, path, "usage record");
+  if (parsed === null || typeof parsed !== "object") {
+    if (existsSync(path)) {
+      const aside = `${path}.corrupt-${Date.now()}`;
+      renameSync(path, aside);
+      ctx.logger?.warn?.(`dsh-claude-style: usage record moved aside to ${aside}; it is rebuilt from the session logs`);
+    }
+    return { kind: "absent" };
+  }
+  const document = parsed;
+  if (document.version !== RECORD_VERSION) {
+    ctx.logger?.warn?.(`dsh-claude-style: usage record version ${String(document.version)} is not one this build reads; it is left as it stands`);
+    return { kind: "foreign" };
+  }
+  const sessions = /* @__PURE__ */ new Map();
+  if (document.sessions === null || typeof document.sessions !== "object") return { kind: "ours", sessions };
+  for (const [id, value] of Object.entries(document.sessions)) {
+    const entry = sessionFromStored(value);
+    if (entry !== null) sessions.set(id, entry);
+  }
+  return { kind: "ours", sessions };
+}
+function readRecord(ctx) {
+  const stored = readStored(ctx);
+  if (stored.kind === "foreign") return { sessions: /* @__PURE__ */ new Map(), mustWrite: false, writable: false };
+  const sessions = stored.kind === "ours" ? stored.sessions : /* @__PURE__ */ new Map();
+  const legacy = legacyRecord(ctx);
+  for (const [id, entry] of legacy ?? []) {
+    if (!sessions.has(id)) sessions.set(id, entry);
+  }
+  return { sessions, mustWrite: stored.kind === "absent" || legacy !== null, writable: true };
+}
+function overStored(stored, sessions, live) {
+  const merged = new Map(sessions);
+  for (const [id, held] of stored) {
+    if (sessions.get(id)?.fingerprint !== void 0) continue;
+    if (live.has(id)) merged.set(id, held);
+    else if (held.days.size > 0) merged.set(id, { days: held.days });
+  }
+  return merged;
+}
+function writeRecord(ctx, sessions, live) {
+  const stored = readStored(ctx);
+  if (stored.kind === "foreign") return sessions;
+  const merged = stored.kind === "ours" ? overStored(stored.sessions, sessions, live) : sessions;
+  const document = {
+    version: RECORD_VERSION,
+    computedAt: Date.now(),
+    sessions: {}
+  };
+  for (const [id, entry] of merged) document.sessions[id] = sessionToStored(entry);
+  if (!writeJsonDocument(ctx, pluginPath(ctx, RECORD_FILE), "usage record", document)) return merged;
+  const legacy = legacyCachePath(ctx);
+  if (existsSync(legacy)) unlinkSync(legacy);
+  return merged;
+}
+export {
+  readRecord,
+  writeRecord
+};

package/lib/host/usage-summary.js

@@ -1,6 +1,5 @@
 // packages/host/src/usage-summary.ts
 import { BUCKET_KEYS, addBuckets, emptyBuckets } from "./usage-ledger.js";
-import { dayKey } from "./usage-fold.js";
 function bucketTotal(buckets) {
   let total = 0;
   for (const key of BUCKET_KEYS) total += Number(buckets?.[key]) || 0;
@@ -8,13 +7,7 @@ function bucketTotal(buckets) {
 }
 function mergeSessions(sessions) {
   const days = /* @__PURE__ */ new Map();
-  const hours = new Array(24).fill(0);
-  const seen = /* @__PURE__ */ new Set();
   for (const [id, entry] of sessions) {
-    seen.add(id);
-    if (Array.isArray(entry.hours)) {
-      for (let hour = 0; hour < 24; hour += 1) hours[hour] += Number(entry.hours[hour]) || 0;
-    }
     for (const [day, buckets] of entry.days) {
       let target = days.get(day);
       if (target === void 0) {
@@ -44,7 +37,7 @@ function mergeSessions(sessions) {
     day.sessionIds = behind;
     day.sessions = behind.length;
   }
-  return { days, sessionCount: seen.size, hours };
+  return days;
 }
 function summarize(days, sessionCount, source, hours, window) {
   const inWindow = (date) => window?.dates === void 0 || window.dates.has(date);
@@ -100,7 +93,7 @@ function summarize(days, sessionCount, source, hours, window) {
     }
   };
 }
-function mergeLedgerFold(ledgerDays, sessions, logs) {
+function mergeLedgerFold(ledgerDays, sessions) {
   const days = /* @__PURE__ */ new Map();
   const sessionIds = /* @__PURE__ */ new Set();
   let lastLedgerDay = null;
@@ -110,14 +103,11 @@ function mergeLedgerFold(ledgerDays, sessions, logs) {
     for (const id of buckets.sessionIds ?? []) sessionIds.add(id);
   }
   let folded = false;
-  for (const [date, buckets] of mergeSessions(sessions).days) {
+  for (const [date, buckets] of mergeSessions(sessions)) {
     if (lastLedgerDay !== null && date <= lastLedgerDay) continue;
     days.set(date, buckets);
     folded = true;
-  }
-  for (const log of logs) {
-    const date = dayKey(log.mtimeMs);
-    if (date !== null && (lastLedgerDay === null || date > lastLedgerDay)) sessionIds.add(log.id);
+    for (const id of buckets.sessionIds ?? []) sessionIds.add(id);
   }
   return { days, sessionIds, folded };
 }

package/lib/host/usage.js

@@ -1,14 +1,13 @@
 // packages/host/src/usage.ts
 import { join, resolve } from "node:path";
 import { harnessPath } from "./harness-home.js";
-import { readCache, writeCache } from "./usage-cache.js";
+import { readRecord, writeRecord } from "./usage-record.js";
 import { readEvents } from "./session-events.js";
 import { foldSession, listSessionLogs } from "./usage-fold.js";
 import { readLedger } from "./usage-ledger.js";
 import { mergeLedgerFold, summarize } from "./usage-summary.js";
 var LEDGER_SOURCE = "cost-meter";
 var LOCAL_SOURCE = "local";
-var NO_HOURS = new Array(24).fill(0);
 function hoursOf(days) {
   const hours = new Array(24).fill(0);
   for (const buckets of days.values()) {
@@ -17,34 +16,46 @@ function hoursOf(days) {
   }
   return hours;
 }
+function recordChanged(stored, sessions, read) {
+  if (read > 0 || stored.size !== sessions.size) return true;
+  for (const [id, entry] of sessions) {
+    const held = stored.get(id);
+    if (held === void 0 || held.days.size !== entry.days.size) return true;
+    if (held.fingerprint !== void 0 !== (entry.fingerprint !== void 0)) return true;
+  }
+  return false;
+}
 function createUsage(ctx) {
   const home = () => harnessPath(ctx);
   let state = null;
   let pending = null;
   let disposed = false;
   async function computeLocal(logs, ledgerDays) {
-    const cache = readCache(ctx);
+    const record = readRecord(ctx);
     const sessions = /* @__PURE__ */ new Map();
     let read = 0;
     let failed = 0;
     for (const log of logs) {
-      const cached = cache.get(log.id);
-      if (cached !== void 0 && cached.size === log.size && cached.mtimeMs === log.mtimeMs) {
-        sessions.set(log.id, cached);
+      const stored = record.sessions.get(log.id);
+      const fingerprint = stored?.fingerprint;
+      if (stored !== void 0 && fingerprint !== void 0 && fingerprint.size === log.size && fingerprint.mtimeMs === log.mtimeMs) {
+        sessions.set(log.id, stored);
         continue;
       }
       const events = await readEvents(ctx, log.id, "the usage roll-up");
       if (events === null) {
         failed += 1;
-        if (cached !== void 0) sessions.set(log.id, cached);
+        if (stored !== void 0) sessions.set(log.id, stored);
         continue;
       }
-      const folded = foldSession(events);
-      sessions.set(log.id, { size: log.size, mtimeMs: log.mtimeMs, days: folded.days, hours: folded.hours });
+      sessions.set(log.id, { fingerprint: { size: log.size, mtimeMs: log.mtimeMs }, days: foldSession(events).days });
       read += 1;
     }
-    writeCache(ctx, sessions);
-    const merge = mergeLedgerFold(ledgerDays, sessions, logs);
+    for (const [id, stored] of record.sessions) {
+      if (!sessions.has(id) && stored.days.size > 0) sessions.set(id, { days: stored.days });
+    }
+    const recorded = record.writable && (record.mustWrite || recordChanged(record.sessions, sessions, read)) ? writeRecord(ctx, sessions, new Set(logs.map((log) => log.id))) : sessions;
+    const merge = mergeLedgerFold(ledgerDays, recorded);
     const source = ledgerDays === null ? LOCAL_SOURCE : merge.folded ? `${LEDGER_SOURCE}+${LOCAL_SOURCE}` : LEDGER_SOURCE;
     const summary = summarize(
       merge.days,
@@ -62,7 +73,6 @@ function createUsage(ctx) {
     const root = resolve(join(home(), "sessions"));
     const logs = listSessionLogs(root);
     const ledgerDays = readLedger(home());
-    if (logs.length === 0) return summarize(/* @__PURE__ */ new Map(), 0, LOCAL_SOURCE, NO_HOURS);
     if (ledgerDays !== null && ledgerDays.size > 0) {
       const sessionIds = /* @__PURE__ */ new Set();
       for (const buckets of ledgerDays.values()) {

package/lib/model-descriptions.json

@@ -1337,7 +1337,7 @@
         "note": "Claude rows draw Claude's own lockup, not the parent Anthropic one: the label names the model line, and a wordmark has to match the word it stands in for — the same reason Grok rows draw Grok's rather than xAI's. Anthropic stays the fallback for the `anthropic` route."
       },
       {
-        "match": "gpt|(^|[/-])o[1-9](-|$)",
+        "match": "gpt|(^|[^a-z0-9])o[1-9](-|$)",
         "brand": "openai"
       },
       {
@@ -1360,8 +1360,9 @@
         "brand": "zai"
       },
       {
-        "match": "kimi|(^|-)k3($|-)",
-        "brand": "kimi"
+        "match": "kimi|(^|[^a-z0-9])k3($|-)",
+        "brand": "kimi",
+        "note": "The id can carry the serving provider's namespace (`cn:k3`, `moonshot/k3`), so the segment start accepts any character outside a letter or a digit. Requiring `k3` to start a segment is what leaves `mk3` unclaimed."
       },
       {
         "match": "qwen",
@@ -1372,8 +1373,9 @@
         "brand": "stepfun"
       },
       {
-        "match": "minimax|(^|-)m[23]($|-)",
-        "brand": "minimax"
+        "match": "minimax|(^|[^a-z0-9])m[23]($|-)",
+        "brand": "minimax",
+        "note": "The id can carry the serving provider's namespace (`cn:m3`), so the segment start accepts any character outside a letter or a digit. Requiring `m2` or `m3` to start a segment is what leaves `pm2` unclaimed."
       },
       {
         "match": "muse-spark|llama",
@@ -1401,8 +1403,9 @@
         "brand": "baidu"
       },
       {
-        "match": "hunyuan|(^|-)hy(\\d|-?mt)",
-        "brand": "tencent"
+        "match": "hunyuan|(^|[^a-z0-9])hy(\\d|-?mt)",
+        "brand": "tencent",
+        "note": "The id can carry the serving provider's namespace (`cn:hy3`, `openrouter/hy3`), so the segment start accepts any character outside a letter or a digit. Requiring `hy` to start a segment is what leaves `shy-mt2` unclaimed."
       },
       {
         "match": "mistral|magistral|codestral",
@@ -1417,8 +1420,9 @@
         "brand": "microsoft"
       },
       {
-        "match": "nova",
-        "brand": "nova"
+        "match": "(^|[^a-z0-9])nova(-|$)",
+        "brand": "nova",
+        "note": "The vendor name has to start a segment and end one: unanchored, this rule claims `sensenova-6.8-flash-lite` for Amazon and lands that lockup in the middle of the name."
       },
       {
         "match": "mimo",
@@ -1659,8 +1663,8 @@
       }
     },
     {
-      "match": "kimi.*(k3|k-?3)|^k3",
-      "note": "Anchored to the K3 line: the 2.8T size belongs to it, and the catalog's `k3` and `k3-256k` spellings are the same line.",
+      "match": "kimi.*(k3|k-?3)|(^|[^a-z0-9])k-?3",
+      "note": "Anchored to the K3 line: the 2.8T size belongs to it, and the catalog's `k3` and `k3-256k` spellings are the same line. The K3 mentions carry the same segment start as the lockup rule, so an id spelled `cn:k3` reads this line.",
       "text": {
         "zh": "面向编程与知识工作的 2.8T 开放权重模型。",
         "en": "An open-weight 2.8T model for coding and knowledge work."
@@ -1765,7 +1769,7 @@
       }
     },
     {
-      "match": "minimax.*m3|(^|-)m3($|-)",
+      "match": "minimax.*m3|(^|[^a-z0-9])m3($|-)",
       "note": "The M3 line's own claims; the catalog's `minimax-m3-1m` is the same line at a longer context.",
       "text": {
         "zh": "首个集前沿编程、1M 上下文与原生多模态于一身的开放权重模型。",
@@ -1773,7 +1777,7 @@
       }
     },
     {
-      "match": "minimax|(^|-)m2[-.]?\\d",
+      "match": "minimax|(^|[^a-z0-9])m2[-.]?\\d",
       "text": {
         "zh": "主打智能体推理、工具调用、编程与多模态输入，面向长上下文任务。",
         "en": "Agentic reasoning, tool use, coding and multimodal input for long-context work."
@@ -1870,11 +1874,12 @@
       }
     },
     {
-      "match": "hunyuan|(^|-)hy\\d",
+      "match": "hunyuan|(^|[^a-z0-9])hy\\d",
       "text": {
         "zh": "中文理解与智能体场景表现均衡。",
         "en": "Balanced for Chinese language and agentic scenarios."
-      }
+      },
+      "note": "The brand rule for this line reads the same segment start: `cn:hy3` is the same line as `hy3`."
     },
     {
       "match": "codestral",
@@ -1927,7 +1932,8 @@
       }
     },
     {
-      "match": "nova",
+      "match": "(^|[^a-z0-9])nova(-|$)",
+      "note": "Every mention of the line reads the same boundary as the lockup rule: unanchored, this rule gives `sensenova-6.8-flash-lite` Amazon Nova's description.",
       "text": {
         "zh": "Micro/Lite/Pro/Premier 四档，支持文本、图像与视频输入。",
         "en": "Micro, Lite, Pro and Premier tiers taking text, image and video."

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-claude-style",
   "description": "Claude Code Desktop theme for DeepSeek Harness (dsh) web GUI — visual & interaction overhaul",
-  "version": "0.15.0-dev.22",
+  "version": "0.16.0-dev.27",
   "type": "module",
   "main": "lib/host/index.js",
   "icon": "lib/claude-mark.svg",
@@ -15,10 +15,9 @@
     "changelog:check": "node scripts/changelog.mjs --check",
     "docs:index": "node scripts/decisions-index.mjs",
     "docs:check": "node scripts/decisions-index.mjs --check",
-    "docs:numbers": "node scripts/doc-numbers.mjs",
+    "checks:numbers": "node packages/testing/check-numbers.cjs",
     "agents": "node scripts/agents-commands.mjs",
     "agents:check": "node scripts/agents-commands.mjs --check",
-    "decision:number": "node scripts/decision-number.mjs",
     "lint": "node scripts/lint.mjs",
     "features": "node scripts/features.mjs",
     "features:check": "node scripts/features.mjs --check",

package/lib/host/usage-cache.js

@@ -1,75 +0,0 @@
-// packages/host/src/usage-cache.ts
-import { cachePath, readJsonDocument, writeJsonDocument } from "./cache-file.js";
-import { addBuckets, emptyBuckets } from "./usage-ledger.js";
-var CACHE_VERSION = 4;
-function hoursFrom(raw) {
-  return Array.isArray(raw) && raw.length === 24 ? raw.map((value) => Number.isFinite(Number(value)) ? Number(value) : 0) : new Array(24).fill(0);
-}
-function daysToObject(days) {
-  const out = {};
-  for (const [day, buckets] of days) {
-    const entry = { ...buckets, models: void 0, sessions: void 0 };
-    const cells = {};
-    if (buckets.models !== void 0) {
-      for (const [model, cell] of buckets.models) cells[model] = cell;
-      entry.models = cells;
-    }
-    out[day] = entry;
-  }
-  return out;
-}
-function daysFromObject(raw) {
-  const days = /* @__PURE__ */ new Map();
-  if (raw === null || typeof raw !== "object") return days;
-  for (const [day, buckets] of Object.entries(raw)) {
-    if (buckets === null || typeof buckets !== "object") continue;
-    const stored = buckets;
-    const clean = emptyBuckets();
-    addBuckets(clean, stored, 1);
-    clean.hours = hoursFrom(stored.hours);
-    if (stored.models !== null && typeof stored.models === "object") {
-      const models = /* @__PURE__ */ new Map();
-      for (const [model, cell] of Object.entries(stored.models)) {
-        if (cell === null || typeof cell !== "object") continue;
-        const into = emptyBuckets();
-        addBuckets(into, cell, 1);
-        models.set(model, into);
-      }
-      clean.models = models;
-    }
-    days.set(day, clean);
-  }
-  return days;
-}
-function readCache(ctx) {
-  const parsed = readJsonDocument(ctx, cachePath(ctx, "usage.json"), "usage cache");
-  if (parsed === null || typeof parsed !== "object") return /* @__PURE__ */ new Map();
-  const document = parsed;
-  if (document.version !== CACHE_VERSION) return /* @__PURE__ */ new Map();
-  const sessions = /* @__PURE__ */ new Map();
-  const rawSessions = document.sessions;
-  if (rawSessions === null || typeof rawSessions !== "object") return sessions;
-  for (const [id, value] of Object.entries(rawSessions)) {
-    if (value === null || typeof value !== "object") continue;
-    const entry = value;
-    if (!Number.isFinite(entry.size) || !Number.isFinite(entry.mtimeMs)) continue;
-    sessions.set(id, {
-      size: Number(entry.size),
-      mtimeMs: Number(entry.mtimeMs),
-      days: daysFromObject(entry.days),
-      hours: hoursFrom(entry.hours)
-    });
-  }
-  return sessions;
-}
-function writeCache(ctx, sessions) {
-  const document = { version: CACHE_VERSION, computedAt: Date.now(), sessions: {} };
-  for (const [id, entry] of sessions) {
-    document.sessions[id] = { size: entry.size, mtimeMs: entry.mtimeMs, days: daysToObject(entry.days), hours: entry.hours };
-  }
-  writeJsonDocument(ctx, cachePath(ctx, "usage.json"), "usage cache", document);
-}
-export {
-  readCache,
-  writeCache
-};