tokentracker-cli 1.1.4 → 1.1.6

package/src/commands/status.js

@@ -116,6 +116,13 @@ const {
 const wsl = require("../lib/wsl-probe");
 const { getWslMode, isInvalidWslMode, shouldProbeWsl, discoverWslHome } = wsl;
 const { resolveInstallPaths, resolveZcodeNativeDbPath, resolveMimoNativeDbPath } = require("../lib/install-resolver");
+const {
+  describeScanRootOrigin,
+  describeScanRootState,
+  hasAnyScanChild,
+  resolveEnvRoot,
+  resolveScanRoots,
+} = require("../lib/scan-roots");
 const { probeGrokHookState, resolveGrokHome } = require("../lib/grok-hook");
 const { probeOmpHookState } = require("../lib/omp-hook");
 
@@ -197,7 +204,9 @@ async function cmdStatus(argv = []) {
   const uploadThrottlePath = path.join(trackerDir, "upload.throttle.json");
   const autoRetryPath = path.join(trackerDir, "auto.retry.json");
   const syncSkipPath = path.join(trackerDir, "sync.skip.json");
-  const codexHome = process.env.CODEX_HOME || path.join(home, ".codex");
+  // Normalized like sync (a relative CODEX_HOME is anchored to home, not cwd)
+  // so status lists exactly the root sync walks.
+  const codexHome = resolveEnvRoot("codex", { env: process.env, home }) || path.join(home, ".codex");
   const codexConfigPath = path.join(codexHome, "config.toml");
   const acodeHome = process.env.TOKENTRACKER_ACODE_HOME || path.join(home, ".acode");
   const acodeConfigPath = path.join(acodeHome, "config.toml");
@@ -229,6 +238,33 @@ async function cmdStatus(argv = []) {
   const geminiHookCommand = buildGeminiHookCommand(notifyPath);
 
   const config = await readJson(configPath);
+  // Extra scan roots (#657): CODEX_HOME / CLAUDE_CONFIG_DIR of this process
+  // plus config.scanRoots, resolved exactly as sync does, so status lists every
+  // root sync walks — this is the output users paste when usage looks wrong.
+  const scanRoots = resolveScanRoots({
+    home,
+    env: process.env,
+    config,
+    base: { codex: [codexHome], claude: [path.join(home, ".claude")] },
+  });
+  const extraScanRoots = [];
+  for (const provider of ["codex", "claude"]) {
+    for (const entry of scanRoots[provider]) {
+      if (entry.origin === "native") continue;
+      extraScanRoots.push({
+        provider,
+        origin: describeScanRootOrigin(entry, provider),
+        path: entry.path,
+        exists: entry.exists,
+        error: entry.error || null,
+      });
+    }
+  }
+  const describeExtraScanRoot = (root) =>
+    `${root.provider} ${root.origin}: ${root.path}${describeScanRootState(root)}`;
+  const scanRootsLine = extraScanRoots.length > 0
+    ? `- Extra scan roots: ${extraScanRoots.map(describeExtraScanRoot).join(" | ")}`
+    : null;
   const { cursors } = await readCursorStateSummary({ trackerDir, cursorsPath });
   const codexRecordOnlyWarning = formatRecordOnlyWarning(countRecordOnlyFiles(cursors));
   const queueState = (await readJson(queueStatePath)) || { offset: 0 };
@@ -419,6 +455,10 @@ async function cmdStatus(argv = []) {
       ? wsl.discoverWslHome(".claude")
       : null;
     if (wslClaudeHomeStatus) claudeHomesStatus.push({ dir: wslClaudeHomeStatus, label: "WSL" });
+    for (const entry of scanRoots.claude) {
+      if (entry.origin === "native" || !entry.exists) continue;
+      claudeHomesStatus.push({ dir: entry.path, label: describeScanRootOrigin(entry, "claude") });
+    }
     for (const { dir, label } of claudeHomesStatus) {
       const projects = path.join(dir, "projects");
       try {
@@ -657,7 +697,7 @@ async function cmdStatus(argv = []) {
   // users are asked to paste when Codex usage looks wrong, so it must list
   // every root sync actually walks — and no empty shell sync would skip.
   const codexPaths = resolveInstallPaths({
-    nativeValue: process.env.CODEX_HOME || path.join(home, ".codex"),
+    nativeValue: codexHome,
     wslDir: ".codex",
     requireAnyChild: ["sessions", "archived_sessions"],
     union: true,
@@ -665,6 +705,11 @@ async function cmdStatus(argv = []) {
   // Both children, matching requireAnyChild above: an install holding only
   // archived_sessions/ is counted by sync and must not read as "not detected".
   const codexActive = formatResolvedPaths(codexPaths, ["sessions", "archived_sessions"]);
+  for (const entry of scanRoots.codex) {
+    if (entry.origin === "native" || !entry.exists) continue;
+    if (!hasAnyScanChild(entry.path, ["sessions", "archived_sessions"])) continue;
+    codexActive.push(`${describeScanRootOrigin(entry, "codex")}: ${entry.path}`);
+  }
   const codexInstalledStatus = codexActive.length > 0;
 
   const acodePaths = resolveInstallPaths({
@@ -983,6 +1028,10 @@ async function cmdStatus(argv = []) {
       last_upload_error: lastUploadError || null,
       last_sync_skipped: syncSkip?.at ? syncSkip : null,
       auto_retry: autoRetry || null,
+      // Extra scan roots (#657): CODEX_HOME / CLAUDE_CONFIG_DIR of this process
+      // plus config.scanRoots; `exists` false + `error` null means absent,
+      // `error` set means present but unreadable.
+      extra_scan_roots: extraScanRoots,
       hooks: {
         codex_notify: notifyConfigured,
         acode_notify: acodeConfigured,
@@ -1198,6 +1247,7 @@ async function cmdStatus(argv = []) {
       lastUploadError ? `- Last upload error: ${lastUploadError}` : null,
       syncSkipLine,
       autoRetryLine,
+      scanRootsLine,
       `- Codex notify: ${notifyConfigured ? JSON.stringify(codexNotify) : "unset"}`,
       `- AStudio notify: ${acodeConfigured ? JSON.stringify(acodeNotify) : "unset"}`,
       `- Every Code notify: ${everyCodeConfigured ? JSON.stringify(everyCodeNotify) : "unset"}`,
@@ -1525,6 +1575,11 @@ function renderLightTable(summary) {
     push(`Hook · ${name}`, state ? "set" : "unset");
   }
 
+  for (const root of summary.extra_scan_roots || []) {
+    const state = root.exists ? "" : (root.error ? ` (unreadable: ${root.error})` : " (missing)");
+    push(`Scan root · ${root.provider}`, `${root.origin}: ${root.path}${state}`);
+  }
+
   for (const [name, info] of Object.entries(summary.providers || {})) {
     const detail = [];
     if (typeof info.installed === "boolean") detail.push(info.installed ? "installed" : "not installed");

package/src/commands/sync.js

@@ -172,6 +172,14 @@ const {
   openCursorStore,
 } = require("../lib/cursor-store");
 const { resolveTrackerPaths } = require("../lib/tracker-paths");
+const {
+  appendUniqueDirs,
+  extraScanRootPaths,
+  hasAnyScanChild,
+  resolveEnvRoot,
+  resolveScanRoots,
+  scanRootDirState,
+} = require("../lib/scan-roots");
 const { resolveRuntimeConfig, isLegacyInsforgeBaseUrl } = require("../lib/runtime-config");
 const { extractTokenCount } = require("../lib/codex-rollout-parser");
 const {
@@ -601,7 +609,24 @@ async function cmdSync(argv, context = {}) {
         persistedAnonKey: config.anonKey,
       };
     }
-    const codexCursorRoots = [process.env.CODEX_HOME || path.join(home, ".codex")];
+    // Scan roots (#657). Every producer — hook-fired sync, native background
+    // refresh, CLI — must derive the SAME root list, and the cursor store's
+    // codexRoots must come from that list: a rollout under a root the store
+    // does not know is filed in core.json instead of its per-day shard, so two
+    // producers with different roots never see each other's cursor and re-parse
+    // the file from byte 0 on every alternation (#639). CODEX_HOME keeps its
+    // existing meaning (replaces ~/.codex for this process) but is normalized
+    // once by resolveEnvRoot — a relative value is anchored to home, not cwd —
+    // and that single value feeds discovery AND the cursor store below.
+    // config.scanRoots adds roots for every process.
+    const codexNativeValue = resolveEnvRoot("codex", { env: process.env, home }) || path.join(home, ".codex");
+    const scanRoots = resolveScanRoots({
+      home,
+      env: process.env,
+      config,
+      base: { codex: [codexNativeValue], claude: [path.join(home, ".claude")] },
+    });
+    const codexCursorRoots = scanRoots.codex.map((entry) => entry.path);
     const cursorStore = await openCursorStore({
       trackerDir,
       cursorsPath,
@@ -643,7 +668,16 @@ async function cmdSync(argv, context = {}) {
       claudeInstallHomes.push(claudeNativeHome);
     }
     if (wslClaudeHome) claudeInstallHomes.push(wslClaudeHome);
-    const claudeProjectsDirs = claudeInstallHomes.map((h) => path.join(h, "projects"));
+    // Extra Claude roots (#657): CLAUDE_CONFIG_DIR of the spawning process and
+    // config.scanRoots.claude, additive to the homes above so coverage does not
+    // depend on which process spawned this sync. Deduped by realpath at the
+    // projects/ level: two profiles may symlink one projects/ dir, and reading
+    // it under both spellings would double-parse every file, leaving
+    // correctness to the bounded claudeHashes layer.
+    const claudeProjectsDirs = appendUniqueDirs(
+      claudeInstallHomes.map((h) => path.join(h, "projects")),
+      extraScanRootPaths(scanRoots.claude).map((h) => path.join(h, "projects")),
+    );
     const xdgDataHome = process.env.XDG_DATA_HOME || path.join(home, ".local", "share");
     const kiloHome = process.env.KILO_HOME || path.join(xdgDataHome, "kilo");
 
@@ -700,7 +734,6 @@ async function cmdSync(argv, context = {}) {
 
     const sources = [];
     if (sourceAllowed("codex")) {
-      const codexNativeValue = process.env.CODEX_HOME || path.join(home, ".codex");
       // resolveInstallPaths stays the single authority for wsl-first /
       // native-first / wsl-only / native-only / both selection; requireAnyChild
       // makes it validate that a candidate actually holds sessions/ or
@@ -740,6 +773,17 @@ async function cmdSync(argv, context = {}) {
           sources.push({ source: "codex", sessionsDir: path.join(codexPaths.wsl, "archived_sessions"), deep: true });
         }
       }
+      // Extra Codex roots (#657) from config.scanRoots.codex. Same populated-
+      // root rule as requireAnyChild above so an empty shell dir is not walked;
+      // the day-inventory cache is keyed by day directory, so sharing it across
+      // roots is safe.
+      for (const extraRoot of extraScanRootPaths(scanRoots.codex)) {
+        if (!hasAnyScanChild(extraRoot, ["sessions", "archived_sessions"])) continue;
+        sources.push({ source: "codex", sessionsDir: path.join(extraRoot, "sessions"), inventoryCacheKey: "codexDayInventoryCache" });
+        if (!isBackgroundLightweightSync || backgroundCodexUsageRepair) {
+          sources.push({ source: "codex", sessionsDir: path.join(extraRoot, "archived_sessions"), deep: true });
+        }
+      }
     }
     if (sourceAllowed("acode")) {
       const acodeNativeValue =
@@ -1067,14 +1111,49 @@ async function cmdSync(argv, context = {}) {
     }
     if (isFullSourceScan) {
       await reincludeClaudeMemObserverFiles({ cursors, claudeFiles, queuePath, queueStatePath });
-      await repairClaudeQueueFromGroundTruth({
-        cursors,
-        queuePath,
-        queueStatePath,
-        projectQueuePath,
-        projectQueueStatePath,
-        rootDirs: claudeProjectsDirs,
-      });
+      // The ground-truth repair rebuilds every Claude queue row from the roots
+      // it is given. A configured root that is absent or unreadable right now
+      // (unmounted volume, permissions) may still hold history that an earlier
+      // scoped sync queued, so rebuilding without it would erase that history.
+      // The same applies one level down: listClaudeProjectFiles turns a read
+      // error on projects/ into an empty listing, so an unreadable projects/
+      // would let the repair run against nothing and mark itself complete. An
+      // ABSENT projects/ is fine for a NEW root (a profile with no sessions
+      // yet) but not for one the cursor store shows has supplied files before:
+      // then the directory vanished and rebuilding without it would erase its
+      // history. Defer in both cases: the migration key stays unset and the
+      // repair runs on a later full scan once the root is back. Ordinary
+      // scanning still proceeds.
+      const cursorFilePaths = Object.keys(cursors.files || {});
+      const rootPreviouslySuppliedFiles = (rootPath) => {
+        const prefix = path.join(rootPath, "projects") + path.sep;
+        return cursorFilePaths.some((filePath) => filePath.startsWith(prefix));
+      };
+      const unavailableClaudeRoots = scanRoots.claude
+        .filter((entry) => {
+          if (entry.origin === "native") return false;
+          if (!entry.exists) return true;
+          const projectsState = scanRootDirState(path.join(entry.path, "projects"));
+          if (projectsState.error !== null) return true;
+          return !projectsState.exists && rootPreviouslySuppliedFiles(entry.path);
+        })
+        .map((entry) => entry.path);
+      if (unavailableClaudeRoots.length > 0) {
+        if (!opts.auto) {
+          process.stderr.write(
+            `Claude ground-truth repair deferred: configured scan root(s) unavailable: ${unavailableClaudeRoots.join(", ")}\n`,
+          );
+        }
+      } else {
+        await repairClaudeQueueFromGroundTruth({
+          cursors,
+          queuePath,
+          queueStatePath,
+          projectQueuePath,
+          projectQueueStatePath,
+          rootDirs: claudeProjectsDirs,
+        });
+      }
     }
     let claudeResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
     if (claudeFiles.length > 0) {

package/src/lib/codex-context-breakdown.js

@@ -15,6 +15,8 @@ const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
 
+const { resolveEnvRoot } = require("./scan-roots");
+
 const {
   emptyTotals,
   addInto,
@@ -396,7 +398,7 @@ async function computeCodexContextBreakdown({
     toKey = range?.to || null;
   }
 
-  const codexHome = process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+  const codexHome = resolveEnvRoot("codex", { env: process.env, home: os.homedir() }) || path.join(os.homedir(), ".codex");
   const roots = codexDir
     ? [codexDir]
     : [path.join(codexHome, "sessions"), path.join(codexHome, "archived_sessions")];

package/src/lib/diagnostics.js

@@ -3,6 +3,7 @@ const path = require("node:path");
 const fs = require("node:fs/promises");
 
 const { readJson } = require("./fs");
+const { resolveEnvRoot, resolveScanRoots } = require("./scan-roots");
 const { readCursorStateSummary } = require("./cursor-store");
 const { readCodexNotify, readEveryCodeNotify } = require("./codex-config");
 const { areClaudeUsageHooksConfigured, buildClaudeHookCommand } = require("./claude-config");
@@ -66,7 +67,7 @@ function resolveKiroCliDbPathInline(env, home) {
 
 async function collectTrackerDiagnostics({
   home = os.homedir(),
-  codexHome = process.env.CODEX_HOME || path.join(home, ".codex"),
+  codexHome = resolveEnvRoot("codex", { env: process.env, home }) || path.join(home, ".codex"),
   codeHome = process.env.CODE_HOME || path.join(home, ".code"),
 } = {}) {
   const { trackerDir, binDir } = await resolveTrackerPaths({ home });
@@ -92,6 +93,20 @@ async function collectTrackerDiagnostics({
     path.join(home, ".grok");
 
   const config = await readJson(configPath);
+  // Extra scan roots (#657), resolved as sync does. Paths are home-redacted
+  // like every other entry in `paths`.
+  const scanRoots = resolveScanRoots({
+    home,
+    env: process.env,
+    config,
+    base: { codex: [codexHome], claude: [path.join(home, ".claude")] },
+  });
+  const describeScanRoots = (entries) => entries.map((entry) => ({
+    path: redactValue(entry.path, home),
+    origin: entry.origin,
+    exists: entry.exists,
+    error: entry.error || null,
+  }));
   const cursorSummary = await readCursorStateSummary({ trackerDir, cursorsPath });
   const cursors = cursorSummary.cursors;
   const queueState = (await readJson(queueStatePath)) || { offset: 0 };
@@ -217,6 +232,10 @@ async function collectTrackerDiagnostics({
       merge_policy:
         "Kiro IDE and Kiro CLI both emit source='kiro' in queue.jsonl so token, cost, heatmap, and leaderboard aggregations merge transparently. Use this block to distinguish sub-path contributions.",
     },
+    scan_roots: {
+      codex: describeScanRoots(scanRoots.codex),
+      claude: describeScanRoots(scanRoots.claude),
+    },
     config: {
       base_url: typeof config?.baseUrl === "string" ? config.baseUrl : null,
       device_token: config?.deviceToken ? "set" : "unset",

package/src/lib/doctor.js

@@ -337,6 +337,36 @@ function buildDiagnosticsChecks(diagnostics) {
     });
   }
 
+  // Extra scan roots (#657): surface CODEX_HOME / CLAUDE_CONFIG_DIR / config
+  // roots in the human-readable report and warn when a configured root is not
+  // on disk — a silently missing root is the difference between "no usage"
+  // and "not scanned". Installs without extras get no additional line.
+  const scanRoots = diagnostics?.scan_roots;
+  if (scanRoots && typeof scanRoots === "object") {
+    const extras = [];
+    for (const provider of ["codex", "claude"]) {
+      for (const entry of Array.isArray(scanRoots[provider]) ? scanRoots[provider] : []) {
+        if (!entry || entry.origin === "native") continue;
+        extras.push({ provider, ...entry });
+      }
+    }
+    if (extras.length > 0) {
+      const missing = extras.filter((entry) => !entry.exists);
+      const describe = (list) => list
+        .map((entry) => `${entry.provider} ${entry.path}${entry.error ? ` (unreadable: ${entry.error})` : ""}`)
+        .join(", ");
+      checks.push({
+        id: "scan_roots.extra",
+        status: missing.length > 0 ? "warn" : "ok",
+        detail: missing.length > 0
+          ? `${missing.length} of ${extras.length} extra scan root(s) unavailable: ${describe(missing)}`
+          : `${extras.length} extra scan root(s) present: ${describe(extras)}`,
+        critical: false,
+        meta: { roots: extras },
+      });
+    }
+  }
+
   return checks;
 }
 

package/src/lib/local-api.js

@@ -1131,8 +1131,9 @@ function buildProxyHeaders(headers) {
 // Main handler factory
 // ---------------------------------------------------------------------------
 
-function createLocalApiHandler({ queuePath }) {
+function createLocalApiHandler({ queuePath, serverVersion = null }) {
   const qp = queuePath || resolveQueuePath();
+  const normalizedServerVersion = typeof serverVersion === "string" ? serverVersion.trim() : "";
 
   // Server-side cookie relay: captures auth cookies from InsForge cloud responses
   // so that both browser and WKWebView share the same login session via the proxy.
@@ -1581,7 +1582,10 @@ function createLocalApiHandler({ queuePath }) {
         "Content-Type": "application/json",
         "Cache-Control": "no-store",
       });
-      res.end(JSON.stringify({ token: localAuthToken }));
+      res.end(JSON.stringify({
+        token: localAuthToken,
+        ...(normalizedServerVersion ? { serverVersion: normalizedServerVersion } : {}),
+      }));
       return true;
     }