@hasna/economy 0.2.30 → 0.2.31

package/dist/cli/index.js

@@ -17,6 +17,60 @@ 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, {
@@ -561,9 +615,9 @@ __export(exports_database, {
   deleteGoal: () => deleteGoal,
   deleteBudget: () => deleteBudget,
   dedupeRequests: () => dedupeRequests,
-  clearBillingRange: () => clearBillingRange
+  clearBillingRange: () => clearBillingRange,
+  SqliteAdapter: () => SqliteAdapter
 });
-import { SqliteAdapter as Database } from "@hasna/cloud";
 import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
 import { hostname } from "os";
 import { homedir } from "os";
@@ -606,7 +660,7 @@ function openDatabase(dbPath, skipSeed = false) {
     if (dir && !existsSync(dir))
       mkdirSync(dir, { recursive: true });
   }
-  const db = new Database(path);
+  const db = new SqliteAdapter(path);
   db.exec("PRAGMA journal_mode = WAL");
   db.exec("PRAGMA busy_timeout = 5000");
   db.exec("PRAGMA foreign_keys = ON");
@@ -1358,13 +1412,17 @@ function queryDailyBreakdown(db, days = 30, machine) {
     ORDER BY date ASC
   `).all(...params);
 }
-function queryHourlyBreakdown(db, machine) {
-  const machineClause = machine ? " AND machine_id = ?" : "";
-  const params = machine ? [machine] : [];
+function queryHourlyBreakdown(db, machine, hours) {
+  const clauses = hours == null ? [`DATE(timestamp) = DATE('now')`] : [`DATETIME(timestamp) >= DATETIME('now', ?)`];
+  const params = hours == null ? [] : [`-${hours} hours`];
+  if (machine) {
+    clauses.push("machine_id = ?");
+    params.push(machine);
+  }
   return db.prepare(`
     SELECT STRFTIME('%H', timestamp) as hour, agent, COALESCE(SUM(cost_usd), 0) as cost_usd
     FROM requests
-    WHERE DATE(timestamp) = DATE('now')${machineClause}
+    WHERE ${clauses.join(" AND ")}
     GROUP BY STRFTIME('%H', timestamp), agent
     ORDER BY hour ASC
   `).all(...params);
@@ -1638,7 +1696,10 @@ function dedupeRequests(db) {
   }
   return removed;
 }
-var init_database = () => {};
+var init_database = __esm(() => {
+  init_storage_adapter();
+  init_storage_adapter();
+});
 
 // src/lib/savings.ts
 function periodWhere2(period, column) {
@@ -1904,6 +1965,370 @@ var init_package_metadata = __esm(() => {
   packageMetadata = getPackageMetadata();
 });
 
+// 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;
+  }
+}
+var init_remote_storage = () => {};
+
+// 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 quoteIdent(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(${quoteIdent(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 `${quoteIdent(column.column_name)} ${type}${notNull}`;
+  });
+  if (primaryKeys.size > 0) {
+    definitions.push(`PRIMARY KEY (${[...primaryKeys].map(quoteIdent).join(", ")})`);
+  }
+  target.exec(`CREATE TABLE IF NOT EXISTS ${quoteIdent(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(${quoteIdent(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 ${quoteIdent(table)} ADD COLUMN machine_id TEXT DEFAULT ''`);
+    return;
+  }
+  const rows = target.all(`PRAGMA table_info(${quoteIdent(table)})`);
+  if (!rows.some((row) => row.name === "machine_id")) {
+    target.exec(`ALTER TABLE ${quoteIdent(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 ${quoteIdent(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(quoteIdent).join(", ");
+  const keyList = primaryKeys.map(quoteIdent).join(", ");
+  const setClause = updateColumns.length > 0 ? updateColumns.map((column) => `${quoteIdent(column)} = EXCLUDED.${quoteIdent(column)}`).join(", ") : `${quoteIdent(fallbackKey)} = EXCLUDED.${quoteIdent(fallbackKey)}`;
+  const whereClause = conflictColumn && updateColumns.includes(conflictColumn) ? ` WHERE ${quoteIdent(table)}.${quoteIdent(conflictColumn)} IS NULL OR EXCLUDED.${quoteIdent(conflictColumn)} >= ${quoteIdent(table)}.${quoteIdent(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 ${quoteIdent(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 ${quoteIdent(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(quoteIdent).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 ${quoteIdent(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 ${quoteIdent(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;
+}
+var init_storage_sync = __esm(() => {
+  init_remote_storage();
+});
+
 // src/db/pg-migrations.ts
 var exports_pg_migrations = {};
 __export(exports_pg_migrations, {
@@ -2093,6 +2518,9 @@ var init_pg_migrations = __esm(() => {
 });
 
 // src/lib/cloud-sync.ts
+import { existsSync as existsSync3, 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 join4 } from "path";
 function getCloudDatabaseUrl() {
   return process.env["ECONOMY_CLOUD_DATABASE_URL"] ?? process.env["HASNA_ECONOMY_CLOUD_DATABASE_URL"] ?? null;
 }
@@ -2111,7 +2539,6 @@ async function getCloudPg() {
   if (!url) {
     throw new Error("Missing ECONOMY_CLOUD_DATABASE_URL (or HASNA_ECONOMY_CLOUD_DATABASE_URL)");
   }
-  const { PgAdapterAsync } = await import("@hasna/cloud");
   return new PgAdapterAsync(url);
 }
 async function runCloudMigrations(cloud) {
@@ -2121,31 +2548,35 @@ async function runCloudMigrations(cloud) {
   }
 }
 async function cloudPush(opts) {
-  const { syncPush, SqliteAdapter } = await import("@hasna/cloud");
   const cloud = await getCloudPg();
-  const local = new SqliteAdapter(getDbPath());
-  await runCloudMigrations(cloud);
-  const tables = opts?.tables ?? [...CLOUD_TABLES];
-  const results = await syncPush(local, cloud, { tables, conflictColumn: "updated_at" });
-  const rows = results.reduce((s, r) => s + r.rowsWritten, 0);
-  touchMachineRegistry(local, "push");
-  local.close();
-  await cloud.close();
-  return { rows, machine: getMachineId() };
+  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 { syncPull, SqliteAdapter } = await import("@hasna/cloud");
   const cloud = await getCloudPg();
-  const local = new SqliteAdapter(getDbPath());
-  await runCloudMigrations(cloud);
-  const tables = opts?.tables ?? [...CLOUD_TABLES];
-  const results = await syncPull(cloud, local, { tables, conflictColumn: "updated_at" });
-  const rows = results.reduce((s, r) => s + r.rowsWritten, 0);
-  touchMachineRegistry(local, "pull");
-  local.close();
-  await cloud.close();
-  setLastCloudPull();
-  return { rows, machine: getMachineId() };
+  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();
@@ -2153,13 +2584,21 @@ async function cloudSyncFull() {
   return { push: push.rows, pull: pull.rows, machine: getMachineId() };
 }
 function setLastCloudPull(at = new Date().toISOString()) {
-  const db = openDatabase();
-  db.prepare(`INSERT OR REPLACE INTO ingest_state (source, key, value) VALUES ('cloud', 'last_pull_at', ?)`).run(at);
+  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();
-  const row = db.prepare(`SELECT value FROM ingest_state WHERE source = 'cloud' AND key = 'last_pull_at'`).get();
-  return row?.value ?? null;
+  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())
@@ -2205,22 +2644,231 @@ function touchMachineRegistry(db, direction) {
       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;
+}
 async function registerCloudSchedule(intervalMinutes) {
-  const { registerSyncSchedule } = await import("@hasna/cloud");
-  await registerSyncSchedule(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() {
-  const { removeSyncSchedule } = await import("@hasna/cloud");
-  await removeSyncSchedule();
+  if (platform() === "darwin")
+    await removeLaunchd();
+  if (platform() === "linux")
+    await removeSystemd();
+  try {
+    unlinkSync(SCHEDULE_CONFIG_PATH);
+  } catch {}
 }
 async function getCloudScheduleStatus() {
-  const { getSyncScheduleStatus } = await import("@hasna/cloud");
-  return getSyncScheduleStatus();
+  const mechanism = platform() === "darwin" ? "launchd" : platform() === "linux" ? "systemd" : "none";
+  const interval = readScheduleInterval();
+  const registered = mechanism === "launchd" ? existsSync3(getLaunchdPlistPath()) : mechanism === "systemd" ? existsSync3(join4(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 = [
+    join4(homedir2(), ".bun", "bin", "bun"),
+    "/opt/homebrew/bin/bun",
+    "/usr/local/bin/bun",
+    "/usr/bin/bun"
+  ];
+  return candidates.find((candidate) => existsSync3(candidate)) ?? "bun";
+}
+function getEconomySyncCommand() {
+  const dir = getModuleDir();
+  const candidates = [
+    join4(dir, "..", "cli", "index.js"),
+    join4(dir, "..", "cli", "index.ts")
+  ];
+  const cliPath = candidates.find((candidate) => existsSync3(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 join4(homedir2(), "Library", "LaunchAgents", "com.hasna.economy-cloud-sync.plist");
+}
+function createLaunchdPlist(intervalMinutes) {
+  const args = getEconomySyncCommand();
+  const env = scheduleEnvironment();
+  const stdout = join4(SCHEDULE_CONFIG_DIR, "cloud-sync.log");
+  const stderr = join4(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 {}
 }
-var CLOUD_TABLES;
+function shellArg(value) {
+  return /^[A-Za-z0-9_@%+=:,./-]+$/.test(value) ? value : `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function getSystemdDir() {
+  return join4(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(join4(dir, `${SCHEDULE_SERVICE_NAME}.service`), createSystemdService());
+  writeFileSync2(join4(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(join4(dir, `${SCHEDULE_SERVICE_NAME}.service`));
+  } catch {}
+  try {
+    unlinkSync(join4(dir, `${SCHEDULE_SERVICE_NAME}.timer`));
+  } catch {}
+  try {
+    await Bun.spawn(["systemctl", "--user", "daemon-reload"]).exited;
+  } catch {}
+}
+var CLOUD_TABLES, SCHEDULE_SERVICE_NAME = "hasna-economy-cloud-sync", SCHEDULE_CONFIG_DIR, SCHEDULE_CONFIG_PATH;
 var init_cloud_sync = __esm(() => {
   init_database();
   init_package_metadata();
+  init_remote_storage();
+  init_storage_sync();
   CLOUD_TABLES = [
     "requests",
     "sessions",
@@ -2235,6 +2883,8 @@ var init_cloud_sync = __esm(() => {
     "machines",
     "ingest_state"
   ];
+  SCHEDULE_CONFIG_DIR = join4(homedir2(), ".hasna", "economy");
+  SCHEDULE_CONFIG_PATH = join4(SCHEDULE_CONFIG_DIR, "cloud-sync-schedule.json");
 });
 
 // src/lib/serve-auth.ts
@@ -2404,27 +3054,27 @@ var init_agents = __esm(() => {
 });
 
 // src/lib/paths.ts
-import { homedir as homedir2 } from "os";
-import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+import { join as join5 } from "path";
 function getHomeDir() {
-  return process.env["USERPROFILE"] ?? process.env["HOME"] ?? homedir2();
+  return process.env["USERPROFILE"] ?? process.env["HOME"] ?? homedir3();
 }
 function agentPaths() {
   const home = getHomeDir();
   return {
-    claudeProjects: join4(home, ".claude", "projects"),
-    claudeCredentials: join4(home, ".claude", ".credentials.json"),
-    takumiProjects: join4(home, ".takumi", "projects"),
-    codexDir: join4(home, ".codex"),
-    codexDb: join4(home, ".codex", "state_5.sqlite"),
-    codexAuth: join4(home, ".codex", "auth.json"),
-    codexConfig: join4(home, ".codex", "config.toml"),
-    geminiTmp: join4(home, ".gemini", "tmp"),
-    geminiHistory: join4(home, ".gemini", "history"),
-    opencodeMessages: join4(home, ".local", "share", "opencode", "storage", "message"),
-    piSessions: join4(home, ".pi", "agent", "sessions"),
-    hermesDir: join4(home, ".hermes"),
-    hermesDb: join4(home, ".hermes", "state.db")
+    claudeProjects: join5(home, ".claude", "projects"),
+    claudeCredentials: join5(home, ".claude", ".credentials.json"),
+    takumiProjects: join5(home, ".takumi", "projects"),
+    codexDir: join5(home, ".codex"),
+    codexDb: join5(home, ".codex", "state_5.sqlite"),
+    codexAuth: join5(home, ".codex", "auth.json"),
+    codexConfig: join5(home, ".codex", "config.toml"),
+    geminiTmp: join5(home, ".gemini", "tmp"),
+    geminiHistory: join5(home, ".gemini", "history"),
+    opencodeMessages: join5(home, ".local", "share", "opencode", "storage", "message"),
+    piSessions: join5(home, ".pi", "agent", "sessions"),
+    hermesDir: join5(home, ".hermes"),
+    hermesDb: join5(home, ".hermes", "state.db")
   };
 }
 var init_paths = () => {};
@@ -2565,9 +3215,9 @@ var init_accounts = __esm(() => {
 });
 
 // src/ingest/claude.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync3, existsSync as existsSync4, statSync as statSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join6, basename } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync4, existsSync as existsSync5, statSync as statSync2 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join7, basename } from "path";
 function autoDetectProject(cwd, projects) {
   return projects.find((p) => cwd === p.path || cwd.startsWith(p.path + "/"));
 }
@@ -2580,9 +3230,9 @@ function collectJsonlFiles(projectDir) {
     try {
       for (const entry of readdirSync2(dir, { withFileTypes: true })) {
         if (entry.isDirectory())
-          walk(join6(dir, entry.name));
+          walk(join7(dir, entry.name));
         else if (entry.name.endsWith(".jsonl"))
-          files.push(join6(dir, entry.name));
+          files.push(join7(dir, entry.name));
       }
     } catch {}
   }
@@ -2596,7 +3246,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 (!existsSync4(projectsDir)) {
+  if (!existsSync5(projectsDir)) {
     if (verbose)
       console.log(`${agentName} projects dir not found:`, projectsDir);
     return { files: 0, requests: 0, sessions: 0 };
@@ -2609,7 +3259,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 = join6(projectsDir, projectDirEntry.name);
+    const projectDirPath = join7(projectsDir, projectDirEntry.name);
     const projectPath = dirNameToPath(projectDirEntry.name);
     const jsonlFiles = collectJsonlFiles(projectDirPath);
     for (const filePath of jsonlFiles) {
@@ -2625,7 +3275,7 @@ async function ingestJsonlProjects(db, projectsDir, agentName, verbose = false)
         continue;
       let lines;
       try {
-        lines = readFileSync3(filePath, "utf-8").split(`
+        lines = readFileSync4(filePath, "utf-8").split(`
 `).filter((l) => l.trim());
       } catch {
         continue;
@@ -2746,15 +3396,15 @@ var init_claude = __esm(() => {
   init_database();
   init_pricing();
   init_accounts();
-  CLAUDE_PROJECTS_DIR = join6(homedir3(), ".claude", "projects");
-  TAKUMI_PROJECTS_DIR = join6(homedir3(), ".takumi", "projects");
+  CLAUDE_PROJECTS_DIR = join7(homedir4(), ".claude", "projects");
+  TAKUMI_PROJECTS_DIR = join7(homedir4(), ".takumi", "projects");
 });
 
 // src/ingest/codex.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join7, basename as basename2 } from "path";
-import { Database as BunDatabase } from "bun:sqlite";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join8, basename as basename2 } from "path";
+import { Database as BunDatabase2 } from "bun:sqlite";
 function codexDbPath() {
   return process.env["HASNA_ECONOMY_CODEX_DB_PATH"] ?? DEFAULT_CODEX_DB_PATH;
 }
@@ -2763,10 +3413,10 @@ function codexConfigPath() {
 }
 function readCodexModel() {
   const configPath = codexConfigPath();
-  if (!existsSync5(configPath))
+  if (!existsSync6(configPath))
     return "gpt-5-codex";
   try {
-    const content = readFileSync4(configPath, "utf-8");
+    const content = readFileSync5(configPath, "utf-8");
     const match = content.match(/^model\s*=\s*"([^"]+)"/m);
     return match?.[1] ?? "gpt-5-codex";
   } catch {
@@ -2789,7 +3439,7 @@ function openCodexDb(dbPath, verbose) {
   for (const readonly of [true, false]) {
     let codexDb = null;
     try {
-      codexDb = readonly ? new BunDatabase(dbPath, { readonly: true }) : new BunDatabase(dbPath);
+      codexDb = readonly ? new BunDatabase2(dbPath, { readonly: true }) : new BunDatabase2(dbPath);
       codexDb.prepare("PRAGMA schema_version").get();
       return codexDb;
     } catch (error) {
@@ -2804,12 +3454,12 @@ function openCodexDb(dbPath, verbose) {
   return null;
 }
 function readTokenEvents(rolloutPath) {
-  if (!rolloutPath || !existsSync5(rolloutPath))
+  if (!rolloutPath || !existsSync6(rolloutPath))
     return [];
   const fallbackUsages = new Map;
   let fallbackTimestamp;
   let aggregate = null;
-  for (const line of readFileSync4(rolloutPath, "utf-8").split(`
+  for (const line of readFileSync5(rolloutPath, "utf-8").split(`
 `)) {
     if (!line.trim())
       continue;
@@ -2881,7 +3531,7 @@ function fallbackEvents(totalTokens) {
 }
 async function ingestCodex(db, verbose = false) {
   const dbPath = codexDbPath();
-  if (!existsSync5(dbPath)) {
+  if (!existsSync6(dbPath)) {
     if (verbose)
       console.log("Codex DB not found:", dbPath);
     return { sessions: 0, requests: 0 };
@@ -2966,14 +3616,14 @@ var init_codex = __esm(() => {
   init_database();
   init_pricing();
   init_accounts();
-  DEFAULT_CODEX_DB_PATH = join7(homedir4(), ".codex", "state_5.sqlite");
-  DEFAULT_CODEX_CONFIG_PATH = join7(homedir4(), ".codex", "config.toml");
+  DEFAULT_CODEX_DB_PATH = join8(homedir5(), ".codex", "state_5.sqlite");
+  DEFAULT_CODEX_CONFIG_PATH = join8(homedir5(), ".codex", "config.toml");
 });
 
 // src/ingest/gemini.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync5, existsSync as existsSync6, statSync as statSync3 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join8, basename as basename3 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync6, existsSync as existsSync7, statSync as statSync3 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join9, basename as basename3 } from "path";
 function geminiTmpDir() {
   return process.env["HASNA_ECONOMY_GEMINI_TMP_DIR"] ?? DEFAULT_GEMINI_TMP_DIR;
 }
@@ -2990,12 +3640,12 @@ function numberField(...values) {
 function listProjectDirs(...roots) {
   const dirs = new Set;
   for (const root of roots) {
-    if (!existsSync6(root))
+    if (!existsSync7(root))
       continue;
     try {
       for (const entry of readdirSync3(root, { withFileTypes: true })) {
         if (entry.isDirectory())
-          dirs.add(join8(root, entry.name));
+          dirs.add(join9(root, entry.name));
       }
     } catch {}
   }
@@ -3006,17 +3656,17 @@ function projectRoot(projectDir, chatData) {
     return chatData.projectPath;
   if (chatData.project_path)
     return chatData.project_path;
-  const rootFile = join8(projectDir, ".project_root");
+  const rootFile = join9(projectDir, ".project_root");
   try {
-    if (existsSync6(rootFile))
-      return readFileSync5(rootFile, "utf-8").trim();
+    if (existsSync7(rootFile))
+      return readFileSync6(rootFile, "utf-8").trim();
   } catch {}
   return "";
 }
 async function ingestGemini(db, verbose) {
   const tmpDir = geminiTmpDir();
   const historyDir = geminiHistoryDir();
-  if (!existsSync6(tmpDir) && !existsSync6(historyDir)) {
+  if (!existsSync7(tmpDir) && !existsSync7(historyDir)) {
     if (verbose)
       console.log("Gemini tmp/history dirs not found:", tmpDir, historyDir);
     return { sessions: 0, requests: 0 };
@@ -3028,17 +3678,17 @@ async function ingestGemini(db, verbose) {
   const account = await resolveAccountForAgent("gemini");
   const projectDirs = listProjectDirs(tmpDir, historyDir);
   for (const projectDir of projectDirs) {
-    const chatsDir = join8(projectDir, "chats");
-    if (!existsSync6(chatsDir))
+    const chatsDir = join9(projectDir, "chats");
+    if (!existsSync7(chatsDir))
       continue;
     let chatFiles = [];
     try {
-      chatFiles = readdirSync3(chatsDir).filter((f) => f.endsWith(".json")).map((f) => join8(chatsDir, f));
+      chatFiles = readdirSync3(chatsDir).filter((f) => f.endsWith(".json")).map((f) => join9(chatsDir, f));
     } catch {
       continue;
     }
     for (const filePath of chatFiles) {
-      const stateKey = filePath.replace(homedir5(), "~");
+      const stateKey = filePath.replace(homedir6(), "~");
       let fileMtime = "0";
       try {
         fileMtime = statSync3(filePath).mtimeMs.toString();
@@ -3050,7 +3700,7 @@ async function ingestGemini(db, verbose) {
         continue;
       let chatData;
       try {
-        chatData = JSON.parse(readFileSync5(filePath, "utf-8"));
+        chatData = JSON.parse(readFileSync6(filePath, "utf-8"));
       } catch {
         continue;
       }
@@ -3129,19 +3779,19 @@ var init_gemini = __esm(() => {
   init_database();
   init_pricing();
   init_accounts();
-  DEFAULT_GEMINI_TMP_DIR = join8(homedir5(), ".gemini", "tmp");
-  DEFAULT_GEMINI_HISTORY_DIR = join8(homedir5(), ".gemini", "history");
+  DEFAULT_GEMINI_TMP_DIR = join9(homedir6(), ".gemini", "tmp");
+  DEFAULT_GEMINI_HISTORY_DIR = join9(homedir6(), ".gemini", "history");
 });
 
 // src/ingest/opencode.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join9 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync7, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join10 } from "path";
 function walkJsonFiles(dir, acc = []) {
-  if (!existsSync7(dir))
+  if (!existsSync8(dir))
     return acc;
   for (const entry of readdirSync4(dir, { withFileTypes: true })) {
-    const p = join9(dir, entry.name);
+    const p = join10(dir, entry.name);
     if (entry.isDirectory())
       walkJsonFiles(p, acc);
     else if (entry.name.endsWith(".json"))
@@ -3161,7 +3811,7 @@ function parseSessionIdFromPath(filePath) {
   return null;
 }
 async function ingestOpenCode(db, verbose = false) {
-  const messageDir = join9(OPENCODE_STORAGE, "message");
+  const messageDir = join10(OPENCODE_STORAGE, "message");
   const files = walkJsonFiles(messageDir);
   let requests = 0;
   const touched = new Set;
@@ -3176,7 +3826,7 @@ async function ingestOpenCode(db, verbose = false) {
       continue;
     let parsed;
     try {
-      parsed = JSON.parse(readFileSync6(file, "utf-8"));
+      parsed = JSON.parse(readFileSync7(file, "utf-8"));
     } catch {
       continue;
     }
@@ -3244,7 +3894,7 @@ var init_opencode = __esm(() => {
   init_database();
   init_pricing();
   init_accounts();
-  OPENCODE_STORAGE = join9(homedir6(), ".local", "share", "opencode", "storage");
+  OPENCODE_STORAGE = join10(homedir7(), ".local", "share", "opencode", "storage");
 });
 
 // src/ingest/cursor.ts
@@ -3372,14 +4022,14 @@ var init_cursor = __esm(() => {
 });
 
 // src/ingest/pi.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7, readdirSync as readdirSync5, statSync as statSync5 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join10 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync8, readdirSync as readdirSync5, statSync as statSync5 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join11 } from "path";
 function walkSessions(dir, acc = []) {
-  if (!existsSync8(dir))
+  if (!existsSync9(dir))
     return acc;
   for (const entry of readdirSync5(dir, { withFileTypes: true })) {
-    const p = join10(dir, entry.name);
+    const p = join11(dir, entry.name);
     if (entry.isDirectory())
       walkSessions(p, acc);
     else if (entry.name.endsWith(".json"))
@@ -3401,7 +4051,7 @@ async function ingestPi(db, verbose = false) {
       continue;
     let data;
     try {
-      data = JSON.parse(readFileSync7(file, "utf-8"));
+      data = JSON.parse(readFileSync8(file, "utf-8"));
     } catch {
       continue;
     }
@@ -3466,13 +4116,13 @@ var PI_SESSION_DIR;
 var init_pi = __esm(() => {
   init_database();
   init_accounts();
-  PI_SESSION_DIR = process.env["PI_CODING_AGENT_SESSION_DIR"] ?? join10(homedir7(), ".pi", "agent", "sessions");
+  PI_SESSION_DIR = process.env["PI_CODING_AGENT_SESSION_DIR"] ?? join11(homedir8(), ".pi", "agent", "sessions");
 });
 
 // src/ingest/hermes.ts
-import { existsSync as existsSync9, statSync as statSync6 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join11 } from "path";
+import { existsSync as existsSync10, statSync as statSync6 } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join12 } from "path";
 function mapCostBasis(billingMode) {
   if (billingMode === "subscription")
     return "subscription_included";
@@ -3481,7 +4131,7 @@ function mapCostBasis(billingMode) {
   return defaultCostBasisForAgent("hermes");
 }
 async function ingestHermes(db, verbose = false) {
-  if (!existsSync9(HERMES_DB)) {
+  if (!existsSync10(HERMES_DB)) {
     return { sessions: 0, requests: 0 };
   }
   const { Database: Sqlite } = await import("bun:sqlite");
@@ -3561,19 +4211,19 @@ var HERMES_DB;
 var init_hermes = __esm(() => {
   init_database();
   init_accounts();
-  HERMES_DB = join11(homedir8(), ".hermes", "state.db");
+  HERMES_DB = join12(homedir9(), ".hermes", "state.db");
 });
 
 // src/ingest/claude-quota.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
 function readClaudeToken() {
   const fromEnv = process.env["CLAUDE_OAUTH_TOKEN"] ?? process.env["ANTHROPIC_OAUTH_TOKEN"];
   if (fromEnv)
     return { token: fromEnv };
-  if (!existsSync10(CREDENTIALS_PATH))
+  if (!existsSync11(CREDENTIALS_PATH))
     return null;
   try {
-    const creds = JSON.parse(readFileSync8(CREDENTIALS_PATH, "utf-8"));
+    const creds = JSON.parse(readFileSync9(CREDENTIALS_PATH, "utf-8"));
     const oauth = creds.claudeAiOauth;
     if (!oauth?.accessToken)
       return null;
@@ -3714,16 +4364,16 @@ var init_claude_quota = __esm(() => {
 });
 
 // src/ingest/codex-quota.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
 function readCodexAuth() {
   const fromEnv = process.env["CODEX_OAUTH_TOKEN"];
   if (fromEnv)
     return { token: fromEnv, authMode: "chatgpt" };
   const authPath = agentPaths().codexAuth;
-  if (!existsSync11(authPath))
+  if (!existsSync12(authPath))
     return null;
   try {
-    const auth = JSON.parse(readFileSync9(authPath, "utf-8"));
+    const auth = JSON.parse(readFileSync10(authPath, "utf-8"));
     const token = auth.tokens?.access_token;
     if (!token)
       return null;
@@ -3907,15 +4557,15 @@ __export(exports_billing, {
   syncGeminiBilling: () => syncGeminiBilling,
   syncAnthropicBilling: () => syncAnthropicBilling
 });
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 function getAnthropicAdminKey() {
-  return process.env["HASNAXYZ_ANTHROPIC_LIVE_ADMIN_API_KEY"] ?? process.env["ANTHROPIC_ADMIN_API_KEY"] ?? null;
+  return process.env["ANTHROPIC_ADMIN_API_KEY"] ?? null;
 }
 function getOpenAIAdminKey() {
-  return process.env["HASNAXYZ_OPENAI_LIVE_ADMIN_API_KEY"] ?? process.env["OPENAI_ADMIN_API_KEY"] ?? null;
+  return process.env["OPENAI_ADMIN_API_KEY"] ?? null;
 }
 function getGeminiBillingExportPath() {
-  return process.env["HASNA_ECONOMY_GEMINI_BILLING_EXPORT_PATH"] ?? process.env["HASNAXYZ_ECONOMY_GEMINI_BILLING_EXPORT_PATH"] ?? process.env["GEMINI_BILLING_EXPORT_PATH"] ?? null;
+  return process.env["HASNA_ECONOMY_GEMINI_BILLING_EXPORT_PATH"] ?? process.env["GEMINI_BILLING_EXPORT_PATH"] ?? null;
 }
 function toISODate(d) {
   return d.toISOString().substring(0, 10);
@@ -3991,7 +4641,7 @@ function parseBillingRows(content) {
 async function syncAnthropicBilling(db, opts = {}) {
   const key = getAnthropicAdminKey();
   if (!key)
-    throw new Error("Missing Anthropic admin key (HASNAXYZ_ANTHROPIC_LIVE_ADMIN_API_KEY)");
+    throw new Error("Missing Anthropic admin key (ANTHROPIC_ADMIN_API_KEY)");
   const now = new Date;
   const end = opts.toDate ? new Date(opts.toDate) : new Date(now.getTime() + 24 * 3600000);
   const days = opts.days ?? 31;
@@ -4040,7 +4690,7 @@ async function syncAnthropicBilling(db, opts = {}) {
 async function syncOpenAIBilling(db, opts = {}) {
   const key = getOpenAIAdminKey();
   if (!key)
-    throw new Error("Missing OpenAI admin key (HASNAXYZ_OPENAI_LIVE_ADMIN_API_KEY)");
+    throw new Error("Missing OpenAI admin key (OPENAI_ADMIN_API_KEY)");
   const now = new Date;
   const end = opts.toDate ? new Date(opts.toDate) : now;
   const days = opts.days ?? 31;
@@ -4092,7 +4742,7 @@ async function syncGeminiBilling(db, opts = {}) {
     return {
       days: 0,
       totalUsd: 0,
-      skipped: "Missing Gemini billing export path (HASNA_ECONOMY_GEMINI_BILLING_EXPORT_PATH, HASNAXYZ_ECONOMY_GEMINI_BILLING_EXPORT_PATH, or GEMINI_BILLING_EXPORT_PATH)"
+      skipped: "Missing Gemini billing export path (HASNA_ECONOMY_GEMINI_BILLING_EXPORT_PATH or GEMINI_BILLING_EXPORT_PATH)"
     };
   }
   const now = new Date;
@@ -4101,7 +4751,7 @@ async function syncGeminiBilling(db, opts = {}) {
   const start = opts.fromDate ? new Date(opts.fromDate) : new Date(end.getTime() - days * 24 * 3600000);
   const fromDateStr = toISODate(start);
   const toDateStr = toISODate(end);
-  const rows = parseBillingRows(readFileSync10(exportPath, "utf-8"));
+  const rows = parseBillingRows(readFileSync11(exportPath, "utf-8"));
   clearBillingRange(db, "gemini", fromDateStr, toDateStr);
   const updatedAt = new Date().toISOString();
   let totalUsd = 0;
@@ -4133,22 +4783,26 @@ __export(exports_open_projects, {
   syncOpenProjectsRegistry: () => syncOpenProjectsRegistry
 });
 async function syncOpenProjectsRegistry(db, listActiveProjects) {
-  let listProjects2 = listActiveProjects;
-  if (!listProjects2) {
+  let listOpenProjects = listActiveProjects;
+  if (!listOpenProjects) {
     const projectsApi = await import("@hasna/projects");
-    listProjects2 = projectsApi.listProjects;
+    listOpenProjects = projectsApi.listProjects ?? projectsApi.listWorkspaces;
+  }
+  if (!listOpenProjects) {
+    throw new Error("@hasna/projects does not expose listWorkspaces or listProjects");
   }
-  const projects = listProjects2({ status: "active", limit: 5000 });
+  const projects = listOpenProjects({ status: "active", limit: 5000 });
   let imported = 0;
   let skipped = 0;
   for (const project of projects) {
-    if (!project.path) {
+    const path = project.path ?? project.primary_path ?? "";
+    if (!path) {
       skipped++;
       continue;
     }
     upsertProject(db, {
       id: project.id,
-      path: project.path,
+      path,
       name: project.name,
       description: project.description,
       tags: project.tags ?? [],
@@ -4170,16 +4824,16 @@ __export(exports_config, {
   loadConfig: () => loadConfig2,
   getConfigValue: () => getConfigValue
 });
-import { existsSync as existsSync13, readFileSync as readFileSync11, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
-import { dirname as dirname2, join as join12 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync12, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "fs";
+import { dirname as dirname3, join as join13 } from "path";
 function getConfigPath() {
-  return process.env["HASNA_ECONOMY_CONFIG_PATH"] ?? join12(getDataDir(), "config.json");
+  return process.env["HASNA_ECONOMY_CONFIG_PATH"] ?? join13(getDataDir(), "config.json");
 }
 function loadConfig2() {
   try {
     const configPath = getConfigPath();
-    if (existsSync13(configPath)) {
-      const raw = readFileSync11(configPath, "utf-8");
+    if (existsSync14(configPath)) {
+      const raw = readFileSync12(configPath, "utf-8");
       return { ...DEFAULTS, ...JSON.parse(raw) };
     }
   } catch {}
@@ -4187,10 +4841,10 @@ function loadConfig2() {
 }
 function saveConfig2(config) {
   const configPath = getConfigPath();
-  const dir = dirname2(configPath);
-  if (!existsSync13(dir))
-    mkdirSync3(dir, { recursive: true });
-  writeFileSync2(configPath, JSON.stringify(config, null, 2) + `
+  const dir = dirname3(configPath);
+  if (!existsSync14(dir))
+    mkdirSync4(dir, { recursive: true });
+  writeFileSync3(configPath, JSON.stringify(config, null, 2) + `
 `);
 }
 function getConfigValue(key) {
@@ -4332,7 +4986,7 @@ var init_webhooks = __esm(() => {
 });
 
 // src/lib/watch-paths.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 function getWatchPaths() {
   const p = agentPaths();
   const candidates = [
@@ -4345,7 +4999,7 @@ function getWatchPaths() {
     p.piSessions,
     p.hermesDir
   ];
-  return candidates.filter((path) => existsSync14(path));
+  return candidates.filter((path) => existsSync15(path));
 }
 var init_watch_paths = __esm(() => {
   init_paths();
@@ -4515,7 +5169,7 @@ __export(exports_serve, {
   createHandler: () => createHandler
 });
 import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { resolve, sep } from "path";
 function json(data, status = 200) {
   return new Response(JSON.stringify(data), {
@@ -4580,13 +5234,13 @@ function createServerFetch(apiHandler, dashboardDir = DEFAULT_DASHBOARD_DIR) {
     if (url.pathname.startsWith("/api") || url.pathname === "/health") {
       return apiHandler(req);
     }
-    if (existsSync15(dashboardDir)) {
+    if (existsSync16(dashboardDir)) {
       const filePath = dashboardPath(dashboardDir, url.pathname);
-      if (filePath && existsSync15(filePath)) {
+      if (filePath && existsSync16(filePath)) {
         return new Response(Bun.file(filePath));
       }
       const indexPath = dashboardPath(dashboardDir, "/");
-      if (indexPath && existsSync15(indexPath)) {
+      if (indexPath && existsSync16(indexPath)) {
         return new Response(Bun.file(indexPath));
       }
     }
@@ -4634,7 +5288,16 @@ function createHandler(db) {
     }
     if (path === "/api/hourly" && method === "GET") {
       const machine = url.searchParams.get("machine") ?? undefined;
-      return ok(queryHourlyBreakdown(db, machine));
+      const rawHours = url.searchParams.get("hours");
+      let hours;
+      if (rawHours != null) {
+        const parsedHours = Number(rawHours);
+        if (!Number.isInteger(parsedHours) || parsedHours < 1 || parsedHours > 48) {
+          return err("hours must be between 1 and 48");
+        }
+        hours = parsedHours;
+      }
+      return ok(queryHourlyBreakdown(db, machine, hours));
     }
     if (path === "/api/sessions" && method === "GET") {
       const agent = url.searchParams.get("agent");
@@ -4992,14 +5655,14 @@ __export(exports_menubar, {
 });
 import chalk6 from "chalk";
 import { execFileSync as execFileSync2 } from "child_process";
-import { cpSync, existsSync as existsSync16, mkdirSync as mkdirSync4, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import { cpSync, existsSync as existsSync17, mkdirSync as mkdirSync5, rmSync, writeFileSync as writeFileSync4 } from "fs";
 import { tmpdir, arch } from "os";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 function getArch() {
   return arch() === "arm64" ? "arm64" : "x86_64";
 }
 function isInstalled() {
-  return existsSync16(APP_PATH);
+  return existsSync17(APP_PATH);
 }
 function isRunning() {
   try {
@@ -5036,15 +5699,15 @@ async function menubarInstall(opts) {
     console.error(chalk6.red(`\u2717 Failed to fetch release info: ${e instanceof Error ? e.message : String(e)}`));
     process.exit(1);
   }
-  const zipPath = join13(tmpdir(), `economy-bar-${cpuArch}.zip`);
-  const extractDir = join13(tmpdir(), "economy-bar-extracted");
+  const zipPath = join14(tmpdir(), `economy-bar-${cpuArch}.zip`);
+  const extractDir = join14(tmpdir(), "economy-bar-extracted");
   console.log(chalk6.cyan(`\u2192 Downloading ${assetUrl}...`));
   try {
     const res = await fetch(assetUrl, { signal: AbortSignal.timeout(60000) });
     if (!res.ok)
       throw new Error(`Download failed: ${res.status}`);
     const buffer = await res.arrayBuffer();
-    writeFileSync3(zipPath, Buffer.from(buffer));
+    writeFileSync4(zipPath, Buffer.from(buffer));
     console.log(chalk6.green(`\u2713 Downloaded (${(buffer.byteLength / 1024 / 1024).toFixed(1)} MB)`));
   } catch (e) {
     console.error(chalk6.red(`\u2717 Download failed: ${e instanceof Error ? e.message : String(e)}`));
@@ -5053,11 +5716,11 @@ async function menubarInstall(opts) {
   console.log(chalk6.cyan("\u2192 Installing to /Applications..."));
   try {
     rmSync(extractDir, { recursive: true, force: true });
-    mkdirSync4(extractDir, { recursive: true });
+    mkdirSync5(extractDir, { recursive: true });
     execFileSync2("unzip", ["-q", zipPath, "-d", extractDir], { stdio: "ignore" });
     if (isInstalled())
       rmSync(APP_PATH, { recursive: true, force: true });
-    cpSync(join13(extractDir, "Economy Bar.app"), APP_PATH, { recursive: true });
+    cpSync(join14(extractDir, "Economy Bar.app"), APP_PATH, { recursive: true });
     try {
       execFileSync2("xattr", ["-rd", "com.apple.quarantine", APP_PATH], { stdio: "ignore" });
     } catch {}
@@ -5855,7 +6518,7 @@ var ROADMAP_PHASES = [
   {
     id: "phase-9",
     title: "Multi-machine auto sync (4-machine fleet)",
-    summary: "Investigation: machine_id + listMachines + manual cloud push/pull exist; @hasna/cloud has incremental sync, conflict resolution, and launchd/systemd schedulers \u2014 but economy does not use them, requests/sessions lack updated_at, ingest is local-only, RDS is hardcoded, and default commands never pull before query.",
+    summary: "Investigation: machine_id + listMachines + manual cloud push/pull exist; the previous shared cloud package had incremental sync, conflict resolution, and launchd/systemd schedulers \u2014 but economy did not own them, requests/sessions lacked updated_at, ingest was local-only, RDS was hardcoded, and default commands never pulled before query.",
     tasks: [
       {
         id: "9.1",
@@ -5870,7 +6533,7 @@ var ROADMAP_PHASES = [
       },
       {
         id: "9.3",
-        title: "Switch cloud sync to @hasna/cloud incrementalSyncPush/Pull with _sync_meta (replace full table scans)",
+        title: "Switch cloud sync to repo-native incremental push/pull with _sync_meta (replace full table scans)",
         status: "done",
         deps: ["9.2"]
       },
@@ -5894,7 +6557,7 @@ var ROADMAP_PHASES = [
       },
       {
         id: "9.7",
-        title: "CLI economy cloud schedule install|status|remove \u2014 wrap @hasna/cloud registerSyncSchedule (launchd/systemd every 5\u201315m)",
+        title: "CLI economy cloud schedule install|status|remove \u2014 repo-native launchd/systemd scheduler every 5\u201315m",
         status: "done",
         deps: ["9.5"]
       },
@@ -6305,8 +6968,8 @@ init_agents();
 init_cloud_sync();
 import chalk4 from "chalk";
 import { randomUUID } from "crypto";
-import { existsSync as existsSync3 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { join as join6 } from "path";
 
 // src/cli/commands/completion.ts
 var TOP_LEVEL = [
@@ -6556,13 +7219,13 @@ function registerExtendedCommands(program) {
     const paths = [
       ["claude", agentPaths().claudeProjects],
       ["codex", agentPaths().codexDb],
-      ["gemini", join5(agentPaths().geminiTmp, "..")],
-      ["opencode", join5(agentPaths().opencodeMessages, "..", "..")],
+      ["gemini", join6(agentPaths().geminiTmp, "..")],
+      ["opencode", join6(agentPaths().opencodeMessages, "..", "..")],
       ["pi", agentPaths().piSessions],
       ["hermes", agentPaths().hermesDb]
     ];
     for (const [agent, path] of paths) {
-      checks.push({ ok: existsSync3(path), msg: `${agent}: ${existsSync3(path) ? path : "not found"}` });
+      checks.push({ ok: existsSync4(path), msg: `${agent}: ${existsSync4(path) ? path : "not found"}` });
     }
     checks.push({ ok: Boolean(process.env["CURSOR_SESSION_TOKEN"]), msg: `cursor token: ${process.env["CURSOR_SESSION_TOKEN"] ? "set" : "missing CURSOR_SESSION_TOKEN"}` });
     checks.push({ ok: Boolean(getCloudDatabaseUrl()), msg: `cloud: ${getCloudDatabaseUrl() ? "ECONOMY_CLOUD_DATABASE_URL set" : "not configured"}` });
@@ -6693,8 +7356,8 @@ init_cloud_sync();
 // src/lib/peer-sync.ts
 init_database();
 init_package_metadata();
-import { Database as BunDatabase2 } from "bun:sqlite";
-import { existsSync as existsSync12 } from "fs";
+import { Database as BunDatabase3 } from "bun:sqlite";
+import { existsSync as existsSync13 } from "fs";
 var GENERIC_PEER_TABLES = [
   "usage_snapshots",
   "subscriptions",
@@ -6705,7 +7368,7 @@ var GENERIC_PEER_TABLES = [
   "model_pricing",
   "machines"
 ];
-function quoteIdent(identifier) {
+function quoteIdent2(identifier) {
   return `"${identifier.replace(/"/g, '""')}"`;
 }
 function tableExists(db, table) {
@@ -6715,7 +7378,7 @@ function tableExists(db, table) {
 function tableColumns(db, table) {
   if (!tableExists(db, table))
     return [];
-  return db.prepare(`PRAGMA table_info(${quoteIdent(table)})`).all();
+  return db.prepare(`PRAGMA table_info(${quoteIdent2(table)})`).all();
 }
 function commonColumns(source, target, table) {
   const sourceCols = new Set(tableColumns(source, table).map((c) => c.name));
@@ -6727,19 +7390,19 @@ function primaryKeyColumns(db, table) {
 function selectRows(source, table, columns) {
   if (columns.length === 0)
     return [];
-  const select = columns.map(quoteIdent).join(", ");
-  return source.prepare(`SELECT ${select} FROM ${quoteIdent(table)}`).all();
+  const select = columns.map(quoteIdent2).join(", ");
+  return source.prepare(`SELECT ${select} FROM ${quoteIdent2(table)}`).all();
 }
 function rowByKey(target, table, keyColumns, row) {
   if (keyColumns.length === 0)
     return null;
   if (keyColumns.some((c) => row[c] == null))
     return null;
-  const where = keyColumns.map((c) => `${quoteIdent(c)} = ?`).join(" AND ");
-  return target.prepare(`SELECT * FROM ${quoteIdent(table)} WHERE ${where}`).get(...keyColumns.map((c) => row[c]));
+  const where = keyColumns.map((c) => `${quoteIdent2(c)} = ?`).join(" AND ");
+  return target.prepare(`SELECT * FROM ${quoteIdent2(table)} WHERE ${where}`).get(...keyColumns.map((c) => row[c]));
 }
 function hasId(target, table, id) {
-  return target.prepare(`SELECT id, machine_id FROM ${quoteIdent(table)} WHERE id = ?`).get(id);
+  return target.prepare(`SELECT id, machine_id FROM ${quoteIdent2(table)} WHERE id = ?`).get(id);
 }
 function shouldReplace(source, existing) {
   if (!existing)
@@ -6766,10 +7429,10 @@ function normalizeRow(row, columns, sourceMachine, now) {
   return next;
 }
 function insertOrReplace(target, table, columns, row) {
-  const colSql = columns.map(quoteIdent).join(", ");
+  const colSql = columns.map(quoteIdent2).join(", ");
   const placeholders = columns.map(() => "?").join(", ");
   target.prepare(`
-    INSERT OR REPLACE INTO ${quoteIdent(table)} (${colSql})
+    INSERT OR REPLACE INTO ${quoteIdent2(table)} (${colSql})
     VALUES (${placeholders})
   `).run(...columns.map((c) => row[c] ?? null));
 }
@@ -6883,7 +7546,7 @@ function detectSourceMachine(source, fallback) {
       continue;
     const rows = source.prepare(`
       SELECT machine_id, COUNT(*) as cnt
-      FROM ${quoteIdent(table)}
+      FROM ${quoteIdent2(table)}
       WHERE machine_id != '' AND machine_id IS NOT NULL
       GROUP BY machine_id
     `).all();
@@ -6920,13 +7583,13 @@ function ensureMachineRegistry(target, machine, now) {
 }
 function openSourceDatabase(path) {
   try {
-    return new BunDatabase2(path, { readonly: true });
+    return new BunDatabase3(path, { readonly: true });
   } catch {
-    return new BunDatabase2(path);
+    return new BunDatabase3(path);
   }
 }
 function mergePeerDatabase(target, sourcePath, opts = {}) {
-  if (!existsSync12(sourcePath))
+  if (!existsSync13(sourcePath))
     throw new Error(`source database does not exist: ${sourcePath}`);
   const source = openSourceDatabase(sourcePath);
   const now = opts.now ?? new Date().toISOString();
@@ -7789,8 +8452,8 @@ program.command("dashboard").description("Open the web dashboard (auto-starts se
   if (!serverRunning) {
     console.log(chalk7.cyan(`\u2192 Starting economy server on port ${port}...`));
     const { spawn } = await import("child_process");
-    const { resolve: resolve2, dirname: dirname3 } = await import("path");
-    const serveScript = resolve2(dirname3(process.argv[1]), "..", "server", "index.js");
+    const { resolve: resolve2, dirname: dirname4 } = await import("path");
+    const serveScript = resolve2(dirname4(process.argv[1]), "..", "server", "index.js");
     const child = spawn(process.execPath, [serveScript], {
       detached: true,
       stdio: "ignore",
@@ -7944,8 +8607,8 @@ program.command("export").description("Export data as CSV").option("--type <type
     }
   }
   if (opts.output) {
-    const { writeFileSync: writeFileSync4 } = await import("fs");
-    writeFileSync4(opts.output, csv);
+    const { writeFileSync: writeFileSync5 } = await import("fs");
+    writeFileSync5(opts.output, csv);
     console.log(chalk7.green(`\u2713 Exported to ${opts.output}`));
   } else {
     process.stdout.write(csv);