@thehammer/danx-session-telemetry 0.1.8 → 0.1.10

package/dist/pricing.d.ts

@@ -12,6 +12,25 @@
  * Sonnet 5 at $3/$15 and Haiku 4.5 at $0.80/$4 where the page says $2/$10 and
  * $1/$5, and Opus 5 / Fable 5.1 / Opus 5.5 were missing).
  *
+ * DX-3261 — re-checked the WHOLE table row-by-row against the same page
+ * again, 2026-09-24, https://platform.claude.com/docs/en/about-claude/pricing
+ * (the "Model pricing" table). Found: `claude-opus-4-7` and `claude-opus-4-5`
+ * were both missing (page: $5 in / $25 out / $0.50 cache hit, same row shape
+ * as Opus 4.8 / Opus 4.6 — added below). Every other standard-speed row
+ * matched exactly: Fable 5.1 ($10/$50, 0.025x hit), Fable 5 ($10/$50, hit
+ * $1), Opus 5.5 ($4/$20, 0.05x hit), Opus 5 / Opus 4.8 / Opus 4.6 ($5/$25,
+ * $0.50 hit), Opus 4 retired ($15/$75, $1.50 hit), Sonnet 5 ($2/$10, $0.20
+ * hit), Sonnet 4.6 / Sonnet 4.5 / Sonnet 4 ($3/$15, $0.30 hit), Haiku 4.5
+ * ($1/$5, $0.10 hit), and the derived 1.25x/2h cache-write multipliers on
+ * every row. Fast-mode rows unchanged: Opus 5.5 ($8/$40), Opus 5 / Opus 4.8
+ * ($10/$50) — Opus 4.7 fast mode returns an error per the page (never
+ * priced), and Opus 4.6 fast mode is handled separately below (the page
+ * states it runs at standard speed, billed at standard rates — not an
+ * unpriced fast row). Claude Mythos 5.1/5 (limited-availability, same rates
+ * as their Fable counterparts) and the two retired-elsewhere rows (Opus 4.1,
+ * Haiku 3.5) are not in Claude Code's own model-tag surface and are left out
+ * on the same basis the table already excludes them.
+ *
  * DX-2963 — cache writes are TWO prices, never one: a 5-minute write is
  * 1.25x base input and a 1-hour write is 2x base input. Claude Code reports
  * each lifetime separately (`usage.cache_creation.ephemeral_5m_input_tokens` /
@@ -58,6 +77,16 @@ export type PriceResult = {
  * and records a visible `unpriced_model` event, instead of one new model id
  * failing every write (the live tick used to fail every 30 seconds on it).
  * `<synthetic>` is never passed here: callers exclude it before pricing.
+ *
+ * DX-3261 — both tables are looked up with `Object.hasOwn`, never bracket
+ * access + truthiness (`table[model]`): a model id that collides with an
+ * inherited `Object.prototype` key (`"toString"`, `"constructor"`, …) would
+ * otherwise resolve to that inherited FUNCTION — truthy, so the `!p` guard
+ * never fires — and every subsequent `p.input` / `p.output` / … reads
+ * `undefined` off it, so the whole cost total becomes `NaN`. `Object.hasOwn`
+ * answers "does the row itself have this key" and can never be fooled by
+ * the prototype chain, so an unpriced model always returns `unpriced`
+ * cleanly, whatever its id looks like.
  */
 export declare function priceUsage(model: string, speed: string, tokens: PricedTokens): PriceResult;
 /** True when `model` has a standard-speed price (used by tests + guards). */

package/dist/pricing.js

@@ -12,6 +12,25 @@
  * Sonnet 5 at $3/$15 and Haiku 4.5 at $0.80/$4 where the page says $2/$10 and
  * $1/$5, and Opus 5 / Fable 5.1 / Opus 5.5 were missing).
  *
+ * DX-3261 — re-checked the WHOLE table row-by-row against the same page
+ * again, 2026-09-24, https://platform.claude.com/docs/en/about-claude/pricing
+ * (the "Model pricing" table). Found: `claude-opus-4-7` and `claude-opus-4-5`
+ * were both missing (page: $5 in / $25 out / $0.50 cache hit, same row shape
+ * as Opus 4.8 / Opus 4.6 — added below). Every other standard-speed row
+ * matched exactly: Fable 5.1 ($10/$50, 0.025x hit), Fable 5 ($10/$50, hit
+ * $1), Opus 5.5 ($4/$20, 0.05x hit), Opus 5 / Opus 4.8 / Opus 4.6 ($5/$25,
+ * $0.50 hit), Opus 4 retired ($15/$75, $1.50 hit), Sonnet 5 ($2/$10, $0.20
+ * hit), Sonnet 4.6 / Sonnet 4.5 / Sonnet 4 ($3/$15, $0.30 hit), Haiku 4.5
+ * ($1/$5, $0.10 hit), and the derived 1.25x/2h cache-write multipliers on
+ * every row. Fast-mode rows unchanged: Opus 5.5 ($8/$40), Opus 5 / Opus 4.8
+ * ($10/$50) — Opus 4.7 fast mode returns an error per the page (never
+ * priced), and Opus 4.6 fast mode is handled separately below (the page
+ * states it runs at standard speed, billed at standard rates — not an
+ * unpriced fast row). Claude Mythos 5.1/5 (limited-availability, same rates
+ * as their Fable counterparts) and the two retired-elsewhere rows (Opus 4.1,
+ * Haiku 3.5) are not in Claude Code's own model-tag surface and are left out
+ * on the same basis the table already excludes them.
+ *
  * DX-2963 — cache writes are TWO prices, never one: a 5-minute write is
  * 1.25x base input and a 1-hour write is 2x base input. Claude Code reports
  * each lifetime separately (`usage.cache_creation.ephemeral_5m_input_tokens` /
@@ -51,8 +70,10 @@ const PRICING = {
     "claude-opus-5-5": price(4, 20, 0.2),
     "claude-opus-5": price(5, 25, 0.5),
     "claude-opus-4-8": price(5, 25, 0.5),
+    "claude-opus-4-7": price(5, 25, 0.5),
     "claude-opus-4-6": price(5, 25, 0.5),
     "claude-opus-4-6-20250916": price(5, 25, 0.5),
+    "claude-opus-4-5": price(5, 25, 0.5),
     "claude-opus-4-20250514": price(15, 75, 1.5),
     "claude-sonnet-5": price(2, 10, 0.2),
     "claude-sonnet-4-6": price(3, 15, 0.3),
@@ -78,6 +99,22 @@ const FAST_PRICING = {
     "claude-opus-5": price(10, 50, 1),
     "claude-opus-4-8": price(10, 50, 1),
 };
+/**
+ * DX-3261 — models whose `speed:"fast"` requests are billed at STANDARD
+ * rates, per the page's "Fast mode pricing" section: *"Fast mode is not
+ * available on Claude Opus 4.7 (requests with `speed: "fast"` return an
+ * error) or Claude Opus 4.6 (requests run at standard speed and are billed
+ * at standard rates)."* Opus 4.7 correctly falls through to `unpriced` below
+ * (it has no row in either table — matches the page's "returns an error").
+ * Opus 4.6 does NOT: DX-2963's own wording sent it down the same unpriced
+ * path as Opus 4.7, contradicting the page it pins — a fast-mode Opus 4.6
+ * reply silently lost its cost. The page wins: look it up in the STANDARD
+ * table instead of `unpriced`, never invent a separate fast row for it.
+ */
+const FAST_BILLS_AT_STANDARD_RATE = new Set([
+    "claude-opus-4-6",
+    "claude-opus-4-6-20250916",
+]);
 /**
  * Price one unit of usage. NEVER throws (DX-2963 replaces DX-1720's throw):
  * an unknown model — or a fast reply on a model with no fast price — returns
@@ -85,12 +122,23 @@ const FAST_PRICING = {
  * and records a visible `unpriced_model` event, instead of one new model id
  * failing every write (the live tick used to fail every 30 seconds on it).
  * `<synthetic>` is never passed here: callers exclude it before pricing.
+ *
+ * DX-3261 — both tables are looked up with `Object.hasOwn`, never bracket
+ * access + truthiness (`table[model]`): a model id that collides with an
+ * inherited `Object.prototype` key (`"toString"`, `"constructor"`, …) would
+ * otherwise resolve to that inherited FUNCTION — truthy, so the `!p` guard
+ * never fires — and every subsequent `p.input` / `p.output` / … reads
+ * `undefined` off it, so the whole cost total becomes `NaN`. `Object.hasOwn`
+ * answers "does the row itself have this key" and can never be fooled by
+ * the prototype chain, so an unpriced model always returns `unpriced`
+ * cleanly, whatever its id looks like.
  */
 export function priceUsage(model, speed, tokens) {
-    const table = speed === FAST_SPEED ? FAST_PRICING : PRICING;
-    const p = table[model];
-    if (!p)
+    const useFastTable = speed === FAST_SPEED && !FAST_BILLS_AT_STANDARD_RATE.has(model);
+    const table = useFastTable ? FAST_PRICING : PRICING;
+    if (!Object.hasOwn(table, model))
         return { kind: "unpriced", model, speed };
+    const p = table[model];
     return {
         kind: "priced",
         costUsd: (tokens.input * p.input +
@@ -103,5 +151,7 @@ export function priceUsage(model, speed, tokens) {
 }
 /** True when `model` has a standard-speed price (used by tests + guards). */
 export function isPricedModel(model) {
-    return model in PRICING;
+    // DX-3261 — `in` walks the prototype chain (`"toString" in {}` is `true`);
+    // `Object.hasOwn` can't be fooled by it. See `priceUsage`'s own comment.
+    return Object.hasOwn(PRICING, model);
 }

package/dist/usage-ledger.d.ts

@@ -55,6 +55,18 @@ export interface LedgerLine {
     toolUseIds: readonly string[];
 }
 export declare const MAIN_SOURCE = "main";
+/**
+ * DX-3261 — a producer handed this module a line it cannot safely key or
+ * date: no valid `byte_offset` on a no-`message.id` line (would collapse
+ * every such line in the source onto the same synthetic key, crediting only
+ * the largest — see {@link syntheticMessageKey}), or a `timestamp` that
+ * doesn't parse (would read as `repliedAt: 0`, invisible to every
+ * account-window lookback). Both were silent `0` defaults before this card;
+ * thrown here instead, so a broken producer fails immediately and visibly
+ * rather than quietly losing or mis-crediting usage.
+ */
+export declare class LedgerLineDataError extends Error {
+}
 /**
  * DX-2963 — a usage line with no `message.id` (never observed in the 22,087
  * usage lines of the 20 newest local transcripts, 2026-09-18) is keyed by its

package/dist/usage-ledger.js

@@ -1,4 +1,16 @@
 export const MAIN_SOURCE = "main";
+/**
+ * DX-3261 — a producer handed this module a line it cannot safely key or
+ * date: no valid `byte_offset` on a no-`message.id` line (would collapse
+ * every such line in the source onto the same synthetic key, crediting only
+ * the largest — see {@link syntheticMessageKey}), or a `timestamp` that
+ * doesn't parse (would read as `repliedAt: 0`, invisible to every
+ * account-window lookback). Both were silent `0` defaults before this card;
+ * thrown here instead, so a broken producer fails immediately and visibly
+ * rather than quietly losing or mis-crediting usage.
+ */
+export class LedgerLineDataError extends Error {
+}
 /**
  * DX-2963 — a usage line with no `message.id` (never observed in the 22,087
  * usage lines of the 20 newest local transcripts, 2026-09-18) is keyed by its
@@ -12,13 +24,25 @@ export function isSyntheticMessageKey(key) {
     return key.startsWith("nomsg:");
 }
 /**
- * A usage field as a non-negative count. A numeric STRING is read as its
- * number (drift-safe: a transcript that ever quotes a count is still counted,
- * never silently zeroed); anything else absent or non-numeric is 0.
+ * A usage field as a non-negative INTEGER count. A numeric STRING is read as
+ * its number (drift-safe: a transcript that ever quotes a count is still
+ * counted, never silently zeroed); anything else absent or non-numeric is 0.
+ *
+ * DX-3261 — rounded to the nearest integer, never passed through fractional.
+ * A token count is an integer by definition, so a fractional value here is
+ * itself the anomaly (a malformed/synthetic producer), not a legitimate
+ * reading to preserve verbatim — and the wire contract this feeds
+ * (`parseStatsPayload`'s `isNonNegInt`, `usage-ledger-wire.ts`) REQUIRES an
+ * integer and fails loud on anything else. Before this fix a fractional
+ * value here would sail through the counter, get queued as a changed entry,
+ * then 400 on every single stats-write attempt for that dispatch FOREVER —
+ * the worker's `flush()` re-queues a failed batch unconditionally, so a
+ * value that never changes never stops failing. Rounding at the source
+ * closes the gap without loosening the wire's own integer contract.
  */
 function num(v) {
     const n = typeof v === "string" && v.trim() !== "" ? Number(v) : v;
-    return typeof n === "number" && Number.isFinite(n) && n > 0 ? n : 0;
+    return typeof n === "number" && Number.isFinite(n) && n > 0 ? Math.round(n) : 0;
 }
 /**
  * Read a raw `message.usage` block into {@link LedgerUsage}. The two
@@ -202,6 +226,13 @@ export function ledgerLineFromRaw(raw, source, byteOffset) {
         ? message.content
         : [];
     const ts = typeof raw.timestamp === "string" ? Date.parse(raw.timestamp) : NaN;
+    // DX-3261 — an unparseable/missing timestamp used to silently become
+    // `repliedAt: 0` (epoch 0), which falls outside every account-window
+    // lookback and made that reply's tokens permanently invisible to the
+    // gate — with no event, no log, nothing. Fail loud instead.
+    if (!Number.isFinite(ts)) {
+        throw new LedgerLineDataError(`ledgerLineFromRaw: unparseable/missing timestamp (raw.timestamp=${JSON.stringify(raw.timestamp)})`);
+    }
     return {
         messageId: typeof message.id === "string" && message.id.length > 0 ? message.id : undefined,
         source,
@@ -212,7 +243,7 @@ export function ledgerLineFromRaw(raw, source, byteOffset) {
         usage: message.usage && typeof message.usage === "object"
             ? message.usage
             : undefined,
-        timestamp: Number.isFinite(ts) ? ts : 0,
+        timestamp: ts,
         toolUseIds: content
             .filter((b) => b.type === "tool_use" && typeof b.id === "string")
             .map((b) => b.id),
@@ -260,17 +291,32 @@ export function ledgerLineFromLogEntry(entry) {
     const content = Array.isArray(d.content)
         ? d.content
         : [];
+    const hasMessageId = typeof d.messageId === "string" && d.messageId.length > 0;
+    const hasUsage = Boolean(d.usage && typeof d.usage === "object");
+    const toolUseIds = content
+        .filter((b) => b.type === "tool_use" && typeof b.id === "string")
+        .map((b) => b.id);
+    // DX-3261 — `byteOffset` only matters as the synthetic key for a line with
+    // no `message.id` (`syntheticMessageKey`); a missing/invalid one used to
+    // silently default to `0`, collapsing EVERY no-id reply from this source
+    // onto one key so only the largest single reply was ever credited. Fail
+    // loud rather than repeat that silent collapse — but ONLY when the line
+    // will actually reach that keying step: `UsageLedgerCounter.observe()`
+    // discards a no-id line with neither usage nor a tool-use id before ever
+    // building a key (a tool-call block with no reported `id`, an empty
+    // wrapper entry), so requiring a valid `byteOffset` on THOSE too would
+    // reject lines the counter was always going to ignore. Harmless when a
+    // real `messageId` is present (byteOffset is never used to key that line).
+    if (!hasMessageId && (hasUsage || toolUseIds.length > 0) && typeof d.byte_offset !== "number") {
+        throw new LedgerLineDataError(`ledgerLineFromLogEntry: missing/invalid byte_offset on a no-message-id line carrying usage or a tool-use id (source=${typeof d.subagent_id === "string" ? d.subagent_id : MAIN_SOURCE})`);
+    }
     return {
-        messageId: typeof d.messageId === "string" && d.messageId.length > 0 ? d.messageId : undefined,
+        messageId: hasMessageId ? d.messageId : undefined,
         source: typeof d.subagent_id === "string" ? d.subagent_id : MAIN_SOURCE,
         byteOffset: typeof d.byte_offset === "number" ? d.byte_offset : 0,
         model: typeof d.model === "string" && d.model.length > 0 ? d.model : undefined,
-        usage: d.usage && typeof d.usage === "object"
-            ? d.usage
-            : undefined,
+        usage: hasUsage ? d.usage : undefined,
         timestamp: entry.timestamp,
-        toolUseIds: content
-            .filter((b) => b.type === "tool_use" && typeof b.id === "string")
-            .map((b) => b.id),
+        toolUseIds,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thehammer/danx-session-telemetry",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Shared Claude Code transcript collector (DX-2962) — incremental JSONL tailing for the danxbot worker and the danx-dashboard-mcp desktop bridge, so both run identical collector code.",
   "license": "MIT",
   "type": "module",