@askexenow/exe-os 0.9.127 → 0.9.129

package/dist/chunk-IJ73YE73.js

@@ -0,0 +1,409 @@
+import {
+  vectorToBlob
+} from "./chunk-HSRM6PNM.js";
+import {
+  init_employees,
+  isCoordinatorName
+} from "./chunk-RUG3N6P4.js";
+
+// src/lib/consolidation.ts
+import { randomUUID } from "crypto";
+init_employees();
+async function selectUnconsolidated(client, limit = 200) {
+  const result = await client.execute({
+    sql: `SELECT id, agent_id, project_name, tool_name, raw_text, timestamp
+          FROM memories
+          WHERE consolidated = 0
+            AND COALESCE(memory_type, 'raw') != 'procedure'
+          ORDER BY timestamp DESC
+          LIMIT ?`,
+    args: [limit]
+  });
+  return result.rows.map((row) => ({
+    id: row.id,
+    agent_id: row.agent_id,
+    project_name: row.project_name,
+    tool_name: row.tool_name,
+    raw_text: row.raw_text,
+    timestamp: row.timestamp
+  }));
+}
+function groupMemories(memories) {
+  const byProject = /* @__PURE__ */ new Map();
+  for (const mem of memories) {
+    const key = `${mem.agent_id}::${mem.project_name}`;
+    const list = byProject.get(key) ?? [];
+    list.push(mem);
+    byProject.set(key, list);
+  }
+  const clusters = [];
+  for (const [key, projectMemories] of byProject) {
+    const [agentId, projectName] = key.split("::");
+    const byDay = /* @__PURE__ */ new Map();
+    for (const mem of projectMemories) {
+      const day = mem.timestamp.slice(0, 10);
+      const list = byDay.get(day) ?? [];
+      list.push(mem);
+      byDay.set(day, list);
+    }
+    for (const [day, dayMemories] of byDay) {
+      if (dayMemories.length <= 15) {
+        clusters.push({
+          agentId,
+          projectName,
+          dateRange: day,
+          memories: dayMemories
+        });
+      } else {
+        for (let i = 0; i < dayMemories.length; i += 12) {
+          const chunk = dayMemories.slice(i, i + 12);
+          clusters.push({
+            agentId,
+            projectName,
+            dateRange: day,
+            memories: chunk
+          });
+        }
+      }
+    }
+  }
+  return clusters;
+}
+var ROLE_PROMPTS = {
+  "COO": `Extract EXACTLY THREE types of insights:
+1. KEY DECISIONS \u2014 choices that were made and why (at most 3)
+2. RECURRING PATTERNS \u2014 actions or approaches that repeated (at most 3)
+3. OPEN QUESTIONS \u2014 things that seem unresolved or risky (at most 2)`,
+  "CTO": `Extract EXACTLY THREE types of insights:
+1. ARCHITECTURE DECISIONS \u2014 design choices, tradeoffs, delegation patterns (at most 3)
+2. REVIEW OUTCOMES \u2014 what was approved, rejected, or flagged during code review (at most 3)
+3. TECHNICAL DEBT \u2014 unresolved issues, deferred work, risks identified (at most 2)`,
+  "Principal Engineer": `Extract EXACTLY THREE types of insights:
+1. CODE DECISIONS \u2014 implementation choices, patterns used, bugs fixed (at most 3)
+2. FILE CHANGES \u2014 key files modified and why (at most 3)
+3. BLOCKERS \u2014 things that slowed down or prevented progress (at most 2)`,
+  "Staff Code Reviewer": `Extract EXACTLY THREE types of insights:
+1. AUDIT FINDINGS \u2014 issues found, severity, fix status (at most 3)
+2. RECURRING ISSUES \u2014 patterns that keep appearing across reviews (at most 3)
+3. QUALITY SIGNALS \u2014 areas of the codebase that are strong or weak (at most 2)`,
+  "CMO": `Extract EXACTLY THREE types of insights:
+1. DESIGN DECISIONS \u2014 brand, layout, typography, or content choices made (at most 3)
+2. CONTENT STRATEGY \u2014 messaging, SEO, platform-specific decisions (at most 3)
+3. BRAND ALIGNMENT \u2014 consistency issues or guidelines established (at most 2)`,
+  "AI Product Lead": `Extract EXACTLY THREE types of insights:
+1. RESEARCH FINDINGS \u2014 tools, repos, or models evaluated with conclusions (at most 3)
+2. COMPETITIVE GAPS \u2014 features or patterns worth adopting from competitors (at most 3)
+3. BUILD RECOMMENDATIONS \u2014 what to build, skip, or watch (at most 2)`
+};
+var DEFAULT_ROLE_PROMPT = `Extract EXACTLY THREE types of insights:
+1. KEY DECISIONS \u2014 choices that were made and why (at most 3)
+2. RECURRING PATTERNS \u2014 actions or approaches that repeated (at most 3)
+3. OPEN QUESTIONS \u2014 things that seem unresolved or risky (at most 2)`;
+function buildConsolidationPrompt(cluster, agentRole) {
+  const snippets = cluster.memories.map((m, i) => {
+    const text = m.raw_text.length > 200 ? m.raw_text.slice(0, 200) + "..." : m.raw_text;
+    return `${i + 1}. [${m.tool_name}] ${text}`;
+  }).join("\n");
+  const rolePrompt = agentRole && ROLE_PROMPTS[agentRole] || DEFAULT_ROLE_PROMPT;
+  return `You are reviewing a set of work memories from an AI coding agent.
+These are raw tool call records from ${cluster.dateRange}.
+
+Agent: ${cluster.agentId} | Project: ${cluster.projectName} | Date: ${cluster.dateRange}
+
+MEMORIES:
+${snippets}
+
+${rolePrompt}
+
+Format each as a single sentence. Be specific \u2014 include file names,
+function names, and concrete details. Skip if no insight for a category.`;
+}
+async function consolidateCluster(cluster, model, agentRole) {
+  const Anthropic = (await import("@anthropic-ai/sdk")).default;
+  const client = new Anthropic();
+  const prompt = buildConsolidationPrompt(cluster, agentRole);
+  const response = await client.messages.create({
+    model,
+    max_tokens: 300,
+    messages: [{ role: "user", content: prompt }]
+  });
+  const textBlock = response.content.find((b) => b.type === "text");
+  return textBlock?.text ?? "";
+}
+async function storeConsolidation(client, cluster, synthesisText, embedFn) {
+  const consolidatedId = randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const rawText = `CONSOLIDATION [${cluster.dateRange}, ${cluster.projectName}]:
+
+${synthesisText}`;
+  let vector = null;
+  if (embedFn) {
+    try {
+      vector = await embedFn(rawText);
+    } catch {
+    }
+  }
+  const insertSql = vector ? `INSERT INTO memories
+        (id, agent_id, agent_role, session_id, timestamp,
+         tool_name, project_name, has_error, raw_text, vector, version, consolidated, importance)
+        VALUES (?, ?, 'consolidation', 'daemon-consolidation', ?, 'consolidation', ?, 0, ?, vector32(?), 0, 1, 9)` : `INSERT INTO memories
+        (id, agent_id, agent_role, session_id, timestamp,
+         tool_name, project_name, has_error, raw_text, vector, version, consolidated, importance)
+        VALUES (?, ?, 'consolidation', 'daemon-consolidation', ?, 'consolidation', ?, 0, ?, NULL, 0, 1, 9)`;
+  const insertArgs = vector ? [consolidatedId, cluster.agentId, now, cluster.projectName, rawText, vectorToBlob(vector)] : [consolidatedId, cluster.agentId, now, cluster.projectName, rawText];
+  await client.execute({ sql: insertSql, args: insertArgs });
+  const sourceIds = cluster.memories.map((m) => m.id);
+  const linkStmts = sourceIds.map((sourceId) => ({
+    sql: `INSERT INTO consolidations (id, consolidated_memory_id, source_memory_id, created_at)
+          VALUES (?, ?, ?, ?)`,
+    args: [randomUUID(), consolidatedId, sourceId, now]
+  }));
+  const placeholders = sourceIds.map(() => "?").join(",");
+  const markStmt = {
+    sql: `UPDATE memories SET consolidated = 1 WHERE id IN (${placeholders})`,
+    args: sourceIds
+  };
+  await client.batch([...linkStmts, markStmt], "write");
+  return { consolidatedMemoryId: consolidatedId, sourceIds, rawText };
+}
+var WIKI_FETCH_TIMEOUT_MS = 1e4;
+async function pushToWiki(consolidation, config) {
+  if (!config.wikiEnabled || !config.wikiAutoUpdate) {
+    return { updated: false };
+  }
+  const apiUrl = config.wikiUrl || process.env.EXE_WIKI_API_URL;
+  const apiKey = config.wikiApiKey || process.env.EXE_WIKI_API_KEY;
+  if (!apiUrl || !apiKey) {
+    return { updated: false };
+  }
+  const workspace = config.wikiWorkspaceMapping[consolidation.projectName] ?? consolidation.projectName;
+  try {
+    const listRes = await fetch(
+      `${apiUrl}/v1/workspace/${encodeURIComponent(workspace)}/documents`,
+      {
+        headers: { Authorization: `Bearer ${apiKey}` },
+        signal: AbortSignal.timeout(WIKI_FETCH_TIMEOUT_MS)
+      }
+    );
+    if (!listRes.ok) {
+      return { updated: false, error: `Workspace "${workspace}" not accessible (${listRes.status})` };
+    }
+    const listJson = await listRes.json();
+    const docs = listJson.documents ?? listJson.localFiles?.items ?? [];
+    const contentLines = consolidation.rawText.split("\n").filter((l) => l.trim() && !l.startsWith("CONSOLIDATION") && !l.match(/^[A-Z\s]+:$/)).join(" ");
+    const keywords = contentLines.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 3);
+    let bestMatch = null;
+    for (const doc of docs) {
+      if (!doc.id || !doc.title) continue;
+      const titleWords = doc.title.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 3);
+      if (titleWords.length === 0) continue;
+      const matchCount = titleWords.filter(
+        (tw) => keywords.some((k) => k.includes(tw) || tw.includes(k))
+      ).length;
+      const score = matchCount / titleWords.length;
+      if (score > (bestMatch?.score ?? 0)) {
+        bestMatch = { id: doc.id, title: doc.title, score };
+      }
+    }
+    if (bestMatch && bestMatch.score >= config.wikiAutoUpdateThreshold) {
+      const updateRes = await fetch(`${apiUrl}/v1/document/raw-text`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          textContent: consolidation.rawText,
+          metadata: { title: bestMatch.title, appendTo: bestMatch.id },
+          workspaceSlugs: [workspace]
+        }),
+        signal: AbortSignal.timeout(WIKI_FETCH_TIMEOUT_MS)
+      });
+      if (updateRes.ok) {
+        process.stderr.write(
+          `[consolidation] Wiki auto-updated: ${workspace}/${bestMatch.title}
+`
+        );
+        return { updated: true, action: "updated", page: bestMatch.title };
+      }
+      return { updated: false, error: `Update failed (${updateRes.status})` };
+    }
+    if (config.wikiAutoUpdateCreateNew) {
+      const title = `Consolidated Insights \u2014 ${consolidation.projectName} (${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)})`;
+      const createRes = await fetch(`${apiUrl}/v1/document/raw-text`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          textContent: consolidation.rawText,
+          metadata: { title },
+          workspaceSlugs: [workspace]
+        }),
+        signal: AbortSignal.timeout(WIKI_FETCH_TIMEOUT_MS)
+      });
+      if (createRes.ok) {
+        process.stderr.write(
+          `[consolidation] Wiki page created: ${workspace}/${title}
+`
+        );
+        return { updated: true, action: "created", page: title };
+      }
+      return { updated: false, error: `Create failed (${createRes.status})` };
+    }
+    return { updated: false };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[consolidation] Wiki push failed: ${msg}
+`);
+    return { updated: false, error: msg };
+  }
+}
+async function runConsolidation(client, options) {
+  const memories = await selectUnconsolidated(client);
+  if (memories.length < 20) {
+    return { clustersProcessed: 0, memoriesConsolidated: 0 };
+  }
+  let roleMap = {};
+  try {
+    const { loadEmployeesSync } = await import("./lib/employees.js");
+    const employees = loadEmployeesSync();
+    for (const e of employees) {
+      roleMap[e.name] = e.role;
+    }
+  } catch {
+  }
+  const clusters = groupMemories(memories);
+  let clustersProcessed = 0;
+  let memoriesConsolidated = 0;
+  for (const cluster of clusters) {
+    if (clustersProcessed >= options.maxCalls) break;
+    if (cluster.memories.length < 3) continue;
+    try {
+      const isCoordinator = isCoordinatorName(cluster.agentId);
+      const agentRole = roleMap[cluster.agentId];
+      const dedupCount = await dedupCluster(client, cluster, options.embedFn);
+      memoriesConsolidated += dedupCount;
+      const synthesis = await consolidateCluster(cluster, options.model, agentRole);
+      if (!synthesis.trim()) {
+        if (dedupCount > 0) clustersProcessed++;
+        continue;
+      }
+      const result = await storeConsolidation(client, cluster, synthesis, options.embedFn);
+      if (isCoordinator && options.wikiConfig) {
+        await pushToWiki(
+          { ...result, projectName: cluster.projectName },
+          options.wikiConfig
+        ).catch((err) => {
+          process.stderr.write(
+            `[consolidation] Wiki push error (non-fatal): ${err instanceof Error ? err.message : String(err)}
+`
+          );
+        });
+      }
+      if (isCoordinator) {
+        const sourceIds = result.sourceIds;
+        if (sourceIds.length > 0) {
+          const placeholders = sourceIds.map(() => "?").join(",");
+          await client.execute({
+            sql: `UPDATE memories SET status = 'archived' WHERE id IN (${placeholders})`,
+            args: sourceIds
+          });
+        }
+      }
+      clustersProcessed++;
+      memoriesConsolidated += cluster.memories.length;
+    } catch (err) {
+      process.stderr.write(
+        `[consolidation] Cluster failed (${cluster.projectName}/${cluster.dateRange}): ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  return { clustersProcessed, memoriesConsolidated };
+}
+async function dedupCluster(client, cluster, embedFn) {
+  if (!embedFn || cluster.memories.length < 2) return 0;
+  const vectors = [];
+  for (const mem of cluster.memories) {
+    try {
+      const v = await embedFn(mem.raw_text);
+      vectors.push({ id: mem.id, vector: v });
+    } catch {
+    }
+  }
+  if (vectors.length < 2) return 0;
+  const toArchive = /* @__PURE__ */ new Set();
+  for (let i = 0; i < vectors.length; i++) {
+    if (toArchive.has(vectors[i].id)) continue;
+    for (let j = i + 1; j < vectors.length; j++) {
+      if (toArchive.has(vectors[j].id)) continue;
+      const sim = cosineSimilarity(vectors[i].vector, vectors[j].vector);
+      if (sim > 0.95) {
+        toArchive.add(vectors[j].id);
+      }
+    }
+  }
+  if (toArchive.size === 0) return 0;
+  const ids = [...toArchive];
+  const placeholders = ids.map(() => "?").join(",");
+  await client.execute({
+    sql: `UPDATE memories SET status = 'archived', consolidated = 1 WHERE id IN (${placeholders})`,
+    args: ids
+  });
+  const survivors = vectors.filter((v) => !toArchive.has(v.id)).map((v) => v.id);
+  if (survivors.length > 0) {
+    const survivorPlaceholders = survivors.map(() => "?").join(",");
+    await client.execute({
+      sql: `UPDATE memories SET confidence = MIN(1.0, COALESCE(confidence, 0.7) + 0.1) WHERE id IN (${survivorPlaceholders})`,
+      args: survivors
+    });
+  }
+  return ids.length;
+}
+function cosineSimilarity(a, b) {
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+async function isUserIdle(client, idleMinutes = 30) {
+  const result = await client.execute({
+    sql: `SELECT MAX(timestamp) as last_activity
+          FROM memories
+          WHERE tool_name != 'consolidation'
+            AND timestamp >= datetime('now', '-1 day')`,
+    args: []
+  });
+  const lastActivity = result.rows[0]?.last_activity;
+  if (!lastActivity) return true;
+  const lastMs = new Date(lastActivity).getTime();
+  const now = Date.now();
+  return now - lastMs >= idleMinutes * 60 * 1e3;
+}
+async function countUnconsolidated(client) {
+  const result = await client.execute({
+    sql: `SELECT COUNT(*) as cnt FROM memories
+          WHERE consolidated = 0
+            AND COALESCE(memory_type, 'raw') != 'procedure'`,
+    args: []
+  });
+  return Number(result.rows[0]?.cnt ?? 0);
+}
+
+export {
+  selectUnconsolidated,
+  groupMemories,
+  buildConsolidationPrompt,
+  consolidateCluster,
+  storeConsolidation,
+  pushToWiki,
+  runConsolidation,
+  isUserIdle,
+  countUnconsolidated
+};

package/dist/chunk-INO4ZD5Y.js

@@ -0,0 +1,162 @@
+import {
+  getClient,
+  init_database
+} from "./chunk-A2NZP64U.js";
+
+// src/lib/token-spend.ts
+init_database();
+import { readdir } from "fs/promises";
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import path from "path";
+import os from "os";
+var MODEL_PRICING = {
+  // Opus 4.5+ ($5/$25 — Anthropic price drop from original Opus 4)
+  "claude-opus-4-7": { input: 5 / 1e6, output: 25 / 1e6, cacheRead: 0.5 / 1e6, cacheWrite: 6.25 / 1e6 },
+  "claude-opus-4-6": { input: 5 / 1e6, output: 25 / 1e6, cacheRead: 0.5 / 1e6, cacheWrite: 6.25 / 1e6 },
+  "claude-opus-4-5": { input: 5 / 1e6, output: 25 / 1e6, cacheRead: 0.5 / 1e6, cacheWrite: 6.25 / 1e6 },
+  // Opus 4.0/4.1 (legacy $15/$75)
+  "claude-opus-4-1": { input: 15 / 1e6, output: 75 / 1e6, cacheRead: 1.5 / 1e6, cacheWrite: 18.75 / 1e6 },
+  "claude-opus-4": { input: 15 / 1e6, output: 75 / 1e6, cacheRead: 1.5 / 1e6, cacheWrite: 18.75 / 1e6 },
+  // Sonnet 4.x
+  "claude-sonnet-4": { input: 3 / 1e6, output: 15 / 1e6, cacheRead: 0.3 / 1e6, cacheWrite: 3.75 / 1e6 },
+  // Sonnet 3.7/3.5
+  "claude-3-7-sonnet": { input: 3 / 1e6, output: 15 / 1e6, cacheRead: 0.3 / 1e6, cacheWrite: 3.75 / 1e6 },
+  "claude-3-5-sonnet": { input: 3 / 1e6, output: 15 / 1e6, cacheRead: 0.3 / 1e6, cacheWrite: 3.75 / 1e6 },
+  // Haiku 4.5
+  "claude-haiku-4-5": { input: 1 / 1e6, output: 5 / 1e6, cacheRead: 0.1 / 1e6, cacheWrite: 1.25 / 1e6 },
+  // Haiku 3.5
+  "claude-3-5-haiku": { input: 0.8 / 1e6, output: 4 / 1e6, cacheRead: 0.08 / 1e6, cacheWrite: 1 / 1e6 },
+  // Opus 3
+  "claude-3-opus": { input: 15 / 1e6, output: 75 / 1e6, cacheRead: 1.5 / 1e6, cacheWrite: 18.75 / 1e6 },
+  // Sonnet 3
+  "claude-3-sonnet": { input: 3 / 1e6, output: 15 / 1e6, cacheRead: 0.3 / 1e6, cacheWrite: 3.75 / 1e6 },
+  // Haiku 3
+  "claude-3-haiku": { input: 0.25 / 1e6, output: 1.25 / 1e6, cacheRead: 0.03 / 1e6, cacheWrite: 0.3 / 1e6 }
+};
+var DEFAULT_PRICING = MODEL_PRICING["claude-sonnet-4"];
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var _spendCache = /* @__PURE__ */ new Map();
+function getPricing(model) {
+  if (MODEL_PRICING[model]) return MODEL_PRICING[model];
+  const stripped = model.replace(/-\d{8}$/, "");
+  if (MODEL_PRICING[stripped]) return MODEL_PRICING[stripped];
+  const sortedKeys = Object.keys(MODEL_PRICING).sort((a, b) => b.length - a.length);
+  for (const key of sortedKeys) {
+    if (model.includes(key)) return MODEL_PRICING[key];
+  }
+  return DEFAULT_PRICING;
+}
+async function getAgentSpend(period = "7d") {
+  const cached = _spendCache.get(period);
+  if (cached && Date.now() < cached.expires) {
+    return cached.result;
+  }
+  const cutoff = periodToCutoff(period);
+  const client = getClient();
+  const dbResult = await client.execute({
+    sql: `SELECT session_uuid, agent_id FROM session_agent_map WHERE started_at >= ?`,
+    args: [cutoff]
+  });
+  if (dbResult.rows.length === 0) return [];
+  const sessionAgent = /* @__PURE__ */ new Map();
+  for (const row of dbResult.rows) {
+    sessionAgent.set(row.session_uuid, row.agent_id);
+  }
+  const claudeDir = path.join(os.homedir(), ".claude", "projects");
+  let projectDirs = [];
+  try {
+    const entries = await readdir(claudeDir);
+    projectDirs = entries.map((e) => path.join(claudeDir, e));
+  } catch {
+    return [];
+  }
+  const agentTotals = /* @__PURE__ */ new Map();
+  for (const [sessionUuid, agentId] of sessionAgent) {
+    for (const dir of projectDirs) {
+      const jsonlPath = path.join(dir, `${sessionUuid}.jsonl`);
+      try {
+        const usage = await extractSessionUsage(jsonlPath);
+        if (usage.input === 0 && usage.output === 0) continue;
+        const totals = agentTotals.get(agentId) ?? {
+          input: 0,
+          output: 0,
+          cacheRead: 0,
+          cacheCreate: 0,
+          costUSD: 0,
+          sessions: /* @__PURE__ */ new Set()
+        };
+        totals.input += usage.input;
+        totals.output += usage.output;
+        totals.cacheRead += usage.cacheRead;
+        totals.cacheCreate += usage.cacheCreate;
+        totals.costUSD += usage.costUSD;
+        totals.sessions.add(sessionUuid);
+        agentTotals.set(agentId, totals);
+        break;
+      } catch {
+      }
+    }
+  }
+  const result = Array.from(agentTotals.entries()).map(([agentId, t]) => ({
+    agentId,
+    inputTokens: t.input,
+    outputTokens: t.output,
+    cacheReadTokens: t.cacheRead,
+    cacheCreationTokens: t.cacheCreate,
+    costUSD: t.costUSD,
+    sessions: t.sessions.size,
+    period
+  })).sort((a, b) => b.costUSD - a.costUSD);
+  _spendCache.set(period, { result, expires: Date.now() + CACHE_TTL_MS });
+  return result;
+}
+async function extractSessionUsage(jsonlPath) {
+  let input = 0;
+  let output = 0;
+  let cacheRead = 0;
+  let cacheCreate = 0;
+  let costUSD = 0;
+  const seenMessageIds = /* @__PURE__ */ new Set();
+  const rl = createInterface({
+    input: createReadStream(jsonlPath, { encoding: "utf8" }),
+    crlfDelay: Infinity
+  });
+  for await (const line of rl) {
+    if (!line.includes('"type":"assistant"')) continue;
+    try {
+      const record = JSON.parse(line);
+      if (record.type !== "assistant") continue;
+      const messageId = record.message?.id;
+      if (messageId) {
+        if (seenMessageIds.has(messageId)) continue;
+        seenMessageIds.add(messageId);
+      }
+      const usage = record.message?.usage;
+      if (!usage) continue;
+      const model = record.message?.model ?? "";
+      const pricing = getPricing(model);
+      const inp = usage.input_tokens ?? 0;
+      const out = usage.output_tokens ?? 0;
+      const cr = usage.cache_read_input_tokens ?? 0;
+      const cc = usage.cache_creation_input_tokens ?? 0;
+      input += inp;
+      output += out;
+      cacheRead += cr;
+      cacheCreate += cc;
+      if (pricing) {
+        costUSD += inp * pricing.input + out * pricing.output + cr * pricing.cacheRead + cc * pricing.cacheWrite;
+      }
+    } catch {
+    }
+  }
+  return { input, output, cacheRead, cacheCreate, costUSD };
+}
+function periodToCutoff(period) {
+  const ms = { "24h": 864e5, "7d": 6048e5, "30d": 2592e6 }[period];
+  return new Date(Date.now() - ms).toISOString();
+}
+
+export {
+  getAgentSpend
+};