claude-dependency-test 1.0.0

package/scripts/diagnose.mjs

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+// Claude Dependency Test: computes a 0-100 dependency score from local Claude Code transcripts.
+// The computation is deterministic, offline and dependency-free. Then, unless --no-publish, the
+// aggregate report (numbers and enum values only) is published to the share site.
+//
+// Usage: node diagnose.mjs [--json] [--tz <IANA zone>] [--days <n>] [--open] [--no-html]
+//                          [--no-publish] [--new-link] [--unpublish]
+//                          [--out <dir>] [--config-dir <dir>] [--now <ISO date>]
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { collect } from './lib/collect.mjs';
+import { computeMetrics } from './lib/metrics.mjs';
+import { archetypeFor, scoreMetrics, stageFor } from './lib/score.mjs';
+import { publish, unpublish } from './lib/publish.mjs';
+import { buildResult, finalizeShare, renderHtml, renderShareFooter, toPublicReport } from './lib/report.mjs';
+import { badgeUrl } from '../assets/card.js';
+
+const ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
+const VERSION = JSON.parse(fs.readFileSync(path.join(ROOT, '.claude-plugin', 'plugin.json'), 'utf8')).version;
+
+export function parseArgs(argv) {
+  const args = { json: false, open: false, html: true, publish: true, newLink: false, unpublish: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const next = () => {
+      if (i + 1 >= argv.length) throw new Error(`${a} needs a value`);
+      return argv[++i];
+    };
+    if (a === '--json') args.json = true;
+    else if (a === '--open') args.open = true;
+    else if (a === '--no-open') args.open = false;
+    else if (a === '--no-html') args.html = false;
+    else if (a === '--no-publish') args.publish = false;
+    else if (a === '--new-link') args.newLink = true;
+    else if (a === '--unpublish') args.unpublish = true;
+    else if (a === '--tz') args.tz = next();
+    else if (a === '--days') args.days = Number(next());
+    else if (a === '--out') args.out = next();
+    else if (a === '--config-dir') args.configDir = next();
+    else if (a === '--now') args.now = next();
+    else if (a === '--help' || a === '-h') args.help = true;
+    else throw new Error(`Unknown option: ${a}`);
+  }
+  if (args.days !== undefined && !(args.days >= 1)) throw new Error('--days must be a positive number');
+  if (!argv.includes('--no-open') && !args.json && process.stdout.isTTY) args.open = true; // npx in a terminal
+  if (args.tz) new Intl.DateTimeFormat('en-US', { timeZone: args.tz }); // throws on invalid zone
+  return args;
+}
+
+/** Reads only `cleanupPeriodDays` from settings.json. */
+export function readCleanupPeriodDays(configDir, fallback) {
+  try {
+    const s = JSON.parse(fs.readFileSync(path.join(configDir, 'settings.json'), 'utf8'));
+    const v = Number(s && s.cleanupPeriodDays);
+    return Number.isFinite(v) && v > 0 ? v : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function openInBrowser(file) {
+  const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
+  const cmdArgs = process.platform === 'win32' ? ['/c', 'start', '', file] : [file];
+  try {
+    spawn(cmd, cmdArgs, { detached: true, stdio: 'ignore' }).on('error', () => {}).unref();
+  } catch {
+    /* opening the browser is best-effort */
+  }
+}
+
+export async function run(argv, env = process.env, { fetchImpl = globalThis.fetch } = {}) {
+  const args = parseArgs(argv);
+  if (args.help) {
+    return { text: 'Usage: diagnose.mjs [--json] [--tz Europe/Paris] [--days 30] [--open] [--no-html] [--no-publish] [--new-link] [--unpublish] [--out dir]' };
+  }
+  const outDir = args.out || path.join(os.homedir(), '.claude-dependency-test');
+  const stateFile = path.join(outDir, 'published.json');
+
+  if (args.unpublish) {
+    const r = await unpublish({ stateFile, fetchImpl });
+    const result = { tool: 'claude-dependency-test', version: VERSION, unpublished: r };
+    return { result, text: r.deleted ? `Deleted ${r.url}. It's gone from the database now; cached copies of the page, preview image and badge expire within 5 minutes.` : `Nothing to delete: ${r.reason}.` };
+  }
+  const config = JSON.parse(fs.readFileSync(path.join(ROOT, 'config', 'scoring.json'), 'utf8'));
+  const configDir = args.configDir || env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+  const projectsDir = path.join(configDir, 'projects');
+  const timeZone = args.tz || Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+  const now = args.now ? Date.parse(args.now) : Date.now();
+  if (!Number.isFinite(now)) throw new Error('--now must be an ISO date');
+  const cleanupPeriodDays = readCleanupPeriodDays(configDir, config.defaultCleanupPeriodDays);
+  const baseUrl = env.CDT_SHARE_BASE_URL || config.share.baseUrl;
+
+  const collected = await collect(projectsDir);
+  const computed = computeMetrics(collected, { now, timeZone, cleanupPeriodDays, maxDays: args.days, config });
+
+  if (computed.empty) {
+    const result = {
+      tool: 'claude-dependency-test',
+      version: VERSION,
+      error: 'insufficient_data',
+      message: `No prompts found in the last ${args.days || cleanupPeriodDays} days of Claude Code transcripts. Use Claude Code a bit, then come back for your diagnosis.`,
+      dataQuality: collected.quality,
+    };
+    return { result, text: result.message };
+  }
+
+  const scored = scoreMetrics(computed.metrics, computed.window.days, config);
+  const stage = stageFor(scored.total, config);
+  const archetype = archetypeFor(scored.breakdown, config);
+  const result = buildResult({
+    computed,
+    scored,
+    stage,
+    archetype,
+    config,
+    baseUrl,
+    generatedAt: new Date(now).toISOString(),
+    version: VERSION,
+  });
+  result.dataQuality = collected.quality;
+
+  if (args.publish && !env.CDT_NO_PUBLISH) {
+    try {
+      const p = await publish({ baseUrl, report: toPublicReport(result), stateFile, forceNew: args.newLink, fetchImpl });
+      result.published = p;
+      result.share.url = p.url;
+      result.share.badge = badgeUrl(baseUrl, result.card, p.slug);
+      finalizeShare(result);
+    } catch (err) {
+      result.publishError = `${err.message}. Falling back to a link that carries the card in its URL.`;
+    }
+  }
+
+  if (args.html) {
+    fs.mkdirSync(outDir, { recursive: true });
+    const file = path.join(outDir, 'report.html');
+    fs.writeFileSync(file, renderHtml(result));
+    result.reportPath = file;
+  }
+  if (args.open && !env.CDT_NO_OPEN) {
+    const target = result.published ? result.published.url : result.reportPath;
+    if (target) openInBrowser(target);
+  }
+  const lines = [result.bulletin, ''];
+  if (result.published) {
+    lines.push(`  Online: ${result.published.url}${result.published.updated ? ' (updated)' : ''}`);
+    lines.push('  Only aggregate numbers were published. Delete it: --unpublish · Stay offline next time: --no-publish');
+  }
+  else if (result.publishError) lines.push(`  Not published: ${result.publishError}`);
+  lines.push(`  Card:   ${result.reportPath || '(not written)'}`, renderShareFooter(result), '');
+  return { result, text: lines.join('\n') };
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  run(process.argv.slice(2))
+    .then(({ result, text }) => {
+      const argv = process.argv.slice(2);
+      process.stdout.write(argv.includes('--json') && result ? `${JSON.stringify(result, null, 1)}\n` : `${text}\n`);
+    })
+    .catch((err) => {
+      process.stderr.write(`claude-dependency-test: ${err.message}\n`);
+      process.exit(1);
+    });
+}

package/scripts/lib/collect.mjs

@@ -0,0 +1,206 @@
+// Streams Claude Code transcripts and keeps only timestamps and a few enum-like fields.
+// Message text, file paths, project names and identifiers are never stored or returned:
+// uuids / message ids live only in in-memory Sets used for de-duplication.
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+import { normalizeToolName } from '../../assets/card.js';
+
+// Legacy transcripts (written before Claude Code tagged prompts with `origin`/`promptSource`)
+// have no structured marker for "typed by a human". For those lines only, we compare the first
+// characters of the text against this fixed list of tags that Claude Code itself injects.
+// The text is never copied or kept.
+const LEGACY_INJECTED_PREFIXES = ['<', '[Request interrupted'];
+const HUMAN_PROMPT_SOURCES = new Set(['typed', 'queued', 'suggestion_accepted']);
+
+export function listTranscriptFiles(projectsDir) {
+  const out = [];
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const p = path.join(dir, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (e.isFile() && e.name.endsWith('.jsonl')) out.push(p);
+    }
+  };
+  walk(projectsDir);
+  return out.sort();
+}
+
+function leadingText(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    const block = content.find((b) => b && b.type === 'text');
+    return block && typeof block.text === 'string' ? block.text : '';
+  }
+  return '';
+}
+
+/** Returns 'human' | 'legacy-human' | null for a `type: "user"` line. */
+export function classifyUserLine(o) {
+  if (o.isSidechain || o.isMeta || o.isCompactSummary || o.isVisibleInTranscriptOnly) return null;
+  const content = o.message && o.message.content;
+  if (Array.isArray(content)) {
+    if (content.some((b) => b && b.type === 'tool_result')) return null;
+    if (!content.some((b) => b && (b.type === 'text' || b.type === 'image'))) return null;
+  } else if (typeof content !== 'string') {
+    return null;
+  }
+  if (o.origin && typeof o.origin === 'object') return o.origin.kind === 'human' ? 'human' : null;
+  if (typeof o.promptSource === 'string') return HUMAN_PROMPT_SOURCES.has(o.promptSource) ? 'human' : null;
+  const head = leadingText(content).slice(0, 32).trimStart();
+  if (!head) return Array.isArray(content) ? 'legacy-human' : null; // image-only prompt
+  if (LEGACY_INJECTED_PREFIXES.some((p) => head.startsWith(p))) return null;
+  return 'legacy-human';
+}
+
+// Claude Code writes this marker (not a prompt) when you press Esc while Claude is working.
+const INTERRUPTION_MARKER = '[Request interrupted';
+function isInterruptionLine(o) {
+  if (o.isSidechain || o.origin || o.promptSource) return false;
+  const content = o.message && o.message.content;
+  const block = Array.isArray(content) && content.length === 1 && content[0] && content[0].type === 'text' ? content[0] : null;
+  return !!block && typeof block.text === 'string' && block.text.startsWith(INTERRUPTION_MARKER);
+}
+
+function isRateLimitLine(o) {
+  if (o.error === 'rate_limit') return true;
+  return !!(o.quotaLimits && o.quotaLimits.status === 'rejected');
+}
+
+/**
+ * @returns {Promise<{
+ *   activity: number[], prompts: number[], modelEvents: {ms:number, model:string}[],
+ *   limitEvents: {ms:number, resetsAt:number|null}[], errorSignalsSeen: boolean,
+ *   quality: object }>}
+ */
+export async function collect(projectsDir) {
+  const files = listTranscriptFiles(projectsDir);
+  const seenUuids = new Set();
+  const seenMessageIds = new Set();
+  const activity = [];
+  const prompts = [];
+  const modelEvents = [];
+  const limitEvents = [];
+  const toolEvents = []; // { ms, name } with name from a fixed list (see normalizeToolName)
+  const usageById = new Map(); // message.id -> { ms, out, total }: max over the lines of one response
+  const subagents = new Map(); // agentId -> first ms (ids stay in memory, only the count is output)
+  const compactions = [];
+  const turns = []; // { ms, durationMs } for main-thread turns
+  const interruptions = [];
+  const projectLastMs = new Map(); // transcript folder -> last activity (only the count is output)
+  let errorSignalsSeen = false;
+  const quality = {
+    files: files.length,
+    lines: 0,
+    unparseableLines: 0,
+    duplicateLinesSkipped: 0,
+    promptsFromOriginField: 0,
+    promptsFromLegacyHeuristic: 0,
+  };
+
+  for (const file of files) {
+    const project = path.relative(projectsDir, file).split(path.sep)[0];
+    const rl = readline.createInterface({ input: fs.createReadStream(file), crlfDelay: Infinity });
+    for await (const line of rl) {
+      if (!line) continue;
+      quality.lines++;
+      let o;
+      try {
+        o = JSON.parse(line);
+      } catch {
+        quality.unparseableLines++;
+        continue;
+      }
+      if (!o || (o.type !== 'user' && o.type !== 'assistant' && o.type !== 'system')) continue;
+
+      // Resumed / forked sessions copy earlier lines verbatim (same uuid) into a new file.
+      if (typeof o.uuid === 'string') {
+        if (seenUuids.has(o.uuid)) {
+          quality.duplicateLinesSkipped++;
+          continue;
+        }
+        seenUuids.add(o.uuid);
+      }
+      const ms = Date.parse(o.timestamp);
+      if (!Number.isFinite(ms)) continue;
+
+      if (o.type === 'system') {
+        if (o.isSidechain) continue;
+        if (o.subtype === 'compact_boundary') compactions.push(ms);
+        if (o.subtype === 'turn_duration' && Number.isFinite(o.durationMs) && o.durationMs > 0) turns.push({ ms, durationMs: o.durationMs });
+        continue;
+      }
+      if (o.isSidechain && typeof o.agentId === 'string' && !subagents.has(o.agentId)) subagents.set(o.agentId, ms);
+
+      if (o.type === 'assistant') {
+        if (o.error !== undefined || o.quotaLimits || o.isApiErrorMessage) errorSignalsSeen = true;
+        if (isRateLimitLine(o)) {
+          const r = o.quotaLimits && Number(o.quotaLimits.resetsAt);
+          limitEvents.push({ ms, resetsAt: Number.isFinite(r) ? r : null });
+        }
+        // One API response is written as several lines sharing message.id: count it once.
+        const msg = o.message || {};
+        const model = typeof msg.model === 'string' ? msg.model : null;
+        const id = typeof msg.id === 'string' ? msg.id : null;
+        if (model && model !== '<synthetic>' && !o.isApiErrorMessage && (!id || !seenMessageIds.has(id))) {
+          if (id) seenMessageIds.add(id);
+          modelEvents.push({ ms, model });
+        }
+        if (Array.isArray(msg.content)) {
+          for (const b of msg.content) if (b && b.type === 'tool_use' && typeof b.name === 'string') toolEvents.push({ ms, name: normalizeToolName(b.name) });
+        }
+        const u = msg.usage;
+        if (id && u && !o.isApiErrorMessage) {
+          const n = (v) => (Number.isFinite(v) && v > 0 ? v : 0);
+          const out = n(u.output_tokens);
+          const total = out + n(u.input_tokens) + n(u.cache_read_input_tokens) + n(u.cache_creation_input_tokens);
+          const prev = usageById.get(id);
+          if (!prev) usageById.set(id, { ms, out, total });
+          else {
+            prev.out = Math.max(prev.out, out);
+            prev.total = Math.max(prev.total, total);
+          }
+        }
+      }
+
+      if (o.isSidechain) continue; // subagent work counts for models, tools and tokens, not activity or prompts
+      activity.push(ms);
+      projectLastMs.set(project, Math.max(projectLastMs.get(project) || 0, ms));
+      if (o.type === 'user' && isInterruptionLine(o)) interruptions.push(ms);
+
+      if (o.type === 'user') {
+        const kind = classifyUserLine(o);
+        if (kind) {
+          prompts.push(ms);
+          if (kind === 'human') quality.promptsFromOriginField++;
+          else quality.promptsFromLegacyHeuristic++;
+        }
+      }
+    }
+  }
+
+  activity.sort((a, b) => a - b);
+  prompts.sort((a, b) => a - b);
+  limitEvents.sort((a, b) => a.ms - b.ms);
+  return {
+    activity,
+    prompts,
+    modelEvents,
+    limitEvents,
+    errorSignalsSeen,
+    toolEvents,
+    usageEvents: [...usageById.values()],
+    subagentStarts: [...subagents.values()],
+    compactions,
+    turns,
+    interruptions,
+    projectLastActivity: [...projectLastMs.values()],
+    quality,
+  };
+}

package/scripts/lib/metrics.mjs

@@ -0,0 +1,267 @@
+// Turns collected timestamps into "symptoms". Pure and deterministic given (collected, options).
+import { WORDS_PER_TOKEN } from '../../assets/card.js';
+const WEEKDAYS = { Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6 };
+const DAY_MS = 86_400_000;
+
+/** Maps a UTC instant to the local calendar day / hour / weekday of `timeZone`. */
+export function makeClock(timeZone) {
+  const fmt = new Intl.DateTimeFormat('en-US', {
+    timeZone,
+    hourCycle: 'h23',
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    weekday: 'short',
+  });
+  const cache = new Map();
+  return (ms) => {
+    const bucket = Math.floor(ms / 900_000); // 15 min buckets are safe for every real UTC offset
+    let v = cache.get(bucket);
+    if (!v) {
+      const p = {};
+      for (const part of fmt.formatToParts(ms)) p[part.type] = part.value;
+      v = { day: `${p.year}-${p.month}-${p.day}`, hour: Number(p.hour) % 24, dow: WEEKDAYS[p.weekday], bucketMinute: (Number(p.hour) % 24) * 60 + Number(p.minute) };
+      cache.set(bucket, v);
+    }
+    // Every real UTC offset is a multiple of 15 min, so the local minute moves with the UTC one.
+    return { ...v, minuteOfDay: v.bucketMinute + Math.floor((ms % 900_000) / 60_000) };
+  };
+}
+
+const dayIndex = (day) => Math.round(Date.parse(`${day}T00:00:00Z`) / DAY_MS);
+const indexToDay = (i) => new Date(i * DAY_MS).toISOString().slice(0, 10);
+
+const metric = (value, extra = {}) => ({ available: true, value, ...extra });
+const missing = (reason) => ({ available: false, value: null, reason });
+
+export function modelFamily(model) {
+  const m = String(model).toLowerCase();
+  for (const f of ['opus', 'sonnet', 'haiku', 'fable']) if (m.includes(f)) return f;
+  return 'other';
+}
+
+/**
+ * @param collected output of collect()
+ * @param opts { now:number, timeZone:string, cleanupPeriodDays:number, maxDays?:number, config }
+ */
+export function computeMetrics(collected, opts) {
+  const { config, timeZone } = opts;
+  const clock = makeClock(timeZone);
+  const gapMs = config.sessionGapMinutes * 60_000;
+  const min = config.minSamples;
+
+  // --- Observation window -------------------------------------------------
+  // Claude Code deletes transcripts older than cleanupPeriodDays, but a session resumed
+  // recently keeps its old lines. Clamp to the retention window so a few ancient lines
+  // don't stretch the period (and dilute "active days").
+  const endDay = clock(opts.now).day;
+  const endIdx = dayIndex(endDay);
+  const limitDays = Math.max(1, Math.floor(opts.maxDays || opts.cleanupPeriodDays));
+  const earliestAllowedIdx = endIdx - limitDays + 1;
+  const inWindow = (ms) => {
+    const i = dayIndex(clock(ms).day);
+    return i >= earliestAllowedIdx && i <= endIdx;
+  };
+  const activity = collected.activity.filter(inWindow);
+  const prompts = collected.prompts.filter(inWindow);
+  const limitEvents = collected.limitEvents.filter((e) => inWindow(e.ms));
+
+  if (activity.length === 0 || prompts.length === 0) {
+    return { empty: true, window: { timeZone, cleanupPeriodDays: opts.cleanupPeriodDays, endDay } };
+  }
+  const startIdx = Math.max(earliestAllowedIdx, dayIndex(clock(activity[0]).day));
+  const windowDays = endIdx - startIdx + 1;
+  const firstRawIdx = collected.activity.length ? dayIndex(clock(collected.activity[0]).day) : startIdx;
+
+  const window = {
+    startDay: indexToDay(startIdx),
+    endDay,
+    days: windowDays,
+    timeZone,
+    cleanupPeriodDays: opts.cleanupPeriodDays,
+    clampedToRetention: firstRawIdx < earliestAllowedIdx,
+    likelyTruncatedByCleanup: startIdx === earliestAllowedIdx,
+  };
+
+  // --- Sessions & active time -----------------------------------------------
+  let sessions = 0;
+  let activeMs = 0;
+  let weekendMs = 0;
+  let longestSessionMs = 0;
+  let sessionStart = activity[0];
+  let prev = activity[0];
+  sessions = 1;
+  for (let i = 1; i < activity.length; i++) {
+    const t = activity[i];
+    const gap = t - prev;
+    if (gap > gapMs) {
+      longestSessionMs = Math.max(longestSessionMs, prev - sessionStart);
+      sessions++;
+      sessionStart = t;
+    } else {
+      activeMs += gap;
+      const dow = clock(prev).dow;
+      if (dow === 0 || dow === 6) weekendMs += gap;
+    }
+    prev = t;
+  }
+  longestSessionMs = Math.max(longestSessionMs, prev - sessionStart);
+
+  // --- Prompt-based stats -----------------------------------------------------
+  const activeDaySet = new Set();
+  const daily = new Array(windowDays).fill(0);
+  const byHour = new Array(24).fill(0);
+  const byWeekday = new Array(7).fill(0);
+  let night = 0;
+  for (const t of prompts) {
+    const c = clock(t);
+    const di = dayIndex(c.day);
+    activeDaySet.add(di);
+    daily[di - startIdx]++;
+    byHour[c.hour]++;
+    byWeekday[c.dow]++;
+    if (c.hour >= config.nightHours.start && c.hour < config.nightHours.end) night++;
+  }
+  const activeDayIdx = [...activeDaySet].sort((a, b) => a - b);
+  const activeDays = activeDayIdx.length;
+  let longestStreak = 0;
+  let run = 0;
+  for (let i = 0; i < activeDayIdx.length; i++) {
+    run = i > 0 && activeDayIdx[i] === activeDayIdx[i - 1] + 1 ? run + 1 : 1;
+    longestStreak = Math.max(longestStreak, run);
+  }
+  let currentStreak = 0;
+  for (let d = activeDaySet.has(endIdx) ? endIdx : endIdx - 1; activeDaySet.has(d); d--) currentStreak++;
+  const peakHour = byHour.indexOf(Math.max(...byHour));
+  const peakWeekday = byWeekday.indexOf(Math.max(...byWeekday));
+  const busiest = daily.indexOf(Math.max(...daily));
+
+  // --- Models ---------------------------------------------------------------
+  const families = {};
+  let modelMessages = 0;
+  for (const e of collected.modelEvents) {
+    if (!inWindow(e.ms)) continue;
+    const f = modelFamily(e.model);
+    families[f] = (families[f] || 0) + 1;
+    modelMessages++;
+  }
+
+  // --- Usage stats (fun facts, real numbers) -------------------------------
+  const toolCalls = {};
+  for (const e of collected.toolEvents) if (inWindow(e.ms)) toolCalls[e.name] = (toolCalls[e.name] || 0) + 1;
+  let outputTokens = 0;
+  let totalTokens = 0;
+  for (const u of collected.usageEvents) {
+    if (!inWindow(u.ms)) continue;
+    outputTokens += u.out;
+    totalTokens += u.total;
+  }
+  const turns = collected.turns.filter((t) => inWindow(t.ms));
+  // Latest prompt of the night: evening and night hours (18:00-05:59) ordered as one night.
+  let latestNight = null;
+  let earliestMorning = null;
+  for (const t of prompts) {
+    const m = clock(t).minuteOfDay;
+    if (m >= 18 * 60 || m < 6 * 60) {
+      const shifted = (m + 6 * 60) % (24 * 60);
+      if (latestNight === null || shifted > (latestNight + 6 * 60) % (24 * 60)) latestNight = m;
+    } else if (m < 12 * 60 && (earliestMorning === null || m < earliestMorning)) earliestMorning = m;
+  }
+  const usage = {
+    outputTokens,
+    totalTokens,
+    toolCalls,
+    subagents: collected.subagentStarts.filter(inWindow).length,
+    compactions: collected.compactions.filter(inWindow).length,
+    interruptions: collected.interruptions.filter(inWindow).length,
+    longestTurnMinutes: turns.reduce((mx, t) => Math.max(mx, t.durationMs), 0) / 60_000,
+    claudeHours: turns.reduce((sum, t) => sum + t.durationMs, 0) / 3_600_000,
+    projects: collected.projectLastActivity.filter(inWindow).length,
+    latestNightMinute: latestNight,
+    earliestMorningMinute: earliestMorning,
+  };
+
+  // --- Usage limits -----------------------------------------------------------
+  // One limit hit usually produces several error lines (retries, parallel sessions).
+  // Lines sharing the same reset time, or within an hour of each other, are one hit.
+  let limitHits = 0;
+  let lastMs = -Infinity;
+  const seenResets = new Set();
+  for (const e of limitEvents) {
+    if (e.resetsAt !== null) {
+      if (!seenResets.has(e.resetsAt)) limitHits++;
+      seenResets.add(e.resetsAt);
+    } else if (e.ms - lastMs > 3_600_000) {
+      limitHits++;
+    }
+    lastMs = e.ms;
+  }
+  const limitsDetectable = limitHits > 0 || collected.errorSignalsSeen;
+
+  const hours = activeMs / 3_600_000;
+  const enoughPrompts = prompts.length >= min.prompts;
+  const tooFewPrompts = `fewer than ${min.prompts} prompts in the observation window`;
+
+  const metrics = {
+    activeHoursPerActiveDay: metric(hours / activeDays, { totalActiveHours: hours, sessions, longestSessionHours: longestSessionMs / 3_600_000 }),
+    activeDaysShare:
+      windowDays >= min.windowDaysForRegularity
+        ? metric(activeDays / windowDays, { activeDays, windowDays })
+        : missing(`observation window shorter than ${min.windowDaysForRegularity} days`),
+    longestStreakDays:
+      windowDays >= min.windowDaysForRegularity
+        ? metric(longestStreak, { currentStreak })
+        : missing(`observation window shorter than ${min.windowDaysForRegularity} days`),
+    nightPromptShare: enoughPrompts ? metric(night / prompts.length, { nightPrompts: night }) : missing(tooFewPrompts),
+    promptsPerActiveDay: enoughPrompts ? metric(prompts.length / activeDays, { prompts: prompts.length, activeDays }) : missing(tooFewPrompts),
+    weekendActivityShare:
+      windowDays < min.windowDaysForWeekend
+        ? missing(`observation window shorter than ${min.windowDaysForWeekend} days`)
+        : activeMs > 0
+          ? metric(weekendMs / activeMs)
+          : missing('no measurable active time'),
+    limitHitsPer30Days: limitsDetectable
+      ? metric((limitHits * 30) / windowDays, { limitHits })
+      : missing('no rate-limit or API-error markers found in your transcripts (older Claude Code versions do not record them)'),
+    longestSessionHours: metric(longestSessionMs / 3_600_000),
+    subagentsPerActiveDay: metric(usage.subagents / activeDays, { subagents: usage.subagents }),
+    wordsPerActiveDay: outputTokens > 0
+      ? metric((outputTokens * WORDS_PER_TOKEN) / activeDays, { words: outputTokens * WORDS_PER_TOKEN })
+      : missing('no token usage recorded in your transcripts'),
+    opusShare:
+      modelMessages >= min.modelMessages
+        ? metric((families.opus || 0) / modelMessages, { modelMessages })
+        : missing(`fewer than ${min.modelMessages} model responses with a known model`),
+  };
+
+  const modelMix = Object.fromEntries(
+    Object.entries(families)
+      .sort((a, b) => b[1] - a[1])
+      .map(([f, n]) => [f, n / modelMessages]),
+  );
+
+  return {
+    empty: false,
+    window,
+    metrics,
+    usage,
+    extras: {
+      prompts: prompts.length,
+      activeDays,
+      sessions,
+      totalActiveHours: hours,
+      longestSessionHours: longestSessionMs / 3_600_000,
+      currentStreak,
+      peakHour,
+      peakWeekday,
+      busiestDay: { day: indexToDay(startIdx + busiest), prompts: daily[busiest] },
+      promptsByDay: daily,
+      promptsByHour: byHour,
+      promptsByWeekday: byWeekday,
+      modelMix,
+      limitHits: limitsDetectable ? limitHits : null,
+    },
+  };
+}