cost: read qwen's usage log (#420)

qwen was listed as an engine that keeps no readable record, and that has
stopped being true: it appends one record per request to
~/.qwen/usage/token-usage-YYYY-MM.jsonl, and writes the directory it was
started in to ~/.qwen/projects/<slug>/chats/<session>.runtime.json. So a
qwen session launched through /agents showed up nowhere in /usage.

Two pieces of its arithmetic are easy to get wrong, and both are checked
against qwen-code's own conversion rather than guessed:

- `cachedTokens` is part of `inputTokens`, so fresh input is the
  difference — the same trap codex's cumulative counts have.
- `thoughtsTokens` is already inside `outputTokens` on the
  OpenAI-compatible path (`completion_tokens` contains `reasoning_tokens`),
  so adding it would double-count the thinking. Only the native path,
  which reports Gemini's `candidatesTokenCount`, has to add it back.

No Alibaba rates are shipped — that stays deliberate — so qwen runs report
tokens and no cost, and the report already says how to price them.

Verified against this machine's real log: 314,485 in / 54,574 out /
8.34M cached across 3 sessions, matching a raw sum of the file.

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: ralyodio

src/cli-schema.mjs

@@ -139,7 +139,7 @@ export const CORE_CLI_COMMANDS = [
       + "codex's rollout token counts, opencode's per-message cost, aider's chat history. a figure marked "
       + "`~` was worked out from published rates and is what the tokens WOULD cost on the api; unmarked "
       + "figures are the engine's own arithmetic. models with no rate show tokens and no cost — add yours "
-      + "to ~/.moshcode/pricing.json. gemini, kimi, qwen, deepseek and openagents log nothing readable, "
+      + "to ~/.moshcode/pricing.json. gemini, kimi, deepseek and openagents log nothing readable, "
       + "so they report no cost rather than zero.",
   },
   // Everyone who has used a coding agent's own `/usage` types that word first,

src/cost.mjs

@@ -2,7 +2,8 @@
 //
 // Every engine moshcode wraps already writes down what it used — Claude Code
 // keeps a per-message `usage` block in ~/.claude/projects/**/<session>.jsonl,
-// Codex emits cumulative `token_count` events into ~/.codex/sessions/…, and
+// Codex emits cumulative `token_count` events into ~/.codex/sessions/…, qwen
+// appends a record per request to ~/.qwen/usage/token-usage-YYYY-MM.jsonl, and
 // opencode stores a per-message `cost` it computed itself in SQLite. Nobody has
 // to be instrumented and nothing has to be proxied: the numbers are on disk
 // because the CLI put them there. This module reads them, normalises them into
@@ -408,6 +409,123 @@ async function opencodeRuns(engine, { since, cwd } = {}) {
   return [...bySession.values()];
 }
 
+// ---------------------------------------------------------------------------
+// qwen — ~/.qwen/usage/token-usage-YYYY-MM.jsonl, one record per request
+// ---------------------------------------------------------------------------
+
+const qwenUsageDir = () => path.join(home(), ".qwen", "usage");
+const qwenProjectsDir = () => path.join(home(), ".qwen", "projects");
+
+/** Only the monthly usage logs; the directory also holds unrelated state. */
+const QWEN_USAGE_FILE = /^token-usage-\d{4}-\d{2}\.jsonl$/;
+
+/**
+ * sessionId → the directory qwen was started in.
+ *
+ * The usage log records no path, so on its own it can say what was spent but
+ * not where. qwen writes a tiny `<sessionId>.runtime.json` beside each chat
+ * with the `work_dir` in it, and that is the only exact answer on disk — the
+ * project directory those chats sit in is a lossy dash-slug of the same path,
+ * so it can group sessions but cannot be turned back into a directory.
+ */
+function qwenSessionDirs() {
+  const dirs = new Map();
+  const root = qwenProjectsDir();
+  for (const project of listDir(root)) {
+    if (!project.isDirectory()) continue;
+    const chats = path.join(root, project.name, "chats");
+    for (const entry of listDir(chats)) {
+      if (!entry.isFile() || !entry.name.endsWith(".runtime.json")) continue;
+      let meta;
+      try { meta = parseJson(fs.readFileSync(path.join(chats, entry.name), "utf8")); }
+      catch { continue; }
+      if (meta?.session_id && meta.work_dir) dirs.set(String(meta.session_id), String(meta.work_dir));
+    }
+  }
+  return dirs;
+}
+
+/**
+ * One usage record → the shape every engine normalises into.
+ *
+ * `inputTokens` is the whole prompt and `cachedTokens` is the part of it that
+ * was a cache hit, so the fresh input is the difference — counting both would
+ * bill the cache twice at the full input rate.
+ *
+ * `thoughtsTokens` is the subtle one. On the OpenAI-compatible path — which is
+ * what `authType: "openai"` marks, and what qwen's own DashScope endpoint uses
+ * — `outputTokens` is `completion_tokens`, which already *contains* the
+ * reasoning tokens, and adding them would double-count the thinking. The native
+ * path reports Gemini's `candidatesTokenCount`, which excludes them, so that is
+ * the only case where they have to be added back.
+ */
+function qwenUsageOf(record) {
+  const cached = num(record.cachedTokens);
+  const thoughts = num(record.thoughtsTokens);
+  return {
+    input: Math.max(0, num(record.inputTokens) - cached),
+    output: num(record.outputTokens) + (record.authType === "openai" ? 0 : thoughts),
+    cacheRead: cached,
+    cacheWrite5m: 0,
+    cacheWrite1h: 0,
+  };
+}
+
+/**
+ * Every qwen session in the window, one run per session.
+ *
+ * The log is per-request and flat, so the session id is what makes a run: a
+ * subagent's requests carry the same one (`source` names the subagent) and
+ * belong to the session that spawned them.
+ */
+export function qwenRuns({ since, cwd } = {}) {
+  const dirs = qwenSessionDirs();
+  const sessions = new Map();
+
+  for (const entry of listDir(qwenUsageDir())) {
+    if (!entry.isFile() || !QWEN_USAGE_FILE.test(entry.name)) continue;
+    const file = path.join(qwenUsageDir(), entry.name);
+    const stat = safeStat(file);
+    // A month untouched since before the window holds nothing inside it.
+    if (!stat || (since != null && stat.mtimeMs < since)) continue;
+
+    let text;
+    try { text = fs.readFileSync(file, "utf8"); } catch { continue; }
+    for (const line of text.split("\n")) {
+      if (!line || line.charCodeAt(0) !== 123) continue; // fast reject: not "{"
+      const record = parseJson(line);
+      if (!record?.sessionId) continue;
+      const at = stamp(record.timestamp);
+      if (at != null && since != null && at < since) continue;
+
+      const id = String(record.sessionId);
+      const where = dirs.get(id) || "";
+      // A session whose directory is unknown cannot be claimed for the one that
+      // was asked for — reporting it there would invent an attribution.
+      if (cwd && !samePath(where, cwd)) continue;
+
+      let run = sessions.get(id);
+      if (!run) {
+        run = {
+          engine: "qwen", id, cwd: where,
+          usage: { ...EMPTY_USAGE }, byModel: new Map(),
+          start: null, end: null, engineCost: null,
+        };
+        sessions.set(id, run);
+      }
+      const one = qwenUsageOf(record);
+      const model = record.model || "unknown";
+      run.usage = addUsage(run.usage, one);
+      run.byModel.set(model, addUsage(run.byModel.get(model) || EMPTY_USAGE, one));
+      if (at != null) {
+        run.start = run.start == null ? at : Math.min(run.start, at);
+        run.end = run.end == null ? at : Math.max(run.end, at);
+      }
+    }
+  }
+  return [...sessions.values()];
+}
+
 // ---------------------------------------------------------------------------
 // aider — it prints the running total into its own chat history
 // ---------------------------------------------------------------------------
@@ -486,11 +604,12 @@ export const COST_READERS = {
   codex: (opts) => codexRuns(opts),
   opencode: (opts) => opencodeRuns("opencode", opts),
   privacycode: (opts) => opencodeRuns("privacycode", opts),
+  qwen: (opts) => qwenRuns(opts),
   aider: (opts) => aiderRuns(opts),
 };
 
 /** Engines moshcode can launch but cannot cost — named so the report can say so. */
-export const UNCOSTED_ENGINES = ["gemini", "kimi", "qwen", "deepseek", "openagents"];
+export const UNCOSTED_ENGINES = ["gemini", "kimi", "deepseek", "openagents"];
 
 /**
  * Finish a run: price it, and record where the price came from.

test/cost.test.mjs

@@ -220,6 +220,80 @@ test("codex rollouts", async (t) => {
   }));
 });
 
+test("qwen usage log", async (t) => {
+  const record = ({ at, session = "qw-1", model = "qwen3.8-max", authType = "openai", source = "main", input, output, cached = 0, thoughts = 0 }) => JSON.stringify({
+    schemaVersion: 1, id: `${session}-${at}-${source}`, timestamp: at, sessionId: session,
+    model, authType, source,
+    inputTokens: input, outputTokens: output, cachedTokens: cached, thoughtsTokens: thoughts,
+    totalTokens: input + output,
+  });
+
+  const monthFile = (home, at) => path.join(home, ".qwen", "usage", `token-usage-${at.slice(0, 7)}.jsonl`);
+
+  const runtime = (home, { slug, session, workDir }) => write(
+    path.join(home, ".qwen", "projects", slug, "chats", `${session}.runtime.json`),
+    JSON.stringify({ schema_version: 1, session_id: session, work_dir: workDir }),
+  );
+
+  await t.test("sums a session's requests and nets the cached prompt out of input", () => withHome(async (home) => {
+    const at = new Date().toISOString();
+    runtime(home, { slug: "-home-anthony-src-api", session: "qw-1", workDir: "/home/anthony/src/api" });
+    write(monthFile(home, at), [
+      record({ at, input: 1000, output: 200, cached: 600, thoughts: 120 }),
+      // A subagent's requests carry the session that spawned them.
+      record({ at, source: "Explore", input: 500, output: 50, cached: 0 }),
+    ].join("\n"));
+
+    const [run] = await engineRuns({ since: Date.now() - 3600e3, engines: ["qwen"] });
+    assert.equal(run.engine, "qwen");
+    assert.equal(run.id, "qw-1");
+    assert.equal(run.cwd, "/home/anthony/src/api");
+    assert.equal(run.usage.input, 900); // (1000 - 600) + 500
+    assert.equal(run.usage.cacheRead, 600);
+    // The OpenAI-compatible path counts reasoning inside `outputTokens`, so the
+    // 120 thinking tokens are already in the 200 and must not be added again.
+    assert.equal(run.usage.output, 250);
+    assert.deepEqual(run.models, ["qwen3.8-max"]);
+    // Alibaba rates are deliberately not shipped, so tokens stand and cost does not.
+    assert.equal(run.cost, null);
+    assert.deepEqual(run.unpriced, ["qwen3.8-max"]);
+  }));
+
+  await t.test("the native path reports thinking separately, so it is added back", () => withHome(async (home) => {
+    const at = new Date().toISOString();
+    write(monthFile(home, at), record({ at, authType: "qwen-oauth", input: 100, output: 40, thoughts: 60 }));
+    const [run] = await engineRuns({ since: Date.now() - 3600e3, engines: ["qwen"] });
+    assert.equal(run.usage.output, 100);
+  }));
+
+  await t.test("a session in another directory is not this directory's cost", () => withHome(async (home) => {
+    const at = new Date().toISOString();
+    runtime(home, { slug: "-home-anthony-src-web", session: "qw-1", workDir: "/home/anthony/src/web" });
+    write(monthFile(home, at), record({ at, input: 10, output: 1 }));
+    const runs = await engineRuns({ since: Date.now() - 3600e3, engines: ["qwen"], cwd: "/home/anthony/src/api" });
+    assert.deepEqual(runs, []);
+  }));
+
+  await t.test("requests older than the window do not count", () => withHome(async (home) => {
+    const old = new Date(Date.now() - 48 * 3600e3).toISOString();
+    const now = new Date().toISOString();
+    write(monthFile(home, now), [
+      record({ at: old, input: 999, output: 999 }),
+      record({ at: now, input: 10, output: 2 }),
+    ].join("\n"));
+    const [run] = await engineRuns({ since: Date.now() - 3600e3, engines: ["qwen"] });
+    assert.equal(run.usage.input, 10);
+    assert.equal(run.usage.output, 2);
+  }));
+
+  await t.test("a session with no runtime file still reports, with no directory", () => withHome(async (home) => {
+    const at = new Date().toISOString();
+    write(monthFile(home, at), record({ at, input: 10, output: 2 }));
+    const [run] = await engineRuns({ since: Date.now() - 3600e3, engines: ["qwen"] });
+    assert.equal(run.cwd, "");
+  }));
+});
+
 test("aider history", async (t) => {
   const history = [
     "# aider chat started at 2026-08-16 09:00:00",