tokentracker-cli 0.79.8 → 0.80.0

package/src/commands/init.js

@@ -21,9 +21,11 @@ const {
 } = require("../lib/codex-config");
 const {
   upsertClaudeHook,
+  upsertClaudeUsageHooks,
   buildClaudeHookCommand,
   buildHookCommand,
   isClaudeHookConfigured,
+  areClaudeUsageHooksConfigured,
 } = require("../lib/claude-config");
 const {
   resolveGeminiConfigDir,
@@ -418,6 +420,78 @@ async function repairCodexNotifyIntegration({ home = os.homedir(), trackerDir, b
   return { ...result, skippedReason: null, notifyPath };
 }
 
+async function repairRuntimeIntegrations({
+  home = os.homedir(),
+  trackerDir,
+  binDir,
+  safeMode = true,
+} = {}) {
+  const paths = trackerDir && binDir ? { trackerDir, binDir } : await resolveTrackerPaths({ home });
+  const resolvedTrackerDir = trackerDir || paths.trackerDir;
+  const resolvedBinDir = binDir || paths.binDir;
+  const notifyPath = await writeNotifyHandler({
+    trackerDir: resolvedTrackerDir,
+    binDir: resolvedBinDir,
+  });
+  const context = buildIntegrationTargets({
+    home,
+    trackerDir: resolvedTrackerDir,
+    notifyPath,
+  });
+  const integrations = {};
+  const warnings = [];
+
+  const attempt = async (key, work) => {
+    try {
+      integrations[key] = await work();
+    } catch (error) {
+      integrations[key] = { changed: false, skippedReason: "repair-failed" };
+      warnings.push({ integration: key, error: error?.message || String(error) });
+    }
+  };
+
+  await attempt("codex", () => repairCodexNotifyIntegration({
+    home,
+    trackerDir: resolvedTrackerDir,
+    binDir: resolvedBinDir,
+    safeMode,
+  }));
+
+  const hookRepairs = [
+    ["claude", context.claudeDir, () => upsertClaudeUsageHooks({
+      settingsPath: context.claudeSettingsPath,
+      hookCommand: context.claudeHookCommand,
+    })],
+    ["gemini", context.geminiConfigDir, () => upsertGeminiHook({
+      settingsPath: context.geminiSettingsPath,
+      hookCommand: context.geminiHookCommand,
+    })],
+    ["codebuddy", context.codebuddyDir, () => upsertClaudeHook({
+      settingsPath: context.codebuddySettingsPath,
+      hookCommand: context.codebuddyHookCommand,
+    })],
+    ["workbuddy", context.workbuddyDir, () => upsertClaudeHook({
+      settingsPath: context.workbuddySettingsPath,
+      hookCommand: context.workbuddyHookCommand,
+    })],
+  ];
+  for (const [key, configDir, repair] of hookRepairs) {
+    if (await isDir(configDir)) await attempt(key, repair);
+    else integrations[key] = { changed: false, skippedReason: "config-missing" };
+  }
+
+  if (await isDir(context.opencodeConfigDir)) {
+    await attempt("opencode", () => upsertOpencodePlugin({
+      configDir: context.opencodeConfigDir,
+      notifyPath,
+    }));
+  } else {
+    integrations.opencode = { changed: false, skippedReason: "config-missing" };
+  }
+
+  return { notifyPath, integrations, warnings };
+}
+
 function buildIntegrationTargets({ home, trackerDir, notifyPath }) {
   const codexHome = process.env.CODEX_HOME || path.join(home, ".codex");
   const codexConfigPath = path.join(codexHome, "config.toml");
@@ -495,7 +569,7 @@ async function applyIntegrationSetup({ home, trackerDir, notifyPath, notifyOrigi
 
   const claudeDirExists = await isDir(context.claudeDir);
   if (claudeDirExists) {
-    await upsertClaudeHook({
+    await upsertClaudeUsageHooks({
       settingsPath: context.claudeSettingsPath,
       hookCommand: context.claudeHookCommand,
     });
@@ -787,7 +861,7 @@ async function previewIntegrations({ context }) {
 
   const claudeDirExists = await isDir(context.claudeDir);
   if (claudeDirExists) {
-    const configured = await isClaudeHookConfigured({
+    const configured = await areClaudeUsageHooksConfigured({
       settingsPath: context.claudeSettingsPath,
       hookCommand: context.claudeHookCommand,
     });
@@ -1071,7 +1145,6 @@ const codexOriginalPath = ${JSON.stringify(originalPath)};
 const codeOriginalPath = ${JSON.stringify(path.join(trackerDir, "code_notify_original.json"))};
 const trackerBinPath = ${JSON.stringify(trackerBinPath)};
   const depsMarkerPath = path.join(trackerDir, 'app', 'bin', 'tracker.js');
-  const configPath = path.join(trackerDir, 'config.json');
 const fallbackPkg = ${JSON.stringify(fallbackPkg)};
 const selfPath = path.resolve(__filename);
 const home = os.homedir();
@@ -1109,18 +1182,10 @@ if (debugEnabled) {
 // Throttle spawn: at most once per 20 seconds.
 try {
     const throttlePath = path.join(trackerDir, 'sync.throttle');
-    let deviceToken = process.env.TOKENTRACKER_DEVICE_TOKEN || null;
-    if (!deviceToken) {
-      try {
-        const cfg = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-        if (cfg && typeof cfg.deviceToken === 'string') deviceToken = cfg.deviceToken;
-      } catch (_) {}
-    }
-    const canSync = Boolean(deviceToken && deviceToken.length > 0);
     const now = Date.now();
     let last = 0;
     try { last = Number(fs.readFileSync(throttlePath, 'utf8')) || 0; } catch (_) {}
-    if (canSync && now - last > 20_000) {
+    if (now - last > 20_000) {
     try { fs.writeFileSync(throttlePath, String(now), 'utf8'); } catch (_) {}
     const hasLocalRuntime = fs.existsSync(trackerBinPath);
     const hasLocalDeps = fs.existsSync(depsMarkerPath);
@@ -1241,6 +1306,7 @@ module.exports = {
   buildNotifyHandler,
   installLocalTrackerApp,
   repairCodexNotifyIntegration,
+  repairRuntimeIntegrations,
 };
 
 async function probeFile(p) {
@@ -1266,6 +1332,11 @@ async function isDir(p) {
 }
 
 async function installLocalTrackerApp({ appDir }) {
+  // Test-only escape hatch: skip the ~10 MB runtime copy (src + dashboard/dist +
+  // node_modules) when a test only exercises hook/config/notify wiring. Copying
+  // the bundle per test case dominates the init test suite's wall time. Tests
+  // that assert on the copied runtime simply leave this unset.
+  if (process.env.TOKENTRACKER_SKIP_LOCAL_RUNTIME_COPY === "1") return;
   // Copy the current package's runtime (bin + src) into ~/.tokentracker so notify can run sync without npx.
   const packageRoot = path.resolve(__dirname, "../..");
   const srcFrom = path.join(packageRoot, "src");
@@ -1321,6 +1392,12 @@ async function safeRealpath(p) {
 const FIRST_SYNC_TIMEOUT_MS = 15_000;
 
 async function runFirstSyncAndRead({ trackerBinPath, trackerDir, packageName }) {
+  // Test-only escape hatch: skip spawning a real `sync --drain` subprocess when
+  // a test only exercises init wiring. Returns the same shape derived from an
+  // (empty) queue so callers behave identically without the ~1s spawn per case.
+  if (process.env.TOKENTRACKER_SKIP_FIRST_SYNC === "1") {
+    return readFirstSyncTotals(trackerDir);
+  }
   const fallbackPkg = packageName || "tokentracker-cli";
   const argv = ["sync", "--drain"];
   const hasLocalRuntime = typeof trackerBinPath === "string" && fssync.existsSync(trackerBinPath);

package/src/commands/serve.js

@@ -22,6 +22,7 @@ const WSL_DEFAULT_PORT = 7681;
 const DEFAULT_MAX_PORT_ATTEMPTS = 20;
 const NPM_PACKAGE_NAME = "tokentracker-cli";
 const LOCAL_BIND_HOST = "127.0.0.1";
+const NATIVE_BACKGROUND_SYNC_INTERVAL_MS = 60_000;
 const STATIC_ASSET_EXTENSIONS = new Set([
   ".css",
   ".gif",
@@ -71,11 +72,13 @@ async function cmdServe(argv) {
   }
 
   try {
-    const { installLocalTrackerApp, repairCodexNotifyIntegration } = require("./init");
+    const { installLocalTrackerApp, repairRuntimeIntegrations } = require("./init");
     await installLocalTrackerApp({ appDir: path.join(trackerDir, "app") });
-    const repairResult = await repairCodexNotifyIntegration({ trackerDir, binDir, safeMode: true });
-    if (repairResult?.skippedReason && repairResult.skippedReason !== "config-missing") {
-      process.stdout.write(`Codex notify repair skipped: ${repairResult.skippedReason}\n`);
+    const repairResult = await repairRuntimeIntegrations({ trackerDir, binDir, safeMode: true });
+    for (const warning of repairResult?.warnings || []) {
+      process.stdout.write(
+        `Runtime integration repair warning (${warning.integration}): ${warning.error}\n`,
+      );
     }
   } catch (e) {
     process.stdout.write(`Runtime refresh warning: ${e?.message || e}\n`);
@@ -217,6 +220,18 @@ async function cmdServe(argv) {
 
   await maybeShowStarCta({ trackerDir });
 
+  // Native desktop apps keep this server alive even when the dashboard window
+  // is closed. Provider hooks are the fast path, but they can be removed by a
+  // tool update or skipped by a provider. Scan every local source once a
+  // minute as a bounded fallback so the queue cannot remain stale indefinitely.
+  // `--no-sync` still skips the blocking startup sync; this periodic pass is
+  // native-shell-only and uses the lightweight local mode (no cloud upload,
+  // Cursor network request, or deep Codex archive scan).
+  const nativeBackgroundSync = startNativeBackgroundSync({
+    onError: (e) =>
+      process.stdout.write(`Background local sync warning: ${e?.message || e}\n`),
+  });
+
   // Anonymous daily heartbeat (see src/lib/telemetry.js for the privacy
   // contract). Fire-and-forget at startup, then re-checked every 6 hours so
   // long-lived embedded-app servers still count on later days; the shared
@@ -238,6 +253,7 @@ async function cmdServe(argv) {
   // 5. Graceful shutdown
   const shutdown = () => {
     process.stdout.write("\nShutting down...\n");
+    nativeBackgroundSync?.stop();
     server.close(() => process.exit(0));
     setTimeout(() => process.exit(0), 3000);
   };
@@ -248,6 +264,49 @@ async function cmdServe(argv) {
   await new Promise(() => {});
 }
 
+function startNativeBackgroundSync({
+  appShell = process.env.TOKENTRACKER_APP_SHELL,
+  intervalMs = NATIVE_BACKGROUND_SYNC_INTERVAL_MS,
+  runSync,
+  setIntervalFn = setInterval,
+  clearIntervalFn = clearInterval,
+  onError = () => {},
+} = {}) {
+  const normalizedShell = String(appShell || "").trim().toLowerCase();
+  if (normalizedShell !== "macos" && normalizedShell !== "windows") return null;
+
+  const sync = runSync || (async (args) => {
+    const { cmdSync } = require("./sync");
+    await cmdSync(args);
+  });
+  let inFlight = null;
+  const run = () => {
+    if (inFlight) return inFlight;
+    const pending = Promise.resolve()
+      .then(() => sync(["--auto", "--background", "--all-local-sources"]))
+      .catch((error) => {
+        try { onError(error); } catch (_e) {}
+      })
+      .finally(() => {
+        if (inFlight === pending) inFlight = null;
+      });
+    inFlight = pending;
+    return pending;
+  };
+
+  const timer = setIntervalFn(() => {
+    void run();
+  }, intervalMs);
+  timer?.unref?.();
+
+  return {
+    run,
+    stop() {
+      clearIntervalFn(timer);
+    },
+  };
+}
+
 function findPidOnPort(port) {
   try {
     const out = cp.execFileSync("lsof", ["-ti", `tcp:${port}`], { encoding: "utf8", timeout: 5000 });
@@ -455,4 +514,6 @@ module.exports = {
   isRunningUnderWsl,
   resolveDefaultPort,
   shouldServeSpaFallback,
+  startNativeBackgroundSync,
+  NATIVE_BACKGROUND_SYNC_INTERVAL_MS,
 };

package/src/commands/status.js

@@ -8,6 +8,7 @@ const { readJson } = require("../lib/fs");
 const { readCodexNotify, readEveryCodeNotify } = require("../lib/codex-config");
 const {
   isClaudeHookConfigured,
+  areClaudeUsageHooksConfigured,
   buildClaudeHookCommand,
   buildHookCommand,
 } = require("../lib/claude-config");
@@ -155,7 +156,7 @@ async function cmdStatus(argv = []) {
   const everyCodeNotify = await readEveryCodeNotify(codeConfigPath);
   const everyCodeConfigured =
     Array.isArray(everyCodeNotify) && everyCodeNotify.length > 0;
-  const claudeHookConfigured = await isClaudeHookConfigured({
+  const claudeHookConfigured = await areClaudeUsageHooksConfigured({
     settingsPath: claudeSettingsPath,
     hookCommand: claudeHookCommand,
   });

package/src/commands/sync.js

@@ -172,6 +172,18 @@ const CLOUD_CONVERSATIONS_BACKFILL_KEY = "cloudConversationsBackfill_2026_06";
 // ~/.codex/archived_sessions/ which sync does not scan) — clearing its bucket
 // would lose that history (ref the v6 ground-truth-repair data-loss incident).
 const CODEX_RESCAN_DEDUP_REPAIR_KEY = "codexRescanDedupRepair_2026_06";
+// One-time repair (#169 follow-up): forked Codex rollouts replay the parent
+// session's token history into the child file, and until the same-day burst
+// detector landed in rollout.js the parser counted those replayed rows as live
+// usage (PR #169's date guard only caught cross-day forks). Cursors sit at EOF
+// on every already-parsed file, so the forward fix alone never corrects the
+// inflated history. This re-runs the exact #187 guarded rebuild under a new key
+// — the rebuild re-parses every codex file with the CURRENT (fork-aware)
+// parser, so replay rows are excluded — and inherits all its safety properties
+// (unreproducible-session skip, atomic throwaway rebuild, queue strip, upload
+// offset reset for the cloud overwrite). Pre-gated: installs with no forked
+// rollout on disk carry no fork phantom and mark done without the rebuild.
+const CODEX_FORK_REPLAY_REPAIR_KEY = "codexForkReplayRepair_2026_07";
 const DROID_DUP_SESSION_REPAIR_KEY = "droidDupSessionInflationRepair_2026_06";
 const CODEX_COLD_SCAN_AUDIT_INTERVAL_MS = 24 * 60 * 60 * 1000;
 const CODEX_COLD_SCAN_AUDIT_MAX_SYNCS = 288;
@@ -330,11 +342,18 @@ async function cmdSync(argv) {
 
     const autoSourceScope = resolveAutoSourceScope(opts);
     const isBackgroundLightweightSync = opts.auto && opts.background && !opts.drain;
+    const isBackgroundAllLocalSync = isBackgroundLightweightSync && opts.allLocalSources;
     const isFullSourceScan = !autoSourceScope && !isBackgroundLightweightSync;
     const sourceAllowed = (...sources) => {
       if (isBackgroundLightweightSync) {
         if (autoSourceScope) {
-          return BACKGROUND_AUTO_SYNC_SOURCES.has(autoSourceScope) && sources.includes(autoSourceScope);
+          return (
+            (isBackgroundAllLocalSync || BACKGROUND_AUTO_SYNC_SOURCES.has(autoSourceScope)) &&
+            sources.includes(autoSourceScope)
+          );
+        }
+        if (isBackgroundAllLocalSync) {
+          return sources.some((source) => AUTO_SYNC_SOURCES.has(source));
         }
         return sources.some((source) => BACKGROUND_AUTO_SYNC_SOURCES.has(source));
       }
@@ -398,13 +417,22 @@ async function cmdSync(argv) {
 
     if (isFullSourceScan) {
       await migrateRolloutCumulativeDeltaBuckets({ cursors, queuePath, rolloutFiles });
-      await repairCodexRescanInflation({
+      const codexRescanRepairRan = await repairCodexRescanInflation({
+        cursors,
+        queuePath,
+        queueStatePath,
+        projectQueuePath,
+        projectQueueStatePath,
+        rolloutFiles,
+      });
+      await repairCodexForkReplayInflation({
         cursors,
         queuePath,
         queueStatePath,
         projectQueuePath,
         projectQueueStatePath,
         rolloutFiles,
+        legacyRepairRan: codexRescanRepairRan,
       });
       await repairDroidDuplicateSessionInflation({ cursors, queuePath, queueStatePath });
       await repairMimoClaudeMislabel({
@@ -1998,6 +2026,7 @@ function parseArgs(argv) {
     source: null,
     drain: false,
     background: false,
+    allLocalSources: false,
     repairGrok: false,
   };
   for (let i = 0; i < argv.length; i++) {
@@ -2013,6 +2042,7 @@ function parseArgs(argv) {
     else if (a.startsWith("--source=")) out.source = normalizeSyncSource(a.slice("--source=".length));
     else if (a === "--drain") out.drain = true;
     else if (a === "--background" || a === "--lightweight") out.background = true;
+    else if (a === "--all-local-sources") out.allLocalSources = true;
     else if (a === "--repair-grok") out.repairGrok = true;
     else throw new Error(`Unknown option: ${a}`);
   }
@@ -2088,6 +2118,7 @@ module.exports = {
   migrateCursorUnknownBuckets,
   migrateRolloutCumulativeDeltaBuckets,
   repairCodexRescanInflation,
+  repairCodexForkReplayInflation,
   repairDroidDuplicateSessionInflation,
   repairMimoClaudeMislabel,
   reincludeClaudeMemObserverFiles,
@@ -2100,6 +2131,7 @@ module.exports = {
   CURSOR_UNKNOWN_MIGRATION_KEY,
   ROLLOUT_CUMULATIVE_DELTA_MIGRATION_KEY,
   CODEX_RESCAN_DEDUP_REPAIR_KEY,
+  CODEX_FORK_REPLAY_REPAIR_KEY,
   DROID_DUP_SESSION_REPAIR_KEY,
   CLAUDE_MEM_OBSERVER_REINCLUDE_KEY,
   GROK_APPEND_ONLY_REPAIR_MIGRATION_KEY,
@@ -3148,6 +3180,11 @@ async function repairCodexRescanInflation({
   projectQueuePath,
   projectQueueStatePath,
   rolloutFiles,
+  // The fork-replay repair (#169 follow-up) re-runs this exact rebuild under
+  // its own key: the rebuild always uses the CURRENT parser, so any parser fix
+  // shipped since the last run is applied to the rebuilt history.
+  migrationKey = CODEX_RESCAN_DEDUP_REPAIR_KEY,
+  uploadNote = "reset_after_codex_rescan_dedup_2026_06",
 }) {
   if (!cursors || typeof cursors !== "object") return false;
   const migrations = (cursors.migrations ||= {});
@@ -3158,7 +3195,7 @@ async function repairCodexRescanInflation({
   // found). Treating the skip sentinel as "done" is what left users like #187
   // permanently stuck on the inflated value after upgrading (the key was truthy
   // so the guard never got a second chance).
-  const priorRepair = migrations[CODEX_RESCAN_DEDUP_REPAIR_KEY];
+  const priorRepair = migrations[migrationKey];
   if (priorRepair && !(typeof priorRepair === "object" && priorRepair.skipped)) return false;
 
   // Codex session files THIS sync discovered (source === "codex").
@@ -3194,7 +3231,7 @@ async function repairCodexRescanInflation({
       if (codexFileSet.has(fp)) continue; // exact file re-scanned this run
       const id = codexSessionIdFromPath(fp);
       if (id && scannedSessionIds.has(id)) continue; // same session scanned elsewhere (moved)
-      migrations[CODEX_RESCAN_DEDUP_REPAIR_KEY] = {
+      migrations[migrationKey] = {
         skipped: true,
         reason: "codex_session_unreproducible",
         at: new Date().toISOString(),
@@ -3453,7 +3490,7 @@ async function repairCodexRescanInflation({
     }
     uploadState.offset = 0;
     uploadState.updatedAt = new Date().toISOString();
-    uploadState.note = "reset_after_codex_rescan_dedup_2026_06";
+    uploadState.note = uploadNote;
     await fs.writeFile(queueStatePath, JSON.stringify(uploadState));
   }
   if (projectRepairEnabled && typeof projectQueueStatePath === "string" && projectQueueStatePath) {
@@ -3465,14 +3502,140 @@ async function repairCodexRescanInflation({
     }
     uploadState.offset = 0;
     uploadState.updatedAt = new Date().toISOString();
-    uploadState.note = "reset_after_codex_rescan_dedup_2026_06";
+    uploadState.note = uploadNote;
     await fs.writeFile(projectQueueStatePath, JSON.stringify(uploadState));
   }
 
-  migrations[CODEX_RESCAN_DEDUP_REPAIR_KEY] = new Date().toISOString();
+  migrations[migrationKey] = new Date().toISOString();
   return true;
 }
 
+// #169 follow-up: repair the historical inflation left by same-day forked
+// Codex rollout replays (see CODEX_FORK_REPLAY_REPAIR_KEY). Delegates to the
+// #187 guarded rebuild with the fork-repair key.
+async function repairCodexForkReplayInflation({
+  cursors,
+  queuePath,
+  queueStatePath,
+  projectQueuePath,
+  projectQueueStatePath,
+  rolloutFiles,
+  // True when the #187 repair ran its rebuild earlier in THIS sync: that
+  // rebuild already used the fork-aware parser, so the history is clean and a
+  // second rebuild would be pure waste.
+  legacyRepairRan = false,
+}) {
+  if (!cursors || typeof cursors !== "object") return false;
+  const migrations = (cursors.migrations ||= {});
+  // Same completed-vs-skipped semantics as the #187 repair: an ISO string is
+  // final, a {skipped:true} sentinel retries (the skip condition can clear).
+  const prior = migrations[CODEX_FORK_REPLAY_REPAIR_KEY];
+  if (prior && !(typeof prior === "object" && prior.skipped)) return false;
+
+  if (legacyRepairRan) {
+    migrations[CODEX_FORK_REPLAY_REPAIR_KEY] = new Date().toISOString();
+    return false;
+  }
+
+  // Pre-gate: fork phantom can only exist on installs that have (or had) a
+  // forked rollout. Scanning file heads is cheap; the rebuild re-parses every
+  // codex file. Files forked AFTER the parser fix shipped never accrue
+  // phantom, so a definitive "no forks" verdict may finalize — but ONLY when
+  // this scan can actually stand for the install's whole codex history:
+  //   1. every candidate head was readable (an unreadable candidate could be
+  //      the one forked rollout), AND
+  //   2. every codex session recorded in cursors is covered by THIS scan's
+  //      file list (same UUID-keyed reproducibility rule as the #187 guard).
+  //      A forked rollout can be real yet absent from one run's rolloutFiles —
+  //      WSL/native split probing, a temporarily missing ~/.codex, a deleted
+  //      file whose phantom is already in history — and finalizing off such a
+  //      partial view would permanently foreclose the repair this migration
+  //      exists to perform, while the guarded repair itself would only have
+  //      deferred retryably.
+  // Either failure defers with the retryable {skipped:true} sentinel.
+  const forkScan = await scanForForkedCodexRollout(rolloutFiles);
+  if (!forkScan.forked) {
+    if (forkScan.indeterminate) {
+      migrations[CODEX_FORK_REPLAY_REPAIR_KEY] = {
+        skipped: true,
+        reason: "fork_scan_indeterminate",
+        at: new Date().toISOString(),
+      };
+      return false;
+    }
+    const scannedSessionIds = new Set();
+    const scannedPaths = new Set();
+    for (const entry of Array.isArray(rolloutFiles) ? rolloutFiles : []) {
+      const fp = typeof entry === "string" ? entry : entry?.path;
+      const src = typeof entry === "string" ? "codex" : String(entry?.source || "codex");
+      if (!fp || src !== "codex") continue;
+      scannedPaths.add(fp);
+      const id = codexSessionIdFromPath(fp);
+      if (id) scannedSessionIds.add(id);
+    }
+    if (cursors.files && typeof cursors.files === "object") {
+      for (const fp of Object.keys(cursors.files)) {
+        if (!isCodexSessionCursorPath(fp)) continue;
+        if (scannedPaths.has(fp)) continue;
+        const id = codexSessionIdFromPath(fp);
+        if (id && scannedSessionIds.has(id)) continue;
+        migrations[CODEX_FORK_REPLAY_REPAIR_KEY] = {
+          skipped: true,
+          reason: "codex_history_not_covered",
+          at: new Date().toISOString(),
+        };
+        return false;
+      }
+    }
+    migrations[CODEX_FORK_REPLAY_REPAIR_KEY] = new Date().toISOString();
+    return false;
+  }
+
+  return repairCodexRescanInflation({
+    cursors,
+    queuePath,
+    queueStatePath,
+    projectQueuePath,
+    projectQueueStatePath,
+    rolloutFiles,
+    migrationKey: CODEX_FORK_REPLAY_REPAIR_KEY,
+    uploadNote: "reset_after_codex_fork_replay_2026_07",
+  });
+}
+
+// Scans codex rollout heads for the fork marker. The child session_meta (with
+// forked_from_id) is the FIRST line of a forked rollout — observed at byte
+// offset ≤169 across every local sample — so a bounded head read is
+// sufficient. 64KB leaves ample margin for long base_instructions preceding
+// it; a substring false positive (the marker quoted in unrelated head content)
+// only costs one redundant guarded rebuild, never data. Tri-state result:
+// {forked:true} on a hit, {forked:false, indeterminate:false} only when every
+// candidate was inspected, {forked:false, indeterminate:true} when any head
+// read failed — the caller must not finalize "no forks" off a failed read.
+async function scanForForkedCodexRollout(rolloutFiles) {
+  const HEAD_BYTES = 65536;
+  let indeterminate = false;
+  for (const entry of Array.isArray(rolloutFiles) ? rolloutFiles : []) {
+    const fp = typeof entry === "string" ? entry : entry?.path;
+    const src = typeof entry === "string" ? "codex" : String(entry?.source || "codex");
+    if (!fp || src !== "codex") continue;
+    let fh = null;
+    try {
+      fh = await fs.open(fp, "r");
+      const buf = Buffer.alloc(HEAD_BYTES);
+      const { bytesRead } = await fh.read(buf, 0, HEAD_BYTES, 0);
+      if (buf.toString("utf8", 0, bytesRead).includes('"forked_from_id"')) {
+        return { forked: true, indeterminate: false };
+      }
+    } catch (_e) {
+      indeterminate = true;
+    } finally {
+      if (fh) await fh.close().catch(() => {});
+    }
+  }
+  return { forked: false, indeterminate };
+}
+
 function isCodexSessionCursorPath(filePath) {
   if (typeof filePath !== "string") return false;
   const normalized = filePath.replace(/\\/g, "/");

package/src/commands/uninstall.js

@@ -3,7 +3,12 @@ const path = require("node:path");
 const fs = require("node:fs/promises");
 
 const { restoreCodexNotify, restoreEveryCodeNotify } = require("../lib/codex-config");
-const { removeClaudeHook, buildClaudeHookCommand, buildHookCommand } = require("../lib/claude-config");
+const {
+  removeClaudeHook,
+  removeClaudeUsageHooks,
+  buildClaudeHookCommand,
+  buildHookCommand,
+} = require("../lib/claude-config");
 const {
   resolveGeminiConfigDir,
   resolveGeminiSettingsPath,
@@ -64,7 +69,10 @@ async function cmdUninstall(argv) {
       })
     : { restored: false, skippedReason: "config-missing" };
   const claudeRemove = claudeConfigExists
-    ? await removeClaudeHook({ settingsPath: claudeSettingsPath, hookCommand: claudeHookCommand })
+    ? await removeClaudeUsageHooks({
+        settingsPath: claudeSettingsPath,
+        hookCommand: claudeHookCommand,
+      })
     : { removed: false, skippedReason: "config-missing" };
   const codebuddyRemove = codebuddyConfigExists
     ? await removeClaudeHook({