tokentracker-cli 0.84.5 → 0.84.7

package/src/lib/rollout.js

@@ -1,5 +1,6 @@
 const fs = require("node:fs/promises");
 const fssync = require("node:fs");
+const os = require("node:os");
 const path = require("node:path");
 const readline = require("node:readline");
 
@@ -8,6 +9,11 @@ const { ensureDir } = require("./fs");
 const { readSqliteJsonRows, readSqliteJsonRowsAsync } = require("./sqlite-reader");
 const wsl = require("./wsl-probe");
 const { resolveInstallPaths } = require("./install-resolver");
+const {
+  consumeUsageDelta,
+  createUsageDeltaState,
+  snapshotUsageBaselines,
+} = require("./codex-token-usage");
 
 const DEFAULT_SOURCE = "codex";
 const DEFAULT_MODEL = "unknown";
@@ -360,6 +366,9 @@ async function parseRolloutIncremental({
     const lastTotal = sameInode && !truncated && !rebuildingCodexBaseline
       ? prev.lastTotal || null
       : null;
+    const tokenUsageBaselines = sameInode && !truncated && !rebuildingCodexBaseline
+      ? prev.tokenUsageBaselines || null
+      : null;
     const lastModel = sameInode && !truncated ? prev.lastModel || null : null;
 
     const codexProjectFastPath = projectEnabled && fileSource === DEFAULT_SOURCE;
@@ -430,6 +439,7 @@ async function parseRolloutIncremental({
           filePath,
           fileStat: st,
           lastTotal,
+          tokenUsageBaselines,
           lastModel,
           projectState,
           projectMetaCache,
@@ -442,6 +452,7 @@ async function parseRolloutIncremental({
           fileStat: st,
           startOffset,
           lastTotal,
+          tokenUsageBaselines,
           lastModel,
           hourlyState,
           touchedBuckets,
@@ -462,6 +473,7 @@ async function parseRolloutIncremental({
       inode,
       offset: result.endOffset,
       lastTotal: result.lastTotal,
+      tokenUsageBaselines: result.tokenUsageBaselines,
       lastModel: result.lastModel,
       updatedAt: new Date().toISOString(),
     };
@@ -1731,6 +1743,7 @@ async function parseRolloutFile({
   fileStat,
   startOffset,
   lastTotal,
+  tokenUsageBaselines,
   lastModel,
   hourlyState,
   touchedBuckets,
@@ -1751,14 +1764,25 @@ async function parseRolloutFile({
   const projectFileContexts = [];
   addProjectFileContext(projectFileContexts, projectContext);
   if (startOffset >= endOffset) {
-    return { endOffset, lastTotal, lastModel, eventsAggregated: 0, projectFileContexts };
+    return {
+      endOffset,
+      lastTotal,
+      tokenUsageBaselines,
+      lastModel,
+      eventsAggregated: 0,
+      projectFileContexts,
+    };
   }
 
   const stream = fssync.createReadStream(filePath, { encoding: "utf8", start: startOffset });
   const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
 
   let model = typeof lastModel === "string" ? lastModel : null;
-  let totals = lastTotal && typeof lastTotal === "object" ? lastTotal : null;
+  const usageDeltaState = createUsageDeltaState({
+    lastTotal,
+    baselines: tokenUsageBaselines,
+  });
+  let latestTotal = lastTotal && typeof lastTotal === "object" ? lastTotal : null;
   let currentCwd = null;
   let currentDate = null;
   let isForkedRollout = false;
@@ -1840,15 +1864,13 @@ async function parseRolloutFile({
 
     const lastUsage = info.last_token_usage;
     const totalUsage = info.total_token_usage;
+    if (totalUsage && typeof totalUsage === "object") latestTotal = totalUsage;
 
-    const delta = pickDelta(lastUsage, totalUsage, totals);
-    if (!delta) continue;
+    const rawDelta = consumeUsageDelta(usageDeltaState, lastUsage, totalUsage);
+    const delta = rawDelta ? normalizeUsage(rawDelta) : null;
+    if (!delta || isAllZeroUsage(delta)) continue;
     delta.conversation_count = 1;
 
-    if (totalUsage && typeof totalUsage === "object") {
-      totals = totalUsage;
-    }
-
     // Forked Codex rollouts replay the parent session's entire token history
     // into the child file the moment the fork is created. The date guard below
     // (current_date < rolloutDate) catches cross-day forks, but same-day forks
@@ -1863,8 +1885,8 @@ async function parseRolloutFile({
     // flush spacing and well below genuine turn cadence (≥~4.6s observed). The
     // first replayed row cannot be identified without lookahead, so it is still
     // counted (a bounded, <1% residual over-count); dropping real usage is the
-    // worse failure, so we bias against it. `totals` is already advanced above,
-    // keeping the cumulative-delta baseline correct for the live turns we keep.
+    // worse failure, so we bias against it. `usageDeltaState` is already advanced above,
+    // keeping the cumulative lineage correct for the live turns we keep.
     // Scoped to forked codex rollouts. (issue #169 follow-up.)
     let forkedReplaySkip = false;
     if (isForkedRollout && source === DEFAULT_SOURCE && replayPrefixActive) {
@@ -1903,8 +1925,8 @@ async function parseRolloutFile({
     // buckets. External tools rewrite session files without changing the token
     // data — Codex-Manager atomically rewrites them (new inode) to patch the
     // provider on every account/channel switch — so without dedup each switch
-    // double-counts the rewritten sessions. `totals` is already advanced above,
-    // so skipping an already-seen event keeps the cumulative-delta chain intact
+    // double-counts the rewritten sessions. `usageDeltaState` is already advanced above,
+    // so skipping an already-seen event keeps the cumulative lineage intact
     // while preventing the re-add; genuinely new turns carry new timestamps and
     // are still counted. Key = sessionUUID:eventTimestamp (both stable across the
     // rewrite and across a sessions/ -> archived_sessions/ move).
@@ -1939,13 +1961,21 @@ async function parseRolloutFile({
     eventsAggregated += 1;
   }
 
-  return { endOffset, lastTotal: totals, lastModel: model, eventsAggregated, projectFileContexts };
+  return {
+    endOffset,
+    lastTotal: latestTotal,
+    tokenUsageBaselines: snapshotUsageBaselines(usageDeltaState),
+    lastModel: model,
+    eventsAggregated,
+    projectFileContexts,
+  };
 }
 
 async function scanRolloutProjectFileContexts({
   filePath,
   fileStat,
   lastTotal,
+  tokenUsageBaselines,
   lastModel,
   projectState,
   projectMetaCache,
@@ -1958,7 +1988,14 @@ async function scanRolloutProjectFileContexts({
   const projectFileContexts = [];
   addProjectFileContext(projectFileContexts, projectContext);
   if (!projectState || endOffset <= 0) {
-    return { endOffset, lastTotal, lastModel, eventsAggregated: 0, projectFileContexts };
+    return {
+      endOffset,
+      lastTotal,
+      tokenUsageBaselines,
+      lastModel,
+      eventsAggregated: 0,
+      projectFileContexts,
+    };
   }
 
   const stream = fssync.createReadStream(filePath, { encoding: "utf8", start: 0 });
@@ -2005,7 +2042,14 @@ async function scanRolloutProjectFileContexts({
     addProjectFileContext(projectFileContexts, context);
   }
 
-  return { endOffset, lastTotal, lastModel, eventsAggregated: 0, projectFileContexts };
+  return {
+    endOffset,
+    lastTotal,
+    tokenUsageBaselines,
+    lastModel,
+    eventsAggregated: 0,
+    projectFileContexts,
+  };
 }
 
 async function parseClaudeFile({
@@ -2861,6 +2905,15 @@ function normalizeOpencodeState(raw) {
   };
 }
 
+function normalizeQoderState(raw) {
+  const state = raw && typeof raw === "object" ? raw : {};
+  const messages = state.messages && typeof state.messages === "object" ? state.messages : {};
+  return {
+    messages,
+    updatedAt: typeof state.updatedAt === "string" ? state.updatedAt : null,
+  };
+}
+
 function normalizeMessageKeyPart(value) {
   if (typeof value !== "string") return "";
   return value.trim();
@@ -2954,6 +3007,33 @@ function addTotals(target, delta) {
   target.conversation_count += delta.conversation_count || 0;
 }
 
+function subtractTotals(target, totals) {
+  target.input_tokens = Math.max(0, target.input_tokens - (totals.input_tokens || 0));
+  target.cached_input_tokens = Math.max(
+    0,
+    target.cached_input_tokens - (totals.cached_input_tokens || 0),
+  );
+  target.cache_creation_input_tokens = Math.max(
+    0,
+    target.cache_creation_input_tokens - (totals.cache_creation_input_tokens || 0),
+  );
+  target.output_tokens = Math.max(0, target.output_tokens - (totals.output_tokens || 0));
+  target.reasoning_output_tokens = Math.max(
+    0,
+    target.reasoning_output_tokens - (totals.reasoning_output_tokens || 0),
+  );
+  target.total_tokens = Math.max(0, target.total_tokens - (totals.total_tokens || 0));
+  target.billable_total_tokens = Math.max(
+    0,
+    target.billable_total_tokens -
+      (totals.billable_total_tokens ?? totals.total_tokens ?? 0),
+  );
+  target.conversation_count = Math.max(
+    0,
+    target.conversation_count - (totals.conversation_count || 0),
+  );
+}
+
 function totalsKey(totals) {
   return [
     totals.input_tokens || 0,
@@ -3570,48 +3650,6 @@ function extractTokenCount(obj) {
   return null;
 }
 
-function pickDelta(lastUsage, totalUsage, prevTotals) {
-  const hasLast = isNonEmptyObject(lastUsage);
-  const hasTotal = isNonEmptyObject(totalUsage);
-  const hasPrevTotals = isNonEmptyObject(prevTotals);
-
-  if (hasTotal && hasPrevTotals) {
-    if (totalsReset(totalUsage, prevTotals)) {
-      const resetUsage = hasLast ? lastUsage : totalUsage;
-      const normalized = normalizeUsage(resetUsage);
-      return isAllZeroUsage(normalized) ? null : normalized;
-    }
-
-    const delta = {};
-    for (const k of [
-      "input_tokens",
-      "cached_input_tokens",
-      "cache_creation_input_tokens",
-      "output_tokens",
-      "reasoning_output_tokens",
-      "total_tokens",
-    ]) {
-      const a = Number(totalUsage[k]);
-      const b = Number(prevTotals[k]);
-      if (Number.isFinite(a) && Number.isFinite(b)) delta[k] = Math.max(0, a - b);
-    }
-    const normalized = normalizeUsage(delta);
-    return isAllZeroUsage(normalized) ? null : normalized;
-  }
-
-  if (hasLast) {
-    const normalized = normalizeUsage(lastUsage);
-    return isAllZeroUsage(normalized) ? null : normalized;
-  }
-
-  if (hasTotal) {
-    const normalized = normalizeUsage(totalUsage);
-    return isAllZeroUsage(normalized) ? null : normalized;
-  }
-
-  return null;
-}
-
 function normalizeUsage(u) {
   const out = {};
   for (const k of [
@@ -3694,13 +3732,6 @@ function isAllZeroUsage(u) {
   return true;
 }
 
-function totalsReset(curr, prev) {
-  const currTotal = curr?.total_tokens;
-  const prevTotal = prev?.total_tokens;
-  if (!isFiniteNumber(currTotal) || !isFiniteNumber(prevTotal)) return false;
-  return currTotal < prevTotal;
-}
-
 function isFiniteNumber(v) {
   return typeof v === "number" && Number.isFinite(v);
 }
@@ -4046,6 +4077,349 @@ async function parseOpencodeDbIncremental({
   return { messagesProcessed, eventsAggregated, bucketsQueued, projectBucketsQueued };
 }
 
+const QODER_USAGE_SQL = `
+SELECT
+  cm.rowid AS row_id,
+  cm.id,
+  cm.session_id,
+  cm.request_id,
+  cm.token_info,
+  cm.model_info,
+  cm.gmt_create,
+  cr.extra AS record_extra,
+  cs.preferred_model_info,
+  cs.project_uri,
+  cs.project_name
+FROM chat_message AS cm
+LEFT JOIN chat_record AS cr ON cr.request_id = cm.request_id
+LEFT JOIN chat_session AS cs ON cs.session_id = cm.session_id
+WHERE cm.role = 'assistant'
+  AND cm.token_info IS NOT NULL
+  AND trim(cm.token_info) NOT IN ('', '{}')
+ORDER BY cm.gmt_create, cm.rowid
+`;
+
+function resolveQoderDbPath({
+  home = os.homedir(),
+  env = process.env,
+  platform = process.platform,
+} = {}) {
+  if (typeof env.QODER_DB_PATH === "string" && env.QODER_DB_PATH.trim()) {
+    return path.resolve(env.QODER_DB_PATH.trim());
+  }
+  let root;
+  if (typeof env.QODER_HOME === "string" && env.QODER_HOME.trim()) {
+    root = path.resolve(env.QODER_HOME.trim());
+  } else if (platform === "darwin") {
+    root = path.join(home, "Library", "Application Support", "Qoder");
+  } else if (platform === "win32") {
+    root = path.join(
+      env.APPDATA || path.join(home, "AppData", "Roaming"),
+      "Qoder",
+    );
+  } else {
+    root = path.join(home, ".config", "Qoder");
+  }
+  return path.join(root, "SharedClientCache", "cache", "db", "local.db");
+}
+
+function resolveQoderDbPaths({
+  home = os.homedir(),
+  env = process.env,
+  platform = process.platform,
+  deps = {},
+} = {}) {
+  const nativeValue = resolveQoderDbPath({ home, env, platform });
+  if (platform !== "win32" || env.QODER_DB_PATH || env.QODER_HOME) {
+    return { native: nativeValue, wsl: null };
+  }
+  const existsSync = deps.existsSync || fssync.existsSync;
+  const native = wsl.shouldProbeNative(env) && existsSync(nativeValue) ? nativeValue : null;
+  const discoverWslHome = deps.discoverWslHome || wsl.discoverWslHome;
+  const wslRoot = wsl.shouldProbeWsl(env)
+    ? discoverWslHome(".config/Qoder", { ...deps, env })
+    : null;
+  const wslValue = wslRoot
+    ? path.join(wslRoot, "SharedClientCache", "cache", "db", "local.db")
+    : null;
+  const wslDb = wslValue && existsSync(wslValue) ? wslValue : null;
+  return wsl.resolveAllWin32Paths({
+    nativeValue: native,
+    wslValue: wslDb,
+    env,
+    platform: "win32",
+  });
+}
+
+async function readQoderDbMessages(dbPath, sqliteOptions = {}) {
+  if (!dbPath || !fssync.existsSync(dbPath)) return [];
+  return readSqliteJsonRowsAsync(dbPath, QODER_USAGE_SQL, {
+    label: "Qoder",
+    ...sqliteOptions,
+  });
+}
+
+function parseJsonObject(value) {
+  if (!value) return null;
+  if (value && typeof value === "object" && !Buffer.isBuffer(value)) return value;
+  try {
+    const parsed = JSON.parse(String(value));
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch (_error) {
+    return null;
+  }
+}
+
+function normalizeQoderTokens(tokenInfo) {
+  const tokens = parseJsonObject(tokenInfo);
+  if (!tokens) return null;
+  const prompt = Number(tokens.prompt_tokens);
+  const cached = Number(tokens.cached_tokens || 0);
+  const completion = Number(tokens.completion_tokens);
+  if (
+    !Number.isFinite(prompt) ||
+    !Number.isFinite(cached) ||
+    !Number.isFinite(completion) ||
+    prompt < 0 ||
+    cached < 0 ||
+    completion < 0
+  ) {
+    return null;
+  }
+  // Qoder's prompt_tokens already includes cached_tokens. Keep cached input in
+  // its own column and report only the remainder as ordinary input, otherwise
+  // cached context is counted twice in dashboards and cost calculations.
+  const input = Math.max(0, Math.trunc(prompt) - Math.trunc(cached));
+  const cachedInput = Math.min(Math.trunc(prompt), Math.trunc(cached));
+  const output = Math.trunc(completion);
+  return {
+    input_tokens: input,
+    cached_input_tokens: cachedInput,
+    cache_creation_input_tokens: 0,
+    output_tokens: output,
+    reasoning_output_tokens: 0,
+    total_tokens: Math.trunc(prompt) + output,
+    billable_total_tokens: Math.trunc(prompt) + output,
+  };
+}
+
+function qoderModelFromRow(row) {
+  const direct = parseJsonObject(row?.model_info);
+  const recordExtra = parseJsonObject(row?.record_extra);
+  const preferred = parseJsonObject(row?.preferred_model_info);
+  return (
+    normalizeModelInput(direct?.model_key || direct?.modelKey) ||
+    normalizeModelInput(recordExtra?.modelConfig?.key || recordExtra?.model_config?.key) ||
+    normalizeModelInput(
+      preferred?.model_key ||
+      preferred?.modelKey ||
+      preferred?.preferred_model ||
+      preferred?.preferredModel,
+    ) ||
+    "qoder-agent"
+  );
+}
+
+function qoderMessageKey(row) {
+  const id = normalizeMessageKeyPart(row?.id);
+  const sessionId = normalizeMessageKeyPart(row?.session_id);
+  if (sessionId && id) return `${sessionId}|${id}`;
+  if (id) return id;
+  const rowId = row?.row_id;
+  return rowId === null || rowId === undefined ? null : `row:${rowId}`;
+}
+
+function qoderProjectPath(row) {
+  const raw = typeof row?.project_uri === "string" ? row.project_uri.trim() : "";
+  if (!raw) return null;
+  if (!raw.startsWith("file://")) return raw;
+  try {
+    return decodeURIComponent(new URL(raw).pathname);
+  } catch (_error) {
+    return null;
+  }
+}
+
+async function parseQoderDbIncremental({
+  dbMessages,
+  cursors,
+  queuePath,
+  projectQueuePath,
+  onProgress,
+  publicRepoResolver,
+} = {}) {
+  await ensureDir(path.dirname(queuePath));
+  const rows = Array.isArray(dbMessages) ? dbMessages : [];
+  const hourlyState = normalizeHourlyState(cursors?.hourly);
+  const qoderState = normalizeQoderState(cursors?.qoder);
+  const touchedBuckets = new Set();
+  const projectEnabled = typeof projectQueuePath === "string" && projectQueuePath.length > 0;
+  const projectState = projectEnabled ? normalizeProjectState(cursors?.projectHourly) : null;
+  const projectTouchedBuckets = projectEnabled ? new Set() : null;
+  const projectMetaCache = projectEnabled ? new Map() : null;
+  const publicRepoCache = projectEnabled ? new Map() : null;
+  const requestOwners = new Map();
+  for (const row of rows) {
+    const messageKey = qoderMessageKey(row);
+    if (
+      !messageKey ||
+      !normalizeQoderTokens(row?.token_info) ||
+      !coerceEpochMs(row?.gmt_create)
+    ) {
+      continue;
+    }
+    const requestKey =
+      normalizeMessageKeyPart(row?.request_id) ||
+      normalizeMessageKeyPart(row?.session_id) ||
+      messageKey;
+    if (!requestOwners.has(requestKey)) requestOwners.set(requestKey, messageKey);
+  }
+  const cb = typeof onProgress === "function" ? onProgress : null;
+  let messagesProcessed = 0;
+  let eventsAggregated = 0;
+
+  for (let index = 0; index < rows.length; index++) {
+    const row = rows[index];
+    const messageKey = qoderMessageKey(row);
+    const currentBase = normalizeQoderTokens(row?.token_info);
+    const timestampMs = coerceEpochMs(row?.gmt_create);
+    const bucketStart = timestampMs
+      ? toUtcHalfHourStart(new Date(timestampMs).toISOString())
+      : null;
+    if (!messageKey || !currentBase || !bucketStart) {
+      messagesProcessed += 1;
+      continue;
+    }
+
+    const requestKey =
+      normalizeMessageKeyPart(row?.request_id) ||
+      normalizeMessageKeyPart(row?.session_id) ||
+      messageKey;
+    const previous = qoderState.messages[messageKey];
+    // Recompute request ownership from the complete ordered DB snapshot on
+    // every pass. Qoder can attach token_info to an earlier assistant row only
+    // after a later row was already counted; retaining the old per-message
+    // owner in that case inflates one request to two conversations.
+    const conversationCount = requestOwners.get(requestKey) === messageKey ? 1 : 0;
+
+    const currentTotals = {
+      ...currentBase,
+      conversation_count: conversationCount,
+    };
+    const model = qoderModelFromRow(row);
+    let projectKey = null;
+    let projectRef = null;
+    if (projectEnabled) {
+      const projectPath = qoderProjectPath(row);
+      if (projectPath) {
+        const context = await resolveProjectContextForPath({
+          startDir: projectPath,
+          projectMetaCache,
+          publicRepoCache,
+          publicRepoResolver,
+          projectState,
+        });
+        projectKey = context?.projectKey || null;
+        projectRef = context?.projectRef || null;
+      }
+    }
+
+    const previousTotals =
+      previous?.totals && typeof previous.totals === "object" ? previous.totals : null;
+    const unchanged =
+      previousTotals &&
+      totalsKey(previousTotals) === totalsKey(currentTotals) &&
+      previous.bucketStart === bucketStart &&
+      previous.model === model &&
+      (previous.projectKey || null) === projectKey;
+    if (!unchanged) {
+      if (previousTotals && previous.bucketStart && previous.model) {
+        const oldBucket = getHourlyBucket(
+          hourlyState,
+          "qoder",
+          previous.model,
+          previous.bucketStart,
+        );
+        subtractTotals(oldBucket.totals, previousTotals);
+        touchedBuckets.add(bucketKey("qoder", previous.model, previous.bucketStart));
+        if (projectEnabled && previous.projectKey) {
+          const oldProjectBucket = getProjectBucket(
+            projectState,
+            previous.projectKey,
+            "qoder",
+            previous.bucketStart,
+            previous.projectRef || null,
+          );
+          subtractTotals(oldProjectBucket.totals, previousTotals);
+          projectTouchedBuckets.add(
+            projectBucketKey(previous.projectKey, "qoder", previous.bucketStart),
+          );
+        }
+      }
+
+      const bucket = getHourlyBucket(hourlyState, "qoder", model, bucketStart);
+      addTotals(bucket.totals, currentTotals);
+      touchedBuckets.add(bucketKey("qoder", model, bucketStart));
+      if (projectEnabled && projectKey) {
+        const projectBucket = getProjectBucket(
+          projectState,
+          projectKey,
+          "qoder",
+          bucketStart,
+          projectRef,
+        );
+        addTotals(projectBucket.totals, currentTotals);
+        projectTouchedBuckets.add(projectBucketKey(projectKey, "qoder", bucketStart));
+      }
+      qoderState.messages[messageKey] = {
+        totals: currentTotals,
+        conversationCount,
+        requestKey,
+        bucketStart,
+        model,
+        projectKey,
+        projectRef,
+        updatedAt: new Date().toISOString(),
+      };
+      eventsAggregated += 1;
+    }
+
+    messagesProcessed += 1;
+    if (cb) {
+      cb({
+        index: index + 1,
+        total: rows.length,
+        messagesProcessed,
+        eventsAggregated,
+        bucketsQueued: touchedBuckets.size,
+      });
+    }
+  }
+
+  const bucketsQueued = await enqueueTouchedBuckets({
+    queuePath,
+    hourlyState,
+    touchedBuckets,
+  });
+  const projectBucketsQueued = projectEnabled
+    ? await enqueueTouchedProjectBuckets({
+        projectQueuePath,
+        projectState,
+        projectTouchedBuckets,
+      })
+    : 0;
+  const updatedAt = new Date().toISOString();
+  hourlyState.updatedAt = updatedAt;
+  qoderState.updatedAt = updatedAt;
+  cursors.hourly = hourlyState;
+  cursors.qoder = qoderState;
+  if (projectState) {
+    projectState.updatedAt = updatedAt;
+    cursors.projectHourly = projectState;
+  }
+  return { messagesProcessed, eventsAggregated, bucketsQueued, projectBucketsQueued };
+}
+
 // Resolve project context from DB message (no file path available)
 async function resolveProjectContextForDb({
   msg,
@@ -4940,32 +5314,77 @@ function resolveKiroCliDbPath(env = process.env) {
 // no hyphens. kiro-cli writes proper UUIDs; lock to the canonical shape.
 const KIRO_CLI_SESSION_FILE_RE =
   /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.json$/i;
-
-// Lists ~/.kiro/sessions/cli/{uuid}.json files. Includes files whose sibling
-// .lock is present — we read those as tail-only snapshots so a running
-// session's completed turns still land in the queue on the next sync. The
-// .json files are rewritten atomically by kiro-cli on each turn flush, so
-// a stale read just means we'll pick up the rest next time.
+// The directory prefix and direct messages.jsonl child are the stable
+// contract. Do not assume the suffix will always remain a UUID: Kiro has
+// already changed this layout once, and an opaque non-empty session id is
+// sufficient to keep discovery both bounded and forward-compatible.
+const KIRO_CLI_V2_SESSION_DIR_RE = /^sess_.+$/;
+
+// Lists both Kiro CLI session layouts:
+//   legacy: ~/.kiro/sessions/cli/{uuid}.json
+//   2.13+:  ~/.kiro/sessions/{workspaceHash}/sess_{uuid}/messages.jsonl
+//
+// Legacy .json files are rewritten atomically per turn. The 2.13+ JSONL is
+// append-only and may be read while a session is active. Only the direct
+// messages.jsonl child is accepted; sub-executions and arbitrary nested JSONL
+// files are intentionally excluded.
 //
 // TASK-014: env.HOME is honored (symmetric with resolveKiroCliDbPath) so
 // callers can redirect to a tmp home for hermetic tests/CI.
 function resolveKiroCliSessionFiles(env = process.env) {
   const home = env.HOME || require("node:os").homedir();
   const kiroHome = env.KIRO_HOME || path.join(home, ".kiro");
-  const sessionsDir = path.join(kiroHome, "sessions", "cli");
-  if (!fssync.existsSync(sessionsDir)) return [];
+  const sessionsRoot = path.join(kiroHome, "sessions");
+  if (!fssync.existsSync(sessionsRoot)) return [];
   const files = [];
+
+  const legacyDir = path.join(sessionsRoot, "cli");
   try {
-    for (const entry of fssync.readdirSync(sessionsDir)) {
+    for (const entry of fssync.readdirSync(legacyDir)) {
       // TASK-003: only canonical {uuid}.json files; backups, scratch,
       // typos are skipped so they don't feed JSON.parse garbage.
       if (!KIRO_CLI_SESSION_FILE_RE.test(entry)) continue;
-      files.push(path.join(sessionsDir, entry));
+      files.push(path.join(legacyDir, entry));
     }
   } catch {
     // ignore read errors
   }
-  return files;
+
+  try {
+    const workspaceDirs = fssync.readdirSync(sessionsRoot, {
+      withFileTypes: true,
+    });
+    for (const workspace of workspaceDirs) {
+      if (!workspace.isDirectory() || workspace.name === "cli") continue;
+      const workspacePath = path.join(sessionsRoot, workspace.name);
+      let sessionDirs;
+      try {
+        sessionDirs = fssync.readdirSync(workspacePath, {
+          withFileTypes: true,
+        });
+      } catch {
+        continue;
+      }
+      for (const session of sessionDirs) {
+        if (
+          !session.isDirectory() ||
+          !KIRO_CLI_V2_SESSION_DIR_RE.test(session.name)
+        ) {
+          continue;
+        }
+        const messagesPath = path.join(
+          workspacePath,
+          session.name,
+          "messages.jsonl",
+        );
+        if (fssync.existsSync(messagesPath)) files.push(messagesPath);
+      }
+    }
+  } catch {
+    // ignore read errors
+  }
+
+  return files.sort();
 }
 
 // Build char-count maps from a .jsonl sibling file. Lets us approximate
@@ -5183,6 +5602,199 @@ async function readKiroCliSessionTurns(jsonPath) {
   return flat;
 }
 
+function kiroCliV2ContentChars(value) {
+  if (typeof value === "string") return value.length;
+  if (Array.isArray(value)) {
+    return value.reduce(
+      (sum, item) => sum + kiroCliV2ContentChars(item),
+      0,
+    );
+  }
+  if (!value || typeof value !== "object") return 0;
+  for (const key of ["content", "text", "value", "parts", "entries"]) {
+    if (value[key] !== undefined) {
+      return kiroCliV2ContentChars(value[key]);
+    }
+  }
+  return 0;
+}
+
+// Kiro CLI 2.13+ writes event-sourced sessions under
+// ~/.kiro/sessions/<workspaceHash>/sess_<uuid>/messages.jsonl. The records do
+// not carry token counts, but user/assistant text, turn boundaries, timestamps,
+// and assistant reasoningModelId are sufficient for the same 4 chars/token
+// approximation used by the legacy CLI reader.
+async function readKiroCliV2SessionTurns(messagesPath) {
+  if (
+    !messagesPath ||
+    path.basename(messagesPath) !== "messages.jsonl" ||
+    !fssync.existsSync(messagesPath)
+  ) {
+    return [];
+  }
+
+  const sessionDir = path.dirname(messagesPath);
+  let sessionMeta = {};
+  try {
+    sessionMeta = JSON.parse(
+      fssync.readFileSync(path.join(sessionDir, "session.json"), "utf8"),
+    );
+  } catch {
+    // messages.jsonl is self-contained enough to parse without session.json.
+  }
+
+  const sessionId =
+    typeof sessionMeta?.id === "string" && sessionMeta.id
+      ? sessionMeta.id
+      : path.basename(sessionDir);
+  const fallbackModel =
+    typeof sessionMeta?.modelId === "string" ? sessionMeta.modelId : null;
+  const fallbackTimestamp = Date.parse(
+    sessionMeta?.createdAt || sessionMeta?.lastModifiedAt || "",
+  );
+
+  const flat = [];
+  let stream;
+  try {
+    stream = fssync.createReadStream(messagesPath, { encoding: "utf8" });
+  } catch {
+    return flat;
+  }
+  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+  let pendingUserChars = 0;
+  let pendingUserTimestampMs = NaN;
+  let turn = null;
+  let fallbackTurnIndex = 0;
+
+  const flushTurn = () => {
+    if (!turn) return;
+    const hasUsage =
+      turn.outputChars > 0 ||
+      turn.reasoningChars > 0;
+    const tsMs = Number.isFinite(turn.timestampMs)
+      ? turn.timestampMs
+      : Number.isFinite(pendingUserTimestampMs)
+        ? pendingUserTimestampMs
+        : fallbackTimestamp;
+    if (hasUsage && Number.isFinite(tsMs) && tsMs > 0) {
+      const requestId =
+        turn.executionId ||
+        `${sessionId}:v2:${fallbackTurnIndex}`;
+      const messageIds = Array.from(turn.messageIds);
+      flat.push({
+        request_id: requestId,
+        message_id: messageIds[0] || turn.executionId || null,
+        all_message_ids: messageIds,
+        session_id: sessionId,
+        session_model_id: fallbackModel,
+        model_id: turn.modelId || fallbackModel,
+        request_start_timestamp_ms: tsMs,
+        user_prompt_length: turn.inputChars,
+        response_size: turn.outputChars,
+        reasoning_size: turn.reasoningChars,
+      });
+    }
+    fallbackTurnIndex++;
+    turn = null;
+  };
+
+  const startTurn = (payload, timestampMs) => {
+    flushTurn();
+    turn = {
+      executionId:
+        typeof payload?.executionId === "string" ? payload.executionId : null,
+      timestampMs:
+        Number.isFinite(timestampMs)
+          ? timestampMs
+          : pendingUserTimestampMs,
+      inputChars: pendingUserChars,
+      outputChars: 0,
+      reasoningChars: 0,
+      modelId: null,
+      messageIds: new Set(),
+    };
+    pendingUserChars = 0;
+    pendingUserTimestampMs = NaN;
+  };
+
+  try {
+    for await (const line of rl) {
+      if (!line || !line.trim()) continue;
+      let event;
+      try {
+        event = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const payload = event?.payload;
+      if (!payload || typeof payload !== "object") continue;
+      const type =
+        typeof payload.type === "string"
+          ? payload.type.toLowerCase()
+          : "";
+      const timestampMs = Date.parse(event.timestamp || "");
+
+      if (type === "user") {
+        if (turn) flushTurn();
+        pendingUserChars = kiroCliV2ContentChars(payload.content);
+        pendingUserTimestampMs = timestampMs;
+        continue;
+      }
+
+      if (type === "turn_start") {
+        startTurn(payload, timestampMs);
+        continue;
+      }
+
+      if (
+        ["assistant", "tool_call", "tool_result", "usage_summary"].includes(
+          type,
+        ) &&
+        !turn
+      ) {
+        startTurn(payload, timestampMs);
+      }
+      if (!turn) continue;
+
+      if (
+        typeof payload.executionId === "string" &&
+        payload.executionId &&
+        !turn.executionId
+      ) {
+        turn.executionId = payload.executionId;
+      }
+      if (typeof event.id === "string" && event.id) {
+        turn.messageIds.add(event.id);
+      }
+
+      if (type === "assistant") {
+        const chars = kiroCliV2ContentChars(payload.content);
+        if (
+          typeof payload.operationType === "string" &&
+          payload.operationType.toLowerCase() === "reasoning"
+        ) {
+          turn.reasoningChars += chars;
+        } else {
+          turn.outputChars += chars;
+        }
+        if (
+          typeof payload.reasoningModelId === "string" &&
+          payload.reasoningModelId
+        ) {
+          turn.modelId = payload.reasoningModelId;
+        }
+      } else if (type === "turn_end") {
+        flushTurn();
+      }
+    }
+  } catch {
+    // Return complete turns parsed before a concurrent truncate/delete.
+  }
+  flushTurn();
+  return flat;
+}
+
 // Canonicalize a Kiro-CLI-emitted model id so IDE and CLI rows collapse when
 // they refer to the same underlying Bedrock model. Examples:
 //   anthropic.claude-sonnet-4-20250514-v1:0  -> claude-sonnet-4
@@ -5202,6 +5814,7 @@ function canonicalizeKiroCliModelId(raw) {
   if (!name) return null;
   name = name.toLowerCase();
   if (name === "auto") return null;
+  name = name.replace(/^(?:qdev|kiro)::/, "");
   // Strip provider prefix (anthropic., aws., openai., or a full Bedrock ARN).
   name = name.replace(
     /^(?:arn:aws:bedrock:[^:]*:[^:]*:(?:foundation-model\/)?|anthropic\.|openai\.|aws\.)/,
@@ -5294,10 +5907,11 @@ async function parseKiroCliIncremental({ sessionFiles, cursors, queuePath, onPro
   const resolvedEnv = env || process.env;
   const dbPath = resolveKiroCliDbPath(resolvedEnv);
 
-  // Combine two sources under the same (source='kiro', cursors.kiroCli)
-  // namespace: historical rows from the SQLite DB plus live session state
-  // from ~/.kiro/sessions/cli/{uuid}.json (covers turns from a running
-  // session that hasn't flushed to SQLite yet). Request ID shapes differ:
+  // Combine three sources under the same (source='kiro', cursors.kiroCli)
+  // namespace: historical rows from the SQLite DB, legacy live session state
+  // from ~/.kiro/sessions/cli/{uuid}.json, and Kiro CLI 2.13+ event logs at
+  // ~/.kiro/sessions/<workspaceHash>/sess_<uuid>/messages.jsonl. Request ID
+  // shapes differ:
   // SQLite carries a persisted request_id UUID; session files synthesize
   // `${sessionId}:${loop_id.rand}`. When kiro-cli migrates a live session
   // into SQLite the same turn lands under a new request_id — the cross-
@@ -5309,8 +5923,11 @@ async function parseKiroCliIncremental({ sessionFiles, cursors, queuePath, onPro
     : [];
   const sessionFilesList = resolveKiroCliSessionFiles(resolvedEnv);
   let flatSessions = [];
-  for (const jsonPath of sessionFilesList) {
-    const turns = await readKiroCliSessionTurns(jsonPath);
+  for (const sessionPath of sessionFilesList) {
+    const turns =
+      path.basename(sessionPath) === "messages.jsonl"
+        ? await readKiroCliV2SessionTurns(sessionPath)
+        : await readKiroCliSessionTurns(sessionPath);
     for (const turn of turns) flatSessions.push(turn);
   }
   // Per-request state replaces the old seenIds set. Each entry captures
@@ -5382,7 +5999,14 @@ async function parseKiroCliIncremental({ sessionFiles, cursors, queuePath, onPro
       toRetract.push([reqId, prev, sid]);
     }
     for (const [reqId, prev, sid] of toRetract) {
-      if (prev.input_tokens || prev.output_tokens) {
+      if (
+        prev.input_tokens ||
+        prev.output_tokens ||
+        prev.reasoning_output_tokens
+      ) {
+        const prevReasoning = toNonNegativeInt(
+          prev.reasoning_output_tokens,
+        );
         const prevBucket = getHourlyBucket(
           hourlyState,
           "kiro",
@@ -5394,8 +6018,12 @@ async function parseKiroCliIncremental({ sessionFiles, cursors, queuePath, onPro
           cached_input_tokens: 0,
           cache_creation_input_tokens: 0,
           output_tokens: -prev.output_tokens,
-          reasoning_output_tokens: 0,
-          total_tokens: -(prev.input_tokens + prev.output_tokens),
+          reasoning_output_tokens: -prevReasoning,
+          total_tokens: -(
+            prev.input_tokens +
+            prev.output_tokens +
+            prevReasoning
+          ),
           conversation_count: -1,
         });
         touchedBuckets.add(bucketKey("kiro", prev.model, prev.bucketStart));
@@ -5488,8 +6116,12 @@ async function parseKiroCliIncremental({ sessionFiles, cursors, queuePath, onPro
 
     const promptChars = toNonNegativeInt(r.user_prompt_length);
     const responseChars = toNonNegativeInt(r.response_size);
+    const reasoningChars = toNonNegativeInt(r.reasoning_size);
     const approxInput = Math.floor(promptChars / KIRO_CLI_CHARS_PER_TOKEN);
     const approxOutput = Math.floor(responseChars / KIRO_CLI_CHARS_PER_TOKEN);
+    const approxReasoning = Math.floor(
+      reasoningChars / KIRO_CLI_CHARS_PER_TOKEN,
+    );
 
     const tsMs = Number(r.request_start_timestamp_ms);
     if (!Number.isFinite(tsMs) || tsMs <= 0) continue;
@@ -5502,37 +6134,52 @@ async function parseKiroCliIncremental({ sessionFiles, cursors, queuePath, onPro
     const model = canonical || "kiro-cli-agent";
 
     // Fingerprint captures every field whose change should cause a re-bucket.
-    const fingerprint = `${promptChars}:${responseChars}:${model}:${tsMs}`;
+    const fingerprint =
+      `${promptChars}:${responseChars}:${reasoningChars}:${model}:${tsMs}`;
     const prev = requestState[requestId];
     if (prev && prev.fingerprint === fingerprint) continue; // unchanged
 
     // Subtract the prior contribution (if any) from its prior bucket so the
     // bucket's absolute totals reflect the CURRENT truth, not the historical
     // truth. enqueueTouchedBuckets will emit the net delta at flush time.
-    if (prev && (prev.input_tokens || prev.output_tokens)) {
+    if (
+      prev &&
+      (
+        prev.input_tokens ||
+        prev.output_tokens ||
+        prev.reasoning_output_tokens
+      )
+    ) {
+      const prevReasoning = toNonNegativeInt(
+        prev.reasoning_output_tokens,
+      );
       const prevBucket = getHourlyBucket(hourlyState, "kiro", prev.model, prev.bucketStart);
       addTotals(prevBucket.totals, {
         input_tokens: -prev.input_tokens,
         cached_input_tokens: 0,
         cache_creation_input_tokens: 0,
         output_tokens: -prev.output_tokens,
-        reasoning_output_tokens: 0,
-        total_tokens: -(prev.input_tokens + prev.output_tokens),
+        reasoning_output_tokens: -prevReasoning,
+        total_tokens: -(
+          prev.input_tokens +
+          prev.output_tokens +
+          prevReasoning
+        ),
         conversation_count: -1,
       });
       touchedBuckets.add(bucketKey("kiro", prev.model, prev.bucketStart));
     }
 
     // Add the new contribution.
-    if (approxInput > 0 || approxOutput > 0) {
+    if (approxInput > 0 || approxOutput > 0 || approxReasoning > 0) {
       const bucket = getHourlyBucket(hourlyState, "kiro", model, bucketStart);
       addTotals(bucket.totals, {
         input_tokens: approxInput,
         cached_input_tokens: 0,
         cache_creation_input_tokens: 0,
         output_tokens: approxOutput,
-        reasoning_output_tokens: 0,
-        total_tokens: approxInput + approxOutput,
+        reasoning_output_tokens: approxReasoning,
+        total_tokens: approxInput + approxOutput + approxReasoning,
         conversation_count: 1,
       });
       touchedBuckets.add(bucketKey("kiro", model, bucketStart));
@@ -5551,6 +6198,7 @@ async function parseKiroCliIncremental({ sessionFiles, cursors, queuePath, onPro
       model,
       input_tokens: approxInput,
       output_tokens: approxOutput,
+      reasoning_output_tokens: approxReasoning,
       ...(r.session_id ? { session_id: r.session_id } : {}),
     };
 
@@ -13586,6 +14234,9 @@ module.exports = {
   readOpencodeDbMessages,
   readMimoDbMessages,
   readZcodeDbMessages,
+  resolveQoderDbPath,
+  resolveQoderDbPaths,
+  readQoderDbMessages,
   resolveKiroDbPath,
   resolveKiroJsonlPath,
   resolveHermesPath,
@@ -13610,6 +14261,7 @@ module.exports = {
   parseGeminiIncremental,
   parseOpencodeIncremental,
   parseOpencodeDbIncremental,
+  parseQoderDbIncremental,
   openclawCursorKey,
   parseOpenclawIncremental,
   parseCursorApiIncremental,
@@ -13697,6 +14349,7 @@ module.exports = {
   // Exposed for regression tests covering cache-token accounting.
   normalizeGeminiTokens,
   normalizeOpencodeTokens,
+  normalizeQoderTokens,
   sameGeminiTotals,
   diffGeminiTotals,
   // Exposed so the queue-repair migration can mutate cursors state in the