tokentracker-cli 1.1.3 → 1.1.5

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({
@@ -755,9 +800,10 @@ async function cmdStatus(argv = []) {
   const devinDbPath = resolveDevinDbPath(process.env);
   const devinInstalled = Boolean(devinDbPath && fssync.existsSync(devinDbPath));
 
-  // Trae SOLO (ByteDance AI IDE) — passive entitlement snapshot reader.
+  const { resolveTraeDbPaths } = require("../lib/trae-db");
+  const traeDbPaths = resolveTraeDbPaths(process.env);
   const traeStoragePath = resolveTraeStoragePath(process.env);
-  const traeInstalled = Boolean(traeStoragePath);
+  const traeInstalled = Boolean(traeStoragePath || traeDbPaths.length);
   // Render path for the entitlement snapshot: read it straight from the
   // Trae Local State storage.json via the shared parser. The queue stays
   // token-count-only, so the status read path never depends on queue rows
@@ -982,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,
@@ -1124,7 +1174,9 @@ async function cmdStatus(argv = []) {
         trae: traeInstalled
           ? {
               installed: true,
-              detail: traeStoragePath,
+              detail: traeDbPaths[0] || traeStoragePath,
+              usage_databases: traeDbPaths.length,
+              usage_key_source: process.env.TOKENTRACKER_TRAE_SQLCIPHER_KEY?.trim() ? "environment" : "application",
               ...(traeEntitlement ? { entitlement: traeEntitlement } : {}),
             }
           : { installed: false },
@@ -1195,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"}`,
@@ -1328,12 +1381,9 @@ async function cmdStatus(argv = []) {
         ? `- Devin CLI: passive reader (${devinDbPath})`
         : null,
       traeInstalled
-        // Deliberately NOT "passive reader": every other line with that wording
-        // means tokens are being counted. Trae encrypts its session transcripts
-        // (SQLCipher) and its plaintext summaries carry no token counts, so this
-        // provider contributes plan info and nothing else — say so, or users go
-        // looking for Trae usage in the dashboard that will never appear.
-        ? `- Trae SOLO: plan info only, no token usage (${traeStoragePath})`
+        ? traeDbPaths.length
+          ? `- TRAE: local usage reader, ${traeDbPaths.length} database(s) (shared application key; optional key override)`
+          : `- TRAE: plan info only, no local usage database found (${traeStoragePath})`
         : null,
       traeEntitlement
         ? `- Trae SOLO plan: ${formatTraeEntitlementLine(traeEntitlement)}`
@@ -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

@@ -138,6 +138,7 @@ const {
   resolveCommandCodeSessionFiles,
   parseCommandCodeIncremental,
   parseTraeCnApiIncremental,
+  parseTraeIncremental,
   bucketKey,
   toUtcHalfHourStart,
   totalsKey,
@@ -171,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 {
@@ -333,6 +342,7 @@ const AUTO_SYNC_SOURCES = new Set([
   "reasonix",
   "roocode",
   "trae-cn",
+  "trae",
   "unsloth",
   "workbuddy",
   "zcode",
@@ -599,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,
@@ -641,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");
 
@@ -698,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
@@ -738,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 =
@@ -1065,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) {
@@ -2011,6 +2092,27 @@ async function cmdSync(argv, context = {}) {
       }
     }
 
+    let traeResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+    if (sourceAllowed("trae")) {
+      try {
+        traeResult = await parseTraeIncremental({
+          cursors, queuePath, onProgress: makeProviderProgress("TRAE"),
+        });
+        for (const { database, message } of traeResult.errors) {
+          process.stderr.write(`TRAE sync: could not read ${database}: ${message}. Will retry on the next sync.\n`);
+        }
+        if (traeResult.recordsSkipped > 0 && !opts.auto) {
+          process.stderr.write(`TRAE sync: skipped ${traeResult.recordsSkipped} records with unsupported usage metadata.\n`);
+        }
+        if (traeResult.estimatedRecords > 0 && !opts.auto) {
+          process.stderr.write(`TRAE sync: ${traeResult.estimatedRecords} Gemini records have repaired thought or cache counters, marked as estimated.\n`);
+        }
+        if (traeResult.unpricedRecords > 0 && !opts.auto) {
+          process.stderr.write(`TRAE sync: ${traeResult.unpricedRecords} multi-request turns include earlier input without a cache split; it is counted in token totals but left out of cost.\n`);
+        }
+      } catch (err) { warnProviderParseFailure("TRAE", err); }
+    }
+
     // ── Trae Work CN (国内版) — account-level usage API ──
     // A simple explicit rolling 30-day window captured once per sync (no
     // cursor checkpoints / full-history import / page retries / background
@@ -3101,6 +3203,7 @@ async function cmdSync(argv, context = {}) {
       claudeScienceResult.recordsProcessed +
       cursorResult.recordsProcessed +
       traeCnResult.recordsProcessed +
+      traeResult.recordsProcessed +
       kiroResult.recordsProcessed +
       kiroCliResult.recordsProcessed +
       hermesResult.recordsProcessed +
@@ -3144,6 +3247,7 @@ async function cmdSync(argv, context = {}) {
       claudeScienceResult.bucketsQueued +
       cursorResult.bucketsQueued +
       traeCnResult.bucketsQueued +
+      traeResult.bucketsQueued +
       kiroResult.bucketsQueued +
       kiroCliResult.bucketsQueued +
       hermesResult.bucketsQueued +

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/pricing/curated-overrides.json

@@ -118,6 +118,13 @@
       "cache_write": 0.167,
       "note": "See hy3-preview-agent."
     },
+    "qwen3.8-flash": {
+      "input": 0.15,
+      "output": 0.47,
+      "cache_read": 0.016,
+      "cache_write": 0.2,
+      "note": "Alibaba Model Studio Singapore (International), USD per MTok, verified 2026-09-29: https://www.alibabacloud.com/help/en/model-studio/qwen3-8-flash . Reference API estimate; other regions/providers can have different rates. Issue #715."
+    },
     "hy4-preview": {
       "input": 0.833,
       "output": 2.5,

package/src/lib/pricing/matcher.js

@@ -277,6 +277,11 @@ function lookupPricing(model, { curated, litellm, source } = {}) {
   }
 
   // 1. CURATED exact
+  // Qwen Flash's provider-qualified and dated IDs share the reference SKU.
+  // Keep the boundary strict: Flash-Next and Max have independent prices.
+  if (/(?:^|\/)qwen3[.-]8-flash(?:-\d{4}-\d{2}-\d{2})?$/.test(lower.trim()) && curated.exact?.["qwen3.8-flash"]) {
+    return { hit: true, source: "curated:exact", value: curated.exact["qwen3.8-flash"] };
+  }
   if (curated.exact && curated.exact[lookupModel]) {
     return { hit: true, source: "curated:exact", value: curated.exact[lookupModel] };
   }