tokentracker-cli 0.93.7 → 0.94.1

package/src/lib/session-analytics.js

@@ -31,6 +31,7 @@ const readline = require("node:readline");
 const { listClaudeProjectFiles, listRolloutFilesDeep, claudeMessageDedupKey } = require("./rollout");
 const { parseCodexRolloutFile } = require("./codex-rollout-parser");
 const { computeRowCost } = require("./pricing");
+const { USD_TICKS_PER_USD, normalizeGrokUsage } = require("./grok-usage");
 const wsl = require("./wsl-probe");
 
 // Bump the sidecar when derived metrics change so cached rows are rebuilt
@@ -54,7 +55,11 @@ const wsl = require("./wsl-probe");
 // stay valid while Grok entries appear on the next full rebuild.
 // v11 groups native/WSL copies of one logical Claude/Codex session and scans
 // their union, deduping shared records while retaining divergent tails.
-const SIDECAR_VERSION = 11;
+// v12 fixes Grok's mutually exclusive token columns, retains exact reported
+// cost, and adds metadata-only usage diagnostics to the local session browser.
+// v12 retains Codex parent/subagent metadata locally and derives exact child
+// token totals from observed child rollouts instead of spawn-call estimates.
+const SIDECAR_VERSION = 12;
 const EDIT_TOOLS = new Set([
   "apply_patch",
   "edit",
@@ -238,7 +243,12 @@ function finalizeRecord(record) {
   record.active_ms = Math.max(0, finite(record.active_ms));
   record.duration_ms = record.active_ms;
   record.total_tokens = finite(record.total_tokens || record.tokens?.total_tokens);
-  record.cost_usd = computeRowCost({ source: record.source, model: record.model, ...record.tokens });
+  const providerCost = Number(record.provider_cost_usd);
+  record.cost_usd = record.cost_source === "provider_reported"
+    && Number.isFinite(providerCost)
+    && providerCost >= 0
+    ? providerCost
+    : computeRowCost({ source: record.source, model: record.model, ...record.tokens });
   record.productive = record.edit_turns > 0;
   // A first-pass delivery has exactly one user turn containing an observed
   // edit and no repeated user request. The legacy one_shot field stays as an
@@ -511,6 +521,18 @@ async function scanCodexSession(filePath) {
     version: SIDECAR_VERSION,
     session_hash: sessionHash("codex", parsed.sessionId || primaryFilePath),
     session_id: parsed.sessionId || null,
+    // Local-only lineage. Codex v2 normally writes forked_from_id; keep
+    // parent_thread_id as a compatibility fallback, but reject disagreement.
+    parent_session_id: parsed.forkedFromId || parsed.parentThreadId || null,
+    parent_link_conflict: Boolean(
+      parsed.forkedFromId
+      && parsed.parentThreadId
+      && parsed.forkedFromId !== parsed.parentThreadId
+    ),
+    forked_from_id: parsed.forkedFromId || null,
+    thread_source: typeof parsed.threadSource === "string" ? parsed.threadSource : null,
+    agent_nickname: typeof parsed.agentNickname === "string" ? parsed.agentNickname : null,
+    agent_role: typeof parsed.agentRole === "string" ? parsed.agentRole : null,
     // Local-only: stripped in summarizeSessions before any cloud/CSV export.
     title,
     source: "codex",
@@ -569,42 +591,6 @@ function grokTimestampIso(obj) {
   return new Date(ms).toISOString();
 }
 
-// Grok reports inputTokens as the full prompt (including cache hits). Split so
-// pricing can apply cache_read rates correctly — same authority as the usage
-// parser and grok-context-breakdown.readUsageTotals. Prefer the reported
-// totalTokens; do not re-sum input+cached (that double-counts cache hits).
-function grokUsageTotals(usage) {
-  if (!usage || typeof usage !== "object") return emptyTotals();
-  const inputRaw = finite(usage.inputTokens ?? usage.input_tokens);
-  const cached_input_tokens = finite(
-    usage.cachedReadTokens ?? usage.cache_read_input_tokens ?? usage.cached_input_tokens,
-  );
-  const cache_creation_input_tokens = finite(
-    usage.cachedWriteTokens ?? usage.cache_creation_input_tokens,
-  );
-  const output_tokens = finite(usage.outputTokens ?? usage.output_tokens);
-  const reasoning_output_tokens = finite(
-    usage.reasoningTokens ?? usage.reasoning_output_tokens,
-  );
-  const input_tokens = Math.max(0, inputRaw - cached_input_tokens);
-  let total_tokens = finite(usage.totalTokens ?? usage.total_tokens);
-  if (total_tokens <= 0) {
-    total_tokens = input_tokens
-      + cached_input_tokens
-      + cache_creation_input_tokens
-      + output_tokens
-      + reasoning_output_tokens;
-  }
-  return {
-    input_tokens,
-    cached_input_tokens,
-    cache_creation_input_tokens,
-    output_tokens,
-    reasoning_output_tokens,
-    total_tokens,
-  };
-}
-
 function pickGrokModel(usage, fallback) {
   const modelUsage = usage?.modelUsage;
   if (modelUsage && typeof modelUsage === "object") {
@@ -704,6 +690,13 @@ async function scanGrokSession(filePath) {
   let currentHadEdit = false;
   let subagentCalls = 0;
   const subagentTypes = new Map();
+  let usageEvents = 0;
+  let providerCostEvents = 0;
+  let providerCostUsd = 0;
+  let modelCalls = 0;
+  let apiDurationMs = 0;
+  let usageIsIncomplete = false;
+  let costIsPartial = false;
   let lastPromptFingerprint = null;
   // Grok streams user_message_chunk pieces for one prompt. Accumulate until
   // turn_completed, then fingerprint the full prompt for retry detection.
@@ -772,7 +765,21 @@ async function scanGrokSession(filePath) {
     if (sessionUpdate === "turn_completed") {
       closeTurn();
       const usage = update.usage;
-      addTotals(tokens, grokUsageTotals(usage));
+      const normalizedUsage = normalizeGrokUsage(usage);
+      if (normalizedUsage) {
+        usageEvents += 1;
+        addTotals(tokens, normalizedUsage);
+        modelCalls += finite(normalizedUsage.model_calls);
+        apiDurationMs += finite(normalizedUsage.api_duration_ms);
+        usageIsIncomplete ||= normalizedUsage.usage_is_incomplete;
+        costIsPartial ||= normalizedUsage.cost_is_partial;
+        if (normalizedUsage.total_cost_usd != null) {
+          providerCostEvents += 1;
+          providerCostUsd = Math.round(
+            (providerCostUsd + normalizedUsage.total_cost_usd) * USD_TICKS_PER_USD,
+          ) / USD_TICKS_PER_USD;
+        }
+      }
       const candidate = pickGrokModel(usage, model);
       if (candidate && candidate !== "unknown") model = candidate;
       continue;
@@ -796,6 +803,11 @@ async function scanGrokSession(filePath) {
     model = normalizeSessionModel(signals.primaryModelId) || model;
   }
 
+  const hasCompleteProviderCost = usageEvents > 0
+    && providerCostEvents === usageEvents
+    && !usageIsIncomplete
+    && !costIsPartial;
+
   return finalizeRecord({
     version: SIDECAR_VERSION,
     session_hash: sessionHash("grok", observedSessionId || filePath),
@@ -813,7 +825,29 @@ async function scanGrokSession(filePath) {
     subagent_calls: subagentCalls,
     subagent_types: Object.fromEntries([...subagentTypes.entries()].sort()),
     tokens,
-    provenance: { source: "local-session-log", confidence: "observed", retry_confidence: "inferred", content_retained: false },
+    usage_events: usageEvents,
+    usage_precision: usageIsIncomplete ? "reported_incomplete" : (usageEvents > 0 ? "reported" : "unavailable"),
+    usage_is_incomplete: usageIsIncomplete,
+    cost_is_partial: costIsPartial,
+    cost_source: hasCompleteProviderCost ? "provider_reported" : "model_pricing",
+    provider_cost_usd: hasCompleteProviderCost ? providerCostUsd : null,
+    model_calls: modelCalls,
+    api_duration_ms: apiDurationMs,
+    context_tokens_used: finite(signals.contextTokensUsed),
+    context_window_tokens: finite(signals.contextWindowTokens),
+    context_usage_percent: finite(signals.contextWindowUsage),
+    tool_calls: finite(signals.toolCallCount),
+    tool_failures: finite(signals.toolFailureCount),
+    error_count: finite(signals.errorCount),
+    compaction_count: finite(signals.compactionCount),
+    provenance: {
+      source: "local-session-log",
+      confidence: usageIsIncomplete ? "partial" : "observed",
+      retry_confidence: "inferred",
+      content_retained: false,
+      usage: usageEvents > 0 ? "turn_completed.usage" : "unavailable",
+      cost: hasCompleteProviderCost ? "provider_reported" : "model_pricing",
+    },
   });
 }
 
@@ -829,7 +863,14 @@ function providerRoots(home, providerDir, env, deps = {}) {
   const discoverWslHome = deps.discoverWslHome || wsl.discoverWslHome;
   const roots = [];
   if (platform !== "win32" || wsl.shouldProbeNative(env)) {
-    roots.push(path.join(home, providerDir));
+    const useProcessCodexHome = providerDir === ".codex"
+      && path.resolve(home) === path.resolve(homedir())
+      && typeof env?.CODEX_HOME === "string"
+      && env.CODEX_HOME.trim();
+    const nativeRoot = useProcessCodexHome
+      ? path.resolve(env.CODEX_HOME.trim())
+      : path.join(home, providerDir);
+    roots.push(nativeRoot);
   }
   // Only the machine's own home has a WSL sibling worth probing.
   // discoverWslHome resolves \\wsl$ independently of `home`, so probing for an
@@ -1029,10 +1070,15 @@ function sessionFileStatKey(filePath) {
 const codexTitleIndexCache = new Map();
 
 function codexTitleIndexPathFor(filePath) {
-  const parts = path.resolve(filePath).split(path.sep);
-  const idx = parts.lastIndexOf(".codex");
-  if (idx === -1) return null;
-  return [...parts.slice(0, idx + 1), "session_index.jsonl"].join(path.sep);
+  let current = path.dirname(path.resolve(filePath));
+  while (true) {
+    if (["sessions", "archived_sessions"].includes(path.basename(current))) {
+      return path.join(path.dirname(current), "session_index.jsonl");
+    }
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
 }
 
 function loadCodexTitleIndex(filePath) {
@@ -1239,7 +1285,9 @@ function withinDayRange(row, from, to) {
 }
 
 function summarizeSessions(sessions, { from = "", to = "", includeSessions = true } = {}) {
-  const filtered = (sessions || []).filter((row) => withinDayRange(row, from, to));
+  const filtered = annotateCodexThreadUsage((sessions || [])
+    .filter((row) => withinDayRange(row, from, to))
+    .map((row) => ({ ...row })));
   const byModel = new Map();
   const subagents = new Map();
   for (const row of filtered) {
@@ -1268,6 +1316,26 @@ function summarizeSessions(sessions, { from = "", to = "", includeSessions = tru
       agg.edit_cost_usd += finite(row.cost_usd);
     }
     byModel.set(key, agg);
+    if (row.source === "codex" && row.parent_session_hash) {
+      const name = row.agent_role || row.agent_nickname || "subagent";
+      const sub = subagents.get(name) || {
+        name,
+        calls: 0,
+        sessions: 0,
+        total_tokens: 0,
+        cost_usd: 0,
+        attribution: "observed-child-session",
+      };
+      sub.calls += 1;
+      sub.sessions += 1;
+      sub.total_tokens += finite(row.total_tokens);
+      sub.cost_usd += finite(row.cost_usd);
+      subagents.set(name, sub);
+      continue;
+    }
+    // Codex child rollouts are first-class rows. A spawn call in the parent is
+    // a control-plane event, not token usage, so do not mix in an estimate.
+    if (row.source === "codex") continue;
     for (const [name, calls] of Object.entries(row.subagent_types || {})) {
       const sub = subagents.get(name) || { name, calls: 0, sessions: 0, total_tokens: 0, cost_usd: 0 };
       sub.calls += finite(calls);
@@ -1301,7 +1369,22 @@ function summarizeSessions(sessions, { from = "", to = "", includeSessions = tru
     // Git attribution and the local-only session browser, but never leave the
     // Node process through API/CSV payloads.
     sessions: includeSessions
-      ? filtered.map(({ project_ref: _projectRef, session_id: _sessionId, title: _title, _cache_key: _cacheKey, ...row }) => row)
+      ? filtered.map(({
+        project_ref: _projectRef,
+        session_id: _sessionId,
+        parent_session_id: _parentSessionId,
+        forked_from_id: _forkedFromId,
+        parent_session_hash: _parentSessionHash,
+        root_session_hash: _rootSessionHash,
+        agent_nickname: _agentNickname,
+        agent_role: _agentRole,
+        thread_source: _threadSource,
+        parent_link_conflict: _parentLinkConflict,
+        orphaned_subagent: _orphanedSubagent,
+        title: _title,
+        _cache_key: _cacheKey,
+        ...row
+      }) => row)
       : [],
     session_count: filtered.length,
     summary: {
@@ -1347,9 +1430,18 @@ function resumeCommandFor(source, sessionId) {
 }
 
 function toSessionBrowserRow(row) {
+  const tokens = row.tokens && typeof row.tokens === "object" ? row.tokens : {};
   return {
     session_hash: row.session_hash,
     session_id: row.session_id || null,
+    parent_session_id: row.parent_session_id || null,
+    parent_session_hash: row.parent_session_hash || null,
+    root_session_hash: row.root_session_hash || row.session_hash,
+    thread_kind: row.parent_session_id ? "subagent" : "root",
+    agent_nickname: row.agent_nickname || null,
+    agent_role: row.agent_role || null,
+    orphaned_subagent: Boolean(row.orphaned_subagent),
+    parent_link_conflict: Boolean(row.parent_link_conflict),
     title: row.title || null,
     source: row.source,
     project_key: row.project_key,
@@ -1364,8 +1456,35 @@ function toSessionBrowserRow(row) {
     edit_turns: finite(row.edit_turns),
     retry_turns: finite(row.retry_turns),
     subagent_calls: finite(row.subagent_calls),
+    input_tokens: finite(tokens.input_tokens),
+    cached_input_tokens: finite(tokens.cached_input_tokens),
+    cache_creation_input_tokens: finite(tokens.cache_creation_input_tokens),
+    output_tokens: finite(tokens.output_tokens),
+    reasoning_output_tokens: finite(tokens.reasoning_output_tokens),
+    direct_subagent_count: finite(row.direct_subagent_count),
+    descendant_subagent_count: finite(row.descendant_subagent_count),
+    own_total_tokens: finite(row.total_tokens),
+    subagent_total_tokens: finite(row.subagent_total_tokens),
+    combined_total_tokens: finite(row.combined_total_tokens || row.total_tokens),
     total_tokens: finite(row.total_tokens),
+    own_cost_usd: finite(row.cost_usd),
+    subagent_cost_usd: finite(row.subagent_cost_usd),
+    combined_cost_usd: finite(row.combined_cost_usd || row.cost_usd),
     cost_usd: finite(row.cost_usd),
+    cost_source: row.cost_source || null,
+    usage_precision: row.usage_precision || null,
+    usage_is_incomplete: Boolean(row.usage_is_incomplete),
+    cost_is_partial: Boolean(row.cost_is_partial),
+    usage_events: finite(row.usage_events),
+    model_calls: finite(row.model_calls),
+    api_duration_ms: finite(row.api_duration_ms),
+    context_tokens_used: finite(row.context_tokens_used),
+    context_window_tokens: finite(row.context_window_tokens),
+    context_usage_percent: finite(row.context_usage_percent),
+    tool_calls: finite(row.tool_calls),
+    tool_failures: finite(row.tool_failures),
+    error_count: finite(row.error_count),
+    compaction_count: finite(row.compaction_count),
     productive: Boolean(row.productive),
     first_pass: Boolean(row.first_pass ?? row.one_shot),
     resume_command: resumeCommandFor(row.source, row.session_id),
@@ -1384,18 +1503,46 @@ function mergeSessionFragments(rows) {
     const key = row.session_hash;
     const cur = byHash.get(key);
     if (!cur) {
-      byHash.set(key, { ...row, _repr_tokens: finite(row.total_tokens) });
+      byHash.set(key, {
+        ...row,
+        tokens: row.tokens && typeof row.tokens === "object" ? { ...row.tokens } : emptyTotals(),
+        _repr_tokens: finite(row.total_tokens),
+      });
       continue;
     }
     cur.turns = finite(cur.turns) + finite(row.turns);
     cur.edit_turns = finite(cur.edit_turns) + finite(row.edit_turns);
     cur.retry_turns = finite(cur.retry_turns) + finite(row.retry_turns);
     cur.subagent_calls = finite(cur.subagent_calls) + finite(row.subagent_calls);
+    addTotals(cur.tokens, row.tokens);
     cur.total_tokens = finite(cur.total_tokens) + finite(row.total_tokens);
     cur.cost_usd = finite(cur.cost_usd) + finite(row.cost_usd);
+    cur.provider_cost_usd = finite(cur.provider_cost_usd) + finite(row.provider_cost_usd);
+    cur.usage_events = finite(cur.usage_events) + finite(row.usage_events);
+    cur.model_calls = finite(cur.model_calls) + finite(row.model_calls);
+    cur.api_duration_ms = finite(cur.api_duration_ms) + finite(row.api_duration_ms);
+    cur.tool_calls = finite(cur.tool_calls) + finite(row.tool_calls);
+    cur.tool_failures = finite(cur.tool_failures) + finite(row.tool_failures);
+    cur.error_count = finite(cur.error_count) + finite(row.error_count);
+    cur.compaction_count = finite(cur.compaction_count) + finite(row.compaction_count);
+    cur.context_tokens_used = Math.max(finite(cur.context_tokens_used), finite(row.context_tokens_used));
+    cur.context_window_tokens = Math.max(finite(cur.context_window_tokens), finite(row.context_window_tokens));
+    cur.context_usage_percent = Math.max(finite(cur.context_usage_percent), finite(row.context_usage_percent));
+    cur.usage_is_incomplete = Boolean(cur.usage_is_incomplete) || Boolean(row.usage_is_incomplete);
+    cur.cost_is_partial = Boolean(cur.cost_is_partial) || Boolean(row.cost_is_partial);
+    if (cur.usage_precision !== row.usage_precision) cur.usage_precision = "mixed";
+    if (cur.cost_source !== row.cost_source) cur.cost_source = "mixed";
     cur.productive = Boolean(cur.productive) || Boolean(row.productive);
     cur.active_ms = finite(cur.active_ms) + finite(row.active_ms);
     if (!cur.title && row.title) cur.title = row.title;
+    if (!cur.parent_session_id && row.parent_session_id) cur.parent_session_id = row.parent_session_id;
+    if (cur.parent_session_id && row.parent_session_id && cur.parent_session_id !== row.parent_session_id) {
+      cur.parent_session_id = null;
+      cur.parent_link_conflict = true;
+    }
+    if (!cur.forked_from_id && row.forked_from_id) cur.forked_from_id = row.forked_from_id;
+    if (!cur.agent_nickname && row.agent_nickname) cur.agent_nickname = row.agent_nickname;
+    if (!cur.agent_role && row.agent_role) cur.agent_role = row.agent_role;
     // Representative model/project comes from the busiest fragment (most
     // tokens) so a tiny sidechain cannot overwrite the real coding model.
     if (finite(row.total_tokens) > finite(cur._repr_tokens)) {
@@ -1427,19 +1574,127 @@ function mergeSessionFragments(rows) {
   return merged;
 }
 
+// Attach exact Codex parent/child usage without changing the authoritative
+// per-session total_tokens field. Combined fields are derived views only, so
+// summing total_tokens across all rows still equals the global usage ledger.
+function annotateCodexThreadUsage(rows) {
+  const byId = new Map();
+  const childrenById = new Map();
+  const linkedParentById = new Map();
+
+  for (const row of rows || []) {
+    if (row?.source !== "codex" || typeof row.session_id !== "string" || !row.session_id) continue;
+    const existing = byId.get(row.session_id);
+    if (existing && existing !== row) {
+      existing.parent_link_conflict = true;
+      row.parent_link_conflict = true;
+      continue;
+    }
+    byId.set(row.session_id, row);
+  }
+
+  function hasParentCycle(start) {
+    const seen = new Set();
+    let current = start;
+    while (current?.parent_session_id && byId.has(current.parent_session_id)) {
+      if (seen.has(current.session_id) || current.parent_session_id === current.session_id) return true;
+      seen.add(current.session_id);
+      current = byId.get(current.parent_session_id);
+    }
+    return false;
+  }
+
+  for (const row of byId.values()) {
+    const parentId = typeof row.parent_session_id === "string" ? row.parent_session_id.trim() : "";
+    if (!parentId) continue;
+    if (row.parent_link_conflict || hasParentCycle(row)) {
+      row.parent_link_conflict = true;
+      continue;
+    }
+    if (!byId.has(parentId)) {
+      row.orphaned_subagent = true;
+      continue;
+    }
+    const children = childrenById.get(parentId) || [];
+    children.push(row);
+    childrenById.set(parentId, children);
+    linkedParentById.set(row.session_id, parentId);
+  }
+
+  const memo = new Map();
+  function aggregate(row, visiting = new Set()) {
+    if (memo.has(row.session_id)) return memo.get(row.session_id);
+    if (visiting.has(row.session_id)) {
+      row.parent_link_conflict = true;
+      return { count: 0, tokens: 0, cost: 0 };
+    }
+    const nextVisiting = new Set(visiting);
+    nextVisiting.add(row.session_id);
+    let count = 0;
+    let tokens = 0;
+    let cost = 0;
+    for (const child of childrenById.get(row.session_id) || []) {
+      const nested = aggregate(child, nextVisiting);
+      count += 1 + nested.count;
+      tokens += finite(child.total_tokens) + nested.tokens;
+      cost += finite(child.cost_usd) + nested.cost;
+    }
+    const result = { count, tokens, cost };
+    memo.set(row.session_id, result);
+    return result;
+  }
+
+  function rootFor(row) {
+    const seen = new Set([row.session_id]);
+    let current = row;
+    while (current && linkedParentById.has(current.session_id)) {
+      const linkedParentId = linkedParentById.get(current.session_id);
+      if (seen.has(linkedParentId)) {
+        row.parent_link_conflict = true;
+        break;
+      }
+      seen.add(linkedParentId);
+      current = byId.get(linkedParentId);
+    }
+    return current || row;
+  }
+
+  for (const row of rows || []) {
+    row.own_total_tokens = finite(row.total_tokens);
+    row.own_cost_usd = finite(row.cost_usd);
+    row.direct_subagent_count = row.source === "codex" && row.session_id
+      ? (childrenById.get(row.session_id) || []).length
+      : 0;
+    const nested = row.source === "codex" && row.session_id
+      ? aggregate(row)
+      : { count: 0, tokens: 0, cost: 0 };
+    row.descendant_subagent_count = nested.count;
+    row.subagent_total_tokens = nested.tokens;
+    row.subagent_cost_usd = nested.cost;
+    row.combined_total_tokens = finite(row.total_tokens) + nested.tokens;
+    row.combined_cost_usd = finite(row.cost_usd) + nested.cost;
+    if (row.source === "codex" && row.session_id) {
+      const parent = byId.get(linkedParentById.get(row.session_id));
+      row.parent_session_hash = parent?.session_hash || null;
+      row.root_session_hash = rootFor(row).session_hash || row.session_hash;
+    }
+  }
+  return rows;
+}
+
 // Local-only session list for the dashboard session browser. Unlike
 // summarizeSessions (cloud/CSV safe), this retains session_id + project_ref so
 // the UI can offer one-click resume. Callers must only expose it over the
 // local API.
 function listSessionsForBrowser(sessions, { from = "", to = "", limit = 0 } = {}) {
-  const filtered = mergeSessionFragments(sessions)
+  const filtered = annotateCodexThreadUsage(mergeSessionFragments(sessions)
     // Only sessions that actually spent tokens are worth listing. This drops
     // two kinds of noise: non-session logs under ~/.claude/projects
     // (skill-injections.jsonl, journal.jsonl, …), and sessions abandoned before
     // the model replied. Both render as "unknown · 0 tokens · $0.00" rows with
     // no model, no cost and nothing to analyze.
     .filter((row) => finite(row.total_tokens) > 0)
-    .filter((row) => withinDayRange(row, from, to));
+    .filter((row) => withinDayRange(row, from, to)));
   filtered.sort((a, b) => String(b.ended_at || "").localeCompare(String(a.ended_at || "")));
   const cap = Number(limit) > 0 ? Number(limit) : 0;
   const limited = cap > 0 ? filtered.slice(0, cap) : filtered;

package/src/lib/telemetry.js

@@ -6,7 +6,7 @@
  * Privacy contract (documented in README "Privacy" section — keep in sync):
  * the payload carries exactly four fields — a one-way sha256 hash of the
  * machine id, the app version, `process.platform`, and the app shell
- * (cli / macos / windows). No token counts, no model names, no usernames,
+ * (cli / macos / windows / linux). No token counts, no model names, no usernames,
  * no paths. Opt out with TOKENTRACKER_NO_TELEMETRY=1, the DO_NOT_TRACK
  * standard, or `"telemetry": false` in config.json.
  */
@@ -35,7 +35,7 @@ const MACHINE_HASH_NAMESPACE = "tokentracker-telemetry-v1:";
 // cloud host; sync awaits this at most once per day so the worst-case stall
 // is bounded and rare.
 const DEFAULT_TIMEOUT_MS = 10_000;
-const VALID_SHELLS = new Set(["cli", "macos", "windows"]);
+const VALID_SHELLS = new Set(["cli", "macos", "windows", "linux"]);
 
 const THROTTLE_CONFIG = {
   intervalMs: HEARTBEAT_INTERVAL_MS,

package/src/lib/usage-limits.js

@@ -1882,20 +1882,30 @@ function describeCopilotOtelStatus({ home, env = process.env } = {}) {
   const explicitPath = typeof env.COPILOT_OTEL_FILE_EXPORTER_PATH === "string"
     ? env.COPILOT_OTEL_FILE_EXPORTER_PATH
     : "";
-  const defaultDir = path.join(resolvedHome, ".copilot", "otel");
-  let hasFiles = false;
-  try {
-    if (fs.existsSync(defaultDir)) {
-      hasFiles = fs.readdirSync(defaultDir).some((entry) => entry.endsWith(".jsonl"));
-    }
-  } catch (_e) {}
-  if (!hasFiles && explicitPath && fs.existsSync(explicitPath)) hasFiles = true;
+  const defaultDirs = [
+    path.join(resolvedHome, ".copilot", "otel"),
+    path.join(resolvedHome, ".copilot-otel"),
+  ];
+  const detectedPaths = [];
+  for (const defaultDir of defaultDirs) {
+    try {
+      if (!fs.existsSync(defaultDir)) continue;
+      for (const entry of fs.readdirSync(defaultDir)) {
+        if (entry.endsWith(".jsonl")) {
+          detectedPaths.push(path.join(defaultDir, entry));
+        }
+      }
+    } catch (_e) {}
+  }
+  if (explicitPath && fs.existsSync(explicitPath)) detectedPaths.push(explicitPath);
   return {
     otel_enabled: enabled && (exporterType === "" || exporterType === "file"),
     otel_exporter_type: exporterType || null,
     otel_path: explicitPath || null,
-    otel_default_dir: defaultDir,
-    otel_has_files: hasFiles,
+    otel_default_dir: defaultDirs[0],
+    otel_default_dirs: defaultDirs,
+    otel_detected_paths: detectedPaths,
+    otel_has_files: detectedPaths.length > 0,
   };
 }
 

package/dashboard/dist/assets/DialogDescription-DPyhpdeR.js

@@ -1 +0,0 @@
-import{r as n,z as a}from"./__vite-browser-external-CsbVaBbw.js";import{u as p}from"./DialogTitle-BkAmJrQ_.js";import{u as c}from"./composite-MhgOkYfv.js";const x=n.forwardRef(function(e,r){const{render:l,className:u,style:m,id:s,...t}=e,i=p(),o=c(s);return i.useSyncedValueWithCleanup("descriptionElementId",o),a("p",e,{ref:r,props:[{id:o},t]})});export{x as D};