tledger 0.1.4 → 0.2.0

package/lib/{token-ledger-collector.mjs → token-ledger-importer.mjs}

@@ -4,7 +4,7 @@
  * Token Ledger local collector
  *
  * Reads Codex's local JSONL rollouts and metadata database, then writes a
- * privacy-reduced snapshot for the Token Ledger CLI. It never exports message
+ * privacy-reduced snapshot for the Token Ledger site. It never exports message
  * bodies, tool arguments/results, reasoning text, instructions, credential
  * fields, or full local paths in the generated snapshot.
  *
@@ -23,7 +23,7 @@ import {
   stat,
   writeFile,
 } from "node:fs/promises";
-import { availableParallelism, homedir } from "node:os";
+import { homedir } from "node:os";
 import {
   basename,
   dirname,
@@ -32,65 +32,33 @@ import {
 } from "node:path";
 import { pathToFileURL } from "node:url";
 import { createInterface } from "node:readline";
-import {
-  isMainThread,
-  parentPort,
-  Worker,
-  workerData,
-} from "node:worker_threads";
-
-import { normalizeModelIdentifier } from "./token-ledger-models.mjs";
+import { DatabaseSync } from "node:sqlite";
 
 const SCHEMA_VERSION = 1;
+const RATE_CARD_AS_OF = "2026-08-17";
+const FAST_MODE_MULTIPLIER = 1.5;
+const RATE_CARD_URL = "https://help.openai.com/en/articles/20001106";
 const WEEK_MINUTES = 10_080;
-const DEFAULT_MAX_SCAN_WORKERS = 4;
-const MAX_SCAN_WORKERS = 6;
-const SCAN_WORKER_MODE = "token-ledger-rollout-scanner";
 const UUID_AT_END =
   /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i;
-const RELEVANT_RECORD_TYPE =
-  /"type"\s*:\s*"(?:session_meta|turn_context|task_started|thread_settings_applied|token_count|function_call|custom_tool_call|tool_search_call|web_search_call|image_generation_call)"/;
-const RESPONSE_CALL_TYPES = new Set([
-  "function_call",
-  "custom_tool_call",
-  "tool_search_call",
-  "web_search_call",
-  "image_generation_call",
-]);
-let databaseSyncPromise;
-
-function loadDatabaseSync() {
-  if (!databaseSyncPromise) {
-    databaseSyncPromise = (async () => {
-      const originalEmitWarning = process.emitWarning;
-      process.emitWarning = function emitWarning(warning, ...arguments_) {
-        const message = warning instanceof Error ? warning.message : String(warning);
-        const type = typeof arguments_[0] === "string"
-          ? arguments_[0]
-          : arguments_[0]?.type;
-        if (
-          type === "ExperimentalWarning" &&
-          message === "SQLite is an experimental feature and might change at any time"
-        ) {
-          return;
-        }
-        return originalEmitWarning.call(this, warning, ...arguments_);
-      };
-      try {
-        return (await import("node:sqlite")).DatabaseSync;
-      } finally {
-        process.emitWarning = originalEmitWarning;
-      }
-    })();
-  }
-  return databaseSyncPromise;
-}
+
+const RATE_CARD = {
+  "gpt-5.6-sol": { input: 125, cached: 12.5, output: 750 },
+  "gpt-5.6-terra": { input: 50, cached: 5, output: 300 },
+  "gpt-5.6-luna": { input: 5, cached: 0.5, output: 30 },
+  "gpt-5.5": { input: 125, cached: 12.5, output: 750 },
+  "gpt-5.5-cyber": { input: 500, cached: 50, output: 3_000 },
+  "gpt-5.4": { input: 62.5, cached: 6.25, output: 375 },
+  "gpt-5.4-mini": { input: 18.75, cached: 1.875, output: 113 },
+  "gpt-5.3-codex": { input: 43.75, cached: 4.375, output: 350 },
+  "gpt-5.2": { input: 43.75, cached: 4.375, output: 350 },
+};
 
 function usage() {
   return `Token Ledger local collector
 
 Usage:
-  node lib/token-ledger-collector.mjs [options]
+  node token-ledger-importer.mjs [options]
 
 Options:
   --output <file>       Snapshot destination (default: token-ledger-snapshot.json)
@@ -99,9 +67,10 @@ Options:
   --no-archived         Skip archived_sessions
   --help                Show this help
 
-The snapshot contains local token metadata and project labels only. It never
-contains display titles, message bodies, tool payloads, reasoning text,
-credential fields, or full local paths. Project labels can still be sensitive.`;
+The snapshot contains usage metadata and Codex display titles only. It never
+contains message bodies, tool payloads, reasoning text, credential fields, or
+full local paths in its output. Codex display titles may contain user-written
+text.`;
 }
 
 function parseArgs(argv) {
@@ -143,45 +112,6 @@ function hash(value, length = 24) {
   return createHash("sha256").update(String(value)).digest("hex").slice(0, length);
 }
 
-export function sourceFingerprint(codexHome, includeArchived = true) {
-  return hash(JSON.stringify({
-    codexHome: resolve(codexHome),
-    includeArchived,
-  }));
-}
-
-function sanitizeLabel(value, fallback = "unknown") {
-  const label = String(value ?? "")
-    .replace(/\u001b\][^\u0007]*(?:\u0007|\u001b\\)/g, "")
-    .replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, "")
-    .replace(/[\u0000-\u001f\u007f-\u009f]+/g, " ")
-    .replace(/\s+/g, " ")
-    .trim();
-  return (label || fallback).slice(0, 160);
-}
-
-export async function writePrivateSnapshot(output, snapshot) {
-  const destination = resolve(output);
-  const directory = dirname(destination);
-  const temporary = resolve(
-    directory,
-    `.token-ledger-${process.pid}-${randomUUID()}.tmp`,
-  );
-  await mkdir(directory, { recursive: true });
-  try {
-    await writeFile(temporary, `${JSON.stringify(snapshot)}\n`, {
-      encoding: "utf8",
-      flag: "wx",
-      mode: 0o600,
-    });
-    await chmod(temporary, 0o600);
-    await rename(temporary, destination);
-    await chmod(destination, 0o600);
-  } finally {
-    await rm(temporary, { force: true });
-  }
-}
-
 function asFiniteNumber(value) {
   const number = Number(value ?? 0);
   return Number.isFinite(number) ? number : 0;
@@ -232,7 +162,35 @@ function hasDetailedBreakdown(usage) {
 }
 
 function normalizeModel(model) {
-  return normalizeModelIdentifier(sanitizeLabel(model, "unknown"));
+  const value = String(model || "unknown")
+    .trim()
+    .toLowerCase()
+    .replaceAll("_", "-");
+  if (RATE_CARD[value]) return value;
+  if (value.startsWith("gpt-5.6-sol")) return "gpt-5.6-sol";
+  if (value.startsWith("gpt-5.6-terra")) return "gpt-5.6-terra";
+  if (value.startsWith("gpt-5.6-luna")) return "gpt-5.6-luna";
+  if (value.startsWith("gpt-5.5-cyber")) return "gpt-5.5-cyber";
+  if (value.startsWith("gpt-5.5")) return "gpt-5.5";
+  if (value.startsWith("gpt-5.4-mini")) return "gpt-5.4-mini";
+  if (value.startsWith("gpt-5.4")) return "gpt-5.4";
+  if (value.startsWith("gpt-5.3-codex")) return "gpt-5.3-codex";
+  if (value.startsWith("gpt-5.2")) return "gpt-5.2";
+  return value || "unknown";
+}
+
+function creditsForUsage(model, usage) {
+  if (!hasDetailedBreakdown(usage)) return null;
+  const rate = RATE_CARD[normalizeModel(model)];
+  if (!rate) return null;
+  const cached = Math.min(usage.inputTokens, usage.cachedInputTokens);
+  const uncached = Math.max(0, usage.inputTokens - cached);
+  return (
+    (uncached * rate.input +
+      cached * rate.cached +
+      usage.outputTokens * rate.output) /
+    1_000_000
+  );
 }
 
 function parseStructuredSource(value) {
@@ -265,15 +223,9 @@ function sourceLabels(threadSource, rawSource) {
   if (source === "exec") return { source: "cli", useType: "cli" };
   if (source === "vscode") return { source: "desktop", useType: "interactive" };
   if (typeof source === "string" && source) {
-    return {
-      source: sanitizeLabel(source).slice(0, 40),
-      useType: sanitizeLabel(threadSource || "interactive").slice(0, 40),
-    };
+    return { source: source.slice(0, 40), useType: threadSource || "interactive" };
   }
-  return {
-    source: "unknown",
-    useType: sanitizeLabel(threadSource || "unknown").slice(0, 40),
-  };
+  return { source: "unknown", useType: threadSource || "unknown" };
 }
 
 function cleanRemote(value) {
@@ -281,15 +233,15 @@ function cleanRemote(value) {
   const remote = String(value).trim();
   const scp = remote.match(/^[^@]+@([^:]+):(.+)$/);
   if (scp) {
-    return sanitizeLabel(`${scp[1]}/${scp[2].replace(/\.git$/i, "")}`);
+    return `${scp[1]}/${scp[2].replace(/\.git$/i, "")}`;
   }
   try {
     const url = new URL(remote);
     const path = url.pathname.replace(/^\/+/, "").replace(/\.git$/i, "");
-    return sanitizeLabel(path ? `${url.hostname}/${path}` : url.hostname);
+    return path ? `${url.hostname}/${path}` : url.hostname;
   } catch {
     const withoutCredentials = remote.replace(/\/\/[^/@]+@/, "//");
-    return sanitizeLabel(withoutCredentials.replace(/\.git$/i, ""));
+    return withoutCredentials.replace(/\.git$/i, "").slice(0, 160);
   }
 }
 
@@ -297,15 +249,37 @@ function projectLabel(cwd, gitOrigin) {
   const remote = cleanRemote(gitOrigin);
   if (remote) {
     const parts = remote.split("/").filter(Boolean);
-    return sanitizeLabel(parts.slice(-2).join("/"), "Unknown project");
+    return parts.slice(-2).join("/") || "Unknown project";
   }
   const path = String(cwd || "").replaceAll("\\", "/").replace(/\/+$/, "");
   const worktree = path.match(/\/\.codex\/worktrees\/[^/]+\/([^/]+)$/);
   if (worktree) return worktree[1];
   const name = basename(path);
-  return name && name !== "." && name !== "/"
-    ? sanitizeLabel(name, "Unknown project")
-    : "Unknown project";
+  return name && name !== "." && name !== "/" ? name : "Unknown project";
+}
+
+function safeTitle(row, sessionTitle) {
+  const candidate = String(sessionTitle || row?.title || row?.name || "").trim();
+  const subagent =
+    row?.thread_source === "subagent" ||
+    String(row?.source || "").includes('"subagent"');
+  if (
+    !candidate ||
+    candidate.includes("<codex_delegation>") ||
+    (subagent && candidate.length > 120)
+  ) {
+    if (row?.agent_nickname) return `Subagent · ${row.agent_nickname}`;
+    return subagent ? `Subagent · ${String(row?.id || "").slice(0, 8)}` : "Untitled task";
+  }
+  return candidate
+    .replace(/\/Users\/[^\s"'`]+/g, "[local path]")
+    .replace(/\/(?:private\/)?tmp\/[^\s"'`]+/g, "[temporary path]")
+    .replace(
+      /\b(?:sk-[A-Za-z0-9_-]{16,}|lin_api_[A-Za-z0-9_-]{12,}|gh[pousr]_[A-Za-z0-9_-]{16,})\b/g,
+      "[redacted credential-like text]",
+    )
+    .replace(/\s+/g, " ")
+    .slice(0, 180);
 }
 
 async function pathExists(path) {
@@ -317,6 +291,28 @@ async function pathExists(path) {
   }
 }
 
+export async function writePrivateSnapshot(output, snapshot) {
+  const destination = resolve(output);
+  const directory = dirname(destination);
+  const temporary = resolve(
+    directory,
+    `.token-ledger-${process.pid}-${randomUUID()}.tmp`,
+  );
+  await mkdir(directory, { recursive: true });
+  try {
+    await writeFile(temporary, `${JSON.stringify(snapshot)}\n`, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 0o600,
+    });
+    await chmod(temporary, 0o600);
+    await rename(temporary, destination);
+    await chmod(destination, 0o600);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+}
+
 export async function listJsonlFiles(root) {
   if (!(await pathExists(root))) return [];
   const found = [];
@@ -333,33 +329,51 @@ export async function listJsonlFiles(root) {
   return found;
 }
 
-export async function sourceState(codexHome, includeArchived = true) {
+export async function latestSourceModifiedAt(codexHome, includeArchived = true) {
   const roots = [resolve(codexHome, "sessions")];
   if (includeArchived) {
     roots.push(resolve(codexHome, "archived_sessions"));
   }
   const files = (await Promise.all(roots.map((root) => listJsonlFiles(root))))
     .flat();
-  const preferredState = resolve(codexHome, "state_5.sqlite");
-  const legacyState = resolve(codexHome, "sqlite", "state_5.sqlite");
-  const statePath = (await pathExists(preferredState))
-    ? preferredState
-    : (await pathExists(legacyState))
-      ? legacyState
-      : null;
-  const sourceFiles = statePath ? [...files, statePath] : files;
-  if (!sourceFiles.length) {
-    return { latestMtimeMs: 0, fileCount: 0 };
+  const metadataFiles = [
+    resolve(codexHome, "session_index.jsonl"),
+    resolve(codexHome, "state_5.sqlite"),
+    resolve(codexHome, "sqlite", "state_5.sqlite"),
+  ];
+  const existingMetadataFiles = [];
+  for (const path of metadataFiles) {
+    if (await pathExists(path)) existingMetadataFiles.push(path);
   }
+  const sourceFiles = [...files, ...existingMetadataFiles];
+  if (!sourceFiles.length) return 0;
   const stats = await Promise.all(sourceFiles.map((path) => stat(path)));
-  return {
-    latestMtimeMs: Math.max(...stats.map((entry) => entry.mtimeMs)),
-    fileCount: sourceFiles.length,
-  };
+  return Math.max(...stats.map((entry) => entry.mtimeMs));
 }
 
-export async function latestSourceModifiedAt(codexHome, includeArchived = true) {
-  return (await sourceState(codexHome, includeArchived)).latestMtimeMs;
+async function readSessionTitles(path) {
+  const titles = new Map();
+  if (!(await pathExists(path))) return titles;
+  const input = createReadStream(path, { encoding: "utf8" });
+  const lines = createInterface({ input, crlfDelay: Infinity });
+  for await (const line of lines) {
+    if (!line.trim()) continue;
+    try {
+      const record = JSON.parse(line);
+      if (!record?.id || !record?.thread_name) continue;
+      const timestamp = new Date(record.updated_at || 0).getTime();
+      const current = titles.get(record.id);
+      if (!current || timestamp >= current.timestamp) {
+        titles.set(record.id, {
+          title: String(record.thread_name).replace(/\s+/g, " ").slice(0, 180),
+          timestamp,
+        });
+      }
+    } catch {
+      // The thread index is optional; malformed lines do not affect token totals.
+    }
+  }
+  return titles;
 }
 
 async function readState(codexHome) {
@@ -374,13 +388,13 @@ async function readState(codexHome) {
   const parents = new Map();
   if (!path) return { path: null, rows, parents };
 
-  const DatabaseSync = await loadDatabaseSync();
   const database = new DatabaseSync(path, { readOnly: true });
   try {
     const threadRows = database
       .prepare(
-        `SELECT id, created_at, updated_at, source, cwd,
-                tokens_used, git_origin_url, model, reasoning_effort,
+        `SELECT id, created_at, updated_at, source, cwd, title, name,
+                tokens_used, git_sha, git_branch, git_origin_url,
+                agent_nickname, agent_role, model, reasoning_effort,
                 thread_source
            FROM threads`,
       )
@@ -421,6 +435,7 @@ function taskStartCandidate(record, threadId, stateRow, fileContext) {
     cwd: fileContext.cwd || stateRow?.cwd || "",
     gitOrigin: fileContext.gitOrigin || stateRow?.git_origin_url || null,
     rawSource: fileContext.rawSource || stateRow?.source || null,
+    serviceTier: fileContext.serviceTier,
   };
 }
 
@@ -445,19 +460,38 @@ function rememberQuota(quotaMap, rateLimits, occurrence) {
       usedPercent,
       windowMinutes,
       resetsAt,
-      scope: rateLimits.limit_name ? "named" : "account",
+      planType: String(rateLimits.plan_type || "unknown"),
+      limitKey: hash(limitKey, 16),
+      limitName: rateLimits.limit_name
+        ? String(rateLimits.limit_name).slice(0, 80)
+        : null,
       source: "log",
       turnId: occurrence.turnId || null,
       originalLikely: occurrence.originalLikely,
     };
-    rememberQuotaCandidate(quotaMap, key, candidate);
+    const current = quotaMap.get(key);
+    if (
+      !current ||
+      (!current.originalLikely && candidate.originalLikely) ||
+      (current.originalLikely === candidate.originalLikely &&
+        candidate.timestamp < current.timestamp)
+    ) {
+      quotaMap.set(key, candidate);
+    }
   }
 }
 
 function responseCall(record) {
   if (record.type !== "response_item") return null;
   const payload = record.payload;
-  if (!payload || !RESPONSE_CALL_TYPES.has(payload.type)) return null;
+  const allowed = new Set([
+    "function_call",
+    "custom_tool_call",
+    "tool_search_call",
+    "web_search_call",
+    "image_generation_call",
+  ]);
+  if (!payload || !allowed.has(payload.type)) return null;
   return {
     type: payload.type,
     name: String(payload.name || payload.namespace || payload.type).slice(0, 80),
@@ -465,97 +499,17 @@ function responseCall(record) {
   };
 }
 
-export function rolloutLineMayAffectUsage(line) {
-  return RELEVANT_RECORD_TYPE.test(line);
-}
-
-function rolloutThreadId(path) {
+async function scanRollout(path, context) {
   const match = path.match(UUID_AT_END);
-  return match?.[1] || `file-${hash(path)}`;
-}
-
-function createScanFragment() {
-  return {
-    parents: new Map(),
-    origins: new Map(),
-    tokens: new Map(),
-    quotas: new Map(),
-    calls: new Map(),
-    parseErrors: 0,
-    duplicateEventsSkipped: 0,
-    correctionIntervals: 0,
-  };
-}
-
-function rememberOrigin(originMap, turnId, candidate) {
-  const current = originMap.get(turnId);
-  if (!current || candidate.deltaMs < current.deltaMs) {
-    originMap.set(turnId, candidate);
-  }
-}
-
-function rememberCall(callMap, key, candidate) {
-  const current = callMap.get(key);
-  if (!current || (!current.originalLikely && candidate.originalLikely)) {
-    callMap.set(key, candidate);
-  }
-}
-
-function rememberToken(context, key, candidate) {
-  const current = context.tokens.get(key);
-  if (!current) {
-    context.tokens.set(key, candidate);
-    return;
-  }
-  context.duplicateEventsSkipped += 1;
-  if (!current.originalLikely && candidate.originalLikely) {
-    current.occurrence = candidate.occurrence;
-    current.originalLikely = true;
-  }
-}
-
-function rememberQuotaCandidate(quotaMap, key, candidate) {
-  const current = quotaMap.get(key);
-  if (
-    !current ||
-    (!current.originalLikely && candidate.originalLikely) ||
-    (current.originalLikely === candidate.originalLikely &&
-      candidate.timestamp < current.timestamp)
-  ) {
-    quotaMap.set(key, candidate);
-  }
-}
-
-function mergeScanFragment(context, fragment) {
-  for (const [threadId, parentThreadId] of fragment.parents) {
-    context.parents.set(threadId, parentThreadId);
-  }
-  for (const [turnId, candidate] of fragment.origins) {
-    rememberOrigin(context.origins, turnId, candidate);
-  }
-  for (const [key, candidate] of fragment.tokens) {
-    rememberToken(context, key, candidate);
-  }
-  for (const [key, candidate] of fragment.quotas) {
-    rememberQuotaCandidate(context.quotas, key, candidate);
-  }
-  for (const [key, candidate] of fragment.calls) {
-    rememberCall(context.calls, key, candidate);
-  }
-  context.parseErrors += fragment.parseErrors;
-  context.duplicateEventsSkipped += fragment.duplicateEventsSkipped;
-  context.correctionIntervals += fragment.correctionIntervals;
-}
-
-async function scanRollout(path, stateRow) {
-  const context = createScanFragment();
-  const threadId = rolloutThreadId(path);
+  const threadId = match?.[1] || `file-${hash(path)}`;
+  const stateRow = context.stateRows.get(threadId);
   const fileContext = {
     model: stateRow?.model || "unknown",
     effort: stateRow?.reasoning_effort || "unknown",
     cwd: stateRow?.cwd || "",
     gitOrigin: stateRow?.git_origin_url || null,
     rawSource: stateRow?.source || null,
+    serviceTier: null,
   };
   const callOrdinals = new Map();
   let currentTurnId = "";
@@ -565,7 +519,7 @@ async function scanRollout(path, stateRow) {
   const input = createReadStream(path, { encoding: "utf8" });
   const lines = createInterface({ input, crlfDelay: Infinity });
   for await (const line of lines) {
-    if (!line || !rolloutLineMayAffectUsage(line)) continue;
+    if (!line.trim()) continue;
     let record;
     try {
       record = JSON.parse(line);
@@ -603,7 +557,10 @@ async function scanRollout(path, stateRow) {
           stateRow,
           fileContext,
         );
-        rememberOrigin(context.origins, currentTurnId, currentCandidate);
+        const currentBest = context.origins.get(currentTurnId);
+        if (!currentBest || currentCandidate.deltaMs < currentBest.deltaMs) {
+          context.origins.set(currentTurnId, currentCandidate);
+        }
       }
       continue;
     }
@@ -628,6 +585,10 @@ async function scanRollout(path, stateRow) {
       const settings = record.payload?.thread_settings;
       fileContext.model = settings?.model || fileContext.model;
       fileContext.effort = settings?.reasoning_effort || fileContext.effort;
+      const serviceTier = String(settings?.service_tier ?? "").trim();
+      fileContext.serviceTier = serviceTier
+        ? serviceTier.slice(0, 40)
+        : null;
       continue;
     }
 
@@ -645,6 +606,7 @@ async function scanRollout(path, stateRow) {
       cwd: fileContext.cwd,
       gitOrigin: fileContext.gitOrigin,
       rawSource: fileContext.rawSource,
+      serviceTier: fileContext.serviceTier,
     };
 
     const call = responseCall(record);
@@ -655,11 +617,14 @@ async function scanRollout(path, stateRow) {
       const callKey = call.stableId
         ? `id|${call.stableId}`
         : `ordinal|${ordinalBase}|${ordinal}`;
-      rememberCall(context.calls, callKey, {
-        turnId: currentTurnId,
-        threadId,
-        originalLikely,
-      });
+      const existing = context.calls.get(callKey);
+      if (!existing || (!existing.originalLikely && originalLikely)) {
+        context.calls.set(callKey, {
+          turnId: currentTurnId,
+          threadId,
+          originalLikely,
+        });
+      }
       continue;
     }
 
@@ -692,7 +657,17 @@ async function scanRollout(path, stateRow) {
     }
     previousCumulative = totalTuple[5];
 
-    rememberToken(context, eventKey, {
+    const existing = context.tokens.get(eventKey);
+    if (existing) {
+      context.duplicateEventsSkipped += 1;
+      if (!existing.originalLikely && originalLikely) {
+        existing.occurrence = occurrence;
+        existing.originalLikely = true;
+      }
+      continue;
+    }
+
+    context.tokens.set(eventKey, {
       key: eventKey,
       turnId: currentTurnId,
       usage: usageFromTuple(lastTuple),
@@ -701,172 +676,24 @@ async function scanRollout(path, stateRow) {
       dedupeQuality: currentTurnId ? "turn-exact" : "legacy-heuristic",
     });
   }
-  return context;
 }
 
-export function scanWorkerCount(
-  fileCount,
-  requestedWorkers = null,
-  parallelism = availableParallelism(),
-) {
-  if (!Number.isInteger(fileCount) || fileCount < 0) {
-    throw new Error("fileCount must be a non-negative integer.");
-  }
-  if (fileCount === 0) return 0;
-  if (
-    requestedWorkers !== null &&
-    (!Number.isInteger(requestedWorkers) ||
-      requestedWorkers < 1 ||
-      requestedWorkers > MAX_SCAN_WORKERS)
-  ) {
-    throw new Error(`workers must be an integer from 1 to ${MAX_SCAN_WORKERS}.`);
-  }
-  const detectedParallelism =
-    Number.isInteger(parallelism) && parallelism > 0 ? parallelism : 1;
-  const automaticWorkers = Math.min(
-    DEFAULT_MAX_SCAN_WORKERS,
-    Math.max(1, detectedParallelism - 1),
-  );
-  return Math.min(fileCount, requestedWorkers ?? automaticWorkers);
-}
-
-function reportScanProgress(onProgress, current, total, path) {
-  if (current === 1 || current === total || current % 10 === 0) {
-    onProgress({ current, total, path });
-  }
-}
-
-function workerFailure(message) {
-  const error = new Error(message?.error?.message || "Rollout scan worker failed.");
-  error.name = message?.error?.name || "Error";
-  if (message?.error?.code) error.code = message.error.code;
-  return error;
-}
-
-function scanWithWorker(worker, job) {
-  return new Promise((resolveJob, rejectJob) => {
-    const cleanup = () => {
-      worker.off("message", onMessage);
-      worker.off("error", onError);
-      worker.off("exit", onExit);
-    };
-    const onMessage = (message) => {
-      cleanup();
-      if (message?.jobId !== job.index) {
-        rejectJob(new Error("Rollout scan worker returned an unexpected job."));
-      } else if (message.type === "error") {
-        rejectJob(workerFailure(message));
-      } else if (message.type === "result") {
-        resolveJob(message.fragment);
-      } else {
-        rejectJob(new Error("Rollout scan worker returned an unknown response."));
-      }
-    };
-    const onError = (error) => {
-      cleanup();
-      rejectJob(error);
-    };
-    const onExit = (code) => {
-      cleanup();
-      rejectJob(
-        new Error(`Rollout scan worker exited before completing its job (${code}).`),
-      );
-    };
-    worker.once("message", onMessage);
-    worker.once("error", onError);
-    worker.once("exit", onExit);
-    try {
-      worker.postMessage({
-        type: "scan",
-        jobId: job.index,
-        path: job.path,
-        stateRow: job.stateRow,
-      });
-    } catch (error) {
-      cleanup();
-      rejectJob(error);
-    }
-  });
-}
-
-async function scanRolloutsSequential(jobs, onProgress) {
-  const fragments = new Array(jobs.length);
-  for (let index = 0; index < jobs.length; index += 1) {
-    const job = jobs[index];
-    fragments[job.index] = await scanRollout(job.path, job.stateRow);
-    reportScanProgress(onProgress, index + 1, jobs.length, job.path);
-  }
-  return fragments;
-}
-
-async function scanRolloutsInParallel(jobs, workerCount, onProgress) {
-  const scheduled = [...jobs].sort(
-    (left, right) => right.size - left.size || left.index - right.index,
-  );
-  const fragments = new Array(jobs.length);
-  const workers = Array.from(
-    { length: workerCount },
-    () => new Worker(new URL(import.meta.url), {
-      execArgv: [],
-      workerData: { mode: SCAN_WORKER_MODE },
-    }),
-  );
-  let nextJob = 0;
-  let completed = 0;
-  try {
-    await Promise.all(workers.map(async (worker) => {
-      while (nextJob < scheduled.length) {
-        const job = scheduled[nextJob];
-        nextJob += 1;
-        fragments[job.index] = await scanWithWorker(worker, job);
-        completed += 1;
-        reportScanProgress(onProgress, completed, jobs.length, job.path);
-      }
-    }));
-    return fragments;
-  } finally {
-    await Promise.allSettled(workers.map((worker) => worker.terminate()));
-  }
-}
-
-async function runScanWorker() {
-  parentPort.on("message", async (message) => {
-    if (message?.type !== "scan") return;
-    try {
-      const fragment = await scanRollout(message.path, message.stateRow);
-      parentPort.postMessage({
-        type: "result",
-        jobId: message.jobId,
-        fragment,
-      });
-    } catch (error) {
-      parentPort.postMessage({
-        type: "error",
-        jobId: message.jobId,
-        error: {
-          name: error instanceof Error ? error.name : "Error",
-          message: error instanceof Error ? error.message : String(error),
-          code: error?.code || null,
-        },
-      });
-    }
-  });
-}
-
-function threadMetadata(threadId, stateRows, parents, fallback = {}) {
+function threadMetadata(threadId, stateRows, titles, parents, fallback = {}) {
   const row = stateRows.get(threadId);
+  const sessionTitle = titles.get(threadId)?.title;
   const labels = sourceLabels(
     row?.thread_source,
     fallback.rawSource || row?.source,
   );
   return {
     id: threadId,
+    title: safeTitle(row, sessionTitle),
     project: projectLabel(
       fallback.cwd || row?.cwd,
       fallback.gitOrigin || row?.git_origin_url,
     ),
     model: normalizeModel(fallback.model || row?.model || "unknown"),
-    effort: sanitizeLabel(
+    effort: String(
       fallback.effort || row?.reasoning_effort || "unknown",
     ).slice(0, 40),
     source: labels.source,
@@ -881,7 +708,7 @@ function threadMetadata(threadId, stateRows, parents, fallback = {}) {
   };
 }
 
-function buildSnapshot(context, options) {
+function buildSnapshot(context, options, titles) {
   const events = [];
   for (const token of context.tokens.values()) {
     const origin = token.turnId ? context.origins.get(token.turnId) : null;
@@ -897,6 +724,7 @@ function buildSnapshot(context, options) {
     const metadata = threadMetadata(
       threadId,
       context.stateRows,
+      titles,
       context.parents,
       origin || occurrence,
     );
@@ -908,11 +736,14 @@ function buildSnapshot(context, options) {
       continue;
     }
     const breakdownAvailable = hasDetailedBreakdown(token.usage);
+    const serviceTier = occurrence.serviceTier || null;
+    const baseCredits = creditsForUsage(metadata.model, token.usage);
     events.push({
       ...token.usage,
       id: `evt-${hash(token.key)}`,
       timestamp,
       threadId,
+      threadTitle: metadata.title,
       project: metadata.project,
       model: metadata.model,
       effort: metadata.effort,
@@ -920,6 +751,13 @@ function buildSnapshot(context, options) {
       useType: metadata.useType,
       turnId: token.turnId || "",
       toolCalls: 0,
+      serviceTier,
+      rateCardCredits:
+        baseCredits === null
+          ? null
+          : serviceTier === "priority"
+            ? baseCredits * FAST_MODE_MULTIPLIER
+            : baseCredits,
       breakdownAvailable,
       dedupeQuality: token.dedupeQuality,
     });
@@ -968,6 +806,7 @@ function buildSnapshot(context, options) {
     const metadata = threadMetadata(
       threadId,
       context.stateRows,
+      titles,
       context.parents,
       origin || first || {},
     );
@@ -981,6 +820,10 @@ function buildSnapshot(context, options) {
         sum.toolCalls += event.toolCalls;
         if (event.breakdownAvailable) sum.detailedTokens += event.totalTokens;
         else sum.unknownBreakdownTokens += event.totalTokens;
+        if (event.rateCardCredits !== null) {
+          sum.rateCardCredits += event.rateCardCredits;
+          sum.ratedTokens += event.totalTokens;
+        }
         return sum;
       },
       {
@@ -992,6 +835,8 @@ function buildSnapshot(context, options) {
         toolCalls: 0,
         detailedTokens: 0,
         unknownBreakdownTokens: 0,
+        rateCardCredits: 0,
+        ratedTokens: 0,
       },
     );
     if (rows.length === 0 && !(metadata.reportedCumulativeTokens > 0)) continue;
@@ -1005,6 +850,7 @@ function buildSnapshot(context, options) {
             : "total-only";
     threads.push({
       id: threadId,
+      title: metadata.title,
       project: metadata.project,
       model: metadata.model,
       effort: metadata.effort,
@@ -1021,6 +867,11 @@ function buildSnapshot(context, options) {
       cachedInputTokens: totals.cachedInputTokens,
       outputTokens: totals.outputTokens,
       reasoningTokens: totals.reasoningTokens,
+      rateCardCredits:
+        totals.totalTokens > 0 && totals.ratedTokens === totals.totalTokens
+          ? totals.rateCardCredits
+          : null,
+      ratedTokens: totals.ratedTokens,
       toolCalls: totals.toolCalls,
       eventCount: rows.length,
       coverage,
@@ -1068,7 +919,7 @@ function buildSnapshot(context, options) {
     (quota) => quota.windowMinutes === WEEK_MINUTES,
   );
   const accountWideWeekly = weeklyCandidates.filter(
-    (quota) => quota.scope !== "named",
+    (quota) => !quota.limitName,
   );
   const weekly = [
     ...(accountWideWeekly.length ? accountWideWeekly : weeklyCandidates),
@@ -1101,16 +952,13 @@ function buildSnapshot(context, options) {
     label: "Local Codex snapshot",
     provenance: {
       kind: "codex-local-metadata",
-      sourceFingerprint: sourceFingerprint(
-        options.codexHome,
-        options.includeArchived,
-      ),
       privacy:
-        "Contains token metadata and project labels only; display titles, credential fields, message bodies, reasoning text, tool payloads, and full local paths are not exported. Project labels can still be sensitive.",
+        "Contains token metadata and Codex display titles only; credential fields, message bodies, reasoning text, tool payloads, and full local paths are not exported. Display titles may contain user-written text.",
+      rateCardAsOf: RATE_CARD_AS_OF,
+      rateCardUrl: RATE_CARD_URL,
     },
     coverage: {
       filesScanned: context.filesScanned,
-      sourceFileCount: context.sourceFileCount,
       bytesScanned: context.bytesScanned,
       parseErrors: context.parseErrors,
       duplicateEventsSkipped: context.duplicateEventsSkipped,
@@ -1138,6 +986,9 @@ function buildSnapshot(context, options) {
 
 export async function collectUsage(options, onProgress = () => {}) {
   const state = await readState(options.codexHome);
+  const titles = await readSessionTitles(
+    resolve(options.codexHome, "session_index.jsonl"),
+  );
   const roots = [resolve(options.codexHome, "sessions")];
   if (options.includeArchived) {
     roots.push(resolve(options.codexHome, "archived_sessions"));
@@ -1148,12 +999,6 @@ export async function collectUsage(options, onProgress = () => {}) {
     .flat()
     .sort();
   const sizes = await Promise.all(files.map((path) => stat(path)));
-  const jobs = files.map((path, index) => ({
-    index,
-    path,
-    size: sizes[index].size,
-    stateRow: state.rows.get(rolloutThreadId(path)) || null,
-  }));
 
   const context = {
     stateRows: state.rows,
@@ -1163,24 +1008,30 @@ export async function collectUsage(options, onProgress = () => {}) {
     quotas: new Map(),
     calls: new Map(),
     filesScanned: 0,
-    sourceFileCount: files.length + (state.path ? 1 : 0),
     bytesScanned: 0,
     parseErrors: 0,
     duplicateEventsSkipped: 0,
     correctionIntervals: 0,
   };
 
-  const workerCount = scanWorkerCount(files.length, options.workers);
-  const fragments = workerCount > 1
-    ? await scanRolloutsInParallel(jobs, workerCount, onProgress)
-    : await scanRolloutsSequential(jobs, onProgress);
-  for (const fragment of fragments) {
-    mergeScanFragment(context, fragment);
+  for (let index = 0; index < files.length; index += 1) {
+    await scanRollout(files[index], context);
+    context.filesScanned += 1;
+    context.bytesScanned += sizes[index].size;
+    if (
+      index === 0 ||
+      index === files.length - 1 ||
+      (index + 1) % 10 === 0
+    ) {
+      onProgress({
+        current: index + 1,
+        total: files.length,
+        path: files[index],
+      });
+    }
   }
-  context.filesScanned = files.length;
-  context.bytesScanned = sizes.reduce((sum, entry) => sum + entry.size, 0);
 
-  return buildSnapshot(context, options);
+  return buildSnapshot(context, options, titles);
 }
 
 async function main() {
@@ -1188,7 +1039,7 @@ async function main() {
   try {
     options = parseArgs(process.argv.slice(2));
   } catch (error) {
-    process.stderr.write(`${sanitizeLabel(error.message)}\n\n${usage()}\n`);
+    process.stderr.write(`${error.message}\n\n${usage()}\n`);
     process.exitCode = 1;
     return;
   }
@@ -1197,9 +1048,7 @@ async function main() {
     return;
   }
   if (!(await pathExists(options.codexHome))) {
-    throw new Error(
-      `Codex data directory not found: ${sanitizeLabel(options.codexHome)}`,
-    );
+    throw new Error(`Codex data directory not found: ${options.codexHome}`);
   }
 
   process.stdout.write("Token Ledger: scanning local Codex metadata…\n");
@@ -1213,7 +1062,7 @@ async function main() {
   const outputSize = (await stat(options.output)).size;
   process.stdout.write(
     [
-      `Snapshot: ${sanitizeLabel(options.output)}`,
+      `Snapshot: ${options.output}`,
       `Observed model-call tokens: ${snapshot.coverage.observedTokens.toLocaleString()}`,
       `Unique events: ${snapshot.events.length.toLocaleString()}`,
       `Duplicate/copied events skipped: ${snapshot.coverage.duplicateEventsSkipped.toLocaleString()}`,
@@ -1224,13 +1073,11 @@ async function main() {
 }
 
 const invokedPath = process.argv[1] ? pathToFileURL(resolve(process.argv[1])).href : "";
-if (!isMainThread && workerData?.mode === SCAN_WORKER_MODE) {
-  runScanWorker();
-} else if (isMainThread && import.meta.url === invokedPath) {
+if (import.meta.url === invokedPath) {
   main().catch((error) => {
     process.stderr.write(
       `Token Ledger collector failed: ${
-        error instanceof Error ? sanitizeLabel(error.message) : sanitizeLabel(error)
+        error instanceof Error ? error.message : String(error)
       }\n`,
     );
     process.exitCode = 1;