codexmeter 1.0.0

package/server/live-state.js

@@ -0,0 +1,464 @@
+import { CACHE_ASSUMPTIONS } from './cost-catalog.js';
+import { createDayKeyFormatter } from './day-key.js';
+
+export function createLiveAggregateState(tz) {
+  const now = Date.now() / 1000;
+  return {
+    tz,
+    lowerBounds: {
+      total: 0,
+      d7: now - 7 * 86400,
+      d30: now - 30 * 86400,
+    },
+    overview: {
+      total: createOverviewBucket(),
+      d7: createOverviewBucket(),
+      d30: createOverviewBucket(),
+    },
+    repos: {
+      total: new Map(),
+      d7: new Map(),
+      d30: new Map(),
+    },
+    repoTopKeys: createTopKeyRanges(),
+    models: {
+      total: new Map(),
+      d7: new Map(),
+      d30: new Map(),
+    },
+    modelTopKeys: createTopKeyRanges(),
+    families: {
+      total: new Map(),
+      d7: new Map(),
+      d30: new Map(),
+    },
+    familyTopKeys: createTopKeyRanges(),
+    daily: new Map(),
+    heatmap: new Map(),
+    toDayKey: createDayKeyFormatter(tz),
+  };
+}
+
+export function createEmptyLivePatch() {
+  return {
+    overview: new Set(),
+    repos: { total: new Set(), d7: new Set(), d30: new Set() },
+    models: { total: new Set(), d7: new Set(), d30: new Set() },
+    families: { total: new Set(), d7: new Set(), d30: new Set() },
+    daily: new Set(),
+    heatmap: new Set(),
+  };
+}
+
+export function applySessionToLiveState(live, session, patch) {
+  const rootId = session.root_thread_id || session.thread_id;
+
+  for (const rangeKey of ['total', 'd7', 'd30']) {
+    if (!overlapsLowerBound(session, live.lowerBounds[rangeKey])) continue;
+
+    applyOverviewBucket(live.overview[rangeKey], session, rootId);
+    patch.overview.add(rangeKey);
+
+    applyRepoBucket(live.repos[rangeKey], live.repoTopKeys[rangeKey], session, patch.repos[rangeKey]);
+    applyModelBucket(live.models[rangeKey], live.modelTopKeys[rangeKey], session, patch.models[rangeKey]);
+    applyFamilyBucket(live.families[rangeKey], live.familyTopKeys[rangeKey], session, patch.families[rangeKey]);
+  }
+
+  applyDailyBucket(live.daily, session, live.toDayKey, patch.daily);
+  applyHeatmapBucket(live.heatmap, session, live.toDayKey, patch.heatmap);
+}
+
+export function buildLiveBootstrap(live) {
+  return {
+    overview: serializeOverview(live),
+    repos: serializeTopRanges(live.repos, live.repoTopKeys, serializeRepoSummary),
+    models: serializeTopRanges(live.models, live.modelTopKeys, serializeModelSummary),
+    families: serializeTopRanges(live.families, live.familyTopKeys, serializeFamilySummary),
+    daily: serializeDaily(live.daily),
+    heatmap: serializeHeatmap(live.heatmap),
+  };
+}
+
+export function buildLivePatch(live, patch) {
+  return {
+    overview: Object.fromEntries(
+      [...patch.overview].map((rangeKey) => [rangeKey, serializeOverviewBucket(live.overview[rangeKey])])
+    ),
+    repos: serializePatchedTopRanges(live.repos, live.repoTopKeys, patch.repos, serializeRepoSummary),
+    models: serializePatchedTopRanges(live.models, live.modelTopKeys, patch.models, serializeModelSummary),
+    families: serializePatchedTopRanges(live.families, live.familyTopKeys, patch.families, serializeFamilySummary),
+    daily: Object.fromEntries([...patch.daily].map((dayKey) => [dayKey, serializeDailyEntry(live.daily.get(dayKey))])),
+    heatmap: Object.fromEntries([...patch.heatmap].map((dayKey) => [dayKey, serializeHeatmapEntry(live.heatmap.get(dayKey))])),
+  };
+}
+
+function createTopKeyRanges() {
+  return {
+    total: [],
+    d7: [],
+    d30: [],
+  };
+}
+
+function createOverviewBucket() {
+  return {
+    total_tokens: 0,
+    total_cost: 0,
+    total_elapsed_seconds: 0,
+    thread_rows: 0,
+    rootIds: new Set(),
+    repoSet: new Set(),
+    modelSet: new Set(),
+    enriched: 0,
+    priced: 0,
+    priced_exact: 0,
+    priced_fallback: 0,
+    unpriced: 0,
+    time_valid: 0,
+    earliest: Infinity,
+    latest: -Infinity,
+  };
+}
+
+function applyOverviewBucket(bucket, session, rootId) {
+  bucket.total_tokens += session.tokens_used || 0;
+  bucket.total_cost += session.cost || 0;
+  bucket.total_elapsed_seconds += session.elapsed_seconds || 0;
+  bucket.thread_rows += 1;
+  bucket.rootIds.add(rootId);
+  bucket.repoSet.add(session.repo_label || 'unknown');
+  if (session.model_name) {
+    bucket.modelSet.add(session.model_name);
+    bucket.enriched += 1;
+  }
+  if (session.cost !== null) {
+    bucket.priced += 1;
+    if (session.cost_source === 'exact') bucket.priced_exact += 1;
+    if (session.cost_source === 'heuristic') bucket.priced_fallback += 1;
+  } else {
+    bucket.unpriced += 1;
+  }
+  if (session.elapsed_seconds != null && session.elapsed_seconds > 0) bucket.time_valid += 1;
+  if (session.started_at && session.started_at < bucket.earliest) bucket.earliest = session.started_at;
+  if (session.ended_at && session.ended_at > bucket.latest) bucket.latest = session.ended_at;
+}
+
+function applyRepoBucket(repoMap, topKeys, session, dirtySet) {
+  const key = session.repo_label || 'unknown';
+  if (!repoMap.has(key)) {
+    repoMap.set(key, {
+      repo_key: session.repo_key,
+      repo_label: key,
+      tokens: 0,
+      cost: 0,
+      cost_known: 0,
+      exact_priced: 0,
+      heuristic_priced: 0,
+      sessions: 0,
+    });
+  }
+  const repo = repoMap.get(key);
+  repo.tokens += session.tokens_used || 0;
+  repo.sessions += 1;
+  if (session.cost !== null) {
+    repo.cost += session.cost;
+    repo.cost_known += 1;
+    if (session.cost_source === 'exact') repo.exact_priced += 1;
+    if (session.cost_source === 'heuristic') repo.heuristic_priced += 1;
+  }
+
+  updateTopKeys(repoMap, topKeys, key);
+  dirtySet.add(key);
+}
+
+function applyModelBucket(modelMap, topKeys, session, dirtySet) {
+  const key = session.model_name || 'unknown';
+  if (!modelMap.has(key)) {
+    modelMap.set(key, { model_name: key, tokens: 0, cost: 0, cost_known: 0, exact_priced: 0, heuristic_priced: 0, sessions: 0 });
+  }
+  const model = modelMap.get(key);
+  model.tokens += session.tokens_used || 0;
+  model.sessions += 1;
+  if (session.cost !== null) {
+    model.cost += session.cost;
+    model.cost_known += 1;
+    if (session.cost_source === 'exact') model.exact_priced += 1;
+    if (session.cost_source === 'heuristic') model.heuristic_priced += 1;
+  }
+
+  updateTopKeys(modelMap, topKeys, key);
+  dirtySet.add(key);
+}
+
+function applyFamilyBucket(familyMap, topKeys, session, dirtySet) {
+  const key = session.agent_family || 'generic';
+  if (!familyMap.has(key)) {
+    familyMap.set(key, { family: key, tokens: 0, cost: 0, exact_priced: 0, heuristic_priced: 0, sessions: 0 });
+  }
+  const family = familyMap.get(key);
+  family.tokens += session.tokens_used || 0;
+  family.sessions += 1;
+  if (session.cost !== null) {
+    family.cost += session.cost;
+    if (session.cost_source === 'exact') family.exact_priced += 1;
+    if (session.cost_source === 'heuristic') family.heuristic_priced += 1;
+  }
+  updateTopKeys(familyMap, topKeys, key);
+  dirtySet.add(key);
+}
+
+function applyDailyBucket(dayMap, session, toDayKey, dirtySet) {
+  if (!session.started_at || !session.ended_at) return;
+
+  const startMs = session.started_at * 1000;
+  const endMs = session.ended_at * 1000;
+  const totalDur = endMs - startMs;
+  if (totalDur > 0) {
+    const startDay = toDayKey(startMs);
+    const endDay = toDayKey(endMs - 1);
+
+    if (startDay === endDay) {
+      addToDay(dayMap, startDay, session, 1.0);
+      dirtySet.add(startDay);
+    } else {
+      let cursor = dayStartMs(startDay);
+      while (cursor < endMs) {
+        const nextDay = cursor + 86400000;
+        const overlapStart = Math.max(cursor, startMs);
+        const overlapEnd = Math.min(nextDay, endMs);
+        const fraction = (overlapEnd - overlapStart) / totalDur;
+        if (fraction > 0) {
+          const dayKey = toDayKey(cursor);
+          addToDay(dayMap, dayKey, session, fraction);
+          dirtySet.add(dayKey);
+        }
+        cursor = nextDay;
+      }
+    }
+  }
+
+  if (session.active_by_day) {
+    for (const [dayKey, seconds] of Object.entries(session.active_by_day)) {
+      const day = ensureDay(dayMap, dayKey);
+      day.elapsed_seconds += seconds || 0;
+      dirtySet.add(dayKey);
+    }
+  }
+}
+
+function applyHeatmapBucket(dayMap, session, toDayKey, dirtySet) {
+  if (session.started_at) {
+    const dayKey = toDayKey(session.started_at * 1000);
+    const day = ensureHeatmapDay(dayMap, dayKey);
+    day.tokens += session.tokens_used || 0;
+    if (session.cost !== null) day.cost += session.cost;
+    day.sessions += 1;
+    dirtySet.add(dayKey);
+  }
+
+  if (session.active_by_day) {
+    for (const [dayKey, seconds] of Object.entries(session.active_by_day)) {
+      const day = ensureHeatmapDay(dayMap, dayKey);
+      day.elapsed += seconds || 0;
+      dirtySet.add(dayKey);
+    }
+  }
+}
+
+function addToDay(dayMap, dayKey, session, fraction) {
+  const day = ensureDay(dayMap, dayKey);
+  day.tokens += (session.tokens_used || 0) * fraction;
+  if (session.cost !== null) day.cost += session.cost * fraction;
+  if (fraction > 0.001) day.sessions += 1;
+
+  const modelKey = session.model_name || 'unknown';
+  if (!day.by_model[modelKey]) day.by_model[modelKey] = { tokens: 0, cost: 0, elapsed_seconds: 0 };
+  day.by_model[modelKey].tokens += (session.tokens_used || 0) * fraction;
+  if (session.cost !== null) day.by_model[modelKey].cost += session.cost * fraction;
+}
+
+function ensureDay(dayMap, dayKey) {
+  if (!dayMap.has(dayKey)) {
+    dayMap.set(dayKey, { tokens: 0, cost: 0, elapsed_seconds: 0, sessions: 0, by_model: {} });
+  }
+  return dayMap.get(dayKey);
+}
+
+function ensureHeatmapDay(dayMap, dayKey) {
+  if (!dayMap.has(dayKey)) {
+    dayMap.set(dayKey, { tokens: 0, cost: 0, elapsed: 0, sessions: 0 });
+  }
+  return dayMap.get(dayKey);
+}
+
+function serializeOverview(live) {
+  return {
+    total: serializeOverviewBucket(live.overview.total),
+    d7: serializeOverviewBucket(live.overview.d7),
+    d30: serializeOverviewBucket(live.overview.d30),
+    cost_assumptions: CACHE_ASSUMPTIONS,
+  };
+}
+
+function serializeOverviewBucket(bucket) {
+  return {
+    total_tokens: bucket.total_tokens,
+    total_cost: bucket.total_cost,
+    total_sessions: bucket.rootIds.size,
+    active_repos: bucket.repoSet.size,
+    active_models: bucket.modelSet.size,
+    total_elapsed_seconds: bucket.total_elapsed_seconds,
+    date_range: {
+      from: bucket.earliest === Infinity ? null : bucket.earliest,
+      to: bucket.latest === -Infinity ? null : bucket.latest,
+    },
+    coverage: {
+      total: bucket.thread_rows,
+      thread_rows: bucket.thread_rows,
+      root_sessions: bucket.rootIds.size,
+      enriched: bucket.enriched,
+      priced: bucket.priced,
+      priced_exact: bucket.priced_exact,
+      priced_fallback: bucket.priced_fallback,
+      unpriced: bucket.unpriced,
+      time_valid: bucket.time_valid,
+    },
+  };
+}
+
+function serializeTopRanges(rangeMaps, topKeyRanges, projector) {
+  return {
+    total: serializeTopRange(rangeMaps.total, topKeyRanges.total, projector),
+    d7: serializeTopRange(rangeMaps.d7, topKeyRanges.d7, projector),
+    d30: serializeTopRange(rangeMaps.d30, topKeyRanges.d30, projector),
+  };
+}
+
+function serializePatchedTopRanges(rangeMaps, topKeyRanges, dirtyRanges, projector) {
+  const out = {};
+  for (const rangeKey of ['total', 'd7', 'd30']) {
+    if (dirtyRanges[rangeKey].size > 0) {
+      out[rangeKey] = serializeTopRange(rangeMaps[rangeKey], topKeyRanges[rangeKey], projector);
+    }
+  }
+  return out;
+}
+
+function serializeTopRange(map, topKeys, projector) {
+  return topKeys
+    .map((key) => map.get(key))
+    .filter(Boolean)
+    .map(projector);
+}
+
+function serializeDaily(dayMap) {
+  return Object.fromEntries([...dayMap.entries()].map(([dayKey, value]) => [dayKey, serializeDailyEntry(value)]));
+}
+
+function serializeDailyEntry(value) {
+  return {
+    tokens: Math.round(value?.tokens || 0),
+    cost: value?.cost || 0,
+    elapsed_seconds: Math.round(value?.elapsed_seconds || 0),
+    sessions: value?.sessions || 0,
+    by_model: deepRoundClone(value?.by_model || {}, ['tokens', 'cost', 'elapsed_seconds']),
+    approximate: true,
+  };
+}
+
+function serializeHeatmap(dayMap) {
+  return Object.fromEntries([...dayMap.entries()].map(([dayKey, value]) => [dayKey, serializeHeatmapEntry(value)]));
+}
+
+function serializeHeatmapEntry(value) {
+  return {
+    tokens: Math.round(value?.tokens || 0),
+    cost: value?.cost || 0,
+    elapsed: Math.round(value?.elapsed || 0),
+    sessions: value?.sessions || 0,
+  };
+}
+
+function deepRoundClone(source, numericKeys) {
+  const out = {};
+  for (const [key, value] of Object.entries(source)) {
+    out[key] = {};
+    for (const numKey of numericKeys) {
+      const nextValue = value?.[numKey] || 0;
+      out[key][numKey] = numKey === 'cost' ? nextValue : Math.round(nextValue);
+    }
+  }
+  return out;
+}
+
+function updateTopKeys(map, topKeys, key, limit = 6) {
+  if (!topKeys.includes(key)) {
+    if (topKeys.length < limit) {
+      topKeys.push(key);
+    } else {
+      const weakestKey = topKeys[topKeys.length - 1];
+      const weakestValue = map.get(weakestKey)?.tokens || 0;
+      const nextValue = map.get(key)?.tokens || 0;
+      if (nextValue <= weakestValue) return;
+      topKeys.push(key);
+    }
+  }
+
+  topKeys.sort((a, b) => {
+    const aValue = map.get(a)?.tokens || 0;
+    const bValue = map.get(b)?.tokens || 0;
+    if (bValue !== aValue) return bValue - aValue;
+    return String(a).localeCompare(String(b));
+  });
+
+  if (topKeys.length > limit) {
+    topKeys.length = limit;
+  }
+}
+
+function serializeRepoSummary(value) {
+  return {
+    repo_key: value.repo_key,
+    repo_label: value.repo_label,
+    tokens: value.tokens,
+    cost: value.cost,
+    cost_known: value.cost_known,
+    exact_priced: value.exact_priced,
+    heuristic_priced: value.heuristic_priced,
+    sessions: value.sessions,
+  };
+}
+
+function serializeModelSummary(value) {
+  return {
+    model_name: value.model_name,
+    tokens: value.tokens,
+    cost: value.cost,
+    cost_known: value.cost_known,
+    exact_priced: value.exact_priced,
+    heuristic_priced: value.heuristic_priced,
+    sessions: value.sessions,
+  };
+}
+
+function serializeFamilySummary(value) {
+  return {
+    family: value.family,
+    tokens: value.tokens,
+    cost: value.cost,
+    exact_priced: value.exact_priced,
+    heuristic_priced: value.heuristic_priced,
+    sessions: value.sessions,
+  };
+}
+
+function overlapsLowerBound(session, lowerBound) {
+  const startedAt = session.started_at || 0;
+  const endedAt = session.ended_at || startedAt;
+  return endedAt >= lowerBound;
+}
+
+function dayStartMs(dayKey) {
+  const [y, m, d] = dayKey.split('-').map(Number);
+  return new Date(y, m - 1, d).getTime();
+}

package/server/normalize.js

@@ -0,0 +1,72 @@
+const AGENT_FAMILY_MAP = {
+  review_plan: 'planning',
+  review_github: 'review',
+  'memory builder': 'memory',
+};
+
+const AGENT_FAMILY_PREFIX_RULES = [
+  { prefix: 'review_benchmark_', family: 'review' },
+  { prefix: 'review_', family: 'review' },
+  { prefix: 'review', family: 'review' },
+  { prefix: 'worker', family: 'generic' },
+  { prefix: 'explorer', family: 'exploration' },
+  { prefix: 'local_explorer', family: 'exploration' },
+  { prefix: 'web_explorer', family: 'exploration' },
+];
+
+export function normalizeCwd(cwd) {
+  if (!cwd) return '';
+  let p = cwd;
+  p = p.replace(/^\\\\\?\\/, '');
+  p = p.replace(/\\/g, '/');
+  if (/^[A-Z]:/.test(p)) p = p[0].toLowerCase() + p.slice(1);
+  p = p.toLowerCase();
+  p = p.replace(/\/+$/, '');
+  return p;
+}
+
+export function deriveRepoKey(normalizedCwd) {
+  const label = deriveRepoLabel(normalizedCwd);
+  return label === 'unknown' ? 'unknown' : `repo:${label}`;
+}
+
+export function deriveRepoLabel(normalizedCwd) {
+  if (!normalizedCwd) return 'unknown';
+  const worktreeMatch = normalizedCwd.match(/\.codex\/worktrees\/[^/]+\/([^/]+)/);
+  if (worktreeMatch) return collapseWorktreeLabel(worktreeMatch[1]);
+  if (normalizedCwd.includes('.codex')) return '.codex';
+  const segments = normalizedCwd.split('/').filter(Boolean);
+  return collapseWorktreeLabel(segments[segments.length - 1] || 'unknown');
+}
+
+function collapseWorktreeLabel(label) {
+  return String(label || '')
+    .replace(/-wt-[a-z0-9._-]+$/i, '')
+    .replace(/-worktree-[a-z0-9._-]+$/i, '')
+    .replace(/-worktrees?-[a-z0-9._-]+$/i, '') || 'unknown';
+}
+
+export function classifyAgentFamily(agentRole) {
+  if (!agentRole) return 'generic';
+  if (AGENT_FAMILY_MAP[agentRole]) return AGENT_FAMILY_MAP[agentRole];
+  for (const rule of AGENT_FAMILY_PREFIX_RULES) {
+    if (agentRole.startsWith(rule.prefix)) return rule.family;
+  }
+  if (agentRole === 'default' || agentRole === 'awaiter') return 'generic';
+  return 'generic';
+}
+
+export function isSubagent(agentRole) {
+  return agentRole != null && agentRole !== 'default';
+}
+
+const MODEL_ALIASES = {
+  'codex-mini-latest': 'o4-mini',
+  'gpt-5.2': 'gpt-5.2-codex',
+};
+
+export function normalizeModelName(rawModel) {
+  if (!rawModel) return null;
+  const lower = rawModel.toLowerCase().trim();
+  return MODEL_ALIASES[lower] || lower;
+}

package/server/pricing-fetch.js

@@ -0,0 +1,59 @@
+// Local pricing catalog for models used in codex-cli/codex app lifetime.
+const FALLBACK = {
+  'gpt-5.4':             { input: 2.50,  output: 15.00, cached_input: 0.25 },
+  'gpt-5.3-codex':       { input: 2.00,  output: 10.00, cached_input: 0.20 },
+  'gpt-5.3-codex-spark': { input: 2.00,  output: 10.00, cached_input: 0.20 },
+  'gpt-5.2-codex':       { input: 2.00,  output: 10.00, cached_input: 0.20 },
+  'gpt-5.2':             { input: 2.00,  output: 10.00, cached_input: 0.20 },
+  'gpt-5.1-codex-mini':  { input: 0.25,  output:  2.00, cached_input: 0.025},
+  'gpt-4.1':             { input: 2.00,  output:  8.00, cached_input: 0.50 },
+  'gpt-4.1-mini':        { input: 0.40,  output:  1.60, cached_input: 0.10 },
+  'gpt-4.1-nano':        { input: 0.10,  output:  0.40, cached_input: 0.025 },
+  'o3':                  { input: 2.00,  output:  8.00, cached_input: 0.50 },
+  'o3-mini':             { input: 1.10,  output:  4.40, cached_input: 0.275},
+  'o4-mini':             { input: 1.10,  output:  4.40, cached_input: 0.275},
+  'gpt-4o':              { input: 2.50,  output: 10.00, cached_input: 1.25 },
+  'gpt-4o-mini':         { input: 0.15,  output:  0.60, cached_input: 0.075},
+  'gpt-4-turbo':         { input: 10.00, output: 30.00, cached_input: 1.00 },
+  'gpt-4':               { input: 30.00, output: 60.00, cached_input: 3.00 },
+  'gpt-3.5-turbo':       { input: 0.50,  output:  1.50, cached_input: 0.05 },
+};
+
+const PRICING_URL = process.env.CODEXMETER_PRICING_URL || null;
+
+function normalizeEntry(entry) {
+  if (!entry || typeof entry !== 'object' || entry.input == null || entry.output == null) return null;
+  const cached = entry.cached_input ?? entry.cachedInput ?? entry.input * 0.1;
+  return { input: entry.input, output: entry.output, cached_input: cached };
+}
+
+function normalizePricing(raw) {
+  const models = raw?.models && typeof raw.models === 'object' ? raw.models : raw;
+  if (!models || typeof models !== 'object') return null;
+  const out = {};
+  for (const [name, entry] of Object.entries(models)) {
+    const norm = normalizeEntry(entry);
+    if (norm) out[name] = norm;
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
+
+export async function fetchPricing() {
+  if (!PRICING_URL) return FALLBACK;
+
+  try {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), 3000);
+    const res = await fetch(PRICING_URL, { signal: ctrl.signal });
+    clearTimeout(t);
+    if (!res.ok) return FALLBACK;
+    const data = await res.json();
+    const normalized = normalizePricing(data);
+    if (normalized) {
+      return { ...FALLBACK, ...normalized };
+    }
+  } catch {
+    // timeout, network error, invalid JSON - use fallback
+  }
+  return FALLBACK;
+}

package/server/rollout-reader.js

@@ -0,0 +1,108 @@
+import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+import { createDayKeyFormatter } from './day-key.js';
+
+const ACTIVE_GAP_CAP_MS = 15 * 60 * 1000;
+
+export async function enrichFromRollout(rolloutPath, opts = {}) {
+  if (!rolloutPath || !existsSync(rolloutPath)) {
+    return null;
+  }
+
+  const tz = opts.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const toDayKey = opts.toDayKey || createDayKeyFormatter(tz);
+  const result = {
+    model_name: null,
+    reasoning_effort: null,
+    first_timestamp: null,
+    last_timestamp: null,
+    active_seconds: null,
+    active_by_day: null,
+    parent_thread_id: null,
+    usage_total: null,
+  };
+
+  try {
+    const content = await readFile(rolloutPath, 'utf8');
+
+    let prevTimestamp = null;
+    let activeMs = 0;
+    const activeByDay = new Map();
+    for (const line of content.split(/\r?\n/)) {
+      if (!line.trim()) continue;
+
+      try {
+        const obj = JSON.parse(line);
+
+        if (obj.timestamp) {
+          const ts = new Date(obj.timestamp).getTime();
+          if (!isNaN(ts)) {
+            if (!result.first_timestamp || ts < result.first_timestamp) {
+              result.first_timestamp = ts;
+            }
+            if (!result.last_timestamp || ts > result.last_timestamp) {
+              result.last_timestamp = ts;
+            }
+            if (prevTimestamp !== null && ts >= prevTimestamp) {
+              const deltaMs = Math.min(ts - prevTimestamp, ACTIVE_GAP_CAP_MS);
+              activeMs += deltaMs;
+              if (deltaMs > 0) {
+                const dayKey = toDayKey(prevTimestamp);
+                activeByDay.set(dayKey, (activeByDay.get(dayKey) || 0) + deltaMs);
+              }
+            }
+            prevTimestamp = ts;
+          }
+        }
+
+        if (obj.type === 'event_msg' && obj.payload?.type === 'token_count') {
+          const usage = obj.payload.info?.total_token_usage;
+          if (usage) {
+            result.usage_total = {
+              input_tokens: usage.input_tokens || 0,
+              cached_input_tokens: usage.cached_input_tokens || 0,
+              output_tokens: usage.output_tokens || 0,
+              reasoning_output_tokens: usage.reasoning_output_tokens || 0,
+              total_tokens: usage.total_tokens || 0,
+            };
+          }
+        }
+
+        if (obj.type === 'turn_context' && obj.payload) {
+          const p = obj.payload;
+          if (p.model && !result.model_name) result.model_name = p.model;
+          if (p.effort && !result.reasoning_effort) result.reasoning_effort = p.effort;
+          if (p.collaboration_mode?.settings) {
+            const s = p.collaboration_mode.settings;
+            if (s.model && !result.model_name) result.model_name = s.model;
+            if (s.reasoning_effort && !result.reasoning_effort) result.reasoning_effort = s.reasoning_effort;
+          }
+        }
+
+        if (obj.type === 'session_meta' && obj.payload) {
+          if (obj.payload.model && !result.model_name) result.model_name = obj.payload.model;
+          if (!result.parent_thread_id) {
+            result.parent_thread_id =
+              obj.payload?.source?.subagent?.thread_spawn?.parent_thread_id ||
+              obj.payload?.forked_from_id ||
+              null;
+          }
+        }
+      } catch {
+        // malformed line
+      }
+
+    }
+    if (activeMs > 0) {
+      const activeByDaySeconds = Object.fromEntries(
+        [...activeByDay.entries()].map(([dayKey, ms]) => [dayKey, Math.round(ms / 1000)])
+      );
+      result.active_by_day = activeByDaySeconds;
+      result.active_seconds = Object.values(activeByDaySeconds).reduce((sum, seconds) => sum + seconds, 0);
+    }
+  } catch {
+    return null;
+  }
+
+  return result;
+}