tokentracker-cli 0.5.72 → 0.5.73

package/README.md

@@ -143,6 +143,15 @@ Upgrade with `brew upgrade --cask mm7894215/tokentracker/tokentracker`. The tap
 | **GitHub Copilot** | ✅ Auto | OpenTelemetry file exporter (`COPILOT_OTEL_FILE_EXPORTER_PATH`) |
 | **Kimi Code** | ✅ Auto | Passive `wire.jsonl` reader (`~/.kimi/sessions/**/wire.jsonl`) |
 
+> **Do I need to install any plugin or hook manually?** No. `tokentracker` (or `tokentracker init`) handles everything on first run:
+> - **Hook-based** tools (Claude Code, Codex, Gemini, Every Code) — we write a SessionEnd hook or TOML notify entry into the tool's own config.
+> - **Plugin-based** tools (OpenCode, **OpenClaw**) — the plugin ships inside the npm package (`~/.tokentracker/app/openclaw-plugin/`). We link it via the tool's own CLI (`openclaw plugins install --link …` + `enable`). No download, no drag-and-drop.
+> - **Passive readers** (Cursor, Kiro, Hermes, Kimi Code, Copilot) — nothing is installed into those tools. We only read files they already produce (SQLite DB, JSONL, OTEL export).
+>
+> Run `tokentracker status` anytime to verify every integration's state. If something shows `skipped`, the `detail` column explains why (e.g. tool CLI not on `PATH`, config unreadable).
+>
+> Deeper dives: [OpenClaw integration & troubleshooting](docs/openclaw-integration.md).
+
 Missing your tool? [Open an issue](https://github.com/mm7894215/TokenTracker/issues/new) — adding new providers is usually one parser file away.
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokentracker-cli",
-  "version": "0.5.72",
+  "version": "0.5.73",
   "description": "Token usage tracker for AI agent CLIs (Claude Code, Codex, Cursor, Kiro, Gemini, OpenCode, OpenClaw, Hermes, GitHub Copilot)",
   "main": "src/cli.js",
   "bin": {

package/src/commands/status.js

@@ -20,7 +20,7 @@ const { collectTrackerDiagnostics } = require("../lib/diagnostics");
 const { probeOpenclawHookState } = require("../lib/openclaw-hook");
 const { probeOpenclawSessionPluginState } = require("../lib/openclaw-session-plugin");
 const { resolveTrackerPaths } = require("../lib/tracker-paths");
-const { resolveKimiWireFiles } = require("../lib/rollout");
+const { resolveKimiWireFiles, resolveKiroCliDbPath } = require("../lib/rollout");
 
 async function cmdStatus(argv = []) {
   const opts = parseArgs(argv);
@@ -118,6 +118,13 @@ async function cmdStatus(argv = []) {
   const kimiHome = process.env.KIMI_HOME || path.join(home, ".kimi");
   const kimiInstalled = fssync.existsSync(path.join(kimiHome, "sessions"));
 
+  // Kiro CLI — reads from SQLite at
+  // ~/Library/Application Support/kiro-cli/data.sqlite3. End-user dashboards
+  // show CLI and IDE merged under a single "Kiro" brand; this status line
+  // surfaces the CLI sub-path separately for operators.
+  const kiroCliDbPath = resolveKiroCliDbPath(process.env);
+  const kiroCliInstalled = fssync.existsSync(kiroCliDbPath);
+
   const copilotToken = readCopilotOauthToken({ home });
   const copilotOtel = describeCopilotOtelStatus({ home, env: process.env });
   const copilotLines = formatCopilotLines({ token: copilotToken, otel: copilotOtel });
@@ -147,6 +154,9 @@ async function cmdStatus(argv = []) {
       kimiInstalled
         ? `- Kimi Code: passive reader (${kimiWireFiles.length} wire.jsonl file${kimiWireFiles.length !== 1 ? "s" : ""} found)`
         : null,
+      kiroCliInstalled
+        ? `- Kiro CLI: SQLite data.sqlite3 found (tokens approximated from char lengths, merged under 'kiro' source)`
+        : null,
       ...copilotLines,
       ...subscriptionLines,
       "",

package/src/commands/sync.js

@@ -27,6 +27,9 @@ const {
   parseCopilotIncremental,
   resolveKimiWireFiles,
   parseKimiIncremental,
+  resolveKiroCliSessionFiles,
+  resolveKiroCliDbPath,
+  parseKiroCliIncremental,
 } = require("../lib/rollout");
 const { createProgress, renderBar, formatNumber, formatBytes } = require("../lib/progress");
 const {
@@ -359,6 +362,40 @@ async function cmdSync(argv) {
       });
     }
 
+    // ── Kiro CLI (reads ~/Library/Application Support/kiro-cli/data.sqlite3
+    //    AND live sessions under ~/.kiro/sessions/cli/{uuid}.json) ──
+    // Runs IN PARALLEL with the Kiro IDE branch above — NOT instead of it.
+    // Both emit source='kiro' so totals merge transparently; cursor state
+    // is isolated in cursors.kiroCli. Kiro CLI does not persist explicit
+    // token counts (billing is credit-based on Bedrock); we approximate at
+    // 4 chars/token from user prompt chars and assistant response chars.
+    let kiroCliResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+    const kiroCliDb = resolveKiroCliDbPath(process.env);
+    const kiroCliSessionFiles = resolveKiroCliSessionFiles(process.env);
+    if (fssync.existsSync(kiroCliDb) || kiroCliSessionFiles.length > 0) {
+      if (progress?.enabled) {
+        progress.start(`Parsing Kiro CLI ${renderBar(0)} | buckets 0`);
+      }
+      try {
+        kiroCliResult = await parseKiroCliIncremental({
+          cursors,
+          queuePath,
+          env: process.env,
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing Kiro CLI ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} convs | buckets ${formatNumber(p.bucketsQueued)}`,
+            );
+          },
+        });
+      } catch (err) {
+        if (!opts.auto) {
+          process.stderr.write(`Kiro CLI sync: ${err.message}\n`);
+        }
+      }
+    }
+
     // ── Kimi (passive wire.jsonl reader) ──
     let kimiResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
     const kimiWireFiles = resolveKimiWireFiles(process.env);
@@ -496,6 +533,7 @@ async function cmdSync(argv) {
         opencodeResult.filesProcessed +
         cursorResult.recordsProcessed +
         kiroResult.recordsProcessed +
+        kiroCliResult.recordsProcessed +
         hermesResult.recordsProcessed +
         kimiResult.recordsProcessed +
         copilotResult.recordsProcessed;
@@ -507,6 +545,7 @@ async function cmdSync(argv) {
         opencodeResult.bucketsQueued +
         cursorResult.bucketsQueued +
         kiroResult.bucketsQueued +
+        kiroCliResult.bucketsQueued +
         hermesResult.bucketsQueued +
         kimiResult.bucketsQueued +
         copilotResult.bucketsQueued;

package/src/lib/diagnostics.js

@@ -16,6 +16,7 @@ const { normalizeState: normalizeUploadState } = require("./upload-throttle");
 const { probeOpenclawHookState } = require("./openclaw-hook");
 const { probeOpenclawSessionPluginState } = require("./openclaw-session-plugin");
 const { resolveTrackerPaths } = require("./tracker-paths");
+const { resolveKiroCliDbPath } = require("./rollout");
 
 async function collectTrackerDiagnostics({
   home = os.homedir(),
@@ -81,6 +82,25 @@ async function collectTrackerDiagnostics({
   });
   const openclawHookState = await probeOpenclawHookState({ home, trackerDir, env: process.env });
 
+  // Kiro IDE and Kiro CLI sub-path presence — merged under one "kiro" source
+  // at token/cost aggregation level; operators need visibility of both
+  // sub-paths here for debugging.
+  const kiroIdeDevDataDir = path.join(
+    home,
+    "Library",
+    "Application Support",
+    "Kiro",
+    "User",
+    "globalStorage",
+    "kiro.kiroagent",
+    "dev_data",
+  );
+  const kiroIdePresent =
+    (await safeStatSize(path.join(kiroIdeDevDataDir, "devdata.sqlite"))) > 0 ||
+    (await safeStatSize(path.join(kiroIdeDevDataDir, "tokens_generated.jsonl"))) > 0;
+  const kiroCliDbPath = resolveKiroCliDbPath(process.env);
+  const kiroCliPresent = require("node:fs").existsSync(kiroCliDbPath);
+
   const lastSuccessAt = uploadThrottle.lastSuccessMs
     ? new Date(uploadThrottle.lastSuccessMs).toISOString()
     : null;
@@ -104,6 +124,16 @@ async function collectTrackerDiagnostics({
       claude_config: redactValue(claudeConfigPath, home),
       gemini_config: redactValue(geminiSettingsPath, home),
       opencode_config: redactValue(opencodeConfigDir, home),
+      kiro_ide_dev_data: redactValue(kiroIdeDevDataDir, home),
+      kiro_cli_db: redactValue(kiroCliDbPath, home),
+    },
+    kiro: {
+      ide_present: kiroIdePresent,
+      cli_present: kiroCliPresent,
+      cli_approximation:
+        "Kiro CLI does not persist explicit token counts (billing is credit-based on Bedrock). Tokens are approximated at 4 chars/token from user prompt chars and assistant response chars. Source rows that came through this path have model='kiro-cli-agent' when the underlying model is unknown (auto-routing); known Bedrock ARNs canonicalize to their short name (e.g. claude-sonnet-4).",
+      merge_policy:
+        "Kiro IDE and Kiro CLI both emit source='kiro' in queue.jsonl so token, cost, heatmap, and leaderboard aggregations merge transparently. Use this block to distinguish sub-path contributions.",
     },
     config: {
       base_url: typeof config?.baseUrl === "string" ? config.baseUrl : null,

package/src/lib/local-api.js

@@ -63,6 +63,14 @@ const MODEL_PRICING = {
   "kimi-for-coding": { input: 0.6, output: 2, cache_read: 0.15 },
   "kimi-k2.5": { input: 0.6, output: 2, cache_read: 0.15 },
   "kimi-k2.5-free": { input: 0, output: 0, cache_read: 0 },
+  // ── AWS Kiro (Kiro IDE + Kiro CLI — both route through Bedrock, most
+  //    commonly claude-sonnet-4; rates mirror the sonnet-4 table below so
+  //    costs stay consistent with the real underlying model when a Bedrock
+  //    model_id isn't exposed). Mirrored byte-for-byte in
+  //    dashboard/edge-patches/tokentracker-leaderboard-refresh.ts for
+  //    leaderboard estimated_cost_usd. ──
+  "kiro-agent": { input: 3, output: 15, cache_read: 0.3, cache_write: 3.75 },
+  "kiro-cli-agent": { input: 3, output: 15, cache_read: 0.3, cache_write: 3.75 },
   // ── Misc / Free ──
   "glm-4.7-free": { input: 0, output: 0, cache_read: 0 },
   "nemotron-3-super-free": { input: 0, output: 0, cache_read: 0 },
@@ -90,6 +98,7 @@ function getModelPricing(model) {
   if (lower.includes("gemini-3")) return MODEL_PRICING["gemini-3-flash-preview"];
   if (lower.includes("gemini-2.5")) return MODEL_PRICING["gemini-2.5-pro"];
   if (lower.includes("kimi")) return MODEL_PRICING["kimi-k2.5"];
+  if (lower.includes("kiro")) return MODEL_PRICING["kiro-cli-agent"];
   if (lower.includes("composer")) return MODEL_PRICING["composer-1"];
   if (lower === "auto") return MODEL_PRICING["composer-1"];
   return ZERO_PRICING;
@@ -1061,4 +1070,11 @@ function createLocalApiHandler({ queuePath }) {
   };
 }
 
-module.exports = { createLocalApiHandler, resolveQueuePath };
+module.exports = {
+  createLocalApiHandler,
+  resolveQueuePath,
+  // Exported for cross-consumer tests (pricing + native contract lock).
+  MODEL_PRICING,
+  getModelPricing,
+  computeRowCost,
+};

package/src/lib/rollout.js

@@ -3065,6 +3065,625 @@ function resolveKimiDefaultModel(env = process.env) {
 }
 // ─────────────────────────────────────────────────────────────────────────────
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Kiro CLI — reads historical conversation state from
+// ~/Library/Application Support/kiro-cli/data.sqlite3 (table conversations_v2).
+// Kiro CLI does NOT store explicit token counts locally. Each request row
+// carries: user_prompt_length (chars), response_size (chars), model_id,
+// request_start_timestamp_ms, message_id. We approximate tokens at 4 chars /
+// token. Source is merged with Kiro IDE (source='kiro') and canonicalized
+// model names are used so CLI and IDE rows collapse when they refer to the
+// same underlying Bedrock model. Cursor state is per-request-id so mutable
+// requests can be reprocessed (subtract-old/add-new on fingerprint change).
+// ─────────────────────────────────────────────────────────────────────────────
+
+const KIRO_CLI_CHARS_PER_TOKEN = 4;
+
+function resolveKiroCliDbPath(env = process.env) {
+  if (env.KIRO_CLI_DB_PATH) return env.KIRO_CLI_DB_PATH;
+  const home = env.HOME || require("node:os").homedir();
+  return path.join(home, "Library", "Application Support", "kiro-cli", "data.sqlite3");
+}
+
+// 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.
+function resolveKiroCliSessionFiles(env = process.env) {
+  const 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 files = [];
+  try {
+    for (const entry of fssync.readdirSync(sessionsDir)) {
+      if (!entry.endsWith(".json")) continue;
+      files.push(path.join(sessionsDir, entry));
+    }
+  } catch {
+    // ignore read errors
+  }
+  return files;
+}
+
+// Build char-count maps from a .jsonl sibling file. Lets us approximate
+// per-turn tokens when the live session's input_token_count /
+// output_token_count fields are 0 (kiro-cli does not persist real token
+// counts; billing is credit-based).
+//
+// Returns:
+//   byMessage:       message_id -> assistant+toolUse char count
+//   messageKind:     message_id -> jsonl event kind
+//   turnPromptChars: turn_index -> input chars attributed to that turn
+//
+// Input attribution: Kiro CLI's turn.message_ids only records
+// AssistantMessage / ToolResults ids, NEVER the user Prompt id. So the
+// Prompt event is invisible if you look it up by message_id. To recover
+// the per-turn user input, we walk the jsonl in timestamp order and buffer
+// Prompt chars until the next AssistantMessage that belongs to a turn
+// (turnMessageIds provides that mapping). The first such AssistantMessage
+// "claims" the buffered Prompt chars for its turn, and the buffer resets.
+// Later cycles within the same turn (Assistant → ToolResults → Assistant)
+// do not re-attribute.
+function readKiroCliMessageChars(jsonlPath, turnMessageIds) {
+  const result = {
+    byMessage: new Map(),
+    messageKind: new Map(),
+    turnPromptChars: new Map(),
+  };
+  if (!jsonlPath || !fssync.existsSync(jsonlPath)) return result;
+  let raw;
+  try {
+    raw = fssync.readFileSync(jsonlPath, "utf8");
+  } catch {
+    return result;
+  }
+  const midToTurn =
+    turnMessageIds instanceof Map ? turnMessageIds : new Map();
+  const attributedTurns = new Set();
+  let pendingPromptChars = 0;
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    let evt;
+    try {
+      evt = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const data = evt?.data;
+    if (!data || typeof data !== "object") continue;
+    const mid = data.message_id;
+    if (!mid) continue;
+    const content = Array.isArray(data.content) ? data.content : [];
+    let chars = 0;
+    for (const c of content) {
+      if (!c || typeof c !== "object") continue;
+      if (c.kind === "text" && typeof c.data === "string") {
+        chars += c.data.length;
+      } else if (c.kind === "toolUse" && c.data && typeof c.data === "object") {
+        // tool-use invocations count toward output; stringify the input payload
+        try {
+          chars += JSON.stringify(c.data.input || {}).length;
+        } catch {
+          // ignore
+        }
+      }
+    }
+    result.byMessage.set(mid, (result.byMessage.get(mid) || 0) + chars);
+    if (!result.messageKind.has(mid)) result.messageKind.set(mid, evt.kind);
+
+    if (evt.kind === "Prompt") {
+      pendingPromptChars += chars;
+    } else if (evt.kind === "AssistantMessage" && midToTurn.has(mid)) {
+      const turnIdx = midToTurn.get(mid);
+      if (!attributedTurns.has(turnIdx)) {
+        result.turnPromptChars.set(turnIdx, pendingPromptChars);
+        attributedTurns.add(turnIdx);
+        pendingPromptChars = 0;
+      }
+    }
+  }
+  return result;
+}
+
+// Extract flat per-turn records from a live session .json + its .jsonl
+// sibling. Returns [{ request_id, model_id, request_start_timestamp_ms,
+// input_tokens, output_tokens }]. We use the same request_id dedup slot as
+// the SQLite path so mutations (turn rewritten on next flush) go through
+// the subtract-old/add-new path in parseKiroCliIncremental.
+function readKiroCliSessionTurns(jsonPath) {
+  if (!jsonPath || !fssync.existsSync(jsonPath)) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(fssync.readFileSync(jsonPath, "utf8"));
+  } catch {
+    return [];
+  }
+  if (!parsed || typeof parsed !== "object") return [];
+  const turns = Array.isArray(
+    parsed?.session_state?.conversation_metadata?.user_turn_metadatas,
+  )
+    ? parsed.session_state.conversation_metadata.user_turn_metadatas
+    : [];
+  if (turns.length === 0) return [];
+
+  const modelInfo = parsed?.session_state?.rts_model_state?.model_info || null;
+  const sessionModelId =
+    (modelInfo && (modelInfo.model_id || modelInfo.model_name)) || null;
+  const sessionId =
+    typeof parsed.session_id === "string" ? parsed.session_id : path.basename(jsonPath, ".json");
+
+  // Build turn_index -> Set(message_id) so the jsonl walker can attribute
+  // orphaned Prompt events (not referenced by turn.message_ids) to the
+  // right turn. The turn.message_ids list only contains AssistantMessage
+  // and ToolResults ids; Prompt ids appear in the jsonl stream only.
+  const turnMessageIds = new Map();
+  for (let i = 0; i < turns.length; i++) {
+    const t = turns[i];
+    if (!t || !Array.isArray(t.message_ids)) continue;
+    for (const mid of t.message_ids) {
+      if (typeof mid === "string" && mid) turnMessageIds.set(mid, i);
+    }
+  }
+
+  // Load sibling .jsonl for char-count fallback.
+  const jsonlPath = jsonPath.replace(/\.json$/, ".jsonl");
+  const charMap = readKiroCliMessageChars(jsonlPath, turnMessageIds);
+
+  const flat = [];
+  for (let turnIdx = 0; turnIdx < turns.length; turnIdx++) {
+    const turn = turns[turnIdx];
+    if (!turn || typeof turn !== "object") continue;
+    const loopRand =
+      (turn.loop_id && (turn.loop_id.rand ?? turn.loop_id.seed)) || null;
+    const messageIds = Array.isArray(turn.message_ids) ? turn.message_ids : [];
+    const requestId = loopRand != null ? `${sessionId}:${loopRand}` : (messageIds[0] || null);
+    if (!requestId) continue;
+
+    // Prefer real token counts if kiro-cli populated them.
+    let inputTokens = toNonNegativeInt(turn.input_token_count);
+    let outputTokens = toNonNegativeInt(turn.output_token_count);
+
+    if (inputTokens === 0 && outputTokens === 0) {
+      // Fall back to char-count approximation. Input chars come from the
+      // sequential Prompt attribution (see readKiroCliMessageChars);
+      // output chars come from AssistantMessage+toolUse bodies referenced
+      // by turn.message_ids.
+      const promptChars = charMap.turnPromptChars.get(turnIdx) || 0;
+      let assistantChars = 0;
+      for (const mid of messageIds) {
+        const chars = charMap.byMessage.get(mid) || 0;
+        const kind = charMap.messageKind.get(mid);
+        if (kind === "AssistantMessage") assistantChars += chars;
+      }
+      inputTokens = Math.floor(promptChars / KIRO_CLI_CHARS_PER_TOKEN);
+      outputTokens = Math.floor(assistantChars / KIRO_CLI_CHARS_PER_TOKEN);
+    }
+
+    // Timestamp: end_timestamp is an ISO string; coerce to ms.
+    const tsRaw = turn.end_timestamp || turn.start_timestamp;
+    const tsMs = tsRaw ? Date.parse(tsRaw) : NaN;
+    if (!Number.isFinite(tsMs) || tsMs <= 0) continue;
+
+    flat.push({
+      request_id: requestId,
+      session_model_id: sessionModelId,
+      message_id: messageIds[0] || null,
+      model_id: turn.model_id || sessionModelId,
+      request_start_timestamp_ms: tsMs,
+      // For the parser, we feed the ALREADY-approximated tokens directly via
+      // a special sentinel field. The parser will divide chars by
+      // KIRO_CLI_CHARS_PER_TOKEN; bypass that by pre-multiplying here.
+      user_prompt_length: inputTokens * KIRO_CLI_CHARS_PER_TOKEN,
+      response_size: outputTokens * KIRO_CLI_CHARS_PER_TOKEN,
+    });
+  }
+  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
+//   claude-opus-4.6                           -> claude-opus-4.6
+//   claude-sonnet-4.5                         -> claude-sonnet-4.5
+//   auto                                      -> null (caller uses 'kiro-cli-agent')
+//   <unknown/falsy>                           -> null (caller falls back to 'kiro-cli-agent')
+//
+// "auto" is treated as unknown because Kiro CLI's auto-routing does not
+// expose the underlying Bedrock model id in the session file. Returning
+// null lets pricing fall into the kiro-cli-agent bucket (sonnet-4 rates)
+// rather than the literal "auto" string which matches Cursor's composer-1
+// pricing by accident.
+function canonicalizeKiroCliModelId(raw) {
+  if (!raw || typeof raw !== "string") return null;
+  let name = raw.trim();
+  if (!name) return null;
+  name = name.toLowerCase();
+  if (name === "auto") return null;
+  // Strip provider prefix (anthropic., aws., openai., or a full Bedrock ARN).
+  name = name.replace(
+    /^(?:arn:aws:bedrock:[^:]*:[^:]*:(?:foundation-model\/)?|anthropic\.|openai\.|aws\.)/,
+    "",
+  );
+  // Strip Bedrock revision suffix `:N`.
+  name = name.replace(/:\d+$/, "");
+  // Strip date + vN suffix (e.g. "-20250514-v1"), or lone "-vN", or lone date.
+  name = name.replace(/-\d{8}-v\d+$/i, "");
+  name = name.replace(/-v\d+$/i, "");
+  name = name.replace(/-\d{8}$/, "");
+  // Strip trailing ".v1" or similar Anthropic-on-Bedrock tails if present.
+  name = name.replace(/\.v\d+$/i, "");
+  return name || null;
+}
+
+// Read Kiro CLI requests using SQL-side json_extract so we don't pull the
+// full (93 MB-ish) conversations_v2 blob back through sqlite3 -json.
+function readKiroCliRequests(dbPath) {
+  if (!dbPath || !fssync.existsSync(dbPath)) return [];
+  let raw;
+  try {
+    raw = cp.execFileSync(
+      "sqlite3",
+      [
+        "-json",
+        dbPath,
+        "SELECT conversation_id, " +
+          "json_extract(value, '$.model_info.model_id') AS session_model_id, " +
+          "json_extract(value, '$.user_turn_metadata.requests') AS requests_json " +
+          "FROM conversations_v2 " +
+          "WHERE json_extract(value, '$.user_turn_metadata.requests') IS NOT NULL",
+      ],
+      { encoding: "utf8", maxBuffer: 128 * 1024 * 1024, timeout: 120_000 },
+    );
+  } catch {
+    return [];
+  }
+  if (!raw || !raw.trim()) return [];
+  let rows;
+  try {
+    rows = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(rows)) return [];
+  const flat = [];
+  for (const row of rows) {
+    let requests;
+    try {
+      requests = JSON.parse(row.requests_json || "[]");
+    } catch {
+      continue;
+    }
+    if (!Array.isArray(requests)) continue;
+    for (const r of requests) {
+      if (!r || typeof r !== "object") continue;
+      flat.push({
+        conversation_id: row.conversation_id,
+        session_model_id: row.session_model_id || null,
+        request_id: r.request_id || null,
+        message_id: r.message_id || null,
+        user_prompt_length: r.user_prompt_length,
+        response_size: r.response_size,
+        model_id: r.model_id || null,
+        request_start_timestamp_ms: r.request_start_timestamp_ms,
+      });
+    }
+  }
+  return flat;
+}
+
+async function parseKiroCliIncremental({ sessionFiles, cursors, queuePath, onProgress, env } = {}) {
+  await ensureDir(path.dirname(queuePath));
+  const kiroCliState =
+    cursors.kiroCli && typeof cursors.kiroCli === "object" ? cursors.kiroCli : {};
+  const seenIds = new Set(Array.isArray(kiroCliState.seenIds) ? kiroCliState.seenIds : []);
+
+  // Back-compat branch: if caller explicitly passes sessionFiles (an array of
+  // per-session .json paths, the old contract used in tests/fixtures), read
+  // them as user_turn_metadatas. New default path below reads the SQLite DB.
+  if (Array.isArray(sessionFiles)) {
+    return parseKiroCliFromSessionFiles({
+      sessionFiles,
+      cursors,
+      queuePath,
+      onProgress,
+      env,
+      kiroCliState,
+      seenIds,
+    });
+  }
+
+  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 IDs are disjoint
+  // (SQLite uses request_id UUID; sessions use {sessionId}:{loop_id.rand}),
+  // so no cross-source dedup is needed.
+  const flatDb = fssync.existsSync(dbPath) ? readKiroCliRequests(dbPath) : [];
+  const sessionFilesList = resolveKiroCliSessionFiles(resolvedEnv);
+  const flatSessions = [];
+  for (const jsonPath of sessionFilesList) {
+    for (const turn of readKiroCliSessionTurns(jsonPath)) {
+      flatSessions.push(turn);
+    }
+  }
+  const flat = flatDb.concat(flatSessions);
+  // Per-request state replaces the old seenIds set. Each entry captures
+  // what we contributed for that request_id last time, so a later mutation
+  // (same request_id, different fingerprint) can subtract-old/add-new
+  // instead of being skipped forever.
+  const requestState =
+    kiroCliState.requests && typeof kiroCliState.requests === "object"
+      ? { ...kiroCliState.requests }
+      : {};
+
+  if (flat.length === 0) {
+    cursors.kiroCli = {
+      ...kiroCliState,
+      requests: requestState,
+      updatedAt: new Date().toISOString(),
+    };
+    return { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+  }
+
+  const hourlyState = normalizeHourlyState(cursors?.hourly);
+  const touchedBuckets = new Set();
+  const cb = typeof onProgress === "function" ? onProgress : null;
+  let recordsProcessed = 0;
+  let eventsAggregated = 0;
+
+  for (let i = 0; i < flat.length; i++) {
+    const r = flat[i];
+    recordsProcessed++;
+
+    const requestId = r.request_id || r.message_id;
+    if (!requestId) continue;
+
+    const promptChars = toNonNegativeInt(r.user_prompt_length);
+    const responseChars = toNonNegativeInt(r.response_size);
+    const approxInput = Math.floor(promptChars / KIRO_CLI_CHARS_PER_TOKEN);
+    const approxOutput = Math.floor(responseChars / KIRO_CLI_CHARS_PER_TOKEN);
+
+    const tsMs = Number(r.request_start_timestamp_ms);
+    if (!Number.isFinite(tsMs) || tsMs <= 0) continue;
+    const bucketStart = toUtcHalfHourStart(new Date(tsMs).toISOString());
+    if (!bucketStart) continue;
+
+    const rawModel = r.model_id || r.session_model_id;
+    const canonical = canonicalizeKiroCliModelId(rawModel);
+    const model = canonical || "kiro-cli-agent";
+
+    // Fingerprint captures every field whose change should cause a re-bucket.
+    const fingerprint = `${promptChars}:${responseChars}:${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)) {
+      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),
+        conversation_count: -1,
+      });
+      touchedBuckets.add(bucketKey("kiro", prev.model, prev.bucketStart));
+    }
+
+    // Add the new contribution.
+    if (approxInput > 0 || approxOutput > 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,
+        conversation_count: 1,
+      });
+      touchedBuckets.add(bucketKey("kiro", model, bucketStart));
+      eventsAggregated++;
+    }
+
+    // Always record the cursor entry (even for zero-token requests) so we
+    // don't re-count later if Kiro rewrites this request with real data.
+    requestState[requestId] = {
+      fingerprint,
+      bucketStart,
+      model,
+      input_tokens: approxInput,
+      output_tokens: approxOutput,
+    };
+
+    if (cb && i % 50 === 0) {
+      cb({
+        index: i + 1,
+        total: flat.length,
+        recordsProcessed,
+        eventsAggregated,
+        bucketsQueued: touchedBuckets.size,
+      });
+    }
+  }
+
+  const bucketsQueued = await enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets });
+  const updatedAt = new Date().toISOString();
+  hourlyState.updatedAt = updatedAt;
+  cursors.hourly = hourlyState;
+  cursors.kiroCli = { ...kiroCliState, requests: requestState, updatedAt };
+
+  return { recordsProcessed, eventsAggregated, bucketsQueued };
+}
+
+// Back-compat path: per-session .json files (the old fixture shape). Emits
+// exact tokens if the fixture happens to carry them (which the test fixture
+// does). Used only by the test/rollout-parser.test.js fixture tests.
+async function parseKiroCliFromSessionFiles({
+  sessionFiles,
+  cursors,
+  queuePath,
+  onProgress,
+  env,
+  kiroCliState,
+  seenIds,
+}) {
+  const fileOffsets =
+    kiroCliState.fileOffsets && typeof kiroCliState.fileOffsets === "object"
+      ? { ...kiroCliState.fileOffsets }
+      : {};
+  if (sessionFiles.length === 0) {
+    cursors.kiroCli = {
+      ...kiroCliState,
+      seenIds: Array.from(seenIds),
+      fileOffsets,
+      updatedAt: new Date().toISOString(),
+    };
+    return { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+  }
+
+  const hourlyState = normalizeHourlyState(cursors?.hourly);
+  const touchedBuckets = new Set();
+  const cb = typeof onProgress === "function" ? onProgress : null;
+  let recordsProcessed = 0;
+  let eventsAggregated = 0;
+
+  for (let fileIdx = 0; fileIdx < sessionFiles.length; fileIdx++) {
+    const filePath = sessionFiles[fileIdx];
+    let stat;
+    try {
+      stat = fssync.statSync(filePath);
+    } catch {
+      continue;
+    }
+
+    const prevEntry = fileOffsets[filePath] || {};
+    const prevMtime = Number(prevEntry.mtimeMs) || 0;
+    const prevLastIndex = Number.isFinite(Number(prevEntry.lastIndex))
+      ? Number(prevEntry.lastIndex)
+      : -1;
+    if (prevMtime && stat.mtimeMs <= prevMtime) continue;
+
+    let parsed;
+    try {
+      parsed = JSON.parse(fssync.readFileSync(filePath, "utf8"));
+    } catch {
+      continue;
+    }
+    if (!parsed || typeof parsed !== "object") continue;
+
+    const turns = Array.isArray(
+      parsed?.session_state?.conversation_metadata?.user_turn_metadatas,
+    )
+      ? parsed.session_state.conversation_metadata.user_turn_metadatas
+      : [];
+    const sessionId = typeof parsed.session_id === "string" ? parsed.session_id : filePath;
+    const sessionModelId =
+      (parsed?.session_state?.rts_model_state?.model_info &&
+        (parsed.session_state.rts_model_state.model_info.model_id ||
+          parsed.session_state.rts_model_state.model_info.modelId)) ||
+      null;
+
+    let maxIndex = prevLastIndex;
+    for (let i = 0; i < turns.length; i++) {
+      if (i <= prevLastIndex) continue;
+      const turn = turns[i];
+      if (!turn || typeof turn !== "object") continue;
+      recordsProcessed++;
+
+      const input = toNonNegativeInt(turn.input_tokens);
+      const output = toNonNegativeInt(turn.output_tokens);
+      const cacheRead = toNonNegativeInt(
+        turn.cache_read_input_tokens ?? turn.cached_input_tokens,
+      );
+      const cacheCreation = toNonNegativeInt(
+        turn.cache_creation_input_tokens ?? turn.cache_write_input_tokens,
+      );
+      const reasoning = toNonNegativeInt(turn.reasoning_output_tokens);
+      if (input === 0 && output === 0 && cacheRead === 0 && cacheCreation === 0) {
+        maxIndex = i;
+        continue;
+      }
+
+      const ts = turn.timestamp || turn.created_at || turn.updated_at;
+      if (!ts) continue;
+      const bucketStart = toUtcHalfHourStart(ts);
+      if (!bucketStart) continue;
+
+      const turnMessageId =
+        typeof turn.message_id === "string" && turn.message_id ? turn.message_id : null;
+      const dedupKey = turnMessageId ? `${sessionId}:${turnMessageId}` : null;
+      if (dedupKey && seenIds.has(dedupKey)) {
+        maxIndex = i;
+        continue;
+      }
+
+      const rawModel =
+        turn.model_id ||
+        turn.modelId ||
+        (turn.model_info && (turn.model_info.model_id || turn.model_info.modelId)) ||
+        sessionModelId;
+      const normalized = rawModel ? normalizeKiroModelName(rawModel) : null;
+      const model = normalized || "kiro-cli-agent";
+
+      const delta = {
+        input_tokens: input,
+        cached_input_tokens: cacheRead,
+        cache_creation_input_tokens: cacheCreation,
+        output_tokens: output,
+        reasoning_output_tokens: reasoning,
+        total_tokens: input + output + cacheRead + cacheCreation + reasoning,
+        conversation_count: 1,
+      };
+
+      const bucket = getHourlyBucket(hourlyState, "kiro", model, bucketStart);
+      addTotals(bucket.totals, delta);
+      touchedBuckets.add(bucketKey("kiro", model, bucketStart));
+      if (dedupKey) seenIds.add(dedupKey);
+      maxIndex = i;
+      eventsAggregated++;
+
+      if (cb) {
+        cb({
+          index: fileIdx + 1,
+          total: sessionFiles.length,
+          recordsProcessed,
+          eventsAggregated,
+          bucketsQueued: touchedBuckets.size,
+        });
+      }
+    }
+
+    fileOffsets[filePath] = {
+      mtimeMs: stat.mtimeMs,
+      size: stat.size,
+      lastIndex: maxIndex,
+    };
+  }
+
+  const seenArr = Array.from(seenIds);
+  const cappedSeen = seenArr.length > 10_000 ? seenArr.slice(seenArr.length - 10_000) : seenArr;
+
+  const bucketsQueued = await enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets });
+  const updatedAt = new Date().toISOString();
+  hourlyState.updatedAt = updatedAt;
+  cursors.hourly = hourlyState;
+  cursors.kiroCli = { ...kiroCliState, seenIds: cappedSeen, fileOffsets, updatedAt };
+
+  return { recordsProcessed, eventsAggregated, bucketsQueued };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+
 function resolveKimiWireFiles(env = process.env) {
   const home = require("node:os").homedir();
   const kimiHome = env.KIMI_HOME || path.join(home, ".kimi");
@@ -3417,6 +4036,9 @@ module.exports = {
   resolveKimiWireFiles,
   resolveKimiDefaultModel,
   parseKimiIncremental,
+  resolveKiroCliSessionFiles,
+  resolveKiroCliDbPath,
+  parseKiroCliIncremental,
   // Exposed for regression tests covering cache-token accounting.
   normalizeGeminiTokens,
   normalizeOpencodeTokens,