devrage 0.5.5 → 0.5.7

package/dist/cli.js

@@ -2,7 +2,7 @@
 
 // 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 { dirname as dirname2, join as join11 } from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/adapters/amp.ts
@@ -825,6 +825,97 @@ 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";
+
+// src/adapters/sqlite.ts
+async function openReadonlySqliteDatabase(dbPath) {
+  const requestedDriver = process.env["DEVRAGE_SQLITE_DRIVER"];
+  if (requestedDriver) {
+    const loader = driverLoader(requestedDriver);
+    if (!loader) {
+      return null;
+    }
+    try {
+      return await loader(dbPath);
+    } catch {
+      return null;
+    }
+  }
+  const loaders = isBunRuntime() ? [openWithBunSqlite, openWithNodeSqlite, openWithBetterSqlite3] : [openWithNodeSqlite, openWithBetterSqlite3];
+  for (const loader of loaders) {
+    try {
+      return await loader(dbPath);
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function driverLoader(driver) {
+  switch (driver) {
+    case "bun":
+    case "bun:sqlite":
+      return openWithBunSqlite;
+    case "node":
+    case "node:sqlite":
+      return openWithNodeSqlite;
+    case "better-sqlite3":
+      return openWithBetterSqlite3;
+    default:
+      return null;
+  }
+}
+function isBunRuntime() {
+  return Boolean(process.versions["bun"]);
+}
+async function openWithBunSqlite(dbPath) {
+  const specifier = "bun:sqlite";
+  const sqlite = await import(specifier);
+  const db = new sqlite.Database(dbPath, { readonly: true, create: false });
+  return {
+    prepare(sql) {
+      const prepare = db.prepare ?? db.query;
+      return prepare.call(db, sql);
+    },
+    close() {
+      db.close();
+    }
+  };
+}
+async function openWithNodeSqlite(dbPath) {
+  const sqlite = await importNodeSqlite();
+  return new sqlite.DatabaseSync(dbPath, { open: true, readOnly: true, timeout: 5e3 });
+}
+async function openWithBetterSqlite3(dbPath) {
+  const BetterSqlite3 = await import("better-sqlite3");
+  const Ctor = BetterSqlite3.default ?? BetterSqlite3;
+  return new Ctor(dbPath, {
+    readonly: true,
+    fileMustExist: true
+  });
+}
+async function importNodeSqlite() {
+  const originalEmitWarning = process.emitWarning;
+  process.emitWarning = ((warning, ...args) => {
+    const message = typeof warning === "string" ? warning : warning.message;
+    const type = typeof args[0] === "string" ? args[0] : void 0;
+    if (message === "SQLite is an experimental feature and might change at any time" && type === "ExperimentalWarning") {
+      return;
+    }
+    originalEmitWarning(warning, ...args);
+  });
+  try {
+    const specifier = "node:sqlite";
+    const sqlite = await import(specifier);
+    if (typeof sqlite.DatabaseSync !== "function") {
+      throw new Error("node:sqlite DatabaseSync is unavailable");
+    }
+    return sqlite;
+  } finally {
+    process.emitWarning = originalEmitWarning;
+  }
+}
+
+// src/adapters/cursor.ts
 var CANDIDATE_KEY_PREFIXES = [
   "bubbleId:",
   "composerData:",
@@ -978,16 +1069,7 @@ async function* parseCursorUsageStore(store, options) {
   }
 }
 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;
-  }
+  return openReadonlySqliteDatabase(dbPath);
 }
 function readStateRows(db) {
   const rows = [];
@@ -1048,6 +1130,12 @@ function decodeStateValue(value) {
   if (Buffer.isBuffer(value)) {
     return value.toString("utf-8");
   }
+  if (value instanceof Uint8Array) {
+    return Buffer.from(value).toString("utf-8");
+  }
+  if (ArrayBuffer.isView(value)) {
+    return Buffer.from(value.buffer, value.byteOffset, value.byteLength).toString("utf-8");
+  }
   return null;
 }
 function extractCursorMessages(root, rowKey) {
@@ -1410,17 +1498,11 @@ async function openOpencodeDb() {
   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;
+  const db = await openReadonlySqliteDatabase(dbPath);
+  if (!db) {
+    console.warn("devrage: SQLite support not available, skipping OpenCode sessions");
   }
+  return db;
 }
 function* queryUserMessages(db, options) {
   let query = `
@@ -1689,23 +1771,435 @@ function asRecord5(value) {
   return value;
 }
 
-// src/adapters/zed.ts
-import { readdir as readdir7, readFile as readFile3 } from "node:fs/promises";
+// src/adapters/t3code.ts
 import { existsSync as existsSync4 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { join as join8 } from "node:path";
+import { isAbsolute, join as join8, resolve } from "node:path";
+function t3codeAdapter() {
+  return {
+    name: "t3code",
+    async *messages(options) {
+      for (const location of discoverT3Databases()) {
+        const db = await openT3Db(location.path);
+        if (!db) {
+          continue;
+        }
+        try {
+          yield* queryUserMessages2(db, location, options);
+        } finally {
+          db.close();
+        }
+      }
+    },
+    async *usage(options) {
+      const seen = /* @__PURE__ */ new Set();
+      for (const location of discoverT3Databases()) {
+        const db = await openT3Db(location.path);
+        if (!db) {
+          continue;
+        }
+        try {
+          yield* queryUsageRecords2(db, location, seen, options);
+        } finally {
+          db.close();
+        }
+      }
+    }
+  };
+}
+function discoverT3Databases() {
+  const locations = [];
+  const seen = /* @__PURE__ */ new Set();
+  const stateDir = stringValue6(process.env["T3CODE_STATE_DIR"]);
+  if (stateDir) {
+    addLocation(locations, seen, join8(resolveHomePath(stateDir), "state.sqlite"), "state");
+  }
+  for (const baseDir of uniqueStrings2([
+    stringValue6(process.env["T3CODE_HOME"]),
+    join8(homedir8(), ".t3")
+  ])) {
+    addLocation(
+      locations,
+      seen,
+      join8(resolveHomePath(baseDir), "userdata", "state.sqlite"),
+      "userdata"
+    );
+    addLocation(locations, seen, join8(resolveHomePath(baseDir), "dev", "state.sqlite"), "dev");
+  }
+  return locations;
+}
+function addLocation(locations, seen, dbPath, scope) {
+  if (seen.has(dbPath) || !existsSync4(dbPath)) {
+    return;
+  }
+  seen.add(dbPath);
+  locations.push({ path: dbPath, scope });
+}
+function resolveHomePath(value) {
+  if (value === "~") {
+    return homedir8();
+  }
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return join8(homedir8(), value.slice(2));
+  }
+  return isAbsolute(value) ? value : resolve(value);
+}
+async function openT3Db(dbPath) {
+  return openReadonlySqliteDatabase(dbPath);
+}
+function* queryUserMessages2(db, location, options) {
+  if (!hasColumns(db, "projection_thread_messages", ["thread_id", "role", "text", "created_at"])) {
+    return;
+  }
+  const orderColumn = hasColumns(db, "projection_thread_messages", ["message_id"]) ? "message_id" : "created_at";
+  let query = `
+    SELECT thread_id, created_at, text
+    FROM projection_thread_messages
+    WHERE role = 'user'
+  `;
+  const params = [];
+  if (options?.since) {
+    query += ` AND created_at >= ?`;
+    params.push(options.since.toISOString());
+  }
+  query += ` ORDER BY created_at ASC, ${orderColumn} ASC`;
+  let rows;
+  try {
+    rows = db.prepare(query).all(...params);
+  } catch {
+    return;
+  }
+  for (const row of rows) {
+    const text = stringValue6(row.text);
+    if (!text) {
+      continue;
+    }
+    yield {
+      text,
+      timestamp: stringValue6(row.created_at),
+      session: stringValue6(row.thread_id),
+      project: location.scope
+    };
+  }
+}
+function* queryUsageRecords2(db, location, seen, options) {
+  if (!hasColumns(db, "orchestration_events", [
+    "event_id",
+    "stream_id",
+    "event_type",
+    "occurred_at",
+    "payload_json"
+  ])) {
+    return;
+  }
+  const threadInfo = readThreadInfo(db);
+  const orderColumn = hasColumns(db, "orchestration_events", ["sequence"]) ? "sequence" : "event_id";
+  let query = `
+    SELECT event_id, stream_id, occurred_at, payload_json
+    FROM orchestration_events
+    WHERE event_type = 'thread.activity-appended'
+  `;
+  const params = [];
+  if (options?.since) {
+    query += ` AND occurred_at >= ?`;
+    params.push(options.since.toISOString());
+  }
+  query += ` ORDER BY occurred_at ASC, ${orderColumn} ASC`;
+  let rows;
+  try {
+    rows = db.prepare(query).all(...params);
+  } catch {
+    return;
+  }
+  for (const row of rows) {
+    const payload = asRecord6(parseJson(row.payload_json));
+    const activity = asRecord6(payload?.["activity"]);
+    if (activity?.["kind"] !== "context-window.updated") {
+      continue;
+    }
+    const usage2 = parseUsageSnapshot(activity["payload"]);
+    if (!usage2 || !hasBillableUsage2(usage2)) {
+      continue;
+    }
+    const threadId = stringValue6(payload?.["threadId"]) ?? stringValue6(row.stream_id);
+    const timestamp = stringValue6(activity["createdAt"]) ?? stringValue6(row.occurred_at);
+    const turnId = stringValue6(activity["turnId"]);
+    const info = threadId ? threadInfo.get(threadId) : void 0;
+    const provider = normalizeT3Provider(info?.provider, info?.model);
+    const dedupeKey = t3UsageDedupeKey({
+      scope: location.scope,
+      threadId,
+      turnId,
+      provider,
+      model: info?.model,
+      usage: usage2
+    });
+    if (seen.has(dedupeKey)) {
+      continue;
+    }
+    seen.add(dedupeKey);
+    yield {
+      agent: "t3code",
+      provider,
+      model: info?.model,
+      timestamp,
+      session: threadId,
+      inputTokens: usage2.inputTokens,
+      outputTokens: usage2.outputTokens,
+      reasoningTokens: usage2.reasoningTokens,
+      cacheReadTokens: usage2.cacheReadTokens,
+      cacheWriteTokens: usage2.cacheWriteTokens
+    };
+  }
+}
+function normalizeT3Provider(provider, model) {
+  const normalized = provider?.trim().toLowerCase();
+  const key = normalized?.replace(/[^a-z0-9]/g, "");
+  switch (key) {
+    case "codex":
+      return "openai";
+    case "claudeagent":
+    case "claudecode":
+      return "anthropic";
+    case "cursor":
+    case "opencode":
+      return void 0;
+    default:
+      if (key?.includes("codex")) {
+        return "openai";
+      }
+      if (key?.includes("claude")) {
+        return "anthropic";
+      }
+      if (normalized === "openai" || normalized === "anthropic") {
+        return normalized;
+      }
+      return providerFromModel(model);
+  }
+}
+function providerFromModel(model) {
+  const slash = model?.indexOf("/") ?? -1;
+  if (!model || slash <= 0) {
+    return void 0;
+  }
+  return model.slice(0, slash);
+}
+function readThreadInfo(db) {
+  const info = /* @__PURE__ */ new Map();
+  readProjectionThreadModels(db, info);
+  readProjectionThreadProviders(db, info);
+  return info;
+}
+function readProjectionThreadModels(db, info) {
+  if (!tableExists(db, "projection_threads")) {
+    return;
+  }
+  const columns = tableColumns(db, "projection_threads");
+  if (!columns.has("thread_id")) {
+    return;
+  }
+  try {
+    if (columns.has("model_selection_json")) {
+      const rows = db.prepare("SELECT thread_id, model_selection_json FROM projection_threads").all();
+      for (const row of rows) {
+        const threadId = stringValue6(row.thread_id);
+        const modelSelection = asRecord6(parseJson(row.model_selection_json));
+        if (!threadId || !modelSelection) {
+          continue;
+        }
+        const entry = info.get(threadId) ?? {};
+        entry.model = stringValue6(modelSelection["model"]) ?? entry.model;
+        entry.provider = stringValue6(modelSelection["provider"]) ?? stringValue6(modelSelection["instanceId"]) ?? entry.provider;
+        info.set(threadId, entry);
+      }
+      return;
+    }
+    if (columns.has("model")) {
+      const rows = db.prepare("SELECT thread_id, model FROM projection_threads").all();
+      for (const row of rows) {
+        const threadId = stringValue6(row.thread_id);
+        const model = stringValue6(row.model);
+        if (threadId && model) {
+          info.set(threadId, { ...info.get(threadId), model });
+        }
+      }
+    }
+  } catch {
+    return;
+  }
+}
+function readProjectionThreadProviders(db, info) {
+  if (!hasColumns(db, "projection_thread_sessions", ["thread_id", "provider_name"])) {
+    return;
+  }
+  try {
+    const rows = db.prepare("SELECT thread_id, provider_name FROM projection_thread_sessions").all();
+    for (const row of rows) {
+      const threadId = stringValue6(row.thread_id);
+      const provider = stringValue6(row.provider_name);
+      if (!threadId || !provider) {
+        continue;
+      }
+      info.set(threadId, { ...info.get(threadId), provider });
+    }
+  } catch {
+    return;
+  }
+}
+function parseUsageSnapshot(value) {
+  const usage2 = asRecord6(value);
+  if (!usage2) {
+    return null;
+  }
+  const lastInputTokens = tokenValue(usage2["lastInputTokens"] ?? usage2["last_input_tokens"]);
+  const lastCachedInputTokens = tokenValue(
+    usage2["lastCachedInputTokens"] ?? usage2["last_cached_input_tokens"]
+  );
+  const lastOutputTokens = tokenValue(usage2["lastOutputTokens"] ?? usage2["last_output_tokens"]);
+  const lastReasoningOutputTokens = tokenValue(
+    usage2["lastReasoningOutputTokens"] ?? usage2["last_reasoning_output_tokens"]
+  );
+  const hasLastDetails = [
+    lastInputTokens,
+    lastCachedInputTokens,
+    lastOutputTokens,
+    lastReasoningOutputTokens
+  ].some((token) => token !== void 0);
+  if (hasLastDetails) {
+    return splitTokenUsage({
+      inputTokens: lastInputTokens ?? 0,
+      cachedInputTokens: lastCachedInputTokens ?? 0,
+      outputTokens: lastOutputTokens ?? 0,
+      reasoningOutputTokens: lastReasoningOutputTokens ?? 0
+    });
+  }
+  const inputTokens = tokenValue(usage2["inputTokens"] ?? usage2["input_tokens"]);
+  const cachedInputTokens = tokenValue(usage2["cachedInputTokens"] ?? usage2["cached_input_tokens"]);
+  const outputTokens = tokenValue(usage2["outputTokens"] ?? usage2["output_tokens"]);
+  const reasoningOutputTokens = tokenValue(
+    usage2["reasoningOutputTokens"] ?? usage2["reasoning_output_tokens"]
+  );
+  const hasSnapshotDetails = [
+    inputTokens,
+    cachedInputTokens,
+    outputTokens,
+    reasoningOutputTokens
+  ].some((token) => token !== void 0);
+  if (!hasSnapshotDetails) {
+    return null;
+  }
+  return splitTokenUsage({
+    inputTokens: inputTokens ?? 0,
+    cachedInputTokens: cachedInputTokens ?? 0,
+    outputTokens: outputTokens ?? 0,
+    reasoningOutputTokens: reasoningOutputTokens ?? 0
+  });
+}
+function splitTokenUsage(input) {
+  const reasoningTokens = Math.min(input.reasoningOutputTokens, input.outputTokens);
+  return {
+    inputTokens: Math.max(input.inputTokens - input.cachedInputTokens, 0),
+    outputTokens: Math.max(input.outputTokens - reasoningTokens, 0),
+    reasoningTokens,
+    cacheReadTokens: input.cachedInputTokens,
+    cacheWriteTokens: 0
+  };
+}
+function hasBillableUsage2(usage2) {
+  return usage2.inputTokens + usage2.outputTokens + usage2.reasoningTokens + usage2.cacheReadTokens + usage2.cacheWriteTokens > 0;
+}
+function t3UsageDedupeKey(input) {
+  return JSON.stringify([
+    input.scope,
+    input.threadId ?? "",
+    input.turnId ?? "",
+    input.provider ?? "",
+    input.model ?? "",
+    input.usage.inputTokens,
+    input.usage.outputTokens,
+    input.usage.reasoningTokens,
+    input.usage.cacheReadTokens,
+    input.usage.cacheWriteTokens
+  ]);
+}
+function hasColumns(db, table, requiredColumns) {
+  const columns = tableColumns(db, table);
+  return requiredColumns.every((column) => columns.has(column));
+}
+function tableExists(db, table) {
+  try {
+    const row = db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ? LIMIT 1").get(table);
+    return Boolean(row);
+  } catch {
+    return false;
+  }
+}
+function tableColumns(db, table) {
+  if (!tableExists(db, table)) {
+    return /* @__PURE__ */ new Set();
+  }
+  try {
+    const rows = db.prepare(`PRAGMA table_info("${table}")`).all();
+    return new Set(rows.flatMap((row) => stringValue6(row.name) ?? []));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function parseJson(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+function tokenValue(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return void 0;
+  }
+  return Math.max(Math.round(value), 0);
+}
+function uniqueStrings2(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const value of values) {
+    if (!value || seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    unique.push(value);
+  }
+  return unique;
+}
+function stringValue6(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function asRecord6(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+
+// src/adapters/zed.ts
+import { readdir as readdir7, readFile as readFile3 } from "node:fs/promises";
+import { existsSync as existsSync5 } from "node:fs";
+import { homedir as homedir9 } from "node:os";
+import { join as join9 } from "node:path";
 function getZedPaths() {
   if (process.platform === "darwin") {
-    const base2 = join8(homedir8(), "Library", "Application Support", "Zed");
+    const base2 = join9(homedir9(), "Library", "Application Support", "Zed");
     return {
-      conversations: join8(base2, "conversations"),
-      db: join8(base2, "db")
+      conversations: join9(base2, "conversations"),
+      db: join9(base2, "db")
     };
   }
-  const base = join8(process.env["XDG_DATA_HOME"] ?? join8(homedir8(), ".local", "share"), "zed");
+  const base = join9(process.env["XDG_DATA_HOME"] ?? join9(homedir9(), ".local", "share"), "zed");
   return {
-    conversations: join8(base, "conversations"),
-    db: join8(base, "db")
+    conversations: join9(base, "conversations"),
+    db: join9(base, "db")
   };
 }
 function zedAdapter() {
@@ -1719,7 +2213,7 @@ function zedAdapter() {
   };
 }
 async function* parseTextThreads(dir, _options) {
-  if (!existsSync4(dir)) {
+  if (!existsSync5(dir)) {
     return;
   }
   let files;
@@ -1730,7 +2224,7 @@ async function* parseTextThreads(dir, _options) {
   }
   const jsonFiles = files.filter((f) => f.endsWith(".json"));
   for (const file of jsonFiles) {
-    const filePath = join8(dir, file);
+    const filePath = join9(dir, file);
     const session = file.replace(".json", "");
     try {
       const raw = await readFile3(filePath, "utf-8");
@@ -1756,7 +2250,7 @@ async function* parseTextThreads(dir, _options) {
   }
 }
 async function* parseAgentThreads(dbDir, _options) {
-  if (!existsSync4(dbDir)) {
+  if (!existsSync5(dbDir)) {
     return;
   }
   let dbFiles;
@@ -1769,21 +2263,10 @@ async function* parseAgentThreads(dbDir, _options) {
   if (dbFiles.length === 0) {
     return;
   }
-  let Database;
-  try {
-    const mod = await import("better-sqlite3");
-    Database = mod.default ?? mod;
-  } catch {
-    return;
-  }
   for (const dbFile of dbFiles) {
-    const dbPath = join8(dbDir, dbFile);
-    let db;
-    try {
-      db = new Database(dbPath, {
-        readonly: true
-      });
-    } catch {
+    const dbPath = join9(dbDir, dbFile);
+    const db = await openReadonlySqliteDatabase(dbPath);
+    if (!db) {
       continue;
     }
     try {
@@ -1793,14 +2276,12 @@ async function* parseAgentThreads(dbDir, _options) {
         (t) => t === "messages" || t === "thread_messages" || t.includes("message")
       );
       if (!msgTable) {
-        db.close();
         continue;
       }
       const columns = db.prepare(`PRAGMA table_info("${msgTable}")`).all();
       const colNames = columns.map((c2) => c2.name);
       const hasRole = colNames.includes("role");
       if (!hasRole) {
-        db.close();
         continue;
       }
       const contentCol = colNames.includes("content") ? "content" : colNames.includes("body") ? "body" : "text";
@@ -1828,6 +2309,7 @@ var ADAPTERS = {
   amp: ampAdapter,
   cline: clineAdapter,
   pi: piAdapter,
+  t3code: t3codeAdapter,
   zed: zedAdapter
 };
 function createAdapter(name) {
@@ -1997,8 +2479,8 @@ 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";
+import { homedir as homedir10 } from "node:os";
+import { dirname, join as join10 } 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;
@@ -2098,16 +2580,16 @@ async function summarizeUsage(records, pricing) {
 }
 function getPricingCachePath() {
   if (process.env["XDG_CACHE_HOME"]) {
-    return join9(process.env["XDG_CACHE_HOME"], "devrage", "models.dev.json");
+    return join10(process.env["XDG_CACHE_HOME"], "devrage", "models.dev.json");
   }
   if (process.platform === "darwin") {
-    return join9(homedir9(), "Library", "Caches", "devrage", "models.dev.json");
+    return join10(homedir10(), "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");
+    const localAppData = process.env["LOCALAPPDATA"] ?? join10(homedir10(), "AppData", "Local");
+    return join10(localAppData, "devrage", "models.dev.json");
   }
-  return join9(homedir9(), ".cache", "devrage", "models.dev.json");
+  return join10(homedir10(), ".cache", "devrage", "models.dev.json");
 }
 function createCostAccumulator() {
   return {
@@ -2216,7 +2698,7 @@ async function readPricingCache(cachePath) {
   try {
     const raw = await readFile4(cachePath, "utf-8");
     const parsed = JSON.parse(raw);
-    const cache = asRecord6(parsed);
+    const cache = asRecord7(parsed);
     if (cache?.["source"] !== "models.dev" || cache["schemaVersion"] !== 1 || typeof cache["fetchedAt"] !== "string" || !isModelsDevCatalog(cache["catalog"])) {
       return null;
     }
@@ -2357,10 +2839,10 @@ function inferProvider(model) {
   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]);
+  const root = asRecord7(catalog);
+  const providerEntry = asRecord7(root?.[provider]);
+  const models = asRecord7(providerEntry?.["models"]);
+  const modelEntry = asRecord7(models?.[model]);
   return toRateTable(modelEntry?.["cost"]);
 }
 function selectContextRates(rates, record) {
@@ -2368,8 +2850,8 @@ function selectContextRates(rates, record) {
   let selected = rates;
   let selectedSize = 0;
   for (const tier of rates.tiers ?? []) {
-    const tierRecord = asRecord6(tier);
-    const tierInfo = asRecord6(tierRecord?.["tier"]);
+    const tierRecord = asRecord7(tier);
+    const tierInfo = asRecord7(tierRecord?.["tier"]);
     const size = typeof tierInfo?.["size"] === "number" ? tierInfo["size"] : 0;
     if (tierInfo?.["type"] !== "context" || contextTokens < size || size < selectedSize) {
       continue;
@@ -2386,7 +2868,7 @@ function selectContextRates(rates, record) {
   return selected;
 }
 function toRateTable(value) {
-  const record = asRecord6(value);
+  const record = asRecord7(value);
   if (!record) {
     return null;
   }
@@ -2420,10 +2902,10 @@ 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"]));
+  const catalog = asRecord7(value);
+  const openai = asRecord7(catalog?.["openai"]);
+  const anthropic = asRecord7(catalog?.["anthropic"]);
+  return Boolean(asRecord7(openai?.["models"]) || asRecord7(anthropic?.["models"]));
 }
 function isFresh(fetchedAt, ttlMs) {
   const fetchedTime = new Date(fetchedAt).getTime();
@@ -2432,7 +2914,7 @@ function isFresh(fetchedAt, ttlMs) {
 function mergePricingSource(left, right) {
   return left === right ? left : "mixed";
 }
-function asRecord6(value) {
+function asRecord7(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return null;
   }
@@ -2537,7 +3019,7 @@ function parseArgs(args) {
       console.log(`devrage scan \u2014 scan sessions for profanity
 
 Options:
-  --agent, -a <name>   Scan only a specific agent (claude, codex, cursor, opencode, amp, cline, pi, zed)
+  --agent, -a <name>   Scan only a specific agent (claude, codex, cursor, opencode, amp, cline, pi, t3code, 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
@@ -2578,7 +3060,7 @@ Usage:
   devrage cost [options]
 
 Options:
-  --agent, -a <name>   Show only a specific agent (claude, codex, cursor, opencode, amp, pi)
+  --agent, -a <name>   Show only a specific agent (claude, codex, cursor, opencode, amp, pi, t3code)
   --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)
@@ -2792,7 +3274,7 @@ function printCostCommandUnavailable(options) {
 }
 async function writeCostHtmlReport(totals, options) {
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const reportPath = join10(
+  const reportPath = join11(
     dirname2(getPricingCachePath()),
     `cost-report-${safeTimestamp(generatedAt)}.html`
   );
@@ -3245,7 +3727,7 @@ async function main() {
     process.exit(0);
   }
   if (command === "--version") {
-    console.log("0.5.5");
+    console.log("0.5.7");
     process.exit(0);
   }
   const parsed = parseCommand(args);