devrage 0.0.4 → 0.5.3

package/dist/cli.js

@@ -1,15 +1,16 @@
 #!/usr/bin/env node
 
+// src/commands/scan.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2, join as join10 } from "node:path";
+import { pathToFileURL } from "node:url";
+
 // src/adapters/amp.ts
 import { readdir, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 function getAmpThreadsDir() {
-  return join(
-    process.env["XDG_DATA_HOME"] ?? join(homedir(), ".local", "share"),
-    "amp",
-    "threads"
-  );
+  return join(process.env["XDG_DATA_HOME"] ?? join(homedir(), ".local", "share"), "amp", "threads");
 }
 function ampAdapter() {
   return {
@@ -27,17 +28,27 @@ function ampAdapter() {
         const filePath = join(threadsDir, file);
         const threadId = file.replace(".json", "");
         try {
-          const raw = await readFile(filePath, "utf-8");
-          const thread = JSON.parse(raw);
-          if (!thread.messages || !Array.isArray(thread.messages)) continue;
+          const thread = await readAmpThread(filePath);
+          if (!thread) {
+            continue;
+          }
+          if (!thread.messages || !Array.isArray(thread.messages)) {
+            continue;
+          }
           for (const msg of thread.messages) {
-            if (msg.role !== "user") continue;
+            if (msg.role !== "user") {
+              continue;
+            }
             const text = extractText(msg.content);
-            if (!text) continue;
+            if (!text) {
+              continue;
+            }
             const timestamp = msg.timestamp ?? msg.createdAt ?? void 0;
             if (options?.since && timestamp) {
               const ts = new Date(timestamp);
-              if (ts < options.since) continue;
+              if (ts < options.since) {
+                continue;
+              }
             }
             yield {
               text,
@@ -48,11 +59,47 @@ function ampAdapter() {
         } catch {
         }
       }
+    },
+    async *usage(options) {
+      const threadsDir = getAmpThreadsDir();
+      let files;
+      try {
+        files = await readdir(threadsDir);
+      } catch {
+        return;
+      }
+      for (const file of files.filter((f) => f.endsWith(".json"))) {
+        const filePath = join(threadsDir, file);
+        const threadId = file.replace(".json", "");
+        try {
+          const thread = await readAmpThread(filePath);
+          if (!thread?.usageLedger) {
+            continue;
+          }
+          for (const record of extractAmpUsageRecords(thread.usageLedger, threadId)) {
+            if (options?.since && record.timestamp) {
+              const ts = new Date(record.timestamp);
+              if (ts < options.since) {
+                continue;
+              }
+            }
+            yield record;
+          }
+        } catch {
+        }
+      }
     }
   };
 }
+async function readAmpThread(filePath) {
+  const raw = await readFile(filePath, "utf-8");
+  const parsed = JSON.parse(raw);
+  return asRecord(parsed) ? parsed : null;
+}
 function extractText(content) {
-  if (typeof content === "string") return content;
+  if (typeof content === "string") {
+    return content;
+  }
   if (Array.isArray(content)) {
     const parts = content.filter(
       (p) => typeof p === "object" && p !== null && typeof p.text === "string"
@@ -61,6 +108,125 @@ function extractText(content) {
   }
   return null;
 }
+function extractAmpUsageRecords(usageLedger, threadId) {
+  const records = [];
+  collectAmpUsage(usageLedger, threadId, records, {});
+  return records;
+}
+function collectAmpUsage(value, threadId, records, context, depth = 0) {
+  if (depth > 12) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectAmpUsage(item, threadId, records, context, depth + 1);
+    }
+    return;
+  }
+  const record = asRecord(value);
+  if (!record) {
+    return;
+  }
+  const nextContext = {
+    provider: stringField(record, ["provider", "providerID", "providerId"]) ?? context.provider,
+    model: stringField(record, ["model", "modelID", "modelId"]) ?? context.model,
+    timestamp: timestampField(record) ?? context.timestamp
+  };
+  const usageSource = firstRecordField(record, ["usage", "tokens", "tokenUsage"]) ?? record;
+  const rawInputTokens = tokenField(usageSource, ["inputTokens", "input_tokens", "promptTokens"]);
+  const outputTokens = tokenField(usageSource, [
+    "outputTokens",
+    "output_tokens",
+    "completionTokens"
+  ]);
+  const reasoningTokens = tokenField(usageSource, ["reasoningTokens", "reasoning_output_tokens"]);
+  const cachedInputSubset = tokenField(usageSource, ["cachedInputTokens", "cached_input_tokens"]);
+  const cacheReadTokens = tokenField(usageSource, [
+    "cacheReadTokens",
+    "cache_read_tokens",
+    "cacheReadInputTokens",
+    "cache_read_input_tokens",
+    "cachedInputTokens",
+    "cached_input_tokens"
+  ]);
+  const inputTokens = Math.max(rawInputTokens - cachedInputSubset, 0);
+  const cacheWriteTokens = tokenField(usageSource, [
+    "cacheWriteTokens",
+    "cache_write_tokens",
+    "cacheCreationInputTokens",
+    "cache_creation_input_tokens",
+    "cacheWriteInputTokens",
+    "cache_write_input_tokens"
+  ]);
+  const billedCost = tokenField(record, [
+    "cost",
+    "totalCost",
+    "total_cost",
+    "billedCost",
+    "billed_cost"
+  ]);
+  if (inputTokens + outputTokens + reasoningTokens + cacheReadTokens + cacheWriteTokens + billedCost > 0) {
+    records.push({
+      agent: "amp",
+      provider: nextContext.provider,
+      model: nextContext.model,
+      timestamp: nextContext.timestamp,
+      session: threadId,
+      billedCost,
+      inputTokens,
+      outputTokens,
+      reasoningTokens,
+      cacheReadTokens,
+      cacheWriteTokens
+    });
+  }
+  for (const child of Object.values(record)) {
+    if (child !== usageSource && typeof child === "object" && child !== null) {
+      collectAmpUsage(child, threadId, records, nextContext, depth + 1);
+    }
+  }
+}
+function firstRecordField(record, fields) {
+  for (const field of fields) {
+    const value = asRecord(record[field]);
+    if (value) {
+      return value;
+    }
+  }
+  return null;
+}
+function stringField(record, fields) {
+  for (const field of fields) {
+    const value = record[field];
+    if (typeof value === "string" && value.trim()) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function timestampField(record) {
+  const value = stringField(record, ["timestamp", "createdAt", "time", "date"]);
+  if (value) {
+    const date = new Date(value);
+    return Number.isFinite(date.getTime()) ? date.toISOString() : void 0;
+  }
+  return void 0;
+}
+function tokenField(record, fields) {
+  for (const field of fields) {
+    const value = record[field];
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+  }
+  return 0;
+}
+function asRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
 
 // src/adapters/claude.ts
 import { createReadStream } from "node:fs";
@@ -73,63 +239,78 @@ function claudeAdapter() {
   return {
     name: "claude",
     async *messages(options) {
-      const projectsDir = CLAUDE_DIR;
-      let projectDirs;
-      try {
-        projectDirs = await readdir2(projectsDir);
-      } catch {
-        return;
+      for await (const file of discoverClaudeJsonlFiles()) {
+        yield* parseClaudeJsonl(file.filePath, { ...file, since: options?.since });
       }
-      for (const projectDir of projectDirs) {
-        const projectPath = join2(projectsDir, projectDir);
-        const projectStat = await stat(projectPath);
-        if (!projectStat.isDirectory()) continue;
-        const entries = await readdir2(projectPath);
-        const jsonlFiles = entries.filter((f) => f.endsWith(".jsonl"));
-        for (const file of jsonlFiles) {
-          const filePath = join2(projectPath, file);
-          const session = file.replace(".jsonl", "");
-          yield* parseClaudeJsonl(filePath, {
-            session,
-            project: projectDir,
-            since: options?.since
-          });
-        }
-        const subdirs = entries.filter((f) => !f.includes("."));
-        for (const subdir of subdirs) {
-          const subagentsDir = join2(projectPath, subdir, "subagents");
-          try {
-            const subFiles = await readdir2(subagentsDir);
-            const subJsonl = subFiles.filter((f) => f.endsWith(".jsonl"));
-            for (const file of subJsonl) {
-              yield* parseClaudeJsonl(join2(subagentsDir, file), {
-                session: `${subdir}/${file.replace(".jsonl", "")}`,
-                project: projectDir,
-                since: options?.since
-              });
-            }
-          } catch {
-          }
-        }
+    },
+    async *usage(options) {
+      for await (const file of discoverClaudeJsonlFiles()) {
+        yield* parseClaudeUsageJsonl(file.filePath, { ...file, since: options?.since });
       }
     }
   };
 }
+async function* discoverClaudeJsonlFiles() {
+  let projectDirs;
+  try {
+    projectDirs = await readdir2(CLAUDE_DIR);
+  } catch {
+    return;
+  }
+  for (const projectDir of projectDirs) {
+    const projectPath = join2(CLAUDE_DIR, projectDir);
+    const projectStat = await stat(projectPath);
+    if (!projectStat.isDirectory()) {
+      continue;
+    }
+    const entries = await readdir2(projectPath);
+    const jsonlFiles = entries.filter((f) => f.endsWith(".jsonl"));
+    for (const file of jsonlFiles) {
+      yield {
+        filePath: join2(projectPath, file),
+        session: file.replace(".jsonl", ""),
+        project: projectDir
+      };
+    }
+    const subdirs = entries.filter((f) => !f.includes("."));
+    for (const subdir of subdirs) {
+      const subagentsDir = join2(projectPath, subdir, "subagents");
+      try {
+        const subFiles = await readdir2(subagentsDir);
+        const subJsonl = subFiles.filter((f) => f.endsWith(".jsonl"));
+        for (const file of subJsonl) {
+          yield {
+            filePath: join2(subagentsDir, file),
+            session: `${subdir}/${file.replace(".jsonl", "")}`,
+            project: projectDir
+          };
+        }
+      } catch {
+      }
+    }
+  }
+}
 async function* parseClaudeJsonl(filePath, context) {
   const rl = createInterface({
     input: createReadStream(filePath, { encoding: "utf-8" }),
     crlfDelay: Infinity
   });
   for await (const line of rl) {
-    if (!line.trim()) continue;
+    if (!line.trim()) {
+      continue;
+    }
     try {
       const entry = JSON.parse(line);
       const text = extractUserText(entry);
-      if (!text) continue;
+      if (!text) {
+        continue;
+      }
       const timestamp = extractTimestamp(entry);
       if (context.since && timestamp) {
         const ts = new Date(timestamp);
-        if (ts < context.since) continue;
+        if (ts < context.since) {
+          continue;
+        }
       }
       yield {
         text,
@@ -144,12 +325,16 @@ async function* parseClaudeJsonl(filePath, context) {
 function extractUserText(entry) {
   if (entry["type"] === "user") {
     const message = entry["message"];
-    if (!message) return null;
+    if (!message) {
+      return null;
+    }
     return contentToString(message["content"]);
   }
   if (entry["type"] === "human") {
     const message = entry["message"];
-    if (!message) return null;
+    if (!message) {
+      return null;
+    }
     return contentToString(message["content"]);
   }
   if (entry["role"] === "user") {
@@ -158,7 +343,9 @@ function extractUserText(entry) {
   return null;
 }
 function contentToString(content) {
-  if (typeof content === "string") return content;
+  if (typeof content === "string") {
+    return content;
+  }
   if (Array.isArray(content)) {
     const parts = content.filter(
       (p) => typeof p === "object" && p !== null && p.type === "text"
@@ -168,10 +355,90 @@ function contentToString(content) {
   return null;
 }
 function extractTimestamp(entry) {
-  if (typeof entry["timestamp"] === "string") return entry["timestamp"];
-  if (typeof entry["createdAt"] === "string") return entry["createdAt"];
+  if (typeof entry["timestamp"] === "string") {
+    return entry["timestamp"];
+  }
+  if (typeof entry["createdAt"] === "string") {
+    return entry["createdAt"];
+  }
   return null;
 }
+async function* parseClaudeUsageJsonl(filePath, context) {
+  const rl = createInterface({
+    input: createReadStream(filePath, { encoding: "utf-8" }),
+    crlfDelay: Infinity
+  });
+  const seen = /* @__PURE__ */ new Set();
+  for await (const line of rl) {
+    if (!line.trim()) {
+      continue;
+    }
+    try {
+      const entry = JSON.parse(line);
+      const message = asRecord2(entry["message"]);
+      if (!message || entry["type"] !== "assistant" || message["role"] !== "assistant") {
+        continue;
+      }
+      const usage2 = asRecord2(message["usage"]);
+      if (!usage2) {
+        continue;
+      }
+      const model = stringValue(message["model"]);
+      const timestamp = extractTimestamp(entry) ?? void 0;
+      if (context.since && timestamp) {
+        const ts = new Date(timestamp);
+        if (ts < context.since) {
+          continue;
+        }
+      }
+      const inputTokens = numberValue(usage2["input_tokens"]);
+      const outputTokens = numberValue(usage2["output_tokens"]);
+      const cacheReadTokens = numberValue(usage2["cache_read_input_tokens"]);
+      const cacheWriteTokens = cacheCreationTokens(usage2);
+      if (inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens === 0) {
+        continue;
+      }
+      const dedupeKey = stringValue(entry["requestId"]) ?? stringValue(message["id"]) ?? `${context.session}:${timestamp ?? ""}:${model ?? "unknown"}:${inputTokens}:${outputTokens}`;
+      if (seen.has(dedupeKey)) {
+        continue;
+      }
+      seen.add(dedupeKey);
+      yield {
+        agent: "claude",
+        provider: "anthropic",
+        model,
+        timestamp,
+        session: context.session,
+        inputTokens,
+        outputTokens,
+        reasoningTokens: 0,
+        cacheReadTokens,
+        cacheWriteTokens
+      };
+    } catch {
+    }
+  }
+}
+function cacheCreationTokens(usage2) {
+  const explicit = numberValue(usage2["cache_creation_input_tokens"]);
+  if (explicit > 0) {
+    return explicit;
+  }
+  const cacheCreation = asRecord2(usage2["cache_creation"]);
+  return numberValue(cacheCreation?.["ephemeral_1h_input_tokens"]) + numberValue(cacheCreation?.["ephemeral_5m_input_tokens"]);
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function asRecord2(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
 
 // src/adapters/cline.ts
 import { readdir as readdir3, readFile as readFile2, stat as stat2 } from "node:fs/promises";
@@ -185,11 +452,15 @@ function getClineTaskDirs() {
   for (const basePath of vscodePaths) {
     for (const extId of extensionIds) {
       const tasksDir = join3(basePath, extId, "tasks");
-      if (existsSync(tasksDir)) dirs.push(tasksDir);
+      if (existsSync(tasksDir)) {
+        dirs.push(tasksDir);
+      }
     }
   }
   const clineStandalone = join3(homedir3(), ".cline", "data", "tasks");
-  if (existsSync(clineStandalone)) dirs.push(clineStandalone);
+  if (existsSync(clineStandalone)) {
+    dirs.push(clineStandalone);
+  }
   return dirs;
 }
 function getVSCodeGlobalStoragePaths() {
@@ -232,20 +503,30 @@ function clineAdapter() {
         for (const taskId of taskIds) {
           const taskDir = join3(tasksDir, taskId);
           const taskStat = await stat2(taskDir).catch(() => null);
-          if (!taskStat?.isDirectory()) continue;
+          if (!taskStat?.isDirectory()) {
+            continue;
+          }
           const historyFile = join3(taskDir, "api_conversation_history.json");
           try {
             const raw = await readFile2(historyFile, "utf-8");
             const messages = JSON.parse(raw);
-            if (!Array.isArray(messages)) continue;
+            if (!Array.isArray(messages)) {
+              continue;
+            }
             for (const msg of messages) {
-              if (msg.role !== "user") continue;
+              if (msg.role !== "user") {
+                continue;
+              }
               const text = extractText2(msg.content);
-              if (!text) continue;
+              if (!text) {
+                continue;
+              }
               const timestamp = msg.ts ?? void 0;
               if (options?.since && timestamp) {
                 const ts = new Date(timestamp);
-                if (ts < options.since) continue;
+                if (ts < options.since) {
+                  continue;
+                }
               }
               yield {
                 text,
@@ -260,7 +541,9 @@ function clineAdapter() {
   };
 }
 function extractText2(content) {
-  if (typeof content === "string") return content;
+  if (typeof content === "string") {
+    return content;
+  }
   if (Array.isArray(content)) {
     const parts = content.filter(
       (p) => typeof p === "object" && p !== null && p.type === "text" && typeof p.text === "string"
@@ -281,11 +564,21 @@ function codexAdapter() {
   return {
     name: "codex",
     async *messages(options) {
-      yield* walkCodexSessions(CODEX_SESSIONS_DIR, options);
+      for await (const file of discoverCodexSessionFiles(CODEX_SESSIONS_DIR)) {
+        yield* parseCodexJsonl(file.filePath, { session: file.session, since: options?.since });
+      }
+    },
+    async *usage(options) {
+      for await (const file of discoverCodexSessionFiles(CODEX_SESSIONS_DIR)) {
+        yield* parseCodexUsageJsonl(file.filePath, {
+          session: file.session,
+          since: options?.since
+        });
+      }
     }
   };
 }
-async function* walkCodexSessions(dir, options) {
+async function* discoverCodexSessionFiles(dir) {
   let entries;
   try {
     entries = await readdir4(dir);
@@ -296,10 +589,9 @@ async function* walkCodexSessions(dir, options) {
     const fullPath = join4(dir, entry);
     const entryStat = await stat3(fullPath);
     if (entryStat.isDirectory()) {
-      yield* walkCodexSessions(fullPath, options);
+      yield* discoverCodexSessionFiles(fullPath);
     } else if (entry.endsWith(".jsonl")) {
-      const session = entry.replace(".jsonl", "");
-      yield* parseCodexJsonl(fullPath, { session, since: options?.since });
+      yield { filePath: fullPath, session: entry.replace(".jsonl", "") };
     }
   }
 }
@@ -309,19 +601,33 @@ async function* parseCodexJsonl(filePath, context) {
     crlfDelay: Infinity
   });
   for await (const line of rl) {
-    if (!line.trim()) continue;
+    if (!line.trim()) {
+      continue;
+    }
     try {
       const entry = JSON.parse(line);
-      if (entry.type !== "response_item") continue;
+      if (entry.type !== "response_item") {
+        continue;
+      }
       const payload = entry.payload;
-      if (!payload || payload.role !== "user") continue;
+      if (!payload || payload.role !== "user") {
+        continue;
+      }
       const text = extractText3(payload.content);
-      if (!text) continue;
-      if (text.startsWith("<environment_context>")) continue;
-      if (text.startsWith("<permissions instructions>")) continue;
+      if (!text) {
+        continue;
+      }
+      if (text.startsWith("<environment_context>")) {
+        continue;
+      }
+      if (text.startsWith("<permissions instructions>")) {
+        continue;
+      }
       if (context.since && entry.timestamp) {
         const ts = new Date(entry.timestamp);
-        if (ts < context.since) continue;
+        if (ts < context.since) {
+          continue;
+        }
       }
       yield {
         text,
@@ -333,114 +639,868 @@ async function* parseCodexJsonl(filePath, context) {
   }
 }
 function extractText3(content) {
-  if (!Array.isArray(content)) return null;
+  if (!Array.isArray(content)) {
+    return null;
+  }
   const parts = content.filter(
     (p) => typeof p === "object" && p !== null && p.type === "input_text" && typeof p.text === "string"
   ).map((p) => p.text);
   return parts.length > 0 ? parts.join(" ") : null;
 }
+async function* parseCodexUsageJsonl(filePath, context) {
+  const rl = createInterface2({
+    input: createReadStream2(filePath, { encoding: "utf-8" }),
+    crlfDelay: Infinity
+  });
+  let model;
+  let previousTotal = null;
+  let previousUsageSignature = null;
+  for await (const line of rl) {
+    if (!line.trim()) {
+      continue;
+    }
+    try {
+      const entry = JSON.parse(line);
+      const payload = asRecord3(entry["payload"]);
+      if (entry["type"] === "turn_context") {
+        model = stringValue2(payload?.["model"]) ?? model;
+        continue;
+      }
+      if (entry["type"] !== "event_msg" || payload?.["type"] !== "token_count") {
+        continue;
+      }
+      const info = asRecord3(payload["info"]);
+      if (!info) {
+        continue;
+      }
+      const lastUsageValue = info["last_token_usage"];
+      const lastUsage = parseCodexTokenUsage(lastUsageValue);
+      const total = parseCodexTokenUsage(info["total_token_usage"]);
+      let usage2 = null;
+      if (lastUsageValue !== void 0) {
+        if (lastUsage && hasBillableUsage(lastUsage)) {
+          const signature = codexUsageSignature(lastUsage, total);
+          if (signature !== previousUsageSignature) {
+            usage2 = lastUsage;
+          }
+          previousUsageSignature = signature;
+        }
+      } else if (total) {
+        const delta = previousTotal ? subtractCodexUsage(total, previousTotal) : total;
+        if (hasBillableUsage(delta)) {
+          usage2 = delta;
+        }
+      }
+      if (total && hasBillableUsage(total)) {
+        previousTotal = total;
+      }
+      if (!usage2) {
+        continue;
+      }
+      const timestamp = stringValue2(entry["timestamp"]);
+      if (context.since && timestamp) {
+        const ts = new Date(timestamp);
+        if (ts < context.since) {
+          continue;
+        }
+      }
+      const reasoningTokens = Math.min(usage2.reasoningOutputTokens, usage2.outputTokens);
+      yield {
+        agent: "codex",
+        provider: "openai",
+        model,
+        timestamp,
+        session: context.session,
+        inputTokens: Math.max(usage2.inputTokens - usage2.cachedInputTokens, 0),
+        outputTokens: Math.max(usage2.outputTokens - reasoningTokens, 0),
+        reasoningTokens,
+        cacheReadTokens: usage2.cachedInputTokens,
+        cacheWriteTokens: 0
+      };
+    } catch {
+    }
+  }
+}
+function parseCodexTokenUsage(value) {
+  const usage2 = asRecord3(value);
+  if (!usage2) {
+    return null;
+  }
+  const hasUsageField = [
+    "input_tokens",
+    "cached_input_tokens",
+    "output_tokens",
+    "reasoning_output_tokens",
+    "total_tokens"
+  ].some((key) => typeof usage2[key] === "number" && Number.isFinite(usage2[key]));
+  if (!hasUsageField) {
+    return null;
+  }
+  return {
+    inputTokens: numberValue2(usage2["input_tokens"]),
+    cachedInputTokens: numberValue2(usage2["cached_input_tokens"]),
+    outputTokens: numberValue2(usage2["output_tokens"]),
+    reasoningOutputTokens: numberValue2(usage2["reasoning_output_tokens"]),
+    totalTokens: numberValue2(usage2["total_tokens"])
+  };
+}
+function subtractCodexUsage(current, previous) {
+  return {
+    inputTokens: Math.max(current.inputTokens - previous.inputTokens, 0),
+    cachedInputTokens: Math.max(current.cachedInputTokens - previous.cachedInputTokens, 0),
+    outputTokens: Math.max(current.outputTokens - previous.outputTokens, 0),
+    reasoningOutputTokens: Math.max(
+      current.reasoningOutputTokens - previous.reasoningOutputTokens,
+      0
+    ),
+    totalTokens: Math.max(current.totalTokens - previous.totalTokens, 0)
+  };
+}
+function hasBillableUsage(usage2) {
+  return usage2.inputTokens + usage2.cachedInputTokens + usage2.outputTokens + usage2.reasoningOutputTokens > 0;
+}
+function codexUsageSignature(usage2, total) {
+  return [
+    usage2.inputTokens,
+    usage2.cachedInputTokens,
+    usage2.outputTokens,
+    usage2.reasoningOutputTokens,
+    total?.inputTokens ?? "",
+    total?.cachedInputTokens ?? "",
+    total?.outputTokens ?? "",
+    total?.reasoningOutputTokens ?? ""
+  ].join(":");
+}
+function numberValue2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function stringValue2(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function asRecord3(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
 
-// src/adapters/opencode.ts
+// src/adapters/cursor.ts
 import { existsSync as existsSync2 } from "node:fs";
+import { readdir as readdir5 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
 import { join as join5 } from "node:path";
-function getOpencodeDatabasePath() {
-  const xdgPath = join5(
-    process.env["XDG_DATA_HOME"] ?? join5(homedir5(), ".local", "share"),
-    "opencode",
-    "opencode.db"
-  );
-  if (existsSync2(xdgPath)) return xdgPath;
-  if (process.platform === "darwin") {
-    const macPath = join5(
-      homedir5(),
-      "Library",
-      "Application Support",
-      "opencode",
-      "opencode.db"
-    );
-    if (existsSync2(macPath)) return macPath;
-  }
-  return null;
-}
-function opencodeAdapter() {
+var CANDIDATE_KEY_PREFIXES = [
+  "bubbleId:",
+  "composerData:",
+  "composer.composerData",
+  "aiService.prompts",
+  "aiService.generations",
+  "workbench.panel.composerChatViewPane."
+];
+var STATE_TABLES = ["ItemTable", "cursorDiskKV"];
+function cursorAdapter() {
   return {
-    name: "opencode",
+    name: "cursor",
     async *messages(options) {
-      const dbPath = getOpencodeDatabasePath();
-      if (!dbPath) return;
-      let db;
-      try {
-        const BetterSqlite3 = await import("better-sqlite3");
-        const Ctor = BetterSqlite3.default ?? BetterSqlite3;
-        db = new Ctor(dbPath, { readonly: true });
-      } catch {
-        console.warn(
-          "devrage: better-sqlite3 not available, skipping OpenCode sessions"
-        );
-        return;
+      const stores = await discoverCursorStateStores();
+      for (const store of stores) {
+        yield* parseCursorStore(store, options);
       }
-      try {
-        yield* queryUserMessages(db, options);
-      } finally {
-        db.close();
+    },
+    async *usage(options) {
+      const stores = await discoverCursorStateStores();
+      for (const store of stores) {
+        yield* parseCursorUsageStore(store, options);
       }
     }
   };
 }
-function* queryUserMessages(db, options) {
-  let query = `
-    SELECT
-      m.session_id,
-      m.time_created,
-      json_extract(p.data, '$.text') as text
-    FROM message m
-    JOIN part p ON p.message_id = m.id
-    WHERE json_extract(m.data, '$.role') = 'user'
-      AND json_extract(p.data, '$.type') = 'text'
-  `;
-  if (options?.since) {
-    const sinceMs = options.since.getTime();
-    query += ` AND m.time_created >= ${sinceMs}`;
+async function discoverCursorStateStores() {
+  const stores = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const userDir of getCursorUserDirs()) {
+    if (!existsSync2(userDir)) {
+      continue;
+    }
+    const globalState = join5(userDir, "globalStorage", "state.vscdb");
+    if (existsSync2(globalState) && !seen.has(globalState)) {
+      seen.add(globalState);
+      stores.push({ path: globalState, scope: "global" });
+    }
+    const workspaceRoot = join5(userDir, "workspaceStorage");
+    let workspaceIds = [];
+    try {
+      workspaceIds = await readdir5(workspaceRoot);
+    } catch {
+      continue;
+    }
+    for (const workspaceId of workspaceIds) {
+      const statePath = join5(workspaceRoot, workspaceId, "state.vscdb");
+      if (existsSync2(statePath) && !seen.has(statePath)) {
+        seen.add(statePath);
+        stores.push({ path: statePath, scope: "workspace", project: workspaceId });
+      }
+    }
   }
-  query += ` ORDER BY m.time_created ASC`;
-  const rows = db.prepare(query).all();
-  for (const row of rows) {
-    if (!row.text || !row.text.trim()) continue;
-    yield {
-      text: row.text,
-      timestamp: new Date(row.time_created).toISOString(),
-      session: row.session_id
-    };
+  return stores;
+}
+function getCursorUserDirs() {
+  const configHome = envOrDefault("XDG_CONFIG_HOME", join5(homedir5(), ".config"));
+  const appData = envOrDefault("APPDATA", join5(homedir5(), "AppData", "Roaming"));
+  return uniqueStrings([
+    join5(homedir5(), "Library", "Application Support", "Cursor", "User"),
+    join5(configHome, "Cursor", "User"),
+    join5(appData, "Cursor", "User")
+  ]);
+}
+async function* parseCursorStore(store, options) {
+  const db = await openCursorDb(store.path);
+  if (!db) {
+    return;
+  }
+  try {
+    const rows = readStateRows(db);
+    const seen = /* @__PURE__ */ new Set();
+    for (const row of rows) {
+      try {
+        if (!isCandidateKey(row.key)) {
+          continue;
+        }
+        const parsed = parseJsonValue(row.value);
+        if (parsed === void 0) {
+          continue;
+        }
+        for (const message of extractCursorMessages(parsed, row.key)) {
+          const text = message.text.trim();
+          if (!isLikelyMessageText(text)) {
+            continue;
+          }
+          if (options?.since && message.timestamp) {
+            const timestamp = new Date(message.timestamp);
+            if (Number.isFinite(timestamp.getTime()) && timestamp < options.since) {
+              continue;
+            }
+          }
+          const session = message.session ?? `${store.scope}:${row.key}`;
+          const dedupeKey = `${session}\0${message.timestamp ?? ""}\0${text}`;
+          if (seen.has(dedupeKey)) {
+            continue;
+          }
+          seen.add(dedupeKey);
+          yield {
+            text,
+            timestamp: message.timestamp,
+            session,
+            project: store.project
+          };
+        }
+      } catch {
+        continue;
+      }
+    }
+  } finally {
+    db.close();
+  }
+}
+async function* parseCursorUsageStore(store, options) {
+  const db = await openCursorDb(store.path);
+  if (!db) {
+    return;
+  }
+  try {
+    const rows = readStateRows(db);
+    const composerModels = collectComposerModels(rows);
+    const seen = /* @__PURE__ */ new Set();
+    for (const row of rows) {
+      try {
+        if (!row.key.startsWith("bubbleId:")) {
+          continue;
+        }
+        const parsed = parseJsonValue(row.value);
+        const usage2 = extractCursorBubbleUsage(parsed, row.key, composerModels);
+        if (!usage2) {
+          continue;
+        }
+        if (options?.since && usage2.timestamp) {
+          const timestamp = new Date(usage2.timestamp);
+          if (Number.isFinite(timestamp.getTime()) && timestamp < options.since) {
+            continue;
+          }
+        }
+        const dedupeKey = `${usage2.session ?? ""}\0${usage2.timestamp ?? ""}\0${usage2.model ?? ""}\0${usage2.inputTokens}\0${usage2.outputTokens}`;
+        if (seen.has(dedupeKey)) {
+          continue;
+        }
+        seen.add(dedupeKey);
+        yield usage2;
+      } catch {
+        continue;
+      }
+    }
+  } finally {
+    db.close();
+  }
+}
+async function openCursorDb(dbPath) {
+  try {
+    const BetterSqlite3 = await import("better-sqlite3");
+    const Ctor = BetterSqlite3.default ?? BetterSqlite3;
+    return new Ctor(
+      dbPath,
+      { readonly: true }
+    );
+  } catch {
+    return null;
   }
 }
+function readStateRows(db) {
+  const rows = [];
+  try {
+    const tables = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all();
+    const availableTables = new Set(tables.flatMap((table) => stringValue3(table.name) ?? []));
+    for (const table of STATE_TABLES) {
+      if (!availableTables.has(table)) {
+        continue;
+      }
+      const columns = db.prepare(`PRAGMA table_info("${table}")`).all();
+      const columnNames = new Set(columns.flatMap((column) => stringValue3(column.name) ?? []));
+      if (!columnNames.has("key") || !columnNames.has("value")) {
+        continue;
+      }
+      const tableRows = db.prepare(`SELECT key, value FROM "${table}"`).all();
+      rows.push(
+        ...tableRows.flatMap(
+          (row) => typeof row.key === "string" ? [{ key: row.key, value: row.value }] : []
+        )
+      );
+    }
+  } catch {
+    return rows;
+  }
+  return rows;
+}
+function isCandidateKey(key) {
+  return CANDIDATE_KEY_PREFIXES.some((prefix) => key === prefix || key.startsWith(prefix));
+}
+function parseJsonValue(value) {
+  const raw = decodeStateValue(value);
+  if (!raw) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "string") {
+      return parsed;
+    }
+    const trimmed = parsed.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+      return parsed;
+    }
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return parsed;
+    }
+  } catch {
+    return void 0;
+  }
+}
+function decodeStateValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Buffer.isBuffer(value)) {
+    return value.toString("utf-8");
+  }
+  return null;
+}
+function extractCursorMessages(root, rowKey) {
+  if (rowKey.startsWith("bubbleId:")) {
+    const message = extractCursorBubbleMessage(root, rowKey);
+    return message ? [message] : [];
+  }
+  const messages = [];
+  collectRoleMessages(root, messages);
+  if (rowKey.startsWith("aiService.prompts") || rowKey.startsWith("aiService.generations")) {
+    collectPromptMessages(root, messages);
+  }
+  return uniqueMessages(messages);
+}
+function extractCursorBubbleMessage(root, rowKey) {
+  const record = asRecord4(root);
+  if (!record || numberValue3(record["type"]) !== 1) {
+    return null;
+  }
+  const text = firstTextField(record, ["text", "richText"]);
+  if (!text) {
+    return null;
+  }
+  return {
+    text,
+    timestamp: extractTimestamp2(record),
+    session: cursorBubbleSession(rowKey) ?? extractSession(record)
+  };
+}
+function collectComposerModels(rows) {
+  const models = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (!row.key.startsWith("composerData:")) {
+      continue;
+    }
+    const parsed = parseJsonValue(row.value);
+    const record = asRecord4(parsed);
+    if (!record) {
+      continue;
+    }
+    const composerId = stringValue3(record["composerId"]) ?? row.key.slice("composerData:".length);
+    const model = extractCursorModel(record);
+    if (composerId && model) {
+      models.set(composerId, model);
+    }
+  }
+  return models;
+}
+function extractCursorBubbleUsage(root, rowKey, composerModels) {
+  const record = asRecord4(root);
+  if (!record || numberValue3(record["type"]) !== 2) {
+    return null;
+  }
+  const tokenCount = asRecord4(record["tokenCount"]);
+  if (!tokenCount) {
+    return null;
+  }
+  const inputTokens = numberValue3(tokenCount["inputTokens"] ?? tokenCount["input"]);
+  const outputTokens = numberValue3(tokenCount["outputTokens"] ?? tokenCount["output"]);
+  const cacheReadTokens = numberValue3(tokenCount["cacheReadTokens"] ?? tokenCount["cacheRead"]);
+  const cacheWriteTokens = numberValue3(tokenCount["cacheWriteTokens"] ?? tokenCount["cacheWrite"]);
+  if (inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens === 0) {
+    return null;
+  }
+  const composerId = cursorBubbleSession(rowKey);
+  const model = extractCursorModel(record) ?? (composerId ? composerModels.get(composerId) : void 0);
+  return {
+    agent: "cursor",
+    model,
+    timestamp: extractTimestamp2(record),
+    session: composerId ?? extractSession(record),
+    inputTokens,
+    outputTokens,
+    reasoningTokens: numberValue3(tokenCount["reasoningTokens"] ?? tokenCount["reasoning"]),
+    cacheReadTokens,
+    cacheWriteTokens
+  };
+}
+function extractCursorModel(record) {
+  const direct = firstStringField(record, ["model", "modelName", "modelId"]);
+  if (direct) {
+    return direct;
+  }
+  for (const field of ["modelInfo", "modelConfig"]) {
+    const modelRecord = asRecord4(record[field]);
+    if (!modelRecord) {
+      continue;
+    }
+    const nested = firstStringField(modelRecord, ["modelName", "modelId", "id", "name"]);
+    if (nested && nested !== "default") {
+      return nested;
+    }
+    const selected = modelRecord["selectedModels"];
+    if (Array.isArray(selected)) {
+      for (const item of selected) {
+        const itemRecord = asRecord4(item);
+        const selectedModel = itemRecord ? firstStringField(itemRecord, ["modelId", "modelName", "id", "name"]) : void 0;
+        if (selectedModel && selectedModel !== "default") {
+          return selectedModel;
+        }
+      }
+    }
+    if (nested) {
+      return nested;
+    }
+  }
+  return void 0;
+}
+function cursorBubbleSession(rowKey) {
+  const [, composerId] = rowKey.split(":");
+  return composerId?.trim() || void 0;
+}
+function collectRoleMessages(value, messages, inheritedSession, depth = 0) {
+  if (depth > 12) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectRoleMessages(item, messages, inheritedSession, depth + 1);
+    }
+    return;
+  }
+  const record = asRecord4(value);
+  if (!record) {
+    return;
+  }
+  const session = extractSession(record) ?? inheritedSession;
+  if (isUserAuthored(record)) {
+    const text = extractMessageText(record);
+    if (text) {
+      messages.push({ text, timestamp: extractTimestamp2(record), session });
+    }
+  }
+  for (const child of Object.values(record)) {
+    if (typeof child === "object" && child !== null) {
+      collectRoleMessages(child, messages, session, depth + 1);
+    }
+  }
+}
+function collectPromptMessages(value, messages, inheritedSession, depth = 0) {
+  if (depth > 12) {
+    return;
+  }
+  if (typeof value === "string") {
+    messages.push({ text: value, session: inheritedSession });
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectPromptMessages(item, messages, inheritedSession, depth + 1);
+    }
+    return;
+  }
+  const record = asRecord4(value);
+  if (!record) {
+    return;
+  }
+  const session = extractSession(record) ?? inheritedSession;
+  const prompt = firstTextField(record, [
+    "prompt",
+    "userPrompt",
+    "originalPrompt",
+    "currentPrompt",
+    "query",
+    "input"
+  ]);
+  if (prompt && !isAssistantAuthored(record)) {
+    messages.push({ text: prompt, timestamp: extractTimestamp2(record), session });
+  }
+  for (const child of Object.values(record)) {
+    if (typeof child === "object" && child !== null) {
+      collectPromptMessages(child, messages, session, depth + 1);
+    }
+  }
+}
+function isUserAuthored(record) {
+  return ["role", "speaker", "sender", "author", "source", "from", "type", "kind"].some(
+    (field) => actorIsUser(record[field])
+  );
+}
+function isAssistantAuthored(record) {
+  return ["role", "speaker", "sender", "author", "source", "from", "type", "kind"].some(
+    (field) => actorIsAssistant(record[field])
+  );
+}
+function actorIsUser(value) {
+  const actor = actorString(value);
+  return actor === "user" || actor === "human" || actor === "usermessage";
+}
+function actorIsAssistant(value) {
+  const actor = actorString(value);
+  return actor === "assistant" || actor === "ai" || actor === "assistantmessage";
+}
+function actorString(value) {
+  if (typeof value === "string") {
+    return value.toLowerCase().replace(/[^a-z]/g, "");
+  }
+  const record = asRecord4(value);
+  if (!record) {
+    return null;
+  }
+  for (const field of ["role", "type", "name"]) {
+    if (typeof record[field] === "string") {
+      return record[field].toLowerCase().replace(/[^a-z]/g, "");
+    }
+  }
+  return null;
+}
+function extractMessageText(record) {
+  return firstTextField(record, ["text", "content", "message", "prompt", "query", "input"]);
+}
+function firstTextField(record, fields) {
+  for (const field of fields) {
+    const text = contentToText(record[field]);
+    if (text) {
+      return text;
+    }
+  }
+  return null;
+}
+function firstStringField(record, fields) {
+  for (const field of fields) {
+    const value = stringValue3(record[field]);
+    if (value) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function contentToText(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const parts = value.map(contentToText).filter((part) => Boolean(part));
+    return parts.length > 0 ? parts.join(" ") : null;
+  }
+  const record = asRecord4(value);
+  if (!record) {
+    return null;
+  }
+  return firstTextField(record, ["text", "content", "message", "value"]);
+}
+function extractTimestamp2(record) {
+  for (const field of ["timestamp", "createdAt", "updatedAt", "time", "created", "date", "ts"]) {
+    const timestamp = normalizeTimestamp(record[field]);
+    if (timestamp) {
+      return timestamp;
+    }
+  }
+  return void 0;
+}
+function normalizeTimestamp(value) {
+  if (typeof value === "string") {
+    const date = new Date(value);
+    return Number.isFinite(date.getTime()) ? date.toISOString() : void 0;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const milliseconds = value > 1e12 ? value : value * 1e3;
+    const date = new Date(milliseconds);
+    return Number.isFinite(date.getTime()) ? date.toISOString() : void 0;
+  }
+  return void 0;
+}
+function extractSession(record) {
+  for (const field of ["conversationId", "composerId", "sessionId", "chatId", "threadId", "id"]) {
+    const value = record[field];
+    if (typeof value === "string" && value.trim()) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function isLikelyMessageText(text) {
+  return text.length > 0 && !text.startsWith("<environment_context>");
+}
+function uniqueMessages(messages) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const message of messages) {
+    const key = `${message.session ?? ""}\0${message.timestamp ?? ""}\0${message.text}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    unique.push(message);
+  }
+  return unique;
+}
+function uniqueStrings(values) {
+  return Array.from(new Set(values));
+}
+function envOrDefault(name, fallback) {
+  const value = process.env[name];
+  return value && value.trim() ? value : fallback;
+}
+function numberValue3(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function stringValue3(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function asRecord4(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+
+// src/adapters/opencode.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { join as join6 } from "node:path";
+function getOpencodeDatabasePath() {
+  const xdgPath = join6(
+    process.env["XDG_DATA_HOME"] ?? join6(homedir6(), ".local", "share"),
+    "opencode",
+    "opencode.db"
+  );
+  if (existsSync3(xdgPath)) {
+    return xdgPath;
+  }
+  if (process.platform === "darwin") {
+    const macPath = join6(homedir6(), "Library", "Application Support", "opencode", "opencode.db");
+    if (existsSync3(macPath)) {
+      return macPath;
+    }
+  }
+  return null;
+}
+function opencodeAdapter() {
+  return {
+    name: "opencode",
+    async *messages(options) {
+      const db = await openOpencodeDb();
+      if (!db) {
+        return;
+      }
+      try {
+        yield* queryUserMessages(db, options);
+      } finally {
+        db.close();
+      }
+    },
+    async *usage(options) {
+      const db = await openOpencodeDb();
+      if (!db) {
+        return;
+      }
+      try {
+        yield* queryUsageRecords(db, options);
+      } finally {
+        db.close();
+      }
+    }
+  };
+}
+async function openOpencodeDb() {
+  const dbPath = getOpencodeDatabasePath();
+  if (!dbPath) {
+    return null;
+  }
+  try {
+    const BetterSqlite3 = await import("better-sqlite3");
+    const Ctor = BetterSqlite3.default ?? BetterSqlite3;
+    return new Ctor(
+      dbPath,
+      { readonly: true }
+    );
+  } catch {
+    console.warn("devrage: better-sqlite3 not available, skipping OpenCode sessions");
+    return null;
+  }
+}
+function* queryUserMessages(db, options) {
+  let query = `
+    SELECT
+      m.session_id,
+      m.time_created,
+      json_extract(p.data, '$.text') as text
+    FROM message m
+    JOIN part p ON p.message_id = m.id
+    WHERE json_extract(m.data, '$.role') = 'user'
+      AND json_extract(p.data, '$.type') = 'text'
+  `;
+  const params = [];
+  if (options?.since) {
+    query += ` AND m.time_created >= ?`;
+    params.push(options.since.getTime());
+  }
+  query += ` ORDER BY m.time_created ASC`;
+  const rows = db.prepare(query).all(...params);
+  for (const row of rows) {
+    if (!row.text || !row.text.trim()) {
+      continue;
+    }
+    yield {
+      text: row.text,
+      timestamp: new Date(row.time_created).toISOString(),
+      session: row.session_id
+    };
+  }
+}
+function* queryUsageRecords(db, options) {
+  let where = `WHERE json_type(data, '$.tokens') = 'object'`;
+  const params = [];
+  if (options?.since) {
+    where += ` AND time_created >= ?`;
+    params.push(options.since.getTime());
+  }
+  const rows = db.prepare(`
+    SELECT
+      session_id,
+      time_created,
+      COALESCE(json_extract(data, '$.providerID'), json_extract(data, '$.model.providerID')) AS provider,
+      COALESCE(json_extract(data, '$.modelID'), json_extract(data, '$.model.modelID')) AS model,
+      json_extract(data, '$.cost') AS billed_cost,
+      json_extract(data, '$.tokens.input') AS input_tokens,
+      json_extract(data, '$.tokens.output') AS output_tokens,
+      json_extract(data, '$.tokens.reasoning') AS reasoning_tokens,
+      json_extract(data, '$.tokens.cache.read') AS cache_read_tokens,
+      json_extract(data, '$.tokens.cache.write') AS cache_write_tokens
+    FROM message
+    ${where}
+    ORDER BY time_created ASC
+  `).all(...params);
+  for (const row of rows) {
+    const inputTokens = numberValue4(row.input_tokens);
+    const outputTokens = numberValue4(row.output_tokens);
+    const reasoningTokens = numberValue4(row.reasoning_tokens);
+    const cacheReadTokens = numberValue4(row.cache_read_tokens);
+    const cacheWriteTokens = numberValue4(row.cache_write_tokens);
+    const billedCost = numberValue4(row.billed_cost);
+    if (inputTokens + outputTokens + reasoningTokens + cacheReadTokens + cacheWriteTokens === 0 && billedCost === 0) {
+      continue;
+    }
+    yield {
+      agent: "opencode",
+      provider: stringValue4(row.provider),
+      model: stringValue4(row.model),
+      timestamp: row.time_created ? new Date(row.time_created).toISOString() : void 0,
+      session: stringValue4(row.session_id),
+      billedCost,
+      inputTokens,
+      outputTokens,
+      reasoningTokens,
+      cacheReadTokens,
+      cacheWriteTokens
+    };
+  }
+}
+function numberValue4(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function stringValue4(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
 
 // src/adapters/pi.ts
 import { createReadStream as createReadStream3 } from "node:fs";
-import { readdir as readdir5, stat as stat4 } from "node:fs/promises";
+import { readdir as readdir6, stat as stat4 } from "node:fs/promises";
 import { createInterface as createInterface3 } from "node:readline";
-import { homedir as homedir6 } from "node:os";
-import { join as join6 } from "node:path";
-var PI_SESSIONS_DIR = join6(homedir6(), ".pi", "agent", "sessions");
+import { homedir as homedir7 } from "node:os";
+import { join as join7 } from "node:path";
+var PI_SESSIONS_DIR = join7(homedir7(), ".pi", "agent", "sessions");
 function piAdapter() {
   return {
     name: "pi",
     async *messages(options) {
       yield* walkPiSessions(PI_SESSIONS_DIR, options);
+    },
+    async *usage(options) {
+      yield* walkPiUsageSessions(PI_SESSIONS_DIR, options);
     }
   };
 }
 async function* walkPiSessions(dir, options, project) {
   let entries;
   try {
-    entries = await readdir5(dir);
+    entries = await readdir6(dir);
   } catch {
     return;
   }
   for (const entry of entries) {
-    const fullPath = join6(dir, entry);
+    const fullPath = join7(dir, entry);
     const entryStat = await stat4(fullPath).catch(() => null);
-    if (!entryStat) continue;
+    if (!entryStat) {
+      continue;
+    }
     if (entryStat.isDirectory()) {
       yield* walkPiSessions(fullPath, options, project ?? entry);
     } else if (entry.endsWith(".jsonl")) {
@@ -449,6 +1509,27 @@ async function* walkPiSessions(dir, options, project) {
     }
   }
 }
+async function* walkPiUsageSessions(dir, options, project) {
+  let entries;
+  try {
+    entries = await readdir6(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = join7(dir, entry);
+    const entryStat = await stat4(fullPath).catch(() => null);
+    if (!entryStat) {
+      continue;
+    }
+    if (entryStat.isDirectory()) {
+      yield* walkPiUsageSessions(fullPath, options, project ?? entry);
+    } else if (entry.endsWith(".jsonl")) {
+      const session = entry.replace(".jsonl", "");
+      yield* parsePiUsageJsonl(fullPath, { session, project, since: options?.since });
+    }
+  }
+}
 async function* parsePiJsonl(filePath, context) {
   const rl = createInterface3({
     input: createReadStream3(filePath, { encoding: "utf-8" }),
@@ -456,22 +1537,32 @@ async function* parsePiJsonl(filePath, context) {
   });
   let project = context.project;
   for await (const line of rl) {
-    if (!line.trim()) continue;
+    if (!line.trim()) {
+      continue;
+    }
     try {
       const entry = JSON.parse(line);
       if (entry.type === "session") {
         project = entry.cwd ?? project;
         continue;
       }
-      if (entry.type !== "message") continue;
+      if (entry.type !== "message") {
+        continue;
+      }
       const message = entry.message;
-      if (!message || message.role !== "user") continue;
+      if (!message || message.role !== "user") {
+        continue;
+      }
       const text = contentToString2(message.content);
-      if (!text) continue;
+      if (!text) {
+        continue;
+      }
       const timestamp = typeof entry.timestamp === "string" ? entry.timestamp : typeof message.timestamp === "number" ? new Date(message.timestamp).toISOString() : void 0;
       if (context.since && timestamp) {
         const ts = new Date(timestamp);
-        if (ts < context.since) continue;
+        if (ts < context.since) {
+          continue;
+        }
       }
       yield {
         text,
@@ -483,8 +1574,64 @@ async function* parsePiJsonl(filePath, context) {
     }
   }
 }
+async function* parsePiUsageJsonl(filePath, context) {
+  const rl = createInterface3({
+    input: createReadStream3(filePath, { encoding: "utf-8" }),
+    crlfDelay: Infinity
+  });
+  for await (const line of rl) {
+    if (!line.trim()) {
+      continue;
+    }
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type !== "message") {
+        continue;
+      }
+      const message = entry.message;
+      if (!message || message.role !== "assistant") {
+        continue;
+      }
+      const usage2 = asRecord5(message.usage);
+      if (!usage2) {
+        continue;
+      }
+      const inputTokens = numberValue5(usage2["input"]);
+      const outputTokens = numberValue5(usage2["output"]);
+      const cacheReadTokens = numberValue5(usage2["cacheRead"]);
+      const cacheWriteTokens = numberValue5(usage2["cacheWrite"]);
+      if (inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens === 0) {
+        continue;
+      }
+      const timestamp = typeof entry.timestamp === "string" ? entry.timestamp : typeof message.timestamp === "number" ? new Date(message.timestamp).toISOString() : void 0;
+      if (context.since && timestamp) {
+        const ts = new Date(timestamp);
+        if (ts < context.since) {
+          continue;
+        }
+      }
+      const responseModel = stringValue5(message.responseModel);
+      const model = responseModel ?? stringValue5(message.model);
+      yield {
+        agent: "pi",
+        provider: responseModel?.includes("/") ? void 0 : stringValue5(message.provider),
+        model,
+        timestamp,
+        session: context.session,
+        inputTokens,
+        outputTokens,
+        reasoningTokens: 0,
+        cacheReadTokens,
+        cacheWriteTokens
+      };
+    } catch {
+    }
+  }
+}
 function contentToString2(content) {
-  if (typeof content === "string") return content;
+  if (typeof content === "string") {
+    return content;
+  }
   if (Array.isArray(content)) {
     const parts = content.filter(
       (p) => typeof p === "object" && p !== null && p.type === "text" && typeof p.text === "string"
@@ -493,27 +1640,36 @@ function contentToString2(content) {
   }
   return null;
 }
+function numberValue5(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function stringValue5(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function asRecord5(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
 
 // src/adapters/zed.ts
-import { readdir as readdir6, readFile as readFile3 } from "node:fs/promises";
-import { existsSync as existsSync3 } from "node:fs";
-import { homedir as homedir7 } from "node:os";
-import { join as join7 } from "node:path";
+import { readdir as readdir7, readFile as readFile3 } from "node:fs/promises";
+import { existsSync as existsSync4 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { join as join8 } from "node:path";
 function getZedPaths() {
   if (process.platform === "darwin") {
-    const base2 = join7(homedir7(), "Library", "Application Support", "Zed");
+    const base2 = join8(homedir8(), "Library", "Application Support", "Zed");
     return {
-      conversations: join7(base2, "conversations"),
-      db: join7(base2, "db")
+      conversations: join8(base2, "conversations"),
+      db: join8(base2, "db")
     };
   }
-  const base = join7(
-    process.env["XDG_DATA_HOME"] ?? join7(homedir7(), ".local", "share"),
-    "zed"
-  );
+  const base = join8(process.env["XDG_DATA_HOME"] ?? join8(homedir8(), ".local", "share"), "zed");
   return {
-    conversations: join7(base, "conversations"),
-    db: join7(base, "db")
+    conversations: join8(base, "conversations"),
+    db: join8(base, "db")
   };
 }
 function zedAdapter() {
@@ -527,25 +1683,33 @@ function zedAdapter() {
   };
 }
 async function* parseTextThreads(dir, _options) {
-  if (!existsSync3(dir)) return;
+  if (!existsSync4(dir)) {
+    return;
+  }
   let files;
   try {
-    files = await readdir6(dir);
+    files = await readdir7(dir);
   } catch {
     return;
   }
   const jsonFiles = files.filter((f) => f.endsWith(".json"));
   for (const file of jsonFiles) {
-    const filePath = join7(dir, file);
+    const filePath = join8(dir, file);
     const session = file.replace(".json", "");
     try {
       const raw = await readFile3(filePath, "utf-8");
       const conversation = JSON.parse(raw);
-      if (!conversation.messages || !Array.isArray(conversation.messages)) continue;
+      if (!conversation.messages || !Array.isArray(conversation.messages)) {
+        continue;
+      }
       for (const msg of conversation.messages) {
-        if (msg.role !== "user") continue;
+        if (msg.role !== "user") {
+          continue;
+        }
         const text = typeof msg.content === "string" ? msg.content : null;
-        if (!text) continue;
+        if (!text) {
+          continue;
+        }
         yield {
           text,
           session
@@ -556,15 +1720,19 @@ async function* parseTextThreads(dir, _options) {
   }
 }
 async function* parseAgentThreads(dbDir, _options) {
-  if (!existsSync3(dbDir)) return;
+  if (!existsSync4(dbDir)) {
+    return;
+  }
   let dbFiles;
   try {
-    const entries = await readdir6(dbDir);
+    const entries = await readdir7(dbDir);
     dbFiles = entries.filter((f) => f.endsWith(".db"));
   } catch {
     return;
   }
-  if (dbFiles.length === 0) return;
+  if (dbFiles.length === 0) {
+    return;
+  }
   let Database;
   try {
     const mod = await import("better-sqlite3");
@@ -573,13 +1741,12 @@ async function* parseAgentThreads(dbDir, _options) {
     return;
   }
   for (const dbFile of dbFiles) {
-    const dbPath = join7(dbDir, dbFile);
+    const dbPath = join8(dbDir, dbFile);
     let db;
     try {
-      db = new Database(
-        dbPath,
-        { readonly: true }
-      );
+      db = new Database(dbPath, {
+        readonly: true
+      });
     } catch {
       continue;
     }
@@ -604,7 +1771,9 @@ async function* parseAgentThreads(dbDir, _options) {
       let query = `SELECT "${contentCol}" as text FROM "${msgTable}" WHERE role = 'user'`;
       const rows = db.prepare(query).all();
       for (const row of rows) {
-        if (!row.text?.trim()) continue;
+        if (!row.text?.trim()) {
+          continue;
+        }
         yield { text: row.text };
       }
     } catch {
@@ -618,6 +1787,7 @@ async function* parseAgentThreads(dbDir, _options) {
 var ADAPTERS = {
   claude: claudeAdapter,
   codex: codexAdapter,
+  cursor: cursorAdapter,
   opencode: opencodeAdapter,
   amp: ampAdapter,
   cline: clineAdapter,
@@ -627,9 +1797,7 @@ var ADAPTERS = {
 function createAdapter(name) {
   const factory = ADAPTERS[name];
   if (!factory) {
-    throw new Error(
-      `unknown adapter: ${name} (available: ${Object.keys(ADAPTERS).join(", ")})`
-    );
+    throw new Error(`unknown adapter: ${name} (available: ${Object.keys(ADAPTERS).join(", ")})`);
   }
   return factory();
 }
@@ -773,10 +1941,14 @@ function runPattern(_originalText, searchText, matches, seen) {
   DEFAULT_PATTERN.lastIndex = 0;
   let match;
   while ((match = DEFAULT_PATTERN.exec(searchText)) !== null) {
-    if (seen.has(match.index)) continue;
+    if (seen.has(match.index)) {
+      continue;
+    }
     const word = match[0].toLowerCase();
     const entry = WORD_MAP.get(word);
-    if (!entry) continue;
+    if (!entry) {
+      continue;
+    }
     seen.add(match.index);
     matches.push({
       word,
@@ -787,6 +1959,450 @@ function runPattern(_originalText, searchText, matches, seen) {
   }
 }
 
+// src/pricing/index.ts
+import { mkdir, readFile as readFile4, writeFile } from "node:fs/promises";
+import { homedir as homedir9 } from "node:os";
+import { dirname, join as join9 } from "node:path";
+var MODELS_DEV_URL = "https://models.dev/api.json";
+var CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 2e3;
+var FALLBACK_COSTS = {
+  openai: {
+    "gpt-5.5": {
+      input: 5,
+      output: 30,
+      cache_read: 0.5,
+      context_over_200k: { input: 10, output: 45, cache_read: 1 }
+    },
+    "gpt-5.5-pro": { input: 30, output: 180 },
+    "gpt-5.4": { input: 2.5, output: 15, cache_read: 0.25 },
+    "gpt-5.4-mini": { input: 0.75, output: 4.5, cache_read: 0.075 },
+    "gpt-5.4-nano": { input: 0.2, output: 1.25, cache_read: 0.02 },
+    "gpt-5.4-pro": { input: 30, output: 180 },
+    "gpt-5.3-codex": { input: 1.75, output: 14, cache_read: 0.175 }
+  },
+  anthropic: {
+    "claude-opus-4-7": { input: 5, output: 25, cache_read: 0.5, cache_write: 6.25 }
+  }
+};
+var PROVIDER_ALIASES = {
+  anthropic: "anthropic",
+  claude: "anthropic",
+  openai: "openai"
+};
+async function loadPricingCatalog(options = {}) {
+  const cachePath = getPricingCachePath();
+  const cache = await readPricingCache(cachePath);
+  const ttlMs = options.cacheTtlMs ?? CACHE_TTL_MS;
+  if (!options.refresh && cache && isFresh(cache.fetchedAt, ttlMs)) {
+    return {
+      source: "catalog",
+      fetchedAt: cache.fetchedAt,
+      cachePath,
+      catalog: cache.catalog
+    };
+  }
+  try {
+    const catalog = await fetchModelsDevCatalog(options.fetchTimeoutMs ?? FETCH_TIMEOUT_MS);
+    const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await writePricingCache(cachePath, {
+      source: "models.dev",
+      fetchedAt,
+      schemaVersion: 1,
+      catalog
+    });
+    return { source: "catalog", fetchedAt, cachePath, catalog };
+  } catch {
+    if (cache) {
+      return {
+        source: "stale-catalog",
+        fetchedAt: cache.fetchedAt,
+        cachePath,
+        catalog: cache.catalog
+      };
+    }
+    return { source: "fallback", cachePath };
+  }
+}
+async function summarizeUsage(records, pricing) {
+  const total = createCostAccumulator();
+  const byDay = /* @__PURE__ */ new Map();
+  for await (const record of records) {
+    const priced = priceUsageRecord(record, pricing);
+    const billedCost = record.billedCost ?? 0;
+    const isUnpriced = priced.source === "stored" || priced.source === "unknown";
+    addUsageToAccumulator(total, record, priced, billedCost, isUnpriced);
+    const day = timestampDay(record.timestamp);
+    if (day) {
+      let dayAccumulator = byDay.get(day);
+      if (!dayAccumulator) {
+        dayAccumulator = createCostAccumulator();
+        byDay.set(day, dayAccumulator);
+      }
+      addUsageToAccumulator(dayAccumulator, record, priced, billedCost, isUnpriced);
+    }
+  }
+  return {
+    requests: total.requests,
+    estimatedCost: total.estimatedCost,
+    billedCost: total.billedCost,
+    unpricedRequests: total.unpricedRequests,
+    inputTokens: total.inputTokens,
+    outputTokens: total.outputTokens,
+    reasoningTokens: total.reasoningTokens,
+    cacheReadTokens: total.cacheReadTokens,
+    cacheWriteTokens: total.cacheWriteTokens,
+    models: sortedModels(total.byModel),
+    days: Array.from(byDay.entries()).sort(([left], [right]) => left.localeCompare(right)).map(([day, bucket]) => costDaySummary(day, bucket)),
+    pricing: {
+      source: pricing.source,
+      fetchedAt: pricing.fetchedAt
+    }
+  };
+}
+function getPricingCachePath() {
+  if (process.env["XDG_CACHE_HOME"]) {
+    return join9(process.env["XDG_CACHE_HOME"], "devrage", "models.dev.json");
+  }
+  if (process.platform === "darwin") {
+    return join9(homedir9(), "Library", "Caches", "devrage", "models.dev.json");
+  }
+  if (process.platform === "win32") {
+    const localAppData = process.env["LOCALAPPDATA"] ?? join9(homedir9(), "AppData", "Local");
+    return join9(localAppData, "devrage", "models.dev.json");
+  }
+  return join9(homedir9(), ".cache", "devrage", "models.dev.json");
+}
+function createCostAccumulator() {
+  return {
+    requests: 0,
+    estimatedCost: 0,
+    billedCost: 0,
+    unpricedRequests: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    reasoningTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    byModel: /* @__PURE__ */ new Map()
+  };
+}
+function addUsageToAccumulator(bucket, record, priced, billedCost, isUnpriced) {
+  const key = `${priced.provider ?? ""}:${priced.model}`;
+  let model = bucket.byModel.get(key);
+  if (!model) {
+    model = {
+      model: priced.model,
+      provider: priced.provider,
+      requests: 0,
+      estimatedCost: 0,
+      billedCost: 0,
+      pricingSource: priced.source,
+      unpricedRequests: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      reasoningTokens: 0,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0
+    };
+    bucket.byModel.set(key, model);
+  }
+  model.requests += 1;
+  model.estimatedCost += priced.estimatedCost;
+  model.billedCost += billedCost;
+  model.pricingSource = mergePricingSource(model.pricingSource, priced.source);
+  model.inputTokens += record.inputTokens;
+  model.outputTokens += record.outputTokens;
+  model.reasoningTokens += record.reasoningTokens;
+  model.cacheReadTokens += record.cacheReadTokens;
+  model.cacheWriteTokens += record.cacheWriteTokens;
+  bucket.requests += 1;
+  bucket.estimatedCost += priced.estimatedCost;
+  bucket.billedCost += billedCost;
+  bucket.inputTokens += record.inputTokens;
+  bucket.outputTokens += record.outputTokens;
+  bucket.reasoningTokens += record.reasoningTokens;
+  bucket.cacheReadTokens += record.cacheReadTokens;
+  bucket.cacheWriteTokens += record.cacheWriteTokens;
+  if (isUnpriced) {
+    model.unpricedRequests += 1;
+    bucket.unpricedRequests += 1;
+  }
+}
+function costDaySummary(day, bucket) {
+  return {
+    day,
+    requests: bucket.requests,
+    estimatedCost: bucket.estimatedCost,
+    billedCost: bucket.billedCost,
+    unpricedRequests: bucket.unpricedRequests,
+    inputTokens: bucket.inputTokens,
+    outputTokens: bucket.outputTokens,
+    reasoningTokens: bucket.reasoningTokens,
+    cacheReadTokens: bucket.cacheReadTokens,
+    cacheWriteTokens: bucket.cacheWriteTokens,
+    models: sortedModels(bucket.byModel)
+  };
+}
+function sortedModels(byModel) {
+  return Array.from(byModel.values()).sort(
+    (a, b) => b.estimatedCost - a.estimatedCost || b.requests - a.requests
+  );
+}
+function timestampDay(timestamp) {
+  if (!timestamp) {
+    return null;
+  }
+  const time = new Date(timestamp).getTime();
+  if (!Number.isFinite(time)) {
+    return null;
+  }
+  return new Date(time).toISOString().slice(0, 10);
+}
+async function fetchModelsDevCatalog(timeoutMs) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(MODELS_DEV_URL, { signal: controller.signal });
+    if (!response.ok) {
+      throw new Error(`models.dev returned ${response.status}`);
+    }
+    const catalog = await response.json();
+    if (!isModelsDevCatalog(catalog)) {
+      throw new Error("models.dev response did not match expected shape");
+    }
+    return catalog;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function readPricingCache(cachePath) {
+  try {
+    const raw = await readFile4(cachePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const cache = asRecord6(parsed);
+    if (cache?.["source"] !== "models.dev" || cache["schemaVersion"] !== 1 || typeof cache["fetchedAt"] !== "string" || !isModelsDevCatalog(cache["catalog"])) {
+      return null;
+    }
+    return {
+      source: "models.dev",
+      fetchedAt: cache["fetchedAt"],
+      schemaVersion: 1,
+      catalog: cache["catalog"]
+    };
+  } catch {
+    return null;
+  }
+}
+async function writePricingCache(cachePath, cache) {
+  try {
+    await mkdir(dirname(cachePath), { recursive: true });
+    await writeFile(cachePath, `${JSON.stringify(cache)}
+`, "utf-8");
+  } catch {
+  }
+}
+function priceUsageRecord(record, catalog) {
+  const resolved = resolveRates(record, catalog);
+  if (!resolved) {
+    return {
+      provider: normalizeProvider(record.provider),
+      model: normalizeModel(record.model) ?? "unknown",
+      estimatedCost: 0,
+      source: (record.billedCost ?? 0) > 0 ? "stored" : "unknown"
+    };
+  }
+  const rates = selectContextRates(resolved.rates, record);
+  const inputRate = rates.input ?? 0;
+  const outputRate = rates.output ?? 0;
+  const cacheReadRate = rates.cache_read ?? inputRate;
+  const cacheWriteRate = rates.cache_write ?? inputRate;
+  const outputTokens = record.outputTokens + record.reasoningTokens;
+  return {
+    provider: resolved.provider,
+    model: resolved.model,
+    estimatedCost: (record.inputTokens * inputRate + record.cacheReadTokens * cacheReadRate + record.cacheWriteTokens * cacheWriteRate + outputTokens * outputRate) / 1e6,
+    source: resolved.source
+  };
+}
+function resolveRates(record, pricing) {
+  const candidates = modelCandidates(record.provider, record.model);
+  for (const candidate of candidates) {
+    if (!candidate.provider || !pricing.catalog) {
+      continue;
+    }
+    const rates = getCatalogRates(pricing.catalog, candidate.provider, candidate.model);
+    if (rates) {
+      return {
+        provider: candidate.provider,
+        model: candidate.model,
+        rates,
+        source: pricing.source === "stale-catalog" ? "stale-catalog" : "catalog"
+      };
+    }
+  }
+  for (const candidate of candidates) {
+    if (!candidate.provider) {
+      continue;
+    }
+    const providerRates = FALLBACK_COSTS[candidate.provider];
+    const rates = providerRates?.[candidate.model];
+    if (rates) {
+      return { provider: candidate.provider, model: candidate.model, rates, source: "fallback" };
+    }
+  }
+  return null;
+}
+function modelCandidates(providerInput, modelInput) {
+  const candidates = [];
+  let provider = normalizeProvider(providerInput);
+  let model = normalizeModel(modelInput);
+  if (!model) {
+    return candidates;
+  }
+  const prefixed = splitProviderModel(model);
+  if (prefixed) {
+    provider = provider ?? prefixed.provider;
+    model = prefixed.model;
+  }
+  addCandidate(candidates, provider, model);
+  addCandidate(candidates, provider, MODEL_ALIASES[model]);
+  const inferred = provider ?? inferProvider(model);
+  addCandidate(candidates, inferred, model);
+  addCandidate(candidates, inferred, MODEL_ALIASES[model]);
+  for (const fallbackProvider of Object.keys(FALLBACK_COSTS)) {
+    addCandidate(candidates, fallbackProvider, model);
+    addCandidate(candidates, fallbackProvider, MODEL_ALIASES[model]);
+  }
+  return candidates;
+}
+var MODEL_ALIASES = {
+  "gpt-5.5-chat-latest": "gpt-5.5"
+};
+function addCandidate(candidates, provider, model) {
+  if (!model) {
+    return;
+  }
+  if (candidates.some((candidate) => candidate.provider === provider && candidate.model === model)) {
+    return;
+  }
+  candidates.push({ provider, model });
+}
+function splitProviderModel(model) {
+  const slash = model.indexOf("/");
+  if (slash <= 0 || slash === model.length - 1) {
+    return null;
+  }
+  const provider = normalizeProvider(model.slice(0, slash));
+  const bareModel = normalizeModel(model.slice(slash + 1));
+  if (!provider || !bareModel) {
+    return null;
+  }
+  return { provider, model: bareModel };
+}
+function normalizeProvider(provider) {
+  if (!provider) {
+    return void 0;
+  }
+  const normalized = provider.trim().toLowerCase();
+  return PROVIDER_ALIASES[normalized] ?? normalized;
+}
+function normalizeModel(model) {
+  const normalized = model?.trim().toLowerCase();
+  return normalized || void 0;
+}
+function inferProvider(model) {
+  if (model.startsWith("gpt-") || /^o\d/.test(model)) {
+    return "openai";
+  }
+  if (model.startsWith("claude-")) {
+    return "anthropic";
+  }
+  return void 0;
+}
+function getCatalogRates(catalog, provider, model) {
+  const root = asRecord6(catalog);
+  const providerEntry = asRecord6(root?.[provider]);
+  const models = asRecord6(providerEntry?.["models"]);
+  const modelEntry = asRecord6(models?.[model]);
+  return toRateTable(modelEntry?.["cost"]);
+}
+function selectContextRates(rates, record) {
+  const contextTokens = record.inputTokens + record.cacheReadTokens + record.cacheWriteTokens;
+  let selected = rates;
+  let selectedSize = 0;
+  for (const tier of rates.tiers ?? []) {
+    const tierRecord = asRecord6(tier);
+    const tierInfo = asRecord6(tierRecord?.["tier"]);
+    const size = typeof tierInfo?.["size"] === "number" ? tierInfo["size"] : 0;
+    if (tierInfo?.["type"] !== "context" || contextTokens < size || size < selectedSize) {
+      continue;
+    }
+    const tierRates = toRateTable(tierRecord);
+    if (tierRates) {
+      selected = { ...rates, ...tierRates };
+      selectedSize = size;
+    }
+  }
+  if (selected === rates && rates.context_over_200k && contextTokens > 2e5) {
+    selected = { ...rates, ...rates.context_over_200k };
+  }
+  return selected;
+}
+function toRateTable(value) {
+  const record = asRecord6(value);
+  if (!record) {
+    return null;
+  }
+  const rates = {};
+  const input = numberValue6(record["input"]);
+  const output = numberValue6(record["output"]);
+  const cacheRead = numberValue6(record["cache_read"]);
+  const cacheWrite = numberValue6(record["cache_write"]);
+  const contextOver200k = toRateTable(record["context_over_200k"]);
+  if (input !== void 0) {
+    rates.input = input;
+  }
+  if (output !== void 0) {
+    rates.output = output;
+  }
+  if (cacheRead !== void 0) {
+    rates.cache_read = cacheRead;
+  }
+  if (cacheWrite !== void 0) {
+    rates.cache_write = cacheWrite;
+  }
+  if (Array.isArray(record["tiers"])) {
+    rates.tiers = record["tiers"];
+  }
+  if (contextOver200k) {
+    rates.context_over_200k = contextOver200k;
+  }
+  return rates.input !== void 0 || rates.output !== void 0 ? rates : null;
+}
+function numberValue6(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function isModelsDevCatalog(value) {
+  const catalog = asRecord6(value);
+  const openai = asRecord6(catalog?.["openai"]);
+  const anthropic = asRecord6(catalog?.["anthropic"]);
+  return Boolean(asRecord6(openai?.["models"]) || asRecord6(anthropic?.["models"]));
+}
+function isFresh(fetchedAt, ttlMs) {
+  const fetchedTime = new Date(fetchedAt).getTime();
+  return Number.isFinite(fetchedTime) && Date.now() - fetchedTime <= ttlMs;
+}
+function mergePricingSource(left, right) {
+  return left === right ? left : "mixed";
+}
+function asRecord6(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+
 // src/commands/scan.ts
 var c = {
   reset: "\x1B[0m",
@@ -801,6 +2417,7 @@ var c = {
   white: "\x1B[37m",
   gray: "\x1B[90m"
 };
+var MAX_TERMINAL_MODELS = 10;
 var SPINNER_MESSAGES = [
   "Tallying the damage",
   "Reviewing your outbursts",
@@ -813,20 +2430,19 @@ var SPINNER_MESSAGES = [
   "Auditing your language",
   "Tabulating regrets"
 ];
-function createSpinner() {
+var DAY_MS = 24 * 60 * 60 * 1e3;
+function createSpinner(messages = SPINNER_MESSAGES) {
   let messageIdx = 0;
   let dotCount = 0;
   let timer = null;
   return {
     start() {
-      messageIdx = Math.floor(Math.random() * SPINNER_MESSAGES.length);
+      messageIdx = Math.floor(Math.random() * messages.length);
       timer = setInterval(() => {
         dotCount = (dotCount + 1) % 4;
-        const msg = SPINNER_MESSAGES[messageIdx % SPINNER_MESSAGES.length];
+        const msg = messages[messageIdx % messages.length];
         const dots = ".".repeat(dotCount || 1);
-        process.stdout.write(
-          `\r  ${c.dim}${msg}${dots}${c.reset}   `
-        );
+        process.stdout.write(`\r  ${c.dim}${msg}${dots}${c.reset}   `);
       }, 300);
     },
     update() {
@@ -850,24 +2466,106 @@ function parseArgs(args) {
     } else if (arg === "--since" || arg === "-s") {
       const val = args[++i];
       if (val) {
-        options.since = new Date(val);
-        if (isNaN(options.since.getTime())) {
-          console.error(`invalid date: ${val}`);
-          process.exit(1);
-        }
+        setAbsoluteSince(options, val);
       }
+    } else if (arg === "--day" || arg === "--days") {
+      const parsed = readOptionalDaysArg(args, i);
+      setRelativeRange(options, parsed.days);
+      if (parsed.consumed) {
+        i++;
+      }
+    } else if (arg === "--week") {
+      setRelativeRange(options, 7);
+    } else if (arg === "--month") {
+      setRelativeRange(options, 30);
     } else if (arg === "--help" || arg === "-h") {
       console.log(`devrage scan \u2014 scan sessions for profanity
 
 Options:
-  --agent, -a <name>   Scan only a specific agent (claude, codex, opencode, amp, cline, pi, zed)
+  --agent, -a <name>   Scan only a specific agent (claude, codex, cursor, opencode, amp, cline, pi, zed)
   --since, -s <date>   Only scan messages after this date (ISO 8601)
+  --day, --days [n]    Only scan the last n days (default: 1)
+  --week               Only scan the last 7 days
+  --month              Only scan the last 30 days
+  --help, -h           Show this help`);
+      process.exit(0);
+    }
+  }
+  return options;
+}
+function parseCostArgs(args) {
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--agent" || arg === "-a") {
+      options.agent = args[++i];
+    } else if (arg === "--refresh-prices") {
+      options.refreshPrices = true;
+    } else if (arg === "--since" || arg === "-s") {
+      const val = args[++i];
+      if (val) {
+        setAbsoluteSince(options, val);
+      }
+    } else if (arg === "--day" || arg === "--days") {
+      const parsed = readOptionalDaysArg(args, i);
+      setRelativeRange(options, parsed.days);
+      if (parsed.consumed) {
+        i++;
+      }
+    } else if (arg === "--week") {
+      setRelativeRange(options, 7);
+    } else if (arg === "--month") {
+      setRelativeRange(options, 30);
+    } else if (arg === "--help" || arg === "-h") {
+      console.log(`devrage cost \u2014 show API-equivalent coding agent cost
+
+Usage:
+  devrage cost [options]
+
+Options:
+  --agent, -a <name>   Show only a specific agent (claude, codex, cursor, opencode, amp, pi)
+  --refresh-prices     Refresh models.dev pricing before estimating cost
+  --since, -s <date>   Only include usage after this date (ISO 8601)
+  --day, --days [n]    Only include the last n days (default: 1)
+  --week               Only include the last 7 days
+  --month              Only include the last 30 days
   --help, -h           Show this help`);
       process.exit(0);
     }
   }
   return options;
 }
+function setAbsoluteSince(options, value) {
+  options.since = parseDateArg(value);
+  options.rangeLabel = void 0;
+}
+function setRelativeRange(options, days) {
+  options.since = new Date(Date.now() - days * DAY_MS);
+  options.rangeLabel = `last ${days} ${days === 1 ? "day" : "days"}`;
+}
+function readOptionalDaysArg(args, index) {
+  const value = args[index + 1];
+  if (!value || value.startsWith("-") && !/^-\d+$/.test(value)) {
+    return { days: 1, consumed: false };
+  }
+  return { days: parseDaysArg(value), consumed: true };
+}
+function parseDaysArg(value) {
+  const days = Number(value);
+  if (!Number.isInteger(days) || days < 1) {
+    console.error(`invalid days: ${value ?? ""}`);
+    process.exit(1);
+  }
+  return days;
+}
+function parseDateArg(value) {
+  const date = new Date(value);
+  if (isNaN(date.getTime())) {
+    console.error(`invalid date: ${value}`);
+    process.exit(1);
+  }
+  return date;
+}
 async function scan(args) {
   const options = parseArgs(args);
   const adapters = options.agent ? [createAdapter(options.agent)] : allAdapters();
@@ -901,27 +2599,24 @@ async function scan(args) {
     }
   }
   spinner.stop();
-  console.log("");
-  console.log(`  ${c.bold}${c.red}devrage${c.reset} ${c.dim}report${c.reset}`);
-  console.log(`  ${c.dim}${"\u2500".repeat(30)}${c.reset}`);
-  console.log("");
-  console.log(`  ${c.dim}messages scanned${c.reset}  ${c.bold}${totalMessages}${c.reset}`);
-  console.log(`  ${c.dim}total swears${c.reset}      ${c.bold}${c.red}${totalSwears}${c.reset}`);
   const activeAgents = Object.entries(perAgent);
+  console.log("");
+  printReportHeader(options);
+  printBasicOverview(totalMessages, totalSwears);
   if (activeAgents.length > 1) {
     console.log("");
-    console.log(`  ${c.bold}by agent${c.reset}`);
+    console.log(`  ${sectionTitle("agent language")}`);
     for (const [name, stats] of activeAgents) {
       const rate = (stats.swears / stats.messages * 100).toFixed(1);
       console.log(
-        `    ${c.cyan}${name.padEnd(10)}${c.reset} ${c.bold}${String(stats.swears).padStart(4)}${c.reset} ${c.dim}in ${stats.messages} messages (${rate}%)${c.reset}`
+        `    ${colorText(name.padEnd(10), agentColor(name))} ${c.bold}${String(stats.swears).padStart(4)}${c.reset} ${c.dim}in ${stats.messages} messages (${rate}%)${c.reset}`
       );
     }
   }
   if (totalSwears > 0) {
     const sorted = Object.entries(groupTally).sort(([, a], [, b]) => b - a);
     console.log("");
-    console.log(`  ${c.bold}top words${c.reset}`);
+    console.log(`  ${sectionTitle("top words")}`);
     for (const [group, count] of sorted.slice(0, 10)) {
       const variants = variantTally[group] ?? {};
       const variantList = Object.entries(variants).sort(([, a], [, b]) => b - a).filter(([v]) => v !== group).slice(0, 15).map(([v, cnt]) => `${c.dim}${v}${c.reset} ${cnt}`).join(`${c.dim},${c.reset} `);
@@ -937,11 +2632,521 @@ async function scan(args) {
     console.log("");
   }
 }
+async function cost(args) {
+  const options = parseCostArgs(args);
+  const adapters = options.agent ? [createAdapter(options.agent)] : allAdapters();
+  const costByAgent = {};
+  const pricing = await loadPricingCatalog({ refresh: options.refreshPrices });
+  for (const adapter of adapters) {
+    if (!adapter.usage) {
+      continue;
+    }
+    const summary = await summarizeUsage(adapter.usage({ since: options.since }), pricing);
+    if (summary.requests > 0) {
+      costByAgent[adapter.name] = summary;
+    }
+  }
+  const totals = getCostTotals(costByAgent);
+  console.log("");
+  if (totals.entries.length === 0) {
+    printCostCommandUnavailable(options);
+    return;
+  }
+  const reportUrl = await writeCostHtmlReport(totals, options);
+  printCostCommand(totals, options, reportUrl);
+}
+function printCostCommand(totals, options, reportUrl) {
+  const modelTotals = aggregateModelCosts(totals.entries);
+  printCompactHeader(options);
+  printCompactTotal(totals);
+  printCompactAgents(totals.entries);
+  printCompactModels(modelTotals, totals.totalCost);
+  console.log("");
+  console.log(`  ${c.dim}Report:${c.reset} ${reportUrl}`);
+  console.log("");
+}
+function printCompactHeader(options) {
+  const filters = [
+    options.agent,
+    options.rangeLabel ?? (options.since ? `since ${formatDate(options.since)}` : null)
+  ].filter(Boolean);
+  const suffix = filters.length > 0 ? ` ${c.dim}${filters.join(" \xB7 ")}${c.reset}` : "";
+  console.log(`  ${c.bold}${c.red}devrage${c.reset} ${c.dim}cost${c.reset}${suffix}`);
+  console.log("");
+}
+function compactMeta(totals) {
+  const parts = [formatRequests(totals.pricedRequests)];
+  if (totals.unpricedRequests > 0) {
+    parts.push(`${formatNumber(totals.unpricedRequests)} unpriced`);
+  }
+  return `${c.dim}${parts.join(" \xB7 ")}${c.reset}`;
+}
+function printCompactTotal(totals) {
+  console.log(`  ${c.bold}total${c.reset}`);
+  console.log(
+    `    ${c.bold}${c.green}${formatCurrency(totals.totalCost)}${c.reset}  ${compactMeta(totals)}`
+  );
+}
+function printCompactModels(models, totalCost) {
+  if (models.length === 0) {
+    return;
+  }
+  const visibleModels = models.slice(0, MAX_TERMINAL_MODELS);
+  const maxCost = visibleModels[0]?.estimatedCost ?? 0;
+  console.log("");
+  console.log(`  ${c.bold}models${c.reset}`);
+  for (const model of visibleModels) {
+    const share = totalCost > 0 ? model.estimatedCost / totalCost : 0;
+    const color = modelColor(model);
+    console.log(
+      `    ${colorText(clip(model.model, 27).padEnd(27), color)} ${formatCurrency(model.estimatedCost).padStart(9)} ${c.dim}${formatPercent(share).padStart(6)}${c.reset}  ${renderBar(model.estimatedCost, maxCost, 16, color)}`
+    );
+  }
+}
+function printCompactAgents(entries) {
+  console.log("");
+  console.log(`  ${c.bold}agents${c.reset}`);
+  for (const [name, stats] of entries.sort(
+    ([, left], [, right]) => right.estimatedCost - left.estimatedCost
+  )) {
+    const color = agentColor(name);
+    console.log(
+      `    ${colorText(name.padEnd(10), color)} ${colorText(formatCurrency(stats.estimatedCost).padStart(9), color)} ${c.dim}${formatRequests(stats.requests).padStart(12)}${c.reset}`
+    );
+  }
+}
+function printCostCommandUnavailable(options) {
+  printCompactHeader(options);
+  console.log(`  ${c.gray}no local usage found${c.reset}`);
+  console.log("");
+}
+async function writeCostHtmlReport(totals, options) {
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const reportPath = join10(
+    dirname2(getPricingCachePath()),
+    `cost-report-${safeTimestamp(generatedAt)}.html`
+  );
+  await mkdir2(dirname2(reportPath), { recursive: true });
+  await writeFile2(
+    reportPath,
+    renderCostHtmlReport(costReportData(totals, options, generatedAt)),
+    "utf-8"
+  );
+  return pathToFileURL(reportPath).href;
+}
+function safeTimestamp(value) {
+  return value.replace(/[:.]/g, "-");
+}
+function costReportData(totals, options, generatedAt) {
+  return {
+    generatedAt,
+    scope: options.rangeLabel ?? (options.since ? `since ${formatDate(options.since)}` : "all local history"),
+    totalCost: totals.totalCost,
+    pricedRequests: totals.pricedRequests,
+    unpricedRequests: totals.unpricedRequests,
+    agents: totals.entries.map(([name, summary]) => ({
+      name,
+      estimatedCost: summary.estimatedCost,
+      requests: summary.requests - summary.unpricedRequests,
+      models: summary.models.map(costReportModel),
+      days: summary.days.map((day) => ({
+        day: day.day,
+        estimatedCost: day.estimatedCost,
+        requests: day.requests - day.unpricedRequests,
+        models: day.models.map(costReportModel)
+      }))
+    })).sort((left, right) => right.estimatedCost - left.estimatedCost)
+  };
+}
+function costReportModel(model) {
+  return {
+    model: model.model,
+    provider: model.provider,
+    estimatedCost: model.estimatedCost,
+    requests: model.requests - model.unpricedRequests,
+    inputTokens: model.inputTokens,
+    outputTokens: model.outputTokens,
+    reasoningTokens: model.reasoningTokens,
+    cacheReadTokens: model.cacheReadTokens,
+    cacheWriteTokens: model.cacheWriteTokens
+  };
+}
+function renderCostHtmlReport(data) {
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>devrage cost report</title>
+  <style>
+    :root {
+      color-scheme: dark;
+      --bg: #0f1117;
+      --panel: #151923;
+      --panel-2: #10141c;
+      --border: #283040;
+      --text: #edf1f7;
+      --muted: #99a3b5;
+      --faint: #677184;
+      --green: #55c98f;
+      --purple: #b18cff;
+      --blue: #75a7ff;
+      --yellow: #e5b75f;
+      --cyan: #62c7df;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      background: var(--bg);
+      color: var(--text);
+      font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      line-height: 1.45;
+    }
+    main { width: min(1180px, calc(100vw - 32px)); margin: 0 auto; padding: 28px 0 48px; }
+    header { display: flex; justify-content: space-between; gap: 20px; align-items: end; margin-bottom: 22px; }
+    h1 { margin: 0; font-size: 22px; letter-spacing: -0.02em; }
+    .scope { color: var(--muted); font-size: 13px; margin-top: 4px; }
+    .generated { color: var(--faint); font-size: 12px; text-align: right; }
+    .summary { display: grid; grid-template-columns: 1.4fr repeat(3, 1fr); gap: 12px; margin-bottom: 18px; }
+    .card, .panel { border: 1px solid var(--border); background: var(--panel); }
+    .card { padding: 16px; min-height: 92px; }
+    .label { color: var(--muted); font-size: 11px; font-weight: 700; text-transform: uppercase; letter-spacing: 0.1em; }
+    .value { margin-top: 8px; font-size: 26px; font-weight: 800; letter-spacing: -0.03em; font-variant-numeric: tabular-nums; }
+    .primary .value { color: var(--green); font-size: 42px; }
+    .controls { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 12px; margin: 18px 0; }
+    label { display: grid; gap: 6px; color: var(--muted); font-size: 12px; font-weight: 700; text-transform: uppercase; letter-spacing: 0.08em; }
+    select { width: 100%; border: 1px solid var(--border); background: var(--panel-2); color: var(--text); padding: 10px 12px; font: inherit; border-radius: 0; }
+    .grid { display: grid; grid-template-columns: 1fr; gap: 14px; align-items: start; }
+    .panel { min-width: 0; }
+    .panel h2 { margin: 0; padding: 13px 14px; border-bottom: 1px solid var(--border); font-size: 13px; text-transform: uppercase; letter-spacing: 0.1em; color: var(--muted); }
+    .panel-body { padding: 14px; }
+    table { width: 100%; border-collapse: collapse; font-variant-numeric: tabular-nums; }
+    th, td { padding: 9px 8px; border-bottom: 1px solid #202838; text-align: left; white-space: nowrap; }
+    th { color: var(--faint); font-size: 11px; text-transform: uppercase; letter-spacing: 0.08em; }
+    td:not(:first-child), th:not(:first-child) { text-align: right; }
+    tr:last-child td { border-bottom: 0; }
+    .name { color: var(--text); font-weight: 650; }
+    .muted { color: var(--muted); }
+    .chart-wrap { min-width: 0; }
+    .chart { width: 100%; min-width: 0; height: 190px; display: grid; grid-auto-flow: column; grid-auto-columns: minmax(0, 1fr); gap: clamp(1px, 0.55vw, 8px); align-items: end; overflow: hidden; }
+    .bar-column { display: flex; align-items: end; min-width: 0; height: 190px; overflow: hidden; font-variant-numeric: tabular-nums; }
+    .chart-empty { align-self: center; }
+    .axis { position: relative; height: 24px; margin-top: 8px; border-top: 1px solid #202838; color: var(--muted); font-size: 10px; font-variant-numeric: tabular-nums; overflow: hidden; }
+    .axis-tick { position: absolute; top: 6px; transform: translateX(-50%); white-space: nowrap; }
+    .axis-tick.edge-start { transform: translateX(0); }
+    .axis-tick.edge-end { transform: translateX(-100%); }
+    .column-track { width: 100%; min-width: 0; height: 190px; display: flex; align-items: end; background: #202838; overflow: hidden; }
+    .column-fill { width: 100%; min-height: 2px; background: var(--cyan); }
+    .legend { display: flex; flex-wrap: wrap; gap: 10px 14px; color: var(--muted); font-size: 12px; margin-top: 12px; }
+    .dot { display: inline-block; width: 9px; height: 9px; margin-right: 5px; background: var(--cyan); }
+    .tooltip { position: fixed; z-index: 20; display: none; pointer-events: none; border: 1px solid var(--border); background: #0b0e14; color: var(--text); padding: 7px 9px; font-size: 12px; font-variant-numeric: tabular-nums; box-shadow: 0 8px 20px rgba(0, 0, 0, 0.35); }
+    .tooltip .sub { color: var(--muted); margin-top: 2px; }
+    .green { color: var(--green); } .purple { color: var(--purple); } .blue { color: var(--blue); } .yellow { color: var(--yellow); } .cyan { color: var(--cyan); }
+    .bg-green { background: var(--green); } .bg-purple { background: var(--purple); } .bg-blue { background: var(--blue); } .bg-yellow { background: var(--yellow); } .bg-cyan { background: var(--cyan); }
+    @media (max-width: 900px) { header, .grid { display: block; } .summary, .controls { grid-template-columns: 1fr; } .panel { margin-top: 14px; } .generated { text-align: left; margin-top: 8px; } }
+  </style>
+</head>
+<body>
+  <main>
+    <header>
+      <div>
+        <h1>devrage cost report</h1>
+        <div class="scope" id="scope"></div>
+      </div>
+      <div class="generated" id="generated"></div>
+    </header>
+    <section class="summary">
+      <div class="card primary"><div class="label">total</div><div class="value" id="totalCost"></div></div>
+      <div class="card"><div class="label">requests</div><div class="value" id="requestCount"></div></div>
+      <div class="card"><div class="label">models</div><div class="value" id="modelCount"></div></div>
+      <div class="card"><div class="label">agents</div><div class="value" id="agentCount"></div></div>
+    </section>
+    <section class="controls">
+      <label>Agent<select id="agentFilter"></select></label>
+      <label>Model<select id="modelFilter"></select></label>
+      <label>Range<select id="rangeFilter"><option value="all">All included data</option><option value="7">Last 7 days</option><option value="30">Last 30 days</option><option value="90">Last 90 days</option></select></label>
+    </section>
+    <section class="grid">
+      <div class="panel"><h2>Agents</h2><div class="panel-body"><table><thead><tr><th>Agent</th><th>Cost</th><th>Reqs</th></tr></thead><tbody id="agentRows"></tbody></table></div></div>
+      <div class="panel"><h2>Models</h2><div class="panel-body"><table><thead><tr><th>Model</th><th>Cost</th><th>Share</th><th>Reqs</th><th>Input</th><th>Output</th><th>Cache</th></tr></thead><tbody id="modelRows"></tbody></table><div class="legend"><span><i class="dot bg-purple"></i>Claude/Anthropic</span><span><i class="dot bg-green"></i>OpenAI</span><span><i class="dot bg-blue"></i>Google</span><span><i class="dot bg-yellow"></i>Kimi/GLM</span></div></div></div>
+      <div class="panel"><h2>Daily</h2><div class="panel-body"><div class="chart-wrap"><div class="chart" id="dailyChart"></div><div class="axis" id="dailyAxis"></div></div></div></div>
+    </section>
+    <div class="tooltip" id="tooltip"></div>
+  </main>
+  <script>
+    const DATA = ${jsonForScript(data)};
+    const $ = (id) => document.getElementById(id);
+    const money = (value) => '$' + (Math.floor(Math.max(0, value) * 100 + 1e-9) / 100).toFixed(2);
+    const number = (value) => Math.round(value).toLocaleString('en-US');
+    const pct = (value) => (value * 100).toFixed(1) + '%';
+    const esc = (value) => String(value).replace(/[&<>"']/g, (ch) => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[ch]));
+    const modelClass = (name, provider) => {
+      const model = String(name || '').toLowerCase();
+      const p = String(provider || '').toLowerCase();
+      if (p === 'anthropic' || model.startsWith('claude-')) return 'purple';
+      if (p === 'openai' || model.startsWith('gpt-') || /^o\\d/.test(model)) return 'green';
+      if (p === 'google' || model.startsWith('gemini-')) return 'blue';
+      if (model.startsWith('kimi-') || model.startsWith('glm-')) return 'yellow';
+      return 'cyan';
+    };
+    const shortDate = (day) => new Date(day + 'T00:00:00.000Z').toLocaleDateString('en-US', {month:'short', day:'numeric', timeZone:'UTC'});
+    function dailyTicks(days) {
+      const count = days.length;
+      if (count === 0) return [];
+      const maxTicks = count <= 7 ? count : count <= 31 ? 6 : count <= 90 ? 7 : 9;
+      if (maxTicks <= 1) return [{index: 0, day: days[0].day}];
+      const ticks = [];
+      const seen = new Set();
+      for (let tick = 0; tick < maxTicks; tick++) {
+        const index = Math.round(((count - 1) * tick) / (maxTicks - 1));
+        if (seen.has(index)) continue;
+        seen.add(index);
+        ticks.push({index, day: days[index].day});
+      }
+      return ticks;
+    }
+    function addModel(map, incoming) {
+      const key = incoming.model;
+      const row = map.get(key) || {model: incoming.model, provider: incoming.provider, estimatedCost: 0, requests: 0, inputTokens: 0, outputTokens: 0, reasoningTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0};
+      row.estimatedCost += incoming.estimatedCost; row.requests += incoming.requests;
+      row.inputTokens += incoming.inputTokens; row.outputTokens += incoming.outputTokens; row.reasoningTokens += incoming.reasoningTokens;
+      row.cacheReadTokens += incoming.cacheReadTokens; row.cacheWriteTokens += incoming.cacheWriteTokens;
+      map.set(key, row);
+    }
+    function filteredAgents() {
+      const selected = $('agentFilter').value;
+      return DATA.agents.filter((agent) => selected === 'all' || agent.name === selected);
+    }
+    function dayAllowed(day) {
+      const range = $('rangeFilter').value;
+      if (range === 'all') return true;
+      const cutoff = new Date(DATA.generatedAt).getTime() - Number(range) * 24 * 60 * 60 * 1000;
+      return new Date(day + 'T23:59:59.999Z').getTime() >= cutoff;
+    }
+    function selectedModelRows(models) {
+      const selected = $('modelFilter').value;
+      return models.filter((model) => selected === 'all' || model.model === selected);
+    }
+    function compute() {
+      const agents = filteredAgents();
+      const modelMap = new Map();
+      const dayMap = new Map();
+      let totalCost = 0, requests = 0;
+      for (const agent of agents) {
+        const models = selectedModelRows(agent.models);
+        for (const model of models) { addModel(modelMap, model); totalCost += model.estimatedCost; requests += model.requests; }
+        for (const day of agent.days) {
+          if (!dayAllowed(day.day)) continue;
+          const dayModels = selectedModelRows(day.models);
+          const cost = dayModels.reduce((sum, model) => sum + model.estimatedCost, 0);
+          const reqs = dayModels.reduce((sum, model) => sum + model.requests, 0);
+          if (cost <= 0 && reqs <= 0) continue;
+          const row = dayMap.get(day.day) || {day: day.day, estimatedCost: 0, requests: 0};
+          row.estimatedCost += cost; row.requests += reqs; dayMap.set(day.day, row);
+        }
+      }
+      return {agents, models: Array.from(modelMap.values()).sort((a,b) => b.estimatedCost - a.estimatedCost), days: Array.from(dayMap.values()).sort((a,b) => a.day.localeCompare(b.day)), totalCost, requests};
+    }
+    function render() {
+      const view = compute();
+      $('totalCost').textContent = money(view.totalCost);
+      $('requestCount').textContent = number(view.requests);
+      $('modelCount').textContent = number(view.models.length);
+      $('agentCount').textContent = number(view.agents.length);
+      const agentRows = view.agents.map((agent) => '<tr><td class="name">' + esc(agent.name) + '</td><td>' + money(agent.estimatedCost) + '</td><td>' + number(agent.requests) + '</td></tr>').join('');
+      $('agentRows').innerHTML = agentRows || '<tr><td colspan="3" class="muted">No data</td></tr>';
+      const maxModel = Math.max(1, ...view.models.map((model) => model.estimatedCost));
+      $('modelRows').innerHTML = view.models.map((model) => {
+        const klass = modelClass(model.model, model.provider);
+        const cache = model.cacheReadTokens + model.cacheWriteTokens;
+        return '<tr><td class="name ' + klass + '">' + esc(model.model) + '</td><td>' + money(model.estimatedCost) + '</td><td>' + pct(view.totalCost > 0 ? model.estimatedCost / view.totalCost : 0) + '</td><td>' + number(model.requests) + '</td><td>' + number(model.inputTokens) + '</td><td>' + number(model.outputTokens + model.reasoningTokens) + '</td><td>' + number(cache) + '</td></tr>';
+      }).join('') || '<tr><td colspan="7" class="muted">No data</td></tr>';
+      const maxDay = Math.max(1, ...view.days.map((day) => day.estimatedCost));
+      $('dailyChart').innerHTML = view.days.length ? view.days.map((day) => {
+        const tooltip = esc(shortDate(day.day) + '|' + money(day.estimatedCost) + '|' + number(day.requests) + ' reqs');
+        return '<div class="bar-column" data-tooltip="' + tooltip + '"><div class="column-track"><div class="column-fill" style="height:' + Math.max(1, (day.estimatedCost / maxDay) * 100) + '%"></div></div></div>';
+      }).join('') : '<div class="muted chart-empty">No data</div>';
+      $('dailyAxis').innerHTML = dailyTicks(view.days).map((tick) => {
+        const left = view.days.length === 1 ? 50 : ((tick.index + 0.5) / view.days.length) * 100;
+        const edge = view.days.length === 1 ? '' : tick.index === 0 ? ' edge-start' : tick.index === view.days.length - 1 ? ' edge-end' : '';
+        return '<span class="axis-tick' + edge + '" style="left:' + left.toFixed(4) + '%">' + esc(shortDate(tick.day)) + '</span>';
+      }).join('');
+    }
+    function showTooltip(event) {
+      const target = event.target.closest('[data-tooltip]');
+      const tooltip = $('tooltip');
+      if (!target) { tooltip.style.display = 'none'; return; }
+      const [date, amount, requests] = target.dataset.tooltip.split('|');
+      tooltip.innerHTML = '<div>' + esc(date) + '</div><div class="sub">' + esc(amount) + ' \xB7 ' + esc(requests) + '</div>';
+      tooltip.style.display = 'block';
+      moveTooltip(event);
+    }
+    function moveTooltip(event) {
+      const tooltip = $('tooltip');
+      if (tooltip.style.display !== 'block') return;
+      const offset = 12;
+      const nextLeft = Math.min(window.innerWidth - tooltip.offsetWidth - 8, event.clientX + offset);
+      const nextTop = Math.min(window.innerHeight - tooltip.offsetHeight - 8, event.clientY + offset);
+      tooltip.style.left = Math.max(8, nextLeft) + 'px';
+      tooltip.style.top = Math.max(8, nextTop) + 'px';
+    }
+    function init() {
+      $('scope').textContent = DATA.scope;
+      $('generated').textContent = 'Generated ' + new Date(DATA.generatedAt).toLocaleString();
+      $('agentFilter').innerHTML = '<option value="all">All agents</option>' + DATA.agents.map((agent) => '<option value="' + esc(agent.name) + '">' + esc(agent.name) + '</option>').join('');
+      const models = Array.from(new Set(DATA.agents.flatMap((agent) => agent.models.map((model) => model.model)))).sort();
+      $('modelFilter').innerHTML = '<option value="all">All models</option>' + models.map((model) => '<option value="' + esc(model) + '">' + esc(model) + '</option>').join('');
+      ['agentFilter', 'modelFilter', 'rangeFilter'].forEach((id) => $(id).addEventListener('change', render));
+      $('dailyChart').addEventListener('mouseover', showTooltip);
+      $('dailyChart').addEventListener('mousemove', moveTooltip);
+      $('dailyChart').addEventListener('mouseleave', () => { $('tooltip').style.display = 'none'; });
+      render();
+    }
+    init();
+  </script>
+</body>
+</html>`;
+}
+function jsonForScript(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c");
+}
+function printReportHeader(options) {
+  const scope = options.rangeLabel ?? (options.since ? `since ${formatDate(options.since)}` : "all local history");
+  const agent = options.agent ? ` \xB7 ${options.agent}` : "";
+  console.log(`  ${c.bold}${c.red}devrage${c.reset} ${c.dim}report${c.reset}`);
+  console.log(`  ${c.dim}${scope}${agent}${c.reset}`);
+  console.log(`  ${c.dim}${"\u2500".repeat(54)}${c.reset}`);
+}
+function printBasicOverview(totalMessages, totalSwears) {
+  console.log(
+    `  ${c.dim}messages scanned${c.reset}   ${c.bold}${formatNumber(totalMessages)}${c.reset}`
+  );
+  console.log(
+    `  ${c.dim}total swears${c.reset}       ${c.bold}${c.red}${formatNumber(totalSwears)}${c.reset}`
+  );
+}
+function getCostTotals(costByAgent) {
+  const entries = Object.entries(costByAgent);
+  const totalCost = entries.reduce((sum, [, stats]) => sum + stats.estimatedCost, 0);
+  const totalRequests = entries.reduce((sum, [, stats]) => sum + stats.requests, 0);
+  const unpricedRequests = entries.reduce((sum, [, stats]) => sum + stats.unpricedRequests, 0);
+  return {
+    entries,
+    totalCost,
+    totalRequests,
+    pricedRequests: totalRequests - unpricedRequests,
+    unpricedRequests
+  };
+}
+function aggregateModelCosts(entries) {
+  const models = /* @__PURE__ */ new Map();
+  for (const [, stats] of entries) {
+    for (const model of stats.models) {
+      mergeModelSummary(models, model);
+    }
+  }
+  return sortedCostModels(models);
+}
+function mergeModelSummary(models, incoming) {
+  const key = incoming.model;
+  let model = models.get(key);
+  if (!model) {
+    models.set(key, { ...incoming });
+    return;
+  }
+  model.requests += incoming.requests;
+  model.estimatedCost += incoming.estimatedCost;
+  model.billedCost += incoming.billedCost;
+  model.pricingSource = mergeDisplayPricingSource(model.pricingSource, incoming.pricingSource);
+  model.unpricedRequests += incoming.unpricedRequests;
+  model.inputTokens += incoming.inputTokens;
+  model.outputTokens += incoming.outputTokens;
+  model.reasoningTokens += incoming.reasoningTokens;
+  model.cacheReadTokens += incoming.cacheReadTokens;
+  model.cacheWriteTokens += incoming.cacheWriteTokens;
+}
+function sortedCostModels(models) {
+  return Array.from(models.values()).sort(
+    (left, right) => right.estimatedCost - left.estimatedCost || right.requests - left.requests
+  );
+}
+function mergeDisplayPricingSource(left, right) {
+  return left === right ? left : "mixed";
+}
+function sectionTitle(label) {
+  const width = 54;
+  const lineLength = Math.max(4, width - label.length - 1);
+  return `${c.bold}${label}${c.reset} ${c.dim}${"\u2500".repeat(lineLength)}${c.reset}`;
+}
+function colorText(value, color) {
+  return `${color}${value}${c.reset}`;
+}
+function agentColor(agent) {
+  switch (agent) {
+    case "claude":
+      return c.magenta;
+    case "codex":
+      return c.green;
+    case "opencode":
+      return c.cyan;
+    case "amp":
+      return c.yellow;
+    case "pi":
+      return c.blue;
+    case "cursor":
+      return c.blue;
+    default:
+      return c.white;
+  }
+}
+function modelColor(model) {
+  const provider = model.provider?.toLowerCase();
+  const modelName = model.model.toLowerCase();
+  if (provider === "anthropic" || modelName.startsWith("claude-")) {
+    return c.magenta;
+  }
+  if (provider === "openai" || modelName.startsWith("gpt-") || /^o\d/.test(modelName)) {
+    return c.green;
+  }
+  if (provider === "google" || modelName.startsWith("gemini-")) {
+    return c.blue;
+  }
+  if (modelName.startsWith("kimi-") || modelName.startsWith("glm-")) {
+    return c.yellow;
+  }
+  return c.cyan;
+}
+function renderBar(value, max, width, color = c.cyan) {
+  const filled = max > 0 && value > 0 ? Math.max(1, Math.round(value / max * width)) : 0;
+  const empty = width - filled;
+  return `${color}${"\u2501".repeat(filled)}${c.gray}${"\u2500".repeat(empty)}${c.reset}`;
+}
+function clip(value, maxLength) {
+  return value.length <= maxLength ? value : `${value.slice(0, maxLength - 1)}\u2026`;
+}
+function formatCurrency(value) {
+  const cents = Math.floor(Math.max(0, value) * 100 + 1e-9);
+  return `$${(cents / 100).toFixed(2)}`;
+}
+function formatNumber(value) {
+  return value.toLocaleString("en-US");
+}
+function formatRequests(value) {
+  return `${formatNumber(value)} ${value === 1 ? "req" : "reqs"}`;
+}
+function formatPercent(value) {
+  return `${(value * 100).toFixed(1)}%`;
+}
+function formatDate(value) {
+  return value.toISOString().slice(0, 10);
+}
 
 // src/cli.ts
 var COMMANDS = {
+  cost,
   scan
 };
+var OPTIONS_WITH_VALUES = /* @__PURE__ */ new Set(["--agent", "-a", "--since", "-s"]);
 function usage() {
   console.log(`devrage \u2014 count how many times you swear at your coding agents
 
@@ -949,6 +3154,7 @@ Usage:
   devrage <command> [options]
 
 Commands:
+  cost          Show API-equivalent coding agent cost
   scan          Scan sessions for profanity
 
 Options:
@@ -956,6 +3162,7 @@ Options:
   --version     Show version
 
 Examples:
+  devrage cost
   devrage scan
   devrage scan --agent claude
   devrage scan --since 2025-01-01`);
@@ -968,16 +3175,35 @@ async function main() {
     process.exit(0);
   }
   if (command === "--version") {
-    console.log("0.0.4");
+    console.log("0.5.3");
     process.exit(0);
   }
-  const handler = command ? COMMANDS[command] : void 0;
-  if (handler) {
-    await handler(args.slice(1));
+  const parsed = parseCommand(args);
+  if (parsed) {
+    await parsed.handler(parsed.args);
   } else {
     await scan(args);
   }
 }
+function parseCommand(args) {
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (!arg) {
+      continue;
+    }
+    const handler = COMMANDS[arg];
+    if (handler) {
+      return {
+        handler,
+        args: [...args.slice(0, index), ...args.slice(index + 1)]
+      };
+    }
+    if (OPTIONS_WITH_VALUES.has(arg) && index + 1 < args.length) {
+      index++;
+    }
+  }
+  return null;
+}
 main().catch((err) => {
   console.error(err);
   process.exit(1);