whoburnedmore 0.9.20 → 0.9.21

package/dist/index.js

@@ -7,10 +7,8 @@ var __export = (target, all) => {
 
 // src/index.ts
 import { spawn } from "node:child_process";
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
-import { createRequire as createRequire4 } from "node:module";
+import { createRequire as createRequire5 } from "node:module";
 import { platform as platform4 } from "node:os";
-import { join as join15 } from "node:path";
 import { pathToFileURL } from "node:url";
 import { createInterface } from "node:readline/promises";
 import pc2 from "picocolors";
@@ -25,8 +23,8 @@ function parseOrg(args) {
 function parsePass(args) {
   return parseValueFlag(args, "--pass") ?? parseValueFlag(args, "--code");
 }
-function parseInstallToken(args) {
-  return parseValueFlag(args, "--token");
+function hasUnsafeInstallTokenArg(args) {
+  return args.some((arg) => arg === "--token" || arg.startsWith("--token="));
 }
 function applyScope(payload, flags) {
   if (flags.board) payload.board = flags.board;
@@ -67,9 +65,65 @@ function resolveCommand(args) {
   return words[0] ?? "run";
 }
 
+// src/http-bounds.ts
+async function readResponseBytesCapped(response, maxBytes) {
+  const limit = Math.max(1, maxBytes);
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > limit) {
+    throw new Error("response body too large");
+  }
+  if (!response.body) throw new Error("response body missing");
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      total += value.byteLength;
+      if (total > limit) {
+        await reader.cancel("response body too large").catch(() => void 0);
+        throw new Error("response body too large");
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+async function readTextResponseCapped(response, maxBytes) {
+  return new TextDecoder("utf-8", { fatal: true }).decode(
+    await readResponseBytesCapped(response, maxBytes)
+  );
+}
+async function readJsonResponseCapped(response, maxBytes) {
+  return JSON.parse(await readTextResponseCapped(response, maxBytes));
+}
+
 // src/api.ts
+var DEFAULT_API_BASE = "https://api.whoburnedmore.com";
+var MAX_SERVER_RESPONSE_BYTES = 2 * 1024 * 1024;
 function apiBase() {
-  return process.env.WHOBURNEDMORE_API ?? "https://api.whoburnedmore.com";
+  const raw = process.env.WHOBURNEDMORE_API?.trim() || DEFAULT_API_BASE;
+  try {
+    const url = new URL(raw);
+    const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+    const trustedTransport = url.protocol === "https:" || url.protocol === "http:" && loopback;
+    if (!trustedTransport || url.username || url.password || url.pathname !== "" && url.pathname !== "/" || url.search || url.hash) {
+      throw new Error("untrusted");
+    }
+    return url.origin;
+  } catch {
+    throw new Error("WHOBURNEDMORE_API must be a trusted HTTPS or loopback HTTP origin");
+  }
 }
 function webBase() {
   return process.env.WHOBURNEDMORE_WEB ?? "https://whoburnedmore.com";
@@ -89,7 +143,7 @@ function isOpenableUrl(url) {
   return /^(https?|file):\/\//.test(url);
 }
 async function readJson(res) {
-  const text = await res.text();
+  const text = await readTextResponseCapped(res, MAX_SERVER_RESPONSE_BYTES);
   if (!text) return {};
   try {
     return JSON.parse(text);
@@ -110,7 +164,8 @@ async function send(method, path, body, token) {
       ...body === void 0 ? {} : { body: JSON.stringify(body) },
       // Bound the request so a slow/black-holing/hostile server can't hang the CLI
       // — or the unattended 15-minute background sync — indefinitely.
-      signal: AbortSignal.timeout(3e4)
+      signal: AbortSignal.timeout(3e4),
+      redirect: "error"
     });
   } catch {
     throw new Error(
@@ -161,9 +216,9 @@ async function devicePoll(deviceCode) {
   }
   return body;
 }
-async function refreshCliToken(anonKey) {
+async function refreshCliToken(refreshToken) {
   try {
-    const { status, body } = await post("/v1/auth/cli/refresh", { anonKey });
+    const { status, body } = await post("/v1/auth/cli/refresh", { refreshToken });
     if (status === 200 && typeof body.token === "string" && body.token) {
       return { token: body.token, handle: body.handle ?? "" };
     }
@@ -173,14 +228,20 @@ async function refreshCliToken(anonKey) {
 }
 async function bindDeviceKey(token, anonKey) {
   try {
-    const { status } = await post(
+    const { status, body } = await post(
       "/v1/me/devices/bind",
       { anonKey },
       token
     );
-    return status === 200 || status === 409;
+    if (status === 200) {
+      return {
+        definitive: true,
+        ...typeof body.refreshToken === "string" && body.refreshToken ? { refreshToken: body.refreshToken } : {}
+      };
+    }
+    return { definitive: status === 409 };
   } catch {
-    return false;
+    return { definitive: false };
   }
 }
 async function submit(token, payload) {
@@ -229,31 +290,112 @@ async function redeemServerInstall(token, anonKey) {
 
 // src/autosync.ts
 import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
 import {
   existsSync as existsSync2,
   mkdirSync as mkdirSync2,
-  readFileSync as readFileSync2,
+  readFileSync,
   renameSync as renameSync2,
   rmSync as rmSync2,
   statSync,
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { homedir as homedir2, platform } from "node:os";
-import { dirname, join as join2, posix, win32 } from "node:path";
+import { dirname as dirname2, join as join2, posix, win32 } from "node:path";
 
 // src/config.ts
+import { createHash, randomBytes as randomBytes2 } from "node:crypto";
+import {
+  existsSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// src/safe-local-file.ts
 import { randomBytes } from "node:crypto";
 import {
   chmodSync,
-  existsSync,
+  closeSync,
+  constants,
+  fstatSync,
   mkdirSync,
-  readFileSync,
+  openSync,
+  readSync,
   renameSync,
   rmSync,
   writeFileSync
 } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
+import { dirname } from "node:path";
+function readTextFileSyncCapped(path, maxBytes) {
+  const limit = Math.max(1, maxBytes);
+  let fd = null;
+  try {
+    fd = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    const metadata = fstatSync(fd);
+    if (!metadata.isFile() || metadata.size > limit) return null;
+    const chunks = [];
+    let total = 0;
+    while (true) {
+      const allowance = Math.min(64 * 1024, limit + 1 - total);
+      if (allowance <= 0) return null;
+      const chunk = Buffer.allocUnsafe(allowance);
+      const count = readSync(fd, chunk, 0, allowance, null);
+      if (count === 0) break;
+      total += count;
+      if (total > limit) return null;
+      chunks.push(chunk.subarray(0, count));
+    }
+    return Buffer.concat(chunks, total).toString("utf8");
+  } catch {
+    return null;
+  } finally {
+    if (fd !== null) {
+      try {
+        closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+function writePrivateFileAtomic(path, content, maxBytes) {
+  if (Buffer.byteLength(content, "utf8") > Math.max(1, maxBytes)) return false;
+  const dir = dirname(path);
+  let tmp = null;
+  try {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    try {
+      chmodSync(dir, 448);
+    } catch {
+    }
+    tmp = `${path}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`;
+    writeFileSync(tmp, content, { encoding: "utf8", flag: "wx", mode: 384 });
+    try {
+      chmodSync(tmp, 384);
+    } catch {
+    }
+    renameSync(tmp, path);
+    tmp = null;
+    return true;
+  } catch {
+    return false;
+  } finally {
+    if (tmp) {
+      try {
+        rmSync(tmp, { force: true });
+      } catch {
+      }
+    }
+  }
+}
+
+// src/config.ts
+var MAX_CONFIG_BYTES = 1024 * 1024;
+function deviceKeyHash(anonKey) {
+  return createHash("sha256").update(anonKey).digest("hex");
+}
+function needsDeviceBind(config) {
+  return !config.deviceBoundAt || !config.refreshToken;
+}
 function defaultConfigDir() {
   const override = process.env.WHOBURNEDMORE_CONFIG_DIR?.trim();
   if (override) return override;
@@ -263,10 +405,13 @@ function loadConfig(dir = defaultConfigDir()) {
   const file = join(dir, "config.json");
   if (!existsSync(file)) return null;
   try {
-    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    const content = readTextFileSyncCapped(file, MAX_CONFIG_BYTES);
+    if (content === null) return null;
+    const parsed = JSON.parse(content);
     const config = {};
     if (typeof parsed.anonKey === "string") config.anonKey = parsed.anonKey;
     if (typeof parsed.cliToken === "string") config.cliToken = parsed.cliToken;
+    if (typeof parsed.refreshToken === "string") config.refreshToken = parsed.refreshToken;
     if (typeof parsed.handle === "string") config.handle = parsed.handle;
     if (typeof parsed.lastSyncAt === "number" && Number.isFinite(parsed.lastSyncAt))
       config.lastSyncAt = parsed.lastSyncAt;
@@ -282,28 +427,15 @@ function loadConfig(dir = defaultConfigDir()) {
   }
 }
 function saveConfig(dir = defaultConfigDir(), config = {}) {
-  mkdirSync(dir, { recursive: true });
   const file = join(dir, "config.json");
-  const tmp = join(dir, `config.json.${process.pid}.tmp`);
-  try {
-    writeFileSync(tmp, JSON.stringify(config, null, 2), { mode: 384 });
-    try {
-      chmodSync(tmp, 384);
-    } catch {
-    }
-    renameSync(tmp, file);
-  } catch (err) {
-    try {
-      rmSync(tmp, { force: true });
-    } catch {
-    }
-    throw err;
+  if (!writePrivateFileAtomic(file, JSON.stringify(config, null, 2), MAX_CONFIG_BYTES)) {
+    throw new Error("could not save private CLI configuration");
   }
 }
 function ensureAnonKey(dir = defaultConfigDir()) {
   const config = loadConfig(dir) ?? {};
   if (config.anonKey) return config.anonKey;
-  const anonKey = randomBytes(32).toString("hex");
+  const anonKey = randomBytes2(32).toString("hex");
   saveConfig(dir, { ...config, anonKey });
   return anonKey;
 }
@@ -317,7 +449,12 @@ function recordDeviceBound(dir = defaultConfigDir(), when = Date.now()) {
 }
 function saveAuth(dir = defaultConfigDir(), auth = { cliToken: "" }) {
   const config = loadConfig(dir) ?? {};
-  saveConfig(dir, { ...config, cliToken: auth.cliToken, handle: auth.handle });
+  saveConfig(dir, {
+    ...config,
+    cliToken: auth.cliToken,
+    handle: auth.handle,
+    ...auth.refreshToken ? { refreshToken: auth.refreshToken } : {}
+  });
 }
 function clearAuth(dir = defaultConfigDir()) {
   const config = loadConfig(dir);
@@ -342,7 +479,9 @@ var STABLE_NPM_CANDIDATES = [
   "/usr/local/bin/npm",
   "/usr/bin/npm"
 ];
-var LATEST_PACKAGE_SPEC = "whoburnedmore@latest";
+var require2 = createRequire(import.meta.url);
+var CLI_VERSION = require2("../package.json").version;
+var SCHEDULED_PACKAGE_SPEC = `whoburnedmore@${CLI_VERSION}`;
 var SYNC_PATH_DIRS = [
   "/opt/homebrew/bin",
   "/usr/local/bin",
@@ -352,7 +491,7 @@ var SYNC_PATH_DIRS = [
   "/sbin"
 ];
 function syncPathEnv(npmPath = resolveNpmPath()) {
-  const dir = dirname(npmPath);
+  const dir = dirname2(npmPath);
   const dirs = [];
   if (dir && dir !== "." && dir !== "/" && dir !== npmPath) dirs.push(dir);
   for (const d of SYNC_PATH_DIRS) {
@@ -482,7 +621,7 @@ function syncCommandArgs(npmPath = resolveNpmPath()) {
     "--yes",
     "--ignore-scripts",
     "--package",
-    LATEST_PACKAGE_SPEC,
+    SCHEDULED_PACKAGE_SPEC,
     "--",
     "whoburnedmore",
     "sync"
@@ -697,8 +836,8 @@ function autoSyncInstalled() {
 }
 function readInstalledSystemd() {
   try {
-    return `${readFileSync2(systemdServicePath(), "utf8")}
-${readFileSync2(systemdTimerPath(), "utf8")}`;
+    return `${readFileSync(systemdServicePath(), "utf8")}
+${readFileSync(systemdTimerPath(), "utf8")}`;
   } catch {
     return null;
   }
@@ -710,7 +849,7 @@ ${buildSystemdTimer()}`;
 function readInstalledAgent() {
   if (platform() === "darwin") {
     const p = launchAgentPath();
-    return existsSync2(p) ? readFileSync2(p, "utf8") : null;
+    return existsSync2(p) ? readFileSync(p, "utf8") : null;
   }
   if (platform() === "linux") {
     const mech = linuxSyncMechanism();
@@ -798,7 +937,7 @@ async function daemonLoop(deps) {
 
 // src/collect.ts
 import { execFile } from "node:child_process";
-import { createRequire as createRequire3 } from "node:module";
+import { createRequire as createRequire4 } from "node:module";
 import { dirname as dirname6, join as join13 } from "node:path";
 import { promisify } from "node:util";
 
@@ -808,7 +947,7 @@ import { homedir as homedir4 } from "node:os";
 import { join as join5 } from "node:path";
 
 // src/native/claude.ts
-import { readdir, readFile as readFile2 } from "node:fs/promises";
+import { readdir } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
 import { join as join4 } from "node:path";
 
@@ -6249,7 +6388,12 @@ function estimateCostUSD(model, t) {
 
 // ../shared/dist/index.js
 var DateString = external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/, "must be YYYY-MM-DD");
-var tokenCount = external_exports.number().int().nonnegative();
+var MAX_TOKEN_COUNT = 1e11;
+var MAX_ROLLUP_COUNT = 1e9;
+var MAX_COST_USD = 1e5;
+var tokenCount = external_exports.number().int().nonnegative().max(MAX_TOKEN_COUNT);
+var rollupCount = external_exports.number().int().nonnegative().max(MAX_ROLLUP_COUNT);
+var costUSD = external_exports.number().nonnegative().max(MAX_COST_USD);
 var ConnectorProvider = external_exports.enum([
   "anthropic-api",
   "openai-api",
@@ -6279,7 +6423,7 @@ var DailyUsageEntry = external_exports.object({
   cacheCreationTokens: tokenCount,
   cacheReadTokens: tokenCount,
   /** Estimated cost in USD for this entry. */
-  costUSD: external_exports.number().nonnegative(),
+  costUSD,
   /** Where this entry came from. Defaults to the local CLI for back-compat. */
   origin: UsageOrigin.default("cli"),
   /** True when the numbers come from a provider's authoritative usage API. */
@@ -6294,7 +6438,7 @@ var DailyUsageEntry = external_exports.object({
    * cannot see request ids) omit it, and an omitted fingerprint is never
    * penalized.
    */
-  requestCount: external_exports.number().int().nonnegative().optional()
+  requestCount: rollupCount.optional()
 });
 var Timestamp = external_exports.string().min(1).max(40);
 var SessionEntry = external_exports.object({
@@ -6305,49 +6449,76 @@ var SessionEntry = external_exports.object({
   outputTokens: tokenCount,
   cacheCreationTokens: tokenCount,
   cacheReadTokens: tokenCount,
-  costUSD: external_exports.number().nonnegative(),
+  costUSD,
   lastActivity: Timestamp,
   /** Number of assistant messages in this session (from transcripts). Optional. */
-  messageCount: external_exports.number().int().nonnegative().optional()
+  messageCount: rollupCount.optional()
 });
 var BlockEntry = external_exports.object({
   startTime: Timestamp,
   totalTokens: tokenCount,
-  costUSD: external_exports.number().nonnegative()
+  costUSD
 });
 var ToolStat = external_exports.object({
   name: external_exports.string().min(1).max(128),
-  count: external_exports.number().int().nonnegative(),
+  count: rollupCount,
   /** How many of those calls returned an error/interrupt (tool reliability). Optional. */
-  errors: external_exports.number().int().nonnegative().optional(),
+  errors: rollupCount.optional(),
   /** Tokens burned on turns that used this tool (turn tokens split across its tool calls). Optional. */
-  tokens: external_exports.number().int().nonnegative().optional()
+  tokens: tokenCount.optional()
 });
 var AgentStat = external_exports.object({
   /** Total assistant messages across transcripts. */
-  messageCount: external_exports.number().int().nonnegative(),
+  messageCount: rollupCount,
   /** Assistant messages that ran inside a subagent sidechain. */
-  subagentMessages: external_exports.number().int().nonnegative(),
+  subagentMessages: rollupCount,
   /** Tokens spent inside subagent sidechains. */
-  subagentTokens: external_exports.number().int().nonnegative(),
+  subagentTokens: tokenCount,
   /** Total tokens observed across transcripts (denominator for the share). */
-  totalTokens: external_exports.number().int().nonnegative(),
+  totalTokens: tokenCount,
   /**
    * Messages the human actually sent (their prompts) — non-sidechain user turns
    * carrying real text, NOT tool results or injected/meta turns. Denominator for
    * "avg cost per message". Optional (back-compat with older CLIs).
    */
-  userMessageCount: external_exports.number().int().nonnegative().optional()
+  userMessageCount: rollupCount.optional()
 });
 var SkillStat = external_exports.object({
   name: external_exports.string().min(1).max(128),
-  count: external_exports.number().int().nonnegative(),
+  count: rollupCount,
   /** Tokens burned in records produced while this skill was active. Optional. */
-  tokens: external_exports.number().int().nonnegative().optional()
+  tokens: tokenCount.optional()
+});
+var CodexReplayPriorRow = external_exports.object({
+  model: external_exports.string().min(1).max(128),
+  inputTokens: tokenCount,
+  outputTokens: tokenCount,
+  cacheCreationTokens: tokenCount,
+  cacheReadTokens: tokenCount
+});
+var CodexReplayPriorScope = external_exports.object({
+  date: DateString,
+  rows: external_exports.array(CodexReplayPriorRow).min(1).max(100)
 });
 var SubmitPayload = external_exports.object({
   cliVersion: external_exports.string().min(1).max(32),
   entries: external_exports.array(DailyUsageEntry).min(1).max(2e4),
+  /**
+   * Dates observed only inside replayed Codex fork/subagent rollouts and absent
+   * from a successful replay-aware parse. The API may remove an old
+   * self-reported Codex scope for these targeted dates only when the account has
+   * one confirmed device and the accompanying prior scope matches exactly.
+   * Omitted on parser failure, timeout, capped payloads, and older clients.
+   */
+  codexReplayTombstoneDates: external_exports.array(DateString).max(5e3).optional(),
+  /**
+   * Compare-and-swap proof for destructive Codex correction. Each scope is the
+   * exact model/token snapshot the legacy native reader would have submitted.
+   * The API corrects only when its stored scope matches these rows exactly.
+   */
+  codexReplayPriorScopes: external_exports.array(CodexReplayPriorScope).max(5e3).optional(),
+  /** sha256 of this machine's bound secret; required by the API for correction authority. */
+  deviceKeyHash: external_exports.string().regex(/^[a-f0-9]{64}$/).optional(),
   /** Optional per-conversation rollups (ccusage session). Back-compat: omittable. */
   sessions: external_exports.array(SessionEntry).max(1e4).optional(),
   /** Optional time-window rollups (ccusage blocks) for peak-hours analysis. */
@@ -6421,6 +6592,7 @@ function entryTotalTokens(e) {
 }
 var LeaderboardPeriod = external_exports.enum(["today", "7d", "30d", "all"]);
 var LeaderboardMetric = external_exports.enum(["tokens", "cost"]);
+var InsightsPeriod = external_exports.enum(["7d", "30d", "all"]);
 var OrgType = external_exports.enum(["company", "hackathon", "hackerhouse"]);
 var MemberRole = external_exports.enum(["owner", "admin", "member"]);
 var OrgBoardVisibility = external_exports.enum(["public", "members"]);
@@ -6559,18 +6731,63 @@ var OrgJoinInput = external_exports.object({
 });
 
 // src/native/file-cache.ts
-import { mkdirSync as mkdirSync3, renameSync as renameSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { readFile, stat } from "node:fs/promises";
-import { dirname as dirname2, join as join3 } from "node:path";
+import {
+  chmodSync as chmodSync2,
+  constants as constants2,
+  mkdirSync as mkdirSync3,
+  renameSync as renameSync3,
+  unlinkSync,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+import { open, stat } from "node:fs/promises";
+import { randomBytes as randomBytes3 } from "node:crypto";
+import { dirname as dirname3, join as join3 } from "node:path";
+var MAX_NATIVE_FILE_BYTES = 64 * 1024 * 1024;
+var MAX_NATIVE_CACHE_BYTES = 128 * 1024 * 1024;
+var READ_CHUNK_BYTES = 64 * 1024;
+async function readTextFileCapped(path, opts = {}) {
+  const maxBytes = Math.max(1, opts.maxBytes ?? MAX_NATIVE_FILE_BYTES);
+  const deadline = opts.deadline ?? Number.POSITIVE_INFINITY;
+  const now = opts.now ?? Date.now;
+  let handle = null;
+  try {
+    handle = await open(
+      path,
+      constants2.O_RDONLY | (constants2.O_NOFOLLOW ?? 0)
+    );
+    const metadata = await handle.stat();
+    if (!metadata.isFile()) return { ok: false, reason: "unreadable" };
+    if (metadata.size > maxBytes) return { ok: false, reason: "too-large" };
+    const chunks = [];
+    let total = 0;
+    while (true) {
+      if (now() > deadline) return { ok: false, reason: "timed-out" };
+      const allowance = Math.min(READ_CHUNK_BYTES, maxBytes + 1 - total);
+      if (allowance <= 0) return { ok: false, reason: "too-large" };
+      const chunk = Buffer.allocUnsafe(allowance);
+      const { bytesRead } = await handle.read(chunk, 0, allowance, null);
+      if (bytesRead === 0) break;
+      total += bytesRead;
+      if (total > maxBytes) return { ok: false, reason: "too-large" };
+      chunks.push(chunk.subarray(0, bytesRead));
+    }
+    return { ok: true, content: Buffer.concat(chunks, total).toString("utf8") };
+  } catch {
+    return { ok: false, reason: "unreadable" };
+  } finally {
+    await handle?.close().catch(() => void 0);
+  }
+}
 function nativeCachePath(reader, env = process.env) {
   const override = env.WHOBURNEDMORE_CONFIG_DIR?.trim();
   const dir = override || defaultConfigDir();
   return join3(dir, `native-cache-${reader}.json`);
 }
-async function loadCache(path, version) {
+async function loadCache(path, version, maxBytes) {
   try {
-    const raw = await readFile(path, "utf8");
-    const parsed = JSON.parse(raw);
+    const read = await readTextFileCapped(path, { maxBytes });
+    if (!read.ok) return {};
+    const parsed = JSON.parse(read.content);
     if (parsed && parsed.v === version && parsed.files && typeof parsed.files === "object") {
       return parsed.files;
     }
@@ -6578,18 +6795,34 @@ async function loadCache(path, version) {
   }
   return {};
 }
-function saveCache(path, version, files) {
+function saveCache(path, version, files, maxBytes) {
+  let tmp = null;
   try {
-    mkdirSync3(dirname2(path), { recursive: true });
-    const tmp = `${path}.tmp-${process.pid}`;
-    writeFileSync3(tmp, JSON.stringify({ v: version, files }));
+    const dir = dirname3(path);
+    mkdirSync3(dir, { recursive: true, mode: 448 });
+    chmodSync2(dir, 448);
+    tmp = `${path}.tmp-${process.pid}-${randomBytes3(8).toString("hex")}`;
+    const serialized = JSON.stringify({ v: version, files });
+    if (Buffer.byteLength(serialized, "utf8") > maxBytes) return;
+    writeFileSync3(tmp, serialized, { encoding: "utf8", flag: "wx", mode: 384 });
+    chmodSync2(tmp, 384);
     renameSync3(tmp, path);
+    tmp = null;
   } catch {
+  } finally {
+    if (tmp) {
+      try {
+        unlinkSync(tmp);
+      } catch {
+      }
+    }
   }
 }
 async function readFilesWithCache(opts) {
   const now = opts.now ?? Date.now;
-  const cached = await loadCache(opts.cachePath, opts.version);
+  const maxFileBytes = Math.max(1, opts.maxFileBytes ?? MAX_NATIVE_FILE_BYTES);
+  const maxCacheBytes = Math.max(1, opts.maxCacheBytes ?? MAX_NATIVE_CACHE_BYTES);
+  const cached = await loadCache(opts.cachePath, opts.version, maxCacheBytes);
   const fresh = {};
   const itemsByFile = [];
   let filesRead = 0;
@@ -6603,6 +6836,9 @@ async function readFilesWithCache(opts) {
     } catch {
       continue;
     }
+    if (size > maxFileBytes) {
+      continue;
+    }
     const hit = cached[f];
     if (hit && hit.size === size && hit.mtimeMs === mtimeMs) {
       fresh[f] = hit;
@@ -6610,21 +6846,27 @@ async function readFilesWithCache(opts) {
       continue;
     }
     if (now() > opts.deadline) {
-      saveCache(opts.cachePath, opts.version, { ...cached, ...fresh });
+      saveCache(opts.cachePath, opts.version, { ...cached, ...fresh }, maxCacheBytes);
       return { itemsByFile: null, filesRead, timedOut: true };
     }
-    let content;
-    try {
-      content = await readFile(f, "utf8");
-    } catch {
+    const read = await readTextFileCapped(f, {
+      maxBytes: maxFileBytes,
+      deadline: opts.deadline,
+      now
+    });
+    if (!read.ok) {
+      if (read.reason === "timed-out") {
+        saveCache(opts.cachePath, opts.version, { ...cached, ...fresh }, maxCacheBytes);
+        return { itemsByFile: null, filesRead, timedOut: true };
+      }
       continue;
     }
-    const items = opts.parseFile(content, f);
+    const items = opts.parseFile(read.content, f);
     fresh[f] = { size, mtimeMs, items };
     itemsByFile.push(items);
     filesRead += 1;
   }
-  saveCache(opts.cachePath, opts.version, fresh);
+  saveCache(opts.cachePath, opts.version, fresh, maxCacheBytes);
   return { itemsByFile, filesRead, timedOut: false };
 }
 
@@ -6867,13 +7109,18 @@ async function collectClaudeRequests(env = process.env, opts = {}) {
     if (now() > deadline) {
       return { requests: [...acc.values()], found: true, timedOut: true };
     }
-    let content;
-    try {
-      content = await readFile2(f, "utf8");
-    } catch {
+    const read = await readTextFileCapped(f, {
+      maxBytes: opts.maxFileBytes ?? MAX_NATIVE_FILE_BYTES,
+      deadline,
+      now
+    });
+    if (!read.ok) {
+      if (read.reason === "timed-out") {
+        return { requests: [...acc.values()], found: true, timedOut: true };
+      }
       continue;
     }
-    accumulateClaudeLines(acc, splitLines(content));
+    accumulateClaudeLines(acc, splitLines(read.content));
   }
   return { requests: [...acc.values()], found: true };
 }
@@ -7278,28 +7525,54 @@ function parseContinueJsonl(content) {
   }
   return mapContinueRecords(records);
 }
-async function listJsonl2(dir) {
-  let dirents;
-  try {
-    dirents = await readdir2(dir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  const out = [];
-  for (const d of dirents) {
-    const full = join6(dir, d.name);
-    if (d.isDirectory()) out.push(...await listJsonl2(full));
-    else if (d.isFile() && d.name === "tokensGenerated.jsonl") out.push(full);
+async function listJsonl2(root, opts) {
+  const queue = [{ dir: root, depth: 0 }];
+  let queueIndex = 0;
+  const files = [];
+  let visitedEntries = 0;
+  const maxEntries = Math.max(1e3, opts.maxFiles * 20);
+  while (queueIndex < queue.length) {
+    if (opts.now() > opts.deadline) return { files: [], aborted: true };
+    const current = queue[queueIndex++];
+    let dirents;
+    try {
+      dirents = await readdir2(current.dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const d of dirents) {
+      visitedEntries += 1;
+      if (visitedEntries > maxEntries || opts.now() > opts.deadline) {
+        return { files: [], aborted: true };
+      }
+      const full = join6(current.dir, d.name);
+      if (d.isDirectory()) {
+        if (current.depth >= 32) return { files: [], aborted: true };
+        queue.push({ dir: full, depth: current.depth + 1 });
+      } else if (d.isFile() && d.name === "tokensGenerated.jsonl") {
+        files.push(full);
+        if (files.length > opts.maxFiles) return { files: [], aborted: true };
+      }
+    }
   }
-  return out;
+  return { files, aborted: false };
 }
 var CONTINUE_CACHE_VERSION = 2;
 async function collectContinue(opts = {}) {
   const env = opts.env ?? process.env;
   const home = opts.continueDir ?? join6(env.HOME || homedir5(), ".continue");
-  const files = await listJsonl2(join6(home, "dev_data"));
-  if (files.length === 0) return { entries: [], found: false, filesScanned: 0 };
   const now = opts.now ?? Date.now;
+  const deadline = now() + (opts.budgetMs ?? NATIVE_READ_BUDGET_MS);
+  const discovery = await listJsonl2(join6(home, "dev_data"), {
+    deadline,
+    now,
+    maxFiles: Math.max(1, opts.maxFiles ?? 1e4)
+  });
+  if (discovery.aborted) {
+    return { entries: [], found: false, filesScanned: 0, timedOut: true };
+  }
+  const files = discovery.files;
+  if (files.length === 0) return { entries: [], found: false, filesScanned: 0 };
   const res = await readFilesWithCache({
     files,
     cachePath: opts.cachePath ?? nativeCachePath("continue", env),
@@ -7312,7 +7585,7 @@ async function collectContinue(opts = {}) {
       e.costUSD,
       e.requestCount ?? 0
     ]),
-    deadline: now() + (opts.budgetMs ?? NATIVE_READ_BUDGET_MS),
+    deadline,
     now
   });
   if (!res.itemsByFile) {
@@ -7351,15 +7624,15 @@ async function collectContinue(opts = {}) {
 
 // src/cursor.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync3 } from "node:fs";
-import { createRequire as createRequire2 } from "node:module";
+import { existsSync as existsSync3, realpathSync, statSync as statSync3 } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
 import { homedir as homedir6, platform as platform2 } from "node:os";
 import { join as join8 } from "node:path";
 
 // src/tokscale.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { createRequire } from "node:module";
-import { dirname as dirname3, join as join7 } from "node:path";
+import { createRequire as createRequire2 } from "node:module";
+import { dirname as dirname4, join as join7 } from "node:path";
 var LOOKBACK_DAYS = 30;
 function num3(n) {
   const v = Math.round(Number(n));
@@ -7378,9 +7651,9 @@ function mapTokscaleDay(date, json) {
     const outputTokens = num3(e.output) + num3(e.reasoning);
     const cacheCreationTokens = num3(e.cacheWrite);
     const cacheReadTokens = num3(e.cacheRead);
-    const costUSD = numCost(e.cost);
+    const costUSD2 = numCost(e.cost);
     const total = inputTokens + outputTokens + cacheCreationTokens + cacheReadTokens;
-    if (total === 0 && costUSD === 0) continue;
+    if (total === 0 && costUSD2 === 0) continue;
     out.push({
       date,
       tool: "cursor",
@@ -7389,7 +7662,7 @@ function mapTokscaleDay(date, json) {
       outputTokens,
       cacheCreationTokens,
       cacheReadTokens,
-      costUSD,
+      costUSD: costUSD2,
       origin: "cli",
       verified: false
     });
@@ -7398,12 +7671,12 @@ function mapTokscaleDay(date, json) {
 }
 function resolveTokscaleBin() {
   try {
-    const require3 = createRequire(import.meta.url);
-    const pkgPath = require3.resolve("tokscale/package.json");
-    const pkg = require3("tokscale/package.json");
+    const require4 = createRequire2(import.meta.url);
+    const pkgPath = require4.resolve("tokscale/package.json");
+    const pkg = require4("tokscale/package.json");
     const rel = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.tokscale ?? "";
     if (!rel) return null;
-    const binPath = join7(dirname3(pkgPath), rel);
+    const binPath = join7(dirname4(pkgPath), rel);
     if (/\.(c|m)?js$/.test(binPath)) {
       return { cmd: process.execPath, prefixArgs: [binPath] };
     }
@@ -7460,31 +7733,47 @@ function collectCursorViaTokscale(lookbackDays = LOOKBACK_DAYS) {
 
 // src/cursor.ts
 var EVENTS_URL = "https://cursor.com/api/dashboard/get-filtered-usage-events";
+var MAX_CURSOR_PAGE_BYTES = 4 * 1024 * 1024;
 function cursorDbPath() {
   const home = homedir6();
   const os = platform2();
   const p = os === "darwin" ? join8(home, "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb") : os === "win32" ? join8(process.env.APPDATA ?? join8(home, "AppData", "Roaming"), "Cursor", "User", "globalStorage", "state.vscdb") : join8(process.env.XDG_CONFIG_HOME ?? join8(home, ".config"), "Cursor", "User", "globalStorage", "state.vscdb");
   return existsSync3(p) ? p : null;
 }
+function trustedSqliteBinaries() {
+  const candidates = platform2() === "darwin" ? ["/usr/bin/sqlite3", "/opt/homebrew/bin/sqlite3", "/usr/local/bin/sqlite3"] : platform2() === "linux" ? ["/usr/bin/sqlite3", "/usr/local/bin/sqlite3"] : [];
+  const trusted = [];
+  for (const candidate of candidates) {
+    try {
+      const resolved = realpathSync(candidate);
+      const stat2 = statSync3(resolved);
+      if (stat2.isFile() && (stat2.mode & 18) === 0) trusted.push(resolved);
+    } catch {
+    }
+  }
+  return [...new Set(trusted)];
+}
 function readCursorToken(db) {
-  const require3 = createRequire2(import.meta.url);
+  const require4 = createRequire3(import.meta.url);
   try {
-    const { DatabaseSync } = require3("node:sqlite");
+    const { DatabaseSync } = require4("node:sqlite");
     const d = new DatabaseSync(db, { readOnly: true });
     const row = d.prepare("SELECT value FROM ItemTable WHERE key = ?").get("cursorAuth/accessToken");
     d.close();
     if (row?.value) return String(row.value);
   } catch {
   }
-  try {
-    const res = spawnSync3(
-      "sqlite3",
-      [db, "SELECT value FROM ItemTable WHERE key='cursorAuth/accessToken';"],
-      { encoding: "utf8", timeout: 1e4 }
-    );
-    const out = res.stdout?.trim();
-    if (res.status === 0 && out) return out;
-  } catch {
+  for (const sqlite3 of trustedSqliteBinaries()) {
+    try {
+      const res = spawnSync3(
+        sqlite3,
+        [db, "SELECT value FROM ItemTable WHERE key='cursorAuth/accessToken';"],
+        { encoding: "utf8", timeout: 1e4 }
+      );
+      const out = res.stdout?.trim();
+      if (res.status === 0 && out) return out;
+    } catch {
+    }
   }
   return null;
 }
@@ -7571,12 +7860,16 @@ async function fetchCursorEvents(cookie, maxPages = 30, pageSize = 500) {
         Cookie: cookie
       },
       body: JSON.stringify({ page, pageSize }),
-      signal: AbortSignal.timeout(2e4)
+      signal: AbortSignal.timeout(2e4),
+      redirect: "error"
     });
     if (!res.ok) {
       throw new Error(`cursor usage page ${page} failed (HTTP ${res.status})`);
     }
-    const body = await res.json();
+    const body = await readJsonResponseCapped(
+      res,
+      MAX_CURSOR_PAGE_BYTES
+    );
     const batch = body.usageEventsDisplay ?? [];
     all.push(...batch);
     if (batch.length < pageSize) break;
@@ -7606,7 +7899,7 @@ async function collectCursor(opts) {
 // src/native/codex.ts
 import { readdir as readdir3 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
-import { join as join9, resolve } from "node:path";
+import { basename, join as join9, resolve } from "node:path";
 function num5(n) {
   const v = Math.round(Number(n));
   return Number.isFinite(v) && v > 0 ? v : 0;
@@ -7623,8 +7916,10 @@ function readTokenFields(payload) {
     output: num5(output)
   };
 }
-function parseCodexRollout(lines) {
+function inspectCodexRollout(lines) {
   let model = "unknown";
+  let sawSessionMeta = false;
+  let replayedRollout = false;
   const perDay = /* @__PURE__ */ new Map();
   let lastSeenDate = null;
   for (const raw of lines) {
@@ -7639,6 +7934,13 @@ function parseCodexRollout(lines) {
     const payload = obj.payload;
     if (!payload || typeof payload !== "object") continue;
     const kind = obj.type;
+    if (kind === "session_meta" && !sawSessionMeta) {
+      sawSessionMeta = true;
+      const source = payload.source;
+      if (typeof payload.forked_from_id === "string" || typeof payload.parent_thread_id === "string" || source && typeof source === "object" && source.subagent !== void 0) {
+        replayedRollout = true;
+      }
+    }
     if (kind === "session_meta" || kind === "turn_context") {
       if (typeof payload.model === "string" && payload.model) model = payload.model;
     }
@@ -7658,7 +7960,8 @@ function parseCodexRollout(lines) {
       }
     }
   }
-  if (perDay.size === 0) return [];
+  if (perDay.size === 0)
+    return { sessions: [], replaySessions: [], replayCandidateDates: [] };
   const dates = [...perDay.keys()].sort();
   const out = [];
   let prev = { input: 0, cached: 0, output: 0 };
@@ -7668,8 +7971,8 @@ function parseCodexRollout(lines) {
     const dCached = Math.max(0, cum.cached - prev.cached);
     const dOutput = Math.max(0, cum.output - prev.output);
     prev = cum;
-    const cacheReadTokens = dCached;
-    const inputTokens = Math.max(0, dInput - dCached);
+    const cacheReadTokens = Math.min(dCached, dInput);
+    const inputTokens = dInput - cacheReadTokens;
     const outputTokens = dOutput;
     if (inputTokens + outputTokens + cacheReadTokens === 0) continue;
     out.push({
@@ -7682,7 +7985,11 @@ function parseCodexRollout(lines) {
       turnCount: turns
     });
   }
-  return out;
+  return {
+    sessions: replayedRollout ? [] : out,
+    replaySessions: replayedRollout ? out : [],
+    replayCandidateDates: replayedRollout ? dates : []
+  };
 }
 function foldCodexSessions(acc, sessions) {
   for (const s of sessions) {
@@ -7730,7 +8037,7 @@ function resolveCodexHome(env = process.env) {
   return env.CODEX_HOME && env.CODEX_HOME.trim() ? env.CODEX_HOME.trim() : join9(homedir7(), ".codex");
 }
 function resolveCodexSessionsDirs(env = process.env) {
-  const home = resolveCodexHome(env);
+  const home = resolve(resolveCodexHome(env));
   return [join9(home, "sessions"), join9(home, "archived_sessions")];
 }
 async function listJsonl3(dir) {
@@ -7759,9 +8066,10 @@ function* splitLines3(content) {
   if (start < content.length) yield content.slice(start);
 }
 var NATIVE_READ_BUDGET_MS2 = 45e3;
-var CODEX_CACHE_VERSION = 2;
-function toCachedSession(s) {
+var CODEX_CACHE_VERSION = 7;
+function toCachedSession(s, kind = "usage") {
   return [
+    kind,
     s.date,
     s.model,
     s.inputTokens,
@@ -7773,25 +8081,53 @@ function toCachedSession(s) {
 }
 function fromCachedSession(t) {
   return {
-    date: t[0],
-    model: t[1],
-    inputTokens: t[2],
-    outputTokens: t[3],
-    cacheCreationTokens: t[4],
-    cacheReadTokens: t[5],
-    turnCount: t[6]
+    date: t[1],
+    model: t[2],
+    inputTokens: t[3],
+    outputTokens: t[4],
+    cacheCreationTokens: t[5],
+    cacheReadTokens: t[6],
+    turnCount: t[7]
   };
 }
 async function collectCodexNative(env = process.env, opts = {}) {
   const dirs = resolveCodexSessionsDirs(env);
-  const files = (await Promise.all(dirs.map(listJsonl3))).flat();
+  const files = [];
+  const primaryFiles = /* @__PURE__ */ new Set();
+  const seenIdentities = /* @__PURE__ */ new Set();
+  for (const dir of dirs) {
+    for (const file of await listJsonl3(dir)) {
+      const key = basename(file);
+      files.push(file);
+      if (!seenIdentities.has(key)) {
+        seenIdentities.add(key);
+        primaryFiles.add(file);
+      }
+    }
+  }
   if (files.length === 0) return { entries: [], found: false, filesScanned: 0 };
   const now = opts.now ?? Date.now;
   const res = await readFilesWithCache({
     files,
     cachePath: opts.cachePath ?? nativeCachePath("codex", env),
     version: CODEX_CACHE_VERSION,
-    parseFile: (content) => parseCodexRollout(splitLines3(content)).map(toCachedSession),
+    parseFile: (content, path) => {
+      const inspected = inspectCodexRollout(splitLines3(content));
+      const primary = primaryFiles.has(path);
+      return [
+        // Do not pass toCachedSession directly to map: Array.map's numeric
+        // index would be supplied as the optional `kind` argument.
+        ...inspected.sessions.map(
+          (session) => toCachedSession(session, primary ? "usage" : "duplicate")
+        ),
+        ...inspected.replaySessions.map(
+          (session) => toCachedSession(
+            session,
+            primary ? "replay" : "replay-duplicate"
+          )
+        )
+      ];
+    },
     deadline: now() + (opts.budgetMs ?? NATIVE_READ_BUDGET_MS2),
     now
   });
@@ -7804,13 +8140,24 @@ async function collectCodexNative(env = process.env, opts = {}) {
     };
   }
   const acc = /* @__PURE__ */ new Map();
+  const legacyAcc = /* @__PURE__ */ new Map();
+  const replayCandidateDates = /* @__PURE__ */ new Set();
   for (const items of res.itemsByFile) {
-    foldCodexSessions(acc, items.map(fromCachedSession));
+    const usage = items.filter((item) => item[0] === "usage").map(fromCachedSession);
+    const legacy = items.map(fromCachedSession);
+    const replay = items.filter(
+      (item) => item[0] === "replay" || item[0] === "replay-duplicate"
+    ).map(fromCachedSession);
+    foldCodexSessions(acc, usage);
+    foldCodexSessions(legacyAcc, legacy);
+    for (const session of replay) replayCandidateDates.add(session.date);
   }
   return {
     entries: finalizeCodexEntries(acc),
     found: true,
-    filesScanned: res.filesRead
+    filesScanned: res.filesRead,
+    replayCandidateDates: [...replayCandidateDates].sort(),
+    legacyEntries: finalizeCodexEntries(legacyAcc)
   };
 }
 
@@ -8016,16 +8363,20 @@ async function collectVscodeAgent(opts) {
 }
 
 // src/pricing-live.ts
-import { mkdir, readFile as readFile3, rename, writeFile } from "node:fs/promises";
-import { dirname as dirname4, join as join11 } from "node:path";
+import { chmod, mkdir, rename, unlink, writeFile } from "node:fs/promises";
+import { randomBytes as randomBytes4 } from "node:crypto";
+import { dirname as dirname5, join as join11 } from "node:path";
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 5e3;
+var MAX_PRICING_BYTES = 32 * 1024 * 1024;
 function pricingCachePath(dir = defaultConfigDir()) {
   return join11(dir, "pricing-cache.json");
 }
 async function readCache(path) {
   try {
-    const parsed = JSON.parse(await readFile3(path, "utf8"));
+    const read = await readTextFileCapped(path, { maxBytes: MAX_PRICING_BYTES });
+    if (!read.ok) return null;
+    const parsed = JSON.parse(read.content);
     if (typeof parsed?.fetchedAt === "number" && parsed.table && typeof parsed.table === "object") {
       return parsed;
     }
@@ -8036,10 +8387,11 @@ async function readCache(path) {
 async function fetchLiveTable(url) {
   try {
     const res = await fetch(url, {
-      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+      redirect: "error"
     });
     if (!res.ok) return null;
-    const table = litellmToTable(await res.json());
+    const table = litellmToTable(await readJsonResponseCapped(res, MAX_PRICING_BYTES));
     return Object.keys(table).length > 0 ? table : null;
   } catch {
     return null;
@@ -8057,10 +8409,20 @@ async function loadLivePricing(env = process.env, now = Date.now, cachePath = pr
   if (live) {
     setLivePricing(live);
     try {
-      await mkdir(dirname4(path), { recursive: true });
-      const tmp = `${path}.${process.pid}.tmp`;
-      await writeFile(tmp, JSON.stringify({ fetchedAt: now(), table: live }));
-      await rename(tmp, path);
+      const dir = dirname5(path);
+      await mkdir(dir, { recursive: true, mode: 448 });
+      await chmod(dir, 448);
+      const serialized = JSON.stringify({ fetchedAt: now(), table: live });
+      if (Buffer.byteLength(serialized, "utf8") <= MAX_PRICING_BYTES) {
+        const tmp = `${path}.${process.pid}.${randomBytes4(8).toString("hex")}.tmp`;
+        try {
+          await writeFile(tmp, serialized, { encoding: "utf8", flag: "wx", mode: 384 });
+          await chmod(tmp, 384);
+          await rename(tmp, path);
+        } finally {
+          await unlink(tmp).catch(() => void 0);
+        }
+      }
     } catch {
     }
     return "live";
@@ -8073,8 +8435,8 @@ async function loadLivePricing(env = process.env, now = Date.now, cachePath = pr
 }
 
 // src/provenance-store.ts
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, renameSync as renameSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname5, join as join12 } from "node:path";
+import { join as join12 } from "node:path";
+var MAX_PROVENANCE_STORE_BYTES = 4 * 1024 * 1024;
 var PROVENANCE_STORE_VERSION = 1;
 var KEY_SEP = "|";
 var keyOf = (date, tool) => `${date}${KEY_SEP}${tool}`;
@@ -8088,7 +8450,9 @@ function provenanceStorePath(env = process.env) {
 }
 function loadProvenanceStore(path) {
   try {
-    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    const content = readTextFileSyncCapped(path, MAX_PROVENANCE_STORE_BYTES);
+    if (content === null) return null;
+    const parsed = JSON.parse(content);
     if (parsed && parsed.v === PROVENANCE_STORE_VERSION && parsed.req && typeof parsed.req === "object") {
       return {
         v: PROVENANCE_STORE_VERSION,
@@ -8102,10 +8466,7 @@ function loadProvenanceStore(path) {
 }
 function saveProvenanceStore(path, store) {
   try {
-    mkdirSync4(dirname5(path), { recursive: true });
-    const tmp = `${path}.tmp-${process.pid}`;
-    writeFileSync4(tmp, JSON.stringify(store));
-    renameSync4(tmp, path);
+    writePrivateFileAtomic(path, JSON.stringify(store), MAX_PROVENANCE_STORE_BYTES);
   } catch {
   }
 }
@@ -8159,12 +8520,131 @@ function reconcileProvenance(entries, agent, complete, store) {
   };
 }
 
+// src/wire-sanitize.ts
+import { createHash as createHash2 } from "node:crypto";
+var MACHINE_IDENTIFIER = /^[A-Za-z0-9][A-Za-z0-9._:/@+~-]*$/;
+function sanitizeMachineLabel(value, kind, maxLength) {
+  const raw = typeof value === "string" ? value.trim() : "";
+  if (raw.length > 0 && raw.length <= maxLength && MACHINE_IDENTIFIER.test(raw)) {
+    return raw;
+  }
+  const digest = createHash2("sha256").update(`${kind}\0`).update(raw).digest("hex").slice(0, 12);
+  return `${kind}-${digest}`;
+}
+function sanitizeDailyEntries(rows) {
+  const safe = [];
+  for (const raw of rows) {
+    if (!raw || typeof raw !== "object") continue;
+    const row = raw;
+    const parsed = DailyUsageEntry.safeParse({
+      ...row,
+      tool: sanitizeMachineLabel(row.tool, "agent", 64),
+      model: sanitizeMachineLabel(row.model, "model", 128),
+      // Only a server-side connector may assert stronger provenance.
+      origin: "cli",
+      verified: false
+    });
+    if (parsed.success) safe.push(parsed.data);
+  }
+  return safe;
+}
+function sanitizeSessions(rows) {
+  const safe = [];
+  for (const raw of rows) {
+    if (!raw || typeof raw !== "object") continue;
+    const row = raw;
+    const sessionId = createHash2("sha256").update("session\0").update(String(row.sessionId ?? "")).digest("hex");
+    const parsed = SessionEntry.safeParse({
+      ...row,
+      sessionId: `local-${sessionId.slice(0, 24)}`,
+      tool: sanitizeMachineLabel(row.tool, "agent", 64),
+      model: sanitizeMachineLabel(row.model, "model", 128)
+    });
+    if (parsed.success) safe.push(parsed.data);
+  }
+  return safe;
+}
+function sanitizeBlocks(rows) {
+  return rows.flatMap((row) => {
+    const parsed = BlockEntry.safeParse(row);
+    return parsed.success ? [parsed.data] : [];
+  });
+}
+function sanitizeToolStats(rows) {
+  return rows.flatMap((raw) => {
+    if (!raw || typeof raw !== "object") return [];
+    const row = raw;
+    const parsed = ToolStat.safeParse({
+      ...row,
+      name: sanitizeMachineLabel(row.name, "tool", 128)
+    });
+    return parsed.success ? [parsed.data] : [];
+  });
+}
+function sanitizeSkillStats(rows) {
+  return rows.flatMap((raw) => {
+    if (!raw || typeof raw !== "object") return [];
+    const row = raw;
+    const parsed = SkillStat.safeParse({
+      ...row,
+      name: sanitizeMachineLabel(row.name, "skill", 128)
+    });
+    return parsed.success ? [parsed.data] : [];
+  });
+}
+var EMPTY_AGENT = {
+  messageCount: 0,
+  subagentMessages: 0,
+  subagentTokens: 0,
+  totalTokens: 0,
+  userMessageCount: 0
+};
+function sanitizeAgentStat(value) {
+  const parsed = AgentStat.safeParse(value);
+  return parsed.success ? parsed.data : { ...EMPTY_AGENT };
+}
+function sanitizeCodexReplayScopes(scopes) {
+  return scopes.flatMap((raw) => {
+    if (!raw || typeof raw !== "object") return [];
+    const scope = raw;
+    const rows = Array.isArray(scope.rows) ? scope.rows.map((row) => {
+      if (!row || typeof row !== "object") return row;
+      const value = row;
+      return {
+        ...value,
+        model: sanitizeMachineLabel(value.model, "model", 128)
+      };
+    }) : scope.rows;
+    const parsed = CodexReplayPriorScope.safeParse({ ...scope, rows });
+    return parsed.success ? [parsed.data] : [];
+  });
+}
+
 // src/collect.ts
 var execFileAsync = promisify(execFile);
 var NATIVE_COVERED_SOURCES = /* @__PURE__ */ new Set(["claude", "codex"]);
 var CCUSAGE_TIMEOUT_MS = 25e3;
 var CCUSAGE_FALLBACK_TIMEOUT_MS = NATIVE_READ_BUDGET_MS;
 var CCUSAGE_AGGREGATE_TIMEOUT_MS = 18e4;
+var CCUSAGE_MAX_CONCURRENCY = 4;
+var CCUSAGE_MAX_BUFFER_BYTES = 32 * 1024 * 1024;
+async function mapConcurrent(items, concurrency, fn) {
+  const out = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (true) {
+      const index = next++;
+      if (index >= items.length) return;
+      out[index] = await fn(items[index], index);
+    }
+  };
+  const workers = Math.min(
+    items.length,
+    Math.max(1, Math.floor(concurrency) || 1)
+  );
+  await Promise.all(Array.from({ length: workers }, () => worker()));
+  return out;
+}
 var SOURCES = [
   "claude",
   "codex",
@@ -8292,16 +8772,16 @@ function mapCcusageBlocks(json) {
     if (b.isGap === true) continue;
     if (typeof b.startTime !== "string") continue;
     const totalTokens = norm(b.totalTokens);
-    const costUSD = normCost(b.costUSD);
-    if (totalTokens === 0 && costUSD === 0) continue;
-    out.push({ startTime: b.startTime, totalTokens, costUSD });
+    const costUSD2 = normCost(b.costUSD);
+    if (totalTokens === 0 && costUSD2 === 0) continue;
+    out.push({ startTime: b.startTime, totalTokens, costUSD: costUSD2 });
   }
   return out;
 }
 function resolveCcusageBin() {
-  const require3 = createRequire3(import.meta.url);
-  const pkgPath = require3.resolve("ccusage/package.json");
-  const pkg = require3("ccusage/package.json");
+  const require4 = createRequire4(import.meta.url);
+  const pkgPath = require4.resolve("ccusage/package.json");
+  const pkg = require4("ccusage/package.json");
   const rel = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.ccusage ?? "ccusage";
   const binPath = join13(dirname6(pkgPath), rel);
   if (/\.(c|m)?js$/.test(binPath)) {
@@ -8309,6 +8789,68 @@ function resolveCcusageBin() {
   }
   return { cmd: binPath, prefixArgs: [] };
 }
+function codexReplayTombstoneDates(native, correctedEntries, replayReadSucceeded) {
+  if (!replayReadSucceeded || native.timedOut) return [];
+  const correctedDates = new Set(
+    correctedEntries.filter((entry) => entry.tool === "codex").map((entry) => entry.date)
+  );
+  return [...new Set(native.replayCandidateDates ?? [])].filter((date) => !correctedDates.has(date)).sort().slice(0, 5e3);
+}
+function codexRowsByDate(entries) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.tool !== "codex" || entry.origin !== "cli" || entry.verified === true)
+      continue;
+    const byModel = grouped.get(entry.date) ?? /* @__PURE__ */ new Map();
+    const row = byModel.get(entry.model) ?? {
+      model: entry.model,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheCreationTokens: 0,
+      cacheReadTokens: 0
+    };
+    row.inputTokens += entry.inputTokens;
+    row.outputTokens += entry.outputTokens;
+    row.cacheCreationTokens += entry.cacheCreationTokens;
+    row.cacheReadTokens += entry.cacheReadTokens;
+    byModel.set(entry.model, row);
+    grouped.set(entry.date, byModel);
+  }
+  return new Map(
+    [...grouped].map(([date, byModel]) => [
+      date,
+      [...byModel.values()].sort((a, b) => a.model.localeCompare(b.model))
+    ])
+  );
+}
+function codexRowsEqual(left, right) {
+  return JSON.stringify(left ?? []) === JSON.stringify(right ?? []);
+}
+function codexReplayCorrectionMetadata(native, correctedEntries, replayReadSucceeded) {
+  if (!replayReadSucceeded || native.timedOut || !native.legacyEntries) {
+    return { tombstoneDates: [], priorScopes: [] };
+  }
+  const tombstoneDates = codexReplayTombstoneDates(
+    native,
+    correctedEntries,
+    replayReadSucceeded
+  );
+  const legacyByDate = codexRowsByDate(native.legacyEntries);
+  const correctedByDate = codexRowsByDate(correctedEntries);
+  const changedDates = new Set(tombstoneDates);
+  for (const [date, rows] of legacyByDate) {
+    if (!codexRowsEqual(rows, correctedByDate.get(date))) changedDates.add(date);
+  }
+  const priorScopes = [...changedDates].sort().flatMap((date) => {
+    const rows = legacyByDate.get(date);
+    return rows && rows.length > 0 && rows.length <= 100 ? [{ date, rows }] : [];
+  }).slice(0, 5e3);
+  const provedDates = new Set(priorScopes.map((scope) => scope.date));
+  return {
+    tombstoneDates: tombstoneDates.filter((date) => provedDates.has(date)),
+    priorScopes
+  };
+}
 function dedupeDaily(entries) {
   const byKey = /* @__PURE__ */ new Map();
   for (const e of entries) {
@@ -8362,8 +8904,7 @@ function dedupeBlocks(blocks) {
 function selectSourceEntries(source, ccusageEntries, native) {
   if (source === "claude" && nativeReaderWon(native.claude))
     return native.claude.entries;
-  if (source === "codex" && nativeReaderWon(native.codex))
-    return native.codex.entries;
+  if (source === "codex") return ccusageEntries;
   return ccusageEntries;
 }
 function nativeReaderWon(result) {
@@ -8371,7 +8912,7 @@ function nativeReaderWon(result) {
 }
 function ccusageFallbackSources(native) {
   return SOURCES.filter(
-    (s) => NATIVE_COVERED_SOURCES.has(s) && !nativeReaderWon(s === "claude" ? native.claude : native.codex)
+    (s) => s === "codex" || s === "claude" && !nativeReaderWon(native.claude)
   );
 }
 function ccusageClaudeEnv(env = process.env) {
@@ -8387,7 +8928,7 @@ async function runCcusageOnce(cmd, args, env, timeoutMs = CCUSAGE_TIMEOUT_MS) {
   try {
     const { stdout } = await execFileAsync(cmd, args, {
       encoding: "utf8",
-      maxBuffer: 64 * 1024 * 1024,
+      maxBuffer: CCUSAGE_MAX_BUFFER_BYTES,
       // A single source shouldn't be able to hang the whole run: a hung source
       // gets killed and (if transient) retried once below rather than stalling
       // everything for minutes. The claude/codex fallback passes a longer cap —
@@ -8428,22 +8969,26 @@ async function collectAll(onProgress, opts) {
   const nativeCodexTask = collectCodexNative().catch(
     () => ({ entries: [], found: false, filesScanned: 0, timedOut: true })
   );
-  const sourceTasks = SOURCES.map(async (source) => {
-    if (NATIVE_COVERED_SOURCES.has(source)) {
-      await (source === "claude" ? nativeClaudeTask : nativeCodexTask);
+  const sourceTasks = mapConcurrent(
+    SOURCES,
+    CCUSAGE_MAX_CONCURRENCY,
+    async (source) => {
+      if (NATIVE_COVERED_SOURCES.has(source)) {
+        await (source === "claude" ? nativeClaudeTask : nativeCodexTask);
+        tick();
+        return { source, mapped: [] };
+      }
+      const json = await runCcusage(cmd, [
+        ...prefixArgs,
+        source,
+        "daily",
+        "--json",
+        "--offline"
+      ]);
       tick();
-      return { source, mapped: [] };
+      return { source, mapped: json ? mapCcusageDaily(source, json) : [] };
     }
-    const json = await runCcusage(cmd, [
-      ...prefixArgs,
-      source,
-      "daily",
-      "--json",
-      "--offline"
-    ]);
-    tick();
-    return { source, mapped: json ? mapCcusageDaily(source, json) : [] };
-  });
+  );
   const sessionTask = runCcusage(
     cmd,
     [...prefixArgs, "session", "--json", "--offline"],
@@ -8491,7 +9036,7 @@ async function collectAll(onProgress, opts) {
     vscodeResults,
     continueResult
   ] = await Promise.all([
-    Promise.all(sourceTasks),
+    sourceTasks,
     sessionTask,
     blockTask,
     cursorTask,
@@ -8503,6 +9048,7 @@ async function collectAll(onProgress, opts) {
   ]);
   const native = { claude: nativeClaude, codex: nativeCodex };
   const fallbacks = /* @__PURE__ */ new Map();
+  let codexReplayReadSucceeded = false;
   for (const source of ccusageFallbackSources(native)) {
     const json = await runCcusage(
       cmd,
@@ -8511,8 +9057,15 @@ async function collectAll(onProgress, opts) {
       source === "claude" ? ccusageClaudeEnv() : void 0,
       CCUSAGE_FALLBACK_TIMEOUT_MS
     );
+    if (source === "codex") codexReplayReadSucceeded = json !== null;
     fallbacks.set(source, json ? mapCcusageDaily(source, json) : []);
   }
+  const codexReplayEntries = fallbacks.get("codex") ?? [];
+  const replayCorrection = codexReplayCorrectionMetadata(
+    nativeCodex,
+    codexReplayEntries,
+    codexReplayReadSucceeded
+  );
   const entries = [];
   const toolsFound = [];
   for (const { source, mapped } of sourceResults) {
@@ -8539,13 +9092,16 @@ async function collectAll(onProgress, opts) {
   }
   const { tools, skills, agent, sessionMessages, complete } = attribution;
   onProgress?.(COLLECT_STAGES, COLLECT_STAGES, "");
-  const dedupedSessions = dedupeSessions(sessions).map((s) => {
+  const localSessions = dedupeSessions(sessions).map((s) => {
     const messageCount = sessionMessages.get(s.sessionId);
     return {
       ...s,
       ...messageCount ? { messageCount } : {}
     };
   });
+  const dedupedSessions = sanitizeSessions(localSessions);
+  const boundaryEntries = sanitizeDailyEntries(entries);
+  const boundaryAgent = sanitizeAgentStat(agent);
   const scanComplete = isAuthoritativeScan(
     complete,
     nativeClaude,
@@ -8555,25 +9111,40 @@ async function collectAll(onProgress, opts) {
   );
   const storePath = provenanceStorePath();
   const reconciled = reconcileProvenance(
-    dedupeDaily(entries),
-    agent,
+    dedupeDaily(boundaryEntries),
+    boundaryAgent,
     scanComplete,
     loadProvenanceStore(storePath)
   );
+  const reconciledEntries = sanitizeDailyEntries(reconciled.entries);
   saveProvenanceStore(storePath, reconciled.store);
+  const cappedEntries = capByTokens(reconciledEntries, 2e4, entryTokens2);
+  const payloadReplayCorrection = boundaryEntries.length === entries.length && reconciledEntries.length === reconciled.entries.length && cappedEntries.length === reconciledEntries.length ? replayCorrection : { tombstoneDates: [], priorScopes: [] };
+  const safeReplayScopes = sanitizeCodexReplayScopes(
+    payloadReplayCorrection.priorScopes
+  );
+  const safeReplayDates = new Set(safeReplayScopes.map((scope) => scope.date));
   return {
     // Cap each array to the server's accepted maximum (the shared SubmitPayload
     // schema: entries ≤ 20000, sessions/blocks ≤ 10000), keeping the
     // highest-token rows. Without this, a power user with >10000 distinct sessions
     // would have their ENTIRE submit rejected with a 400 instead of a capped one.
     // tools/skills are already bounded upstream (attribution caps).
-    entries: capByTokens(reconciled.entries, 2e4, entryTokens2),
+    entries: cappedEntries,
+    codexReplayTombstoneDates: payloadReplayCorrection.tombstoneDates.filter(
+      (date) => safeReplayDates.has(date)
+    ),
+    codexReplayPriorScopes: safeReplayScopes,
     sessions: capByTokens(dedupedSessions, 1e4, entryTokens2),
-    blocks: capByTokens(dedupeBlocks(blocks), 1e4, (b) => b.totalTokens),
+    blocks: capByTokens(
+      dedupeBlocks(sanitizeBlocks(blocks)),
+      1e4,
+      (b) => b.totalTokens
+    ),
     toolsFound,
-    tools,
-    skills,
-    agent: reconciled.agent,
+    tools: sanitizeToolStats(tools),
+    skills: sanitizeSkillStats(skills),
+    agent: sanitizeAgentStat(reconciled.agent),
     attributionComplete: complete
   };
 }
@@ -8598,7 +9169,7 @@ function antigravityNoticeLines() {
 }
 
 // src/verify-upload.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 function prepareVerifyUpload(requests, scanTimedOut, cap = 5e4) {
   const sorted = requests.slice().sort((a, b) => b.ts - a.ts);
   const truncated = scanTimedOut || sorted.length > cap;
@@ -8612,7 +9183,7 @@ function prepareVerifyUpload(requests, scanTimedOut, cap = 5e4) {
     outputTokens: r.outputTokens,
     cacheCreationTokens: r.cacheCreationTokens,
     cacheReadTokens: r.cacheReadTokens,
-    reqHash: createHash("sha256").update(r.key).digest("hex").slice(0, 32)
+    reqHash: createHash3("sha256").update(r.key).digest("hex").slice(0, 32)
   }));
   return { records, truncated };
 }
@@ -8679,6 +9250,9 @@ function agentStatusReport(now = Date.now()) {
   });
 }
 
+// src/local-dashboard.ts
+import { join as join15 } from "node:path";
+
 // src/output.ts
 function formatTokens(n) {
   if (n >= 1e9) return `${(n / 1e9).toFixed(2)}B`;
@@ -8721,6 +9295,14 @@ function signedInNextStepLines(result) {
 }
 
 // src/local-dashboard.ts
+var MAX_LOCAL_DASHBOARD_BYTES = 16 * 1024 * 1024;
+function writeLocalDashboard(dir, html) {
+  const file = join15(dir, "dashboard.html");
+  if (!writePrivateFileAtomic(file, html, MAX_LOCAL_DASHBOARD_BYTES)) {
+    throw new Error("could not write the private local dashboard");
+  }
+  return file;
+}
 function esc(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
@@ -8951,8 +9533,8 @@ async function publishLocal(payload, deps) {
 }
 
 // src/index.ts
-var require2 = createRequire4(import.meta.url);
-var VERSION = require2("../package.json").version;
+var require3 = createRequire5(import.meta.url);
+var VERSION = require3("../package.json").version;
 var LOADING_VIBES = [
   "counting up your token usage, right here on your machine\u2026",
   "tallying tokens across every coding agent you use\u2026",
@@ -9024,10 +9606,8 @@ async function confirm(question) {
 }
 function showLocalDashboard(payload) {
   const dir = defaultConfigDir();
-  mkdirSync5(dir, { recursive: true });
-  const file = join15(dir, "dashboard.html");
-  writeFileSync5(
-    file,
+  const file = writeLocalDashboard(
+    dir,
     renderDashboardHtml(payload.entries, /* @__PURE__ */ new Date(), { webBaseUrl: webBase() })
   );
   const fileUrl = pathToFileURL(file).href;
@@ -9058,7 +9638,16 @@ async function run(flags) {
   } finally {
     progress.stop();
   }
-  const { entries, sessions, blocks, tools, skills, agent, attributionComplete } = collected;
+  const {
+    entries,
+    codexReplayTombstoneDates: codexReplayTombstoneDates2,
+    codexReplayPriorScopes,
+    blocks,
+    tools,
+    skills,
+    agent,
+    attributionComplete
+  } = collected;
   if (entries.length === 0) {
     console.log();
     console.log("  Nothing to burn yet \u2014 no local usage found from any coding agent.");
@@ -9070,8 +9659,14 @@ async function run(flags) {
     return;
   }
   const payload = { cliVersion: VERSION, entries };
+  if (codexReplayTombstoneDates2.length > 0)
+    payload.codexReplayTombstoneDates = codexReplayTombstoneDates2;
+  if (codexReplayPriorScopes.length > 0)
+    payload.codexReplayPriorScopes = codexReplayPriorScopes;
+  const configuredMachineKey = loadConfig()?.anonKey;
+  if (configuredMachineKey)
+    payload.deviceKeyHash = deviceKeyHash(configuredMachineKey);
   payload.tzOffsetMinutes = -(/* @__PURE__ */ new Date()).getTimezoneOffset();
-  if (sessions.length > 0) payload.sessions = sessions;
   if (blocks.length > 0) payload.blocks = blocks;
   if (tools.length > 0) payload.tools = tools;
   if (skills.length > 0) payload.skills = skills;
@@ -9091,19 +9686,11 @@ async function run(flags) {
         confirm,
         signIn: ensureSignedIn,
         submit: async (token, p) => {
-          const result = await submit(token, p);
+          const result = await submitFromBoundDevice(token, p);
           try {
             recordSync();
           } catch {
           }
-          try {
-            const cfgNow = loadConfig();
-            if (!cfgNow?.deviceBoundAt) {
-              const key = ensureAnonKey();
-              if (await bindDeviceKey(token, key)) recordDeviceBound();
-            }
-          } catch {
-          }
           return result;
         },
         openBrowser,
@@ -9122,7 +9709,7 @@ async function run(flags) {
     await submitSignedIn(cfg.cliToken, payload, flags, canSignIn);
     return;
   }
-  const healed = cfg?.anonKey ? await refreshCliToken(cfg.anonKey) : null;
+  const healed = cfg?.refreshToken ? await refreshCliToken(cfg.refreshToken) : null;
   if (healed) {
     saveAuth(void 0, { cliToken: healed.token, handle: healed.handle });
     await submitSignedIn(healed.token, payload, flags, canSignIn);
@@ -9134,7 +9721,7 @@ async function run(flags) {
     console.log(pc2.yellow("  Sign in to put your usage on the leaderboard."));
     console.log(
       pc2.dim(
-        "  Run `npx whoburnedmore` in an interactive terminal to sign in, or `npx whoburnedmore link --token=\u2026` (from your signed-in profile) for servers/CI."
+        "  Run `npx whoburnedmore` in an interactive terminal to sign in, or generate a one-time `npx whoburnedmore link` code from your profile for servers/CI."
       )
     );
   } else {
@@ -9146,8 +9733,8 @@ function sleep(ms) {
 }
 async function refreshCliTokenFromConfig() {
   const cfg = loadConfig();
-  if (!cfg?.anonKey) return null;
-  return refreshCliToken(cfg.anonKey);
+  if (!cfg?.refreshToken) return null;
+  return refreshCliToken(cfg.refreshToken);
 }
 async function ensureSignedIn() {
   const cfg = loadConfig();
@@ -9176,7 +9763,11 @@ async function ensureSignedIn() {
       continue;
     }
     if (res.status === "ok") {
-      saveAuth(void 0, { cliToken: res.token, handle: res.handle });
+      saveAuth(void 0, {
+        cliToken: res.token,
+        handle: res.handle,
+        refreshToken: res.refreshToken
+      });
       console.log(pc2.green(`  \u2713 Signed in as @${sanitizeServerText(res.handle)}.`));
       return { token: res.token, handle: res.handle };
     }
@@ -9188,24 +9779,21 @@ async function ensureSignedIn() {
   return null;
 }
 async function submitSignedIn(token, payload, flags, interactive) {
-  let activeToken = token;
   let result;
   try {
-    result = await submit(token, payload);
+    result = await submitFromBoundDevice(token, payload);
   } catch (err) {
     if (err instanceof UnauthorizedError) {
       const healed = await refreshCliTokenFromConfig();
       if (healed) {
         saveAuth(void 0, { cliToken: healed.token, handle: healed.handle });
-        activeToken = healed.token;
-        result = await submit(healed.token, payload);
+        result = await submitFromBoundDevice(healed.token, payload);
       } else {
         clearAuth();
         if (!interactive) return;
         const auth = await ensureSignedIn();
         if (!auth) return;
-        activeToken = auth.token;
-        result = await submit(auth.token, payload);
+        result = await submitFromBoundDevice(auth.token, payload);
       }
     } else {
       throw err;
@@ -9215,14 +9803,6 @@ async function submitSignedIn(token, payload, flags, interactive) {
     recordSync();
   } catch {
   }
-  try {
-    const cfgNow = loadConfig();
-    if (!cfgNow?.deviceBoundAt) {
-      const key = ensureAnonKey();
-      if (await bindDeviceKey(activeToken, key)) recordDeviceBound();
-    }
-  } catch {
-  }
   const baseUrl = result.orgBoardUrl ?? result.boardUrl ?? result.profileUrl;
   if (!flags.quiet) {
     console.log(
@@ -9281,6 +9861,29 @@ async function submitSignedIn(token, payload, flags, interactive) {
   }
   afterSubmitChores(flags);
 }
+async function submitFromBoundDevice(token, payload) {
+  let machineKey = loadConfig()?.anonKey;
+  try {
+    const cfg = loadConfig();
+    if (!cfg || needsDeviceBind(cfg)) {
+      machineKey = ensureAnonKey();
+      const bound = await bindDeviceKey(token, machineKey);
+      if (bound.refreshToken) {
+        saveAuth(void 0, {
+          cliToken: token,
+          handle: cfg?.handle,
+          refreshToken: bound.refreshToken
+        });
+      }
+      if (bound.definitive) recordDeviceBound();
+    }
+  } catch {
+  }
+  if (machineKey) {
+    payload.deviceKeyHash = deviceKeyHash(machineKey);
+  }
+  return submit(token, payload);
+}
 function afterSubmitChores(flags) {
   if (flags.quiet) {
     try {
@@ -9298,14 +9901,36 @@ function afterSubmitChores(flags) {
     autoSyncInstalled() ? pc2.dim("  Background sync is on \u2014 your page updates automatically every 15 min (`npx whoburnedmore uninstall-sync` to stop).") : pc2.dim("  Re-run anytime to update your page.")
   );
 }
+async function readServerInstallToken() {
+  const fromEnvironment = process.env.WHOBURNEDMORE_INSTALL_TOKEN?.trim();
+  if (fromEnvironment) return fromEnvironment;
+  if (process.stdin.isTTY) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const value2 = (await rl.question("  Paste the one-time link code: ")).trim();
+    rl.close();
+    return value2 || void 0;
+  }
+  let value = "";
+  for await (const chunk of process.stdin) {
+    value += String(chunk);
+    if (value.length > 512) {
+      throw new Error("install code input is too large");
+    }
+  }
+  return value.trim() || void 0;
+}
 async function linkServerInstall(token) {
   if (!token) {
-    throw new Error("missing install token \u2014 use `npx whoburnedmore link --token=<token>`");
+    throw new Error("missing install code \u2014 generate one from your signed-in profile, then paste it when prompted");
   }
   const anonKey = ensureAnonKey();
   const linked = await redeemServerInstall(token, anonKey);
   if (linked.cliToken) {
-    saveAuth(void 0, { cliToken: linked.cliToken, handle: linked.handle });
+    saveAuth(void 0, {
+      cliToken: linked.cliToken,
+      handle: linked.handle,
+      refreshToken: linked.refreshToken
+    });
   }
   const handle = sanitizeServerText(linked.handle);
   console.log(
@@ -9378,7 +10003,7 @@ async function runDaemon() {
       await run({ dryRun: false, noSubmit: false, local: false, quiet: true });
       if (!loadConfig()?.cliToken) {
         throw new Error(
-          "not linked \u2014 nothing submitted (run `npx whoburnedmore link --token=\u2026` from your signed-in profile first)"
+          "not linked \u2014 nothing submitted (generate a one-time link code from your signed-in profile first)"
         );
       }
     }
@@ -9597,7 +10222,10 @@ async function main() {
       break;
     }
     case "link":
-      await linkServerInstall(parseInstallToken(args));
+      if (hasUnsafeInstallTokenArg(args)) {
+        throw new Error("`--token` is no longer accepted because command-line secrets leak into shell history and process listings; run `npx whoburnedmore link` and paste the code when prompted");
+      }
+      await linkServerInstall(await readServerInstallToken());
       break;
     case "daemon":
       await runDaemon();
@@ -9650,7 +10278,7 @@ function printHelp() {
     npx whoburnedmore --local      build the dashboard on your machine and open it (offline)
     npx whoburnedmore --dry-run    print exactly what would be sent, send nothing
     npx whoburnedmore --no-submit  collect locally, send nothing (no dashboard)
-    npx whoburnedmore link --token=TOKEN  link this server/VM to your signed-in account
+    npx whoburnedmore link                link this server/VM (prompts for a one-time code)
     npx whoburnedmore daemon       keep syncing in the foreground (VMs/containers with no cron)
     npx whoburnedmore private      take yourself off the public leaderboard
     npx whoburnedmore public       put yourself back on it