@dzhechkov/harness-core 0.3.134 → 0.3.136

package/src/recall-usage.ts

@@ -12,13 +12,31 @@
 export const RECALL_USAGE_LOG_RELATIVE = '.dz/recall-usage.jsonl';
 export const RECALL_USAGE_LOG_MAX_BYTES = 1_048_576;
 export const RECALL_USAGE_COMPACT_TARGET_BYTES = Math.floor(RECALL_USAGE_LOG_MAX_BYTES * 0.75);
+/** Newest query-bearing read rows survive compaction verbatim — they are the replay corpus. */
+export const RECALL_USAGE_REPLAY_KEEP = 500;
 
 export interface RecallUsageReadRecord {
   readonly dzId: string;
   readonly score: number;
   readonly ts: string;
+  /**
+   * The PROMPT the lesson was injected into (truncated). Without it the log can say a lesson was
+   * used but never say FOR WHAT — which made cold-vs-warm replay unbuildable from 39 recorded
+   * events (MEASURED, compounding data inventory 2026-07-28). `.dz/` is git-ignored, so a truncated
+   * query stays on this machine.
+   */
+  readonly query?: string;
+  /** The session/run the injection happened in — lets replay group events into runs. */
+  readonly runId?: string;
+  /** One id per PROMPT (the hook writes one row per injected hit — up to 3 per prompt). */
+  readonly eventId?: string;
+  /** True when the stored query is a PREFIX of the real prompt — not replayable. */
+  readonly queryTruncated?: boolean;
 }
 
+/** Query text is capped so a pasted wall of text cannot bloat the log. */
+export const RECALL_USAGE_QUERY_MAX_CHARS = 200;
+
 export interface RecallUsageAggregateRecord {
   readonly kind: 'aggregate';
   readonly dzId: string;
@@ -90,6 +108,10 @@ export function formatRecallUsageRecord(input: {
   readonly dzId?: unknown;
   readonly score?: unknown;
   readonly ts?: unknown;
+  readonly query?: unknown;
+  readonly runId?: unknown;
+  readonly eventId?: unknown;
+  readonly queryTruncated?: unknown;
 }): string | undefined {
   const rec = normalizeReadRecord(input);
   return rec === undefined ? undefined : `${JSON.stringify(rec)}\n`;
@@ -198,8 +220,16 @@ export function compactRecallUsageLog(
   const maxBytes = validMax(opts.maxBytes ?? RECALL_USAGE_LOG_MAX_BYTES);
   const targetBytes = validTarget(opts.targetBytes ?? Math.floor(maxBytes * 0.75), maxBytes);
   const compactedAt = validTs(opts.compactedAt) ? opts.compactedAt : new Date(0).toISOString();
-  const stats = aggregateRecallUsage(parseRecallUsageLog(text).records);
-  const lines = stats.map((s) => aggregateLine(s, compactedAt));
+  const parsed = parseRecallUsageLog(text).records;
+  const stats = aggregateRecallUsage(parsed);
+  // The query-bearing read rows are the ONLY inputs a cold-vs-warm replay has — aggregating them
+  // away silently reset the accruing corpus at the size threshold (Codex #4). Keep the NEWEST ones
+  // (bounded) verbatim alongside the aggregates.
+  const replayRows = parsed
+    .filter((r): r is RecallUsageReadRecord => !('kind' in r) && typeof (r as RecallUsageReadRecord).query === 'string')
+    .sort((a, b) => a.ts.localeCompare(b.ts))
+    .slice(-RECALL_USAGE_REPLAY_KEEP);
+  const lines = [...stats.map((s) => aggregateLine(s, compactedAt)), ...replayRows.map((r) => JSON.stringify(r))];
   let out = joinLines(lines);
   if (byteLength(out) <= maxBytes) return out;
 
@@ -232,7 +262,19 @@ function normalizeReadRecord(value: unknown): RecallUsageReadRecord | undefined
   if (typeof dzId !== 'string' || dzId.trim() === '') return undefined;
   if (typeof score !== 'number' || !Number.isFinite(score)) return undefined;
   if (!validTs(ts)) return undefined;
-  return { dzId: dzId.trim(), score, ts };
+  const query = value['query'];
+  const runId = value['runId'];
+  return {
+    dzId: dzId.trim(),
+    score,
+    ts,
+    ...(typeof query === 'string' && query.trim() !== ''
+      ? { query: query.slice(0, RECALL_USAGE_QUERY_MAX_CHARS) }
+      : {}),
+    ...(typeof runId === 'string' && runId.trim() !== '' ? { runId: runId.trim() } : {}),
+    ...(typeof value['eventId'] === 'string' && (value['eventId'] as string).trim() !== '' ? { eventId: (value['eventId'] as string).trim() } : {}),
+    ...(value['queryTruncated'] === true ? { queryTruncated: true } : {}),
+  };
 }
 
 function normalizeAggregateRecord(value: Record<string, unknown>): RecallUsageAggregateRecord | undefined {

package/src/usage.ts

@@ -321,7 +321,8 @@ function listTranscriptFiles(root: string): Array<{ path: string; mtimeMs: numbe
     const projDir = join(root, d);
     let files: string[];
     try {
-      const st = statSync(projDir);
+      // lstat, not stat: a symlinked project directory would otherwise be walked (Codex #3).
+      const st = lstatSync(projDir);
       if (!st.isDirectory()) continue;
       files = readdirSync(projDir);
     } catch {
@@ -334,10 +335,9 @@ function listTranscriptFiles(root: string): Array<{ path: string; mtimeMs: numbe
       if (!f.endsWith('.jsonl')) {
         const nested = join(projDir, f, 'subagents');
         try {
-          if (!statSync(nested).isDirectory()) continue;
+          if (!lstatSync(nested).isDirectory()) continue; // no symlinked session/subagent dirs
           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 });
@@ -347,12 +347,17 @@ function listTranscriptFiles(root: string): Array<{ path: string; mtimeMs: numbe
         }
         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 });
     }
   }
+  // Cap by RECENCY, not by enumeration order: capping as we walked could discard the very files that
+  // hold current usage while keeping ancient ones (Codex #1).
+  if (out.length > MAX_TRANSCRIPT_FILES) {
+    out.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    out.length = MAX_TRANSCRIPT_FILES;
+  }
   return out;
 }
 
@@ -426,7 +431,12 @@ function extractSamples(path: string, scanCutoff: number, into: Sample[], seen:
     const reqId = typeof rec.requestId === 'string' ? rec.requestId : '';
     // 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}`;
+    // Include the raw vector + model: `{input:50}` and `{output:10}` both weigh 50, so a
+    // total-only key silently merged distinct records (Codex #4).
+    const key =
+      id !== '' || reqId !== ''
+        ? id + ':' + reqId
+        : `anon:${ts}:${n(usage.input_tokens)}:${n(usage.cache_creation_input_tokens)}:${n(usage.cache_read_input_tokens)}:${n(usage.output_tokens)}:${String(rec.message?.model ?? rec.model ?? '')}`;
     if (seen.has(key)) continue;
     seen.add(key);
     into.push({ ts, tokens, key, model: normalizeClaudeUsageModel(rec.message?.model ?? rec.model) });
@@ -487,6 +497,12 @@ function configuredModelLimits(
  * (all projects). `now` is injectable for tests.
  */
 export function computeUsage(projectRoot: string, now?: number): UsageEstimate {
+  // never-throw contract: a non-finite or out-of-range clock reached `toISOString()` and raised
+  // RangeError. Clamp to the valid Date range instead of crashing the statusline (Codex #5).
+  const MAX_TIME = 8.64e15;
+  if (now !== undefined && (!isFinite(now) || Math.abs(now) > MAX_TIME)) {
+    now = Date.now();
+  }
   const nowMs = typeof now === 'number' && isFinite(now) ? now : Date.now();
   const limits = readUsageLimits(projectRoot);
   const sessionBlockHours = limits.sessionBlockHours ?? DEFAULT_SESSION_BLOCK_HOURS;