tokentracker-cli 1.3.4 → 1.3.6

package/src/lib/claude-config.js

@@ -2,6 +2,7 @@ const fs = require("node:fs/promises");
 const path = require("node:path");
 
 const { ensureDir, readJson, writeJson } = require("./fs");
+const { buildNotifyCommand, notifyIdentity } = require("./notify-command");
 
 const DEFAULT_EVENT = "SessionEnd";
 const CLAUDE_USAGE_EVENTS = ["Stop", DEFAULT_EVENT];
@@ -23,10 +24,10 @@ async function upsertClaudeHooks({ settingsPath, hookCommand, events }) {
 
   for (const event of normalizeEventList(events)) {
     const entries = normalizeEntries(hooks[event]);
-    const normalized = normalizeEntriesForCommand(entries, hookCommand);
+    const normalized = normalizeEntriesForCommand(entries, hookCommand, event);
     let nextEntries = normalized.entries;
     if (!hasHook(nextEntries, hookCommand)) {
-      nextEntries = nextEntries.concat([{ hooks: [{ type: "command", command: hookCommand }] }]);
+      nextEntries = nextEntries.concat([{ hooks: [{ type: "command", command: hookCommand, ...hookShell(hookCommand) }] }]);
       changed = true;
     }
     if (normalized.changed) changed = true;
@@ -106,14 +107,14 @@ async function areClaudeHooksConfigured({ settingsPath, hookCommand, events }) {
 // Generic Session-hook command builder. CodeBuddy CLI is a Claude-Code fork
 // and uses the exact same settings.json hook schema, so this function works
 // for any source that accepts the `node notify.cjs --source=<name>` contract.
-function buildHookCommand(notifyPath, source) {
+function buildHookCommand(notifyPath, source, options) {
   const cmd = typeof notifyPath === "string" ? notifyPath : "";
   const src = typeof source === "string" && source ? source : "claude";
-  return `/usr/bin/env node ${quoteArg(cmd)} --source=${src}`;
+  return buildNotifyCommand(cmd, src, options);
 }
 
-function buildClaudeHookCommand(notifyPath) {
-  return buildHookCommand(notifyPath, "claude");
+function buildClaudeHookCommand(notifyPath, options) {
+  return buildHookCommand(notifyPath, "claude", options);
 }
 
 function normalizeSettings(raw) {
@@ -140,12 +141,15 @@ function normalizeCommand(cmd) {
 }
 
 function hasHook(entries, hookCommand) {
+  const shell = hookShell(hookCommand).shell;
+  const configured = (hook) => normalizeCommand(hook?.command) === normalizeCommand(hookCommand) &&
+    (!shell || (hook.shell === shell && !Object.hasOwn(hook, "args")));
   for (const entry of entries) {
     if (!entry || typeof entry !== "object") continue;
-    if (entry.command && commandsEqual(entry.command, hookCommand)) return true;
+    if (entry.command && configured(entry)) return true;
     const hooks = Array.isArray(entry.hooks) ? entry.hooks : [];
     for (const hook of hooks) {
-      if (hook && commandsEqual(hook.command, hookCommand)) return true;
+      if (hook && configured(hook)) return true;
     }
   }
   return false;
@@ -169,14 +173,25 @@ function stripHookFromEntry(entry, hookCommand) {
   return { entry: { ...entry, hooks: nextHooks }, removed: true };
 }
 
-function normalizeEntriesForCommand(entries, hookCommand) {
+function hookShell(command) {
+  return typeof command === "string" && command.trimStart().startsWith("& '")
+    ? { shell: "powershell" } : {};
+}
+
+function normalizeEntriesForCommand(entries, hookCommand, event) {
+  const shell = hookShell(hookCommand);
+  const repair = (hook) => {
+    const next = { ...hook, type: "command", command: hookCommand, ...shell };
+    if (shell.shell) delete next.args;
+    return next;
+  };
   let changed = false;
   const nextEntries = entries.map((entry) => {
     if (!entry || typeof entry !== "object") return entry;
     if (entry.command && commandsEqual(entry.command, hookCommand)) {
-      if (entry.type !== "command") {
+      if (entry.type !== "command" || entry.command !== hookCommand || (shell.shell && (entry.shell !== shell.shell || Object.hasOwn(entry, "args")))) {
         changed = true;
-        return { ...entry, type: "command" };
+        return repair(entry);
       }
       return entry;
     }
@@ -184,9 +199,9 @@ function normalizeEntriesForCommand(entries, hookCommand) {
     let hooksChanged = false;
     const nextHooks = entry.hooks.map((hook) => {
       if (hook && commandsEqual(hook.command, hookCommand)) {
-        if (hook.type !== "command") {
+        if (hook.type !== "command" || hook.command !== hookCommand || (shell.shell && (hook.shell !== shell.shell || Object.hasOwn(hook, "args")))) {
           hooksChanged = true;
-          return { ...hook, type: "command" };
+          return repair(hook);
         }
       }
       return hook;
@@ -195,13 +210,30 @@ function normalizeEntriesForCommand(entries, hookCommand) {
     changed = true;
     return { ...entry, hooks: nextHooks };
   });
-  return { entries: nextEntries, changed };
+  const seen = new Set();
+  const deduplicated = nextEntries.map((entry) => {
+    const matcher = entry?.matcher;
+    const scope = JSON.stringify(event === "Stop" || matcher == null || ["", "*", ".*"].includes(matcher) ? null : matcher);
+    const keep = (hook) => {
+      if (!commandsEqual(hook?.command, hookCommand)) return true;
+      if (seen.has(scope)) { changed = true; return false; }
+      seen.add(scope);
+      return true;
+    };
+    if (entry?.command) return keep(entry) ? entry : null;
+    if (!Array.isArray(entry?.hooks)) return entry;
+    const hooks = entry.hooks.filter(keep);
+    if (!hooks.length) return null;
+    return hooks.length === entry.hooks.length ? entry : { ...entry, hooks };
+  }).filter(Boolean);
+  return { entries: deduplicated, changed };
 }
 
 function commandsEqual(a, b) {
   const left = normalizeCommand(a);
   const right = normalizeCommand(b);
-  return Boolean(left && right && left === right);
+  return Boolean(left && right && (left === right ||
+    (notifyIdentity(left) && notifyIdentity(left) === notifyIdentity(right))));
 }
 
 function quoteArg(value) {

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

@@ -713,6 +713,8 @@ async function parseCodexRolloutFile(filePath, {
       };
       byModel.set(effectiveModel, row);
     }
+    const subsetKeys = Object.keys(row).filter((key) => /^(?:long_context_|priority_)|^(?:usage_events|rerouted_usage_events)$/.test(key));
+    const before = Object.fromEntries(subsetKeys.map((key) => [key, row[key]]));
     addInto(row, delta);
     row.usage_events += 1;
     if (attribution.selectedModel) {
@@ -758,6 +760,10 @@ async function parseCodexRolloutFile(filePath, {
         row.priority_long_context_reasoning_output_tokens += delta.reasoning_output_tokens;
       }
     }
+    return { ...delta, ...Object.fromEntries(subsetKeys.map((key) => [key, row[key] - before[key]])),
+      selected_models: attribution.selectedModel ? [attribution.selectedModel] : [],
+      reroute_reasons: attribution.rerouteReason ? [attribution.rerouteReason] : [],
+      model_attribution: attribution.rerouted ? "effective" : "selected" };
   }
 
   function ensureTool(name) {
@@ -927,7 +933,9 @@ async function parseCodexRolloutFile(filePath, {
     if (compactionResponseIds.has(record.responseId)) return;
     compactionResponseIds.add(record.responseId);
     if (!record.inRequestedRange) return;
-    recordModelUsage(record.delta, record.rawUsage, record.attribution);
+    const pricedDelta = recordModelUsage(record.delta, record.rawUsage, record.attribution);
+    if (typeof onUsage === "function") onUsage({ timestamp: record.timestamp,
+      delta: pricedDelta || record.delta, rawUsage: record.rawUsage, model: record.attribution.model, origin: "compaction" });
     attributeTurn(record.delta);
   }
 
@@ -1098,8 +1106,8 @@ async function parseCodexRolloutFile(filePath, {
           attributeTurn(null);
         } else {
           if (seenTokenEvents && delta?.total_tokens > 0) seenTokenEvents.add(eventKey);
-          recordModelUsage(delta, lastUsage || rawDelta);
-          if (typeof onUsage === "function") onUsage({ timestamp: ts, delta, rawUsage: lastUsage || rawDelta, model: attributedModel });
+          const pricedDelta = recordModelUsage(delta, lastUsage || rawDelta);
+          if (typeof onUsage === "function") onUsage({ timestamp: ts, delta: pricedDelta || delta, rawUsage: lastUsage || rawDelta, model: attributedModel });
           attributeTurn(delta);
         }
       } else {

package/src/lib/command-runner.js

@@ -15,6 +15,7 @@ const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
 
+/** Run a command without a shell by default, optionally piping options.input to stdin. */
 function runCommand(commandRunner, command, args, options = {}) {
   const merged = {
     encoding: "utf8",
@@ -29,6 +30,7 @@ function runCommand(commandRunner, command, args, options = {}) {
   const {
     timeout,
     maxBuffer,
+    input,
     completeWhen,
     completionGraceMs = 250,
     killProcessGroup = false,
@@ -64,7 +66,7 @@ function runCommand(commandRunner, command, args, options = {}) {
         ...spawnOptions,
         detached: useProcessGroup || spawnOptions.detached,
         shell: useShell,
-        stdio: ["ignore", "pipe", "pipe"],
+        stdio: [input === undefined ? "ignore" : "pipe", "pipe", "pipe"],
       });
     } catch (error) {
       resolve({ status: null, stdout: "", stderr: "", error });
@@ -168,6 +170,18 @@ function runCommand(commandRunner, command, args, options = {}) {
     if (Number.isFinite(timeout) && timeout > 0) {
       timer = setTimeout(() => stopChild({ timeoutExpired: true }), timeout);
     }
+    if (input !== undefined) {
+      child.stdin?.on("error", (error) => {
+        signalChild("SIGKILL");
+        settle({ error });
+      });
+      try {
+        child.stdin?.end(input);
+      } catch (error) {
+        signalChild("SIGKILL");
+        settle({ error });
+      }
+    }
   });
 }
 

package/src/lib/cursor-config.js

@@ -15,7 +15,8 @@ function resolveCursorPaths({ home, platform = process.platform, env = process.e
     appDir = pathForPlatform.join(h, "Library", "Application Support", "Cursor");
   } else if (platform === "win32") {
     const appData =
-      (typeof env.APPDATA === "string" && env.APPDATA.trim()) ||
+      ((!home || h === os.homedir() || env !== process.env) &&
+        typeof env.APPDATA === "string" && env.APPDATA.trim()) ||
       pathForPlatform.join(h, "AppData", "Roaming");
     appDir = pathForPlatform.join(appData, "Cursor");
   } else {

package/src/lib/gemini-config.js

@@ -3,6 +3,7 @@ const path = require("node:path");
 const fs = require("node:fs/promises");
 
 const { ensureDir, readJson, writeJson } = require("./fs");
+const { buildNotifyCommand } = require("./notify-command");
 
 const DEFAULT_EVENT = "SessionEnd";
 const DEFAULT_HOOK_NAME = "tokentracker";
@@ -99,9 +100,9 @@ async function isGeminiHookConfigured({
   return hasHook(entries, { hookCommand, hookName });
 }
 
-function buildGeminiHookCommand(notifyPath) {
+function buildGeminiHookCommand(notifyPath, options) {
   const cmd = typeof notifyPath === "string" ? notifyPath : "";
-  return `/usr/bin/env node ${quoteArg(cmd)} --source=gemini`;
+  return buildNotifyCommand(cmd, "gemini", options);
 }
 
 function buildHookEntry({ hookCommand, hookName, matcher }) {

package/src/lib/local-api.js

@@ -1056,7 +1056,17 @@ function scanClaudeProjects(projectMap) {
 // ---------------------------------------------------------------------------
 
 function json(res, data, status) {
-  res.writeHead(status || 200, { "Content-Type": "application/json" });
+  // Usage and cost payloads change on every sync, and cost is re-priced on
+  // every read (pricing is applied per request, never stored in the queue) —
+  // so a cached response can pin stale costs on screen indefinitely. WebView2
+  // caches responses that carry no freshness directive, and the dashboard's
+  // local fetch path omits `cache: "no-store"` (only the cloud path sets it).
+  // Endpoints that care already set this header by hand; do it once here so
+  // every JSON response is covered.
+  res.writeHead(status || 200, {
+    "Content-Type": "application/json",
+    "Cache-Control": "no-store",
+  });
   res.end(JSON.stringify(data));
 }
 
@@ -2610,7 +2620,7 @@ function createLocalApiHandler({ queuePath, serverVersion = null, trackerDataDir
         const sessions = await buildSessionAnalytics({ force: refresh });
         const wantsCsv = url.searchParams.get("format") === "csv";
         const includeSessions = wantsCsv || ["1", "true"].includes(url.searchParams.get("include_sessions"));
-        const result = summarizeSessions(sessions, { from, to, includeSessions });
+        const result = summarizeSessions(sessions, { from, to, includeSessions, ...getTimeZoneContext(url) });
         if (wantsCsv) {
           const content = sessionsToCsv(result.sessions);
           res.statusCode = 200;
@@ -2645,7 +2655,7 @@ function createLocalApiHandler({ queuePath, serverVersion = null, trackerDataDir
       try {
         const { buildSessionAnalytics, listSessionsForBrowser } = require("./session-analytics");
         const sessions = await buildSessionAnalytics({ force: refresh });
-        const result = listSessionsForBrowser(sessions, { from, to, limit });
+        const result = listSessionsForBrowser(sessions, { from, to, limit, ...getTimeZoneContext(url) });
         json(res, { from, to, ...result });
       } catch (error) {
         // Node fs errors embed the absolute path ("EACCES ... open '/Users/…'").

package/src/lib/notify-command.js

@@ -0,0 +1,38 @@
+"use strict";
+
+function powershellLiteral(value) {
+  return `'${String(value || "").replace(/'/g, "''")}'`;
+}
+
+function quotePosix(value) {
+  const text = String(value || "");
+  if (/^[A-Za-z0-9_\-./:@]+$/.test(text)) return text;
+  return `"${text.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\$/g, '\\$').replace(/`/g, '\\`')}"`;
+}
+
+function buildNotifyCommand(notifyPath, source, { platform = process.platform, execPath = process.execPath } = {}) {
+  if (!/^[a-z0-9-]+$/i.test(source)) throw new Error("Invalid notify source");
+  if (platform === "win32") {
+    return `& ${powershellLiteral(execPath)} ${powershellLiteral(notifyPath)} --source=${source}`;
+  }
+  return `/usr/bin/env node ${quotePosix(notifyPath)} --source=${source}`;
+}
+
+// Recognize only our complete notify invocation, never a user command merely
+// containing notify.cjs or additional shell actions. Used to repair old hooks.
+function notifyIdentity(command) {
+  if (typeof command !== "string") return null;
+  const tokens = command.match(/"(?:\\.|[^"\\])*"|'(?:''|[^'])*'|[^\s]+/g) || [];
+  const decode = (token) => token.startsWith("'")
+    ? token.slice(1, -1).replace(/''/g, "'")
+    : token.startsWith('"') ? token.slice(1, -1).replace(/\\([\\"$`])/g, "$1") : token;
+  const args = tokens.map(decode);
+  if (args[0] === "&") args.shift();
+  if (args[0] === "/usr/bin/env" && args[1] === "node") args.shift();
+  if (args.length !== 3 || !/(?:^|[\\/])node(?:\.exe)?$/i.test(args[0])) return null;
+  if (!/(?:^|[\\/])notify\.cjs$/i.test(args[1]) || !/^--source=[a-z0-9-]+$/i.test(args[2])) return null;
+  const file = args[1].replace(/\\/g, "/");
+  return `${/^[a-z]:\//i.test(file) ? file.toLowerCase() : file}\u0000${args[2]}`;
+}
+
+module.exports = { buildNotifyCommand, notifyIdentity };

package/src/lib/openclaw-session-plugin.js

@@ -371,7 +371,7 @@ function buildSessionPluginIndex({ trackerDir, packageName = "tokentracker-cli",
     `      const agentId = normalize(ctx && ctx.agentId) || parseAgentId(sessionKey);\n` +
     `      if (!agentId) return;\n` +
     `\n` +
-    `      const sessionInfo = resolveSessionInfo(agentId, sessionKey);\n` +
+    `      const sessionInfo = await resolveSessionInfo(agentId, sessionKey);\n` +
     `      const sessionId = normalize(sessionInfo && sessionInfo.sessionId);\n` +
     `      if (!sessionId) return;\n` +
     `\n` +
@@ -440,25 +440,58 @@ function buildSessionPluginIndex({ trackerDir, packageName = "tokentracker-cli",
     `  return out;\n` +
     `}\n` +
     `\n` +
-    `function resolveSessionInfo(agentId, sessionKey) {\n` +
+    `async function resolveSessionInfo(agentId, sessionKey) {\n` +
     `  const key = normalize(sessionKey);\n` +
     `  if (!key) return null;\n` +
     `  const sessionsPath = path.join(openclawHome, 'agents', agentId, 'sessions', 'sessions.json');\n` +
-    `  try {\n` +
-    `    const raw = fs.readFileSync(sessionsPath, 'utf8');\n` +
-    `    const parsed = JSON.parse(raw);\n` +
-    `    if (!parsed || typeof parsed !== 'object') return null;\n` +
-    `    const entry = parsed[key];\n` +
-    `    if (!entry || typeof entry !== 'object') return null;\n` +
-    `    return {\n` +
-    `      sessionKey: key,\n` +
-    `      sessionId: normalize(entry.sessionId),\n` +
-    `      entry\n` +
-    `    };\n` +
-    `  } catch (_) {}\n` +
+    `  if (fs.existsSync(sessionsPath)) {\n` +
+    `    try {\n` +
+    `      const raw = fs.readFileSync(sessionsPath, 'utf8');\n` +
+    `      const parsed = JSON.parse(raw);\n` +
+    `      if (parsed && typeof parsed === 'object') {\n` +
+    `        const entry = parsed[key];\n` +
+    `        if (entry && typeof entry === 'object' && normalize(entry.sessionId)) {\n` +
+    `          return { sessionKey: key, sessionId: normalize(entry.sessionId), entry };\n` +
+    `        }\n` +
+    `      }\n` +
+    `    } catch (_) {}\n` +
+    `  }\n` +
+    `  // OpenClaw >= 2026.9.9 keeps session state in a per-agent SQLite\n` +
+    `  // database (~/.openclaw/agents/<id>/agent/openclaw-agent.sqlite);\n` +
+    `  // sessions.json is no longer written. Without this fallback the\n` +
+    `  // plugin would silently no-op on every agent_end for anyone on a\n` +
+    `  // current OpenClaw install (issue: openclaw migration to sqlite).\n` +
+    `  return resolveSessionInfoFromSqlite(agentId, key);\n` +
+    `}\n` +
+    `\n` +
+    `async function resolveSessionInfoFromSqlite(agentId, sessionKey) {\n` +
+    `  const sqliteModule = await importSqliteSync();\n` +
+    `  if (!sqliteModule) return null;\n` +
+    `  const { DatabaseSync } = sqliteModule;\n` +
+    `  const currentSessionQuery = "SELECT w.session_id FROM session_nodes n JOIN session_windows w ON w.session_id = n.current_session_id WHERE n.session_key = ? AND COALESCE(w.reason, '') != 'compaction'";\n` +
+    `  const sessionQuery = "SELECT session_id FROM session_windows WHERE session_key = ? AND COALESCE(reason, '') != 'compaction' ORDER BY updated_at DESC LIMIT 1";\n` +
+    `  const dbCandidates = [path.join(openclawHome, 'agents', agentId, 'agent', 'openclaw-agent.sqlite'), path.join(openclawHome, 'agents', agentId, 'openclaw-agent.sqlite')];\n` +
+    `  for (const dbPath of dbCandidates) {\n` +
+    `    if (!fs.existsSync(dbPath)) continue;\n` +
+    `    let db;\n` +
+    `    try { db = new DatabaseSync(dbPath, { readOnly: true }); } catch (_) { continue; }\n` +
+    `    try {\n` +
+    `      let row;\n` +
+    `      try { row = db.prepare(currentSessionQuery).get(sessionKey); } catch (_) {}\n` +
+    `      if (!row || !row.session_id) row = db.prepare(sessionQuery).get(sessionKey);\n` +
+    `      if (!row || !row.session_id) continue;\n` +
+    `      // The passive SQLite reader owns per-event accounting; never synthesize lifetime sums.\n` +
+    `      return { sessionKey, sessionId: row.session_id, entry: {} };\n` +
+    `    } catch (_) {}\n` +
+    `    finally { try { db.close(); } catch (_) {} }\n` +
+    `  }\n` +
     `  return null;\n` +
     `}\n` +
     `\n` +
+    `async function importSqliteSync() {\n` +
+    `  try { return await import('node:sqlite'); } catch (_) { return null; }\n` +
+    `}\n` +
+    `\n` +
     `function parseAgentId(sessionKey) {\n` +
     `  const s = normalize(sessionKey);\n` +
     `  if (!s || !s.startsWith('agent:')) return null;\n` +

package/src/lib/passive-mode.js

@@ -28,6 +28,7 @@
 
 const fs = require("node:fs");
 const path = require("node:path");
+const { expandHome } = require("./scan-roots");
 
 /**
  * @typedef {Object} PassiveProvider
@@ -171,6 +172,17 @@ function detectPassiveProviders({ home, hookStatus, env = process.env }) {
     settingsPath: path.join(home, ".workbuddy", "settings.json"),
   }));
 
+  // WorkBuddy AI — international build; data + hooks in ~/.workbuddy-ai
+  const workbuddyAiHome = expandHome(env.WORKBUDDY_AI_HOME, home) || path.join(home, ".workbuddy-ai");
+  out.push(buildEntry({
+    name: "workbuddy-ai",
+    hookExpected: true,
+    hookInstalled: Boolean(hookStatus?.["workbuddy-ai"]),
+    logsDir: workbuddyAiHome,
+    logsPredicate: (_full, name) => name === "projects" || name.endsWith(".jsonl"),
+    settingsPath: path.join(workbuddyAiHome, "settings.json"),
+  }));
+
   return out;
 }
 

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

@@ -3,9 +3,43 @@
     "note": "Curated price overrides. Always wins over LiteLLM. Two reasons to live here: (1) self-defined alias names that LiteLLM will never carry (kiro-*, hy3-*, composer-*, kimi-for-coding, free-tier OpenRouter routes); (2) prices we want to pin even if LiteLLM has the model (e.g. cache_write fields LiteLLM often omits). Units: USD per million tokens. Edit this file to override pricing without redeploying.",
     "units": "usd_per_million_tokens",
     "deepseek_v4_pricing_note": "Official DeepSeek V4 pricing verified on 2026-08-21. Peak hours are 01:00-04:00 and 06:00-10:00 UTC; all other hours are off-peak at half price. Exact entries store peak rates. computeRowCost applies the time-of-use discount from each row's UTC hour_start.",
-    "iflytek_maas_pricing_note": "iFlytek MaaS inference prices supplied for AStudio on 2026-08-31. AStudio homepage: https://agent.xfyun.cn/. Official pricing source: https://maas.xfyun.cn/modelSquare. Source values are RMB per million tokens, converted at 7.2 RMB/USD, then rounded to two decimal places for billing. Models without a dedicated cache-hit price use the normal input rate; cache writes also use the normal input rate. iFlytek MaaS prices are source-scoped and do not inherit DeepSeek time-of-use discounts."
+    "iflytek_maas_pricing_note": "iFlytek MaaS inference prices supplied for AStudio on 2026-08-31. AStudio homepage: https://agent.xfyun.cn/. Official pricing source: https://maas.xfyun.cn/modelSquare. Source values are RMB per million tokens, converted at 7.2 RMB/USD, then rounded to two decimal places for billing. Models without a dedicated cache-hit price use the normal input rate; cache writes also use the normal input rate. iFlytek MaaS prices are source-scoped and do not inherit DeepSeek time-of-use discounts. Spark-X2.5 entries (spark-x2.5, spark-x2.5-4b, spark-x2.5-1.7b) were read from the model square on 2026-10-08; spark-x2.5 is listed at a limited-time 30% rate (0.96 / 3.6 / 0.14 RMB input / output / cache-hit, list price 3.2 / 12 / 0.48), and the two small models are free."
   },
   "exact": {
+    "claude-opus-5-5": {
+      "input": 4,
+      "output": 20,
+      "cache_read": 0.2,
+      "cache_write": 5,
+      "note": "Official Anthropic pricing verified 2026-10-11: https://platform.claude.com/docs/en/about-claude/pricing"
+    },
+    "claude-opus-5.5": {
+      "input": 4,
+      "output": 20,
+      "cache_read": 0.2,
+      "cache_write": 5,
+      "note": "Official Anthropic pricing verified 2026-10-11: https://platform.claude.com/docs/en/about-claude/pricing"
+    },
+    "claude-sonnet-5-5": {
+      "input": 2,
+      "output": 10,
+      "cache_read": 0.1,
+      "cache_write": 2.5,
+      "note": "Official Anthropic pricing verified 2026-10-11: https://platform.claude.com/docs/en/about-claude/pricing"
+    },
+    "claude-sonnet-5.5": {
+      "input": 2,
+      "output": 10,
+      "cache_read": 0.1,
+      "cache_write": 2.5,
+      "note": "Official Anthropic pricing verified 2026-10-11: https://platform.claude.com/docs/en/about-claude/pricing"
+    },
+    "k3-256k": {
+      "input": 3,
+      "output": 15,
+      "cache_read": 0.3,
+      "note": "Bare alias emitted by Kimi Code (modelAlias \"kimi-code/k3\" -> \"k3\"). Same rates as kimi-k3."
+    },
     "cline-gateway-models": {
       "input": 0,
       "output": 0,
@@ -42,10 +76,10 @@
       "note": "Opus 4.8 not yet in LiteLLM. Pin to the standard Opus tier (same as 4.6/4.7); remove once LiteLLM carries it."
     },
     "claude-sonnet-5": {
-      "input": 3,
-      "output": 15,
-      "cache_read": 0.3,
-      "cache_write": 3.75,
+      "input": 2,
+      "output": 10,
+      "cache_read": 0.2,
+      "cache_write": 2.5,
       "note": "Sonnet 5. LiteLLM added this model on ~2026-06-30 with matching rates, but pin explicitly so pricing is correct immediately rather than depending on the 24h local pricing-cache refresh cycle."
     },
     "claude-haiku-4-5": {
@@ -482,6 +516,9 @@
   },
   "source_exact": {
     "acode": {
+      "spark-x2.5": { "input": 0.13, "output": 0.50, "cache_read": 0.02, "cache_write": 0.13 },
+      "spark-x2.5-4b": { "input": 0.00, "output": 0.00, "cache_read": 0.00, "cache_write": 0.00 },
+      "spark-x2.5-1.7b": { "input": 0.00, "output": 0.00, "cache_read": 0.00, "cache_write": 0.00 },
       "xopglm53": { "input": 1.11, "output": 3.89, "cache_read": 0.28, "cache_write": 1.11 },
       "xopdeepseekv4pro0813": { "input": 1.25, "output": 3.75, "cache_read": 0.04, "cache_write": 1.25 },
       "xopdeepseekv4flash0731": { "input": 0.14, "output": 0.28, "cache_read": 0.03, "cache_write": 0.14 },

package/src/lib/pricing/matcher.js

@@ -238,7 +238,13 @@ function lookupContainedExactCaseInsensitive(table, model) {
   const lower = model.toLowerCase();
   const keys = Object.keys(table).sort((a, b) => b.length - a.length);
   for (const key of keys) {
-    if (lower.includes(key.toLowerCase())) return table[key];
+    const start = lower.indexOf(key.toLowerCase());
+    if (start < 0) continue;
+    // A model generation must not match a later numeric version (Opus 5.5
+    // is a separate SKU from Opus 5). Dated and provider suffixes still work.
+    const suffix = lower.slice(start + key.length);
+    if (/^[.\d]/.test(suffix)) continue;
+    return table[key];
   }
   return null;
 }
@@ -256,6 +262,9 @@ function lookupPricing(model, { curated, litellm, source } = {}) {
   // 0. CURATED source exact. Source-specific prices apply only to their source,
   // preventing collisions with public prices for same-named models from other CLIs.
   const sourceKey = typeof source === "string" ? source.toLowerCase() : "";
+  if (sourceKey === "workbuddy-ai" && lower.trim() === "auto") {
+    return { hit: false, source: "miss", value: null };
+  }
   if (sourceKey === "cline" && lower.endsWith(":free")) {
     return {
       hit: true,
@@ -289,10 +298,6 @@ function lookupPricing(model, { curated, litellm, source } = {}) {
   if (curatedDotExact) {
     return { hit: true, source: "curated:exact-dot", value: curatedDotExact };
   }
-  const curatedDotContainedExact = lookupContainedExactCaseInsensitive(curated.exact, dotForm);
-  if (curatedDotContainedExact) {
-    return { hit: true, source: "curated:exact-dot", value: curatedDotContainedExact };
-  }
 
   // 2. LiteLLM exact
   if (litellm && litellm[lookupModel]) {
@@ -302,6 +307,10 @@ function lookupPricing(model, { curated, litellm, source } = {}) {
   if (litellmDotExact) {
     return { hit: true, source: "litellm:exact-dot", value: litellmDotExact };
   }
+  const curatedDotContainedExact = lookupContainedExactCaseInsensitive(curated.exact, dotForm);
+  if (curatedDotContainedExact) {
+    return { hit: true, source: "curated:exact-dot", value: curatedDotContainedExact };
+  }
 
   // 3. CURATED alias (literal mapping like "auto" -> "composer-1")
   if (curated.alias && curated.alias[lookupModel] && curated.exact[curated.alias[lookupModel]]) {