@askexenow/exe-os 0.9.270 → 0.9.272

package/dist/chunk-KZNSOHCB.js

@@ -0,0 +1,280 @@
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-2NQQP3FF.js";
+
+// src/lib/worktree.ts
+import { execSync } from "child_process";
+import { existsSync, readFileSync, appendFileSync, mkdirSync, realpathSync } from "fs";
+import path from "path";
+var GIT_TIMEOUT_MS = 1e4;
+function getGitRoot(dir) {
+  try {
+    const root = execSync("git rev-parse --show-toplevel", {
+      cwd: dir,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return realpath(root);
+  } catch {
+    return null;
+  }
+}
+function getMainRepoRoot(dir) {
+  try {
+    const commonDir = execSync(
+      "git rev-parse --path-format=absolute --git-common-dir",
+      { cwd: dir, encoding: "utf-8", timeout: GIT_TIMEOUT_MS, stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    return realpath(path.dirname(commonDir));
+  } catch {
+    return null;
+  }
+}
+function worktreePath(repoRoot, employeeName, instance) {
+  const label = instanceLabel(employeeName, instance);
+  return path.join(repoRoot, ".worktrees", label);
+}
+function worktreeBranch(employeeName, instance, taskSlug) {
+  const label = instanceLabel(employeeName, instance);
+  if (taskSlug) {
+    const slug = taskSlug.slice(0, 40).replace(/[^a-z0-9-]/gi, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+    return `${label}-${slug}`;
+  }
+  return `${label}-work`;
+}
+function instanceLabel(name, instance) {
+  return instance != null && instance > 0 ? `${name}${instance}` : name;
+}
+function ensureWorktree(projectDir, employeeName, instance) {
+  const repoRoot = getGitRoot(projectDir);
+  if (!repoRoot) return null;
+  const wtPath = worktreePath(repoRoot, employeeName, instance);
+  const branch = worktreeBranch(employeeName, instance);
+  if (existsSync(path.join(wtPath, ".git"))) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.reused",
+      source: "worktree.ensureWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { branch }
+    });
+    return wtPath;
+  }
+  const worktreesDir = path.join(repoRoot, ".worktrees");
+  mkdirSync(worktreesDir, { recursive: true });
+  ensureGitignoreEntry(repoRoot, "/.worktrees/");
+  try {
+    execSync("git worktree prune", {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+  }
+  const branchExists = branchExistsLocally(repoRoot, branch);
+  try {
+    if (branchExists) {
+      execSync(`git worktree add "${wtPath}" "${branch}"`, {
+        cwd: repoRoot,
+        encoding: "utf-8",
+        timeout: GIT_TIMEOUT_MS,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } else {
+      execSync(`git worktree add "${wtPath}" -b "${branch}" HEAD`, {
+        cwd: repoRoot,
+        encoding: "utf-8",
+        timeout: GIT_TIMEOUT_MS,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    }
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.created",
+      source: "worktree.ensureWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { branch, reusedBranch: branchExists }
+    });
+    return wtPath;
+  } catch (err) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.failed",
+      source: "worktree.ensureWorktree",
+      severity: "warn",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      errorCode: err instanceof Error ? err.name : "worktree_create_failed",
+      payload: { branch }
+    });
+    process.stderr.write(
+      `[worktree] Failed to create worktree for ${employeeName}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return null;
+  }
+}
+function isWorktreeDirty(wtPath) {
+  try {
+    const status = execSync("git status --porcelain", {
+      cwd: wtPath,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return status.length > 0;
+  } catch {
+    return true;
+  }
+}
+function cleanupWorktree(projectDir, employeeName, instance) {
+  const repoRoot = getMainRepoRoot(projectDir);
+  if (!repoRoot) return { cleaned: false, reason: "not a git repo" };
+  const wtPath = worktreePath(repoRoot, employeeName, instance);
+  const branch = worktreeBranch(employeeName, instance);
+  if (!existsSync(wtPath)) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.skipped",
+      source: "worktree.cleanupWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { reason: "worktree does not exist", branch }
+    });
+    return { cleaned: false, reason: "worktree does not exist" };
+  }
+  if (isWorktreeDirty(wtPath)) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.skipped",
+      source: "worktree.cleanupWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { reason: "worktree has uncommitted changes", branch }
+    });
+    return { cleaned: false, reason: "worktree has uncommitted changes" };
+  }
+  const mainBranch = detectMainBranch(repoRoot);
+  if (!mainBranch) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.skipped",
+      source: "worktree.cleanupWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { reason: "could not determine main branch", branch }
+    });
+    return { cleaned: false, reason: "could not determine main branch" };
+  }
+  if (!isBranchMerged(repoRoot, branch, mainBranch)) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.skipped",
+      source: "worktree.cleanupWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { reason: "branch not merged", branch, mainBranch }
+    });
+    return { cleaned: false, reason: `branch ${branch} not merged into ${mainBranch}` };
+  }
+  try {
+    execSync(`git worktree remove "${wtPath}"`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch (err) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.failed",
+      source: "worktree.cleanupWorktree",
+      severity: "warn",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      errorCode: err instanceof Error ? err.name : "worktree_remove_failed",
+      payload: { branch, mainBranch }
+    });
+    return {
+      cleaned: false,
+      reason: `git worktree remove failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  try {
+    execSync(`git branch -d "${branch}"`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+  }
+  recordOrchestrationEventBestEffort({
+    eventType: "worktree.pruned",
+    source: "worktree.cleanupWorktree",
+    agentId: employeeName,
+    instanceId: instance != null ? String(instance) : null,
+    payload: { branch, mainBranch }
+  });
+  return { cleaned: true, reason: `worktree and branch ${branch} removed (merged into ${mainBranch})` };
+}
+function branchExistsLocally(repoRoot, branch) {
+  try {
+    execSync(`git rev-parse --verify "refs/heads/${branch}"`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectMainBranch(repoRoot) {
+  for (const candidate of ["main", "master"]) {
+    if (branchExistsLocally(repoRoot, candidate)) return candidate;
+  }
+  return null;
+}
+function isBranchMerged(repoRoot, branch, into) {
+  try {
+    const merged = execSync(`git branch --merged "${into}"`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return merged.split("\n").map((l) => l.replace(/^[*+]?\s+/, "").trim()).includes(branch);
+  } catch {
+    return false;
+  }
+}
+function realpath(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function ensureGitignoreEntry(repoRoot, entry) {
+  try {
+    const gitignorePath = path.join(repoRoot, ".gitignore");
+    if (existsSync(gitignorePath)) {
+      const content = readFileSync(gitignorePath, "utf-8");
+      if (content.includes(entry)) return;
+      appendFileSync(gitignorePath, `
+# Agent worktrees (exe-os)
+${entry}
+`);
+    } else {
+    }
+  } catch {
+  }
+}
+
+export {
+  getGitRoot,
+  getMainRepoRoot,
+  worktreePath,
+  worktreeBranch,
+  ensureWorktree,
+  isWorktreeDirty,
+  cleanupWorktree
+};

package/dist/chunk-LVMBYP3C.js

@@ -0,0 +1,171 @@
+import {
+  writeMemoryViaDaemon
+} from "./chunk-OSXQTCW5.js";
+
+// src/lib/auto-checkpoint.ts
+var FILE_RE = /(?:^|\s)([\w./-]+\.(?:ts|tsx|js|jsx|json|md|yml|yaml|sql|go|py|css|scss|html|sh))(?:\b|$)/g;
+var DECISION_RE = /\b(decision:|decided:|we decided|founder directive|captured in .*architecture|source of truth)\b/i;
+function asString(value, fallback = "") {
+  if (value == null) return fallback;
+  return String(value);
+}
+function compactLine(text, max = 220) {
+  return text.replace(/\s+/g, " ").trim().slice(0, max);
+}
+function topEntries(counts, limit) {
+  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, limit).map(([name, count]) => `${name}(${count})`);
+}
+function buildAutoCheckpoint(input) {
+  const maxSamples = input.maxSamples ?? 8;
+  const projectCounts = /* @__PURE__ */ new Map();
+  const toolCounts = /* @__PURE__ */ new Map();
+  const files = /* @__PURE__ */ new Set();
+  const errors = [];
+  const samples = [];
+  const decisionTexts = [];
+  for (const row of input.memories) {
+    const tool = asString(row.tool_name, "unknown");
+    const project = asString(row.project_name, input.projectName || "unknown");
+    const raw = asString(row.raw_text);
+    const hasError = row.has_error === 1 || row.has_error === true;
+    toolCounts.set(tool, (toolCounts.get(tool) ?? 0) + 1);
+    projectCounts.set(project, (projectCounts.get(project) ?? 0) + 1);
+    if (hasError && errors.length < 5) errors.push(compactLine(raw, 180));
+    if (samples.length < maxSamples && raw.length > 30) {
+      samples.push(`[${tool}] ${compactLine(raw)}`);
+    }
+    if (DECISION_RE.test(raw) && decisionTexts.length < 5) {
+      decisionTexts.push(`AUTO DECISION CANDIDATE [${input.agentId}]: ${compactLine(raw, 500)}`);
+    }
+    for (const match of raw.matchAll(FILE_RE)) {
+      if (match[1]) files.add(match[1]);
+      if (files.size >= 20) break;
+    }
+  }
+  const taskLines = (input.tasks ?? []).slice(0, 10).map((task) => {
+    const status = asString(task.status, "unknown");
+    const priority = asString(task.priority, "?").toUpperCase();
+    const title = asString(task.title, "untitled");
+    const taskFile = asString(task.task_file);
+    return `- [${status}/${priority}] ${title}${taskFile ? ` (${taskFile})` : ""}`;
+  });
+  const parts = [
+    `CONTEXT CHECKPOINT [auto:${input.reason}]`,
+    `Agent: ${input.agentId} (${input.agentRole})`,
+    `Session: ${input.sessionId}`,
+    `Project: ${input.projectName}`,
+    `Time: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    "## Recent Activity",
+    `- Memories scanned: ${input.memories.length}`,
+    `- Projects: ${topEntries(projectCounts, 5).join(", ") || input.projectName}`,
+    `- Tools: ${topEntries(toolCounts, 8).join(", ") || "none"}`
+  ];
+  if (taskLines.length > 0) {
+    parts.push("", "## Open / Active Tasks", ...taskLines);
+  }
+  if (files.size > 0) {
+    parts.push("", "## Files Mentioned", ...[...files].slice(0, 20).map((f) => `- ${f}`));
+  }
+  if (samples.length > 0) {
+    parts.push("", "## Important Recent Traces", ...samples.map((s) => `- ${s}`));
+  }
+  if (errors.length > 0) {
+    parts.push("", "## Errors / Risks", ...errors.map((e) => `- ${e}`));
+  }
+  if (decisionTexts.length > 0) {
+    parts.push("", "## Decision Candidates", ...decisionTexts.map((d) => `- ${d.replace(/^AUTO DECISION CANDIDATE \\[[^\\]]+\\]: /, "")}`));
+  }
+  return {
+    checkpointText: parts.join("\n"),
+    decisionTexts
+  };
+}
+
+// src/lib/checkpoint-orchestrator.ts
+function toolNameForReason(reason) {
+  switch (reason) {
+    case "periodic":
+      return "auto-summary";
+    case "session-end":
+      return "SessionEnd";
+    case "pre-compact":
+      return "pre-compact-hook";
+    case "capacity-signal":
+      return "auto-checkpoint";
+  }
+}
+function importanceForReason(reason, override) {
+  if (override !== void 0) return override;
+  switch (reason) {
+    case "periodic":
+      return 7;
+    case "session-end":
+    case "pre-compact":
+    case "capacity-signal":
+      return 8;
+  }
+}
+function buildContinuityCheckpoint(input) {
+  const { checkpointText, decisionTexts } = buildAutoCheckpoint({
+    agentId: input.agentId,
+    agentRole: input.agentRole,
+    sessionId: input.sessionId,
+    projectName: input.projectName,
+    reason: input.reason,
+    memories: input.memories ?? [],
+    tasks: input.tasks ?? [],
+    maxSamples: input.maxSamples
+  });
+  const extra = input.extraSections?.filter((section) => section.trim().length > 0) ?? [];
+  return {
+    checkpointText: extra.length > 0 ? `${checkpointText}
+
+${extra.join("\n\n")}` : checkpointText,
+    decisionTexts
+  };
+}
+async function writeContinuityCheckpoint(input) {
+  const result = buildContinuityCheckpoint(input);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await writeMemoryViaDaemon({
+    raw_text: result.checkpointText,
+    agent_id: input.agentId,
+    agent_role: input.agentRole,
+    session_id: input.sessionId,
+    tool_name: toolNameForReason(input.reason),
+    project_name: input.projectName,
+    timestamp: now,
+    importance: importanceForReason(input.reason, input.importance),
+    task_id: input.taskId,
+    memory_type: "checkpoint"
+  });
+  const decisionLimit = input.reason === "periodic" ? 3 : 5;
+  for (const decisionText of result.decisionTexts.slice(0, decisionLimit)) {
+    await writeMemoryViaDaemon({
+      raw_text: decisionText,
+      agent_id: input.agentId,
+      agent_role: input.agentRole,
+      session_id: input.sessionId,
+      tool_name: "auto-decision",
+      project_name: input.projectName,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      importance: 8,
+      memory_type: "decision"
+    });
+  }
+  return result;
+}
+async function checkpointActiveTask(input) {
+  const { writeCheckpoint } = await import("./lib/tasks.js");
+  await writeCheckpoint({
+    taskId: input.taskId,
+    step: input.step ?? "pre-compaction-checkpoint",
+    contextSummary: `Auto-checkpoint before context compaction. Task: ${input.taskTitle}. Session: ${input.sessionId}. Project: ${input.projectName}.`
+  });
+}
+
+export {
+  writeContinuityCheckpoint,
+  checkpointActiveTask
+};

package/dist/chunk-M2WQW5NC.js

@@ -0,0 +1,227 @@
+import {
+  getClient
+} from "./chunk-CHBHR5W6.js";
+
+// src/lib/token-spend.ts
+import { readdir, stat } 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 JSONL_INDEX_TTL_MS = 5 * 60 * 1e3;
+var USAGE_CACHE_MAX_ENTRIES = 1e4;
+var _spendCache = /* @__PURE__ */ new Map();
+var _spendInFlight = /* @__PURE__ */ new Map();
+var _usageCache = /* @__PURE__ */ new Map();
+var _usageInFlight = /* @__PURE__ */ new Map();
+var _jsonlPathIndex = null;
+function yieldToEventLoop() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+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 inFlight = _spendInFlight.get(period);
+  if (inFlight) return inFlight;
+  const promise = computeAgentSpend(period).finally(() => _spendInFlight.delete(period));
+  _spendInFlight.set(period, promise);
+  return promise;
+}
+async function computeAgentSpend(period) {
+  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 jsonlPaths = await getClaudeSessionJsonlIndex();
+  if (jsonlPaths.size === 0) return [];
+  const agentTotals = /* @__PURE__ */ new Map();
+  let processed = 0;
+  for (const [sessionUuid, agentId] of sessionAgent) {
+    const jsonlPath = jsonlPaths.get(sessionUuid);
+    if (!jsonlPath) continue;
+    try {
+      const usage = await extractSessionUsageCached(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);
+    } catch {
+    }
+    processed++;
+    if (processed % 25 === 0) await yieldToEventLoop();
+  }
+  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 getClaudeSessionJsonlIndex() {
+  if (_jsonlPathIndex && Date.now() < _jsonlPathIndex.expires) {
+    return _jsonlPathIndex.paths;
+  }
+  const claudeDir = path.join(os.homedir(), ".claude", "projects");
+  const paths = /* @__PURE__ */ new Map();
+  let projectDirs = [];
+  try {
+    const entries = await readdir(claudeDir, { withFileTypes: true });
+    projectDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => path.join(claudeDir, entry.name));
+  } catch {
+    _jsonlPathIndex = { expires: Date.now() + JSONL_INDEX_TTL_MS, paths };
+    return paths;
+  }
+  let scanned = 0;
+  for (const dir of projectDirs) {
+    try {
+      const files = await readdir(dir);
+      for (const file of files) {
+        if (!file.endsWith(".jsonl")) continue;
+        paths.set(file.slice(0, -".jsonl".length), path.join(dir, file));
+      }
+    } catch {
+    }
+    scanned++;
+    if (scanned % 25 === 0) await yieldToEventLoop();
+  }
+  _jsonlPathIndex = { expires: Date.now() + JSONL_INDEX_TTL_MS, paths };
+  return paths;
+}
+async function extractSessionUsageCached(jsonlPath) {
+  const st = await stat(jsonlPath);
+  const cached = _usageCache.get(jsonlPath);
+  if (cached && cached.mtimeMs === st.mtimeMs && cached.size === st.size) {
+    return cached.usage;
+  }
+  const existing = _usageInFlight.get(jsonlPath);
+  if (existing) return existing;
+  const promise = extractSessionUsage(jsonlPath).then((usage) => {
+    _usageCache.set(jsonlPath, { mtimeMs: st.mtimeMs, size: st.size, usage });
+    pruneUsageCache();
+    return usage;
+  }).finally(() => _usageInFlight.delete(jsonlPath));
+  _usageInFlight.set(jsonlPath, promise);
+  return promise;
+}
+function pruneUsageCache() {
+  if (_usageCache.size <= USAGE_CACHE_MAX_ENTRIES) return;
+  const overflow = _usageCache.size - USAGE_CACHE_MAX_ENTRIES;
+  let removed = 0;
+  for (const key of _usageCache.keys()) {
+    _usageCache.delete(key);
+    removed++;
+    if (removed >= overflow) break;
+  }
+}
+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
+};