tokentracker-cli 0.95.2 → 0.96.1

package/src/lib/ark-coding-plan-limits.js

@@ -2,13 +2,17 @@
 
 // Ark Coding Plan (火山方舟 Coding Plan) quota monitoring.
 //
-// Coding Plan is a subscription-style quota product (Lite/Pro) that refreshes
-// on three windows — 5-hour (session), weekly and monthly — and is shared by
-// every compatible coding tool (Claude Code, Codex CLI, OpenCode, TRAE, ...).
-// TokenTracker already counts those tools' token consumption from their local
-// files, so this module deliberately adds NO consumption source. It only
-// surfaces the subscription quota percentage, which is otherwise only visible
-// in the Volcano console web page.
+// Coding Plan (Lite/Pro) and Agent Plan (Small/Medium/Large/Max) are
+// two parallel subscription products that each refresh on three windows —
+// 5-hour (session for Coding Plan, 5h for Agent Plan), weekly and monthly —
+// and are shared by compatible coding tools (Claude Code, Codex CLI,
+// OpenCode, TRAE, ...). Official docs present them as parallel, not
+// successor/replacement. TokenTracker already counts those tools' token
+// consumption from their local files, so this module deliberately adds
+// NO consumption source. It only surfaces the subscription quota
+// percentage, which is otherwise only visible in the Volcano console web
+// page. Agent Plan is handled by a separate provider module
+// `ark-agent-plan-limits.js` (dual Provider, issue #555).
 //
 // The quota is read through the user's own `arkcli` binary
 // (`arkcli usage plan --format json`), which is already installed and logged
@@ -21,7 +25,7 @@ const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
 
-const { runCommand, resolveBinaryPath, statBinaryInDirs, commonGlobalBinDirectories } = require("./command-runner");
+const { runCommand, resolveBinaryPath, statBinaryInDirs, commonGlobalBinDirectories, resolvedCliEnvironment } = require("./command-runner");
 
 const ARK_LIMITS_CACHE_FILE = "ark-coding-plan-limits-cache.json";
 const ARK_LIMITS_CACHE_UNKNOWN_RESET_TTL_MS = 12 * 60 * 60 * 1000;
@@ -43,14 +47,23 @@ const ARK_PROVIDER_TIMEOUT_MS = 15_000;
 // Same shape as codexResetCreditListTimeoutMs's guard in usage-limits.js.
 const ARK_PROVIDER_BUDGET_GUARD_MS = 1_500;
 
-// arkcli period label -> canonical window slot. `session` is the 5-hour
-// rolling window; `weekly` and `monthly` refresh on calendar boundaries.
+// arkcli period label -> canonical window slot.
+// Coding Plan uses `session` for the 5-hour rolling window; Agent Plan
+// uses `5h`. `weekly` and `monthly` are shared. `daily` (Agent Plan
+// visual quota) is intentionally not surfaced — it is a separate
+// per-day visual bucket that does not fit the three-window panel.
 const ARK_PERIOD_WINDOW = {
   session: "primary_window",
+  "5h": "primary_window",
   weekly: "secondary_window",
   monthly: "tertiary_window",
 };
 
+// Coding Plan personal product. Team products (coding-plan-team) are
+// seat-scoped and not surfaced in this personal-quota panel.
+const ARK_PERSONAL_PRODUCTS = ["coding-plan"];
+const ARK_PRODUCT_PRIORITY = ["coding-plan"];
+
 function clampPercent(value) {
   return Math.max(0, Math.min(100, value));
 }
@@ -73,22 +86,33 @@ function normalizeResetAt(value) {
 // "Ark Coding Plan Coding Plan Lite".
 function planLabelForTier(tier) {
   const normalized = String(tier || "").trim().toLowerCase();
-  if (normalized === "pro") return "Pro";
-  if (normalized === "lite") return "Lite";
+  const mapping = {
+    pro: "Pro",
+    lite: "Lite",
+    small: "Small",
+    medium: "Medium",
+    large: "Large",
+    max: "Max",
+  };
+  if (mapping[normalized]) return mapping[normalized];
   return tier && String(tier).trim() ? String(tier).trim() : null;
 }
 
 /**
  * Normalize the JSON payload returned by `arkcli plans get --format json`.
- * The tier ("lite" / "pro") lives on the plans payload, not on the usage
- * payload, so it is resolved here and merged into the plan label.
+ * The tier ("lite" / "pro" for Coding Plan) lives on the plans payload,
+ * not on the usage payload, so it is resolved here and merged into the
+ * plan label.
  * Returns null when there is no Coding Plan entry.
  */
 function normalizeArkPlansResponse(body) {
   if (!body || typeof body !== "object") return null;
   const plans = Array.isArray(body.plans) ? body.plans : [];
-  const plan = plans.find((entry) => entry?.key === "coding-plan");
-  return plan?.tier ? String(plan.tier) : null;
+  for (const key of ARK_PRODUCT_PRIORITY) {
+    const plan = plans.find((entry) => entry?.key === key);
+    if (plan?.tier) return String(plan.tier);
+  }
+  return null;
 }
 
 function arkProfileIdentity(body) {
@@ -114,26 +138,56 @@ function arkProfileIdentity(body) {
   return identity || null;
 }
 
+function resolveArkProductItem(items) {
+  for (const product of ARK_PRODUCT_PRIORITY) {
+    const item = items.find((entry) => entry?.product === product && entry?.subscribed === true);
+    if (item) return item;
+  }
+  return null;
+}
+
+function percentFromPeriod(period) {
+  // null / undefined / blank percent must fall through to the used/total
+  // fallback: Number(null) and Number("") both coerce to 0, which would
+  // otherwise report a fake fresh 0% window instead of deriving real usage
+  // (Agent Plan's 5h period can omit percent entirely, #555).
+  const rawPercent = period?.percent;
+  if (rawPercent !== null && rawPercent !== undefined && String(rawPercent).trim() !== "") {
+    const direct = Number(rawPercent);
+    if (Number.isFinite(direct)) return direct;
+  }
+  const used = Number(period?.used);
+  const total = Number(period?.total);
+  if (Number.isFinite(used) && Number.isFinite(total) && total > 0) {
+    return (used / total) * 100;
+  }
+  return NaN;
+}
+
 /**
  * Normalize the JSON payload returned by `arkcli usage plan --format json`.
  * Returns `null` when the account has no active Coding Plan subscription
  * (caller reports `configured: false`). Throws when the payload shape is
  * unusable so the caller can fall back to the disk cache.
+ * Only `coding-plan` (Lite/Pro, session label) is handled here;
+ * Agent Plan is handled by `ark-agent-plan-limits.js`.
  */
 function normalizeArkCodingPlanResponse(body) {
   if (!body || typeof body !== "object") {
     throw new Error("Ark Coding Plan response is not an object.");
   }
   const items = Array.isArray(body.items) ? body.items : [];
-  const item = items.find((entry) => entry?.product === "coding-plan");
-  if (!item || item.subscribed !== true) return null;
+  const item = resolveArkProductItem(items);
+  if (!item) return null;
 
   const windows = {};
   const periods = Array.isArray(item.periods) ? item.periods : [];
   for (const period of periods) {
+    // Agent Plan `daily` is a visual-only quota not shown in the 3-window panel.
+    if (period?.label === "daily") continue;
     const slot = ARK_PERIOD_WINDOW[period?.label];
     if (!slot) continue;
-    const percent = Number(period.percent);
+    const percent = percentFromPeriod(period);
     if (!Number.isFinite(percent)) continue;
     windows[slot] = {
       used_percent: clampPercent(percent),
@@ -149,6 +203,7 @@ function normalizeArkCodingPlanResponse(body) {
     configured: true,
     error: null,
     plan_label: planLabelForTier(item.tier),
+    product: item.product || null,
     primary_window: windows.primary_window || null,
     secondary_window: windows.secondary_window || null,
     tertiary_window: windows.tertiary_window || null,
@@ -194,6 +249,7 @@ function readArkCodingPlanLimitsCache({ home = os.homedir(), nowMs = Date.now(),
       configured: true,
       error: null,
       plan_label: typeof parsed?.plan_label === "string" ? parsed.plan_label : null,
+      product: typeof parsed?.product === "string" ? parsed.product : null,
       primary_window: bounded[0],
       secondary_window: bounded[1],
       tertiary_window: bounded[2],
@@ -212,6 +268,7 @@ function writeArkCodingPlanLimitsCache(limits, { home = os.homedir(), nowMs = Da
   const cachePath = arkCodingPlanCachePath({ home });
   const payload = {
     plan_label: limits.plan_label || null,
+    product: limits.product || null,
     profile_identity: limits.profile_identity || null,
     primary_window: limits.primary_window || null,
     secondary_window: limits.secondary_window || null,
@@ -325,6 +382,7 @@ async function fetchArkCodingPlanLimits({
   if (!arkcliPath) return { configured: false };
 
   const commandOptions = {
+    env: resolvedCliEnvironment(arkcliPath, { platform }),
     signal,
     killProcessGroup: true,
     platform,
@@ -384,12 +442,19 @@ async function fetchArkCodingPlanLimits({
   };
 
   if (result?.error || result?.status !== 0) {
-    const detail = result?.error?.message
+    const isExit127 = result?.status === 127;
+    const baseDetail = result?.error?.message
       || (result?.status !== 0 && result?.status !== null
         ? `arkcli exited with code ${result.status}`
         : "arkcli usage plan failed");
+    // Exit 127 can mean a missing interpreter as well as an outdated CLI.
+    // Preserve stderr so users can distinguish runtime and command failures.
+    const detail = isExit127
+      ? "arkcli exited with code 127 — check its runtime/PATH or update arkcli: npm i -g @volcengine/ark-cli"
+      : baseDetail;
     const stderr = trimStderr(result?.stderr);
-    return failWithCache(stderr ? `${detail}: ${stderr}` : detail);
+    const message = stderr ? `${detail}: ${stderr}` : detail;
+    return failWithCache(message);
   }
 
   let body;
@@ -406,17 +471,22 @@ async function fetchArkCodingPlanLimits({
     return failWithCache(error?.message || "Ark Coding Plan response could not be parsed.");
   }
   if (!limits) {
-    // Only a response that explicitly carries the coding-plan entry with
+    // Only a response that explicitly carries an Ark product entry with
     // `subscribed: false` confirms the plan was retired — drop the cache
     // then, or a later transient CLI failure would resurrect the retired
-    // plan's numbers through failWithCache. A payload with *no*
-    // coding-plan entry at all (`{}`, `{"items":[]}` — not logged in,
-    // backend degraded, product key renamed) is ambiguous and must NOT
-    // destroy the cache: transient signals never drive persistent state.
+    // plan's numbers through failWithCache. A payload with *no* Ark entry
+    // at all (`{}`, `{"items":[]}` — not logged in, backend degraded,
+    // product key renamed) is ambiguous and must NOT destroy the cache:
+    // transient signals never drive persistent state.
+    // Only coding-plan is considered here; agent-plan is handled by the
+    // parallel provider `ark-agent-plan-limits.js`.
     const entry = Array.isArray(body?.items)
-      ? body.items.find((candidate) => candidate?.product === "coding-plan")
+      ? body.items.find(
+        (candidate) =>
+          ARK_PERSONAL_PRODUCTS.includes(candidate?.product) && candidate?.subscribed === false,
+      )
       : null;
-    if (entry && entry.subscribed === false) {
+    if (entry) {
       try {
         fs.unlinkSync(arkCodingPlanCachePath({ home }));
       } catch (_error) {}
@@ -452,6 +522,8 @@ async function fetchArkCodingPlanLimits({
 
 module.exports = {
   ARK_PERIOD_WINDOW,
+  ARK_PERSONAL_PRODUCTS,
+  ARK_PRODUCT_PRIORITY,
   normalizeArkPlansResponse,
   arkProfileIdentity,
   normalizeArkCodingPlanResponse,
@@ -459,4 +531,7 @@ module.exports = {
   writeArkCodingPlanLimitsCache,
   hasArkCliInstallEvidence,
   fetchArkCodingPlanLimits,
+  // exposed for testing
+  resolveArkProductItem,
+  percentFromPeriod,
 };

package/src/lib/codex-model-attribution.js

@@ -0,0 +1,128 @@
+"use strict";
+
+// Codex token_count events do not carry a model id. Every usage event is
+// therefore attributed to the model named by the most recent turn_context,
+// which Codex emits at the start of each turn and which tracks mid-session
+// model switches exactly. That per-turn path is what actually runs today.
+//
+// The model/rerouted upgrade below is forward-looking: it promotes usage to
+// the effective model when the app server reports a server-side reroute.
+//
+// Deliberately NOT used for attribution: event_msg/thread_settings_applied.
+// It carries thread_settings.model, but it fires when the user picks a model
+// in the UI - seconds to minutes before the switch takes effect - so usage
+// still streaming from the in-flight turn belongs to the previous model.
+// turn_context is the only signal that marks where a turn actually begins.
+//
+// session_meta is a defensive fallback, not an observed source. Codex has
+// never written a model into it - 0 of 10310 session_meta rows across 5849
+// local rollouts carry the field (codex-cli 0.151.0); the payload records
+// model_provider ("openai"), which is provenance rather than a model. The
+// fallback only fills selectedModel when nothing else has, so a future format
+// that does carry one attributes instead of falling through to "unknown". It
+// never overrides a turn_context model.
+
+function cleanString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+function normalizeEventName(value) {
+  return cleanString(value)?.toLowerCase().replaceAll("_", "/") || "";
+}
+
+function eventEnvelope(obj) {
+  const candidates = [
+    { name: obj?.method, data: obj?.params },
+    { name: obj?.type, data: obj?.payload },
+    { name: obj?.payload?.method, data: obj?.payload?.params },
+    { name: obj?.payload?.type, data: obj?.payload },
+    { name: obj?.payload?.msg?.method, data: obj?.payload?.msg?.params },
+    { name: obj?.payload?.msg?.type, data: obj?.payload?.msg },
+    { name: obj?.msg?.method, data: obj?.msg?.params },
+    { name: obj?.msg?.type, data: obj?.msg },
+  ];
+  return candidates.find(({ name }) => normalizeEventName(name) === "model/rerouted") || null;
+}
+
+// Forward-looking: no model/rerouted event has been observed in any real
+// rollout (verified against 5832 local files, codex-cli 0.151.0), so the
+// envelope shapes and the fromModel/toModel field names below are inferred
+// from the app-server protocol rather than confirmed against logged data.
+// Re-verify against a real sample before relying on rerouted attribution.
+function extractModelReroute(obj) {
+  const envelope = eventEnvelope(obj);
+  if (!envelope) return null;
+  const data = envelope.data && typeof envelope.data === "object" ? envelope.data : {};
+  const fromModel = cleanString(data.fromModel ?? data.from_model);
+  const toModel = cleanString(data.toModel ?? data.to_model);
+  if (!toModel) return null;
+  return {
+    fromModel,
+    toModel,
+    reason: cleanString(data.reason),
+    threadId: cleanString(data.threadId ?? data.thread_id),
+    turnId: cleanString(data.turnId ?? data.turn_id),
+  };
+}
+
+function createCodexModelAttributionState(value = {}) {
+  const selectedModel = cleanString(value.selectedModel ?? value.selected_model ?? value.model);
+  const effectiveModel = cleanString(value.effectiveModel ?? value.effective_model) || selectedModel;
+  return {
+    selectedModel,
+    effectiveModel,
+    turnId: cleanString(value.turnId ?? value.turn_id),
+    rerouted: Boolean(value.rerouted),
+    rerouteReason: cleanString(value.rerouteReason ?? value.reroute_reason),
+  };
+}
+
+function applyCodexModelEvent(state, obj) {
+  if (!state || typeof state !== "object") return null;
+  if (obj?.type === "turn_context" && obj.payload && typeof obj.payload === "object") {
+    const selectedModel = cleanString(obj.payload.model);
+    if (selectedModel) {
+      state.selectedModel = selectedModel;
+    }
+    state.effectiveModel = state.selectedModel || state.effectiveModel;
+    state.turnId = cleanString(obj.payload.turn_id ?? obj.payload.turnId) || state.turnId;
+    state.rerouted = false;
+    state.rerouteReason = null;
+    return { type: "turn_context", selectedModel };
+  }
+
+  // Strictly weaker than turn_context, and never allowed to overwrite it: a
+  // forked rollout replays the parent's session_meta rows after its own.
+  if (obj?.type === "session_meta" && obj.payload && typeof obj.payload === "object") {
+    const metaModel = cleanString(obj.payload.model);
+    if (!metaModel || state.selectedModel) return null;
+    state.selectedModel = metaModel;
+    state.effectiveModel = state.effectiveModel || metaModel;
+    return { type: "session_meta", selectedModel: metaModel };
+  }
+
+  const reroute = extractModelReroute(obj);
+  if (!reroute) return null;
+  state.selectedModel = reroute.fromModel || state.selectedModel || state.effectiveModel;
+  state.effectiveModel = reroute.toModel;
+  state.turnId = reroute.turnId || state.turnId;
+  state.rerouted = true;
+  state.rerouteReason = reroute.reason;
+  return { type: "model_rerouted", ...reroute };
+}
+
+function currentCodexModel(state) {
+  return cleanString(state?.effectiveModel) || cleanString(state?.selectedModel);
+}
+
+function snapshotCodexModelAttributionState(state) {
+  return createCodexModelAttributionState(state);
+}
+
+module.exports = {
+  applyCodexModelEvent,
+  createCodexModelAttributionState,
+  currentCodexModel,
+  extractModelReroute,
+  snapshotCodexModelAttributionState,
+};

package/src/lib/codex-rollout-parser.js

@@ -24,12 +24,21 @@ const {
   getExecutableName,
   buildExecStatsEntry,
 } = require("./categorizer-utils");
+const {
+  applyCodexModelEvent,
+  createCodexModelAttributionState,
+  currentCodexModel,
+  snapshotCodexModelAttributionState,
+} = require("./codex-model-attribution");
 
 const DISCOVERY_FULL_AUDIT_INTERVAL_MS = 60 * 1000;
 const MAX_DISCOVERY_INVENTORIES = 32;
 const DISCOVERY_INVENTORIES = new Map();
 const ZONED_DAY_FORMATTERS = new Map();
 const CODEX_RESUME_INVALIDATED = "TOKENTRACKER_CODEX_RESUME_INVALIDATED";
+// See src/lib/pricing/index.js: no observed Codex request reaches this
+// threshold yet (context window 258400), so long_context_* stays at zero.
+const OPENAI_LONG_CONTEXT_INPUT_THRESHOLD = 272_000;
 
 // ---------------------------------------------------------------------------
 // Timezone helpers
@@ -520,6 +529,17 @@ function finalizeExecRows(map) {
     .sort((a, b) => (b.totals?.total_tokens || 0) - (a.totals?.total_tokens || 0));
 }
 
+function finalizeModelUsageRows(map) {
+  return Array.from(map.values())
+    .map((row) => ({
+      ...row,
+      selected_models: Array.from(row.selected_models).sort(),
+      reroute_reasons: Array.from(row.reroute_reasons).sort(),
+      model_attribution: row.rerouted_usage_events > 0 ? "effective" : "selected",
+    }))
+    .sort((a, b) => b.total_tokens - a.total_tokens || a.model.localeCompare(b.model));
+}
+
 // ---------------------------------------------------------------------------
 // Main parser
 // ---------------------------------------------------------------------------
@@ -537,6 +557,9 @@ async function parseCodexRolloutFile(filePath, {
   captureContentHash = false,
   contentHashState = null,
   sourceHandle = null,
+  collectBreakdowns = true,
+  collectModelUsage = false,
+  onObject = null,
 } = {}) {
   const filePaths = (Array.isArray(filePath) ? filePath : [filePath]).filter(Boolean);
   const primaryFilePath = filePaths[0] || String(filePath || "");
@@ -566,6 +589,9 @@ async function parseCodexRolloutFile(filePath, {
   let sessionId = isResuming ? resumeState.sessionId || null : null;
   let cwd = isResuming ? resumeState.cwd || null : null;
   let model = isResuming ? resumeState.model || null : null;
+  const modelAttributionState = createCodexModelAttributionState(
+    isResuming ? resumeState.modelAttributionState || { model } : {},
+  );
   let provider = isResuming ? resumeState.provider || null : null;
   let cliVersion = isResuming ? resumeState.cliVersion || null : null;
   let forkedFromId = isResuming ? resumeState.forkedFromId || null : null;
@@ -607,9 +633,55 @@ async function parseCodexRolloutFile(filePath, {
   const byExecCommand = new Map(); // sanitized executable + subcommand -> stats
   const byExecDuration = new Map(); // duration bucket -> stats
   const byExecOutput = new Map(); // output size bucket -> stats
+  const byModel = new Map(); // effective model -> observed token usage
 
   let turnCount = 0;
 
+  function recordModelUsage(delta, rawRequestUsage) {
+    if (!collectModelUsage || !delta || delta.total_tokens <= 0) return;
+    const effectiveModel = currentCodexModel(modelAttributionState) || "unknown";
+    let row = byModel.get(effectiveModel);
+    if (!row) {
+      row = {
+        model: effectiveModel,
+        ...emptyTotals(),
+        long_context_input_tokens: 0,
+        long_context_cached_input_tokens: 0,
+        long_context_cache_creation_input_tokens: 0,
+        long_context_output_tokens: 0,
+        long_context_reasoning_output_tokens: 0,
+        usage_events: 0,
+        rerouted_usage_events: 0,
+        long_context_usage_events: 0,
+        selected_models: new Set(),
+        reroute_reasons: new Set(),
+      };
+      byModel.set(effectiveModel, row);
+    }
+    addInto(row, delta);
+    row.usage_events += 1;
+    if (modelAttributionState.selectedModel) {
+      row.selected_models.add(modelAttributionState.selectedModel);
+    }
+    if (modelAttributionState.rerouted) {
+      row.rerouted_usage_events += 1;
+      if (modelAttributionState.rerouteReason) {
+        row.reroute_reasons.add(modelAttributionState.rerouteReason);
+      }
+    }
+    // OpenAI applies the long-context tier to the whole request when its raw
+    // (cache-inclusive) input exceeds 272K tokens. Preserve the exact subset
+    // so pricing can be recomputed later without rescanning private logs.
+    if (Number(rawRequestUsage?.input_tokens || 0) > OPENAI_LONG_CONTEXT_INPUT_THRESHOLD) {
+      row.long_context_usage_events += 1;
+      row.long_context_input_tokens += delta.input_tokens;
+      row.long_context_cached_input_tokens += delta.cached_input_tokens;
+      row.long_context_cache_creation_input_tokens += delta.cache_creation_input_tokens;
+      row.long_context_output_tokens += delta.output_tokens;
+      row.long_context_reasoning_output_tokens += delta.reasoning_output_tokens;
+    }
+  }
+
   function ensureTool(name) {
     if (!byTool.has(name)) {
       byTool.set(name, { name, ...buildToolStatsEntry() });
@@ -686,6 +758,14 @@ async function parseCodexRolloutFile(filePath, {
     }
     turnCount += 1;
 
+    if (!collectBreakdowns) {
+      addInto(totals, delta);
+      pendingToolNames = [];
+      pendingSkills = [];
+      pendingExecDetails = [];
+      return;
+    }
+
     const unique = [...new Set(pendingToolNames.filter(Boolean))];
     const tools = unique.length > 0 ? unique : ["text_response"];
     const share = 1 / tools.length;
@@ -822,6 +902,16 @@ async function parseCodexRolloutFile(filePath, {
     contentHasher,
     sourceHandle,
   })) {
+    const modelEvent = applyCodexModelEvent(modelAttributionState, obj);
+    const attributedModel = currentCodexModel(modelAttributionState);
+    model = attributedModel || model;
+    // onObject runs AFTER the attribution state machine, and is handed the
+    // model it just decided. A consumer sharing this pass (the delivery-signal
+    // collector, which attributes edit turns) therefore sees exactly the model
+    // recordModelUsage() bills the turn's tokens to. Letting it re-read
+    // turn_context.payload.model itself would make codex-model-attribution.js
+    // one of two authorities on the same question.
+    if (typeof onObject === "function") onObject(obj, attributedModel);
     const ts = typeof obj?.timestamp === "string" ? obj.timestamp : null;
     if (!ts) continue;
     const inRequestedRange = isTimestampInRequestedDayRange(ts, { from, to, timeZoneContext });
@@ -849,18 +939,19 @@ async function parseCodexRolloutFile(filePath, {
     if (obj.type === "turn_context") {
       const p = obj.payload || {};
       if (typeof p.cwd === "string") cwd = p.cwd;
-      if (typeof p.model === "string") model = p.model;
       continue;
     }
 
-    if (obj.type === "response_item" && obj.payload?.type === "function_call") {
+    if (modelEvent?.type === "model_rerouted") continue;
+
+    if (collectBreakdowns && obj.type === "response_item" && obj.payload?.type === "function_call") {
       pendingToolNames.push(normalizeToolName(obj.payload));
       const skill = extractSkillNameFromFunctionCall(obj.payload, diagnostics);
       if (skill) pendingSkills.push(skill);
       continue;
     }
 
-    if (obj.type === "event_msg" && obj.payload?.type === "exec_command_end") {
+    if (collectBreakdowns && obj.type === "event_msg" && obj.payload?.type === "exec_command_end") {
       const details = getExecKeys(obj.payload);
       if (details) pendingExecDetails.push(details);
       continue;
@@ -881,6 +972,7 @@ async function parseCodexRolloutFile(filePath, {
           attributeTurn(null);
         } else {
           if (seenTokenEvents && delta?.total_tokens > 0) seenTokenEvents.add(eventKey);
+          recordModelUsage(delta, lastUsage || rawDelta);
           attributeTurn(delta);
         }
       } else {
@@ -895,7 +987,7 @@ async function parseCodexRolloutFile(filePath, {
   const result = {
     sessionId: sessionId || rolloutSessionIdFromPath(primaryFilePath) || primaryFilePath,
     cwd,
-    model: model || provider,
+    model: currentCodexModel(modelAttributionState) || model || provider,
     provider,
     version: cliVersion,
     forkedFromId,
@@ -906,6 +998,7 @@ async function parseCodexRolloutFile(filePath, {
     filePath: primaryFilePath,
     turnCount,
     totals,
+    modelUsage: finalizeModelUsageRows(byModel),
     toolBreakdown: {
       tool_rows: finalizeToolRows(byTool),
     },
@@ -926,6 +1019,7 @@ async function parseCodexRolloutFile(filePath, {
       sessionId,
       cwd,
       model,
+      modelAttributionState: snapshotCodexModelAttributionState(modelAttributionState),
       provider,
       cliVersion,
       forkedFromId,

package/src/lib/command-runner.js

@@ -226,6 +226,8 @@ function commonGlobalBinDirectories({ home = os.homedir(), platform = process.pl
   return [
     "/opt/homebrew/bin",
     "/usr/local/bin",
+    path.join(home, ".local", "bin"),
+    path.join(home, ".bun", "bin"),
     path.join(home, ".npm-global", "bin"),
     // volta keeps shims for every global install here
     path.join(home, ".volta", "bin"),
@@ -276,6 +278,16 @@ async function resolveBinaryPath(binary, { commandRunner, home, platform = proce
   return statBinaryInDirs(binary, searchDirs, platform);
 }
 
+// Resolving an npm CLI's absolute path does not resolve its /usr/bin/env node
+// shebang. Finder-launched apps have a minimal PATH even when the CLI lives
+// beside a working nvm/fnm/Homebrew Node. Scope this environment to the child;
+// preserve the install's own runtime and use our running Node as a fallback.
+function resolvedCliEnvironment(binaryPath, { env = process.env, platform = process.platform } = {}) {
+  if (platform === "win32") return { ...env };
+  const dirs = [path.dirname(binaryPath), ...(env.PATH || "/usr/bin:/bin").split(path.delimiter), path.dirname(process.execPath)];
+  return { ...env, PATH: [...new Set(dirs.filter(Boolean))].join(path.delimiter) };
+}
+
 module.exports = {
   runCommand,
   whichBinary,
@@ -283,4 +295,5 @@ module.exports = {
   commonGlobalBinDirectories,
   statBinaryInDirs,
   resolveBinaryPath,
+  resolvedCliEnvironment,
 };

package/src/lib/local-api.js

@@ -2019,6 +2019,9 @@ function createLocalApiHandler({ queuePath }) {
         const publishAccount =
           background && body.publishAccount === true && getCloudSyncPref();
         const allLocalSources = background && body.allLocalSources === true;
+        if (background && body.nativeOnlyWsl === true) {
+          extraEnv.TOKENTRACKER_WSL_MODE = "native-only";
+        }
         if (typeof body.deviceToken === "string" && body.deviceToken.trim()) {
           extraEnv.TOKENTRACKER_DEVICE_TOKEN = body.deviceToken.trim();
         }

package/src/lib/pricing/curated-overrides.json

@@ -48,11 +48,11 @@
       "note": "Canonical undated alias emitted by Cursor. Pin to the same rates as claude-haiku-4-5-20251001 so local cost does not depend on which dated LiteLLM aliases are present in the current cache."
     },
     "gpt-5.6-sol": {
-      "input": 5,
-      "output": 30,
-      "cache_read": 0.5,
-      "cache_write": 6.25,
-      "note": "GPT-5.6 family (public 2026-07-09). Flagship tier. Not yet in LiteLLM. developers.openai.com/api/docs/pricing short-context: $5/$30 per MTok, cached input 0.1x, cache write 1.25x. Codex emits gpt-5.6-sol (+ reasoning-effort variants like gpt-5.6-solhigh, caught by fuzzy). Remove once LiteLLM carries it."
+      "input": 4,
+      "output": 20,
+      "cache_read": 0.4,
+      "cache_write": 5,
+      "note": "Official GPT-5.6 Sol standard pricing: $4 input, $0.40 cached input, $5 cache write, and $20 output per MTok. Requests above 272K input are repriced from their preserved per-request long-context subset. Codex emits gpt-5.6-sol plus reasoning-effort variants caught by fuzzy matching."
     },
     "gpt-5.6-terra": {
       "input": 2,
@@ -428,7 +428,7 @@
     },
     {
       "match": "gpt-5.6",
-      "ref": "gpt-5.6-terra"
+      "ref": "gpt-5.6-sol"
     },
     {
       "match": "kiro",