@hasna/economy 0.2.31 → 0.2.32

package/dist/index.js

@@ -16,60 +16,6 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
-// src/db/storage-adapter.ts
-import { Database as BunDatabase } from "bun:sqlite";
-
-class SqliteAdapter {
-  db;
-  constructor(path) {
-    this.db = new BunDatabase(path, { create: true });
-  }
-  run(sql, ...params) {
-    const result = this.db.prepare(sql).run(...params);
-    return { changes: result.changes, lastInsertRowid: result.lastInsertRowid };
-  }
-  get(sql, ...params) {
-    return this.db.prepare(sql).get(...params);
-  }
-  all(sql, ...params) {
-    return this.db.prepare(sql).all(...params);
-  }
-  exec(sql) {
-    this.db.exec(sql);
-  }
-  query(sql) {
-    return this.db.query(sql);
-  }
-  prepare(sql) {
-    const statement = this.db.prepare(sql);
-    return {
-      run(...params) {
-        const result = statement.run(...params);
-        return { changes: result.changes, lastInsertRowid: result.lastInsertRowid };
-      },
-      get(...params) {
-        return statement.get(...params);
-      },
-      all(...params) {
-        return statement.all(...params);
-      },
-      finalize() {
-        statement.finalize();
-      }
-    };
-  }
-  close() {
-    this.db.close();
-  }
-  transaction(fn) {
-    return this.db.transaction(fn)();
-  }
-  get raw() {
-    return this.db;
-  }
-}
-var init_storage_adapter = () => {};
-
 // src/lib/pricing.ts
 var exports_pricing = {};
 __export(exports_pricing, {
@@ -566,6 +512,7 @@ var init_pricing = __esm(() => {
 });
 
 // src/db/database.ts
+import { SqliteAdapter as Database } from "@hasna/cloud";
 import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
 import { hostname } from "os";
 import { homedir } from "os";
@@ -608,7 +555,7 @@ function openDatabase(dbPath, skipSeed = false) {
     if (dir && !existsSync(dir))
       mkdirSync(dir, { recursive: true });
   }
-  const db = new SqliteAdapter(path);
+  const db = new Database(path);
   db.exec("PRAGMA journal_mode = WAL");
   db.exec("PRAGMA busy_timeout = 5000");
   db.exec("PRAGMA foreign_keys = ON");
@@ -1644,198 +1591,7 @@ function dedupeRequests(db) {
   }
   return removed;
 }
-var init_database = __esm(() => {
-  init_storage_adapter();
-  init_storage_adapter();
-});
-
-// src/db/pg-migrations.ts
-var exports_pg_migrations = {};
-__export(exports_pg_migrations, {
-  PG_MIGRATIONS: () => PG_MIGRATIONS
-});
-var PG_MIGRATIONS;
-var init_pg_migrations = __esm(() => {
-  PG_MIGRATIONS = [
-    `CREATE TABLE IF NOT EXISTS requests (
-    id TEXT PRIMARY KEY,
-    agent TEXT NOT NULL,
-    session_id TEXT NOT NULL,
-    model TEXT NOT NULL,
-    input_tokens INTEGER DEFAULT 0,
-    output_tokens INTEGER DEFAULT 0,
-    cache_read_tokens INTEGER DEFAULT 0,
-    cache_create_tokens INTEGER DEFAULT 0,
-    cache_create_5m_tokens INTEGER DEFAULT 0,
-    cache_create_1h_tokens INTEGER DEFAULT 0,
-    cost_usd REAL NOT NULL DEFAULT 0,
-    duration_ms INTEGER DEFAULT 0,
-    timestamp TEXT NOT NULL,
-    source_request_id TEXT,
-    machine_id TEXT DEFAULT '',
-    account_key TEXT DEFAULT '',
-    account_tool TEXT DEFAULT '',
-    account_name TEXT DEFAULT '',
-    account_email TEXT DEFAULT '',
-    account_source TEXT DEFAULT ''
-  )`,
-    `CREATE TABLE IF NOT EXISTS sessions (
-    id TEXT PRIMARY KEY,
-    agent TEXT NOT NULL,
-    project_path TEXT DEFAULT '',
-    project_name TEXT DEFAULT '',
-    started_at TEXT NOT NULL,
-    ended_at TEXT,
-    total_cost_usd REAL DEFAULT 0,
-    total_tokens INTEGER DEFAULT 0,
-    request_count INTEGER DEFAULT 0,
-    machine_id TEXT DEFAULT '',
-    account_key TEXT DEFAULT '',
-    account_tool TEXT DEFAULT '',
-    account_name TEXT DEFAULT '',
-    account_email TEXT DEFAULT '',
-    account_source TEXT DEFAULT ''
-  )`,
-    `CREATE TABLE IF NOT EXISTS projects (
-    id TEXT PRIMARY KEY,
-    path TEXT UNIQUE NOT NULL,
-    name TEXT NOT NULL,
-    description TEXT,
-    tags TEXT DEFAULT '[]',
-    created_at TEXT NOT NULL
-  )`,
-    `CREATE TABLE IF NOT EXISTS budgets (
-    id TEXT PRIMARY KEY,
-    project_path TEXT,
-    agent TEXT,
-    period TEXT NOT NULL,
-    limit_usd REAL NOT NULL,
-    alert_at_percent INTEGER DEFAULT 80,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL
-  )`,
-    `CREATE TABLE IF NOT EXISTS goals (
-    id TEXT PRIMARY KEY,
-    period TEXT NOT NULL,
-    project_path TEXT,
-    agent TEXT,
-    limit_usd REAL NOT NULL,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL
-  )`,
-    `CREATE TABLE IF NOT EXISTS ingest_state (
-    source TEXT NOT NULL,
-    key TEXT NOT NULL,
-    value TEXT NOT NULL,
-    PRIMARY KEY (source, key)
-  )`,
-    `CREATE INDEX IF NOT EXISTS idx_requests_session ON requests(session_id)`,
-    `CREATE INDEX IF NOT EXISTS idx_requests_timestamp ON requests(timestamp)`,
-    `CREATE INDEX IF NOT EXISTS idx_requests_agent ON requests(agent)`,
-    `CREATE INDEX IF NOT EXISTS idx_requests_machine ON requests(machine_id)`,
-    `CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent)`,
-    `CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_path)`,
-    `CREATE INDEX IF NOT EXISTS idx_sessions_started ON sessions(started_at)`,
-    `CREATE INDEX IF NOT EXISTS idx_sessions_machine ON sessions(machine_id)`,
-    `CREATE TABLE IF NOT EXISTS model_pricing (
-    model TEXT PRIMARY KEY,
-    input_per_1m REAL NOT NULL DEFAULT 0,
-    output_per_1m REAL NOT NULL DEFAULT 0,
-    cache_read_per_1m REAL NOT NULL DEFAULT 0,
-    cache_write_per_1m REAL NOT NULL DEFAULT 0,
-    cache_write_1h_per_1m REAL NOT NULL DEFAULT 0,
-    cache_storage_per_1m_hour REAL NOT NULL DEFAULT 0,
-    updated_at TEXT NOT NULL
-  )`,
-    `ALTER TABLE requests ADD COLUMN IF NOT EXISTS cache_create_5m_tokens INTEGER DEFAULT 0`,
-    `ALTER TABLE requests ADD COLUMN IF NOT EXISTS cache_create_1h_tokens INTEGER DEFAULT 0`,
-    `ALTER TABLE model_pricing ADD COLUMN IF NOT EXISTS cache_write_1h_per_1m REAL NOT NULL DEFAULT 0`,
-    `ALTER TABLE model_pricing ADD COLUMN IF NOT EXISTS cache_storage_per_1m_hour REAL NOT NULL DEFAULT 0`,
-    `CREATE TABLE IF NOT EXISTS feedback (
-    id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text,
-    message TEXT NOT NULL,
-    email TEXT,
-    category TEXT DEFAULT 'general',
-    version TEXT,
-    machine_id TEXT,
-    created_at TEXT NOT NULL DEFAULT NOW()::text
-  )`,
-    `CREATE TABLE IF NOT EXISTS billing_daily (
-    date TEXT NOT NULL,
-    provider TEXT NOT NULL,
-    description TEXT DEFAULT '',
-    cost_usd REAL NOT NULL DEFAULT 0,
-    updated_at TEXT NOT NULL,
-    PRIMARY KEY (date, provider, description)
-  )`,
-    `CREATE INDEX IF NOT EXISTS idx_billing_date ON billing_daily(date)`,
-    `CREATE INDEX IF NOT EXISTS idx_billing_provider ON billing_daily(provider)`,
-    `CREATE TABLE IF NOT EXISTS subscriptions (
-    id TEXT PRIMARY KEY,
-    agent TEXT,
-    provider TEXT NOT NULL,
-    plan TEXT NOT NULL,
-    monthly_fee_usd REAL NOT NULL DEFAULT 0,
-    included_usage_usd REAL NOT NULL DEFAULT 0,
-    billing_cycle_start TEXT,
-    reset_policy TEXT DEFAULT 'monthly',
-    active INTEGER NOT NULL DEFAULT 1,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL
-  )`,
-    `CREATE TABLE IF NOT EXISTS usage_snapshots (
-    id TEXT PRIMARY KEY,
-    agent TEXT NOT NULL,
-    date TEXT NOT NULL,
-    metric TEXT NOT NULL,
-    value REAL NOT NULL DEFAULT 0,
-    unit TEXT DEFAULT '',
-    machine_id TEXT DEFAULT '',
-    updated_at TEXT NOT NULL
-  )`,
-    `CREATE TABLE IF NOT EXISTS savings_daily (
-    date TEXT NOT NULL,
-    agent TEXT DEFAULT '',
-    api_equivalent_usd REAL NOT NULL DEFAULT 0,
-    subscription_fee_usd REAL NOT NULL DEFAULT 0,
-    included_consumed_usd REAL NOT NULL DEFAULT 0,
-    on_demand_usd REAL NOT NULL DEFAULT 0,
-    saved_usd REAL NOT NULL DEFAULT 0,
-    updated_at TEXT NOT NULL,
-    PRIMARY KEY (date, agent)
-  )`,
-    `CREATE TABLE IF NOT EXISTS machines (
-    machine_id TEXT PRIMARY KEY,
-    hostname TEXT NOT NULL,
-    last_seen_at TEXT,
-    last_push_at TEXT,
-    last_pull_at TEXT,
-    economy_version TEXT,
-    updated_at TEXT NOT NULL
-  )`,
-    `ALTER TABLE requests ADD COLUMN IF NOT EXISTS cost_basis TEXT DEFAULT 'estimated'`,
-    `ALTER TABLE requests ADD COLUMN IF NOT EXISTS attribution_tag TEXT DEFAULT ''`,
-    `ALTER TABLE requests ADD COLUMN IF NOT EXISTS account_key TEXT DEFAULT ''`,
-    `ALTER TABLE requests ADD COLUMN IF NOT EXISTS account_tool TEXT DEFAULT ''`,
-    `ALTER TABLE requests ADD COLUMN IF NOT EXISTS account_name TEXT DEFAULT ''`,
-    `ALTER TABLE requests ADD COLUMN IF NOT EXISTS account_email TEXT DEFAULT ''`,
-    `ALTER TABLE requests ADD COLUMN IF NOT EXISTS account_source TEXT DEFAULT ''`,
-    `ALTER TABLE requests ADD COLUMN IF NOT EXISTS updated_at TEXT DEFAULT ''`,
-    `ALTER TABLE requests ADD COLUMN IF NOT EXISTS synced_at TEXT DEFAULT ''`,
-    `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS attribution_tag TEXT DEFAULT ''`,
-    `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS account_key TEXT DEFAULT ''`,
-    `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS account_tool TEXT DEFAULT ''`,
-    `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS account_name TEXT DEFAULT ''`,
-    `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS account_email TEXT DEFAULT ''`,
-    `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS account_source TEXT DEFAULT ''`,
-    `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS updated_at TEXT DEFAULT ''`,
-    `ALTER TABLE sessions ADD COLUMN IF NOT EXISTS synced_at TEXT DEFAULT ''`,
-    `CREATE INDEX IF NOT EXISTS idx_usage_agent_date ON usage_snapshots(agent, date)`,
-    `CREATE INDEX IF NOT EXISTS idx_savings_date ON savings_daily(date)`,
-    `CREATE INDEX IF NOT EXISTS idx_requests_account ON requests(account_key)`,
-    `CREATE INDEX IF NOT EXISTS idx_sessions_account ON sessions(account_key)`
-  ];
-});
+var init_database = () => {};
 
 // src/lib/agents.ts
 var AGENTS = [
@@ -2088,26 +1844,22 @@ function clearActiveModel() {
 // src/lib/open-projects.ts
 init_database();
 async function syncOpenProjectsRegistry(db, listActiveProjects) {
-  let listOpenProjects = listActiveProjects;
-  if (!listOpenProjects) {
+  let listProjects2 = listActiveProjects;
+  if (!listProjects2) {
     const projectsApi = await import("@hasna/projects");
-    listOpenProjects = projectsApi.listProjects ?? projectsApi.listWorkspaces;
+    listProjects2 = projectsApi.listProjects;
   }
-  if (!listOpenProjects) {
-    throw new Error("@hasna/projects does not expose listWorkspaces or listProjects");
-  }
-  const projects = listOpenProjects({ status: "active", limit: 5000 });
+  const projects = listProjects2({ status: "active", limit: 5000 });
   let imported = 0;
   let skipped = 0;
   for (const project of projects) {
-    const path = project.path ?? project.primary_path ?? "";
-    if (!path) {
+    if (!project.path) {
       skipped++;
       continue;
     }
     upsertProject(db, {
       id: project.id,
-      path,
+      path: project.path,
       name: project.name,
       description: project.description,
       tags: project.tags ?? [],
@@ -2119,7 +1871,7 @@ async function syncOpenProjectsRegistry(db, listActiveProjects) {
 }
 // src/lib/peer-sync.ts
 init_database();
-import { Database as BunDatabase2 } from "bun:sqlite";
+import { Database as BunDatabase } from "bun:sqlite";
 import { existsSync as existsSync3 } from "fs";
 
 // src/lib/package-metadata.ts
@@ -2364,9 +2116,9 @@ function ensureMachineRegistry(target, machine, now) {
 }
 function openSourceDatabase(path) {
   try {
-    return new BunDatabase2(path, { readonly: true });
+    return new BunDatabase(path, { readonly: true });
   } catch {
-    return new BunDatabase2(path);
+    return new BunDatabase(path);
   }
 }
 function mergePeerDatabase(target, sourcePath, opts = {}) {
@@ -2410,741 +2162,12 @@ function mergePeerDatabase(target, sourcePath, opts = {}) {
     tables: tables.filter((t) => t.inserted || t.updated || t.skipped || t.collisions)
   };
 }
-// src/lib/cloud-sync.ts
-init_database();
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir2, platform } from "os";
-import { dirname as dirname2, join as join3 } from "path";
-
-// src/lib/remote-storage.ts
-import pg from "pg";
-function translatePlaceholders(sql) {
-  let index = 0;
-  return sql.replace(/\?/g, () => `$${++index}`);
-}
-function normalizeParams(params) {
-  const flat = params.length === 1 && Array.isArray(params[0]) ? params[0] : params;
-  return flat.map((value) => value === undefined ? null : value);
-}
-function sslConfigFor(connectionString) {
-  return connectionString.includes("sslmode=require") || connectionString.includes("ssl=true") ? { rejectUnauthorized: false } : undefined;
-}
-
-class PgAdapterAsync {
-  pool;
-  constructor(source) {
-    this.pool = typeof source === "string" ? new pg.Pool({ connectionString: source, ssl: sslConfigFor(source) }) : source;
-  }
-  async run(sql, ...params) {
-    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams(params));
-    return { changes: result.rowCount ?? 0, lastInsertRowid: 0 };
-  }
-  async get(sql, ...params) {
-    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams(params));
-    return result.rows[0] ?? null;
-  }
-  async all(sql, ...params) {
-    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams(params));
-    return result.rows;
-  }
-  async exec(sql) {
-    await this.pool.query(translatePlaceholders(sql));
-  }
-  async close() {
-    await this.pool.end();
-  }
-  async transaction(fn) {
-    const client = await this.pool.connect();
-    try {
-      await client.query("BEGIN");
-      const result = await fn(client);
-      await client.query("COMMIT");
-      return result;
-    } catch (error) {
-      await client.query("ROLLBACK");
-      throw error;
-    } finally {
-      client.release();
-    }
-  }
-  get raw() {
-    return this.pool;
-  }
-}
-
-// src/lib/storage-sync.ts
-async function syncPush(local, remote, options) {
-  const tables = await getTableOrder(remote, options.tables);
-  return syncTransfer(local, remote, { ...options, tables }, "push");
-}
-async function syncPull(remote, local, options) {
-  const tables = await getTableOrder(remote, options.tables);
-  return syncTransfer(remote, local, { ...options, tables }, "pull");
-}
-function quoteIdent2(identifier) {
-  return `"${identifier.replace(/"/g, '""')}"`;
-}
-async function getTableOrder(remote, tables) {
-  if (tables.length <= 1)
-    return tables;
-  try {
-    const rows = await remote.all(`
-      SELECT DISTINCT
-        tc.table_name AS source_table,
-        ccu.table_name AS referenced_table
-      FROM information_schema.table_constraints tc
-      JOIN information_schema.constraint_column_usage ccu
-        ON tc.constraint_name = ccu.constraint_name
-        AND tc.table_schema = ccu.table_schema
-      WHERE tc.constraint_type = 'FOREIGN KEY'
-        AND tc.table_schema = 'public'
-    `);
-    if (rows.length > 0)
-      return topoSort(tables, rows);
-  } catch {}
-  return tables;
-}
-function topoSort(tables, foreignKeys) {
-  const allowed = new Set(tables);
-  const deps = new Map;
-  for (const table of tables)
-    deps.set(table, new Set);
-  for (const fk of foreignKeys) {
-    if (allowed.has(fk.source_table) && allowed.has(fk.referenced_table)) {
-      deps.get(fk.source_table)?.add(fk.referenced_table);
-    }
-  }
-  const sorted = [];
-  const visited = new Set;
-  const visiting = new Set;
-  function visit(table) {
-    if (visited.has(table))
-      return;
-    if (visiting.has(table)) {
-      visited.add(table);
-      sorted.push(table);
-      return;
-    }
-    visiting.add(table);
-    for (const dep of deps.get(table) ?? [])
-      visit(dep);
-    visiting.delete(table);
-    visited.add(table);
-    sorted.push(table);
-  }
-  for (const table of tables)
-    visit(table);
-  return sorted;
-}
-async function resolvePrimaryKeys(source, target, table, option) {
-  if (option)
-    return Array.isArray(option) ? option : [option];
-  const sourceKeys = await detectPrimaryKeys(source, table);
-  if (sourceKeys.length > 0)
-    return sourceKeys;
-  return detectPrimaryKeys(target, table);
-}
-async function detectPrimaryKeys(adapter, table) {
-  if (isAsyncAdapter(adapter)) {
-    try {
-      const rows = await adapter.all(`
-        SELECT kcu.column_name, kcu.ordinal_position
-        FROM information_schema.table_constraints tc
-        JOIN information_schema.key_column_usage kcu
-          ON tc.constraint_name = kcu.constraint_name
-          AND tc.table_schema = kcu.table_schema
-        WHERE tc.constraint_type = 'PRIMARY KEY'
-          AND tc.table_schema = 'public'
-          AND tc.table_name = ?
-        ORDER BY kcu.ordinal_position
-      `, table);
-      return rows.map((row) => row.column_name);
-    } catch {
-      return [];
-    }
-  }
-  try {
-    const rows = adapter.all(`PRAGMA table_info(${quoteIdent2(table)})`);
-    return rows.filter((row) => row.pk > 0).sort((a, b) => a.pk - b.pk).map((row) => row.name);
-  } catch {
-    return [];
-  }
-}
-async function ensureTablesExist(source, target, tables) {
-  if (!isAsyncAdapter(source) || isAsyncAdapter(target))
-    return;
-  for (const table of tables)
-    await ensureTableInSqliteFromPg(target, source, table);
-}
-async function ensureTableInSqliteFromPg(target, source, table) {
-  const existing = target.all(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`, table);
-  if (existing.length > 0)
-    return;
-  const columns = await source.all(`
-    SELECT column_name, data_type, is_nullable
-    FROM information_schema.columns
-    WHERE table_schema = 'public' AND table_name = ?
-    ORDER BY ordinal_position
-  `, table);
-  if (columns.length === 0)
-    return;
-  const primaryKeys = new Set(await detectPrimaryKeys(source, table));
-  const definitions = columns.filter((column) => !["tsvector", "tsquery"].includes(column.data_type.toLowerCase())).map((column) => {
-    const type = pgTypeToSqlite(column.data_type);
-    const notNull = column.is_nullable === "NO" && !primaryKeys.has(column.column_name) ? " NOT NULL" : "";
-    return `${quoteIdent2(column.column_name)} ${type}${notNull}`;
-  });
-  if (primaryKeys.size > 0) {
-    definitions.push(`PRIMARY KEY (${[...primaryKeys].map(quoteIdent2).join(", ")})`);
-  }
-  target.exec(`CREATE TABLE IF NOT EXISTS ${quoteIdent2(table)} (${definitions.join(", ")})`);
-}
-function pgTypeToSqlite(pgType) {
-  const type = pgType.toLowerCase();
-  if (type.includes("int") || ["bigint", "smallint", "serial", "bigserial"].includes(type))
-    return "INTEGER";
-  if (type.includes("bool"))
-    return "INTEGER";
-  if (type.includes("float") || type.includes("double") || ["real", "numeric", "decimal"].includes(type))
-    return "REAL";
-  if (type === "bytea")
-    return "BLOB";
-  return "TEXT";
-}
-async function filterColumnsForTarget(target, table, columns) {
-  if (columns.includes("machine_id") && table !== "machines")
-    await ensureMachineIdColumnInTarget(target, table);
-  try {
-    if (isAsyncAdapter(target)) {
-      const rows2 = await target.all(`
-        SELECT column_name
-        FROM information_schema.columns
-        WHERE table_schema = 'public' AND table_name = ?
-      `, table);
-      if (rows2.length === 0)
-        return columns;
-      const targetColumns2 = new Set(rows2.map((row) => row.column_name));
-      return columns.filter((column) => targetColumns2.has(column));
-    }
-    const rows = target.all(`PRAGMA table_info(${quoteIdent2(table)})`);
-    if (rows.length === 0)
-      return columns;
-    const targetColumns = new Set(rows.map((row) => row.name));
-    return columns.filter((column) => targetColumns.has(column));
-  } catch {
-    return columns;
-  }
-}
-async function ensureMachineIdColumnInTarget(target, table) {
-  if (isAsyncAdapter(target)) {
-    const rows2 = await target.all(`
-      SELECT column_name
-      FROM information_schema.columns
-      WHERE table_schema = 'public' AND table_name = ? AND column_name = 'machine_id'
-    `, table);
-    if (rows2.length === 0)
-      await target.exec(`ALTER TABLE ${quoteIdent2(table)} ADD COLUMN machine_id TEXT DEFAULT ''`);
-    return;
-  }
-  const rows = target.all(`PRAGMA table_info(${quoteIdent2(table)})`);
-  if (!rows.some((row) => row.name === "machine_id")) {
-    target.exec(`ALTER TABLE ${quoteIdent2(table)} ADD COLUMN machine_id TEXT DEFAULT ''`);
-  }
-}
-async function syncTransfer(source, target, options, _direction) {
-  const { tables, onProgress, batchSize = 100, conflictColumn = "updated_at", primaryKey } = options;
-  const results = [];
-  const sqliteTarget = isAsyncAdapter(target) ? null : target;
-  await ensureTablesExist(source, target, tables);
-  if (sqliteTarget) {
-    try {
-      sqliteTarget.exec("PRAGMA foreign_keys = OFF");
-    } catch {}
-  }
-  try {
-    for (let i = 0;i < tables.length; i++) {
-      const table = tables[i];
-      const result = { table, rowsRead: 0, rowsWritten: 0, rowsSkipped: 0, errors: [] };
-      try {
-        onProgress?.({ table, phase: "reading", rowsRead: 0, rowsWritten: 0, totalTables: tables.length, currentTableIndex: i });
-        const rows = await readAll(source, `SELECT * FROM ${quoteIdent2(table)}`);
-        result.rowsRead = rows.length;
-        if (rows.length === 0) {
-          onProgress?.({ table, phase: "done", rowsRead: 0, rowsWritten: 0, totalTables: tables.length, currentTableIndex: i });
-          results.push(result);
-          continue;
-        }
-        const sourceColumns = Object.keys(rows[0]);
-        const columns = await filterColumnsForTarget(target, table, sourceColumns);
-        const primaryKeys = await resolvePrimaryKeys(source, target, table, primaryKey);
-        if (primaryKeys.length === 0) {
-          result.errors.push(`Table "${table}" has no primary key; inserted without conflict handling`);
-          for (const batch of batches(rows, batchSize)) {
-            await insertBatch(target, table, columns, batch);
-            result.rowsWritten += batch.length;
-          }
-          results.push(result);
-          continue;
-        }
-        const missingKeys = primaryKeys.filter((key) => !columns.includes(key));
-        if (missingKeys.length > 0) {
-          result.errors.push(`Table "${table}" missing primary key column(s): ${missingKeys.join(", ")}`);
-          results.push(result);
-          continue;
-        }
-        onProgress?.({ table, phase: "writing", rowsRead: result.rowsRead, rowsWritten: 0, totalTables: tables.length, currentTableIndex: i });
-        const updateColumns = columns.filter((column) => !primaryKeys.includes(column));
-        const newestWinsColumn = columns.includes(conflictColumn) ? conflictColumn : undefined;
-        for (const batch of batches(rows, batchSize)) {
-          await upsertBatch(target, table, columns, updateColumns, primaryKeys, batch, newestWinsColumn);
-          result.rowsWritten += batch.length;
-          onProgress?.({ table, phase: "writing", rowsRead: result.rowsRead, rowsWritten: result.rowsWritten, totalTables: tables.length, currentTableIndex: i });
-        }
-        onProgress?.({ table, phase: "done", rowsRead: result.rowsRead, rowsWritten: result.rowsWritten, totalTables: tables.length, currentTableIndex: i });
-      } catch (error) {
-        result.errors.push(error instanceof Error ? error.message : String(error));
-      }
-      results.push(result);
-    }
-  } finally {
-    if (sqliteTarget) {
-      try {
-        sqliteTarget.exec("PRAGMA foreign_keys = ON");
-      } catch {}
-    }
-  }
-  return results;
-}
-function batches(rows, size) {
-  const result = [];
-  for (let offset = 0;offset < rows.length; offset += size)
-    result.push(rows.slice(offset, offset + size));
-  return result;
-}
-async function upsertBatch(target, table, columns, updateColumns, primaryKeys, batch, conflictColumn) {
-  if (batch.length === 0 || columns.length === 0)
-    return;
-  const fallbackKey = primaryKeys[0] ?? columns[0] ?? "id";
-  const columnList = columns.map(quoteIdent2).join(", ");
-  const keyList = primaryKeys.map(quoteIdent2).join(", ");
-  const setClause = updateColumns.length > 0 ? updateColumns.map((column) => `${quoteIdent2(column)} = EXCLUDED.${quoteIdent2(column)}`).join(", ") : `${quoteIdent2(fallbackKey)} = EXCLUDED.${quoteIdent2(fallbackKey)}`;
-  const whereClause = conflictColumn && updateColumns.includes(conflictColumn) ? ` WHERE ${quoteIdent2(table)}.${quoteIdent2(conflictColumn)} IS NULL OR EXCLUDED.${quoteIdent2(conflictColumn)} >= ${quoteIdent2(table)}.${quoteIdent2(conflictColumn)}` : "";
-  if (isAsyncAdapter(target)) {
-    const placeholders2 = batch.map((_, rowIndex) => `(${columns.map((__, columnIndex) => `$${rowIndex * columns.length + columnIndex + 1}`).join(", ")})`).join(", ");
-    const params2 = batch.flatMap((row) => columns.map((column) => row[column] ?? null));
-    await target.run(`INSERT INTO ${quoteIdent2(table)} (${columnList}) VALUES ${placeholders2}
-       ON CONFLICT (${keyList}) DO UPDATE SET ${setClause}${whereClause}`, ...params2);
-    return;
-  }
-  const placeholders = batch.map(() => `(${columns.map(() => "?").join(", ")})`).join(", ");
-  const params = batch.flatMap((row) => columns.map((column) => coerceForSqlite(row[column])));
-  target.run(`INSERT INTO ${quoteIdent2(table)} (${columnList}) VALUES ${placeholders}
-     ON CONFLICT (${keyList}) DO UPDATE SET ${setClause}${whereClause}`, ...params);
-}
-async function insertBatch(target, table, columns, batch) {
-  if (batch.length === 0 || columns.length === 0)
-    return;
-  const columnList = columns.map(quoteIdent2).join(", ");
-  if (isAsyncAdapter(target)) {
-    const placeholders2 = batch.map((_, rowIndex) => `(${columns.map((__, columnIndex) => `$${rowIndex * columns.length + columnIndex + 1}`).join(", ")})`).join(", ");
-    const params2 = batch.flatMap((row) => columns.map((column) => row[column] ?? null));
-    await target.run(`INSERT INTO ${quoteIdent2(table)} (${columnList}) VALUES ${placeholders2}`, ...params2);
-    return;
-  }
-  const placeholders = batch.map(() => `(${columns.map(() => "?").join(", ")})`).join(", ");
-  const params = batch.flatMap((row) => columns.map((column) => coerceForSqlite(row[column])));
-  target.run(`INSERT INTO ${quoteIdent2(table)} (${columnList}) VALUES ${placeholders}`, ...params);
-}
-function coerceForSqlite(value) {
-  if (value === null || value === undefined)
-    return null;
-  if (typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean")
-    return value;
-  if (value instanceof Date)
-    return value.toISOString();
-  if (Buffer.isBuffer(value) || value instanceof Uint8Array)
-    return value;
-  if (typeof value === "object")
-    return JSON.stringify(value);
-  return String(value);
-}
-function isAsyncAdapter(adapter) {
-  return adapter instanceof PgAdapterAsync;
-}
-async function readAll(adapter, sql) {
-  const rows = adapter.all(sql);
-  return rows instanceof Promise ? await rows : rows;
-}
-
-// src/lib/cloud-sync.ts
-var CLOUD_TABLES = [
-  "requests",
-  "sessions",
-  "projects",
-  "budgets",
-  "goals",
-  "model_pricing",
-  "billing_daily",
-  "subscriptions",
-  "usage_snapshots",
-  "savings_daily",
-  "machines",
-  "ingest_state"
-];
-function getCloudDatabaseUrl() {
-  return process.env["ECONOMY_CLOUD_DATABASE_URL"] ?? process.env["HASNA_ECONOMY_CLOUD_DATABASE_URL"] ?? null;
-}
-function isCloudAutoEnabled() {
-  return process.env["ECONOMY_CLOUD_AUTO"] === "1" || process.env["ECONOMY_CLOUD_AUTO"] === "true";
-}
-function getCloudPullIntervalMinutes() {
-  const raw = process.env["ECONOMY_CLOUD_PULL_INTERVAL"];
-  if (!raw)
-    return 15;
-  const n = Number(raw);
-  return Number.isFinite(n) && n > 0 ? n : 15;
-}
-async function getCloudPg() {
-  const url = getCloudDatabaseUrl();
-  if (!url) {
-    throw new Error("Missing ECONOMY_CLOUD_DATABASE_URL (or HASNA_ECONOMY_CLOUD_DATABASE_URL)");
-  }
-  return new PgAdapterAsync(url);
-}
-async function runCloudMigrations(cloud) {
-  const { PG_MIGRATIONS: PG_MIGRATIONS2 } = await Promise.resolve().then(() => (init_pg_migrations(), exports_pg_migrations));
-  for (const sql of PG_MIGRATIONS2) {
-    await cloud.run(sql);
-  }
-}
-function isCloudIncrementalEnabled() {
-  return process.env["ECONOMY_CLOUD_INCREMENTAL"] === "1" || process.env["ECONOMY_CLOUD_INCREMENTAL"] === "true";
-}
-async function cloudPush(opts) {
-  const cloud = await getCloudPg();
-  const local = openDatabase(getDbPath(), true);
-  try {
-    await runCloudMigrations(cloud);
-    touchMachineRegistry(local, "push");
-    const tables = resolveCloudTables(opts?.tables);
-    const results = await syncPush(local, cloud, { tables, conflictColumn: "updated_at" });
-    const rows = results.reduce((sum, result) => sum + result.rowsWritten, 0);
-    return { rows, machine: getMachineId() };
-  } finally {
-    local.close();
-    await cloud.close();
-  }
-}
-async function cloudPull(opts) {
-  const cloud = await getCloudPg();
-  const local = openDatabase(getDbPath(), true);
-  try {
-    await runCloudMigrations(cloud);
-    const tables = resolveCloudTables(opts?.tables);
-    const results = await syncPull(cloud, local, { tables, conflictColumn: "updated_at" });
-    const rows = results.reduce((sum, result) => sum + result.rowsWritten, 0);
-    touchMachineRegistry(local, "pull");
-    setLastCloudPull();
-    return { rows, machine: getMachineId() };
-  } finally {
-    local.close();
-    await cloud.close();
-  }
-}
-async function cloudSyncFull() {
-  const push = await cloudPush();
-  const pull = await cloudPull();
-  return { push: push.rows, pull: pull.rows, machine: getMachineId() };
-}
-function setLastCloudPull(at = new Date().toISOString()) {
-  const db = openDatabase(undefined, true);
-  try {
-    db.prepare(`INSERT OR REPLACE INTO ingest_state (source, key, value) VALUES ('cloud', 'last_pull_at', ?)`).run(at);
-  } finally {
-    db.close();
-  }
-}
-function getLastCloudPull() {
-  const db = openDatabase(undefined, true);
-  try {
-    const row = db.prepare(`SELECT value FROM ingest_state WHERE source = 'cloud' AND key = 'last_pull_at'`).get();
-    return row?.value ?? null;
-  } finally {
-    db.close();
-  }
-}
-function shouldPullFromCloud() {
-  if (!getCloudDatabaseUrl())
-    return false;
-  const last = getLastCloudPull();
-  if (!last)
-    return true;
-  const ageMs = Date.now() - new Date(last).getTime();
-  return ageMs > getCloudPullIntervalMinutes() * 60000;
-}
-async function maybePullFromCloud() {
-  if (!shouldPullFromCloud())
-    return false;
-  try {
-    await cloudPull();
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function maybePushAfterIngest() {
-  if (!isCloudAutoEnabled() || !getCloudDatabaseUrl())
-    return false;
-  try {
-    await cloudPush();
-    return true;
-  } catch {
-    return false;
-  }
-}
-function touchMachineRegistry(db, direction) {
-  const now = new Date().toISOString();
-  const machine = getMachineId();
-  db.prepare(`
-    INSERT INTO machines (machine_id, hostname, last_seen_at, last_push_at, last_pull_at, economy_version, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(machine_id) DO UPDATE SET
-      hostname = excluded.hostname,
-      last_seen_at = excluded.last_seen_at,
-      last_push_at = CASE WHEN ? = 'push' THEN excluded.last_push_at ELSE machines.last_push_at END,
-      last_pull_at = CASE WHEN ? = 'pull' THEN excluded.last_pull_at ELSE machines.last_pull_at END,
-      economy_version = excluded.economy_version,
-      updated_at = excluded.updated_at
-  `).run(machine, machine, now, direction === "push" ? now : null, direction === "pull" ? now : null, packageMetadata.version, now, direction, direction);
-}
-function resolveCloudTables(tables) {
-  if (!tables || tables.length === 0)
-    return [...CLOUD_TABLES];
-  const allowed = new Set(CLOUD_TABLES);
-  const requested = tables.map((table) => table.trim()).filter(Boolean);
-  const invalid = requested.filter((table) => !allowed.has(table));
-  if (invalid.length > 0) {
-    throw new Error(`Unknown economy sync table(s): ${invalid.join(", ")}`);
-  }
-  return requested;
-}
-var SCHEDULE_SERVICE_NAME = "hasna-economy-cloud-sync";
-var SCHEDULE_CONFIG_DIR = join3(homedir2(), ".hasna", "economy");
-var SCHEDULE_CONFIG_PATH = join3(SCHEDULE_CONFIG_DIR, "cloud-sync-schedule.json");
-async function registerCloudSchedule(intervalMinutes) {
-  if (!Number.isFinite(intervalMinutes) || intervalMinutes <= 0) {
-    throw new Error("Cloud sync interval must be greater than 0 minutes");
-  }
-  mkdirSync3(SCHEDULE_CONFIG_DIR, { recursive: true });
-  if (platform() === "darwin") {
-    await registerLaunchd(intervalMinutes);
-  } else if (platform() === "linux") {
-    await registerSystemd(intervalMinutes);
-  } else {
-    throw new Error(`Automatic economy cloud sync is not supported on ${platform()}`);
-  }
-  writeFileSync2(SCHEDULE_CONFIG_PATH, JSON.stringify({ intervalMinutes, updatedAt: new Date().toISOString() }, null, 2));
-}
-async function removeCloudSchedule() {
-  if (platform() === "darwin")
-    await removeLaunchd();
-  if (platform() === "linux")
-    await removeSystemd();
-  try {
-    unlinkSync(SCHEDULE_CONFIG_PATH);
-  } catch {}
-}
-async function getCloudScheduleStatus() {
-  const mechanism = platform() === "darwin" ? "launchd" : platform() === "linux" ? "systemd" : "none";
-  const interval = readScheduleInterval();
-  const registered = mechanism === "launchd" ? existsSync4(getLaunchdPlistPath()) : mechanism === "systemd" ? existsSync4(join3(getSystemdDir(), `${SCHEDULE_SERVICE_NAME}.timer`)) : false;
-  return {
-    registered,
-    schedule_minutes: interval,
-    cron_expression: interval > 0 ? minutesToCron(interval) : null,
-    mechanism
-  };
-}
-function readScheduleInterval() {
-  try {
-    const parsed = JSON.parse(readFileSync3(SCHEDULE_CONFIG_PATH, "utf8"));
-    return typeof parsed.intervalMinutes === "number" && parsed.intervalMinutes > 0 ? parsed.intervalMinutes : 0;
-  } catch {
-    return 0;
-  }
-}
-function minutesToCron(minutes) {
-  if (minutes < 60)
-    return `*/${minutes} * * * *`;
-  const hours = Math.floor(minutes / 60);
-  const remainder = minutes % 60;
-  return remainder === 0 && hours <= 24 ? `0 */${hours} * * *` : `*/${minutes} * * * *`;
-}
-function getModuleDir() {
-  return typeof import.meta.dir === "string" ? import.meta.dir : dirname2(new URL(import.meta.url).pathname);
-}
-function getBunPath() {
-  const candidates = [
-    join3(homedir2(), ".bun", "bin", "bun"),
-    "/opt/homebrew/bin/bun",
-    "/usr/local/bin/bun",
-    "/usr/bin/bun"
-  ];
-  return candidates.find((candidate) => existsSync4(candidate)) ?? "bun";
-}
-function getEconomySyncCommand() {
-  const dir = getModuleDir();
-  const candidates = [
-    join3(dir, "..", "cli", "index.js"),
-    join3(dir, "..", "cli", "index.ts")
-  ];
-  const cliPath = candidates.find((candidate) => existsSync4(candidate));
-  return cliPath ? [getBunPath(), "run", cliPath, "cloud", "sync"] : ["economy", "cloud", "sync"];
-}
-function scheduleEnvironment() {
-  const keys = [
-    "ECONOMY_CLOUD_DATABASE_URL",
-    "HASNA_ECONOMY_CLOUD_DATABASE_URL",
-    "HASNA_ECONOMY_DB_PATH",
-    "ECONOMY_DB",
-    "ECONOMY_MACHINE_ID",
-    "ECONOMY_CLOUD_AUTO"
-  ];
-  const env = {
-    HOME: homedir2(),
-    PATH: process.env.PATH || "/usr/local/bin:/usr/bin:/bin"
-  };
-  for (const key of keys) {
-    const value = process.env[key];
-    if (value)
-      env[key] = value;
-  }
-  return env;
-}
-function xmlEscape(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-}
-function getLaunchdPlistPath() {
-  return join3(homedir2(), "Library", "LaunchAgents", "com.hasna.economy-cloud-sync.plist");
-}
-function createLaunchdPlist(intervalMinutes) {
-  const args = getEconomySyncCommand();
-  const env = scheduleEnvironment();
-  const stdout = join3(SCHEDULE_CONFIG_DIR, "cloud-sync.log");
-  const stderr = join3(SCHEDULE_CONFIG_DIR, "cloud-sync-error.log");
-  const programArgs = args.map((arg) => `    <string>${xmlEscape(arg)}</string>`).join(`
-`);
-  const environment = Object.entries(env).map(([key, value]) => `    <key>${xmlEscape(key)}</key>
-    <string>${xmlEscape(value)}</string>`).join(`
-`);
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key>
-  <string>com.hasna.economy-cloud-sync</string>
-  <key>ProgramArguments</key>
-  <array>
-${programArgs}
-  </array>
-  <key>StartInterval</key>
-  <integer>${Math.round(intervalMinutes * 60)}</integer>
-  <key>RunAtLoad</key>
-  <true/>
-  <key>StandardOutPath</key>
-  <string>${xmlEscape(stdout)}</string>
-  <key>StandardErrorPath</key>
-  <string>${xmlEscape(stderr)}</string>
-  <key>EnvironmentVariables</key>
-  <dict>
-${environment}
-  </dict>
-</dict>
-</plist>`;
-}
-async function registerLaunchd(intervalMinutes) {
-  const plistPath = getLaunchdPlistPath();
-  mkdirSync3(dirname2(plistPath), { recursive: true });
-  try {
-    await Bun.spawn(["launchctl", "unload", plistPath]).exited;
-  } catch {}
-  writeFileSync2(plistPath, createLaunchdPlist(intervalMinutes));
-  await Bun.spawn(["launchctl", "load", plistPath]).exited;
-}
-async function removeLaunchd() {
-  const plistPath = getLaunchdPlistPath();
-  try {
-    await Bun.spawn(["launchctl", "unload", plistPath]).exited;
-  } catch {}
-  try {
-    unlinkSync(plistPath);
-  } catch {}
-}
-function shellArg(value) {
-  return /^[A-Za-z0-9_@%+=:,./-]+$/.test(value) ? value : `'${value.replace(/'/g, `'\\''`)}'`;
-}
-function getSystemdDir() {
-  return join3(homedir2(), ".config", "systemd", "user");
-}
-function createSystemdService() {
-  const command = getEconomySyncCommand().map(shellArg).join(" ");
-  const environment = Object.entries(scheduleEnvironment()).map(([key, value]) => `Environment=${key}=${shellArg(value)}`).join(`
-`);
-  return `[Unit]
-Description=Hasna Economy Cloud Sync
-After=network.target
-
-[Service]
-Type=oneshot
-ExecStart=${command}
-${environment}
-
-[Install]
-WantedBy=default.target
-`;
-}
-function createSystemdTimer(intervalMinutes) {
-  return `[Unit]
-Description=Hasna Economy Cloud Sync Timer
-
-[Timer]
-OnBootSec=${intervalMinutes}min
-OnUnitActiveSec=${intervalMinutes}min
-Persistent=true
-
-[Install]
-WantedBy=timers.target
-`;
-}
-async function registerSystemd(intervalMinutes) {
-  const dir = getSystemdDir();
-  mkdirSync3(dir, { recursive: true });
-  writeFileSync2(join3(dir, `${SCHEDULE_SERVICE_NAME}.service`), createSystemdService());
-  writeFileSync2(join3(dir, `${SCHEDULE_SERVICE_NAME}.timer`), createSystemdTimer(intervalMinutes));
-  await Bun.spawn(["systemctl", "--user", "daemon-reload"]).exited;
-  await Bun.spawn(["systemctl", "--user", "enable", "--now", `${SCHEDULE_SERVICE_NAME}.timer`]).exited;
-}
-async function removeSystemd() {
-  try {
-    await Bun.spawn(["systemctl", "--user", "disable", "--now", `${SCHEDULE_SERVICE_NAME}.timer`]).exited;
-  } catch {}
-  const dir = getSystemdDir();
-  try {
-    unlinkSync(join3(dir, `${SCHEDULE_SERVICE_NAME}.service`));
-  } catch {}
-  try {
-    unlinkSync(join3(dir, `${SCHEDULE_SERVICE_NAME}.timer`));
-  } catch {}
-  try {
-    await Bun.spawn(["systemctl", "--user", "daemon-reload"]).exited;
-  } catch {}
-}
 // src/ingest/claude.ts
 init_database();
 init_pricing();
-import { readdirSync as readdirSync2, readFileSync as readFileSync4, existsSync as existsSync5, statSync as statSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join4, basename } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync3, existsSync as existsSync4, statSync as statSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3, basename } from "path";
 
 // src/lib/savings.ts
 function defaultCostBasisForAgent(agent) {
@@ -3291,8 +2314,8 @@ function withAccount(record, account) {
 function autoDetectProject(cwd, projects) {
   return projects.find((p) => cwd === p.path || cwd.startsWith(p.path + "/"));
 }
-var CLAUDE_PROJECTS_DIR = join4(homedir3(), ".claude", "projects");
-var TAKUMI_PROJECTS_DIR = join4(homedir3(), ".takumi", "projects");
+var CLAUDE_PROJECTS_DIR = join3(homedir2(), ".claude", "projects");
+var TAKUMI_PROJECTS_DIR = join3(homedir2(), ".takumi", "projects");
 function dirNameToPath(dirName) {
   return dirName.replace(/^-/, "/").replace(/-/g, "/").replace(/\/\//g, "/-");
 }
@@ -3302,9 +2325,9 @@ function collectJsonlFiles(projectDir) {
     try {
       for (const entry of readdirSync2(dir, { withFileTypes: true })) {
         if (entry.isDirectory())
-          walk(join4(dir, entry.name));
+          walk(join3(dir, entry.name));
         else if (entry.name.endsWith(".jsonl"))
-          files.push(join4(dir, entry.name));
+          files.push(join3(dir, entry.name));
       }
     } catch {}
   }
@@ -3318,7 +2341,7 @@ async function ingestTakumi(db, verbose = false, projectsDir = TAKUMI_PROJECTS_D
   return ingestJsonlProjects(db, projectsDir, "takumi", verbose);
 }
 async function ingestJsonlProjects(db, projectsDir, agentName, verbose = false) {
-  if (!existsSync5(projectsDir)) {
+  if (!existsSync4(projectsDir)) {
     if (verbose)
       console.log(`${agentName} projects dir not found:`, projectsDir);
     return { files: 0, requests: 0, sessions: 0 };
@@ -3331,7 +2354,7 @@ async function ingestJsonlProjects(db, projectsDir, agentName, verbose = false)
   const account = await resolveAccountForAgent(agentName);
   const projectDirs = readdirSync2(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
   for (const projectDirEntry of projectDirs) {
-    const projectDirPath = join4(projectsDir, projectDirEntry.name);
+    const projectDirPath = join3(projectsDir, projectDirEntry.name);
     const projectPath = dirNameToPath(projectDirEntry.name);
     const jsonlFiles = collectJsonlFiles(projectDirPath);
     for (const filePath of jsonlFiles) {
@@ -3347,7 +2370,7 @@ async function ingestJsonlProjects(db, projectsDir, agentName, verbose = false)
         continue;
       let lines;
       try {
-        lines = readFileSync4(filePath, "utf-8").split(`
+        lines = readFileSync3(filePath, "utf-8").split(`
 `).filter((l) => l.trim());
       } catch {
         continue;
@@ -3466,12 +2489,12 @@ function supportsClaudeDataResidencyPricing(model) {
 // src/ingest/codex.ts
 init_database();
 init_pricing();
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join5, basename as basename2 } from "path";
-import { Database as BunDatabase3 } from "bun:sqlite";
-var DEFAULT_CODEX_DB_PATH = join5(homedir4(), ".codex", "state_5.sqlite");
-var DEFAULT_CODEX_CONFIG_PATH = join5(homedir4(), ".codex", "config.toml");
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4, basename as basename2 } from "path";
+import { Database as BunDatabase2 } from "bun:sqlite";
+var DEFAULT_CODEX_DB_PATH = join4(homedir3(), ".codex", "state_5.sqlite");
+var DEFAULT_CODEX_CONFIG_PATH = join4(homedir3(), ".codex", "config.toml");
 var CODEX_INGEST_VERSION = "rollout-aggregate-v3";
 function codexDbPath() {
   return process.env["HASNA_ECONOMY_CODEX_DB_PATH"] ?? DEFAULT_CODEX_DB_PATH;
@@ -3481,10 +2504,10 @@ function codexConfigPath() {
 }
 function readCodexModel() {
   const configPath = codexConfigPath();
-  if (!existsSync6(configPath))
+  if (!existsSync5(configPath))
     return "gpt-5-codex";
   try {
-    const content = readFileSync5(configPath, "utf-8");
+    const content = readFileSync4(configPath, "utf-8");
     const match = content.match(/^model\s*=\s*"([^"]+)"/m);
     return match?.[1] ?? "gpt-5-codex";
   } catch {
@@ -3507,7 +2530,7 @@ function openCodexDb(dbPath, verbose) {
   for (const readonly of [true, false]) {
     let codexDb = null;
     try {
-      codexDb = readonly ? new BunDatabase3(dbPath, { readonly: true }) : new BunDatabase3(dbPath);
+      codexDb = readonly ? new BunDatabase2(dbPath, { readonly: true }) : new BunDatabase2(dbPath);
       codexDb.prepare("PRAGMA schema_version").get();
       return codexDb;
     } catch (error) {
@@ -3522,12 +2545,12 @@ function openCodexDb(dbPath, verbose) {
   return null;
 }
 function readTokenEvents(rolloutPath) {
-  if (!rolloutPath || !existsSync6(rolloutPath))
+  if (!rolloutPath || !existsSync5(rolloutPath))
     return [];
   const fallbackUsages = new Map;
   let fallbackTimestamp;
   let aggregate = null;
-  for (const line of readFileSync5(rolloutPath, "utf-8").split(`
+  for (const line of readFileSync4(rolloutPath, "utf-8").split(`
 `)) {
     if (!line.trim())
       continue;
@@ -3599,7 +2622,7 @@ function fallbackEvents(totalTokens) {
 }
 async function ingestCodex(db, verbose = false) {
   const dbPath = codexDbPath();
-  if (!existsSync6(dbPath)) {
+  if (!existsSync5(dbPath)) {
     if (verbose)
       console.log("Codex DB not found:", dbPath);
     return { sessions: 0, requests: 0 };
@@ -3682,11 +2705,11 @@ async function ingestCodex(db, verbose = false) {
 // src/ingest/gemini.ts
 init_database();
 init_pricing();
-import { readdirSync as readdirSync3, readFileSync as readFileSync6, existsSync as existsSync7, statSync as statSync3 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join6, basename as basename3 } from "path";
-var DEFAULT_GEMINI_TMP_DIR = join6(homedir5(), ".gemini", "tmp");
-var DEFAULT_GEMINI_HISTORY_DIR = join6(homedir5(), ".gemini", "history");
+import { readdirSync as readdirSync3, readFileSync as readFileSync5, existsSync as existsSync6, statSync as statSync3 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join5, basename as basename3 } from "path";
+var DEFAULT_GEMINI_TMP_DIR = join5(homedir4(), ".gemini", "tmp");
+var DEFAULT_GEMINI_HISTORY_DIR = join5(homedir4(), ".gemini", "history");
 function geminiTmpDir() {
   return process.env["HASNA_ECONOMY_GEMINI_TMP_DIR"] ?? DEFAULT_GEMINI_TMP_DIR;
 }
@@ -3703,12 +2726,12 @@ function numberField(...values) {
 function listProjectDirs(...roots) {
   const dirs = new Set;
   for (const root of roots) {
-    if (!existsSync7(root))
+    if (!existsSync6(root))
       continue;
     try {
       for (const entry of readdirSync3(root, { withFileTypes: true })) {
         if (entry.isDirectory())
-          dirs.add(join6(root, entry.name));
+          dirs.add(join5(root, entry.name));
       }
     } catch {}
   }
@@ -3719,17 +2742,17 @@ function projectRoot(projectDir, chatData) {
     return chatData.projectPath;
   if (chatData.project_path)
     return chatData.project_path;
-  const rootFile = join6(projectDir, ".project_root");
+  const rootFile = join5(projectDir, ".project_root");
   try {
-    if (existsSync7(rootFile))
-      return readFileSync6(rootFile, "utf-8").trim();
+    if (existsSync6(rootFile))
+      return readFileSync5(rootFile, "utf-8").trim();
   } catch {}
   return "";
 }
 async function ingestGemini(db, verbose) {
   const tmpDir = geminiTmpDir();
   const historyDir = geminiHistoryDir();
-  if (!existsSync7(tmpDir) && !existsSync7(historyDir)) {
+  if (!existsSync6(tmpDir) && !existsSync6(historyDir)) {
     if (verbose)
       console.log("Gemini tmp/history dirs not found:", tmpDir, historyDir);
     return { sessions: 0, requests: 0 };
@@ -3741,17 +2764,17 @@ async function ingestGemini(db, verbose) {
   const account = await resolveAccountForAgent("gemini");
   const projectDirs = listProjectDirs(tmpDir, historyDir);
   for (const projectDir of projectDirs) {
-    const chatsDir = join6(projectDir, "chats");
-    if (!existsSync7(chatsDir))
+    const chatsDir = join5(projectDir, "chats");
+    if (!existsSync6(chatsDir))
       continue;
     let chatFiles = [];
     try {
-      chatFiles = readdirSync3(chatsDir).filter((f) => f.endsWith(".json")).map((f) => join6(chatsDir, f));
+      chatFiles = readdirSync3(chatsDir).filter((f) => f.endsWith(".json")).map((f) => join5(chatsDir, f));
     } catch {
       continue;
     }
     for (const filePath of chatFiles) {
-      const stateKey = filePath.replace(homedir5(), "~");
+      const stateKey = filePath.replace(homedir4(), "~");
       let fileMtime = "0";
       try {
         fileMtime = statSync3(filePath).mtimeMs.toString();
@@ -3763,7 +2786,7 @@ async function ingestGemini(db, verbose) {
         continue;
       let chatData;
       try {
-        chatData = JSON.parse(readFileSync6(filePath, "utf-8"));
+        chatData = JSON.parse(readFileSync5(filePath, "utf-8"));
       } catch {
         continue;
       }
@@ -3847,18 +2870,11 @@ export {
   upsertGoal,
   upsertBudget,
   upsertBillingDaily,
-  syncPush,
-  syncPull,
   syncOpenProjectsRegistry,
-  shouldPullFromCloud,
-  setLastCloudPull,
   setIngestState,
   setActiveModel,
   seedModelPricing,
-  runCloudMigrations,
   rollupSession,
-  removeCloudSchedule,
-  registerCloudSchedule,
   readCodexModel,
   queryUsageSnapshots,
   queryTopSessions,
@@ -3875,8 +2891,6 @@ export {
   openDatabase,
   normalizeModelName,
   mergePeerDatabase,
-  maybePushAfterIngest,
-  maybePullFromCloud,
   listSubscriptions,
   listProjects,
   listModelPricing,
@@ -3884,8 +2898,6 @@ export {
   listMachineRegistry,
   listGoals,
   listBudgets,
-  isCloudIncrementalEnabled,
-  isCloudAutoEnabled,
   isAgent,
   ingestTakumi,
   ingestJsonlProjects,
@@ -3897,15 +2909,10 @@ export {
   getPricing,
   getModelPricing,
   getMachineId,
-  getLastCloudPull,
   getIngestState,
   getGoalStatuses,
   getDbPath,
   getDataDir,
-  getCloudScheduleStatus,
-  getCloudPullIntervalMinutes,
-  getCloudPg,
-  getCloudDatabaseUrl,
   getBudgetStatuses,
   getActiveModel,
   gatherTrainingData,
@@ -3918,16 +2925,10 @@ export {
   dedupeRequests,
   computeCostFromDb,
   computeCost,
-  cloudSyncFull,
-  cloudPush,
-  cloudPull,
   clearBillingRange,
   clearActiveModel,
-  SqliteAdapter,
-  PgAdapterAsync,
   DEFAULT_PRICING,
   DEFAULT_MODEL,
   COST_BASIS,
-  CLOUD_TABLES,
   AGENTS
 };