@hasna/economy 0.4.0 → 0.5.1

package/dist/chunks/index-xsah93s2.js

@@ -0,0 +1,2085 @@
+// @bun
+import {
+  LOCAL_STORAGE_OPT_IN_KEYS
+} from "./index-d480p2wh.js";
+import {
+  assessCostFromDb,
+  getIngestState,
+  getMachineId,
+  loadIngestState,
+  normalizeModelName,
+  observationId,
+  rollupSession,
+  scanReceiptId,
+  setIngestState,
+  subscriptionId,
+  upsertCostCenter,
+  upsertRequest,
+  upsertScanReceipt,
+  upsertSession,
+  upsertSubscription,
+  upsertUsageSnapshot
+} from "./index-ez9thsr7.js";
+import {
+  __require
+} from "./index-p35cyhc4.js";
+
+// src/ingest/collection-outcome.ts
+import { AsyncLocalStorage } from "async_hooks";
+var context = new AsyncLocalStorage;
+function collectionProblem(status, code) {
+  const state = context.getStore();
+  if (state && state.status !== "failed") {
+    state.status = status;
+    state.code = /^[A-Z][A-Z0-9_]{0,63}$/.test(code.toUpperCase()) ? code.toUpperCase() : "COLLECTION_FAILED";
+  }
+}
+function collectionUnchanged() {
+  const state = context.getStore();
+  if (state)
+    state.unchanged = true;
+}
+async function collectWithOutcome(source, run, empty) {
+  const attempted_at = new Date().toISOString();
+  const state = { unchanged: false };
+  let result = empty;
+  await context.run(state, async () => {
+    try {
+      result = await run();
+    } catch {
+      collectionProblem("failed", "collection_failed");
+    }
+  });
+  const changes = Object.entries(result).some(([key, value]) => ["requests", "snapshots", "sessions"].includes(key) && typeof value === "number" && value > 0);
+  return { result, outcome: { source, attempted_at, completed_at: new Date().toISOString(), status: state.status ?? (!changes && state.unchanged ? "unchanged" : "success"), parser_version: "economy-collector-v4", error_code: state.code ?? null } };
+}
+
+// src/ingest/source-time.ts
+function sourceTime(value) {
+  if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/.test(value))
+    return null;
+  const day = value.slice(0, 10), midnight = Date.parse(day + "T00:00:00Z"), ms = Date.parse(value);
+  if (!Number.isFinite(midnight) || new Date(midnight).toISOString().slice(0, 10) !== day || !Number.isFinite(ms) || Number(value.slice(11, 13)) > 23 || Number(value.slice(14, 16)) > 59 || Number(value.slice(17, 19)) > 59)
+    return null;
+  return new Date(ms).toISOString();
+}
+function sourceTimeMillis(value) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0 || !Number.isFinite(new Date(value).getTime()))
+    return null;
+  return new Date(value).toISOString();
+}
+
+// src/ingest/claude.ts
+import { readdirSync, readFileSync as readFileSync2, existsSync as existsSync2, statSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2, basename } from "path";
+
+// src/lib/accounts-store.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { z } from "zod";
+import { resolveClientTransport, resolveCredential } from "@hasna/contracts/client";
+var ACCOUNTS_APP = "accounts";
+var profileNameSchema = z.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9-]*$/, "must be lowercase alphanumeric/hyphen and start with a letter or digit");
+var profileSchema = z.object({
+  name: z.string(),
+  tool: z.string(),
+  email: z.string().optional(),
+  displayName: z.string().optional(),
+  dir: z.string(),
+  description: z.string().optional(),
+  createdAt: z.string(),
+  lastUsedAt: z.string().optional()
+});
+var toolDefSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  envVar: z.string(),
+  defaultDir: z.string(),
+  bin: z.string()
+});
+var storeSchema = z.object({
+  version: z.literal(1),
+  current: z.record(z.string(), z.string()).default({}),
+  applied: z.record(z.string(), z.string()).default({}),
+  toolLocks: z.record(z.string(), z.string()).default({}),
+  profiles: z.array(profileSchema).default([]),
+  tools: z.array(toolDefSchema).default([])
+});
+function localRegistryAllowed(env = process.env) {
+  return LOCAL_STORAGE_OPT_IN_KEYS.some((key) => {
+    const raw = env[key];
+    if (raw === undefined)
+      return false;
+    const value = raw.trim().toLowerCase();
+    return value !== "" && value !== "0" && value !== "false" && value !== "no" && value !== "off";
+  });
+}
+function validateEnvPath(value, label) {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.includes("\x00") || /[\r\n]/.test(trimmed))
+    throw new Error(`invalid ${label}`);
+  return trimmed;
+}
+function accountsHome() {
+  const override = process.env.ACCOUNTS_HOME;
+  if (override && override.trim())
+    return validateEnvPath(override, "ACCOUNTS_HOME");
+  return join(homedir(), ".hasna", "accounts");
+}
+function storePath() {
+  const override = process.env.ACCOUNTS_STORE_PATH;
+  if (override && override.trim())
+    return validateEnvPath(override, "ACCOUNTS_STORE_PATH");
+  return join(accountsHome(), "accounts.json");
+}
+var EMPTY_STORE = {
+  version: 1,
+  current: {},
+  applied: {},
+  toolLocks: {},
+  profiles: [],
+  tools: []
+};
+function parseStoreFile() {
+  if (!localRegistryAllowed())
+    return structuredClone(EMPTY_STORE);
+  const path = storePath();
+  if (!existsSync(path))
+    return structuredClone(EMPTY_STORE);
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf8"));
+  } catch (err) {
+    throw new Error(`could not parse store at ${path}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const parsed = storeSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new Error(`invalid store at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+  }
+  return parsed.data;
+}
+function loadAppliedMap() {
+  const applied = {};
+  for (const [toolId, name] of Object.entries(parseStoreFile().applied)) {
+    if (name && profileNameSchema.safeParse(name).success)
+      applied[toolId] = name;
+  }
+  return applied;
+}
+function appliedProfileName(toolId) {
+  if (!localRegistryAllowed())
+    return;
+  return loadAppliedMap()[toolId];
+}
+var BUILTIN_TOOLS = [
+  { id: "claude", label: "Claude Code", envVar: "CLAUDE_CONFIG_DIR", defaultDir: join(homedir(), ".claude"), bin: "claude" },
+  { id: "codex-app", label: "Codex App", envVar: "CODEX_HOME", defaultDir: join(homedir(), ".codex"), bin: "/Applications/Codex.app/Contents/MacOS/Codex" },
+  { id: "codex", label: "Codex CLI", envVar: "CODEX_HOME", defaultDir: join(homedir(), ".codex"), bin: "codex" },
+  { id: "codewith", label: "Codewith", envVar: "CODEWITH_HOME", defaultDir: join(homedir(), ".codewith"), bin: "codewith" },
+  { id: "takumi", label: "Takumi", envVar: "TAKUMI_CONFIG_DIR", defaultDir: join(homedir(), ".takumi"), bin: "takumi" },
+  { id: "gemini", label: "Gemini CLI", envVar: "GEMINI_CONFIG_DIR", defaultDir: join(homedir(), ".gemini"), bin: "gemini" },
+  { id: "opencode", label: "opencode", envVar: "OPENCODE_CONFIG_DIR", defaultDir: join(homedir(), ".config", "opencode"), bin: "opencode" },
+  { id: "cursor", label: "Cursor Agent", envVar: "CURSOR_CONFIG_DIR", defaultDir: join(homedir(), ".cursor"), bin: "cursor-agent" },
+  { id: "pi", label: "Pi Coding Agent", envVar: "PI_CODING_AGENT_HOME", defaultDir: join(homedir(), ".pi"), bin: "pi" },
+  { id: "hermes", label: "Hermes", envVar: "HERMES_HOME", defaultDir: join(homedir(), ".hermes"), bin: "hermes" },
+  { id: "kimi", label: "Kimi Code", envVar: "KIMI_CODE_HOME", defaultDir: join(homedir(), ".kimi-code"), bin: "kimi" },
+  { id: "grok", label: "Grok Build", envVar: "HOME", defaultDir: join(homedir(), ".grok"), bin: "grok" }
+];
+
+class LocalStore {
+  transport = "local";
+  async listProfiles(tool) {
+    const profiles = parseStoreFile().profiles;
+    const filtered = tool ? profiles.filter((profile) => profile.tool === tool) : profiles;
+    return filtered.slice().sort((a, b) => a.tool.localeCompare(b.tool) || a.name.localeCompare(b.name));
+  }
+  async findProfile(name, tool) {
+    const matches = parseStoreFile().profiles.filter((profile) => profile.name === name && (!tool || profile.tool === tool));
+    return matches.length === 1 ? matches[0] : undefined;
+  }
+  async currentProfile(tool) {
+    const store = parseStoreFile();
+    const name = store.current[tool];
+    if (!name)
+      return;
+    return store.profiles.find((profile) => profile.name === name && profile.tool === tool);
+  }
+  async listTools() {
+    const custom = parseStoreFile().tools;
+    const byId = new Map;
+    for (const tool of BUILTIN_TOOLS)
+      byId.set(tool.id, tool);
+    for (const tool of custom)
+      byId.set(tool.id, tool);
+    return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
+  }
+}
+
+class NoRegistryStore {
+  transport = "none";
+  async listProfiles() {
+    return [];
+  }
+  async findProfile() {
+    return;
+  }
+  async currentProfile() {
+    return;
+  }
+  async listTools() {
+    return BUILTIN_TOOLS.slice().sort((a, b) => a.id.localeCompare(b.id));
+  }
+}
+var RETRY_STATUSES = [408, 425, 429, 500, 502, 503, 504];
+
+class AccountsApiError extends Error {
+  status;
+  body;
+  constructor(method, path, status, body) {
+    super(`accounts cloud request failed: ${method} ${path} -> ${status}`);
+    this.name = "AccountsApiError";
+    this.status = status;
+    this.body = body;
+  }
+}
+function isNotFound(err) {
+  return Boolean(err && typeof err === "object" && err.status === 404);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function cloudRequest(baseUrl, apiKey, path, query) {
+  const rel = path.startsWith("/") ? path : `/${path}`;
+  const url = query && Object.keys(query).length > 0 ? `${baseUrl}${rel}?${new URLSearchParams(query).toString()}` : `${baseUrl}${rel}`;
+  let lastError;
+  for (let attempt = 0;attempt < 3; attempt += 1) {
+    const controller = new AbortController;
+    const timer = setTimeout(() => controller.abort(), 30000);
+    let res;
+    try {
+      res = await fetch(url, {
+        method: "GET",
+        headers: {
+          "x-api-key": apiKey,
+          Authorization: `Bearer ${apiKey}`,
+          Accept: "application/json"
+        },
+        signal: controller.signal
+      });
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      clearTimeout(timer);
+      if (attempt < 2) {
+        const backoff = Math.min(2000, 200 * 2 ** attempt);
+        const jitter = Math.floor(Math.random() * (backoff / 2 + 1));
+        await sleep(backoff + jitter);
+      }
+      continue;
+    } finally {
+      clearTimeout(timer);
+    }
+    const text = await res.text();
+    let parsed;
+    if (text.length > 0) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = text;
+      }
+    }
+    if (!res.ok) {
+      lastError = new AccountsApiError("GET", rel, res.status, parsed);
+      if (attempt < 2 && RETRY_STATUSES.includes(res.status)) {
+        const backoff = Math.min(2000, 200 * 2 ** attempt);
+        const jitter = Math.floor(Math.random() * (backoff / 2 + 1));
+        await sleep(backoff + jitter);
+        continue;
+      }
+      break;
+    }
+    return parsed;
+  }
+  throw lastError;
+}
+function toProfile(account) {
+  const profile = {
+    name: String(account.name),
+    tool: String(account.tool),
+    dir: typeof account.dir === "string" ? account.dir : "",
+    createdAt: String(account.createdAt)
+  };
+  if (typeof account.email === "string")
+    profile.email = account.email;
+  if (typeof account.displayName === "string")
+    profile.displayName = account.displayName;
+  if (typeof account.description === "string")
+    profile.description = account.description;
+  if (typeof account.lastUsedAt === "string")
+    profile.lastUsedAt = account.lastUsedAt;
+  return profile;
+}
+
+class ApiStore {
+  baseUrl;
+  apiKey;
+  transport = "api";
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+  }
+  async listProfiles(tool) {
+    const raw = await cloudRequest(this.baseUrl, this.apiKey, "/accounts", tool ? { tool } : undefined);
+    const accounts = Array.isArray(raw?.accounts) ? raw.accounts : [];
+    return accounts.map((account) => toProfile(account)).sort((a, b) => a.tool.localeCompare(b.tool) || a.name.localeCompare(b.name));
+  }
+  async findProfile(name, tool) {
+    if (tool) {
+      try {
+        const account = await cloudRequest(this.baseUrl, this.apiKey, `/accounts/${encodeURIComponent(tool)}/${encodeURIComponent(name)}`);
+        return account ? toProfile(account) : undefined;
+      } catch (err) {
+        if (isNotFound(err))
+          return;
+        throw err;
+      }
+    }
+    const matches = (await this.listProfiles()).filter((profile) => profile.name === name);
+    return matches.length === 1 ? matches[0] : undefined;
+  }
+  async currentProfile(tool) {
+    let current;
+    try {
+      const raw = await cloudRequest(this.baseUrl, this.apiKey, `/current/${encodeURIComponent(tool)}`);
+      current = raw && typeof raw === "object" ? raw : null;
+    } catch (err) {
+      if (isNotFound(err))
+        return;
+      throw err;
+    }
+    if (!current || typeof current.name !== "string")
+      return;
+    return this.findProfile(current.name, tool);
+  }
+  async listTools() {
+    const raw = await cloudRequest(this.baseUrl, this.apiKey, "/tools");
+    const tools = Array.isArray(raw?.tools) ? raw.tools : [];
+    const custom = [];
+    for (const item of tools) {
+      if (item === null || typeof item !== "object")
+        continue;
+      const record = item;
+      if (record.builtin !== false)
+        continue;
+      const parsed = toolDefSchema.safeParse(item);
+      if (!parsed.success) {
+        throw new Error(`invalid custom tool "${String(record.id)}" returned by accounts-serve: ` + parsed.error.issues.map((issue) => issue.message).join("; "));
+      }
+      custom.push(parsed.data);
+    }
+    const byId = new Map;
+    for (const tool of BUILTIN_TOOLS)
+      byId.set(tool.id, tool);
+    for (const tool of custom)
+      byId.set(tool.id, tool);
+    return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
+  }
+}
+function resolveStore(env = process.env, options = {}) {
+  const clientEnv = env;
+  const credential = resolveCredential(ACCOUNTS_APP, clientEnv, options.credentials);
+  if (credential === null) {
+    try {
+      resolveClientTransport(ACCOUNTS_APP, clientEnv, options.credentials ? { credentials: options.credentials } : {});
+    } catch (err) {
+      if (isNoAccountsCredentialConfigurationError(err))
+        return unconfiguredStore(env);
+      throw err;
+    }
+    return unconfiguredStore(env);
+  }
+  if (credential.tier === "pointer") {
+    throw new Error(`accounts: ${credential.source} names a secrets-vault item, and the local accounts API store resolves ` + "credentials synchronously, so it cannot complete the pointer per request. It is a deliberate " + "selection and is not resolved around. Use a literal tier instead \u2014 the Keychain item " + "hasna.credentials.accounts.api-key, ~/.hasna/accounts/config/credentials, or HASNA_ACCOUNTS_API_KEY.");
+  }
+  const resolution = resolveClientTransport(ACCOUNTS_APP, clientEnv, {
+    credentials: { ...options.credentials, apiKey: credential.apiKey }
+  });
+  return new ApiStore(resolution.baseUrl, credential.apiKey);
+}
+function isNoAccountsCredentialConfigurationError(error) {
+  if (typeof error !== "object" || error === null)
+    return false;
+  const candidate = error;
+  return candidate.name === "ClientTransportConfigurationError" && typeof candidate.message === "string" && candidate.message.includes("is not set and no API key could be resolved");
+}
+function unconfiguredStore(env) {
+  if (localRegistryAllowed(env)) {
+    announceAccountsLocalMode();
+    return new LocalStore;
+  }
+  announceAccountsRefusal();
+  return new NoRegistryStore;
+}
+function accountsLocalModeNotice() {
+  return `accounts: LOCAL mode (${LOCAL_STORAGE_OPT_IN_KEYS[0]}=1) \u2014 no Hasna Accounts credential resolved, so ` + "attribution reads the on-box JSON registry (~/.hasna/accounts/accounts.json) instead of accounts-serve. " + "To go hosted, put the fleet key in the Keychain item hasna.credentials.accounts.api-key, write " + "~/.hasna/accounts/config/credentials, or set HASNA_ACCOUNTS_API_KEY.";
+}
+function accountsRefusalNotice() {
+  return "accounts: no Hasna Accounts credential resolved (Keychain item hasna.credentials.accounts.api-key, " + "~/.hasna/accounts/config/credentials, HASNA_ACCOUNTS_API_KEY), so spend attribution is omitted. The " + `on-box registry (~/.hasna/accounts/accounts.json) is NOT read without ${LOCAL_STORAGE_OPT_IN_KEYS[0]}=1 \u2014 ` + "economy fails closed instead of attributing hosted spend from an on-box file.";
+}
+var accountsLocalNoticePrinted = false;
+function announceAccountsLocalMode() {
+  if (accountsLocalNoticePrinted)
+    return;
+  accountsLocalNoticePrinted = true;
+  process.stderr.write(`${accountsLocalModeNotice()}
+`);
+}
+function announceAccountsRefusal() {
+  if (accountsLocalNoticePrinted)
+    return;
+  accountsLocalNoticePrinted = true;
+  process.stderr.write(`${accountsRefusalNotice()}
+`);
+}
+
+// src/lib/accounts.ts
+var AGENT_ACCOUNT_TOOLS = {
+  claude: ["claude"],
+  takumi: ["takumi", "claude"],
+  codex: ["codex"],
+  gemini: ["gemini"],
+  opencode: ["opencode"],
+  cursor: ["cursor"],
+  pi: ["pi"],
+  hermes: ["hermes"]
+};
+function normalizeEmail(email) {
+  return (email ?? "").trim().toLowerCase();
+}
+function accountKey(tool, name, email) {
+  const normalizedEmail = normalizeEmail(email);
+  return `${tool}:${normalizedEmail || name}`;
+}
+function normalizeDir(value) {
+  return value.replace(/\/+$/, "");
+}
+function fromProfile(profile, source) {
+  return {
+    account_key: accountKey(profile.tool, profile.name, profile.email),
+    account_tool: profile.tool,
+    account_name: profile.name,
+    ...profile.email ? { account_email: normalizeEmail(profile.email) } : {},
+    account_source: source
+  };
+}
+function fromOverride(raw, agent) {
+  const value = raw.trim();
+  if (!value)
+    return null;
+  const candidateTool = AGENT_ACCOUNT_TOOLS[agent][0] ?? agent;
+  const [tool, name] = value.includes(":") ? value.split(":", 2) : [candidateTool, value];
+  if (!tool || !name)
+    return null;
+  const email = name.includes("@") ? normalizeEmail(name) : undefined;
+  return {
+    account_key: accountKey(tool, name, email),
+    account_tool: tool,
+    account_name: name,
+    ...email ? { account_email: email } : {},
+    account_source: "override"
+  };
+}
+function envOverride(agent, env) {
+  const agentPrefix = agent.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+  const raw = env[`ECONOMY_${agentPrefix}_ACCOUNT_KEY`] ?? env[`ECONOMY_${agentPrefix}_ACCOUNT`] ?? env["ECONOMY_ACCOUNT_KEY"] ?? env["ECONOMY_ACCOUNT"];
+  if (raw)
+    return fromOverride(raw, agent);
+  const tool = env[`ECONOMY_${agentPrefix}_ACCOUNT_TOOL`] ?? env["ECONOMY_ACCOUNT_TOOL"];
+  const name = env[`ECONOMY_${agentPrefix}_ACCOUNT_NAME`] ?? env["ECONOMY_ACCOUNT_NAME"];
+  if (!tool || !name)
+    return null;
+  const email = normalizeEmail(env[`ECONOMY_${agentPrefix}_ACCOUNT_EMAIL`] ?? env["ECONOMY_ACCOUNT_EMAIL"]);
+  return {
+    account_key: accountKey(tool, name, email),
+    account_tool: tool,
+    account_name: name,
+    ...email ? { account_email: email } : {},
+    account_source: "override"
+  };
+}
+async function profileForEnvDir(store, tool, env) {
+  const configuredDir = env[tool.envVar];
+  if (!configuredDir)
+    return null;
+  const normalized = normalizeDir(configuredDir);
+  return (await store.listProfiles(tool.id)).find((profile) => normalizeDir(profile.dir) === normalized) ?? null;
+}
+async function resolveAccountForAgent(agent, env = process.env, options = {}) {
+  const override = envOverride(agent, env);
+  if (override)
+    return override;
+  const store = resolveStore(env, options);
+  const tools = new Map((await store.listTools()).map((tool) => [tool.id, tool]));
+  for (const toolId of AGENT_ACCOUNT_TOOLS[agent]) {
+    const tool = tools.get(toolId);
+    if (!tool)
+      continue;
+    const envProfile = await profileForEnvDir(store, tool, env);
+    if (envProfile)
+      return fromProfile(envProfile, "env");
+    const appliedName = appliedProfileName(toolId);
+    if (appliedName) {
+      const applied = await store.findProfile(appliedName, toolId);
+      if (applied)
+        return fromProfile(applied, "applied");
+    }
+    const current = await store.currentProfile(toolId);
+    if (current)
+      return fromProfile(current, "current");
+  }
+  return null;
+}
+function withAccount(record, account) {
+  if (!account)
+    return record;
+  return {
+    ...record,
+    account_key: account.account_key,
+    account_tool: account.account_tool,
+    account_name: account.account_name,
+    account_email: account.account_email ?? "",
+    account_source: account.account_source
+  };
+}
+
+// src/ingest/claude.ts
+function autoDetectProject(cwd, projects) {
+  return projects.find((p) => cwd === p.path || cwd.startsWith(p.path + "/"));
+}
+var CLAUDE_PROJECTS_DIR = process.env["HASNA_ECONOMY_CLAUDE_PROJECTS_DIR"] ?? join2(homedir2(), ".claude", "projects");
+var TAKUMI_PROJECTS_DIR = process.env["HASNA_ECONOMY_TAKUMI_PROJECTS_DIR"] ?? join2(homedir2(), ".takumi", "projects");
+function dirNameToPath(dirName) {
+  return dirName.replace(/^-/, "/").replace(/-/g, "/").replace(/\/\//g, "/-");
+}
+function collectJsonlFiles(projectDir) {
+  const files = [];
+  function walk(dir) {
+    try {
+      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.isDirectory())
+          walk(join2(dir, entry.name));
+        else if (entry.name.endsWith(".jsonl"))
+          files.push(join2(dir, entry.name));
+      }
+    } catch {
+      collectionProblem("failed", "source_unreadable");
+    }
+  }
+  walk(projectDir);
+  return files;
+}
+async function ingestClaude(db, verbose = false, projectsDir = CLAUDE_PROJECTS_DIR) {
+  return ingestJsonlProjects(db, projectsDir, "claude", verbose);
+}
+async function ingestTakumi(db, verbose = false, projectsDir = TAKUMI_PROJECTS_DIR) {
+  return ingestJsonlProjects(db, projectsDir, "takumi", verbose);
+}
+async function ingestJsonlProjects(db, projectsDir, agentName, verbose = false) {
+  if (!existsSync2(projectsDir)) {
+    collectionProblem("missing", "source_missing");
+    if (verbose)
+      console.log(`${agentName} projects dir not found:`, projectsDir);
+    return { files: 0, requests: 0, sessions: 0 };
+  }
+  const machineId = getMachineId();
+  let totalFiles = 0;
+  let totalRequests = 0;
+  const touchedSessions = new Set;
+  const registeredProjects = db.prepare(`SELECT path, name FROM projects ORDER BY LENGTH(path) DESC`).all();
+  const account = await resolveAccountForAgent(agentName);
+  const ingestState = loadIngestState(db, agentName);
+  const projectDirs = readdirSync(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+  for (const projectDirEntry of projectDirs) {
+    const projectDirPath = join2(projectsDir, projectDirEntry.name);
+    const projectPath = dirNameToPath(projectDirEntry.name);
+    const jsonlFiles = collectJsonlFiles(projectDirPath);
+    for (const filePath of jsonlFiles) {
+      const stateKey = filePath.replace(projectsDir, "");
+      let fileMtime = "0";
+      try {
+        fileMtime = statSync(filePath).mtimeMs.toString();
+      } catch {
+        collectionProblem("failed", "source_unreadable");
+        continue;
+      }
+      const processed = ingestState.get(stateKey) ?? null;
+      if (processed === fileMtime) {
+        collectionUnchanged();
+        continue;
+      }
+      let lines;
+      try {
+        lines = readFileSync2(filePath, "utf-8").split(`
+`).filter((l) => l.trim());
+      } catch {
+        collectionProblem("failed", "source_unreadable");
+        continue;
+      }
+      const fileBasename = basename(filePath, ".jsonl");
+      const isUuid = /^[0-9a-f-]{36}$/.test(fileBasename);
+      let sessionId = isUuid ? fileBasename : fileBasename.replace(/^agent-/, "");
+      let sessionCwd = projectPath;
+      let fileInvalid = false;
+      for (const line of lines) {
+        let entry;
+        try {
+          entry = JSON.parse(line);
+        } catch {
+          fileInvalid = true;
+          collectionProblem("failed", "source_invalid");
+          continue;
+        }
+        if (entry.sessionId)
+          sessionId = entry.sessionId;
+        if (entry.cwd)
+          sessionCwd = entry.cwd;
+        if (entry.message?.role !== "assistant")
+          continue;
+        const usage = entry.message.usage;
+        if (!usage)
+          continue;
+        const model = entry.message.model;
+        if (!model)
+          continue;
+        const inputTokens = usage.input_tokens ?? 0;
+        const outputTokens = usage.output_tokens ?? 0;
+        const cacheWrite5mTokens = usage.cache_creation?.ephemeral_5m_input_tokens ?? usage.cache_creation_input_tokens ?? 0;
+        const cacheWrite1hTokens = usage.cache_creation?.ephemeral_1h_input_tokens ?? 0;
+        const cacheWriteTokens = cacheWrite5mTokens + cacheWrite1hTokens;
+        const cacheReadTokens = usage.cache_read_input_tokens ?? 0;
+        if (inputTokens + outputTokens + cacheWriteTokens + cacheReadTokens === 0)
+          continue;
+        const timestamp = sourceTime(entry.timestamp);
+        if (timestamp === null) {
+          fileInvalid = true;
+          collectionProblem("failed", "source_invalid");
+          continue;
+        }
+        const assessment = assessCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens, cacheWrite5mTokens, cacheWrite1hTokens);
+        let costUsd = assessment.usd === null ? 0 : applyClaudeModifiers(assessment.usd, model, usage, entry);
+        const serverToolUse = usage.server_tool_use;
+        if (assessment.usd !== null && serverToolUse?.web_search_requests) {
+          costUsd += serverToolUse.web_search_requests * 0.01;
+        }
+        const sourceRequestId = entry.requestId ?? entry.request_id ?? entry.message.id ?? entry.uuid ?? `${sessionId}-${timestamp}`;
+        const reqId = `${agentName}-${sourceRequestId}`;
+        upsertRequest(db, withAccount({
+          id: reqId,
+          agent: agentName,
+          session_id: sessionId,
+          model,
+          input_tokens: inputTokens,
+          output_tokens: outputTokens,
+          cache_read_tokens: cacheReadTokens,
+          cache_create_tokens: cacheWriteTokens,
+          cache_create_5m_tokens: cacheWrite5mTokens,
+          cache_create_1h_tokens: cacheWrite1hTokens,
+          cost_usd: costUsd,
+          cost_basis: assessment.usd === null ? "unknown" : "estimated",
+          duration_ms: 0,
+          timestamp,
+          source_request_id: sourceRequestId,
+          machine_id: machineId
+        }, account));
+        if (!touchedSessions.has(sessionId)) {
+          const existing = db.prepare(`SELECT id FROM sessions WHERE id = ?`).get(sessionId);
+          if (!existing) {
+            const effectiveCwd = sessionCwd || projectPath;
+            const detectedProject = autoDetectProject(effectiveCwd, registeredProjects);
+            const session = {
+              id: sessionId,
+              agent: agentName,
+              project_path: detectedProject ? detectedProject.path : effectiveCwd,
+              project_name: detectedProject ? detectedProject.name : "",
+              started_at: timestamp,
+              ended_at: null,
+              total_cost_usd: 0,
+              total_tokens: 0,
+              request_count: 0,
+              machine_id: machineId
+            };
+            upsertSession(db, withAccount(session, account));
+          }
+          touchedSessions.add(sessionId);
+        }
+        totalRequests++;
+      }
+      if (!fileInvalid)
+        setIngestState(db, agentName, stateKey, fileMtime);
+      totalFiles++;
+    }
+  }
+  for (const sessionId of touchedSessions) {
+    rollupSession(db, sessionId);
+  }
+  return { files: totalFiles, requests: totalRequests, sessions: touchedSessions.size };
+}
+function applyClaudeModifiers(costUsd, model, usage, entry) {
+  let multiplier = 1;
+  const speed = usage.speed ?? entry.message?.speed ?? entry.speed;
+  if (speed === "fast" && model.includes("opus-4-6")) {
+    multiplier *= 6;
+  }
+  const inferenceGeo = usage.inference_geo ?? entry.message?.inference_geo ?? entry.inference_geo;
+  if (inferenceGeo && ["us", "us-only", "us_only"].includes(inferenceGeo) && supportsClaudeDataResidencyPricing(model)) {
+    multiplier *= 1.1;
+  }
+  return costUsd * multiplier;
+}
+function supportsClaudeDataResidencyPricing(model) {
+  const normalized = normalizeModelName(model);
+  const match = normalized.match(/^claude-(opus|sonnet|haiku)-(\d+)(?:-(\d+))?(?:-|$)/);
+  if (!match)
+    return false;
+  const major = Number(match[2]);
+  const minor = match[3] ? Number(match[3]) : 0;
+  return major > 4 || major === 4 && minor >= 6;
+}
+
+// src/ingest/codex.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { createHash } from "crypto";
+import { homedir as homedir3 } from "os";
+import { join as join3, basename as basename2 } from "path";
+var DEFAULT_CODEX_DB_PATH = join3(homedir3(), ".codex", "state_5.sqlite");
+var DEFAULT_CODEX_CONFIG_PATH = join3(homedir3(), ".codex", "config.toml");
+var DEFAULT_CODEWITH_DB_PATH = join3(homedir3(), ".codewith", "state_5.sqlite");
+var DEFAULT_CODEWITH_CONFIG_PATH = join3(homedir3(), ".codewith", "config.toml");
+var CODEX_INGEST_VERSION = "rollout-events-v4";
+function codexDbPath() {
+  return process.env["HASNA_ECONOMY_CODEX_DB_PATH"] ?? DEFAULT_CODEX_DB_PATH;
+}
+function codexConfigPath() {
+  return process.env["HASNA_ECONOMY_CODEX_CONFIG_PATH"] ?? DEFAULT_CODEX_CONFIG_PATH;
+}
+function codewithDbPath() {
+  return process.env["HASNA_ECONOMY_CODEWITH_DB_PATH"] ?? DEFAULT_CODEWITH_DB_PATH;
+}
+function codewithConfigPath() {
+  return process.env["HASNA_ECONOMY_CODEWITH_CONFIG_PATH"] ?? DEFAULT_CODEWITH_CONFIG_PATH;
+}
+function codexSources() {
+  const explicitCodexPath = process.env["HASNA_ECONOMY_CODEX_DB_PATH"];
+  const explicitCodewithPath = process.env["HASNA_ECONOMY_CODEWITH_DB_PATH"];
+  const sources = [{
+    label: "Codex",
+    dbPath: codexDbPath(),
+    configPath: codexConfigPath(),
+    sessionPrefix: "codex",
+    stateSource: "codex"
+  }];
+  if (!explicitCodexPath || explicitCodewithPath) {
+    sources.push({
+      label: "Codewith",
+      dbPath: codewithDbPath(),
+      configPath: codewithConfigPath(),
+      sessionPrefix: "codex-codewith",
+      stateSource: "codex-codewith"
+    });
+  }
+  const seen = new Set;
+  return sources.filter((source) => {
+    if (seen.has(source.dbPath))
+      return false;
+    seen.add(source.dbPath);
+    return true;
+  });
+}
+function buildThreadQuery(codexDb) {
+  const cols = new Set(codexDb.prepare(`PRAGMA table_info(threads)`).all().map((c) => c.name));
+  const modelSelect = cols.has("model") ? "model" : "NULL AS model";
+  const rolloutSelect = cols.has("rollout_path") ? "rollout_path" : "NULL AS rollout_path";
+  const providerSelect = cols.has("model_provider") ? "model_provider" : "NULL AS model_provider";
+  return `
+    SELECT id, ${rolloutSelect}, cwd, created_at, updated_at, tokens_used, title,
+           ${providerSelect}, ${modelSelect}
+    FROM threads WHERE tokens_used > 0
+  `;
+}
+async function openCodexDb(dbPath) {
+  const { openThirdPartySqlite } = await import("./third-party-sqlite-5e85fxa2.js");
+  const db = openThirdPartySqlite(dbPath, { readonly: true });
+  try {
+    db.prepare("PRAGMA schema_version").get();
+    return db;
+  } catch (error) {
+    db.close();
+    throw error;
+  }
+}
+function validUsage(value) {
+  if (!value || typeof value !== "object")
+    return null;
+  const input = value;
+  for (const key of ["input_tokens", "cached_input_tokens", "output_tokens", "reasoning_output_tokens", "total_tokens"]) {
+    if (input[key] !== undefined && (!Number.isSafeInteger(input[key]) || input[key] < 0))
+      return null;
+  }
+  if ((input.cached_input_tokens ?? 0) > (input.input_tokens ?? 0))
+    return null;
+  return input;
+}
+function tokenTotal(usage) {
+  return (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0);
+}
+function parseCodexEvents(content) {
+  const events = [];
+  let model = "unknown";
+  let turn = null;
+  let previous = null;
+  let incomplete = false;
+  const occurrences = new Map;
+  for (const line of content.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      incomplete = true;
+      continue;
+    }
+    if (!entry || typeof entry !== "object")
+      continue;
+    const payload = entry.payload;
+    if (!payload || typeof payload !== "object")
+      continue;
+    if (entry.type === "turn_context") {
+      if (typeof payload.model === "string" && payload.model)
+        model = payload.model;
+      turn = typeof payload.turn_id === "string" ? payload.turn_id : null;
+      continue;
+    }
+    if (payload.type !== "token_count" || !payload.info)
+      continue;
+    const total = validUsage(payload.info.total_token_usage);
+    const last = validUsage(payload.info.last_token_usage);
+    if (total && previous && ["input_tokens", "output_tokens", "cached_input_tokens"].every((key) => total[key] === previous[key]))
+      continue;
+    const reset = total && previous && ((total.input_tokens ?? 0) < (previous.input_tokens ?? 0) || (total.output_tokens ?? 0) < (previous.output_tokens ?? 0));
+    let usage = last;
+    if (!usage && total && previous && !reset) {
+      usage = { input_tokens: (total.input_tokens ?? 0) - (previous.input_tokens ?? 0), output_tokens: (total.output_tokens ?? 0) - (previous.output_tokens ?? 0), cached_input_tokens: (total.cached_input_tokens ?? 0) - (previous.cached_input_tokens ?? 0) };
+      if (!validUsage(usage))
+        usage = null;
+    }
+    previous = total ?? previous;
+    if (!usage || tokenTotal(usage) <= 0 || reset && !last) {
+      incomplete = true;
+      continue;
+    }
+    const timestamp = typeof entry.timestamp === "string" && Number.isFinite(Date.parse(entry.timestamp)) ? new Date(entry.timestamp).toISOString() : null;
+    if (!timestamp) {
+      incomplete = true;
+      continue;
+    }
+    const eventModel = typeof payload.info.model === "string" ? payload.info.model : model;
+    const fingerprint = JSON.stringify([timestamp, eventModel, turn, payload.request_id ?? entry.id ?? null, usage]);
+    const ordinal = occurrences.get(fingerprint) ?? 0;
+    occurrences.set(fingerprint, ordinal + 1);
+    const identity = createHash("sha256").update(JSON.stringify([fingerprint, ordinal])).digest("hex");
+    events.push({ usage, timestamp, model: eventModel, identity });
+  }
+  return { events, incomplete };
+}
+async function ingestCodex(db, verbose = false) {
+  const machineId = getMachineId();
+  let ingested = 0;
+  let requests = 0;
+  const issues = [];
+  const account = await resolveAccountForAgent("codex");
+  for (const source of codexSources()) {
+    if (!existsSync3(source.dbPath)) {
+      if (source.stateSource === "codex")
+        collectionProblem("missing", "source_missing");
+      if (verbose)
+        console.log(`${source.label} DB not found:`, source.dbPath);
+      continue;
+    }
+    let codexDb = null;
+    try {
+      try {
+        codexDb = await openCodexDb(source.dbPath);
+      } catch {
+        collectionProblem("failed", "source_unreadable");
+        issues.push({ code: "source_unreadable" });
+        continue;
+      }
+      const threads = codexDb.prepare(buildThreadQuery(codexDb)).all();
+      for (const thread of threads) {
+        let rolloutStamp = "missing";
+        try {
+          const stat = statSync2(thread.rollout_path);
+          rolloutStamp = `${stat.size}:${stat.mtimeMs}`;
+        } catch {}
+        const stateValue = `${CODEX_INGEST_VERSION}:${thread.updated_at}:${thread.tokens_used}:${rolloutStamp}`;
+        const processed = getIngestState(db, source.stateSource, thread.id);
+        if (processed === stateValue) {
+          collectionUnchanged();
+          continue;
+        }
+        const projectPath = thread.cwd ?? "";
+        const projectName = projectPath ? basename2(projectPath) : "unknown";
+        const sessionId = `${source.sessionPrefix}-${thread.id}`;
+        const legacy = db.prepare("SELECT id FROM economy_effective_requests WHERE session_id = ? AND id = ?").get(sessionId, `${sessionId}-0`);
+        if (legacy) {
+          collectionProblem("unsupported", "legacy_aggregate_requires_migration");
+          issues.push({ code: "legacy_aggregate_requires_migration", session_id: sessionId });
+          continue;
+        }
+        let parsed;
+        try {
+          parsed = parseCodexEvents(readFileSync3(thread.rollout_path, "utf8"));
+        } catch {
+          collectionProblem("unsupported", "usage_events_unavailable");
+          issues.push({ code: "usage_events_unavailable", session_id: sessionId });
+          continue;
+        }
+        if (parsed.incomplete) {
+          collectionProblem("failed", "usage_events_incomplete");
+          issues.push({ code: "usage_events_incomplete", session_id: sessionId });
+        }
+        if (parsed.events.length === 0) {
+          collectionProblem("unsupported", "usage_events_unavailable");
+          issues.push({ code: "usage_events_unavailable", session_id: sessionId });
+          continue;
+        }
+        const startedAt = thread.created_at ? new Date(thread.created_at * 1000).toISOString() : parsed.events[0].timestamp;
+        const endedAt = thread.updated_at ? new Date(thread.updated_at * 1000).toISOString() : null;
+        upsertSession(db, withAccount({
+          id: sessionId,
+          agent: "codex",
+          project_path: projectPath,
+          project_name: projectName,
+          started_at: startedAt,
+          ended_at: endedAt,
+          total_cost_usd: 0,
+          total_tokens: 0,
+          request_count: 0,
+          machine_id: machineId
+        }, account));
+        const tokenEvents = parsed.events;
+        tokenEvents.forEach((event) => {
+          const usage = event.usage;
+          const cacheReadTokens = usage.cached_input_tokens ?? 0;
+          const inputTokens = (usage.input_tokens ?? 0) - cacheReadTokens;
+          const outputTokens = usage.output_tokens ?? 0;
+          const model = event.model;
+          const assessment = assessCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens, 0);
+          const timestamp = event.timestamp;
+          const requestId = `${sessionId}-event-${event.identity}`;
+          if (db.prepare("SELECT id FROM requests WHERE id = ?").get(requestId))
+            return;
+          upsertRequest(db, withAccount({
+            id: requestId,
+            agent: "codex",
+            session_id: sessionId,
+            model,
+            input_tokens: inputTokens,
+            output_tokens: outputTokens,
+            cache_read_tokens: cacheReadTokens,
+            cache_create_tokens: 0,
+            cost_usd: assessment.usd ?? 0,
+            cost_basis: assessment.usd === null ? "unknown" : "estimated",
+            duration_ms: 0,
+            timestamp,
+            source_request_id: requestId,
+            machine_id: machineId
+          }, account));
+          requests++;
+        });
+        rollupSession(db, sessionId);
+        if (!parsed.incomplete)
+          setIngestState(db, source.stateSource, thread.id, stateValue);
+        ingested++;
+        if (verbose)
+          console.log(`${source.label}: observed ${tokenEvents.length} usage events`);
+      }
+    } finally {
+      codexDb?.close();
+    }
+  }
+  return { sessions: ingested, requests, ...issues.length ? { issues } : {} };
+}
+
+// src/ingest/gemini.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync4, existsSync as existsSync4, statSync as statSync3 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4, basename as basename3 } from "path";
+var DEFAULT_GEMINI_TMP_DIR = join4(homedir4(), ".gemini", "tmp");
+var DEFAULT_GEMINI_HISTORY_DIR = join4(homedir4(), ".gemini", "history");
+function geminiTmpDir() {
+  return process.env["HASNA_ECONOMY_GEMINI_TMP_DIR"] ?? DEFAULT_GEMINI_TMP_DIR;
+}
+function geminiHistoryDir() {
+  return process.env["HASNA_ECONOMY_GEMINI_HISTORY_DIR"] ?? DEFAULT_GEMINI_HISTORY_DIR;
+}
+function numberField(...values) {
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value))
+      return value;
+  }
+  return 0;
+}
+function listProjectDirs(...roots) {
+  const dirs = new Set;
+  for (const root of roots) {
+    if (!existsSync4(root))
+      continue;
+    try {
+      for (const entry of readdirSync2(root, { withFileTypes: true })) {
+        if (entry.isDirectory())
+          dirs.add(join4(root, entry.name));
+      }
+    } catch {
+      collectionProblem("failed", "source_unreadable");
+    }
+  }
+  return [...dirs];
+}
+function projectRoot(projectDir, chatData) {
+  if (chatData.projectPath)
+    return chatData.projectPath;
+  if (chatData.project_path)
+    return chatData.project_path;
+  const rootFile = join4(projectDir, ".project_root");
+  try {
+    if (existsSync4(rootFile))
+      return readFileSync4(rootFile, "utf-8").trim();
+  } catch {
+    collectionProblem("failed", "source_unreadable");
+  }
+  return "";
+}
+async function ingestGemini(db, verbose) {
+  const tmpDir = geminiTmpDir();
+  const historyDir = geminiHistoryDir();
+  if (!existsSync4(tmpDir) && !existsSync4(historyDir)) {
+    collectionProblem("missing", "source_missing");
+    if (verbose)
+      console.log("Gemini tmp/history dirs not found:", tmpDir, historyDir);
+    return { sessions: 0, requests: 0 };
+  }
+  const machineId = getMachineId();
+  let totalSessions = 0;
+  let totalRequests = 0;
+  const touchedSessions = new Set;
+  const account = await resolveAccountForAgent("gemini");
+  const projectDirs = listProjectDirs(tmpDir, historyDir);
+  for (const projectDir of projectDirs) {
+    const chatsDir = join4(projectDir, "chats");
+    if (!existsSync4(chatsDir))
+      continue;
+    let chatFiles = [];
+    try {
+      chatFiles = readdirSync2(chatsDir).filter((f) => f.endsWith(".json")).map((f) => join4(chatsDir, f));
+    } catch {
+      collectionProblem("failed", "source_unreadable");
+      continue;
+    }
+    for (const filePath of chatFiles) {
+      const stateKey = filePath.replace(homedir4(), "~");
+      let fileMtime = "0";
+      try {
+        fileMtime = statSync3(filePath).mtimeMs.toString();
+      } catch {
+        collectionProblem("failed", "source_unreadable");
+        continue;
+      }
+      const processed = getIngestState(db, "gemini", stateKey);
+      if (processed === fileMtime) {
+        collectionUnchanged();
+        continue;
+      }
+      let chatData;
+      try {
+        chatData = JSON.parse(readFileSync4(filePath, "utf-8"));
+      } catch {
+        collectionProblem("failed", "source_unreadable");
+        continue;
+      }
+      const sessionId = chatData.sessionId ?? chatData.id ?? basename3(filePath, ".json");
+      if (!sessionId)
+        continue;
+      const startTime = sourceTime(chatData.startTime);
+      const projectPath = projectRoot(projectDir, chatData);
+      const projectName = projectPath ? basename3(projectPath) : "";
+      let fileInvalid = false;
+      for (const [index, message] of (chatData.messages ?? []).entries()) {
+        const usage = message.usage ?? message.usageMetadata ?? message.response?.usageMetadata;
+        if (!usage)
+          continue;
+        const model = message.model ?? message.response?.modelVersion ?? message.response?.model ?? chatData.model;
+        if (!model)
+          continue;
+        const toolUsePromptTokens = numberField(usage.toolUsePromptTokenCount, usage.tool_use_prompt_token_count);
+        const inputTotal = numberField(usage.inputTokens, usage.input_tokens, usage.promptTokenCount, usage.prompt_token_count) + toolUsePromptTokens;
+        const cacheReadTokens = numberField(usage.cachedInputTokens, usage.cache_read_tokens, usage.cachedContentTokenCount, usage.cached_content_token_count);
+        const inputTokens = Math.max(inputTotal - cacheReadTokens, 0);
+        const thoughtsTokens = numberField(usage.thoughtsTokenCount, usage.thoughts_token_count);
+        const outputTokens = numberField(usage.outputTokens, usage.output_tokens, usage.candidatesTokenCount, usage.candidates_token_count) + thoughtsTokens;
+        const totalTokens = numberField(usage.totalTokens, usage.total_tokens, usage.totalTokenCount, usage.total_token_count);
+        if (inputTokens + outputTokens + cacheReadTokens + totalTokens === 0)
+          continue;
+        const assessment = assessCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens, 0);
+        const sourceCost = message.costUsd ?? message.cost_usd;
+        const hasSourceCost = typeof sourceCost === "number" && Number.isFinite(sourceCost) && sourceCost >= 0;
+        const costUsd = hasSourceCost ? sourceCost : assessment.usd ?? 0;
+        const timestamp = sourceTime(message.timestamp);
+        if (timestamp === null) {
+          fileInvalid = true;
+          collectionProblem("failed", "source_invalid");
+          continue;
+        }
+        if (!touchedSessions.has(sessionId)) {
+          if (!db.get("SELECT id FROM sessions WHERE id=?", sessionId)) {
+            const session = {
+              id: sessionId,
+              agent: "gemini",
+              project_path: projectPath,
+              project_name: projectName,
+              started_at: startTime ?? timestamp,
+              ended_at: sourceTime(chatData.lastUpdated),
+              total_cost_usd: 0,
+              total_tokens: 0,
+              request_count: 0,
+              machine_id: machineId
+            };
+            upsertSession(db, withAccount(session, account));
+            totalSessions++;
+          }
+          touchedSessions.add(sessionId);
+        }
+        const requestId = `gemini-${sessionId}-${message.id ?? index}`;
+        upsertRequest(db, withAccount({
+          id: requestId,
+          agent: "gemini",
+          session_id: sessionId,
+          model,
+          input_tokens: inputTokens,
+          output_tokens: outputTokens,
+          cache_read_tokens: cacheReadTokens,
+          cache_create_tokens: 0,
+          cost_usd: costUsd,
+          cost_basis: !hasSourceCost && assessment.usd === null ? "unknown" : "estimated",
+          duration_ms: 0,
+          timestamp,
+          source_request_id: message.id ?? requestId,
+          machine_id: machineId
+        }, account));
+        totalRequests++;
+      }
+      if (!fileInvalid)
+        setIngestState(db, "gemini", stateKey, fileMtime);
+    }
+  }
+  for (const sessionId of touchedSessions) {
+    rollupSession(db, sessionId);
+  }
+  return { sessions: totalSessions, requests: totalRequests };
+}
+
+// src/ingest/opencode.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync as readdirSync3, statSync as statSync4 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join5 } from "path";
+var OPENCODE_STORAGE = join5(homedir5(), ".local", "share", "opencode", "storage");
+function walkJsonFiles(dir, acc = []) {
+  if (!existsSync5(dir))
+    return acc;
+  for (const entry of readdirSync3(dir, { withFileTypes: true })) {
+    const p = join5(dir, entry.name);
+    if (entry.isDirectory())
+      walkJsonFiles(p, acc);
+    else if (entry.name.endsWith(".json"))
+      acc.push(p);
+  }
+  return acc;
+}
+function parseSessionIdFromPath(filePath) {
+  const parts = filePath.split("/");
+  const msgIdx = parts.indexOf("message");
+  if (msgIdx >= 0 && parts[msgIdx + 1])
+    return parts[msgIdx + 1];
+  const sessionIdx = parts.indexOf("session");
+  if (sessionIdx >= 0 && parts[parts.length - 1]?.endsWith(".json")) {
+    return parts[parts.length - 1].replace(/\.json$/, "");
+  }
+  return null;
+}
+async function ingestOpenCode(db, verbose = false, sourceDir = OPENCODE_STORAGE) {
+  const messageDir = join5(sourceDir, "message");
+  if (!existsSync5(messageDir))
+    collectionProblem("missing", "source_missing");
+  const files = walkJsonFiles(messageDir);
+  let requests = 0;
+  const touched = new Set;
+  const machineId = getMachineId();
+  const account = await resolveAccountForAgent("opencode");
+  for (const file of files) {
+    const mtime = statSync4(file).mtimeMs;
+    const stateKey = file;
+    const prev = getIngestState(db, "opencode", stateKey);
+    if (prev && Number(prev) >= mtime) {
+      collectionUnchanged();
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync5(file, "utf-8"));
+    } catch {
+      collectionProblem("failed", "source_invalid");
+      continue;
+    }
+    if (parsed.role !== "assistant")
+      continue;
+    const usage = parsed.usage;
+    if (!usage)
+      continue;
+    const sessionId = parseSessionIdFromPath(file) ?? `opencode-${statSync4(file).ino}`;
+    const model = normalizeModelName(parsed.model ?? "unknown");
+    const input = usage.inputTokens ?? 0;
+    const output = usage.outputTokens ?? 0;
+    const cacheRead = usage.cacheReadTokens ?? 0;
+    const cacheWrite = usage.cacheWriteTokens ?? 0;
+    if (input + output + cacheRead + cacheWrite === 0 && !usage.cost)
+      continue;
+    const timestamp = sourceTimeMillis(parsed.time?.created);
+    if (timestamp === null) {
+      collectionProblem("failed", "source_invalid");
+      continue;
+    }
+    const sourceId = file.replace(sourceDir, "");
+    const reqId = `opencode-${sourceId}`;
+    const assessment = assessCostFromDb(db, model, input, output, cacheRead, cacheWrite, 0);
+    const hasSourceCost = typeof usage.cost === "number" && Number.isFinite(usage.cost) && usage.cost >= 0;
+    const costUsd = hasSourceCost ? usage.cost : assessment.usd ?? 0;
+    upsertRequest(db, withAccount({
+      id: reqId,
+      agent: "opencode",
+      session_id: sessionId,
+      model,
+      input_tokens: input,
+      output_tokens: output,
+      cache_read_tokens: cacheRead,
+      cache_create_tokens: cacheWrite,
+      cost_usd: costUsd,
+      cost_basis: !hasSourceCost && assessment.usd === null ? "unknown" : "estimated",
+      duration_ms: 0,
+      timestamp,
+      source_request_id: sourceId,
+      machine_id: machineId,
+      updated_at: timestamp
+    }, account));
+    requests++;
+    if (!touched.has(sessionId)) {
+      upsertSession(db, withAccount({
+        id: sessionId,
+        agent: "opencode",
+        project_path: "",
+        project_name: "",
+        started_at: timestamp,
+        ended_at: null,
+        total_cost_usd: 0,
+        total_tokens: 0,
+        request_count: 0,
+        machine_id: machineId,
+        updated_at: timestamp
+      }, account));
+      touched.add(sessionId);
+    }
+    setIngestState(db, "opencode", stateKey, String(mtime));
+    if (verbose)
+      console.log(`  opencode: ${reqId} ${model} $${costUsd.toFixed(4)}`);
+  }
+  for (const sid of touched)
+    rollupSession(db, sid);
+  return { files: files.length, requests, sessions: touched.size };
+}
+
+// src/ingest/quota-observation.ts
+function isoTime(value) {
+  const ms = typeof value === "number" ? value * 1000 : typeof value === "string" ? Date.parse(value) : NaN;
+  return Number.isFinite(ms) && ms >= 0 ? new Date(ms).toISOString() : null;
+}
+function quotaObservation(db, ctx, metric, value, unit, detail = {}) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+    return 0;
+  const machine_id = getMachineId();
+  const window_seconds = typeof detail.window_seconds === "number" && Number.isSafeInteger(detail.window_seconds) && detail.window_seconds > 0 ? detail.window_seconds : null;
+  upsertUsageSnapshot(db, {
+    ...ctx,
+    id: observationId({ ...ctx, machine_id, metric }),
+    date: ctx.observed_at.slice(0, 10),
+    metric,
+    value,
+    unit,
+    machine_id,
+    source_timestamp: null,
+    window_start: null,
+    window_end: null,
+    reset_at: isoTime(detail.reset_at),
+    window_seconds,
+    value_kind: detail.value_kind ?? "gauge",
+    updated_at: ctx.observed_at
+  });
+  return 1;
+}
+function quotaSubscription(db, ctx, plan) {
+  upsertSubscription(db, {
+    id: subscriptionId(ctx),
+    agent: ctx.agent,
+    provider: ctx.provider,
+    account_key: ctx.account_key,
+    plan,
+    monthly_fee_usd: 0,
+    included_usage_usd: 0,
+    fee_basis: "unknown",
+    included_basis: "unknown",
+    observed_station: getMachineId(),
+    observed_at: ctx.observed_at,
+    billing_cycle_start: null,
+    reset_policy: "unknown",
+    active: 1,
+    created_at: ctx.observed_at,
+    updated_at: ctx.observed_at
+  }, "quota_observation");
+}
+
+// src/ingest/cursor.ts
+function getCursorSessionToken() {
+  return process.env["CURSOR_SESSION_TOKEN"] ?? process.env["CURSOR_API_TOKEN"] ?? null;
+}
+async function cursorFetch(path, token) {
+  try {
+    const res = await fetch(`https://cursor.com${path}`, {
+      headers: {
+        Cookie: `WorkosCursorSessionToken=${token}`,
+        Accept: "application/json"
+      },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) {
+      collectionProblem("failed", res.status === 401 || res.status === 403 ? "provider_auth_refused" : "provider_refused");
+      return null;
+    }
+    return await res.json();
+  } catch {
+    collectionProblem("failed", "provider_unavailable");
+    return null;
+  }
+}
+async function ingestCursor(db, verbose = false) {
+  const token = getCursorSessionToken();
+  if (!token) {
+    collectionProblem("missing", "provider_credential_unavailable");
+    if (verbose)
+      console.log("  cursor: skipped \u2014 set CURSOR_SESSION_TOKEN");
+    return { requests: 0, snapshots: 0 };
+  }
+  const account = await resolveAccountForAgent("cursor");
+  if (!account?.account_key) {
+    collectionProblem("unsupported", "account_identity_unavailable");
+    return { requests: 0, snapshots: 0 };
+  }
+  const ctx = { provider: "cursor", agent: "cursor", account_key: account.account_key, observed_at: new Date().toISOString() };
+  let snapshots = 0;
+  const usage = await cursorFetch("/api/usage", token);
+  snapshots += quotaObservation(db, ctx, "premium_requests_used", usage?.premiumRequests, "count", { value_kind: "unknown" });
+  snapshots += quotaObservation(db, ctx, "premium_requests_limit", usage?.maxPremiumRequests, "count", { value_kind: "unknown" });
+  const summary = await cursorFetch("/api/usage-summary", token);
+  snapshots += quotaObservation(db, ctx, "individual_spend", summary?.individualUsage?.spend, "source_units", { value_kind: "unknown" });
+  snapshots += quotaObservation(db, ctx, "individual_included_spend", summary?.individualUsage?.includedSpend, "source_units", { value_kind: "unknown" });
+  if (summary?.teamUsage?.spend !== undefined)
+    collectionProblem("unsupported", "team_usage_attribution_unavailable");
+  if (verbose)
+    console.log(`  cursor: ${snapshots} observations`);
+  return { requests: 0, snapshots };
+}
+
+// src/ingest/pi.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6, readdirSync as readdirSync4, statSync as statSync5 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join6 } from "path";
+var PI_SESSION_DIR = process.env["PI_CODING_AGENT_SESSION_DIR"] ?? join6(homedir6(), ".pi", "agent", "sessions");
+function walkSessions(dir, acc = []) {
+  if (!existsSync6(dir))
+    return acc;
+  for (const entry of readdirSync4(dir, { withFileTypes: true })) {
+    const p = join6(dir, entry.name);
+    if (entry.isDirectory())
+      walkSessions(p, acc);
+    else if (entry.name.endsWith(".json"))
+      acc.push(p);
+  }
+  return acc;
+}
+async function ingestPi(db, verbose = false, sourceDir = PI_SESSION_DIR) {
+  if (!existsSync6(sourceDir))
+    collectionProblem("missing", "source_missing");
+  const files = walkSessions(sourceDir);
+  let requests = 0;
+  const touched = new Set;
+  const machineId = getMachineId();
+  const account = await resolveAccountForAgent("pi");
+  for (const file of files) {
+    const mtime = statSync5(file).mtimeMs;
+    const prev = getIngestState(db, "pi", file);
+    if (prev && Number(prev) >= mtime) {
+      collectionUnchanged();
+      continue;
+    }
+    let data;
+    try {
+      data = JSON.parse(readFileSync6(file, "utf-8"));
+    } catch {
+      collectionProblem("failed", "source_invalid");
+      continue;
+    }
+    const sessionId = data.id ?? file.replace(/\.json$/, "").split("/").pop() ?? `pi-${statSync5(file).ino}`;
+    const turns = data.turns ?? data.messages?.filter((m) => m.role === "assistant") ?? [];
+    let firstEvent = null, fileInvalid = false;
+    for (let i = 0;i < turns.length; i++) {
+      const turn = turns[i];
+      const usage = turn.usage;
+      if (!usage)
+        continue;
+      const input = usage.input ?? 0;
+      const output = usage.output ?? 0;
+      if (input + output === 0 && !usage.cost)
+        continue;
+      const model = turn.model ?? turn.provider ?? "unknown";
+      const timestamp = sourceTime(turn.timestamp);
+      if (timestamp === null) {
+        fileInvalid = true;
+        collectionProblem("failed", "source_invalid");
+        continue;
+      }
+      if (firstEvent === null || timestamp < firstEvent)
+        firstEvent = timestamp;
+      const reqId = `pi-${sessionId}-${i}`;
+      upsertRequest(db, withAccount({
+        id: reqId,
+        agent: "pi",
+        session_id: sessionId,
+        model,
+        input_tokens: input,
+        output_tokens: output,
+        cache_read_tokens: usage.cacheRead ?? 0,
+        cache_create_tokens: usage.cacheWrite ?? 0,
+        cost_usd: usage.cost ?? 0,
+        cost_basis: usage.cost === undefined ? "unknown" : "estimated",
+        duration_ms: 0,
+        timestamp,
+        source_request_id: `${sessionId}-${i}`,
+        machine_id: machineId,
+        updated_at: timestamp
+      }, account));
+      requests++;
+    }
+    if (firstEvent !== null) {
+      upsertSession(db, withAccount({
+        id: sessionId,
+        agent: "pi",
+        project_path: "",
+        project_name: "",
+        started_at: firstEvent,
+        ended_at: null,
+        total_cost_usd: 0,
+        total_tokens: 0,
+        request_count: 0,
+        machine_id: machineId,
+        updated_at: firstEvent
+      }, account));
+      touched.add(sessionId);
+    }
+    if (!fileInvalid)
+      setIngestState(db, "pi", file, String(mtime));
+    if (verbose)
+      console.log(`  pi: ${sessionId} (${turns.length} turns)`);
+  }
+  for (const sid of touched)
+    rollupSession(db, sid);
+  return { files: files.length, requests, sessions: touched.size };
+}
+
+// src/ingest/hermes.ts
+import { existsSync as existsSync7, statSync as statSync6 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join7 } from "path";
+var HERMES_DB = join7(homedir7(), ".hermes", "state.db");
+async function ingestHermes(db, verbose = false, sourcePath = HERMES_DB) {
+  if (!existsSync7(sourcePath)) {
+    collectionProblem("missing", "source_missing");
+    return { sessions: 0, requests: 0 };
+  }
+  const { openThirdPartySqlite } = await import("./third-party-sqlite-5e85fxa2.js");
+  const hermes = openThirdPartySqlite(sourcePath, { readonly: true });
+  const rows = hermes.prepare(`
+    SELECT id, source, model, started_at, ended_at,
+           input_tokens, output_tokens, cache_read_tokens, cache_write_tokens,
+           reasoning_tokens, estimated_cost_usd, actual_cost_usd, billing_mode, parent_session_id
+    FROM sessions
+    ORDER BY started_at DESC
+  `).all();
+  const stateKey = "state.db";
+  const mtime = statSyncSafe(sourcePath);
+  const prev = getIngestState(db, "hermes", stateKey);
+  if (prev && Number(prev) >= mtime && rows.length === 0) {
+    hermes.close();
+    return { sessions: 0, requests: 0 };
+  }
+  const machineId = getMachineId();
+  let sessions = 0;
+  const account = await resolveAccountForAgent("hermes");
+  for (const row of rows) {
+    const sessionId = `hermes-${row.id}`;
+    if (db.get("SELECT id FROM economy_effective_requests WHERE session_id=? AND id=?", sessionId, `${sessionId}-rollup`)) {
+      collectionProblem("unsupported", "legacy_aggregate_requires_migration");
+      continue;
+    }
+    const startedAt = new Date(row.started_at * 1000).toISOString();
+    const endedAt = row.ended_at ? new Date(row.ended_at * 1000).toISOString() : null;
+    const cost = row.actual_cost_usd ?? row.estimated_cost_usd ?? 0;
+    const tokens = row.input_tokens + row.output_tokens + row.cache_read_tokens + row.cache_write_tokens + row.reasoning_tokens;
+    upsertSession(db, withAccount({
+      id: sessionId,
+      agent: "hermes",
+      project_path: row.source ?? "",
+      project_name: row.source ?? "",
+      started_at: startedAt,
+      ended_at: endedAt,
+      total_cost_usd: cost,
+      total_tokens: tokens,
+      request_count: 0,
+      machine_id: machineId,
+      updated_at: endedAt ?? startedAt
+    }, account));
+    collectionProblem("unsupported", "usage_events_unavailable");
+    sessions++;
+    if (verbose)
+      console.log(`  hermes: ${sessionId} $${cost.toFixed(4)}`);
+  }
+  setIngestState(db, "hermes", stateKey, String(mtime));
+  hermes.close();
+  return { sessions, requests: 0 };
+}
+function statSyncSafe(path) {
+  try {
+    return statSync6(path).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+// src/ingest/loops.ts
+import { existsSync as existsSync8 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join8 } from "path";
+import { homedir as pathsResolverHomedir } from "os";
+import { join as pathsResolverJoin } from "path";
+var PATHS_RESOLVER_KIND_ENV = {
+  config: "HASNA_CONFIG_HOME",
+  data: "HASNA_DATA_HOME",
+  state: "HASNA_STATE_HOME",
+  cache: "HASNA_CACHE_HOME"
+};
+var PATHS_RESOLVER_APP_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function pathsResolverAssertApp(app) {
+  if (typeof app !== "string" || app.length === 0) {
+    throw new TypeError("paths: app must be a non-empty string");
+  }
+  if (!PATHS_RESOLVER_APP_SLUG_RE.test(app)) {
+    throw new TypeError(`paths: invalid app slug "${app}" \u2014 expected lowercase kebab-case ([a-z0-9]+(-[a-z0-9]+)*)`);
+  }
+}
+function pathsResolverAssertKind(kind) {
+  if (!Object.keys(PATHS_RESOLVER_KIND_ENV).includes(kind)) {
+    throw new TypeError(`paths: invalid path kind "${kind}" \u2014 expected one of ${Object.keys(PATHS_RESOLVER_KIND_ENV).join(", ")}`);
+  }
+}
+function pathsResolverBaseDir(kind, options) {
+  pathsResolverAssertKind(kind);
+  const env = options.env ?? process.env;
+  const override = env[PATHS_RESOLVER_KIND_ENV[kind]];
+  if (typeof override === "string" && override.length > 0)
+    return override;
+  const home = options.home ?? pathsResolverHomedir();
+  const platform = options.platform ?? process.platform;
+  if (platform === "darwin") {
+    switch (kind) {
+      case "config":
+      case "data":
+        return pathsResolverJoin(home, "Library", "Application Support", "Hasna");
+      case "cache":
+        return pathsResolverJoin(home, "Library", "Caches", "Hasna");
+      case "state":
+        return pathsResolverJoin(home, "Library", "Logs", "Hasna");
+    }
+  }
+  switch (kind) {
+    case "config":
+      return pathsResolverJoin(home, ".config", "hasna");
+    case "data":
+      return pathsResolverJoin(home, ".local", "share", "hasna");
+    case "state":
+      return pathsResolverJoin(home, ".local", "state", "hasna");
+    case "cache":
+      return pathsResolverJoin(home, ".cache", "hasna");
+  }
+}
+function pathsResolverResolve(kind, options) {
+  pathsResolverAssertApp(options.app);
+  const appSegment = options.internal === true ? pathsResolverJoin("internal", options.app) : options.app;
+  return pathsResolverJoin(pathsResolverBaseDir(kind, options), appSegment);
+}
+function dataDir(options) {
+  return pathsResolverResolve("data", options);
+}
+var LOOPS_INGEST_VERSION = "goal-runs-orchestration-v1";
+function defaultLoopsDbPath() {
+  const resolved = dataDir({
+    app: "loops",
+    home: process.env["HOME"] || process.env["USERPROFILE"] || undefined
+  });
+  const legacy = join8(process.env["HOME"] || process.env["USERPROFILE"] || homedir8(), ".hasna", "loops", "loops.db");
+  return existsSync8(join8(resolved, "loops.db")) ? join8(resolved, "loops.db") : legacy;
+}
+function loopsDbPath() {
+  return process.env["HASNA_ECONOMY_LOOPS_DB_PATH"] ?? defaultLoopsDbPath();
+}
+function loopsModel() {
+  return process.env["HASNA_ECONOMY_LOOPS_MODEL"] ?? process.env["ECONOMY_LOOPS_MODEL"] ?? "gpt-5.3-codex";
+}
+async function openLoopsDb(dbPath, verbose) {
+  const { openThirdPartySqlite } = await import("./third-party-sqlite-5e85fxa2.js");
+  let lastError;
+  for (const readonly of [true, false]) {
+    let loopsDb = null;
+    try {
+      loopsDb = openThirdPartySqlite(dbPath, { readonly });
+      loopsDb.prepare("PRAGMA schema_version").get();
+      return loopsDb;
+    } catch (error) {
+      lastError = error;
+      loopsDb?.close();
+    }
+  }
+  if (verbose) {
+    const message = lastError instanceof Error ? lastError.message : String(lastError);
+    console.log("OpenLoops DB unreadable:", dbPath, message);
+  }
+  return null;
+}
+function slug(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "unknown";
+}
+function parseTarget(raw) {
+  if (!raw)
+    return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function stringValue(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function accountFields(row) {
+  const target = parseTarget(row.target_json);
+  const tool = stringValue(row.account_tool) || stringValue(target["account_tool"]) || stringValue(target["tool"]) || stringValue(target["agent"]);
+  const profile = stringValue(row.account_profile) || stringValue(target["account_profile"]) || stringValue(target["profile"]) || stringValue(target["account"]);
+  if (!tool || !profile) {
+    return { account_key: "", account_tool: tool, account_name: profile, account_source: "" };
+  }
+  return {
+    account_key: `${tool}:${profile}`,
+    account_tool: tool,
+    account_name: profile,
+    account_source: "loops"
+  };
+}
+function readLoopGoalRuns(loopsDb) {
+  return loopsDb.prepare(`
+    SELECT
+      gr.id as goal_run_id,
+      gr.goal_id as goal_id,
+      COALESCE(gr.loop_id, g.loop_id, lr.loop_id) as loop_id,
+      COALESCE(gr.loop_run_id, g.loop_run_id, lr.id) as loop_run_id,
+      COALESCE(l.name, lr.loop_name, 'unknown-loop') as loop_name,
+      l.labels_json as labels_json,
+      l.target_json as target_json,
+      g.objective as objective,
+      gr.phase as phase,
+      gr.status as status,
+      COALESCE(gr.tokens_used, 0) as tokens_used,
+      gr.created_at as created_at,
+      gr.updated_at as updated_at,
+      lr.started_at as loop_run_started_at,
+      wsr.account_profile as account_profile,
+      wsr.account_tool as account_tool
+    FROM goal_runs gr
+    LEFT JOIN goals g ON g.id = gr.goal_id
+    LEFT JOIN loop_runs lr ON lr.id = COALESCE(gr.loop_run_id, g.loop_run_id)
+    LEFT JOIN loops l ON l.id = COALESCE(gr.loop_id, g.loop_id, lr.loop_id)
+    LEFT JOIN (
+      SELECT goal_run_id, MIN(account_profile) as account_profile, MIN(account_tool) as account_tool
+      FROM workflow_step_runs
+      WHERE goal_run_id IS NOT NULL
+      GROUP BY goal_run_id
+    ) wsr ON wsr.goal_run_id = gr.id
+    WHERE COALESCE(gr.tokens_used, 0) > 0
+    ORDER BY gr.created_at ASC, gr.id ASC
+  `).all();
+}
+async function ingestLoops(db, verbose = false) {
+  const dbPath = loopsDbPath();
+  if (!existsSync8(dbPath)) {
+    collectionProblem("missing", "source_missing");
+    if (verbose)
+      console.log("OpenLoops DB not found:", dbPath);
+    return { sessions: 0, requests: 0 };
+  }
+  const model = loopsModel();
+  const machineId = getMachineId();
+  let loopsDb = null;
+  let requests = 0;
+  const sessions = new Set;
+  try {
+    loopsDb = await openLoopsDb(dbPath, verbose);
+    if (!loopsDb) {
+      collectionProblem("failed", "source_unreadable");
+      return { sessions: 0, requests: 0 };
+    }
+    for (const row of readLoopGoalRuns(loopsDb)) {
+      const loopName = row.loop_name || "unknown-loop";
+      const costCenterId = `loop:${slug(loopName)}`;
+      const sessionId = `loops-${row.loop_run_id ?? row.loop_id ?? row.goal_id}`;
+      const requestId = `loops-${row.goal_run_id}`;
+      const timestamp = row.updated_at ?? row.created_at ?? row.loop_run_started_at ?? new Date().toISOString();
+      const stateValue = `${LOOPS_INGEST_VERSION}:${row.updated_at ?? ""}:${row.tokens_used}:${model}:${costCenterId}`;
+      if (getIngestState(db, "loops", row.goal_run_id) === stateValue)
+        continue;
+      upsertCostCenter(db, {
+        id: costCenterId,
+        kind: "loop",
+        name: loopName,
+        repo_path: null,
+        labels_json: row.labels_json ?? "{}",
+        created_at: row.created_at ?? timestamp
+      });
+      const account = accountFields(row);
+      upsertSession(db, {
+        id: sessionId,
+        agent: "loop",
+        project_path: "",
+        project_name: loopName,
+        started_at: row.loop_run_started_at ?? row.created_at ?? timestamp,
+        ended_at: row.updated_at ?? null,
+        total_cost_usd: 0,
+        total_tokens: 0,
+        request_count: 0,
+        machine_id: machineId,
+        cost_center_id: costCenterId,
+        attribution_tag: "loops-orchestration",
+        ...account
+      });
+      const inputTokens = row.tokens_used;
+      const outputTokens = 0;
+      const assessment = assessCostFromDb(db, model, inputTokens, outputTokens);
+      upsertRequest(db, {
+        id: requestId,
+        agent: "loop",
+        session_id: sessionId,
+        model,
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        cache_read_tokens: 0,
+        cache_create_tokens: 0,
+        cost_usd: assessment.usd ?? 0,
+        cost_basis: assessment.usd === null ? "unknown" : "estimated",
+        duration_ms: 0,
+        timestamp,
+        source_request_id: requestId,
+        machine_id: machineId,
+        cost_center_id: costCenterId,
+        attribution_tag: "loops-orchestration",
+        ...account
+      });
+      sessions.add(sessionId);
+      requests++;
+      setIngestState(db, "loops", row.goal_run_id, stateValue);
+      if (verbose)
+        console.log(`OpenLoops ${loopName}: ${row.tokens_used} orchestration tokens`);
+    }
+  } catch {
+    collectionProblem("failed", "source_unreadable");
+    return { sessions: 0, requests: 0 };
+  } finally {
+    loopsDb?.close();
+  }
+  for (const sessionId of sessions)
+    rollupSession(db, sessionId);
+  return { sessions: sessions.size, requests };
+}
+
+// src/ingest/claude-quota.ts
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+
+// src/lib/paths.ts
+import { homedir as homedir9 } from "os";
+import { join as join9 } from "path";
+function getHomeDir() {
+  return process.env["USERPROFILE"] ?? process.env["HOME"] ?? homedir9();
+}
+function agentPaths() {
+  const home = getHomeDir();
+  return {
+    claudeProjects: join9(home, ".claude", "projects"),
+    claudeCredentials: join9(home, ".claude", ".credentials.json"),
+    takumiProjects: join9(home, ".takumi", "projects"),
+    codexDir: join9(home, ".codex"),
+    codexDb: join9(home, ".codex", "state_5.sqlite"),
+    codexAuth: join9(home, ".codex", "auth.json"),
+    codexConfig: join9(home, ".codex", "config.toml"),
+    geminiTmp: join9(home, ".gemini", "tmp"),
+    geminiHistory: join9(home, ".gemini", "history"),
+    opencodeMessages: join9(home, ".local", "share", "opencode", "storage", "message"),
+    piSessions: join9(home, ".pi", "agent", "sessions"),
+    hermesDir: join9(home, ".hermes"),
+    hermesDb: join9(home, ".hermes", "state.db")
+  };
+}
+
+// src/ingest/claude-quota.ts
+var USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+var OAUTH_BETA = "oauth-2025-04-20";
+function readClaudeToken() {
+  const fromEnv = process.env["CLAUDE_OAUTH_TOKEN"] ?? process.env["ANTHROPIC_OAUTH_TOKEN"];
+  if (fromEnv)
+    return { token: fromEnv };
+  const CREDENTIALS_PATH = agentPaths().claudeCredentials;
+  if (!existsSync9(CREDENTIALS_PATH))
+    return null;
+  try {
+    const creds = JSON.parse(readFileSync7(CREDENTIALS_PATH, "utf-8"));
+    const oauth = creds.claudeAiOauth;
+    if (!oauth?.accessToken)
+      return null;
+    return {
+      token: oauth.accessToken,
+      subscriptionType: oauth.subscriptionType,
+      rateLimitTier: oauth.rateLimitTier
+    };
+  } catch {
+    collectionProblem("failed", "provider_credential_unreadable");
+    return null;
+  }
+}
+async function fetchClaudeOAuthUsage(token) {
+  try {
+    const res = await fetch(USAGE_URL, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "anthropic-beta": OAUTH_BETA,
+        Accept: "application/json"
+      },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) {
+      collectionProblem("failed", res.status === 401 || res.status === 403 ? "provider_auth_refused" : "provider_refused");
+      return null;
+    }
+    return await res.json();
+  } catch {
+    collectionProblem("failed", "provider_unavailable");
+    return null;
+  }
+}
+async function ingestClaudeQuota(db, verbose = false) {
+  const auth = readClaudeToken();
+  if (!auth) {
+    collectionProblem("missing", "provider_credential_unavailable");
+    if (verbose)
+      console.log("  claude quota: skipped \u2014 no OAuth token (~/.claude/.credentials.json or CLAUDE_OAUTH_TOKEN)");
+    return { snapshots: 0 };
+  }
+  const account = await resolveAccountForAgent("claude");
+  if (!account?.account_key) {
+    collectionProblem("unsupported", "account_identity_unavailable");
+    return { snapshots: 0 };
+  }
+  const usage = await fetchClaudeOAuthUsage(auth.token);
+  if (!usage)
+    return { snapshots: 0 };
+  const ctx = { provider: "anthropic", agent: "claude", account_key: account.account_key, observed_at: new Date().toISOString() };
+  let snapshots = 0;
+  for (const name of ["five_hour", "seven_day", "seven_day_sonnet", "seven_day_opus"]) {
+    const window = usage[name];
+    if (window)
+      snapshots += quotaObservation(db, ctx, `${name}_utilization`, window.utilization, "percent", { reset_at: window.resets_at });
+  }
+  for (const field of ["spend", "limit", "used_credits", "monthly_limit"]) {
+    snapshots += quotaObservation(db, ctx, `extra_usage_${field}`, usage.extra_usage?.[field], "source_units", { value_kind: "unknown" });
+  }
+  quotaSubscription(db, ctx, auth.rateLimitTier ?? auth.subscriptionType ?? "unknown");
+  if (verbose)
+    console.log(`  claude quota: ${snapshots} observations`);
+  return { snapshots };
+}
+
+// src/ingest/codex-quota.ts
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
+var WHAM_USAGE_URL = process.env["CODEX_USAGE_URL"] ?? "https://chatgpt.com/backend-api/wham/usage";
+function readCodexAuth() {
+  const fromEnv = process.env["CODEX_OAUTH_TOKEN"];
+  if (fromEnv)
+    return { token: fromEnv, authMode: "chatgpt" };
+  const authPath = agentPaths().codexAuth;
+  if (!existsSync10(authPath))
+    return null;
+  try {
+    const auth = JSON.parse(readFileSync8(authPath, "utf-8"));
+    const token = auth.tokens?.access_token;
+    if (!token)
+      return null;
+    return {
+      token,
+      accountId: auth.tokens?.account_id,
+      authMode: auth.auth_mode ?? "chatgpt"
+    };
+  } catch {
+    collectionProblem("failed", "provider_credential_unreadable");
+    return null;
+  }
+}
+async function fetchCodexUsage(token, accountId) {
+  try {
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json",
+      "User-Agent": "economy-cli"
+    };
+    if (accountId)
+      headers["ChatGPT-Account-Id"] = accountId;
+    const res = await fetch(WHAM_USAGE_URL, {
+      headers,
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) {
+      collectionProblem("failed", res.status === 401 || res.status === 403 ? "provider_auth_refused" : "provider_refused");
+      return null;
+    }
+    return await res.json();
+  } catch {
+    collectionProblem("failed", "provider_unavailable");
+    return null;
+  }
+}
+async function ingestCodexQuota(db, verbose = false) {
+  const auth = readCodexAuth();
+  if (!auth) {
+    collectionProblem("missing", "provider_credential_unavailable");
+    if (verbose)
+      console.log("  codex quota: skipped \u2014 no ~/.codex/auth.json or CODEX_OAUTH_TOKEN");
+    return { snapshots: 0 };
+  }
+  if (auth.authMode === "api_key" || auth.authMode === "api") {
+    collectionProblem("unsupported", "subscription_quota_not_applicable");
+    if (verbose)
+      console.log("  codex quota: skipped \u2014 API key mode (no subscription quota)");
+    return { snapshots: 0 };
+  }
+  const account = await resolveAccountForAgent("codex");
+  const account_key = account?.account_key ?? (auth.accountId ? `openai:${auth.accountId}` : "");
+  if (!account_key) {
+    collectionProblem("unsupported", "account_identity_unavailable");
+    return { snapshots: 0 };
+  }
+  const usage = await fetchCodexUsage(auth.token, auth.accountId);
+  if (!usage)
+    return { snapshots: 0 };
+  const ctx = { provider: "openai", agent: "codex", account_key, observed_at: new Date().toISOString() };
+  let snapshots = 0;
+  for (const [name, window] of Object.entries({ primary_window: usage.rate_limit?.primary_window, secondary_window: usage.rate_limit?.secondary_window })) {
+    if (window)
+      snapshots += quotaObservation(db, ctx, `${name}_utilization`, window.used_percent, "percent", { reset_at: window.reset_at, window_seconds: window.limit_window_seconds });
+  }
+  snapshots += quotaObservation(db, ctx, "credits_balance", usage.credits?.balance, "credits");
+  quotaSubscription(db, ctx, usage.plan_type ?? "unknown");
+  if (verbose)
+    console.log(`  codex quota: ${snapshots} observations`);
+  return { snapshots };
+}
+
+// src/lib/sync-all.ts
+var loopsRefusalPrinted = false;
+function announceLoopsRefusal() {
+  if (loopsRefusalPrinted)
+    return;
+  loopsRefusalPrinted = true;
+  process.stderr.write("economy: loops ingest skipped \u2014 it reads the loops app's on-box SQLite " + "(~/.hasna/loops/loops.db), which a hosted economy client never treats as fleet data. " + "Set HASNA_ECONOMY_LOCAL=1 to run economy on the on-box store (where the read is allowed), " + `or wait for the hosted loops read (PORT-TO-API).
+`);
+}
+async function syncAll(db, opts = {}) {
+  const anySpecific = Boolean(opts.claude || opts.takumi || opts.codex || opts.gemini || opts.opencode || opts.cursor || opts.pi || opts.hermes || opts.loops);
+  const all = !anySpecific;
+  const result = { deduped: 0 };
+  const collections = [];
+  async function collect(key, run, empty) {
+    const item = await collectWithOutcome(key, run, empty);
+    result[key] = item.result;
+    collections.push(item.outcome);
+    const machine_id = getMachineId();
+    const source = key;
+    const event = db.prepare("SELECT MAX(timestamp) AS latest FROM economy_effective_requests WHERE agent = ?").get(key);
+    upsertScanReceipt(db, { ...item.outcome, machine_id, id: scanReceiptId({ machine_id, source, attempted_at: item.outcome.attempted_at }), latest_event_at: event?.latest ?? null });
+  }
+  if (all || opts.claude) {
+    await collect("claude", () => ingestClaude(db, opts.verbose, opts.projectsDir), { files: 0, sessions: 0, requests: 0 });
+    await collect("claudeQuota", () => ingestClaudeQuota(db, opts.verbose), { snapshots: 0 });
+  }
+  if (all || opts.takumi)
+    await collect("takumi", () => ingestTakumi(db, opts.verbose, opts.projectsDir), { files: 0, sessions: 0, requests: 0 });
+  if (all || opts.codex) {
+    await collect("codex", () => ingestCodex(db, opts.verbose), { sessions: 0, requests: 0 });
+    await collect("codexQuota", () => ingestCodexQuota(db, opts.verbose), { snapshots: 0 });
+  }
+  if (all || opts.gemini)
+    await collect("gemini", () => ingestGemini(db, opts.verbose), { sessions: 0, requests: 0 });
+  if (all || opts.opencode)
+    await collect("opencode", () => ingestOpenCode(db, opts.verbose), { files: 0, sessions: 0, requests: 0 });
+  if (all || opts.cursor)
+    await collect("cursor", () => ingestCursor(db, opts.verbose), { snapshots: 0, requests: 0 });
+  if (all || opts.pi)
+    await collect("pi", () => ingestPi(db, opts.verbose), { files: 0, sessions: 0, requests: 0 });
+  if (all || opts.hermes)
+    await collect("hermes", () => ingestHermes(db, opts.verbose), { sessions: 0, requests: 0 });
+  if (all || opts.loops)
+    await collect("loops", async () => {
+      if (opts.noCrossAppLocalReads) {
+        announceLoopsRefusal();
+        collectionProblem("unsupported", "cross_app_local_read_refused");
+        return { sessions: 0, requests: 0 };
+      }
+      return ingestLoops(db, opts.verbose);
+    }, { sessions: 0, requests: 0 });
+  result.collections = collections;
+  return result;
+}
+
+export { agentPaths, syncAll };