codexmeter 1.0.23 → 1.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codexmeter",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "description": "Local telemetry dashboard for Codex CLI usage",
   "type": "module",
   "bin": {

package/server/aggregator.js

@@ -11,7 +11,16 @@ function normalizeEffortKey(effort) {
   return k || 'unknown';
 }
 
-export function buildAggregates(sessions, tz, sessionView = null) {
+function modelKeyFor(session, opts = {}) {
+  const key = session.model_name || 'unknown';
+  if (key === 'unknown' && opts.includeUnknownModels === false) return null;
+  return key;
+}
+
+export function buildAggregates(sessions, tz, sessionView = null, opts = {}) {
+  const aggregateOpts = {
+    includeUnknownModels: opts.includeUnknownModels !== false,
+  };
   const now = Date.now() / 1000;
   const d7 = now - 7 * 86400;
   const d30 = now - 30 * 86400;
@@ -25,21 +34,21 @@ export function buildAggregates(sessions, tz, sessionView = null) {
 
   const overview = buildOverview(sessions, groupedSessions, d7, d30);
   const repos = {
-    total: buildRepos(rawBuckets.total),
-    d7: buildRepos(rawBuckets.d7),
-    d30: buildRepos(rawBuckets.d30),
+    total: buildRepos(rawBuckets.total, aggregateOpts),
+    d7: buildRepos(rawBuckets.d7, aggregateOpts),
+    d30: buildRepos(rawBuckets.d30, aggregateOpts),
   };
   const models = {
-    total: buildModels(rawBuckets.total),
-    d7: buildModels(rawBuckets.d7),
-    d30: buildModels(rawBuckets.d30),
+    total: buildModels(rawBuckets.total, aggregateOpts),
+    d7: buildModels(rawBuckets.d7, aggregateOpts),
+    d30: buildModels(rawBuckets.d30, aggregateOpts),
   };
   const families = {
     total: buildFamilies(rawBuckets.total),
     d7: buildFamilies(rawBuckets.d7),
     d30: buildFamilies(rawBuckets.d30),
   };
-  const daily = buildDaily(sessions, groupedSessions, tz);
+  const daily = buildDaily(sessions, groupedSessions, tz, aggregateOpts);
   const heatmap = buildHeatmap(sessions, groupedSessions, tz);
 
   return { overview, repos, models, daily, heatmap, families };
@@ -135,7 +144,7 @@ function buildOverview(rawSessions, groupedSessions, d7, d30) {
   };
 }
 
-function buildRepos(sessions) {
+function buildRepos(sessions, opts) {
   const map = new Map();
   for (const s of sessions) {
     const key = s.repo_label;
@@ -163,15 +172,17 @@ function buildRepos(sessions) {
     }
     r.sessions++;
 
-    const mKey = s.model_name || 'unknown';
-    if (!r.by_model[mKey]) r.by_model[mKey] = { tokens: 0, cost: 0, sessions: 0, exact_priced: 0, heuristic_priced: 0 };
-    r.by_model[mKey].tokens += s.tokens_used;
-    if (s.cost !== null) {
-      r.by_model[mKey].cost += s.cost;
-      if (s.cost_source === 'exact') r.by_model[mKey].exact_priced++;
-      if (s.cost_source === 'heuristic') r.by_model[mKey].heuristic_priced++;
+    const mKey = modelKeyFor(s, opts);
+    if (mKey) {
+      if (!r.by_model[mKey]) r.by_model[mKey] = { tokens: 0, cost: 0, sessions: 0, exact_priced: 0, heuristic_priced: 0 };
+      r.by_model[mKey].tokens += s.tokens_used;
+      if (s.cost !== null) {
+        r.by_model[mKey].cost += s.cost;
+        if (s.cost_source === 'exact') r.by_model[mKey].exact_priced++;
+        if (s.cost_source === 'heuristic') r.by_model[mKey].heuristic_priced++;
+      }
+      r.by_model[mKey].sessions++;
     }
-    r.by_model[mKey].sessions++;
 
     const fKey = s.agent_family;
     if (!r.by_family[fKey]) r.by_family[fKey] = { tokens: 0, cost: 0, sessions: 0, exact_priced: 0, heuristic_priced: 0 };
@@ -186,10 +197,11 @@ function buildRepos(sessions) {
   return [...map.values()].sort((a, b) => b.tokens - a.tokens);
 }
 
-function buildModels(sessions) {
+function buildModels(sessions, opts) {
   const map = new Map();
   for (const s of sessions) {
-    const key = s.model_name || 'unknown';
+    const key = modelKeyFor(s, opts);
+    if (!key) continue;
     if (!map.has(key)) map.set(key, { model_name: key, tokens: 0, cost: 0, cost_known: 0, exact_priced: 0, heuristic_priced: 0, sessions: 0, by_effort: {} });
     const m = map.get(key);
     m.tokens += s.tokens_used;
@@ -230,7 +242,7 @@ function buildFamilies(sessions) {
   return [...map.values()].sort((a, b) => b.tokens - a.tokens);
 }
 
-function buildDaily(rawSessions, groupedSessions, tz) {
+function buildDaily(rawSessions, groupedSessions, tz, opts) {
   const dayMap = new Map();
   for (const s of rawSessions) {
     if (!s.started_at || !s.ended_at) continue;
@@ -242,10 +254,10 @@ function buildDaily(rawSessions, groupedSessions, tz) {
 
     if (s.has_usage_by_day) {
       addSessionPresence(dayMap, startMs, endMs, totalDur, tz, s);
-      addUsageByDay(dayMap, s);
+      addUsageByDay(dayMap, s, opts);
     } else {
       for (const { dayKey, overlapMs } of splitIntervalByDay(startMs, endMs, tz)) {
-        addToDay(dayMap, dayKey, s, overlapMs / totalDur);
+        addToDay(dayMap, dayKey, s, overlapMs / totalDur, opts);
       }
     }
   }
@@ -253,7 +265,7 @@ function buildDaily(rawSessions, groupedSessions, tz) {
   for (const s of rawSessions) {
     if (!s.active_by_day) continue;
     for (const [dayKey, seconds] of Object.entries(s.active_by_day)) {
-      addElapsedToDay(dayMap, dayKey, s, seconds || 0);
+      addElapsedToDay(dayMap, dayKey, s, seconds || 0, opts);
     }
   }
 
@@ -278,17 +290,19 @@ function buildDaily(rawSessions, groupedSessions, tz) {
     }));
 }
 
-function addToDay(dayMap, dayKey, session, fraction) {
+function addToDay(dayMap, dayKey, session, fraction, opts) {
   if (!dayMap.has(dayKey)) dayMap.set(dayKey, { tokens: 0, cost: 0, elapsed_seconds: 0, sessions: 0, by_model: {}, by_family: {}, by_repo: {} });
   const d = dayMap.get(dayKey);
   d.tokens += session.tokens_used * fraction;
   if (session.cost !== null) d.cost += session.cost * fraction;
   if (fraction > 0.001) d.sessions++;
 
-  const mKey = session.model_name || 'unknown';
-  if (!d.by_model[mKey]) d.by_model[mKey] = { tokens: 0, cost: 0, elapsed_seconds: 0 };
-  d.by_model[mKey].tokens += session.tokens_used * fraction;
-  if (session.cost !== null) d.by_model[mKey].cost += session.cost * fraction;
+  const mKey = modelKeyFor(session, opts);
+  if (mKey) {
+    if (!d.by_model[mKey]) d.by_model[mKey] = { tokens: 0, cost: 0, elapsed_seconds: 0 };
+    d.by_model[mKey].tokens += session.tokens_used * fraction;
+    if (session.cost !== null) d.by_model[mKey].cost += session.cost * fraction;
+  }
 
   const fKey = session.agent_family;
   if (!d.by_family[fKey]) d.by_family[fKey] = { tokens: 0, cost: 0, elapsed_seconds: 0, sessions: 0 };
@@ -380,7 +394,7 @@ function addPresenceToDay(dayMap, dayKey, session, fraction) {
   if (fraction > 0.001) d.by_repo[rKey].sessions++;
 }
 
-function addUsageByDay(dayMap, session) {
+function addUsageByDay(dayMap, session, opts) {
   for (const usageDay of session.usage_by_day || []) {
     const dayKey = usageDay.day;
     if (!dayMap.has(dayKey)) dayMap.set(dayKey, { tokens: 0, cost: 0, elapsed_seconds: 0, sessions: 0, by_model: {}, by_family: {}, by_repo: {} });
@@ -388,10 +402,12 @@ function addUsageByDay(dayMap, session) {
     d.tokens += usageDay.tokens || 0;
     if (usageDay.cost !== null) d.cost += usageDay.cost;
 
-    const mKey = session.model_name || 'unknown';
-    if (!d.by_model[mKey]) d.by_model[mKey] = { tokens: 0, cost: 0, elapsed_seconds: 0 };
-    d.by_model[mKey].tokens += usageDay.tokens || 0;
-    if (usageDay.cost !== null) d.by_model[mKey].cost += usageDay.cost;
+    const mKey = modelKeyFor(session, opts);
+    if (mKey) {
+      if (!d.by_model[mKey]) d.by_model[mKey] = { tokens: 0, cost: 0, elapsed_seconds: 0 };
+      d.by_model[mKey].tokens += usageDay.tokens || 0;
+      if (usageDay.cost !== null) d.by_model[mKey].cost += usageDay.cost;
+    }
 
     const fKey = session.agent_family;
     if (!d.by_family[fKey]) d.by_family[fKey] = { tokens: 0, cost: 0, elapsed_seconds: 0, sessions: 0 };
@@ -405,15 +421,17 @@ function addUsageByDay(dayMap, session) {
   }
 }
 
-function addElapsedToDay(dayMap, dayKey, session, seconds) {
+function addElapsedToDay(dayMap, dayKey, session, seconds, opts) {
   if (!seconds) return;
   if (!dayMap.has(dayKey)) dayMap.set(dayKey, { tokens: 0, cost: 0, elapsed_seconds: 0, sessions: 0, by_model: {}, by_family: {}, by_repo: {} });
   const d = dayMap.get(dayKey);
   d.elapsed_seconds += seconds;
 
-  const mKey = session.model_name || 'unknown';
-  if (!d.by_model[mKey]) d.by_model[mKey] = { tokens: 0, cost: 0, elapsed_seconds: 0 };
-  d.by_model[mKey].elapsed_seconds += seconds;
+  const mKey = modelKeyFor(session, opts);
+  if (mKey) {
+    if (!d.by_model[mKey]) d.by_model[mKey] = { tokens: 0, cost: 0, elapsed_seconds: 0 };
+    d.by_model[mKey].elapsed_seconds += seconds;
+  }
 
   const fKey = session.agent_family || 'generic';
   if (!d.by_family[fKey]) d.by_family[fKey] = { tokens: 0, cost: 0, elapsed_seconds: 0, sessions: 0 };

package/server/ingest.js

@@ -132,7 +132,7 @@ export async function runIngest(codexHome, state, opts = {}) {
         agent_nickname: t.agent_nickname,
         agent_family: classifyAgentFamily(agentRole),
         is_subagent: isSubagent(agentRole),
-        parent_thread_id: null,
+        parent_thread_id: t.parent_thread_id || null,
         forked_from_id: null,
         cost: null,
         cost_source: 'unavailable',
@@ -142,6 +142,9 @@ export async function runIngest(codexHome, state, opts = {}) {
       });
     }
 
+    const sessionById = new Map(sessions.map((session) => [session.thread_id, session]));
+    inheritMissingLineageModels(sessions, sessionById);
+
     state.phase = 'enrichment';
     queueLiveProgress(state);
 
@@ -226,6 +229,7 @@ export async function runIngest(codexHome, state, opts = {}) {
         }
       }
 
+      inheritMissingLineageModels(batch, sessionById);
       await applyForkUsageCorrections(batch, resolveForkUsageSnapshot, FORK_CORRECTION_CONCURRENCY);
       for (const s of batch) {
         if (s._usage_by_day_raw) {
@@ -301,6 +305,7 @@ export async function runIngest(codexHome, state, opts = {}) {
       }
     }
 
+    inheritMissingLineageModels(sessions, sessionById);
     for (const s of sessions) {
       finalizeSessionMetrics(s, toDayKey);
     }
@@ -378,26 +383,55 @@ export function restartIngest(codexHome, state, opts = {}) {
 }
 
 function rebuildAggregates(sessions, state, opts, tz, mode = {}) {
-  const source = mode.partial ? sessions.filter(session => session.materialized) : sessions;
+  const source = mode.partial ? sessions.filter(isSafeForPartialAggregation) : sessions;
   const visibleSource = filterVisibleSessions(source);
   const filtered = applyFilters(visibleSource, opts);
   const sessionView = buildSessionView(filtered, source);
   state.sessions = sessionView;
-  state.aggregates = buildAggregates(filtered, tz, sessionView);
+  state.aggregates = buildAggregates(filtered, tz, sessionView, {
+    includeUnknownModels: mode.includeUnknownModels !== false,
+  });
   state.generated_at = new Date().toISOString();
 }
 
 function publishPartialAggregates(sessions, state, opts, tz, toDayKey) {
-  for (const session of sessions) {
-    finalizeSessionMetrics(session, toDayKey);
-  }
-  assignRootThreadIds(sessions, toDayKey);
-  rebuildAggregates(sessions, state, opts, tz);
+  const partialSessions = createPartialAggregateSessions(sessions, toDayKey);
+  rebuildAggregates(partialSessions, state, opts, tz, {
+    includeUnknownModels: false,
+  });
   state.partial_ready = true;
   state.percent = Math.max(state.percent, 0.081);
   queueLiveProgress(state);
 }
 
+export function createPartialAggregateSessions(sessions, toDayKey) {
+  assignRootThreadIds(sessions, toDayKey);
+  return sessions
+    .filter(isSafeForPartialAggregation)
+    .map((session) => {
+      const clone = { ...session };
+      const isUnparsedRollout = clone.rollout_path && !clone.materialized;
+      if (isUnparsedRollout) {
+        clone.model_name = null;
+        clone.cost = null;
+        clone.cost_source = 'unavailable';
+        clone.has_usage_by_day = true;
+        clone.usage_by_day = [];
+      }
+      finalizeSessionMetrics(clone, toDayKey);
+      if (isUnparsedRollout) {
+        clone.cost = null;
+        clone.cost_source = 'unavailable';
+      }
+      return clone;
+    });
+}
+
+export function isSafeForPartialAggregation(session) {
+  if (!session?.rollout_path || session.materialized) return true;
+  return !getForkLineageParentThreadId(session);
+}
+
 export function filterVisibleSessions(sessions) {
   return sessions.filter((session) => !isReviewLauncherSession(session));
 }
@@ -429,6 +463,33 @@ export function selectEnrichmentCandidates(sessions, opts = {}) {
   return [...warmup, ...recent, ...older];
 }
 
+export function inheritMissingLineageModels(targets, sessionById = new Map(targets.map((session) => [session.thread_id, session]))) {
+  const memo = new Map();
+  const resolving = new Set();
+
+  const resolveModel = (session) => {
+    if (!session) return null;
+    if (session.model_name) return session.model_name;
+    if (memo.has(session.thread_id)) return memo.get(session.thread_id);
+    if (resolving.has(session.thread_id)) return null;
+
+    resolving.add(session.thread_id);
+    const parent = sessionById.get(getForkLineageParentThreadId(session));
+    const modelName = resolveModel(parent);
+    if (modelName && !session.model_name) {
+      session.model_name = modelName;
+    }
+    resolving.delete(session.thread_id);
+
+    memo.set(session.thread_id, session.model_name || null);
+    return memo.get(session.thread_id);
+  };
+
+  for (const session of targets) {
+    resolveModel(session);
+  }
+}
+
 export function pickVisibleDateBucket(bufferedSessions, liveReadySessions) {
   return bufferedSessions[0]?.live_sort_day || liveReadySessions[0]?.live_sort_day || null;
 }
@@ -636,7 +697,7 @@ async function applyForkUsageCorrections(sessions, resolveForkUsageSnapshot, con
 }
 
 export function getForkLineageParentThreadId(session) {
-  return session?.forked_from_id || null;
+  return session?.forked_from_id || session?.parent_thread_id || null;
 }
 
 export function applyForkUsageCorrection(session, inheritedUsage) {

package/server/rollout-reader.js

@@ -14,6 +14,7 @@ const RG_RELEVANT_PATTERN =
 const RG_TOKEN_COUNT_PATTERN = '"type"\\s*:\\s*"token_count"';
 const RG_TIMESTAMP_PATTERN = '^\\{[^{}]*"timestamp"\\s*:\\s*"[^"]+"';
 const RG_ANY_TIMESTAMP_PATTERN = '"timestamp"\\s*:\\s*"[^"]+"';
+const SORTED_BY_TIMESTAMP = Symbol('codexmeter.sortedByTimestamp');
 
 export async function enrichFromRollout(rolloutPath, opts = {}) {
   if (!rolloutPath || !existsSync(rolloutPath)) {
@@ -266,6 +267,7 @@ export async function readUsageTimeline(rolloutPath, opts = {}) {
       }
     }
     timeline.sort((left, right) => left.timestamp - right.timestamp);
+    markTimelineSorted(timeline);
     return timeline;
   } catch {
     return [];
@@ -273,25 +275,55 @@ export async function readUsageTimeline(rolloutPath, opts = {}) {
 }
 
 export function findUsageEntryAtOrBefore(timeline, timestampMs) {
-  if (!Array.isArray(timeline) || !timeline.length || !timestampMs) return null;
-  const orderedTimeline = timeline.every((entry, index) => index === 0 || timeline[index - 1].timestamp <= entry.timestamp)
-    ? timeline
-    : [...timeline].sort((left, right) => left.timestamp - right.timestamp);
+  if (!Array.isArray(timeline) || !timeline.length || timestampMs == null) return null;
+  const target = Number(timestampMs);
+  if (!Number.isFinite(target)) return null;
+
+  const orderedTimeline = getTimestampOrderedTimeline(timeline);
+  let left = 0;
+  let right = orderedTimeline.length - 1;
   let best = null;
-  for (const entry of orderedTimeline) {
-    if ((entry?.timestamp || 0) <= timestampMs) {
+
+  while (left <= right) {
+    const mid = Math.floor((left + right) / 2);
+    const entry = orderedTimeline[mid];
+    if ((entry?.timestamp || 0) <= target) {
       best = entry;
-      continue;
+      left = mid + 1;
+    } else {
+      right = mid - 1;
     }
-    break;
   }
-  return best || null;
+
+  return best;
 }
 
 export function findUsageAtOrBefore(timeline, timestampMs) {
   return findUsageEntryAtOrBefore(timeline, timestampMs)?.usage || null;
 }
 
+function getTimestampOrderedTimeline(timeline) {
+  if (timeline[SORTED_BY_TIMESTAMP]) return timeline;
+  if (isTimestampSorted(timeline)) {
+    markTimelineSorted(timeline);
+    return timeline;
+  }
+  const orderedTimeline = [...timeline].sort((left, right) => left.timestamp - right.timestamp);
+  markTimelineSorted(orderedTimeline);
+  return orderedTimeline;
+}
+
+function isTimestampSorted(timeline) {
+  return timeline.every((entry, index) => index === 0 || timeline[index - 1].timestamp <= entry.timestamp);
+}
+
+function markTimelineSorted(timeline) {
+  Object.defineProperty(timeline, SORTED_BY_TIMESTAMP, {
+    value: true,
+    configurable: true,
+  });
+}
+
 function shouldUseRipgrep(rolloutPath, minBytes) {
   try {
     return statSync(rolloutPath).size >= minBytes;

package/server/sqlite-reader.js

@@ -14,14 +14,24 @@ export function readThreads(codexHome, onProgress) {
     const count = db.prepare('SELECT count(*) as c FROM threads').get().c;
     if (onProgress) onProgress({ total: count, read: 0 });
 
+    const hasThreadSpawnEdges = db.prepare(
+      'SELECT count(*) as c FROM sqlite_master WHERE type = ? AND name = ?'
+    ).get('table', 'thread_spawn_edges').c > 0;
+    const parentSelect = hasThreadSpawnEdges ? 'e.parent_thread_id' : 'NULL';
+    const parentJoin = hasThreadSpawnEdges
+      ? 'LEFT JOIN thread_spawn_edges e ON e.child_thread_id = t.id'
+      : '';
+
     const stmt = db.prepare(`
       SELECT
-        id, rollout_path, created_at, updated_at,
-        source, model_provider, model, reasoning_effort, cwd, title,
-        tokens_used, agent_nickname, agent_role,
-        cli_version, git_branch, git_origin_url
-      FROM threads
-      ORDER BY created_at ASC
+        t.id, t.rollout_path, t.created_at, t.updated_at,
+        t.source, t.model_provider, t.model, t.reasoning_effort, t.cwd, t.title,
+        t.tokens_used, t.agent_nickname, t.agent_role,
+        t.cli_version, t.git_branch, t.git_origin_url,
+        ${parentSelect} AS parent_thread_id
+      FROM threads t
+      ${parentJoin}
+      ORDER BY t.created_at ASC
     `);
 
     const threads = [];
@@ -41,6 +51,7 @@ export function readThreads(codexHome, onProgress) {
         tokens_used: row.tokens_used || 0,
         agent_nickname: row.agent_nickname || null,
         agent_role: row.agent_role || null,
+        parent_thread_id: row.parent_thread_id || null,
         cli_version: row.cli_version || '',
         git_branch: row.git_branch || null,
       });