session-steward 0.6.0 → 0.8.0

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

@@ -206,6 +206,72 @@ export function createSessionEventCoverage({
   };
 }
 
+export function createSessionEventSummary({ asks = 0, commands = 0, edits = 0 } = {}) {
+  return {
+    asks: requiredCount(asks, "summary.asks"),
+    commands: requiredCount(commands, "summary.commands"),
+    edits: requiredCount(edits, "summary.edits"),
+  };
+}
+
+// Ordered largest-concept-first so the bar and its legend agree
+export const SESSION_EVENT_COMPOSITION_SEGMENTS = Object.freeze([
+  "toolOutput",
+  "largeRecords",
+  "compaction",
+  "attachments",
+  "messages",
+  "edits",
+  "reasoning",
+  "other",
+]);
+
+export function createSessionEventComposition({
+  attachments = 0,
+  compaction = 0,
+  edits = 0,
+  largeRecords = 0,
+  messages = 0,
+  other = 0,
+  reasoning = 0,
+  toolOutput = 0,
+  total = 0,
+} = {}) {
+  const composition = {
+    attachments: requiredCount(attachments, "composition.attachments"),
+    compaction: requiredCount(compaction, "composition.compaction"),
+    edits: requiredCount(edits, "composition.edits"),
+    largeRecords: requiredCount(largeRecords, "composition.largeRecords"),
+    messages: requiredCount(messages, "composition.messages"),
+    other: requiredCount(other, "composition.other"),
+    reasoning: requiredCount(reasoning, "composition.reasoning"),
+    toolOutput: requiredCount(toolOutput, "composition.toolOutput"),
+    total: requiredCount(total, "composition.total"),
+  };
+
+  const segments = SESSION_EVENT_COMPOSITION_SEGMENTS
+    .reduce((sum, segment) => sum + composition[segment], 0);
+
+  if (segments !== composition.total) {
+    throw new TypeError("Session event composition segments must add up to the transcript size.");
+  }
+
+  return composition;
+}
+
+export function finalizeSessionEventComposition(composition, transcriptBytes) {
+  const attributed = SESSION_EVENT_COMPOSITION_SEGMENTS
+    .filter((segment) => segment !== "other")
+    .reduce((sum, segment) => sum + (composition[segment] ?? 0), 0);
+  const total = Math.max(transcriptBytes ?? 0, attributed);
+
+  return createSessionEventComposition({
+    ...composition,
+    other: total - attributed,
+    total,
+  });
+}
+
 export function sessionEventCoveragePercent(coverage) {
   const normalizedCoverage = createSessionEventCoverage(coverage);
   const considered = normalizedCoverage.total - normalizedCoverage.skipped;
@@ -246,13 +312,18 @@ export function createSessionEventHeader({
 }
 
 export function createSessionEventsResult({
+  composition,
   coverage,
   events = [],
   header,
   reason = null,
+  summary,
+  tokens = null,
   window = {},
 } = {}) {
   const normalizedCoverage = createSessionEventCoverage(coverage);
+  const normalizedSummary = createSessionEventSummary(summary);
+  const normalizedComposition = createSessionEventComposition(composition);
 
   if (
     normalizedCoverage.recognized
@@ -298,6 +369,11 @@ export function createSessionEventsResult({
     events: [...events],
     header: createSessionEventHeader(header),
     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/lib/storage/jsonl.mjs

@@ -41,7 +41,12 @@ export async function* readJsonlEntries(filePath) {
 }
 
 function appendLineBytes(state, bytes, maxLineBytes) {
-  if (state.oversized || bytes.length === 0) return;
+  if (bytes.length === 0) return;
+
+  // Counted even once a line is oversized, because the largest records in a
+  // transcript are exactly the ones that stop being buffered.
+  state.totalBytes += bytes.length;
+  if (state.oversized) return;
 
   if (state.length + bytes.length > maxLineBytes) {
     state.length = 0;
@@ -69,17 +74,20 @@ function createLineState(maxLineBytes) {
     buffer: Buffer.allocUnsafe(Math.min(JSONL_STARTING_LINE_BYTES, maxLineBytes)),
     length: 0,
     oversized: false,
+    totalBytes: 0,
   };
 }
 
 function resetLineState(state) {
   state.length = 0;
   state.oversized = false;
+  state.totalBytes = 0;
 }
 
 function snapshotEntry(state, index) {
   if (state.oversized) {
     return {
+      bytes: state.totalBytes,
       index,
       oversized: true,
       parsed: null,
@@ -93,6 +101,7 @@ function snapshotEntry(state, index) {
 
   const entry = parseLine(bytes.toString("utf8"), index);
   return {
+    bytes: state.totalBytes,
     index: entry.index,
     oversized: false,
     parsed: entry.parsed,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "session-steward",
-  "version": "0.6.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",