@yancyyu/openhermit 1.6.41 → 1.6.43

package/src/main/services/runtime/providerAwareCliEnv.ts

@@ -2,20 +2,33 @@
  * Provider-aware CLI environment builder.
  *
  * Builds an enriched environment for CLI processes that accounts for
- * provider-specific configuration (API keys, base URLs, etc.).
+ * provider-specific configuration (API keys, base URLs, etc.), and resolves the
+ * provider launch fields (model, effort, worktree, ...) into concrete CLI args
+ * via {@link resolveProviderLaunchArgs}.
  *
  * NOTE: The full source in claude_agent_teams_ui depends on several services
  * not yet available in this project (ProviderConnectionService, OpenCodeRuntime,
- * codex-runtime-installer). This module provides the core interface and
- * environment building, falling back gracefully when those services are absent.
+ * codex-runtime-installer). This module provides the core interface, environment
+ * building, and provider arg resolution, falling back gracefully when those
+ * services are absent.
  */
 
 import { buildEnrichedEnv } from '@main/utils/cliEnv';
+import { resolveProviderLaunchArgs } from '@shared/utils/providerLaunchArgs';
+
+import type { EffortLevel, TeamProviderId } from '@shared/types';
 
 export interface ProviderAwareCliEnvOptions {
   binaryPath?: string | null;
   providerId?: string;
   providerBackendId?: string | null;
+  model?: string | null;
+  effort?: EffortLevel | null;
+  skipPermissions?: boolean;
+  worktree?: string;
+  extraCliArgs?: string;
+  limitContext?: boolean;
+  clearContext?: boolean;
   shellEnv?: NodeJS.ProcessEnv | null;
   env?: NodeJS.ProcessEnv;
   connectionMode?: 'strict' | 'augment';
@@ -52,9 +65,24 @@ export async function buildProviderAwareCliEnv(
     }
   }
 
+  // Resolve provider launch fields into concrete CLI args. When no provider/model
+  // information is supplied, the resolver returns an empty arg list (backward
+  // compatible with callers that only need the enriched env).
+  const resolution = resolveProviderLaunchArgs({
+    providerId: options.providerId as TeamProviderId | undefined,
+    providerBackendId: options.providerBackendId ?? null,
+    model: options.model,
+    effort: options.effort,
+    skipPermissions: options.skipPermissions,
+    worktree: options.worktree,
+    extraCliArgs: options.extraCliArgs,
+    limitContext: options.limitContext,
+    clearContext: options.clearContext,
+  });
+
   return {
     env,
-    connectionIssues: {},
-    providerArgs: [],
+    connectionIssues: resolution.connectionIssues,
+    providerArgs: resolution.providerArgs,
   };
 }

package/src/main/services/session-intelligence/LocalSessionScanner.ts

@@ -11,7 +11,7 @@ import { readdir, stat } from 'node:fs/promises';
 import { createInterface } from 'node:readline';
 import * as path from 'node:path';
 
-import { getProjectsBasePath, encodePath } from '@main/utils/pathDecoder';
+import { getProjectDirNameCandidates, getProjectsBasePath } from '@main/utils/pathDecoder';
 
 // ---------------------------------------------------------------------------
 // Types
@@ -28,6 +28,7 @@ export interface LocalSessionSummary {
   outputTokens: number;
   cacheReadTokens: number;
   cacheCreationTokens: number;
+  totalTokens: number;
   model: string;
   active: boolean;
   live: boolean;
@@ -58,6 +59,9 @@ export interface LocalSessionDetail {
   model: string;
   inputTokens: number;
   outputTokens: number;
+  cacheReadTokens: number;
+  cacheCreationTokens: number;
+  totalTokens: number;
 }
 
 // ---------------------------------------------------------------------------
@@ -186,7 +190,11 @@ async function* walkJsonl(dir: string): AsyncGenerator<string> {
     const full = path.join(dir, entry.name);
     if (entry.isDirectory()) {
       yield* walkJsonl(full);
-    } else if (entry.isFile() && entry.name.endsWith('.jsonl') && !entry.name.startsWith('agent_')) {
+    } else if (
+      entry.isFile() &&
+      entry.name.endsWith('.jsonl') &&
+      !entry.name.startsWith('agent_')
+    ) {
       yield full;
     }
   }
@@ -251,6 +259,7 @@ async function scanSummaryLines(
     } else if (obj.type === 'user' || obj.type === 'assistant') {
       role = obj.type as string;
       content = obj.content;
+      usage = obj.usage as Record<string, unknown> | undefined;
       ts = obj.timestamp as string | undefined;
     }
 
@@ -297,16 +306,81 @@ async function scanSummaryLines(
 
 export class LocalSessionScanner {
   private summaryCache = new Map<string, SummaryCacheEntry>();
+  private sessionPathByWorkDirAndId = new Map<string, string>();
+
+  private sessionPathKey(workDir: string, sessionId: string): string {
+    return `${workDir}\0${sessionId}`;
+  }
 
   /**
-   * Resolve the JSONL directory for a given workDir.
-   * workDir is the absolute filesystem path (e.g., "/Users/name/project").
-   * The JSONL files live at ~/.claude/projects/{encoded-workDir}/
+   * Resolve possible JSONL directories for a given workDir.
+   * workDir is usually the absolute filesystem path (e.g., "/Users/name/project").
+   * The JSONL files live at ~/.claude/projects/{encoded-workDir}/, but Claude
+   * installations can use portable/legacy encodings, so reuse path candidates.
    */
-  private resolveJsonlDir(workDir: string): string {
+  private async resolveJsonlDirs(workDir: string): Promise<string[]> {
     const projectsBase = getProjectsBasePath();
-    const encoded = encodePath(workDir);
-    return path.join(projectsBase, encoded);
+    const candidateNames = getProjectDirNameCandidates(workDir).filter(
+      (candidate) => !path.isAbsolute(candidate)
+    );
+    const candidateDirs = Array.from(
+      new Set(candidateNames.map((candidate) => path.join(projectsBase, candidate)))
+    );
+
+    const existing: string[] = [];
+    for (const dir of candidateDirs) {
+      try {
+        if ((await stat(dir)).isDirectory()) existing.push(dir);
+      } catch {
+        // ignore missing candidate dirs
+      }
+    }
+
+    return existing.length > 0 ? existing : candidateDirs.slice(0, 1);
+  }
+
+  private async findSessionFile(
+    workDir: string,
+    sessionId: string
+  ): Promise<{ filePath: string; fileStat: Awaited<ReturnType<typeof stat>> } | null> {
+    const indexedPath = this.sessionPathByWorkDirAndId.get(this.sessionPathKey(workDir, sessionId));
+    if (indexedPath) {
+      try {
+        return { filePath: indexedPath, fileStat: await stat(indexedPath) };
+      } catch {
+        this.sessionPathByWorkDirAndId.delete(this.sessionPathKey(workDir, sessionId));
+      }
+    }
+
+    const jsonlDirs = await this.resolveJsonlDirs(workDir);
+    for (const jsonlDir of jsonlDirs) {
+      const directPath = path.join(jsonlDir, `${sessionId}.jsonl`);
+      try {
+        const fileStat = await stat(directPath);
+        this.sessionPathByWorkDirAndId.set(this.sessionPathKey(workDir, sessionId), directPath);
+        return { filePath: directPath, fileStat };
+      } catch {
+        // fall through to recursive lookup
+      }
+    }
+
+    for (const jsonlDir of jsonlDirs) {
+      for await (const candidatePath of walkJsonl(jsonlDir)) {
+        if (path.basename(candidatePath, '.jsonl') !== sessionId) continue;
+        try {
+          const fileStat = await stat(candidatePath);
+          this.sessionPathByWorkDirAndId.set(
+            this.sessionPathKey(workDir, sessionId),
+            candidatePath
+          );
+          return { filePath: candidatePath, fileStat };
+        } catch {
+          // stale file from the directory walk; keep searching
+        }
+      }
+    }
+
+    return null;
   }
 
   /**
@@ -314,63 +388,72 @@ export class LocalSessionScanner {
    * Uses file stat caching to skip unchanged files on subsequent calls.
    */
   async scanSummaries(workDir: string, projectId: string): Promise<LocalSessionSummary[]> {
-    const jsonlDir = this.resolveJsonlDir(workDir);
+    const jsonlDirs = await this.resolveJsonlDirs(workDir);
     const summaries: LocalSessionSummary[] = [];
     const now = Date.now();
 
-    for await (const filePath of walkJsonl(jsonlDir)) {
-      let fileStat;
-      try {
-        fileStat = await stat(filePath);
-      } catch {
-        continue;
-      }
+    for (const jsonlDir of jsonlDirs) {
+      for await (const filePath of walkJsonl(jsonlDir)) {
+        let fileStat;
+        try {
+          fileStat = await stat(filePath);
+        } catch {
+          continue;
+        }
 
-      // Check cache
-      const cached = this.summaryCache.get(filePath);
-      if (cached && cached.size === fileStat.size && cached.mtimeMs === fileStat.mtimeMs) {
-        summaries.push(cached.summary);
-        continue;
-      }
+        const sessionId = path.basename(filePath, '.jsonl');
+        this.sessionPathByWorkDirAndId.set(this.sessionPathKey(workDir, sessionId), filePath);
+
+        // Check cache
+        const cached = this.summaryCache.get(filePath);
+        if (cached && cached.size === fileStat.size && cached.mtimeMs === fileStat.mtimeMs) {
+          summaries.push(cached.summary);
+          continue;
+        }
+
+        const partial = await scanSummaryLines(filePath, sessionId, projectId);
+        if (!partial) continue;
+
+        const mtimeMs = fileStat.mtimeMs;
+        const active = now - mtimeMs < ACTIVE_THRESHOLD_MS;
+        const live = active && partial.lastRole === 'assistant';
+
+        // For a more accurate messageCount and token totals, we need the full file.
+        // But the first SUMMARY_SCAN_LINES is a good approximation for the list view.
+        // We'll mark the count as approximate if we stopped early.
+        const summary: LocalSessionSummary = {
+          id: sessionId,
+          title: partial.title || sessionId,
+          projectId,
+          messageCount: partial.messageCount,
+          userMessageCount: partial.userMessageCount,
+          assistantMessageCount: partial.assistantMessageCount,
+          inputTokens: partial.inputTokens,
+          outputTokens: partial.outputTokens,
+          cacheReadTokens: partial.cacheReadTokens,
+          cacheCreationTokens: partial.cacheCreationTokens,
+          totalTokens:
+            partial.inputTokens +
+            partial.outputTokens +
+            partial.cacheReadTokens +
+            partial.cacheCreationTokens,
+          model: partial.model,
+          active,
+          live,
+          startTime: partial.startTime,
+          endTime: partial.endTime,
+          createdAt: fileStat.birthtime?.toISOString() ?? new Date(mtimeMs).toISOString(),
+          updatedAt: new Date(mtimeMs).toISOString(),
+        };
+
+        this.summaryCache.set(filePath, {
+          size: fileStat.size,
+          mtimeMs,
+          summary,
+        });
 
-      const sessionId = path.basename(filePath, '.jsonl');
-      const partial = await scanSummaryLines(filePath, sessionId, projectId);
-      if (!partial) continue;
-
-      const mtimeMs = fileStat.mtimeMs;
-      const active = now - mtimeMs < ACTIVE_THRESHOLD_MS;
-      const live = active && partial.lastRole === 'assistant';
-
-      // For a more accurate messageCount and token totals, we need the full file.
-      // But the first SUMMARY_SCAN_LINES is a good approximation for the list view.
-      // We'll mark the count as approximate if we stopped early.
-      const summary: LocalSessionSummary = {
-        id: sessionId,
-        title: partial.title || sessionId,
-        projectId,
-        messageCount: partial.messageCount,
-        userMessageCount: partial.userMessageCount,
-        assistantMessageCount: partial.assistantMessageCount,
-        inputTokens: partial.inputTokens,
-        outputTokens: partial.outputTokens,
-        cacheReadTokens: partial.cacheReadTokens,
-        cacheCreationTokens: partial.cacheCreationTokens,
-        model: partial.model,
-        active,
-        live,
-        startTime: partial.startTime,
-        endTime: partial.endTime,
-        createdAt: fileStat.birthtime?.toISOString() ?? new Date(mtimeMs).toISOString(),
-        updatedAt: new Date(mtimeMs).toISOString(),
-      };
-
-      this.summaryCache.set(filePath, {
-        size: fileStat.size,
-        mtimeMs,
-        summary,
-      });
-
-      summaries.push(summary);
+        summaries.push(summary);
+      }
     }
 
     // Sort by endTime descending (most recent first)
@@ -394,16 +477,9 @@ export class LocalSessionScanner {
     sessionId: string,
     options?: { offset?: number; limit?: number }
   ): Promise<LocalSessionDetail | null> {
-    const jsonlDir = this.resolveJsonlDir(workDir);
-    const filePath = path.join(jsonlDir, `${sessionId}.jsonl`);
-
-    // Check file exists
-    let fileStat;
-    try {
-      fileStat = await stat(filePath);
-    } catch {
-      return null;
-    }
+    const resolvedFile = await this.findSessionFile(workDir, sessionId);
+    if (!resolvedFile) return null;
+    const { filePath, fileStat } = resolvedFile;
 
     const offset = options?.offset ?? 0;
     const limit = options?.limit ?? 200;
@@ -413,6 +489,8 @@ export class LocalSessionScanner {
     let model = '';
     let inputTokens = 0;
     let outputTokens = 0;
+    let cacheReadTokens = 0;
+    let cacheCreationTokens = 0;
     let firstTs: string | null = null;
     let lastTs: string | null = null;
 
@@ -446,6 +524,7 @@ export class LocalSessionScanner {
       } else if (obj.type === 'user' || obj.type === 'assistant') {
         role = obj.type as string;
         content = obj.content;
+        usage = obj.usage as Record<string, unknown> | undefined;
         ts = obj.timestamp as string | undefined;
       }
 
@@ -467,6 +546,8 @@ export class LocalSessionScanner {
       if (role === 'assistant' && usage && typeof usage === 'object') {
         inputTokens += Number(usage.input_tokens ?? 0) || 0;
         outputTokens += Number(usage.output_tokens ?? 0) || 0;
+        cacheReadTokens += Number(usage.cache_read_input_tokens ?? 0) || 0;
+        cacheCreationTokens += Number(usage.cache_creation_input_tokens ?? 0) || 0;
       }
 
       // Collect messages within the page range
@@ -482,7 +563,7 @@ export class LocalSessionScanner {
     if (totalMessages === 0) return null;
 
     const now = Date.now();
-    const mtimeMs = fileStat.mtimeMs;
+    const mtimeMs = Number(fileStat.mtimeMs);
     const active = now - mtimeMs < ACTIVE_THRESHOLD_MS;
 
     return {
@@ -500,6 +581,9 @@ export class LocalSessionScanner {
       model,
       inputTokens,
       outputTokens,
+      cacheReadTokens,
+      cacheCreationTokens,
+      totalTokens: inputTokens + outputTokens + cacheReadTokens + cacheCreationTokens,
     };
   }
 
@@ -508,5 +592,6 @@ export class LocalSessionScanner {
    */
   clearCache(): void {
     this.summaryCache.clear();
+    this.sessionPathByWorkDirAndId.clear();
   }
 }

package/src/main/services/session-intelligence/SessionUsageParser.ts

@@ -8,9 +8,10 @@
 
 import { createReadStream } from 'node:fs';
 import { readdir, stat } from 'node:fs/promises';
-import { createInterface } from 'node:readline';
 import * as path from 'node:path';
-import { getProjectsBasePath } from '@main/utils/pathDecoder';
+import { createInterface } from 'node:readline';
+
+import { getProjectDirNameCandidates, getProjectsBasePath } from '@main/utils/pathDecoder';
 
 export interface SessionEntry {
   relPath: string;
@@ -23,6 +24,7 @@ export interface SessionEntry {
     output: number;
     cacheRead: number;
     cacheCreation: number;
+    total: number;
   };
   startTime: string;
   endTime: string;
@@ -39,6 +41,7 @@ export interface UsageAggregate {
     output: number;
     cacheRead: number;
     cacheCreation: number;
+    total: number;
   };
   activeDays: number;
   daily: Record<string, DailyMetrics>;
@@ -55,6 +58,7 @@ export interface DailyMetrics {
   tokensOut: number;
   cacheRead: number;
   cacheCreation: number;
+  tokensTotal: number;
   workSeconds: number;
 }
 
@@ -64,6 +68,7 @@ export interface ProjectMetricsEntry {
   messages: number;
   tokensIn: number;
   tokensOut: number;
+  tokensTotal: number;
 }
 
 export interface EventEntry {
@@ -72,6 +77,7 @@ export interface EventEntry {
   tokensOut: number;
   cacheRead: number;
   cacheCreation: number;
+  tokensTotal: number;
 }
 
 export interface ParseResult {
@@ -137,7 +143,13 @@ interface ParsedSession {
   isWorktree: boolean;
   messageCount: number;
   toolCalls: Record<string, number>;
-  tokens: { input: number; output: number; cacheRead: number; cacheCreation: number };
+  tokens: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheCreation: number;
+    total: number;
+  };
   startTime: string;
   endTime: string;
   dailyTokens: Record<string, DailyMetrics>;
@@ -151,7 +163,7 @@ async function parseJsonl(filePath: string): Promise<ParsedSession | null> {
   let rawCwd = '';
   let isWorktree = false;
   const toolCalls: Record<string, number> = {};
-  const tokens = { input: 0, output: 0, cacheRead: 0, cacheCreation: 0 };
+  const tokens = { input: 0, output: 0, cacheRead: 0, cacheCreation: 0, total: 0 };
   let startTime = '';
   let endTime = '';
   const dailyTokens: Record<string, DailyMetrics> = {};
@@ -173,8 +185,7 @@ async function parseJsonl(filePath: string): Promise<ParsedSession | null> {
 
     if (!rawCwd && typeof obj.cwd === 'string') {
       rawCwd = obj.cwd;
-      const { normalized, isWorktree: iw } = normalizeCwd(rawCwd);
-      isWorktree = iw;
+      isWorktree = normalizeCwd(rawCwd).isWorktree;
     }
 
     const msg = obj.message as Record<string, unknown> | undefined;
@@ -191,6 +202,7 @@ async function parseJsonl(filePath: string): Promise<ParsedSession | null> {
     } else if (obj.type === 'user' || obj.type === 'assistant') {
       role = obj.type as string;
       content = obj.content;
+      usage = obj.usage as Record<string, unknown> | undefined;
       ts = obj.timestamp as string | undefined;
     }
 
@@ -211,11 +223,13 @@ async function parseJsonl(filePath: string): Promise<ParsedSession | null> {
       const out = Number(usage.output_tokens ?? 0) || 0;
       const cread = Number(usage.cache_read_input_tokens ?? 0) || 0;
       const ccreate = Number(usage.cache_creation_input_tokens ?? 0) || 0;
+      const total = inp + out + cread + ccreate;
 
       tokens.input += inp;
       tokens.output += out;
       tokens.cacheRead += cread;
       tokens.cacheCreation += ccreate;
+      tokens.total += total;
 
       // Daily aggregation
       const day = ts.slice(0, 10);
@@ -227,6 +241,7 @@ async function parseJsonl(filePath: string): Promise<ParsedSession | null> {
           tokensOut: 0,
           cacheRead: 0,
           cacheCreation: 0,
+          tokensTotal: 0,
           workSeconds: 0,
         });
         d.messages++;
@@ -234,6 +249,7 @@ async function parseJsonl(filePath: string): Promise<ParsedSession | null> {
         d.tokensOut += out;
         d.cacheRead += cread;
         d.cacheCreation += ccreate;
+        d.tokensTotal += total;
       }
 
       // Hourly distribution
@@ -251,6 +267,7 @@ async function parseJsonl(filePath: string): Promise<ParsedSession | null> {
           tokensOut: out,
           cacheRead: cread,
           cacheCreation: ccreate,
+          tokensTotal: total,
         });
       }
     }
@@ -331,12 +348,79 @@ function calcWorkSeconds(events: EventEntry[]): Record<string, number> {
   return workSeconds;
 }
 
+export interface ProjectUsageStats {
+  sessions: number;
+  messages: number;
+  tokensIn: number;
+  tokensOut: number;
+  cacheRead: number;
+  cacheCreation: number;
+  totalTokens: number;
+  durationMs: number;
+}
+
+/**
+ * Full-file usage stats for one work directory.
+ * Full-file stats are used by the digital worker list to avoid the old first-200-line
+ * approximation. Callers decide whether their displayed total includes cache tokens.
+ */
+export async function scanProjectStats(workDir: string): Promise<ProjectUsageStats | null> {
+  if (!workDir) return null;
+
+  const projectsRoot = getProjectsBasePath();
+  const jsonlDirs = Array.from(
+    new Set(
+      getProjectDirNameCandidates(workDir)
+        .filter((candidate) => !path.isAbsolute(candidate))
+        .map((candidate) => path.join(projectsRoot, candidate))
+    )
+  );
+  const normalizedWorkDir = normalizeCwd(workDir).normalized;
+  const stats: ProjectUsageStats = {
+    sessions: 0,
+    messages: 0,
+    tokensIn: 0,
+    tokensOut: 0,
+    cacheRead: 0,
+    cacheCreation: 0,
+    totalTokens: 0,
+    durationMs: 0,
+  };
+  let earliest = '';
+  let latest = '';
+
+  for (const jsonlDir of jsonlDirs) {
+    for await (const filePath of walkJsonl(jsonlDir)) {
+      const parsed = await parseJsonl(filePath);
+      if (!parsed) continue;
+      if (parsed.projectPath && parsed.projectPath !== normalizedWorkDir) continue;
+
+      stats.sessions++;
+      stats.messages += parsed.messageCount;
+      stats.tokensIn += parsed.tokens.input;
+      stats.tokensOut += parsed.tokens.output;
+      stats.cacheRead += parsed.tokens.cacheRead;
+      stats.cacheCreation += parsed.tokens.cacheCreation;
+      stats.totalTokens += parsed.tokens.total;
+      if (parsed.startTime && (!earliest || parsed.startTime < earliest))
+        earliest = parsed.startTime;
+      if (parsed.endTime && (!latest || parsed.endTime > latest)) latest = parsed.endTime;
+    }
+  }
+
+  if (stats.sessions === 0) return null;
+  if (earliest && latest) {
+    stats.durationMs = Math.max(0, Date.parse(latest) - Date.parse(earliest));
+  }
+  return stats;
+}
+
 export async function scanSessions(): Promise<ParseResult> {
   const sessions: SessionEntry[] = [];
   const aggregate: UsageAggregate = {
     sessions: 0,
     messages: 0,
-    tokens: { input: 0, output: 0, cacheRead: 0, cacheCreation: 0 },
+    tokens: { input: 0, output: 0, cacheRead: 0, cacheCreation: 0, total: 0 },
     activeDays: 0,
     daily: {},
     hourly: new Array(24).fill(0),
@@ -382,6 +466,7 @@ export async function scanSessions(): Promise<ParseResult> {
     aggregate.tokens.output += parsed.tokens.output;
     aggregate.tokens.cacheRead += parsed.tokens.cacheRead;
     aggregate.tokens.cacheCreation += parsed.tokens.cacheCreation;
+    aggregate.tokens.total += parsed.tokens.total;
 
     // Hourly
     for (let h = 0; h < 24; h++) {
@@ -401,6 +486,7 @@ export async function scanSessions(): Promise<ParseResult> {
         tokensOut: 0,
         cacheRead: 0,
         cacheCreation: 0,
+        tokensTotal: 0,
         workSeconds: 0,
       });
       d.sessions++;
@@ -409,18 +495,27 @@ export async function scanSessions(): Promise<ParseResult> {
       d.tokensOut += m.tokensOut;
       d.cacheRead += m.cacheRead;
       d.cacheCreation += m.cacheCreation;
+      d.tokensTotal += m.tokensTotal;
     }
 
     // Projects
     const proj = parsed.projectPath || '(untracked)';
     if (!projectMap[proj]) {
-      projectMap[proj] = { cwd: proj, sessions: 0, messages: 0, tokensIn: 0, tokensOut: 0 };
+      projectMap[proj] = {
+        cwd: proj,
+        sessions: 0,
+        messages: 0,
+        tokensIn: 0,
+        tokensOut: 0,
+        tokensTotal: 0,
+      };
     }
     const p = projectMap[proj];
     p.sessions++;
     p.messages += parsed.messageCount;
     p.tokensIn += parsed.tokens.input;
     p.tokensOut += parsed.tokens.output;
+    p.tokensTotal += parsed.tokens.total;
   }
 
   // Work seconds per day

package/src/main/services/session-intelligence/UsageTelemetryService.ts

@@ -71,6 +71,7 @@ async function uploadMetrics(client: Redis, slug: string, result: ParseResult):
       tokens_out: m.tokensOut,
       cache_read: m.cacheRead,
       cache_creation: m.cacheCreation,
+      tokens_total: m.tokensTotal,
       work_seconds: m.workSeconds,
     });
     pipe.expire(KEY_DAILY(slug, day), 90 * 86400);
@@ -84,6 +85,7 @@ async function uploadMetrics(client: Redis, slug: string, result: ParseResult):
     tokens_out: aggregate.tokens.output,
     cache_read: aggregate.tokens.cacheRead,
     cache_creation: aggregate.tokens.cacheCreation,
+    tokens_total: aggregate.tokens.total,
     active_days: aggregate.activeDays,
     last_scan: new Date().toISOString(),
   });
@@ -172,6 +174,7 @@ interface TelemetryStatusResult {
   tokensOut: number;
   cacheRead: number;
   cacheCreation: number;
+  totalTokens: number;
   activeDays: number;
   hourly: number[];
   projects: Array<{
@@ -180,6 +183,7 @@ interface TelemetryStatusResult {
     messages: number;
     tokensIn: number;
     tokensOut: number;
+    tokensTotal: number;
   }>;
   workSecondsByDay: Record<string, number>;
 }
@@ -195,6 +199,7 @@ function statusFromParseResult(result: ParseResult, connected: boolean): Telemet
     tokensOut: aggregate.tokens.output,
     cacheRead: aggregate.tokens.cacheRead,
     cacheCreation: aggregate.tokens.cacheCreation,
+    totalTokens: aggregate.tokens.total,
     activeDays: aggregate.activeDays,
     hourly: aggregate.hourly,
     projects: aggregate.projects,
@@ -250,6 +255,12 @@ export async function getTelemetryStatus(
       tokensOut: Number(summary.tokens_out ?? 0),
       cacheRead: Number(summary.cache_read ?? 0),
       cacheCreation: Number(summary.cache_creation ?? 0),
+      totalTokens:
+        Number(summary.tokens_total) ||
+        Number(summary.tokens_in ?? 0) +
+          Number(summary.tokens_out ?? 0) +
+          Number(summary.cache_read ?? 0) +
+          Number(summary.cache_creation ?? 0),
       activeDays: Number(summary.active_days ?? 0),
       hourly: hourlyRaw ? JSON.parse(hourlyRaw) : new Array(24).fill(0),
       projects: projectsRaw ? JSON.parse(projectsRaw) : [],