session-steward 0.7.0 → 0.8.0

package/lib/providers/codex/events.mjs

@@ -7,6 +7,7 @@ import {
   createSessionEventsResult,
   finalizeSessionEventComposition,
   SESSION_EVENT_KIND,
+  SESSION_EVENT_READ_MODE,
   SESSION_EVENT_REASON,
 } from "../../session-events.mjs";
 import {
@@ -16,6 +17,7 @@ import {
 } from "../../session-event-reader.mjs";
 import { visitJsonlSnapshotEntries } from "../../storage/jsonl.mjs";
 import { getSessionRecord, loadSessionStore } from "./store.mjs";
+import { createSessionTokenScan } from "./tokens.mjs";
 
 const PROVIDER_ID = "codex";
 const RECORD_CLASSIFICATION = Object.freeze({
@@ -325,12 +327,15 @@ function outputText(payload) {
   return contentText(payload.output ?? payload.content ?? payload.stderr ?? payload.stdout).trim() || null;
 }
 
-function emptyResult({ cwd = null, origin = null, reason }) {
+function emptyResult({ counted = false, cwd = null, origin = null, reason }) {
   return createSessionEventsResult({
     coverage: createSessionEventCoverage(),
     events: [],
     header: createSessionEventHeader({ cwd, origin, provider: PROVIDER_ID }),
     reason,
+    // The reason the timeline is empty is the same reason there is no count:
+    // no transcript to read. Saying so beats leaving the field to guess.
+    tokens: counted ? { available: false, reason } : null,
     window: {
       complete: true,
       end: null,
@@ -352,6 +357,7 @@ export async function readSessionEvents({
   maxLineBytes,
   mode,
   signal,
+  tokens = false,
 }) {
   const record = await findSessionRecord({ codexHome, id });
   if (!record) return null;
@@ -359,12 +365,19 @@ export async function readSessionEvents({
   const origin = record.recordSource ?? null;
   if (!record.rolloutPath) {
     return emptyResult({
+      counted: tokens,
       cwd: record.cwd || null,
       origin,
       reason: SESSION_EVENT_REASON.NO_TRANSCRIPT_PATH,
     });
   }
 
+  // A preview stops as soon as it has enough events, so a count taken from it
+  // would be of part of the file while reading as the whole.
+  const tokenScan = tokens && mode !== SESSION_EVENT_READ_MODE.PREVIEW
+    ? await createSessionTokenScan({ codexHome, maxLineBytes, record, signal })
+    : null;
+
   const coverage = createSessionEventCoverage();
   const summary = createSessionEventSummary();
   const composition = createSessionEventComposition();
@@ -778,6 +791,7 @@ export async function readSessionEvents({
         }
 
         composition[compositionSegment(entry.parsed)] += entry.bytes;
+        tokenScan?.record(entry.parsed);
         const result = handleRecord(entry.parsed, entry.index);
         coverage[result.classification] += 1;
         if (result.duplicate) coverage.duplicates += 1;
@@ -791,6 +805,7 @@ export async function readSessionEvents({
   } catch (error) {
     if (error?.code === "ENOENT") {
       return emptyResult({
+        counted: tokens,
         cwd: record.cwd || null,
         origin,
         reason: SESSION_EVENT_REASON.TRANSCRIPT_MISSING,
@@ -811,6 +826,7 @@ export async function readSessionEvents({
       : null,
     composition: finalizeSessionEventComposition(composition, read.snapshotBytes),
     summary,
+    tokens: tokenScan ? tokenScan.summarize(read) : null,
     window: readState.window(read),
   });
 }

package/lib/providers/codex/index.mjs

@@ -1,4 +1,5 @@
 import { readSessionEvents } from "./events.mjs";
+import { readSessionTokens } from "./tokens.mjs";
 import {
   assertDeepCleanupSupported,
   diagnoseStorageCompatibility,
@@ -40,6 +41,7 @@ export const codexProvider = Object.freeze({
   planSessionDeletion,
   preflightSessionDeletion,
   readSessionEvents,
+  readSessionTokens,
   restoreSessionDeletionBackup,
   verifySessionDeletion,
 });

package/lib/providers/codex/tokens.mjs

@@ -0,0 +1,317 @@
+import { addTokenTotals, createTokenTotals, summarizeSessionTokens } from "../../session-tokens.mjs";
+import { readCachedTokens, readFileStamp, signatureBytes, writeCachedTokens } from "../../session-token-cache.mjs";
+import { visitJsonlSnapshotEntries } from "../../storage/jsonl.mjs";
+import { getSessionRecord, loadSessionStore } from "./store.mjs";
+
+const PAYLOAD_TYPE = "token_count";
+
+// Codex reports a running total plus the cost of the turn that produced it. The
+// running total is not a session total: subagents inherit the parent thread's
+// counter, resume restarts it, and the same figures are re-emitted when nothing
+// advanced. Only `last_token_usage` on an event whose running total *moved* is a
+// turn that belongs to this session.
+function readCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.trunc(value) : 0;
+}
+
+// Codex counts cached tokens inside `input_tokens`; whether cache writes are
+// also inside it is unconfirmed, because the field is zero everywhere we can
+// observe. Subtracting assumes they are. The clamp keeps a wrong assumption from
+// reaching the UI as a negative slice, and reports itself so it can be fixed
+// from evidence rather than replaced with a second guess.
+function normalizeUsage(value) {
+  if (!value || typeof value !== "object") return null;
+
+  const input = readCount(value.input_tokens);
+  const cachedInput = readCount(value.cached_input_tokens);
+  const cacheWrites = readCount(value.cache_write_input_tokens);
+  const output = readCount(value.output_tokens);
+  const underflows = input - cachedInput - cacheWrites < 0;
+  const freshInput = Math.max(0, underflows ? input - cachedInput : input - cachedInput - cacheWrites);
+  // The bar is drawn from these four segments, so the total has to be their sum
+  // or the slices add up to more than the whole. Codex's own `total_tokens`
+  // agrees on every billable event in the corpus (53,685 of 53,685), but it
+  // cannot agree once the clamp above has moved a token, and the clamp exists
+  // precisely because that case is unobserved rather than impossible.
+  const total = freshInput + cachedInput + cacheWrites + output;
+
+  return {
+    // A turn with no input and no output has nothing to bill, whatever its
+    // reported total says.
+    billable: total > 0,
+    cachedInput,
+    cacheWrites,
+    freshInput,
+    output,
+    // Reasoning is part of output, never alongside it.
+    reasoning: Math.min(output, readCount(value.reasoning_output_tokens)),
+    // Codex advances its running counter by its own arithmetic, past events that
+    // report no components at all. Whether the counter moved is a question about
+    // its figure, so that figure is kept rather than recomputed.
+    reportedTotal: readCount(value.total_tokens),
+    total,
+    underflows,
+  };
+}
+
+function readModel(recordValue, payload) {
+  if (recordValue.type === "session_meta") return payload?.model ?? null;
+  if (recordValue.type === "turn_context") return payload?.model ?? recordValue.model ?? null;
+  if (payload?.type === "thread_settings_applied") return payload.thread_settings?.model ?? null;
+  return null;
+}
+
+function isSubagentSource(source) {
+  return Boolean(source) && typeof source === "object" && "subagent" in source;
+}
+
+// A turn is identified by two numbers: the counter it advanced to, and what it
+// cost. `signatures` records those as plain number arrays — 16 bytes a turn,
+// where the turn objects they replace cost 179 — and `prefix` plays a parent's
+// recording back against a fork as the fork streams, so the fork retains nothing
+// at all. Neither is on by default; a plain session needs neither.
+export function createCodexTokenCollector({ prefix = null, signatures = false } = {}) {
+  const totals = createTokenTotals();
+  const modelTotals = new Map();
+  const inherited = prefix ? createTokenTotals() : null;
+  const own = prefix ? createTokenTotals() : null;
+  const ownModels = prefix ? new Map() : null;
+  const runningTotals = signatures ? [] : null;
+  const turnTotals = signatures ? [] : null;
+  let cacheWriteUnderflow = false;
+  let countedTurns = 0;
+  let forkedFromId = null;
+  let inheritedTurns = 0;
+  let matchingPrefix = Boolean(prefix);
+  let model = null;
+  let observedEvents = 0;
+  let previousRunningTotal = null;
+  let sessionId = null;
+  let subagent = false;
+
+  function countTurn(usage, runningTotal) {
+    countedTurns += 1;
+    if (usage.underflows) cacheWriteUnderflow = true;
+    addTokenTotals(totals, usage);
+
+    const key = model ?? "Unknown";
+    if (!modelTotals.has(key)) modelTotals.set(key, createTokenTotals());
+    addTokenTotals(modelTotals.get(key), usage);
+
+    if (signatures) {
+      runningTotals.push(runningTotal);
+      turnTotals.push(usage.total);
+    }
+
+    if (!prefix) return;
+
+    // The replay is a leading run, so the first turn that fails to match ends
+    // it. Everything from there on is this session's own work.
+    if (matchingPrefix) {
+      if (
+        inheritedTurns < prefix.runningTotals.length
+        && prefix.runningTotals[inheritedTurns] === runningTotal
+        && prefix.turnTotals[inheritedTurns] === usage.total
+      ) {
+        inheritedTurns += 1;
+        addTokenTotals(inherited, usage);
+        return;
+      }
+
+      matchingPrefix = false;
+    }
+
+    addTokenTotals(own, usage);
+    if (!ownModels.has(key)) ownModels.set(key, createTokenTotals());
+    addTokenTotals(ownModels.get(key), usage);
+  }
+
+  return {
+    record(recordValue) {
+      if (!recordValue || typeof recordValue !== "object") return;
+      const payload = recordValue.payload && typeof recordValue.payload === "object"
+        ? recordValue.payload
+        : null;
+
+      if (recordValue.type === "session_meta" && payload && sessionId === null) {
+        sessionId = payload.id ?? null;
+        forkedFromId = payload.forked_from_id ?? null;
+        subagent = isSubagentSource(payload.source);
+      }
+
+      const nextModel = readModel(recordValue, payload);
+      if (nextModel) model = nextModel;
+
+      if (payload?.type !== PAYLOAD_TYPE) return;
+      observedEvents += 1;
+
+      // `info` is absent on some builds; the event carries nothing to bill.
+      const info = payload.info;
+      if (!info || typeof info !== "object") return;
+
+      const running = normalizeUsage(info.total_token_usage);
+      const turn = normalizeUsage(info.last_token_usage);
+      if (!running || !turn) return;
+
+      // Unchanged running total means the event was re-emitted, or carries
+      // context-size telemetry rather than a billed turn. Either way it is not
+      // new spend. A *decrease* is a resume resetting the counter, which is.
+      if (previousRunningTotal !== null && running.reportedTotal === previousRunningTotal) return;
+
+      previousRunningTotal = running.reportedTotal;
+
+      // Exceeding the context window makes Codex advance the running total to a
+      // synthetic figure while reporting a turn with no components. The advance
+      // is real bookkeeping; the turn behind it is not spend.
+      if (!turn.billable) return;
+
+      countTurn(turn, running.reportedTotal);
+    },
+
+    result() {
+      return {
+        available: countedTurns > 0,
+        byModel: [...modelTotals]
+          .map(([name, modelSpend]) => ({ model: name, totals: modelSpend }))
+          .sort((left, right) => right.totals.total - left.totals.total),
+        cacheWriteUnderflow,
+        countedTurns,
+        fork: prefix
+          ? {
+            inherited,
+            inheritedTurns,
+            own,
+            ownByModel: [...ownModels]
+              .map(([name, modelSpend]) => ({ model: name, totals: modelSpend }))
+              .sort((left, right) => right.totals.total - left.totals.total),
+            ownTurns: countedTurns - inheritedTurns,
+            parentAvailable: true,
+          }
+          : null,
+        forkedFromId,
+        observedEvents,
+        sessionId,
+        signatures: signatures ? { runningTotals, turnTotals } : null,
+        subagent,
+        totals,
+      };
+    },
+  };
+}
+
+export async function collectCodexSessionTokens(filePath, { maxLineBytes, prefix, signatures, signal } = {}) {
+  const collector = createCodexTokenCollector({ prefix, signatures });
+  const { complete, snapshotBytes } = await visitJsonlSnapshotEntries(
+    filePath,
+    ({ parsed }) => {
+      // A closed panel should not leave a large transcript being scanned.
+      if (signal?.aborted) return false;
+      if (parsed && typeof parsed === "object") collector.record(parsed);
+      return true;
+    },
+    maxLineBytes === undefined ? {} : { maxLineBytes },
+  );
+
+  return { ...collector.result(), complete, snapshotBytes };
+}
+
+// A fork's rollout replays the parent's turns before its own, so the two files
+// share a leading run of identical turns. Everything after that run is this
+// session's own work; the run itself was already billed to the parent and must
+// not be counted twice, in a rollup or on the session's own panel.
+//
+// There is no marker for the boundary inside the fork file. Anchoring at the
+// last `session_meta` locates it 3 times in 44; a timestamp-gap test manages 40
+// in 44, failing on the subagents that matter most. Comparing against the parent
+// is the only exact method — so the parent is read first, and the fork is split
+// as it streams rather than buffered and diffed afterwards.
+async function findSessionRecord({ codexHome, id }) {
+  const record = await getSessionRecord({ codexHome, id });
+  if (record) return record;
+  return (await loadSessionStore({ codexHome })).recordsById.get(id) ?? null;
+}
+
+// A transcript can be deleted between the listing and the read. That is an
+// answer about the session, not a failure of the server, and the timeline
+// reader already treats it as one.
+async function collectOrMissing(filePath, options) {
+  try {
+    return await collectCodexSessionTokens(filePath, options);
+  } catch (error) {
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+}
+
+// The parent is read only to locate the end of the replay, so its signatures
+// are cached: a fork reopened, or several forks of one parent, read it once.
+async function readParentSignatures({ codexHome, id, maxLineBytes, signal }) {
+  const record = await findSessionRecord({ codexHome, id });
+  if (!record?.rolloutPath) return null;
+
+  const stamp = await readFileStamp(record.rolloutPath);
+  const cached = readCachedTokens("signatures", record.rolloutPath, stamp);
+  if (cached !== undefined) return cached;
+
+  const parent = await collectOrMissing(record.rolloutPath, { maxLineBytes, signatures: true, signal });
+  const signatures = parent?.signatures ?? null;
+  if (signal?.aborted || parent?.complete === false) return signatures;
+  return writeCachedTokens("signatures", record.rolloutPath, stamp, signatures, signatureBytes(signatures));
+}
+
+function summarizeCollected(collected) {
+  return summarizeSessionTokens(collected, {
+    fork: collected.fork,
+    // The file itself is the authority on whether this is a fork. If it says so
+    // and no parent was read, the total still carries the replay.
+    forkParentMissing: Boolean(collected.forkedFromId) && !collected.fork,
+  });
+}
+
+// Reading the timeline already streams every record of the same file, so the
+// count rides along with that pass instead of paying for a second one. The
+// parent, when there is one, still has to be read first — and is cached.
+export async function createSessionTokenScan({ codexHome, maxLineBytes, record, signal }) {
+  if (!record?.rolloutPath) return null;
+  const stamp = await readFileStamp(record.rolloutPath);
+  const cached = readCachedTokens("summary", record.rolloutPath, stamp);
+  if (cached !== undefined) return { cached, record() {}, summarize: () => cached };
+
+  const prefix = record.forkedFromId
+    ? await readParentSignatures({ codexHome, id: record.forkedFromId, maxLineBytes, signal })
+    : null;
+  const collector = createCodexTokenCollector({ prefix });
+
+  return {
+    cached: null,
+    record(value) {
+      collector.record(value);
+    },
+    summarize({ complete }) {
+      const summary = summarizeCollected({ ...collector.result(), complete });
+      if (signal?.aborted || complete === false) return summary;
+      return writeCachedTokens("summary", record.rolloutPath, stamp, summary);
+    },
+  };
+}
+
+export async function readSessionTokens({ codexHome, id, maxLineBytes, signal }) {
+  const record = await findSessionRecord({ codexHome, id });
+  if (!record) return null;
+  if (!record.rolloutPath) return { available: false, reason: "no-transcript-path" };
+
+  const stamp = await readFileStamp(record.rolloutPath);
+  const cached = readCachedTokens("summary", record.rolloutPath, stamp);
+  if (cached !== undefined) return cached;
+
+  const prefix = record.forkedFromId
+    ? await readParentSignatures({ codexHome, id: record.forkedFromId, maxLineBytes, signal })
+    : null;
+
+  const collected = await collectOrMissing(record.rolloutPath, { maxLineBytes, prefix, signal });
+  if (!collected) return { available: false, reason: "transcript-missing" };
+
+  const summary = summarizeCollected(collected);
+  if (signal?.aborted || collected.complete === false) return summary;
+  return writeCachedTokens("summary", record.rolloutPath, stamp, summary);
+}

package/lib/server.mjs

@@ -865,6 +865,9 @@ export async function startLocalServer({ claudeHome, codexHome, configDirectory,
           id,
           limit: getSessionEventLimit(requestUrl.searchParams.get("limit")),
           signal: controller.signal,
+          // The scan is already streaming the whole transcript, so the count
+          // comes back with it rather than costing a second pass over it.
+          tokens: true,
         });
 
         if (controller.signal.aborted) return;
@@ -878,6 +881,33 @@ export async function startLocalServer({ claudeHome, codexHome, configDirectory,
         return;
       }
 
+      if (request.method === "GET" && requestUrl.pathname === "/api/session-tokens") {
+        const controller = new AbortController();
+        const abortRead = () => controller.abort();
+        request.once("aborted", abortRead);
+        response.once("close", () => {
+          if (!response.writableEnded) abortRead();
+        });
+        const providerId = resolveProviderId(requestUrl.searchParams.get("provider"));
+        const provider = getProvider(providerId);
+        const id = getSessionId(requestUrl.searchParams.get("id"));
+        const tokens = await provider.readSessionTokens({
+          ...providerOptions(providerId, settings.getHome(providerId)),
+          id,
+          signal: controller.signal,
+        });
+
+        if (controller.signal.aborted) return;
+
+        if (!tokens) {
+          sendJson(response, 404, { error: "Session not found." });
+          return;
+        }
+
+        sendJson(response, 200, { tokens });
+        return;
+      }
+
       if (request.method === "GET" && requestUrl.pathname.startsWith("/api/sessions/")) {
         const providerId = resolveProviderId(requestUrl.searchParams.get("provider"));
         const provider = getProvider(providerId);

package/lib/session-events.mjs

@@ -318,6 +318,7 @@ export function createSessionEventsResult({
   header,
   reason = null,
   summary,
+  tokens = null,
   window = {},
 } = {}) {
   const normalizedCoverage = createSessionEventCoverage(coverage);
@@ -370,6 +371,9 @@ export function createSessionEventsResult({
     reason,
     composition: normalizedComposition,
     summary: normalizedSummary,
+    // Counted during this same pass, so the panel's header does not have to
+    // read the transcript a second time to fill in two fields.
+    tokens,
     window: {
       complete,
       end,

package/lib/session-token-cache.mjs

@@ -0,0 +1,76 @@
+import fs from "node:fs/promises";
+
+// A token count is a pure function of a transcript's bytes, so an unchanged
+// file never needs reading twice — which matters most for a fork, whose parent
+// is a whole extra file scanned only to find where the replay ends.
+//
+// Identity is dev+inode alongside size and mtime, mirroring
+// `transcriptActivityCache` (`lib/providers/claude-code/store.mjs:39`): a path
+// that has been replaced is a different file, not a stale entry. An active
+// session's mtime moves on every write, so it re-reads rather than serving a
+// count that has stopped growing.
+// Two limits, because entries are not the same size. A session summary is about
+// a kilobyte whatever the transcript weighed; a fork parent's signature
+// recording is 16 bytes a turn, so 512 of those is a number with no ceiling.
+// Counting entries bounds the bookkeeping, counting bytes bounds the memory.
+const MAX_ENTRIES = 512;
+const MAX_BYTES = 32 * 1024 * 1024;
+const cache = new Map();
+let cachedBytes = 0;
+
+export async function readFileStamp(filePath) {
+  if (!filePath) return null;
+  try {
+    const stats = await fs.stat(filePath);
+    return `${stats.dev ?? ""}:${stats.ino ?? ""}:${stats.size}:${stats.mtimeMs}`;
+  } catch {
+    return null;
+  }
+}
+
+export function readCachedTokens(kind, filePath, stamp) {
+  if (!stamp) return undefined;
+  const entry = cache.get(`${kind} ${filePath}`);
+  return entry?.stamp === stamp ? entry.value : undefined;
+}
+
+function evict(key) {
+  const entry = cache.get(key);
+  if (!entry) return;
+  cachedBytes -= entry.bytes;
+  cache.delete(key);
+}
+
+export function writeCachedTokens(kind, filePath, stamp, value, bytes = 1024) {
+  if (!stamp) return value;
+  // An entry that cannot fit inside the budget would evict everything else and
+  // then sit there alone. Reading it again is cheaper than that.
+  if (bytes > MAX_BYTES) return value;
+
+  const key = `${kind} ${filePath}`;
+  evict(key);
+  cache.set(key, { bytes, stamp, value });
+  cachedBytes += bytes;
+
+  while (cache.size > MAX_ENTRIES || cachedBytes > MAX_BYTES) {
+    const oldest = cache.keys().next().value;
+    if (oldest === key) break;
+    evict(oldest);
+  }
+
+  return value;
+}
+
+// Two numbers a turn, in arrays V8 stores unboxed.
+export function signatureBytes(signatures) {
+  return signatures ? signatures.runningTotals.length * 16 : 0;
+}
+
+export function sessionTokenCacheStats() {
+  return { bytes: cachedBytes, entries: cache.size, maxBytes: MAX_BYTES, maxEntries: MAX_ENTRIES };
+}
+
+export function clearSessionTokenCache() {
+  cache.clear();
+  cachedBytes = 0;
+}

package/lib/session-tokens.mjs

@@ -0,0 +1,73 @@
+// The shape both providers report in, and the derived figures the UI renders.
+//
+// Codex counts cached tokens inside its input figure and Anthropic counts them
+// beside it, so the providers cannot share a formula. They share this shape
+// instead: each collector resolves its own cache math and hands back the same
+// four buckets, which always sum to the total.
+export const TOKEN_SEGMENT_KEYS = Object.freeze(["freshInput", "cachedInput", "cacheWrites", "output"]);
+
+export function createTokenTotals() {
+  return { cachedInput: 0, cacheWrites: 0, freshInput: 0, output: 0, reasoning: 0, total: 0 };
+}
+
+export function addTokenTotals(target, usage) {
+  target.cachedInput += usage.cachedInput;
+  target.cacheWrites += usage.cacheWrites;
+  target.freshInput += usage.freshInput;
+  target.output += usage.output;
+  target.reasoning += usage.reasoning;
+  target.total += usage.total;
+  return target;
+}
+
+function share(part, whole) {
+  return whole > 0 ? part / whole : 0;
+}
+
+function inputTokens(totals) {
+  return totals.freshInput + totals.cachedInput + totals.cacheWrites;
+}
+
+// A fork's rollout replays its parent's turns before its own. The bar describes
+// what this session actually spent, so the inherited half is reported alongside
+// it rather than folded into it.
+export function summarizeSessionTokens(collected, { fork = null, forkParentMissing = false } = {}) {
+  if (!collected || collected.available !== true) {
+    return { available: false, reason: collected?.complete === false ? "incomplete" : "absent" };
+  }
+
+  const totals = fork ? fork.own : collected.totals;
+  const byModel = fork ? fork.ownByModel : collected.byModel;
+  const warnings = [];
+  if (collected.cacheWriteUnderflow) warnings.push("cache-write-underflow");
+  if (collected.complete === false) warnings.push("incomplete-scan");
+  // A fork whose parent is gone cannot be split, so the total still carries the
+  // inherited turns. Say so rather than presenting it as this session's spend.
+  if (forkParentMissing) warnings.push("fork-parent-missing");
+
+  return {
+    available: true,
+    byModel: (byModel ?? []).map(({ model, totals: modelTotals }) => ({
+      model,
+      share: share(modelTotals.total, totals.total),
+      tokens: modelTotals.total,
+    })),
+    // "N% of input was served from cache" — output is not part of the question.
+    cacheHitRate: inputTokens(totals) > 0 ? share(totals.cachedInput, inputTokens(totals)) : null,
+    compactions: collected.compactions ?? 0,
+    inherited: fork ? { tokens: fork.inherited.total, turns: fork.inheritedTurns } : null,
+    // Reasoning is part of output, so it is reported against output rather than
+    // as a segment of its own.
+    reasoning: totals.reasoning > 0
+      ? { share: share(totals.reasoning, totals.output), tokens: totals.reasoning }
+      : null,
+    segments: TOKEN_SEGMENT_KEYS.map((key) => ({
+      key,
+      share: share(totals[key], totals.total),
+      tokens: totals[key],
+    })),
+    total: totals.total,
+    totals,
+    warnings,
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "session-steward",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Codex and Claude Code session manager - browse, back up, and delete old sessions. Local browser UI + CLI.",
   "license": "MIT",
   "author": "Mallik Cheripally",
@@ -59,6 +59,7 @@
     "benchmark:overview": "node --expose-gc test/benchmarks/codex-overview.mjs",
     "benchmark:scale": "node --expose-gc test/benchmarks/codex-list.mjs",
     "benchmark:size": "node --expose-gc test/benchmarks/codex-size.mjs",
+    "benchmark:tokens": "node --expose-gc test/benchmarks/session-tokens.mjs",
     "benchmark:transcripts": "node --expose-gc test/benchmarks/codex-transcripts.mjs",
     "benchmark:versioned-stores": "node --expose-gc test/benchmarks/codex-versioned-stores.mjs",
     "prepack": "npm run build",