@dzhechkov/harness-core 0.3.131 → 0.3.133

package/src/usage.ts

@@ -28,7 +28,7 @@
  * @packageDocumentation
  */
 
-import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { existsSync, lstatSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
@@ -38,6 +38,13 @@ const DEFAULT_WEEKLY_RESET_ANCHOR = 'Wed 08:59';
 // mtime prefilter slack (+1h) — guards against clock skew between the writer and this reader.
 const MTIME_SLACK_MS = HOUR_MS;
 
+/**
+ * Per-token price ratios relative to base input, used to turn a raw token mix into INPUT-EQUIVALENT
+ * tokens. Without this the metric is ~90-99% cache-read and measures context size, not work.
+ * (Anthropic list pricing: 5m cache write 1.25x input, cache read 0.1x input, output 5x input.)
+ */
+export const TOKEN_WEIGHTS = { input: 1, cacheWrite: 1.25, cacheWrite1h: 2, cacheRead: 0.1, output: 5 } as const;
+
 export const CLAUDE_USAGE_MODELS = ['fable', 'opus', 'sonnet', 'haiku'] as const;
 export type ClaudeUsageModel = (typeof CLAUDE_USAGE_MODELS)[number];
 
@@ -287,6 +294,20 @@ interface Sample {
  * List every `*.jsonl` under `~/.claude/projects/<dir>/`, best-effort. Never throws — an
  * unreadable dir/file is skipped. Returns absolute paths + their `mtimeMs` (the prefilter lever).
  */
+/** A hard bound: a pathological tree must degrade to a partial estimate, never to a hang or an OOM. */
+const MAX_TRANSCRIPT_FILES = 20_000;
+
+/** Only a REGULAR file is readable transcript data. lstat (not stat) so a symlink is never followed —
+ *  a FIFO blocks readFileSync forever and a symlink to a huge file explodes memory. */
+function regularFileMtime(p: string): number | null {
+  try {
+    const st = lstatSync(p);
+    return st.isFile() ? st.mtimeMs : null;
+  } catch {
+    return null;
+  }
+}
+
 function listTranscriptFiles(root: string): Array<{ path: string; mtimeMs: number }> {
   const out: Array<{ path: string; mtimeMs: number }> = [];
   let dirs: string[];
@@ -307,13 +328,29 @@ function listTranscriptFiles(root: string): Array<{ path: string; mtimeMs: numbe
       continue;
     }
     for (const f of files) {
-      if (!f.endsWith('.jsonl')) continue;
-      const p = join(projDir, f);
-      try {
-        out.push({ path: p, mtimeMs: statSync(p).mtimeMs });
-      } catch {
-        // skip a file we cannot stat
+      // A session's SUBAGENT transcripts live one level deeper — `<session>/subagents/*.jsonl` — and
+      // carry real, non-duplicated usage that was silently excluded (MEASURED: 27 such files on this
+      // machine). Their tokens are spent exactly like the main loop's.
+      if (!f.endsWith('.jsonl')) {
+        const nested = join(projDir, f, 'subagents');
+        try {
+          if (!statSync(nested).isDirectory()) continue;
+          for (const sf of readdirSync(nested)) {
+            if (!sf.endsWith('.jsonl')) continue;
+            if (out.length >= MAX_TRANSCRIPT_FILES) break;
+            const sp = join(nested, sf);
+            const m = regularFileMtime(sp);
+            if (m !== null) out.push({ path: sp, mtimeMs: m });
+          }
+        } catch {
+          /* not a session dir — skip */
+        }
+        continue;
       }
+      if (out.length >= MAX_TRANSCRIPT_FILES) break;
+      const p = join(projDir, f);
+      const mt = regularFileMtime(p);
+      if (mt !== null) out.push({ path: p, mtimeMs: mt });
     }
   }
   return out;
@@ -344,6 +381,9 @@ function extractSamples(path: string, scanCutoff: number, into: Sample[], seen:
         usage?: {
           input_tokens?: unknown;
           cache_creation_input_tokens?: unknown;
+          /** TTL breakdown: 5m writes price at 1.25x, 1h writes at 2x. A nested-only record used to
+           *  count as ZERO because only the flat field was read. */
+          cache_creation?: { ephemeral_5m_input_tokens?: unknown; ephemeral_1h_input_tokens?: unknown };
           cache_read_input_tokens?: unknown;
           output_tokens?: unknown;
         };
@@ -362,20 +402,33 @@ function extractSamples(path: string, scanCutoff: number, into: Sample[], seen:
     if (!isFinite(ts)) continue;
     if (ts < scanCutoff) continue;
     const n = (v: unknown): number => (typeof v === 'number' && isFinite(v) && v > 0 ? v : 0);
+    // COST-WEIGHTED, not a flat sum. A flat sum is 89-99.7% `cache_read` (MEASURED on this machine),
+    // which grows with CONVERSATION LENGTH rather than with work done — two sessions doing identical
+    // work differ by orders of magnitude, so no threshold over it can mean anything. These weights are
+    // the published per-token price ratios relative to base input, so the total is "input-equivalent
+    // tokens": a quantity that tracks consumption instead of context size.
+    // Prefer the TTL breakdown when present (5m 1.25x / 1h 2x); fall back to the flat field at the
+    // 5m rate. Reading only the flat field scored a nested-only record as ZERO.
+    const c5 = n(usage.cache_creation?.ephemeral_5m_input_tokens);
+    const c1h = n(usage.cache_creation?.ephemeral_1h_input_tokens);
+    const cacheWriteCost =
+      c5 + c1h > 0
+        ? c5 * TOKEN_WEIGHTS.cacheWrite + c1h * TOKEN_WEIGHTS.cacheWrite1h
+        : n(usage.cache_creation_input_tokens) * TOKEN_WEIGHTS.cacheWrite;
     const tokens =
-      n(usage.input_tokens) +
-      n(usage.cache_creation_input_tokens) +
-      n(usage.cache_read_input_tokens) +
-      n(usage.output_tokens);
+      n(usage.input_tokens) * TOKEN_WEIGHTS.input +
+      cacheWriteCost +
+      n(usage.cache_read_input_tokens) * TOKEN_WEIGHTS.cacheRead +
+      n(usage.output_tokens) * TOKEN_WEIGHTS.output;
     if (tokens <= 0) continue;
     // Dedup: streamed assistant messages repeat their usage object across chunks.
     const id = typeof rec.message?.id === 'string' ? rec.message.id : '';
     const reqId = typeof rec.requestId === 'string' ? rec.requestId : '';
-    const key = id + ':' + reqId;
-    if (id !== '' || reqId !== '') {
-      if (seen.has(key)) continue;
-      seen.add(key);
-    }
+    // With no ids, fall back to a CONTENT key (timestamp + weighted total): the same record copied
+    // into both a main and a subagent transcript would otherwise be counted twice.
+    const key = id !== '' || reqId !== '' ? id + ':' + reqId : `anon:${ts}:${tokens}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
     into.push({ ts, tokens, key, model: normalizeClaudeUsageModel(rec.message?.model ?? rec.model) });
   }
 }