codexmeter 1.0.7 → 1.0.9

package/server/normalize.js

@@ -60,9 +60,74 @@ export function isSubagent(agentRole) {
   return agentRole != null && agentRole !== 'default';
 }
 
+export function parseThreadSource(rawSource) {
+  if (!rawSource) return null;
+  if (typeof rawSource === 'object') return rawSource;
+  const text = String(rawSource).trim();
+  if (!text) return null;
+  if (text.startsWith('{') || text.startsWith('[')) {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return { kind: text };
+    }
+  }
+  return { kind: text };
+}
+
+export function deriveAgentRole(agentRole, rawSource, title = null) {
+  if (agentRole && agentRole !== 'default') return agentRole;
+  const source = parseThreadSource(rawSource);
+  if (source && typeof source === 'object' && typeof source.subagent === 'string') {
+    return source.subagent;
+  }
+  if (isReviewTaskTitle(title)) return 'review';
+  return null;
+}
+
+export function isReviewTaskTitle(title) {
+  if (typeof title !== 'string') return false;
+  const value = title.trim().toLowerCase();
+  return (
+    value.startsWith('review the code changes against the base branch ') ||
+    value.startsWith('you are reviewing a manually supplied diff artifact.') ||
+    value.startsWith('brief review for commit range ') ||
+    value.startsWith('independent brief review ') ||
+    value.startsWith('tight-scope integration review ') ||
+    value.startsWith('pr-scope review ') ||
+    value.startsWith('independent second-round pr review ') ||
+    value.startsWith('second independent pr-scope review ') ||
+    value.startsWith('implementation-review preflight ') ||
+    value.startsWith('implementation-review postflight ')
+  );
+}
+
+export function isReviewLauncherSession(session) {
+  if (session?.rollout_path && !session?.materialized) return false;
+  const source = parseThreadSource(session?.source_raw);
+  const sourceKind = source?.kind || (typeof source === 'string' ? source : null);
+  return isLauncherSourceKind(sourceKind) &&
+    isReviewTaskTitle(session?.title) &&
+    !session?.model_name &&
+    !session?.usage_total &&
+    !session?.has_usage_by_day &&
+    !session?.tokens_used;
+}
+
+function isLauncherSourceKind(sourceKind) {
+  const normalized = String(sourceKind || '').trim().toLowerCase();
+  return normalized === 'exec' ||
+    normalized === 'cli' ||
+    normalized.endsWith('-cli') ||
+    normalized.endsWith('_cli');
+}
+
 const MODEL_ALIASES = {
   'codex-mini-latest': 'o4-mini',
-  'gpt-5.2': 'gpt-5.2-codex',
+  'gpt-5 mini': 'gpt-5-mini',
+  'gpt-5.4 mini': 'gpt-5.4-mini',
+  'gpt-5 nano': 'gpt-5-nano',
+  'gpt-5.4 nano': 'gpt-5.4-nano',
 };
 
 export function normalizeModelName(rawModel) {

package/server/pricing-fetch.js

@@ -1,43 +1,47 @@
 // 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 },
-};
-
+  'gpt-5.4':             { input: 2.50,  output: 15.00, cached_input: 0.25 },
+  'gpt-5-mini':          { input: 0.75,  output:  4.50, cached_input: 0.075},
+  'gpt-5.4-mini':        { input: 0.75,  output:  4.50, cached_input: 0.075},
+  'gpt-5-nano':          { input: 0.15,  output:  0.60, cached_input: 0.015},
+  'gpt-5.4-nano':        { input: 0.15,  output:  0.60, cached_input: 0.015},
+  '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;
-}
-
+
+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;
 
@@ -45,15 +49,15 @@ export async function fetchPricing() {
     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;
-}
+    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

@@ -21,7 +21,9 @@ export async function enrichFromRollout(rolloutPath, opts = {}) {
     active_by_day: null,
     usage_by_day: null,
     parent_thread_id: null,
+    forked_from_id: null,
     usage_total: null,
+    usage_reset_detected: false,
   };
 
   try {
@@ -34,6 +36,8 @@ export async function enrichFromRollout(rolloutPath, opts = {}) {
     let lastInputTokens = 0;
     let lastCachedInputTokens = 0;
     let lastOutputTokens = 0;
+    let lastReasoningOutputTokens = 0;
+    let lastTotalTokens = 0;
     let hasSeenUsage = false;
     for (const line of content.split(/\r?\n/)) {
       if (!line.trim()) continue;
@@ -79,30 +83,54 @@ export async function enrichFromRollout(rolloutPath, opts = {}) {
               total_tokens: totalTokens,
             };
 
+            const hasReset =
+              hasSeenUsage &&
+              totalTokens < lastTotalTokens;
+
+            if (hasReset) {
+              usageByDay.clear();
+              result.usage_reset_detected = true;
+              result.first_usage_timestamp = null;
+              hasSeenUsage = false;
+              lastInputTokens = 0;
+              lastCachedInputTokens = 0;
+              lastOutputTokens = 0;
+              lastReasoningOutputTokens = 0;
+              lastTotalTokens = 0;
+            }
+
             const usageDelta = hasSeenUsage
               ? {
                   input_tokens: Math.max(inputTokens - lastInputTokens, 0),
                   cached_input_tokens: Math.max(cachedInputTokens - lastCachedInputTokens, 0),
                   output_tokens: Math.max(outputTokens - lastOutputTokens, 0),
+                  reasoning_output_tokens: Math.max(reasoningOutputTokens - lastReasoningOutputTokens, 0),
+                  total_tokens: Math.max(totalTokens - lastTotalTokens, 0),
                 }
               : {
                   input_tokens: inputTokens,
                   cached_input_tokens: cachedInputTokens,
                   output_tokens: outputTokens,
+                  reasoning_output_tokens: reasoningOutputTokens,
+                  total_tokens: totalTokens,
                 };
 
             hasSeenUsage = true;
             lastInputTokens = inputTokens;
             lastCachedInputTokens = cachedInputTokens;
             lastOutputTokens = outputTokens;
-            if (obj.timestamp && hasUsage(usageDelta)) {
+            lastReasoningOutputTokens = reasoningOutputTokens;
+            lastTotalTokens = totalTokens;
+            if (obj.timestamp && hasUsageBoundarySignal(usageDelta)) {
               const ts = new Date(obj.timestamp).getTime();
               if (!isNaN(ts)) {
                 if (!result.first_usage_timestamp || ts < result.first_usage_timestamp) {
                   result.first_usage_timestamp = ts;
                 }
-                const dayKey = toDayKey(ts);
-                mergeUsageTotals(usageByDay, dayKey, usageDelta);
+                if (hasUsage(usageDelta)) {
+                  const dayKey = toDayKey(ts);
+                  mergeUsageTotals(usageByDay, dayKey, usageDelta);
+                }
               }
             }
           }
@@ -121,6 +149,7 @@ export async function enrichFromRollout(rolloutPath, opts = {}) {
 
         if (obj.type === 'session_meta' && obj.payload) {
           if (obj.payload.model && !result.model_name) result.model_name = obj.payload.model;
+          if (!result.forked_from_id) result.forked_from_id = obj.payload?.forked_from_id || null;
           if (!result.parent_thread_id) {
             result.parent_thread_id =
               obj.payload?.source?.subagent?.thread_spawn?.parent_thread_id ||
@@ -150,6 +179,68 @@ export async function enrichFromRollout(rolloutPath, opts = {}) {
   return result;
 }
 
+export async function readUsageTimeline(rolloutPath) {
+  if (!rolloutPath || !existsSync(rolloutPath)) {
+    return [];
+  }
+
+  try {
+    const content = await readFile(rolloutPath, 'utf8');
+    const timeline = [];
+    let segmentId = 0;
+    let lastTotalTokens = 0;
+    let hasSeenUsage = false;
+    for (const line of content.split(/\r?\n/)) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type !== 'event_msg' || obj.payload?.type !== 'token_count') continue;
+        const usage = obj.payload.info?.total_token_usage;
+        if (!usage || !obj.timestamp) continue;
+        const ts = new Date(obj.timestamp).getTime();
+        if (isNaN(ts)) continue;
+        const normalizedUsage = normalizeUsageTotals(usage);
+        if (hasSeenUsage && normalizedUsage.total_tokens < lastTotalTokens) {
+          segmentId += 1;
+        }
+        timeline.push({
+          timestamp: ts,
+          segment_id: segmentId,
+          usage: normalizedUsage,
+        });
+        hasSeenUsage = true;
+        lastTotalTokens = normalizedUsage.total_tokens;
+      } catch {
+        // malformed line
+      }
+    }
+    timeline.sort((left, right) => left.timestamp - right.timestamp);
+    return timeline;
+  } catch {
+    return [];
+  }
+}
+
+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);
+  let best = null;
+  for (const entry of orderedTimeline) {
+    if ((entry?.timestamp || 0) <= timestampMs) {
+      best = entry;
+      continue;
+    }
+    break;
+  }
+  return best || null;
+}
+
+export function findUsageAtOrBefore(timeline, timestampMs) {
+  return findUsageEntryAtOrBefore(timeline, timestampMs)?.usage || null;
+}
+
 function normalizeUsageTotals(usage) {
   return {
     input_tokens: usage.input_tokens || 0,
@@ -160,16 +251,50 @@ function normalizeUsageTotals(usage) {
   };
 }
 
-function subtractUsageTotals(current, previous) {
+function splitUsageTotals(usage) {
+  const normalized = normalizeUsageTotals(usage || {});
+  const cachedInputTokens = Math.min(normalized.cached_input_tokens, normalized.input_tokens);
+  return {
+    uncached_input_tokens: Math.max(normalized.input_tokens - cachedInputTokens, 0),
+    cached_input_tokens: cachedInputTokens,
+    output_tokens: normalized.output_tokens,
+    reasoning_output_tokens: normalized.reasoning_output_tokens,
+  };
+}
+
+function combineUsageTotals(parts, currentTotalTokens = 0, previousTotalTokens = 0) {
+  const inputTokens = (parts.uncached_input_tokens || 0) + (parts.cached_input_tokens || 0);
+  const outputTokens = parts.output_tokens || 0;
   return {
-    input_tokens: Math.max((current.input_tokens || 0) - (previous.input_tokens || 0), 0),
-    cached_input_tokens: Math.max((current.cached_input_tokens || 0) - (previous.cached_input_tokens || 0), 0),
-    output_tokens: Math.max((current.output_tokens || 0) - (previous.output_tokens || 0), 0),
-    reasoning_output_tokens: Math.max((current.reasoning_output_tokens || 0) - (previous.reasoning_output_tokens || 0), 0),
-    total_tokens: Math.max((current.total_tokens || 0) - (previous.total_tokens || 0), 0),
+    input_tokens: inputTokens,
+    cached_input_tokens: parts.cached_input_tokens || 0,
+    output_tokens: outputTokens,
+    reasoning_output_tokens: parts.reasoning_output_tokens || 0,
+    total_tokens: Math.max(inputTokens + outputTokens, Math.max(currentTotalTokens - previousTotalTokens, 0)),
   };
 }
 
+export function subtractUsageTotals(current, previous) {
+  const currentParts = splitUsageTotals(current);
+  const previousParts = splitUsageTotals(previous);
+  return combineUsageTotals({
+    uncached_input_tokens: Math.max(currentParts.uncached_input_tokens - previousParts.uncached_input_tokens, 0),
+    cached_input_tokens: Math.max(currentParts.cached_input_tokens - previousParts.cached_input_tokens, 0),
+    output_tokens: Math.max(currentParts.output_tokens - previousParts.output_tokens, 0),
+    reasoning_output_tokens: Math.max(currentParts.reasoning_output_tokens - previousParts.reasoning_output_tokens, 0),
+  }, current?.total_tokens || 0, previous?.total_tokens || 0);
+}
+
+export function hasUsageTotals(usage) {
+  return !!usage && (
+    (usage.input_tokens || 0) > 0 ||
+    (usage.cached_input_tokens || 0) > 0 ||
+    (usage.output_tokens || 0) > 0 ||
+    (usage.reasoning_output_tokens || 0) > 0 ||
+    (usage.total_tokens || 0) > 0
+  );
+}
+
 function hasUsage(usage) {
   return !!usage && (
     usage.input_tokens > 0 ||
@@ -178,6 +303,10 @@ function hasUsage(usage) {
   );
 }
 
+function hasUsageBoundarySignal(usage) {
+  return hasUsage(usage) || (usage?.reasoning_output_tokens || 0) > 0 || (usage?.total_tokens || 0) > 0;
+}
+
 function mergeUsageTotals(target, dayKey, usage) {
   let previous = target.get(dayKey);
   if (!previous) {

package/server/sqlite-reader.js

@@ -35,7 +35,7 @@ export function readThreads(codexHome, onProgress) {
         rollout_path: row.rollout_path,
         created_at: row.created_at,
         updated_at: row.updated_at,
-        source: row.source,
+        source_raw: row.source,
         model_provider: row.model_provider,
         cwd_raw: row.cwd,
         title: row.title ? row.title.slice(0, 200) : '',