tokentracker-cli 1.3.4 → 1.3.5

package/src/lib/rollout.js

@@ -12,6 +12,7 @@ const { physicalJsonlRecords } = require("./jsonl-lines");
 const { readSqliteJsonRows, readSqliteJsonRowsAsync } = require("./sqlite-reader");
 const wsl = require("./wsl-probe");
 const { resolveInstallPaths } = require("./install-resolver");
+const { expandHome } = require("./scan-roots");
 const {
   consumeUsageDelta,
   createUsageDeltaState,
@@ -1634,9 +1635,19 @@ async function resolveOpenclawSessionFiles(env = process.env, deps = {}) {
           out.push(full);
         }
       }
+      for (const dbPath of [
+        path.join(agentsDir, agent.name, "agent", "openclaw-agent.sqlite"),
+        path.join(agentsDir, agent.name, "openclaw-agent.sqlite"),
+      ]) {
+        if ((await fs.stat(dbPath).catch(() => null))?.isFile()) {
+          out.push(dbPath);
+          break; // alternate layouts of one agent database, not two sources
+        }
+      }
     }
   }
-  out.sort((a, b) => a.localeCompare(b));
+  // Import archives must seed dedup before the corresponding SQLite history.
+  out.sort((a, b) => Number(a.endsWith(".sqlite")) - Number(b.endsWith(".sqlite")) || a.localeCompare(b));
   return out;
 }
 
@@ -1699,6 +1710,67 @@ async function parseOpenclawIncremental({
     const previousOffset = Number(prev?.offset || 0);
     let accepted = null;
     let openedRegularFile = false;
+    if (filePath.endsWith(".sqlite")) {
+      const sessionFilter = typeof entry?.sessionId === "string"
+        ? ` AND e.session_id = '${entry.sessionId.replace(/'/g, "''")}'` : "";
+      const rows = await readSqliteJsonRowsAsync(filePath, `
+        SELECT e.session_id, json_object(
+          'type', json_extract(e.event_json, '$.type'),
+          'id', json_extract(e.event_json, '$.id'),
+          'timestamp', json_extract(e.event_json, '$.timestamp'),
+          'message', json_object(
+            'role', json_extract(e.event_json, '$.message.role'),
+            'model', json_extract(e.event_json, '$.message.model'),
+            'provider', json_extract(e.event_json, '$.message.provider'),
+            'api', json_extract(e.event_json, '$.message.api'),
+            'timestamp', json_extract(e.event_json, '$.message.timestamp'),
+            'responseId', json_extract(e.event_json, '$.message.responseId'),
+            'usage', json_extract(e.event_json, '$.message.usage')
+          )) AS event
+        FROM transcript_events e JOIN session_windows w ON w.session_id = e.session_id
+        WHERE json_valid(e.event_json) AND COALESCE(w.reason, '') != 'compaction'
+          AND json_extract(e.event_json, '$.message.role') = 'assistant'
+          AND json_extract(e.event_json, '$.message.usage') IS NOT NULL
+          ${sessionFilter}
+        ORDER BY e.session_id, e.seq
+      `, { readOnly: true, throwOnReadFailure: true, label: "OpenClaw" });
+      const sessions = new Map();
+      for (const row of rows) {
+        if (!sessions.has(row.session_id)) sessions.set(row.session_id, []);
+        sessions.get(row.session_id).push(row.event);
+      }
+      for (const [sessionId, lines] of sessions) {
+        const sessionCursorKey = `${key}#${sessionId}`;
+        const prior = { ...(stagedFiles[sessionCursorKey]?.usageEvents || {}) };
+        const dbDir = path.dirname(filePath);
+        const agentDir = path.basename(dbDir) === "agent" && path.basename(path.dirname(path.dirname(dbDir))) === "agents"
+          ? path.dirname(dbDir) : dbDir;
+        const agentPrefix = openclawCursorKey(`${agentDir}${path.sep}`);
+        // SQLite imports retain transcript identities. Carry forward counts
+        // from this session's legacy transcript, including reset archives.
+        for (const [legacyPath, cursor] of Object.entries(stagedFiles)) {
+          const basename = path.basename(legacyPath);
+          if (cursor.provider !== "openclaw" || !openclawCursorKey(legacyPath).startsWith(agentPrefix)) continue;
+          if (!basename.startsWith(`${sessionId}.jsonl`) &&
+              !(basename.startsWith(`${sessionId}-topic-`) && basename.includes(".jsonl"))) continue;
+          for (const [identity, count] of Object.entries(cursor.usageEvents || {})) {
+            prior[identity] = Math.max(prior[identity] || 0, count);
+          }
+        }
+        const result = await parseOpenclawSessionFile({
+          lines, previousUsageEvents: prior, appendOnly: false,
+          hourlyState, touchedBuckets, source: fileSource,
+        });
+        stagedFiles[sessionCursorKey] = {
+          provider: "openclaw", usageEvents: result.usageEvents,
+          hasRealUsage: Object.keys(result.usageEvents).length > 0,
+          updatedAt: new Date().toISOString(),
+        };
+        eventsAggregated += result.eventsAggregated;
+      }
+      filesProcessed += 1;
+      continue;
+    }
     for (let attempt = 0; attempt < 3; attempt += 1) {
       const fileHandle = await fs.open(filePath, "r").catch(() => null);
       if (!fileHandle) break;
@@ -1913,6 +1985,7 @@ function mergeOpenclawAttemptBuckets(
 }
 
 async function parseOpenclawSessionFile({
+  lines,
   filePath,
   fileHandle,
   startOffset,
@@ -1928,7 +2001,8 @@ async function parseOpenclawSessionFile({
   projectState,
   projectTouchedBuckets,
 }) {
-  const st = fileHandle ? await fileHandle.stat() : await fs.stat(filePath);
+  const st = lines ? { size: lines.length } : fileHandle ? await fileHandle.stat() : await fs.stat(filePath);
+  startOffset = startOffset || 0;
   const endOffset =
     Number.isFinite(endOffsetLimit) && endOffsetLimit >= 0
       ? Math.min(st.size, endOffsetLimit)
@@ -1963,14 +2037,14 @@ async function parseOpenclawSessionFile({
     };
   }
 
-  const stream = fssync.createReadStream(filePath, {
+  const stream = lines ? null : fssync.createReadStream(filePath, {
     fd: fileHandle?.fd,
     autoClose: !fileHandle,
     encoding: "utf8",
     start: startOffset,
     end: endOffset - 1,
   });
-  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+  const rl = lines || readline.createInterface({ input: stream, crlfDelay: Infinity });
 
   let eventsAggregated = 0;
   const scanCounts = appendOnly ? { ...priorCounts } : {};
@@ -2069,8 +2143,8 @@ async function parseOpenclawSessionFile({
     if (!collectOnly) eventsAggregated += 1;
   }
 
-  rl.close();
-  if (!fileHandle) stream.close?.();
+  if (!lines) rl.close();
+  if (!fileHandle) stream?.close?.();
   return {
     endOffset,
     eventsAggregated,
@@ -10451,23 +10525,43 @@ async function parseCodebuddyIncremental({
 //      is accepted by workbuddySqliteUsageSnapshot.
 // ─────────────────────────────────────────────────────────────────────────────
 
-function resolveWorkbuddyHome(env = process.env) {
-  const home = env.HOME || require("node:os").homedir();
-  if (env.WORKBUDDY_HOME) return env.WORKBUDDY_HOME;
+// WorkBuddy ships two regional builds that keep their data in sibling homes:
+//   ~/.workbuddy     — Tencent CN build (models: hy*/glm*/deepseek-*/auto)
+//   ~/.workbuddy-ai  — international build (models: gpt-5.6-*, gpt-6-*)
+// Both write byte-identical JSONL, so every reader below is shared and only
+// the home directory (and the bucket source key) differs. `variant` is also
+// the source key written into hourly buckets, so the two builds stay
+// separable in the dashboard and never share dedup state.
+const WORKBUDDY_VARIANTS = {
+  workbuddy: { dir: ".workbuddy", envVar: "WORKBUDDY_HOME" },
+  "workbuddy-ai": { dir: ".workbuddy-ai", envVar: "WORKBUDDY_AI_HOME" },
+};
+
+function resolveWorkbuddyVariant(variant) {
+  return Object.prototype.hasOwnProperty.call(WORKBUDDY_VARIANTS, variant)
+    ? variant
+    : "workbuddy";
+}
+
+function resolveWorkbuddyHome(env = process.env, variant = "workbuddy") {
+  const spec = WORKBUDDY_VARIANTS[resolveWorkbuddyVariant(variant)];
+  const home = env.HOME || env.USERPROFILE || require("node:os").homedir();
+  const configured = expandHome(env[spec.envVar], home);
+  if (configured) return configured;
   if (process.platform === "win32") {
     return pickWin32ProviderPath({
       env,
-      nativeValue: path.join(home, ".workbuddy"),
-      wslProviderDir: ".workbuddy",
+      nativeValue: path.join(home, spec.dir),
+      wslProviderDir: spec.dir,
     });
   }
-  return path.join(home, ".workbuddy");
+  return path.join(home, spec.dir);
 }
 
-function resolveWorkbuddyDefaultModel(env = process.env) {
+function resolveWorkbuddyDefaultModel(env = process.env, variant = "workbuddy") {
   const fallback = "auto";
   try {
-    const workbuddyHome = resolveWorkbuddyHome(env);
+    const workbuddyHome = resolveWorkbuddyHome(env, variant);
     if (!workbuddyHome) return fallback;
     const settingsPath = path.join(workbuddyHome, "settings.json");
     const raw = fssync.readFileSync(settingsPath, "utf8");
@@ -10487,8 +10581,8 @@ function resolveWorkbuddyDefaultModel(env = process.env) {
 // ~/.workbuddy/traces/<pid>/trace_*.json. Those summaries are useful only when
 // the detailed JSONL for a session is absent, so they are returned as typed
 // entries and parsed after JSONL (JSONL remains authoritative when both exist).
-function resolveWorkbuddyProjectFiles(env = process.env) {
-  const workbuddyHome = resolveWorkbuddyHome(env);
+function resolveWorkbuddyProjectFiles(env = process.env, variant = "workbuddy") {
+  const workbuddyHome = resolveWorkbuddyHome(env, variant);
   if (!workbuddyHome) return [];
   const projectsDir = path.join(workbuddyHome, "projects");
   const files = [];
@@ -10597,10 +10691,15 @@ async function parseWorkbuddyIncremental({
   onProgress,
   env,
   defaultModel,
+  source = "workbuddy",
 } = {}) {
   await ensureDir(path.dirname(queuePath));
+  // `source` doubles as the variant selector and the bucket source key, so the
+  // CN install (~/.workbuddy) and the international install (~/.workbuddy-ai)
+  // get independent cursor namespaces and never share dedup state.
+  const variant = resolveWorkbuddyVariant(source);
   const workbuddyState =
-    cursors.workbuddy && typeof cursors.workbuddy === "object" ? cursors.workbuddy : {};
+    cursors[variant] && typeof cursors[variant] === "object" ? cursors[variant] : {};
   const seenIds = new Set(
     Array.isArray(workbuddyState.seenIds) ? workbuddyState.seenIds : [],
   );
@@ -10626,20 +10725,20 @@ async function parseWorkbuddyIncremental({
 
   const allFiles = Array.isArray(projectFiles)
     ? projectFiles
-    : resolveWorkbuddyProjectFiles(env || process.env);
+    : resolveWorkbuddyProjectFiles(env || process.env, variant);
   const jsonlFiles = allFiles.filter((entry) => typeof entry === "string");
   const traceFiles = allFiles.filter(
     (entry) => entry && typeof entry === "object" && typeof entry.path === "string" && entry.kind === "trace",
   );
   const files = [...jsonlFiles, ...traceFiles];
-  const fallbackModel = defaultModel || resolveWorkbuddyDefaultModel(env || process.env);
+  const fallbackModel = defaultModel || resolveWorkbuddyDefaultModel(env || process.env, variant);
 
-  const workbuddyHome = resolveWorkbuddyHome(env || process.env);
+  const workbuddyHome = resolveWorkbuddyHome(env || process.env, variant);
   const dbPath = workbuddyHome ? path.join(workbuddyHome, "workbuddy.db") : null;
   const dbExists = Boolean(dbPath && fssync.existsSync(dbPath));
 
   if (files.length === 0 && !dbExists) {
-    cursors.workbuddy = {
+    cursors[variant] = {
       ...workbuddyState,
       seenIds: Array.from(seenIds),
       seenTraceIds: Array.from(seenTraceIds),
@@ -10786,9 +10885,9 @@ async function parseWorkbuddyIncremental({
         conversation_count: 1,
       };
 
-      const bucket = getHourlyBucket(hourlyState, "workbuddy", model, bucketStart);
+      const bucket = getHourlyBucket(hourlyState, variant, model, bucketStart);
       addTotals(bucket.totals, delta);
-      touchedBuckets.add(bucketKey("workbuddy", model, bucketStart));
+      touchedBuckets.add(bucketKey(variant, model, bucketStart));
       seenIds.add(messageId);
       // Keep legacy entry-id keys alongside the response id so upgrading a
       // cursor cannot replay a row that an older build already counted.
@@ -10897,9 +10996,9 @@ async function parseWorkbuddyIncremental({
       total_tokens: inputTokens + totalCached + totalOutput,
       conversation_count: 1,
     };
-    const bucket = getHourlyBucket(hourlyState, "workbuddy", model, bucketStart);
+    const bucket = getHourlyBucket(hourlyState, variant, model, bucketStart);
     addTotals(bucket.totals, delta);
-    touchedBuckets.add(bucketKey("workbuddy", model, bucketStart));
+    touchedBuckets.add(bucketKey(variant, model, bucketStart));
     seenTraceIds.add(traceId);
     tracedSessionIds.add(sessionId);
     recordsProcessed++;
@@ -11032,9 +11131,9 @@ async function parseWorkbuddyIncremental({
           conversation_count: Object.keys(previousTokens).every((key) => toNonNegativeInt(previousTokens[key]) === 0) || isReset ? 1 : 0,
         };
 
-        const bucket = getHourlyBucket(hourlyState, "workbuddy", model, bucketStart);
+        const bucket = getHourlyBucket(hourlyState, variant, model, bucketStart);
         addTotals(bucket.totals, delta);
-        touchedBuckets.add(bucketKey("workbuddy", model, bucketStart));
+        touchedBuckets.add(bucketKey(variant, model, bucketStart));
         sqliteSessions[sessionId] = {
           used: usedNow,
           updatedAt: updatedAtRaw,
@@ -11085,7 +11184,7 @@ async function parseWorkbuddyIncremental({
   const updatedAt = new Date().toISOString();
   hourlyState.updatedAt = updatedAt;
   cursors.hourly = hourlyState;
-  cursors.workbuddy = {
+  cursors[variant] = {
     ...workbuddyState,
     seenIds: cappedSeen,
     seenTraceIds: cappedSeenTraceIds,
@@ -15972,6 +16071,27 @@ function resolvePiSessionFiles(env = process.env) {
   } catch {
     // ignore — return what we have
   }
+  // Multica launches pi headless with a dedicated flat session dir:
+  //   ~/.multica/pi-sessions/<session-id>.jsonl
+  // Scan it too so orchestrated runs are counted alongside TUI sessions.
+  try {
+    const seen = new Set(files);
+    const multicaSessionsDir = path.join(
+      env.HOME || require("node:os").homedir(),
+      ".multica",
+      "pi-sessions",
+    );
+    for (const entry of fssync.readdirSync(multicaSessionsDir, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
+      const full = path.join(multicaSessionsDir, entry.name);
+      if (!seen.has(full)) {
+        seen.add(full);
+        files.push(full);
+      }
+    }
+  } catch {
+    // ignore — no Multica install
+  }
   files.sort((a, b) => a.localeCompare(b));
   return files;
 }
@@ -24514,6 +24634,8 @@ module.exports = {
   resolveWorkbuddyProjectFiles,
   resolveWorkbuddyDefaultModel,
   parseWorkbuddyIncremental,
+  WORKBUDDY_VARIANTS,
+  resolveWorkbuddyVariant,
   resolveKiroCliSessionFiles,
   resolveKiroCliDbPath,
   parseKiroCliIncremental,

package/src/lib/session-analytics.js

@@ -70,7 +70,7 @@ const {
 // long-context subset) and folds delivery signals into the token parser's
 // single pass instead of parsing every Codex file twice.
 // v14 adds request-level estimated performance and Claude model usage.
-const SIDECAR_VERSION = 14;
+const SIDECAR_VERSION = 16;
 const EDIT_TOOLS = new Set([
   "apply_patch",
   "edit",
@@ -123,12 +123,23 @@ function addTotals(target, delta) {
   for (const key of ["input_tokens", "cached_input_tokens", "cache_creation_input_tokens", "output_tokens", "reasoning_output_tokens", "total_tokens"]) {
     target[key] = finite(target[key]) + finite(delta?.[key]);
   }
+  for (const key of MODEL_USAGE_SUM_FIELDS) {
+    if (!/^(?:long_context_|priority_)|^(?:usage_events|rerouted_usage_events)$/.test(key)) continue;
+    if (delta?.[key]) target[key] = finite(target[key]) + finite(delta[key]);
+  }
 }
 
 function emptyTotals() {
   return tokenTotals({});
 }
 
+function mergeUsageMetadata(target, usage) {
+  for (const field of ["selected_models", "reroute_reasons"]) {
+    if (Array.isArray(usage[field])) target[field] = [...new Set([...(target[field] || []), ...usage[field]])];
+  }
+  if (usage.model_attribution === "effective") target.model_attribution = "effective";
+}
+
 const MODEL_USAGE_SUM_FIELDS = [
   "input_tokens",
   "cached_input_tokens",
@@ -241,6 +252,11 @@ function serializeSessionRecord(row) {
 }
 
 function repriceSessionRecord(record) {
+  if (Array.isArray(record.usage_buckets)) {
+    record.usage_buckets = record.usage_buckets.map((bucket) => ({
+      ...bucket, cost_usd: computeRowCost({ source: record.source, ...bucket }),
+    }));
+  }
   const modelUsage = normalizeModelUsageRows(record?.model_usage);
   if (modelUsage.length > 0) {
     let hasUnpricedUsage = false;
@@ -469,6 +485,19 @@ function finalizeRecord(record) {
   return record;
 }
 
+function sessionStorageUsage(filePaths) {
+  let bytes = 0;
+  const allocated = process.platform !== "win32";
+  for (const file of new Set(filePaths)) {
+    try {
+      const stat = fs.statSync(file);
+      if (!stat.isFile()) continue;
+      bytes += allocated && Number.isFinite(stat.blocks) ? stat.blocks * 512 : stat.size;
+    } catch { /* deleted or unreadable while scanning */ }
+  }
+  return { session_store_bytes: bytes, session_store_metric: allocated ? "allocated" : "logical" };
+}
+
 function readableSessionPaths(filePath) {
   const candidates = (Array.isArray(filePath) ? filePath : [filePath]).filter(Boolean);
   const readable = candidates.filter((value) => sessionFileStatKey(value));
@@ -623,6 +652,7 @@ async function scanClaudeSession(filePath) {
     // wrote one — the UI then falls back to the project name.
     title: aiTitle,
     source: "claude",
+    ...sessionStorageUsage(filePaths),
     project_key: projectKey(cwd, primaryFilePath),
     project_ref: cwd || null,
     model,
@@ -735,6 +765,7 @@ async function scanCodexSession(filePath) {
   const primaryFilePath = filePaths[0] || String(filePath || "");
   const signalCollector = createCodexDeliverySignalCollector();
   const performanceCollector = createCodexPerformanceCollector();
+  const usageBuckets = new Map();
   const parsed = await parseCodexRolloutFile(filePaths, {
     seenTokenEvents: new Set(),
     collectBreakdowns: false,
@@ -743,7 +774,20 @@ async function scanCodexSession(filePath) {
       signalCollector.consume(obj, model);
       performanceCollector.consume(obj, model);
     },
-    onUsage: performanceCollector.consumeUsage,
+    onUsage(event) {
+      if (event.origin !== "compaction") performanceCollector.consumeUsage(event);
+      if (!event.delta || event.delta.total_tokens <= 0) return;
+      const ms = Date.parse(event.timestamp);
+      if (!Number.isFinite(ms)) return;
+      // Minute buckets preserve every current IANA local-midnight boundary
+      // and every integer tz_offset_minutes accepted by the local API.
+      const timestamp = new Date(Math.floor(ms / 60_000) * 60_000).toISOString();
+      const key = `${timestamp}\u0000${event.model}`;
+      const bucket = usageBuckets.get(key) || { timestamp, model: event.model || "unknown", ...emptyTotals() };
+      addTotals(bucket, event.delta);
+      mergeUsageMetadata(bucket, event.delta);
+      usageBuckets.set(key, bucket);
+    },
   });
   const signals = signalCollector.finish();
   const performance = performanceCollector.finish();
@@ -798,10 +842,12 @@ async function scanCodexSession(filePath) {
     // Local-only: stripped in summarizeSessions before any cloud/CSV export.
     title,
     source: "codex",
+    ...sessionStorageUsage(filePaths),
     project_key: projectKey(parsed.cwd, primaryFilePath),
     project_ref: parsed.cwd || null,
     model,
     model_usage: modelUsage,
+    usage_buckets: [...usageBuckets.values()],
     performance: performance.performance,
     ...signals.bounds,
     turns: signals.turns || finite(parsed.turnCount),
@@ -1079,6 +1125,7 @@ async function scanGrokSession(filePath) {
     // Local-only: stripped in summarizeSessions before any cloud/CSV export.
     title,
     source: "grok",
+    ...sessionStorageUsage([filePath, grokSummaryPathFor(filePath), grokSignalsPathFor(filePath)]),
     project_key: projectKey(cwd, filePath),
     project_ref: cwd || null,
     model: model || "unknown",
@@ -1617,17 +1664,55 @@ function buildSessionAnalytics(options = {}) {
 // exactly the long/resumed ones, which also sort to the top because the sort
 // key is ended_at. On real data a 7-day window lost 6 sessions, the largest
 // 224M tokens. Treat the window as an interval intersection instead.
-function withinDayRange(row, from, to) {
-  const startDay = String(row?.started_at || row?.ended_at || "").slice(0, 10);
-  const endDay = String(row?.ended_at || row?.started_at || "").slice(0, 10);
+function sessionUsageDay(timestamp, { timeZone, offsetMinutes } = {}) {
+  const date = new Date(timestamp);
+  if (!Number.isFinite(date.getTime())) return "";
+  if (timeZone) {
+    try {
+      const parts = new Intl.DateTimeFormat("en-CA", { timeZone, year: "numeric", month: "2-digit", day: "2-digit" }).formatToParts(date);
+      const part = (name) => parts.find((p) => p.type === name)?.value;
+      return `${part("year")}-${part("month")}-${part("day")}`;
+    } catch { /* fall back to the caller's offset or UTC */ }
+  }
+  return new Date(date.getTime() + (Number.isFinite(offsetMinutes) ? offsetMinutes * 60_000 : 0)).toISOString().slice(0, 10);
+}
+
+function withinDayRange(row, from, to, context) {
+  const startDay = sessionUsageDay(row?.started_at || row?.ended_at || "", context);
+  const endDay = sessionUsageDay(row?.ended_at || row?.started_at || "", context);
   if (from && (!endDay || endDay < from)) return false;
   if (to && (!startDay || startDay > to)) return false;
   return true;
 }
 
-function summarizeSessions(sessions, { from = "", to = "", includeSessions = true } = {}) {
+function scopeSessionUsage(row, from, to, context) {
+  if ((!from && !to) || !Array.isArray(row.usage_buckets)) return { ...row };
+  const buckets = row.usage_buckets.filter((bucket) => {
+    const day = sessionUsageDay(bucket.timestamp, context);
+    return (!from || day >= from) && (!to || day <= to);
+  });
+  const tokens = emptyTotals();
+  const byModel = new Map();
+  for (const bucket of buckets) {
+    addTotals(tokens, bucket);
+    const model = byModel.get(bucket.model) || { model: bucket.model, ...emptyTotals(), usage_events: 0 };
+    addTotals(model, bucket);
+    mergeUsageMetadata(model, bucket);
+    if (!bucket.usage_events) model.usage_events += 1;
+    byModel.set(bucket.model, model);
+  }
+  return repriceSessionRecord({ ...row, tokens, total_tokens: tokens.total_tokens,
+    model_usage: [...byModel.values()], usage_buckets: buckets, cost_usd: 0,
+    lifetime_total_tokens: row.total_tokens, lifetime_cost_usd: row.cost_usd });
+}
+
+function summarizeSessions(sessions, { from = "", to = "", includeSessions = true, timeZone, offsetMinutes } = {}) {
+  const context = { timeZone, offsetMinutes };
   const filtered = annotateCodexThreadUsage((sessions || [])
-    .filter((row) => withinDayRange(row, from, to))
+    .filter((row) => withinDayRange(row, from, to, context))
+    // Efficiency is a session-lifetime metric: both tokens and edit turns
+    // must describe that same population. The browser scopes consumption
+    // separately; do not divide in-range tokens by lifetime edit counts here.
     .map((row) => ({ ...row })));
   const byModel = new Map();
   const subagents = new Map();
@@ -1838,12 +1923,19 @@ function toSessionBrowserRow(row) {
     parent_link_conflict: Boolean(row.parent_link_conflict),
     title: row.title || null,
     source: row.source,
+    ...(Number.isFinite(row.session_store_bytes) ? {
+      session_store_bytes: row.session_store_bytes,
+      session_store_metric: row.session_store_metric,
+      bytes_per_1k_tokens: (row.lifetime_total_tokens ?? row.total_tokens) > 0
+        ? row.session_store_bytes * 1000 / (row.lifetime_total_tokens ?? row.total_tokens) : null,
+    } : {}),
     project_key: row.project_key,
     // project_ref (the local cwd) only ever travels over the local API so the
     // browser can show where a session ran and compose a resume command.
     project_ref: row.project_ref || null,
     model: row.model,
     model_usage: modelUsageForAggregation(row),
+    ...(Array.isArray(row.usage_buckets) ? { usage_buckets: row.usage_buckets } : {}),
     performance: normalizePerformance(row.performance),
     started_at: row.started_at || null,
     ended_at: row.ended_at || null,
@@ -1914,11 +2006,15 @@ function mergeSessionFragments(rows) {
     cur.performance = mergePerformance(cur.performance, row.performance);
     cur.subagent_calls = finite(cur.subagent_calls) + finite(row.subagent_calls);
     addTotals(cur.tokens, row.tokens);
+    if (Array.isArray(row.usage_buckets)) {
+      cur.usage_buckets = [...(cur.usage_buckets || []), ...row.usage_buckets];
+    }
     cur.model_usage = normalizeModelUsageRows([
       ...(cur.model_usage || []),
       ...(row.model_usage || []),
     ]);
     cur.total_tokens = finite(cur.total_tokens) + finite(row.total_tokens);
+    if (Number.isFinite(row.session_store_bytes)) cur.session_store_bytes = finite(cur.session_store_bytes) + row.session_store_bytes;
     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);
@@ -2095,7 +2191,8 @@ function annotateCodexThreadUsage(rows) {
 // 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 } = {}) {
+function listSessionsForBrowser(sessions, { from = "", to = "", limit = 0, timeZone, offsetMinutes } = {}) {
+  const context = { timeZone, offsetMinutes };
   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
@@ -2103,7 +2200,9 @@ function listSessionsForBrowser(sessions, { from = "", to = "", limit = 0 } = {}
     // 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, context))
+    .map((row) => scopeSessionUsage(row, from, to, context))
+    .filter((row) => !Array.isArray(row.usage_buckets) || finite(row.total_tokens) > 0));
   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;