@hasna/economy 0.2.42 → 0.3.0

package/dist/mcp/index.js

@@ -21,8 +21,10 @@ var __require = import.meta.require;
 var exports_pricing = {};
 __export(exports_pricing, {
   normalizeModelName: () => normalizeModelName,
+  getPricingFromRows: () => getPricingFromRows,
   getPricingFromDb: () => getPricingFromDb,
   getPricing: () => getPricing,
+  estimateCostFromRows: () => estimateCostFromRows,
   ensurePricingSeeded: () => ensurePricingSeeded,
   computeCostFromDb: () => computeCostFromDb,
   computeCost: () => computeCost,
@@ -213,6 +215,25 @@ function computeCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens
     return 0;
   return computeCostWithPricing(model, pricing, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, cacheWrite1hTokens, cacheStorageTokenHours);
 }
+function getPricingFromRows(rows, model) {
+  if (isFreeModel(model))
+    return FREE_PRICING;
+  for (const key of modelLookupKeys(model)) {
+    const row = rows.find((r) => r.model === key);
+    if (row)
+      return modelPricingFromDbRow(row);
+  }
+  const match = bestModelMatch(model, rows.map((r) => [r.model, r]));
+  if (!match)
+    return null;
+  return modelPricingFromDbRow(match);
+}
+function estimateCostFromRows(rows, model, inputTokens, outputTokens, cacheReadTokens = 0, cacheWriteTokens = 0, cacheWrite1hTokens = 0, cacheStorageTokenHours = 0) {
+  const pricing = getPricingFromRows(rows, model) ?? getPricing(model);
+  if (!pricing)
+    return 0;
+  return computeCostWithPricing(model, pricing, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, cacheWrite1hTokens, cacheStorageTokenHours);
+}
 function computeCostWithPricing(model, pricing, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, cacheWrite1hTokens, cacheStorageTokenHours) {
   if (isFreeModel(model))
     return 0;
@@ -1371,6 +1392,148 @@ function queryAccountBreakdown(db, period = "all", machine) {
   result.sort((a, b) => b.cost_usd - a.cost_usd);
   return result;
 }
+function queryProjectBreakdownSince(db, since) {
+  return db.prepare(`
+    SELECT project_path, project_name,
+           COUNT(*) as sessions,
+           COALESCE(SUM(total_tokens), 0) as total_tokens,
+           COALESCE(SUM(request_count), 0) as requests,
+           COALESCE(SUM(total_cost_usd), 0) as cost_usd,
+           MAX(started_at) as last_active
+    FROM sessions WHERE started_at >= ?
+    GROUP BY project_path ORDER BY cost_usd DESC
+  `).all(since);
+}
+function queryAgentBreakdownSince(db, since) {
+  return db.prepare(`
+    SELECT agent,
+           COUNT(DISTINCT session_id) as sessions,
+           COUNT(*) as requests,
+           COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
+           COALESCE(SUM(cost_usd), 0) as api_equivalent_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'metered_api' THEN cost_usd ELSE 0 END), 0) as billable_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'subscription_included' THEN cost_usd ELSE 0 END), 0) as subscription_included_usd,
+           MAX(timestamp) as last_active
+    FROM requests
+    WHERE timestamp >= ?
+    GROUP BY agent
+    ORDER BY api_equivalent_usd DESC
+  `).all(since);
+}
+function queryModelBreakdownSince(db, since) {
+  return db.prepare(`
+    SELECT model, agent,
+           COUNT(*) as requests,
+           COALESCE(SUM(input_tokens), 0) as input_tokens,
+           COALESCE(SUM(output_tokens), 0) as output_tokens,
+           COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
+           COALESCE(SUM(cost_usd), 0) as cost_usd
+    FROM requests WHERE timestamp >= ?
+    GROUP BY model, agent ORDER BY cost_usd DESC
+  `).all(since);
+}
+function queryAccountBreakdownSince(db, since) {
+  return db.prepare(`
+    WITH request_rows AS (
+      SELECT
+        r.session_id as session_id,
+        COALESCE(NULLIF(r.agent, ''), NULLIF(s.agent, ''), NULLIF(r.account_tool, ''), NULLIF(s.account_tool, ''), 'unknown') as account_agent,
+        COALESCE(NULLIF(r.account_key, ''), NULLIF(s.account_key, ''), '') as raw_account_key,
+        COALESCE(NULLIF(r.account_name, ''), NULLIF(s.account_name, ''), '') as raw_account_name,
+        LOWER(TRIM(COALESCE(NULLIF(r.account_email, ''), NULLIF(s.account_email, ''), ''))) as raw_account_email,
+        COALESCE(NULLIF(r.account_source, ''), NULLIF(s.account_source, ''), 'unknown') as account_source,
+        1 as requests,
+        COALESCE(r.input_tokens + r.output_tokens + r.cache_read_tokens + r.cache_create_tokens, 0) as total_tokens,
+        COALESCE(r.cost_usd, 0) as cost_usd,
+        COALESCE(NULLIF(r.cost_basis, ''), 'estimated') as cost_basis,
+        r.timestamp as last_active
+      FROM requests r
+      LEFT JOIN sessions s ON s.id = r.session_id
+      WHERE r.timestamp >= ?
+        AND (
+          COALESCE(NULLIF(r.account_key, ''), NULLIF(s.account_key, ''), '') != ''
+          OR COALESCE(NULLIF(r.account_tool, ''), NULLIF(s.account_tool, ''), '') != ''
+          OR COALESCE(NULLIF(r.account_name, ''), NULLIF(s.account_name, ''), '') != ''
+          OR COALESCE(NULLIF(r.account_email, ''), NULLIF(s.account_email, ''), '') != ''
+        )
+    ),
+    session_only_rows AS (
+      SELECT
+        s.id as session_id,
+        COALESCE(NULLIF(s.agent, ''), NULLIF(s.account_tool, ''), 'unknown') as account_agent,
+        s.account_key as raw_account_key,
+        s.account_name as raw_account_name,
+        LOWER(TRIM(COALESCE(s.account_email, ''))) as raw_account_email,
+        COALESCE(NULLIF(s.account_source, ''), 'unknown') as account_source,
+        COALESCE(s.request_count, 0) as requests,
+        COALESCE(s.total_tokens, 0) as total_tokens,
+        COALESCE(s.total_cost_usd, 0) as cost_usd,
+        'estimated' as cost_basis,
+        s.started_at as last_active
+      FROM sessions s
+      WHERE s.started_at >= ?
+        AND s.id NOT IN (SELECT DISTINCT session_id FROM requests)
+        AND (s.account_key != '' OR s.account_tool != '' OR s.account_name != '' OR s.account_email != '')
+    ),
+    normalized AS (
+      SELECT
+        CASE
+          WHEN raw_account_email != '' THEN account_agent || ':' || raw_account_email
+          WHEN raw_account_name != '' THEN account_agent || ':' || raw_account_name
+          ELSE raw_account_key
+        END as account_key,
+        account_agent as account_tool,
+        raw_account_name as account_name,
+        raw_account_email as account_email,
+        account_source,
+        session_id,
+        requests,
+        total_tokens,
+        cost_usd,
+        cost_basis,
+        last_active
+      FROM request_rows
+      UNION ALL
+      SELECT
+        CASE
+          WHEN raw_account_email != '' THEN account_agent || ':' || raw_account_email
+          WHEN raw_account_name != '' THEN account_agent || ':' || raw_account_name
+          ELSE raw_account_key
+        END as account_key,
+        account_agent as account_tool,
+        raw_account_name as account_name,
+        raw_account_email as account_email,
+        account_source,
+        session_id,
+        requests,
+        total_tokens,
+        cost_usd,
+        cost_basis,
+        last_active
+      FROM session_only_rows
+    )
+    SELECT account_key,
+           account_tool,
+           COALESCE(MAX(NULLIF(account_name, '')), MAX(NULLIF(account_email, '')), account_key) as account_name,
+           NULLIF(account_email, '') as account_email,
+           COALESCE(MAX(NULLIF(account_source, 'unknown')), 'unknown') as account_source,
+           COUNT(DISTINCT session_id) as sessions,
+           COALESCE(SUM(requests), 0) as requests,
+           COALESCE(SUM(total_tokens), 0) as total_tokens,
+           COALESCE(SUM(cost_usd), 0) as api_equivalent_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'metered_api' THEN cost_usd ELSE 0 END), 0) as billable_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'metered_api' THEN cost_usd ELSE 0 END), 0) as metered_api_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'subscription_included' THEN cost_usd ELSE 0 END), 0) as subscription_included_usd,
+           COALESCE(SUM(CASE WHEN cost_basis NOT IN ('metered_api', 'subscription_included', 'unknown') THEN cost_usd ELSE 0 END), 0) as estimated_usd,
+           COALESCE(SUM(CASE WHEN cost_basis = 'unknown' THEN cost_usd ELSE 0 END), 0) as unknown_usd,
+           COALESCE(SUM(cost_usd), 0) as cost_usd,
+           MAX(last_active) as last_active
+    FROM normalized
+    WHERE account_key != ''
+    GROUP BY account_key, account_tool, account_email
+    ORDER BY api_equivalent_usd DESC
+  `).all(since, since);
+}
 function queryDailyBreakdown(db, days = 30, machine) {
   const machineClause = machine ? " AND machine_id = ?" : "";
   const params = machine ? [`-${days}`, machine] : [`-${days}`];
@@ -1382,6 +1545,21 @@ function queryDailyBreakdown(db, days = 30, machine) {
     ORDER BY date ASC
   `).all(...params);
 }
+function upsertProject(db, project) {
+  db.prepare(`
+    INSERT OR REPLACE INTO projects (id, path, name, description, tags, created_at)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(project.id, project.path, project.name, project.description ?? null, JSON.stringify(project.tags), project.created_at);
+}
+function getProject(db, path) {
+  const row = db.prepare(`SELECT * FROM projects WHERE path = ?`).get(path);
+  if (!row)
+    return null;
+  return { ...row, tags: JSON.parse(row["tags"] ?? "[]") };
+}
+function deleteProject(db, path) {
+  db.prepare(`DELETE FROM projects WHERE path = ?`).run(path);
+}
 function upsertBudget(db, budget) {
   db.prepare(`
     INSERT OR REPLACE INTO budgets
@@ -1468,6 +1646,9 @@ function getIngestState(db, source, key) {
 function setIngestState(db, source, key, value) {
   db.prepare(`INSERT OR REPLACE INTO ingest_state (source, key, value) VALUES (?, ?, ?)`).run(source, key, value);
 }
+function queryRequestsSince(db, since) {
+  return db.prepare(`SELECT * FROM requests WHERE timestamp > ? ORDER BY timestamp ASC`).all(since);
+}
 function queryBillingSummary(db, period) {
   const where = period === "today" ? `date = DATE('now')` : period === "yesterday" ? `date = DATE('now', '-1 day')` : period === "week" ? `date >= DATE('now', 'weekday 0', '-7 days')` : period === "month" ? `date >= DATE('now', 'start of month')` : period === "year" ? `date >= DATE('now', 'start of year')` : "1=1";
   const rows = db.prepare(`SELECT provider, SUM(cost_usd) as cost FROM billing_daily WHERE ${where} GROUP BY provider`).all();
@@ -1479,6 +1660,13 @@ function queryBillingSummary(db, period) {
   }
   return { total_usd: total, by_provider };
 }
+function getSessionDetail(db, id) {
+  const session = db.prepare(`SELECT * FROM sessions WHERE id = ? OR id LIKE ?`).get(id, `${id}%`);
+  if (!session)
+    return null;
+  const requests = db.prepare(`SELECT * FROM requests WHERE session_id = ? ORDER BY timestamp ASC`).all(session["id"]);
+  return { session, requests };
+}
 function listMachines(db, period = "all") {
   const rWhere = requestPeriodWhere(period);
   const sWhere = sessionPeriodWhere(period);
@@ -1597,6 +1785,9 @@ function queryUsageSnapshots(db, opts = {}) {
   const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
   return db.prepare(`SELECT * FROM usage_snapshots ${where} ORDER BY date DESC, agent, metric`).all(...params);
 }
+function listMachineRegistry(db) {
+  return db.prepare(`SELECT * FROM machines ORDER BY last_seen_at DESC`).all();
+}
 function dedupeRequests(db) {
   const dupes = db.prepare(`
     SELECT source_request_id, agent, COALESCE(machine_id, '') as machine_id, MIN(id) as keep_id, COUNT(*) as cnt
@@ -1620,194 +1811,6 @@ function dedupeRequests(db) {
 }
 var init_database = () => {};
 
-// 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)`
-  ];
-});
-
 // src/mcp/index.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
@@ -1829,9 +1832,9 @@ var packageMetadata = getPackageMetadata();
 
 // src/mcp/server.ts
 init_database();
-import { randomUUID } from "crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { registerCloudTools } from "@hasna/cloud";
+import { registerAgentTools } from "@hasna/agent-registry";
 import { z } from "zod";
 
 // src/ingest/claude.ts
@@ -3446,139 +3449,10 @@ async function ingestCodexQuota(db, verbose = false) {
 
 // src/lib/sync-all.ts
 init_database();
-
-// src/lib/cloud-sync.ts
-init_database();
-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)");
-  }
-  const { PgAdapterAsync } = await import("@hasna/cloud");
-  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);
-  }
-}
-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() };
-}
-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() };
-}
-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);
-}
-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;
-}
-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);
-}
-
-// src/lib/sync-all.ts
 async function syncAll(db, opts = {}) {
   const anySpecific = Boolean(opts.claude || opts.takumi || opts.codex || opts.gemini || opts.opencode || opts.cursor || opts.pi || opts.hermes);
   const all = !anySpecific;
-  const useCloud = opts.cloud !== false;
-  if (useCloud)
-    await maybePullFromCloud();
-  const result = { deduped: 0, cloudPulled: false, cloudPushed: false };
+  const result = { deduped: 0 };
   if (all || opts.claude) {
     result.claude = await ingestClaude(db, opts.verbose);
     result.claudeQuota = await ingestClaudeQuota(db, opts.verbose);
@@ -3601,8 +3475,6 @@ async function syncAll(db, opts = {}) {
     result.hermes = await ingestHermes(db, opts.verbose);
   if (opts.dedupe !== false)
     result.deduped = dedupeRequests(db);
-  if (useCloud)
-    result.cloudPushed = await maybePushAfterIngest();
   return result;
 }
 
@@ -3619,7 +3491,73 @@ var AGENTS = [
 ];
 
 // src/mcp/server.ts
+init_pricing();
+
+// src/lib/store/index.ts
+init_database();
+init_pricing();
+import { randomUUID } from "crypto";
+
+// src/lib/billing-diff.ts
 init_database();
+var PROVIDER_TO_AGENT = {
+  anthropic: "claude",
+  openai: "codex",
+  gemini: "gemini",
+  google: "gemini"
+};
+function queryBillingDiff(db, period, thresholdPct = 15) {
+  const estimated = querySummary(db, period, undefined, true);
+  const actual = queryBillingSummary(db, period);
+  const delta = estimated.total_usd - actual.total_usd;
+  const deltaPct = actual.total_usd > 0 ? delta / actual.total_usd * 100 : 0;
+  const agentRows = db.prepare(`
+    SELECT agent, COALESCE(SUM(cost_usd), 0) as estimated_usd
+    FROM requests
+    WHERE ${periodWhere3(period, "timestamp")}
+    GROUP BY agent
+  `).all();
+  const by_agent = agentRows.map((row) => {
+    const provider = Object.entries(PROVIDER_TO_AGENT).find(([, a]) => a === row.agent)?.[0];
+    const actualUsd = provider ? actual.by_provider[provider] ?? 0 : 0;
+    const rowDelta = row.estimated_usd - actualUsd;
+    const rowPct = actualUsd > 0 ? rowDelta / actualUsd * 100 : 0;
+    return {
+      agent: row.agent,
+      estimated_usd: row.estimated_usd,
+      actual_usd: actualUsd,
+      delta_usd: rowDelta,
+      delta_pct: rowPct
+    };
+  }).sort((a, b) => Math.abs(b.delta_usd) - Math.abs(a.delta_usd));
+  return {
+    period,
+    estimated_usd: estimated.total_usd,
+    actual_usd: actual.total_usd,
+    delta_usd: delta,
+    delta_pct: deltaPct,
+    threshold_pct: thresholdPct,
+    is_alert: Math.abs(deltaPct) > thresholdPct,
+    by_agent,
+    by_provider: actual.by_provider
+  };
+}
+function periodWhere3(period, column) {
+  switch (period) {
+    case "today":
+      return `DATE(${column}) = DATE('now')`;
+    case "yesterday":
+      return `DATE(${column}) = DATE('now', '-1 day')`;
+    case "week":
+      return `${column} >= DATE('now', 'weekday 0', '-7 days')`;
+    case "month":
+      return `${column} >= DATE('now', 'start of month')`;
+    case "year":
+      return `${column} >= DATE('now', 'start of year')`;
+    case "all":
+      return "1=1";
+  }
+}
 
 // src/lib/periods.ts
 function ymd(date) {
@@ -3649,110 +3587,1631 @@ function usageSnapshotFilterForPeriod(period) {
   }
 }
 
-// src/mcp/server.ts
-init_pricing();
-init_pricing();
-var MCP_NAME = "economy";
-var DEFAULT_MCP_HTTP_PORT = 8860;
-function buildServer() {
-  const db = openDatabase();
-  ensurePricingSeeded(db);
-  const server = new McpServer({
-    name: MCP_NAME,
-    version: packageMetadata.version
-  });
-  const _econAgents = new Map;
-  const TOOL_NAMES = [
-    "get_cost_summary",
-    "get_sessions",
-    "get_top_sessions",
-    "get_model_breakdown",
-    "get_project_breakdown",
-    "get_agent_breakdown",
-    "get_account_breakdown",
-    "get_budget_status",
-    "set_budget",
-    "remove_budget",
-    "get_pricing",
-    "set_pricing",
-    "remove_pricing",
-    "get_daily",
-    "get_billing_summary",
-    "get_session_detail",
-    "get_usage",
-    "get_savings",
-    "list_subscriptions",
-    "set_subscription",
-    "remove_subscription",
-    "sync",
-    "search_tools",
-    "describe_tools",
-    "get_goals",
-    "set_goal",
-    "remove_goal",
-    "list_machines",
-    "register_agent",
-    "heartbeat",
-    "set_focus",
-    "list_agents",
-    "send_feedback"
-  ];
-  const TOOL_DESCRIPTIONS = {
-    get_cost_summary: "period(today|week|month|year|all), machine?(hostname) -> {total_usd, sessions, requests, tokens, summary}",
-    get_sessions: `agent(${AGENTS.join("|")}), project(partial), account?(key/name/email), machine?(hostname), limit(20) -> compact session table`,
-    get_top_sessions: `n(10), agent(${AGENTS.join("|")}) -> top sessions by cost`,
-    list_machines: "no params -> machine_id, sessions, requests, cost, last_active",
-    get_model_breakdown: "no params -> model, requests, tokens, cost",
-    get_project_breakdown: "period?(today|week|month|year|all) -> project_name, sessions, tokens, cost",
-    get_agent_breakdown: "period?(today|week|month|year|all) -> agent, sessions, requests, tokens, api-equivalent, billable, included",
-    get_account_breakdown: "period?(today|week|month|year|all) -> account profile, sessions, requests, tokens, api-equivalent, billable, included",
-    get_budget_status: "no params -> budget limits, current spend, percent_used, is_over_alert",
-    set_budget: "period(daily|weekly|monthly), limit_usd, project_path?, agent?, alert_at_percent? -> create budget",
-    remove_budget: "id -> delete budget",
-    get_pricing: "no params -> model pricing rows with input, output, cache read/write, and cache storage rates",
-    set_pricing: "model, input_per_1m, output_per_1m, cache_read_per_1m?, cache_write_per_1m?, cache_write_1h_per_1m?, cache_storage_per_1m_hour? -> create/update pricing",
-    remove_pricing: "model -> delete pricing row",
-    get_daily: "days(30) -> daily cost table grouped by date and agent",
-    get_billing_summary: "period(today|yesterday|week|month|year|all) -> actual provider billing totals",
-    get_session_detail: "session_id(prefix ok) -> per-request breakdown with model, tokens, cost",
-    get_usage: `period(today|week|month|year|all), agent?(${AGENTS.join("|")}) -> usage snapshots and all-machine summary`,
-    get_savings: `period(today|week|month|year|all), agent?(${AGENTS.join("|")}) -> subscription/API-equivalent savings`,
-    list_subscriptions: "no params -> configured subscription plans and included usage",
-    set_subscription: `provider, plan, monthly_fee_usd?, included_usage_usd?, agent?(${AGENTS.join("|")}) -> create/update subscription plan`,
-    remove_subscription: "id -> delete subscription plan",
-    sync: `sources(all|${AGENTS.join("|")}) -> ingest latest cost data`,
-    search_tools: "query substring -> tool name list",
-    describe_tools: "names[] -> one-line parameter hints",
-    get_goals: "no params -> goal progress summary",
-    set_goal: "period(day|week|month|year), limit_usd, project_path?, agent? -> create goal",
-    remove_goal: "id -> delete goal",
-    register_agent: "name, session_id? -> register agent session",
-    heartbeat: "agent_id -> update last_seen_at",
-    set_focus: "agent_id, project_id? -> set active project context",
-    list_agents: "no params -> registered agent list",
-    send_feedback: "message, email?, category? -> save feedback locally"
+// src/lib/brief.ts
+init_database();
+var ZERO_REQUEST_TOTALS = {
+  sessions: 0,
+  request_sessions: 0,
+  requests: 0,
+  input_tokens: 0,
+  output_tokens: 0,
+  cache_read_tokens: 0,
+  cache_create_tokens: 0,
+  cache_create_5m_tokens: 0,
+  cache_create_1h_tokens: 0,
+  total_tokens: 0,
+  cost_usd: 0,
+  last_active: null
+};
+var ZERO_SESSION_TOTALS = {
+  sessions: 0,
+  requests: 0,
+  total_tokens: 0,
+  cost_usd: 0,
+  last_active: null
+};
+function formatAge(timestamp, now) {
+  if (!timestamp)
+    return "never";
+  const t = new Date(timestamp).getTime();
+  if (!Number.isFinite(t))
+    return "unknown";
+  const ageMs = Math.max(0, now.getTime() - t);
+  const minutes = Math.floor(ageMs / 60000);
+  if (minutes < 1)
+    return "<1m";
+  if (minutes < 60)
+    return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 48)
+    return `${hours}h`;
+  return `${Math.floor(hours / 24)}d`;
+}
+function machineFilter(machine) {
+  if (!machine || machine === "all")
+    return;
+  return machine;
+}
+function requestPeriodWhere2(period) {
+  if (period === "today")
+    return `DATE(timestamp) = DATE('now')`;
+  return `timestamp >= DATE('now', 'weekday 0', '-7 days')`;
+}
+function sessionPeriodWhere2(period) {
+  if (period === "today")
+    return `DATE(started_at) = DATE('now')`;
+  return `started_at >= DATE('now', 'weekday 0', '-7 days')`;
+}
+function baseRequestTotals(row) {
+  return {
+    ...ZERO_REQUEST_TOTALS,
+    ...row,
+    sessions: Number(row?.request_sessions ?? row?.sessions ?? 0),
+    request_sessions: Number(row?.request_sessions ?? row?.sessions ?? 0),
+    requests: Number(row?.requests ?? 0),
+    input_tokens: Number(row?.input_tokens ?? 0),
+    output_tokens: Number(row?.output_tokens ?? 0),
+    cache_read_tokens: Number(row?.cache_read_tokens ?? 0),
+    cache_create_tokens: Number(row?.cache_create_tokens ?? 0),
+    cache_create_5m_tokens: Number(row?.cache_create_5m_tokens ?? 0),
+    cache_create_1h_tokens: Number(row?.cache_create_1h_tokens ?? 0),
+    total_tokens: Number(row?.total_tokens ?? 0),
+    cost_usd: Number(row?.cost_usd ?? 0),
+    last_active: row?.last_active ?? null
   };
-  const fmtUsd = (n) => "$" + n.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 });
-  const fmtTok = (n) => n >= 1e9 ? `${(n / 1e9).toFixed(1)}B` : n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n);
-  function fmtSession(s) {
-    const id = String(s["id"] ?? "").slice(0, 8);
-    const agent = String(s["agent"] ?? "");
-    const proj = String(s["project_name"] || s["project_path"] || "\u2014").slice(0, 20);
-    const cost = fmtUsd(Number(s["total_cost_usd"] ?? 0));
-    const tok = fmtTok(Number(s["total_tokens"] ?? 0));
-    return `${id} ${agent.padEnd(6)} ${cost.padEnd(10)} ${tok.padEnd(8)} ${proj}`;
-  }
-  function text(text2) {
-    return { content: [{ type: "text", text: text2 }] };
-  }
-  function textError(message) {
-    return { content: [{ type: "text", text: message }], isError: true };
+}
+function baseSessionTotals(row) {
+  return {
+    sessions: Number(row?.sessions ?? 0),
+    requests: Number(row?.requests ?? 0),
+    total_tokens: Number(row?.total_tokens ?? 0),
+    cost_usd: Number(row?.cost_usd ?? 0),
+    last_active: row?.last_active ?? null
+  };
+}
+function latestTimestamp(...values) {
+  return values.filter(Boolean).sort().at(-1) ?? null;
+}
+function combineTotals(requests, sessions) {
+  return {
+    sessions: requests.request_sessions + sessions.sessions,
+    requests: requests.requests + sessions.requests,
+    input_tokens: requests.input_tokens,
+    output_tokens: requests.output_tokens,
+    cache_read_tokens: requests.cache_read_tokens,
+    cache_create_tokens: requests.cache_create_tokens,
+    cache_create_5m_tokens: requests.cache_create_5m_tokens,
+    cache_create_1h_tokens: requests.cache_create_1h_tokens,
+    total_tokens: requests.total_tokens + sessions.total_tokens,
+    cost_usd: requests.cost_usd + sessions.cost_usd,
+    last_active: latestTimestamp(requests.last_active, sessions.last_active)
+  };
+}
+function emptyTotals() {
+  return combineTotals(ZERO_REQUEST_TOTALS, ZERO_SESSION_TOTALS);
+}
+function requestTotalsSql(where, machine) {
+  const params = [];
+  let machineClause = "";
+  if (machine) {
+    machineClause = " AND machine_id = ?";
+    params.push(machine);
   }
-  server.tool("search_tools", "List tool names matching query. Use first to find relevant tools.", { query: z.string().optional() }, async ({ query }) => {
-    const q = query?.toLowerCase();
-    const matches = q ? TOOL_NAMES.filter((name) => name.includes(q)) : [...TOOL_NAMES];
-    return text(matches.join(", "));
-  });
+  return {
+    sql: `
+      SELECT
+        COUNT(DISTINCT session_id) as request_sessions,
+        COUNT(*) as requests,
+        COALESCE(SUM(input_tokens), 0) as input_tokens,
+        COALESCE(SUM(output_tokens), 0) as output_tokens,
+        COALESCE(SUM(cache_read_tokens), 0) as cache_read_tokens,
+        COALESCE(SUM(cache_create_tokens), 0) as cache_create_tokens,
+        COALESCE(SUM(COALESCE(cache_create_5m_tokens, cache_create_tokens)), 0) as cache_create_5m_tokens,
+        COALESCE(SUM(COALESCE(cache_create_1h_tokens, 0)), 0) as cache_create_1h_tokens,
+        COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
+        COALESCE(SUM(cost_usd), 0) as cost_usd,
+        MAX(timestamp) as last_active
+      FROM requests
+      WHERE ${where}${machineClause}
+    `,
+    params
+  };
+}
+function sessionOnlyTotalsSql(where, machine) {
+  const params = [];
+  let machineClause = "";
+  if (machine) {
+    machineClause = " AND machine_id = ?";
+    params.push(machine);
+  }
+  return {
+    sql: `
+      SELECT
+        COUNT(*) as sessions,
+        COALESCE(SUM(request_count), 0) as requests,
+        COALESCE(SUM(total_tokens), 0) as total_tokens,
+        COALESCE(SUM(total_cost_usd), 0) as cost_usd,
+        MAX(started_at) as last_active
+      FROM sessions
+      WHERE ${where}${machineClause}
+        AND NOT EXISTS (SELECT 1 FROM requests r WHERE r.session_id = sessions.id)
+    `,
+    params
+  };
+}
+function queryRequestTotals(db, where, params, machine) {
+  const q = requestTotalsSql(where, machine);
+  return baseRequestTotals(db.prepare(q.sql).get(...params, ...q.params));
+}
+function querySessionOnlyTotals(db, where, params, machine) {
+  const q = sessionOnlyTotalsSql(where, machine);
+  return baseSessionTotals(db.prepare(q.sql).get(...params, ...q.params));
+}
+function queryPeriodTotals(db, period, machine) {
+  const summary = querySummary(db, period, machine);
+  const requests = queryRequestTotals(db, requestPeriodWhere2(period), [], machine);
+  const sessions = querySessionOnlyTotals(db, sessionPeriodWhere2(period), [], machine);
+  const totals = combineTotals(requests, sessions);
+  return {
+    ...totals,
+    sessions: summary.sessions,
+    requests: summary.requests,
+    total_tokens: summary.tokens,
+    cost_usd: summary.total_usd
+  };
+}
+function querySinceTotals(db, since, machine) {
+  const requests = queryRequestTotals(db, "timestamp >= ?", [since], machine);
+  const sessions = querySessionOnlyTotals(db, "started_at >= ?", [since], machine);
+  return combineTotals(requests, sessions);
+}
+function parseSinceDate(input, now) {
+  const value = input.trim();
+  const match = value.match(/^(\d+(?:\.\d+)?)(m|h|d|w)$/i);
+  if (match) {
+    const amount = Number(match[1]);
+    const unit = match[2].toLowerCase();
+    const multiplier = unit === "m" ? 60000 : unit === "h" ? 60 * 60000 : unit === "d" ? 24 * 60 * 60000 : 7 * 24 * 60 * 60000;
+    return {
+      timestamp: new Date(now.getTime() - amount * multiplier).toISOString(),
+      label: value
+    };
+  }
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) {
+    throw new Error("--since must be a duration like 24h, 7d, 30m, 2w, or an ISO date");
+  }
+  return { timestamp: parsed.toISOString(), label: value };
+}
+function queryMachineSinceRows(db, since, machine) {
+  const knownMachines = new Set;
+  for (const m of listMachines(db, "all")) {
+    if (m.machine_id)
+      knownMachines.add(m.machine_id);
+  }
+  for (const m of listMachineRegistry(db)) {
+    if (m.machine_id)
+      knownMachines.add(m.machine_id);
+  }
+  if (machine)
+    knownMachines.add(machine);
+  const requestMachineClause = machine ? " AND machine_id = ?" : "";
+  const requestRows = db.prepare(`
+    SELECT
+      machine_id,
+      COUNT(DISTINCT session_id) as request_sessions,
+      COUNT(*) as requests,
+      COALESCE(SUM(input_tokens), 0) as input_tokens,
+      COALESCE(SUM(output_tokens), 0) as output_tokens,
+      COALESCE(SUM(cache_read_tokens), 0) as cache_read_tokens,
+      COALESCE(SUM(cache_create_tokens), 0) as cache_create_tokens,
+      COALESCE(SUM(COALESCE(cache_create_5m_tokens, cache_create_tokens)), 0) as cache_create_5m_tokens,
+      COALESCE(SUM(COALESCE(cache_create_1h_tokens, 0)), 0) as cache_create_1h_tokens,
+      COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
+      COALESCE(SUM(cost_usd), 0) as cost_usd,
+      MAX(timestamp) as last_active
+    FROM requests
+    WHERE timestamp >= ?
+      AND machine_id != ''
+      ${requestMachineClause}
+    GROUP BY machine_id
+  `).all(...machine ? [since, machine] : [since]);
+  const sessionMachineClause = machine ? " AND machine_id = ?" : "";
+  const sessionRows = db.prepare(`
+    SELECT
+      machine_id,
+      COUNT(*) as sessions,
+      COALESCE(SUM(request_count), 0) as requests,
+      COALESCE(SUM(total_tokens), 0) as total_tokens,
+      COALESCE(SUM(total_cost_usd), 0) as cost_usd,
+      MAX(started_at) as last_active
+    FROM sessions
+    WHERE started_at >= ?
+      AND machine_id != ''
+      ${sessionMachineClause}
+      AND NOT EXISTS (SELECT 1 FROM requests r WHERE r.session_id = sessions.id)
+    GROUP BY machine_id
+  `).all(...machine ? [since, machine] : [since]);
+  const groups = new Map;
+  for (const row of requestRows) {
+    knownMachines.add(row.machine_id);
+    groups.set(row.machine_id, combineTotals(baseRequestTotals(row), ZERO_SESSION_TOTALS));
+  }
+  for (const row of sessionRows) {
+    knownMachines.add(row.machine_id);
+    const current = groups.get(row.machine_id) ?? emptyTotals();
+    const sessions = baseSessionTotals(row);
+    groups.set(row.machine_id, {
+      ...current,
+      sessions: current.sessions + sessions.sessions,
+      requests: current.requests + sessions.requests,
+      total_tokens: current.total_tokens + sessions.total_tokens,
+      cost_usd: current.cost_usd + sessions.cost_usd,
+      last_active: latestTimestamp(current.last_active, sessions.last_active)
+    });
+  }
+  const lastData = queryMachineLastData(db, machine);
+  const rows = [...knownMachines].filter((m) => !machine || m === machine).map((machineId) => {
+    const totals = groups.get(machineId) ?? emptyTotals();
+    const lastDataAt = lastData.get(machineId) ?? totals.last_active;
+    return {
+      machine_id: machineId,
+      ...totals,
+      last_data_at: lastDataAt,
+      last_data_age: ""
+    };
+  });
+  return rows.sort((a, b) => b.cost_usd - a.cost_usd || a.machine_id.localeCompare(b.machine_id));
+}
+function queryMachineLastData(db, machine) {
+  const filter = machine ? " AND machine_id = ?" : "";
+  const requestRows = db.prepare(`
+    SELECT machine_id, MAX(timestamp) as last_at
+    FROM requests
+    WHERE machine_id != ''${filter}
+    GROUP BY machine_id
+  `).all(...machine ? [machine] : []);
+  const sessionRows = db.prepare(`
+    SELECT machine_id, MAX(started_at) as last_at
+    FROM sessions
+    WHERE machine_id != ''${filter}
+    GROUP BY machine_id
+  `).all(...machine ? [machine] : []);
+  const result = new Map;
+  for (const row of [...requestRows, ...sessionRows]) {
+    result.set(row.machine_id, latestTimestamp(result.get(row.machine_id), row.last_at));
+  }
+  return result;
+}
+function queryAgentSinceRows(db, since, machine) {
+  const requestMachineClause = machine ? " AND machine_id = ?" : "";
+  const sessionMachineClause = machine ? " AND machine_id = ?" : "";
+  const rows = db.prepare(`
+    WITH request_rows AS (
+      SELECT
+        agent,
+        session_id,
+        1 as requests,
+        input_tokens,
+        output_tokens,
+        cache_read_tokens,
+        cache_create_tokens,
+        COALESCE(cache_create_5m_tokens, cache_create_tokens) as cache_create_5m_tokens,
+        COALESCE(cache_create_1h_tokens, 0) as cache_create_1h_tokens,
+        input_tokens + output_tokens + cache_read_tokens + cache_create_tokens as total_tokens,
+        cost_usd,
+        timestamp as last_active
+      FROM requests
+      WHERE timestamp >= ?${requestMachineClause}
+    ),
+    session_only_rows AS (
+      SELECT
+        agent,
+        id as session_id,
+        COALESCE(request_count, 0) as requests,
+        0 as input_tokens,
+        0 as output_tokens,
+        0 as cache_read_tokens,
+        0 as cache_create_tokens,
+        0 as cache_create_5m_tokens,
+        0 as cache_create_1h_tokens,
+        COALESCE(total_tokens, 0) as total_tokens,
+        COALESCE(total_cost_usd, 0) as cost_usd,
+        started_at as last_active
+      FROM sessions
+      WHERE started_at >= ?${sessionMachineClause}
+        AND NOT EXISTS (SELECT 1 FROM requests r WHERE r.session_id = sessions.id)
+    ),
+    combined AS (
+      SELECT * FROM request_rows
+      UNION ALL
+      SELECT * FROM session_only_rows
+    )
+    SELECT
+      agent,
+      COUNT(DISTINCT session_id) as sessions,
+      COALESCE(SUM(requests), 0) as requests,
+      COALESCE(SUM(input_tokens), 0) as input_tokens,
+      COALESCE(SUM(output_tokens), 0) as output_tokens,
+      COALESCE(SUM(cache_read_tokens), 0) as cache_read_tokens,
+      COALESCE(SUM(cache_create_tokens), 0) as cache_create_tokens,
+      COALESCE(SUM(cache_create_5m_tokens), 0) as cache_create_5m_tokens,
+      COALESCE(SUM(cache_create_1h_tokens), 0) as cache_create_1h_tokens,
+      COALESCE(SUM(total_tokens), 0) as total_tokens,
+      COALESCE(SUM(cost_usd), 0) as cost_usd,
+      MAX(last_active) as last_active
+    FROM combined
+    GROUP BY agent
+    ORDER BY cost_usd DESC
+  `).all(...machine ? [since, machine, since, machine] : [since, since]);
+  if (rows.length > 0)
+    return rows;
+  return queryAgentBreakdown(db, "all", machine).filter((row) => row.last_active >= since).map(agentBreakdownToBriefRow);
+}
+function agentBreakdownToBriefRow(row) {
+  return {
+    agent: row.agent,
+    sessions: row.sessions,
+    requests: row.requests,
+    input_tokens: 0,
+    output_tokens: 0,
+    cache_read_tokens: 0,
+    cache_create_tokens: 0,
+    cache_create_5m_tokens: 0,
+    cache_create_1h_tokens: 0,
+    total_tokens: row.total_tokens,
+    cost_usd: row.cost_usd,
+    last_active: row.last_active
+  };
+}
+function normalizeAccountEmail2(email) {
+  return email.trim().toLowerCase();
+}
+function accountKey2(row) {
+  const agent = row.agent || row.account_tool || "unknown";
+  const email = normalizeAccountEmail2(row.account_email);
+  if (email)
+    return `${agent}:${email}`;
+  if (row.account_name)
+    return `${agent}:${row.account_name}`;
+  return row.account_key || `${agent}:unknown`;
+}
+function addAccountRow(groups, row) {
+  if (!row.account_key && !row.account_tool && !row.account_name && !row.account_email)
+    return;
+  const key = accountKey2(row);
+  const email = normalizeAccountEmail2(row.account_email);
+  const current = groups.get(key) ?? {
+    account_key: key,
+    account_tool: row.agent || row.account_tool || "unknown",
+    account_name: row.account_name || email || row.account_key || "unknown",
+    account_email: email || null,
+    account_source: row.account_source || "unknown",
+    sessions: 0,
+    requests: 0,
+    input_tokens: 0,
+    output_tokens: 0,
+    cache_read_tokens: 0,
+    cache_create_tokens: 0,
+    cache_create_5m_tokens: 0,
+    cache_create_1h_tokens: 0,
+    total_tokens: 0,
+    cost_usd: 0,
+    last_active: null
+  };
+  current.sessions += Number(row.sessions ?? 0);
+  if (!current.account_email && email)
+    current.account_email = email;
+  if ((!current.account_name || current.account_name === "unknown") && (row.account_name || email)) {
+    current.account_name = row.account_name || email;
+  }
+  if ((!current.account_source || current.account_source === "unknown") && row.account_source && row.account_source !== "unknown") {
+    current.account_source = row.account_source;
+  }
+  current.requests += Number(row.requests ?? 0);
+  current.input_tokens += Number(row.input_tokens ?? 0);
+  current.output_tokens += Number(row.output_tokens ?? 0);
+  current.cache_read_tokens += Number(row.cache_read_tokens ?? 0);
+  current.cache_create_tokens += Number(row.cache_create_tokens ?? 0);
+  current.cache_create_5m_tokens += Number(row.cache_create_5m_tokens ?? 0);
+  current.cache_create_1h_tokens += Number(row.cache_create_1h_tokens ?? 0);
+  current.total_tokens += Number(row.total_tokens ?? 0);
+  current.cost_usd += Number(row.cost_usd ?? 0);
+  current.last_active = latestTimestamp(current.last_active, row.last_active);
+  groups.set(key, current);
+}
+function queryAccountSinceRows(db, since, machine) {
+  const requestMachineClause = machine ? " AND r.machine_id = ?" : "";
+  const sessionMachineClause = machine ? " AND s.machine_id = ?" : "";
+  const requestRows = db.prepare(`
+    SELECT
+      COALESCE(NULLIF(r.agent, ''), NULLIF(s.agent, ''), '') as agent,
+      COALESCE(NULLIF(r.account_key, ''), NULLIF(s.account_key, ''), '') as account_key,
+      COALESCE(NULLIF(r.account_tool, ''), NULLIF(s.account_tool, ''), '') as account_tool,
+      COALESCE(NULLIF(r.account_name, ''), NULLIF(s.account_name, ''), '') as account_name,
+      COALESCE(NULLIF(r.account_email, ''), NULLIF(s.account_email, ''), '') as account_email,
+      COALESCE(NULLIF(r.account_source, ''), NULLIF(s.account_source, ''), 'unknown') as account_source,
+      COUNT(DISTINCT r.session_id) as sessions,
+      COUNT(*) as requests,
+      COALESCE(SUM(r.input_tokens), 0) as input_tokens,
+      COALESCE(SUM(r.output_tokens), 0) as output_tokens,
+      COALESCE(SUM(r.cache_read_tokens), 0) as cache_read_tokens,
+      COALESCE(SUM(r.cache_create_tokens), 0) as cache_create_tokens,
+      COALESCE(SUM(COALESCE(r.cache_create_5m_tokens, r.cache_create_tokens, 0)), 0) as cache_create_5m_tokens,
+      COALESCE(SUM(COALESCE(r.cache_create_1h_tokens, 0)), 0) as cache_create_1h_tokens,
+      COALESCE(SUM(r.input_tokens + r.output_tokens + r.cache_read_tokens + r.cache_create_tokens), 0) as total_tokens,
+      COALESCE(SUM(r.cost_usd), 0) as cost_usd,
+      MAX(r.timestamp) as last_active
+    FROM requests r
+    LEFT JOIN sessions s ON s.id = r.session_id
+    WHERE r.timestamp >= ?${requestMachineClause}
+    GROUP BY
+      COALESCE(NULLIF(r.agent, ''), NULLIF(s.agent, ''), ''),
+      COALESCE(NULLIF(r.account_key, ''), NULLIF(s.account_key, ''), ''),
+      COALESCE(NULLIF(r.account_tool, ''), NULLIF(s.account_tool, ''), ''),
+      COALESCE(NULLIF(r.account_name, ''), NULLIF(s.account_name, ''), ''),
+      COALESCE(NULLIF(r.account_email, ''), NULLIF(s.account_email, ''), ''),
+      COALESCE(NULLIF(r.account_source, ''), NULLIF(s.account_source, ''), 'unknown')
+  `).all(...machine ? [since, machine] : [since]);
+  const sessionRows = db.prepare(`
+    SELECT
+      s.agent as agent,
+      s.account_key as account_key,
+      s.account_tool as account_tool,
+      s.account_name as account_name,
+      COALESCE(s.account_email, '') as account_email,
+      COALESCE(NULLIF(s.account_source, ''), 'unknown') as account_source,
+      COUNT(DISTINCT s.id) as sessions,
+      COALESCE(SUM(s.request_count), 0) as requests,
+      0 as input_tokens,
+      0 as output_tokens,
+      0 as cache_read_tokens,
+      0 as cache_create_tokens,
+      0 as cache_create_5m_tokens,
+      0 as cache_create_1h_tokens,
+      COALESCE(SUM(s.total_tokens), 0) as total_tokens,
+      COALESCE(SUM(s.total_cost_usd), 0) as cost_usd,
+      MAX(s.started_at) as last_active
+    FROM sessions s
+    WHERE s.started_at >= ?${sessionMachineClause}
+      AND NOT EXISTS (SELECT 1 FROM requests r WHERE r.session_id = s.id)
+    GROUP BY
+      s.agent,
+      s.account_key,
+      s.account_tool,
+      s.account_name,
+      COALESCE(s.account_email, ''),
+      COALESCE(NULLIF(s.account_source, ''), 'unknown')
+  `).all(...machine ? [since, machine] : [since]);
+  const groups = new Map;
+  for (const row of requestRows)
+    addAccountRow(groups, row);
+  for (const row of sessionRows)
+    addAccountRow(groups, row);
+  const rows = [...groups.values()];
+  rows.sort((a, b) => b.cost_usd - a.cost_usd || a.account_key.localeCompare(b.account_key));
+  if (rows.length > 0)
+    return rows;
+  return queryAccountBreakdown(db, "all", machine).filter((row) => row.last_active >= since).map(accountBreakdownToBriefRow);
+}
+function accountBreakdownToBriefRow(row) {
+  return {
+    account_key: row.account_key,
+    account_tool: row.account_tool,
+    account_name: row.account_name,
+    account_email: row.account_email,
+    account_source: row.account_source,
+    sessions: row.sessions,
+    requests: row.requests,
+    input_tokens: 0,
+    output_tokens: 0,
+    cache_read_tokens: 0,
+    cache_create_tokens: 0,
+    cache_create_5m_tokens: 0,
+    cache_create_1h_tokens: 0,
+    total_tokens: row.total_tokens,
+    cost_usd: row.cost_usd,
+    last_active: row.last_active
+  };
+}
+function queryFreshness(db, now, machine, localSync) {
+  const requestFilter = machine ? " AND machine_id = ?" : "";
+  const requestRows = db.prepare(`
+    SELECT machine_id, MAX(timestamp) as max_request_at
+    FROM requests
+    WHERE machine_id != ''${requestFilter}
+    GROUP BY machine_id
+  `).all(...machine ? [machine] : []);
+  const registryRows = listMachineRegistry(db).filter((row) => !machine || row.machine_id === machine);
+  const machines = new Map;
+  for (const row of requestRows) {
+    machines.set(row.machine_id, {
+      machine_id: row.machine_id,
+      max_request_at: row.max_request_at,
+      request_age: formatAge(row.max_request_at, now),
+      last_merge_sync_at: null,
+      merge_sync_age: "never"
+    });
+  }
+  for (const row of registryRows) {
+    const current = machines.get(row.machine_id) ?? {
+      machine_id: row.machine_id,
+      max_request_at: null,
+      request_age: "never",
+      last_merge_sync_at: null,
+      merge_sync_age: "never"
+    };
+    const syncAt = latestTimestamp(row.last_pull_at, row.last_push_at, row.updated_at);
+    current.last_merge_sync_at = syncAt;
+    current.merge_sync_age = formatAge(syncAt, now);
+    machines.set(row.machine_id, current);
+  }
+  if (localSync && (!machine || machine === localSync.machineId)) {
+    const current = machines.get(localSync.machineId) ?? {
+      machine_id: localSync.machineId,
+      max_request_at: null,
+      request_age: "never",
+      last_merge_sync_at: null,
+      merge_sync_age: "never"
+    };
+    current.last_merge_sync_at = latestTimestamp(current.last_merge_sync_at, localSync.syncedAt);
+    current.merge_sync_age = formatAge(current.last_merge_sync_at, now);
+    machines.set(localSync.machineId, current);
+  }
+  const rows = [...machines.values()].sort((a, b) => a.machine_id.localeCompare(b.machine_id));
+  return {
+    machines: rows,
+    max_request_line: rows.length ? rows.map((row) => `${row.machine_id} ${row.max_request_at ?? "never"} (${row.request_age})`).join("; ") : "none",
+    merge_sync_line: rows.length ? rows.map((row) => `${row.machine_id} ${row.last_merge_sync_at ?? "never"} (${row.merge_sync_age})`).join("; ") : "none"
+  };
+}
+function buildBrief(db, opts = {}) {
+  const now = opts.now ?? new Date;
+  const machine = machineFilter(opts.machine);
+  const sinceInput = opts.since ?? "24h";
+  const since = parseSinceDate(sinceInput, now);
+  const summaries = [
+    {
+      label: "Today",
+      period: "today",
+      ...queryPeriodTotals(db, "today", machine)
+    },
+    {
+      label: "Week",
+      period: "week",
+      ...queryPeriodTotals(db, "week", machine)
+    },
+    {
+      label: `Since ${since.label}`,
+      period: "since",
+      since: since.timestamp,
+      ...querySinceTotals(db, since.timestamp, machine)
+    }
+  ];
+  const machines = queryMachineSinceRows(db, since.timestamp, machine);
+  for (const row of machines) {
+    row.last_data_age = formatAge(row.last_data_at, now);
+  }
+  return {
+    generated_at: now.toISOString(),
+    machine: machine ?? "all",
+    since: {
+      input: sinceInput,
+      timestamp: since.timestamp,
+      label: since.label
+    },
+    summaries,
+    machines,
+    agents: queryAgentSinceRows(db, since.timestamp, machine),
+    accounts: queryAccountSinceRows(db, since.timestamp, machine),
+    freshness: queryFreshness(db, now, machine, opts.currentMachineId && opts.localSyncAt ? { machineId: opts.currentMachineId, syncedAt: opts.localSyncAt.toISOString() } : undefined)
+  };
+}
+
+// src/lib/analytics.ts
+function queryProjectDetail(db, nameOrPath) {
+  const like = `%${nameOrPath}%`;
+  const sessions = db.prepare(`SELECT id, project_name, project_path, total_cost_usd, total_tokens, started_at
+     FROM sessions
+     WHERE project_name LIKE ? OR project_path LIKE ?
+     ORDER BY started_at DESC`).all(like, like);
+  if (sessions.length === 0)
+    return null;
+  const first = sessions[0];
+  const totalCost = sessions.reduce((s, r) => s + (r.total_cost_usd ?? 0), 0);
+  const totalTokens = sessions.reduce((s, r) => s + (r.total_tokens ?? 0), 0);
+  const daily = db.prepare(`SELECT DATE(r.timestamp) as date, COALESCE(SUM(r.cost_usd), 0) as cost_usd
+     FROM requests r JOIN sessions s ON r.session_id = s.id
+     WHERE (s.project_name LIKE ? OR s.project_path LIKE ?)
+       AND r.timestamp >= DATE('now', '-14 days')
+     GROUP BY date ORDER BY date ASC`).all(like, like);
+  const models = db.prepare(`SELECT r.model as model, COUNT(*) as requests, COALESCE(SUM(r.cost_usd), 0) as cost_usd
+     FROM requests r JOIN sessions s ON r.session_id = s.id
+     WHERE s.project_name LIKE ? OR s.project_path LIKE ?
+     GROUP BY r.model ORDER BY cost_usd DESC LIMIT 5`).all(like, like);
+  const top_sessions = [...sessions].sort((a, b) => (b.total_cost_usd ?? 0) - (a.total_cost_usd ?? 0)).slice(0, 5).map((s) => ({ id: s.id, total_cost_usd: s.total_cost_usd ?? 0, started_at: s.started_at }));
+  return {
+    project_name: first.project_name || nameOrPath,
+    project_path: first.project_path || "",
+    total_cost_usd: totalCost,
+    total_tokens: totalTokens,
+    sessions: sessions.length,
+    daily,
+    models,
+    top_sessions
+  };
+}
+function exportDateWhere(column, period) {
+  switch (period) {
+    case "today":
+      return `DATE(${column}) = DATE('now')`;
+    case "week":
+      return `${column} >= DATE('now', '-7 days')`;
+    case "all":
+      return "1=1";
+    default:
+      return `${column} >= DATE('now', '-30 days')`;
+  }
+}
+function queryExportRows(db, type, period) {
+  if (type === "requests") {
+    const where2 = exportDateWhere("timestamp", period);
+    return db.prepare(`SELECT * FROM requests WHERE ${where2} ORDER BY timestamp ASC`).all();
+  }
+  const where = exportDateWhere("started_at", period);
+  return db.prepare(`SELECT * FROM sessions WHERE ${where} ORDER BY started_at DESC`).all();
+}
+function queryRangeStats(db, from, to) {
+  const r = db.prepare(`SELECT COALESCE(SUM(cost_usd),0) as cost, COUNT(*) as requests,
+            COALESCE(SUM(input_tokens+output_tokens+cache_read_tokens+cache_create_tokens),0) as tokens
+     FROM requests WHERE DATE(timestamp) BETWEEN ? AND ?`).get(from, to);
+  const s = db.prepare(`SELECT COUNT(*) as sessions FROM sessions WHERE DATE(started_at) BETWEEN ? AND ?`).get(from, to);
+  return { cost: r.cost, requests: r.requests, tokens: r.tokens, sessions: s.sessions };
+}
+function queryForecast(db, now = new Date) {
+  const daysInMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0).getDate();
+  const dayOfMonth = now.getDate();
+  const monthStart = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-01`;
+  const monthSoFar = db.prepare(`SELECT COALESCE(SUM(cost_usd),0) as cost FROM requests WHERE DATE(timestamp) >= ?`).get(monthStart);
+  const dailyAvg = dayOfMonth > 0 ? monthSoFar.cost / dayOfMonth : 0;
+  const projected = dailyAvg * daysInMonth;
+  const sevenDaysAgo = new Date(now);
+  sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
+  const last7 = db.prepare(`SELECT COALESCE(SUM(cost_usd),0) as cost FROM requests WHERE DATE(timestamp) >= ?`).get(sevenDaysAgo.toISOString().substring(0, 10));
+  const last7DailyAvg = last7.cost / 7;
+  const dailyCosts = db.prepare(`SELECT DATE(timestamp) as date, COALESCE(SUM(cost_usd),0) as cost_usd
+     FROM requests WHERE DATE(timestamp) >= ? GROUP BY date ORDER BY cost_usd ASC`).all(monthStart);
+  return {
+    day_of_month: dayOfMonth,
+    days_in_month: daysInMonth,
+    spent_so_far_usd: monthSoFar.cost,
+    daily_avg_usd: dailyAvg,
+    projected_usd: projected,
+    last7_daily_avg_usd: last7DailyAvg,
+    last7_projected_usd: last7DailyAvg * daysInMonth,
+    cheapest_day: dailyCosts[0] ?? null,
+    most_expensive_day: dailyCosts[dailyCosts.length - 1] ?? null
+  };
+}
+function queryModelEfficiency(db) {
+  return db.prepare(`SELECT model,
+            COALESCE(SUM(input_tokens),0) as input,
+            COALESCE(SUM(output_tokens),0) as output,
+            COALESCE(SUM(cache_read_tokens),0) as cache_read,
+            COALESCE(SUM(cache_create_tokens),0) as cache_write,
+            COUNT(*) as requests,
+            COALESCE(SUM(cost_usd),0) as cost
+     FROM requests GROUP BY model ORDER BY cost DESC`).all();
+}
+
+// src/lib/contracts-client/mode.ts
+var DEPRECATED_STORAGE_MODE_ALIASES = ["remote", "hybrid", "self_hosted"];
+function normalizeStorageMode(value) {
+  const normalized = value.trim().toLowerCase().replace(/-/g, "_");
+  if (normalized === "local")
+    return { mode: "local", deprecatedAlias: null };
+  if (normalized === "cloud")
+    return { mode: "cloud", deprecatedAlias: null };
+  if (DEPRECATED_STORAGE_MODE_ALIASES.includes(normalized)) {
+    return { mode: "cloud", deprecatedAlias: normalized };
+  }
+  throw new Error(`Unknown storage mode: ${value}. Use local or cloud.`);
+}
+function envToken(name) {
+  return name.toUpperCase().replace(/-/g, "_");
+}
+
+// src/lib/contracts-client/transport.ts
+function defaultCloudBaseUrl(name) {
+  return `https://${name}.hasna.xyz`;
+}
+function clientTransportEnvKeys(name) {
+  const token = envToken(name);
+  return {
+    modeKeys: [
+      `HASNA_${token}_STORAGE_MODE`,
+      `HASNA_${token}_MODE`,
+      `${token}_STORAGE_MODE`,
+      `${token}_MODE`
+    ],
+    apiUrlKeys: [`HASNA_${token}_API_URL`, `${token}_API_URL`],
+    apiKeyKeys: [`HASNA_${token}_API_KEY`, `${token}_API_KEY`]
+  };
+}
+function firstEnv(env, keys) {
+  for (const key of keys) {
+    const value = env[key]?.trim();
+    if (value)
+      return { key, value };
+  }
+  return null;
+}
+function toV1BaseUrl(apiUrl) {
+  const url = new URL(apiUrl);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("API URL must use http or https.");
+  }
+  let path = url.pathname.replace(/\/+$/, "");
+  if (path.endsWith("/v1"))
+    path = path.slice(0, -"/v1".length);
+  url.pathname = `${path}/v1`;
+  url.search = "";
+  url.hash = "";
+  return url.toString().replace(/\/+$/, "");
+}
+function resolveClientTransport(name, env = process.env) {
+  const keys = clientTransportEnvKeys(name);
+  const modeHit = firstEnv(env, keys.modeKeys);
+  const urlHit = firstEnv(env, keys.apiUrlKeys);
+  const keyHit = firstEnv(env, keys.apiKeyKeys);
+  let mode = "local";
+  let deprecatedAlias = null;
+  let modeSource = "default";
+  const warnings = [];
+  if (modeHit) {
+    const normalized = normalizeStorageMode(modeHit.value);
+    mode = normalized.mode;
+    deprecatedAlias = normalized.deprecatedAlias;
+    modeSource = modeHit.key;
+    if (deprecatedAlias) {
+      warnings.push(`Deprecated mode '${deprecatedAlias}' from ${modeHit.key} is treated as 'cloud'. Prefer ${keys.modeKeys[0]}=cloud.`);
+    }
+  } else if (urlHit && keyHit) {
+    mode = "cloud";
+    modeSource = `${urlHit.key}+${keyHit.key}`;
+  }
+  if (mode === "local") {
+    return {
+      transport: "local",
+      mode,
+      deprecatedAlias,
+      modeSource,
+      baseUrl: null,
+      apiUrlSource: null,
+      apiKeyPresent: Boolean(keyHit),
+      apiKeySource: keyHit ? keyHit.key : null,
+      misconfigured: false,
+      warning: warnings.length > 0 ? warnings.join(" ") : null
+    };
+  }
+  if (!keyHit) {
+    warnings.push(`${modeSource}=cloud but no API key is set (${keys.apiKeyKeys[0]}). Refusing to route to cloud; using local store. Set ${keys.apiKeyKeys[0]} to enable the cloud client.`);
+    return {
+      transport: "local",
+      mode,
+      deprecatedAlias,
+      modeSource,
+      baseUrl: null,
+      apiUrlSource: null,
+      apiKeyPresent: false,
+      apiKeySource: null,
+      misconfigured: true,
+      warning: warnings.join(" ")
+    };
+  }
+  const rawUrl = urlHit?.value ?? defaultCloudBaseUrl(name);
+  const apiUrlSource = urlHit ? urlHit.key : "default";
+  let baseUrl;
+  try {
+    baseUrl = toV1BaseUrl(rawUrl);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    warnings.push(`Invalid API URL from ${apiUrlSource}: ${message}. Using local store.`);
+    return {
+      transport: "local",
+      mode,
+      deprecatedAlias,
+      modeSource,
+      baseUrl: null,
+      apiUrlSource: null,
+      apiKeyPresent: true,
+      apiKeySource: keyHit.key,
+      misconfigured: true,
+      warning: warnings.join(" ")
+    };
+  }
+  return {
+    transport: "cloud-http",
+    mode,
+    deprecatedAlias,
+    modeSource,
+    baseUrl,
+    apiUrlSource,
+    apiKeyPresent: true,
+    apiKeySource: keyHit.key,
+    misconfigured: false,
+    warning: warnings.length > 0 ? warnings.join(" ") : null
+  };
+}
+
+class HasnaHttpError extends Error {
+  status;
+  method;
+  path;
+  body;
+  constructor(method, path, status, body) {
+    super(`Hasna cloud request failed: ${method} ${path} -> ${status}`);
+    this.name = "HasnaHttpError";
+    this.status = status;
+    this.method = method;
+    this.path = path;
+    this.body = body;
+  }
+}
+var DEFAULT_RETRY_STATUSES = [408, 425, 429, 500, 502, 503, 504];
+var IDEMPOTENT_METHODS = new Set(["GET", "HEAD", "PUT", "DELETE", "OPTIONS"]);
+function appendQuery(path, query) {
+  if (!query)
+    return path;
+  const params = query instanceof URLSearchParams ? query : new URLSearchParams;
+  if (!(query instanceof URLSearchParams)) {
+    for (const [key, value] of Object.entries(query)) {
+      if (value === null || value === undefined)
+        continue;
+      if (Array.isArray(value)) {
+        for (const v of value)
+          params.append(key, String(v));
+      } else {
+        params.append(key, String(value));
+      }
+    }
+  }
+  const qs = params.toString();
+  if (!qs)
+    return path;
+  return `${path}${path.includes("?") ? "&" : "?"}${qs}`;
+}
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function createHasnaHttpTransport(options) {
+  const fetchImpl = options.fetchImpl ?? ((input, init) => fetch(input, init));
+  const base = options.baseUrl.replace(/\/+$/, "");
+  const timeoutMs = options.timeoutMs ?? 30000;
+  const sleep = options.sleepImpl ?? defaultSleep;
+  const defaultRetry = options.retry;
+  function resolveRetry(callRetry) {
+    const chosen = callRetry !== undefined ? callRetry : defaultRetry;
+    if (chosen === false)
+      return null;
+    const r = chosen ?? {};
+    return {
+      retries: r.retries ?? 2,
+      baseDelayMs: r.baseDelayMs ?? 200,
+      maxDelayMs: r.maxDelayMs ?? 2000,
+      retryStatuses: r.retryStatuses ?? [...DEFAULT_RETRY_STATUSES]
+    };
+  }
+  async function once(method, rel, url, body, opts) {
+    const headers = {
+      "x-api-key": options.apiKey,
+      Authorization: `Bearer ${options.apiKey}`,
+      Accept: "application/json",
+      ...options.headers ?? {},
+      ...opts.headers ?? {}
+    };
+    if (opts.idempotencyKey)
+      headers["Idempotency-Key"] = opts.idempotencyKey;
+    const init = { method, headers };
+    if (body !== undefined) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(body);
+    }
+    const controller = new AbortController;
+    const onAbort = () => controller.abort();
+    if (opts.signal) {
+      if (opts.signal.aborted)
+        controller.abort();
+      else
+        opts.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? timeoutMs);
+    init.signal = controller.signal;
+    let response;
+    try {
+      response = await fetchImpl(url, init);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (opts.signal?.aborted)
+        return { ok: false, retryable: false, error: err };
+      return { ok: false, retryable: true, error: err };
+    } finally {
+      clearTimeout(timer);
+      if (opts.signal)
+        opts.signal.removeEventListener("abort", onAbort);
+    }
+    const text = await response.text();
+    let parsed = undefined;
+    if (text.length > 0) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = text;
+      }
+    }
+    if (!response.ok) {
+      const retry = resolveRetry(opts.retry);
+      const retryable = retry ? retry.retryStatuses.includes(response.status) : false;
+      return { ok: false, retryable, error: new HasnaHttpError(method, rel, response.status, parsed) };
+    }
+    return { ok: true, value: parsed };
+  }
+  async function request(method, path, body, opts = {}) {
+    const upper = method.toUpperCase();
+    const rel = appendQuery(path.startsWith("/") ? path : `/${path}`, opts.query);
+    const url = `${base}${rel}`;
+    const retry = resolveRetry(opts.retry);
+    const methodRetryable = IDEMPOTENT_METHODS.has(upper) || Boolean(opts.idempotencyKey);
+    const maxAttempts = retry && methodRetryable ? retry.retries + 1 : 1;
+    let last = null;
+    for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+      const result = await once(upper, rel, url, body, opts);
+      if (result.ok)
+        return result.value;
+      last = result;
+      const canRetry = retry !== null && methodRetryable && result.retryable && attempt < maxAttempts;
+      if (!canRetry)
+        break;
+      const backoff = Math.min(retry.maxDelayMs, retry.baseDelayMs * 2 ** (attempt - 1));
+      const jitter = Math.floor(Math.random() * (backoff / 2 + 1));
+      await sleep(backoff + jitter);
+    }
+    throw last.error;
+  }
+  return {
+    baseUrl: base,
+    request,
+    get: (path, opts) => request("GET", path, undefined, opts),
+    post: (path, body, opts) => request("POST", path, body, opts),
+    put: (path, body, opts) => request("PUT", path, body, opts),
+    patch: (path, body, opts) => request("PATCH", path, body, opts),
+    del: (path, body, opts) => request("DELETE", path, body, opts)
+  };
+}
+function createClientTransport(name, env = process.env, overrides) {
+  const resolution = resolveClientTransport(name, env);
+  if (resolution.misconfigured) {
+    throw new Error(resolution.warning ?? `Client for '${name}' is misconfigured for cloud mode.`);
+  }
+  if (resolution.transport === "local" || !resolution.baseUrl) {
+    return { transport: "local", client: null, resolution };
+  }
+  const keys = clientTransportEnvKeys(name);
+  const apiKey = firstEnv(env, keys.apiKeyKeys)?.value;
+  if (!apiKey) {
+    throw new Error(`Client for '${name}' resolved to cloud-http without an API key.`);
+  }
+  return {
+    transport: "cloud-http",
+    client: createHasnaHttpTransport({
+      name,
+      baseUrl: resolution.baseUrl,
+      apiKey,
+      ...overrides?.fetchImpl ? { fetchImpl: overrides.fetchImpl } : {},
+      ...overrides?.headers ? { headers: overrides.headers } : {},
+      ...overrides?.timeoutMs ? { timeoutMs: overrides.timeoutMs } : {},
+      ...overrides?.retry !== undefined ? { retry: overrides.retry } : {},
+      ...overrides?.sleepImpl ? { sleepImpl: overrides.sleepImpl } : {}
+    }),
+    resolution
+  };
+}
+
+// src/lib/contracts-client/storage.ts
+function resourcePath(resource) {
+  const trimmed = resource.replace(/^\/+|\/+$/g, "");
+  if (!trimmed)
+    throw new Error("resource must be a non-empty path segment");
+  return `/${trimmed}`;
+}
+function entityPath(resource, id) {
+  if (id === undefined || id === null || `${id}`.length === 0) {
+    throw new Error("id must be a non-empty string");
+  }
+  return `${resourcePath(resource)}/${encodeURIComponent(String(id))}`;
+}
+function newIdempotencyKey() {
+  const g = globalThis;
+  if (g.crypto?.randomUUID)
+    return g.crypto.randomUUID();
+  return `idmp_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 12)}`;
+}
+function extractItems(raw) {
+  if (Array.isArray(raw))
+    return raw;
+  if (raw && typeof raw === "object") {
+    const obj = raw;
+    for (const key of ["items", "data", "results", "rows", "records"]) {
+      if (Array.isArray(obj[key]))
+        return obj[key];
+    }
+  }
+  return [];
+}
+function extractTotal(raw) {
+  if (raw && typeof raw === "object") {
+    const obj = raw;
+    for (const key of ["total", "count", "totalCount", "total_count"]) {
+      if (typeof obj[key] === "number")
+        return obj[key];
+    }
+  }
+  return null;
+}
+function extractCursor(raw) {
+  if (raw && typeof raw === "object") {
+    const obj = raw;
+    for (const key of ["cursor", "nextCursor", "next_cursor", "next"]) {
+      if (typeof obj[key] === "string")
+        return obj[key];
+    }
+  }
+  return null;
+}
+function createHasnaStorageClient(name, transport) {
+  return {
+    name,
+    baseUrl: transport.baseUrl,
+    transport,
+    async list(resource, options = {}) {
+      const raw = await transport.get(resourcePath(resource), options);
+      return {
+        items: extractItems(raw),
+        total: extractTotal(raw),
+        cursor: extractCursor(raw),
+        raw
+      };
+    },
+    async get(resource, id, options = {}) {
+      try {
+        return await transport.get(entityPath(resource, id), options);
+      } catch (error) {
+        if (error instanceof HasnaHttpError && error.status === 404)
+          return null;
+        throw error;
+      }
+    },
+    async create(resource, body, options = {}) {
+      const { idempotencyKey, ...rest } = options;
+      return transport.post(resourcePath(resource), body, {
+        ...rest,
+        idempotencyKey: idempotencyKey ?? newIdempotencyKey()
+      });
+    },
+    async update(resource, id, patch, options = {}) {
+      const { method = "PATCH", idempotencyKey, ...rest } = options;
+      const call = method === "PUT" ? transport.put : transport.patch;
+      return call(entityPath(resource, id), patch, { ...rest, ...idempotencyKey ? { idempotencyKey } : {} });
+    },
+    async delete(resource, id, options = {}) {
+      try {
+        await transport.del(entityPath(resource, id), undefined, options);
+      } catch (error) {
+        if (error instanceof HasnaHttpError && error.status === 404)
+          return;
+        throw error;
+      }
+    }
+  };
+}
+function resolveStorageClient(name, env = process.env, overrides) {
+  const wired = createClientTransport(name, env, overrides);
+  if (wired.transport === "cloud-http") {
+    return { transport: "cloud-http", client: createHasnaStorageClient(name, wired.client) };
+  }
+  return { transport: "local", client: null };
+}
+
+// src/lib/cloud-storage.ts
+var ECONOMY_APP = "economy";
+var cache;
+function resolveEconomyCloudStorage(env = process.env, overrides) {
+  const resolved = resolveStorageClient(ECONOMY_APP, env, overrides);
+  return resolved.transport === "cloud-http" ? { active: true, client: resolved.client } : { active: false, client: null };
+}
+function economyCloudStorage(env = process.env) {
+  if (cache === undefined)
+    cache = resolveEconomyCloudStorage(env);
+  return cache;
+}
+function cleanQuery(query) {
+  if (!query)
+    return;
+  const out = {};
+  for (const [k, v] of Object.entries(query)) {
+    if (v !== undefined && v !== null && v !== "")
+      out[k] = v;
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+async function cloudListItems(storage, resource, query) {
+  const cleaned = cleanQuery(query);
+  const res = await storage.client.list(resource, cleaned ? { query: cleaned } : {});
+  return res.items;
+}
+async function cloudObject(storage, path, query) {
+  const cleaned = cleanQuery(query);
+  const raw = await storage.client.transport.get(path, cleaned ? { query: cleaned } : {});
+  if (raw && typeof raw === "object" && "data" in raw) {
+    return raw.data;
+  }
+  return raw;
+}
+
+// src/lib/store/index.ts
+class LocalStore {
+  transport = "local";
+  _db;
+  db() {
+    if (!this._db) {
+      this._db = openDatabase();
+      ensurePricingSeeded(this._db);
+    }
+    return this._db;
+  }
+  async summary(period, machine) {
+    return querySummary(this.db(), period, machine);
+  }
+  async sessions(filter) {
+    return querySessions(this.db(), filter);
+  }
+  async topSessions(n, agent, since) {
+    return queryTopSessions(this.db(), n, agent, since);
+  }
+  async sessionDetail(id) {
+    return getSessionDetail(this.db(), id);
+  }
+  async modelBreakdown(query = {}) {
+    return query.since ? queryModelBreakdownSince(this.db(), query.since) : queryModelBreakdown(this.db());
+  }
+  async agentBreakdown(query = {}) {
+    return query.since ? queryAgentBreakdownSince(this.db(), query.since) : queryAgentBreakdown(this.db(), query.period ?? "all", query.machine);
+  }
+  async projectBreakdown(query = {}) {
+    return query.since ? queryProjectBreakdownSince(this.db(), query.since) : queryProjectBreakdown(this.db(), query.period ?? "all", query.machine);
+  }
+  async accountBreakdown(query = {}) {
+    return query.since ? queryAccountBreakdownSince(this.db(), query.since) : queryAccountBreakdown(this.db(), query.period ?? "all", query.machine);
+  }
+  async accounts(period) {
+    return queryAccountBreakdown(this.db(), period);
+  }
+  async daily(days, machine) {
+    return queryDailyBreakdown(this.db(), days, machine);
+  }
+  async machines() {
+    return listMachines(this.db());
+  }
+  async fleet(period) {
+    return {
+      summary: querySummary(this.db(), period, undefined, true),
+      machines: listMachines(this.db(), period),
+      registry: listMachineRegistry(this.db())
+    };
+  }
+  async billingSummary(period) {
+    return queryBillingSummary(this.db(), period);
+  }
+  async billingDiff(period) {
+    return queryBillingDiff(this.db(), period);
+  }
+  async usage(period, agent) {
+    const snapshots = queryUsageSnapshots(this.db(), { agent, ...usageSnapshotFilterForPeriod(period) });
+    const summary = querySummary(this.db(), period, undefined, true, agent);
+    return { snapshots, summary };
+  }
+  async savings(period, agent) {
+    return querySavingsSummary(this.db(), period, agent);
+  }
+  async listBudgets() {
+    return getBudgetStatuses(this.db());
+  }
+  async listGoals() {
+    return getGoalStatuses(this.db());
+  }
+  async listPricing() {
+    return listModelPricing(this.db());
+  }
+  async listSubscriptions() {
+    return listSubscriptions(this.db());
+  }
+  async listProjects() {
+    return queryProjectBreakdown(this.db());
+  }
+  async brief(query = {}) {
+    return buildBrief(this.db(), {
+      since: query.since,
+      machine: query.machine,
+      currentMachineId: query.currentMachineId,
+      localSyncAt: query.localSyncAt
+    });
+  }
+  async projectDetail(nameOrPath) {
+    return queryProjectDetail(this.db(), nameOrPath);
+  }
+  async exportRows(type, period) {
+    return queryExportRows(this.db(), type, period);
+  }
+  async rangeStats(from, to) {
+    return queryRangeStats(this.db(), from, to);
+  }
+  async forecast() {
+    return queryForecast(this.db());
+  }
+  async efficiency() {
+    return queryModelEfficiency(this.db());
+  }
+  async recentRequests(since) {
+    return queryRequestsSince(this.db(), since);
+  }
+  async estimate(input) {
+    return estimateCostFromRows(listModelPricing(this.db()), input.model, input.inputTokens, input.outputTokens, input.cacheReadTokens ?? 0, input.cacheWriteTokens ?? 0, input.cacheWrite1hTokens ?? 0, input.cacheStorageTokenHours ?? 0);
+  }
+  async setBudget(input) {
+    const now = new Date().toISOString();
+    const budget = { id: randomUUID(), ...input, created_at: now, updated_at: now };
+    upsertBudget(this.db(), budget);
+    return budget.id;
+  }
+  async removeBudget(id) {
+    deleteBudget(this.db(), id);
+  }
+  async setGoal(input) {
+    const now = new Date().toISOString();
+    upsertGoal(this.db(), { id: randomUUID(), ...input, created_at: now, updated_at: now });
+  }
+  async removeGoal(id) {
+    deleteGoal(this.db(), id);
+  }
+  async setPricing(input) {
+    upsertModelPricing(this.db(), { ...input, updated_at: new Date().toISOString() });
+  }
+  async removePricing(model) {
+    deleteModelPricing(this.db(), model);
+  }
+  async setSubscription(input) {
+    const now = new Date().toISOString();
+    const row = {
+      id: input.id ?? randomUUID(),
+      provider: input.provider,
+      plan: input.plan,
+      agent: input.agent,
+      monthly_fee_usd: input.monthly_fee_usd,
+      included_usage_usd: input.included_usage_usd,
+      billing_cycle_start: input.billing_cycle_start,
+      reset_policy: input.reset_policy,
+      active: input.active,
+      created_at: now,
+      updated_at: now
+    };
+    upsertSubscription(this.db(), row);
+    return row;
+  }
+  async removeSubscription(id) {
+    deleteSubscription(this.db(), id);
+  }
+  async addProject(path, name) {
+    upsertProject(this.db(), {
+      id: randomUUID(),
+      path,
+      name,
+      description: null,
+      tags: [],
+      created_at: new Date().toISOString()
+    });
+  }
+  async renameProject(path, name) {
+    const existing = getProject(this.db(), path);
+    if (!existing)
+      throw new Error("Project not found");
+    upsertProject(this.db(), { ...existing, name });
+  }
+  async removeProject(path) {
+    deleteProject(this.db(), path);
+  }
+}
+function q(params) {
+  const out = {};
+  for (const [k, v] of Object.entries(params))
+    if (v !== undefined && v !== null && v !== "")
+      out[k] = v;
+  return out;
+}
+
+class ApiStore {
+  cloud;
+  transport = "cloud-http";
+  constructor(cloud) {
+    this.cloud = cloud;
+  }
+  async summary(period, machine) {
+    return cloudObject(this.cloud, "/summary", q({ period, machine }));
+  }
+  async sessions(filter) {
+    return cloudListItems(this.cloud, "sessions", q({ ...filter }));
+  }
+  async topSessions(n, agent, since) {
+    return cloudListItems(this.cloud, "top", q({ n, agent, since }));
+  }
+  async sessionDetail(id) {
+    const matches = await cloudListItems(this.cloud, "sessions", q({ search: id, limit: 1 }));
+    const session = matches[0];
+    if (!session)
+      return null;
+    const requests = await cloudObject(this.cloud, `/sessions/${encodeURIComponent(String(session["id"]))}/requests`);
+    return { session, requests: requests ?? [] };
+  }
+  async modelBreakdown(query = {}) {
+    return cloudListItems(this.cloud, "breakdown", q({ by: "model", period: query.period, since: query.since }));
+  }
+  async agentBreakdown(query = {}) {
+    return cloudListItems(this.cloud, "breakdown", q({ by: "agent", period: query.period, since: query.since }));
+  }
+  async projectBreakdown(query = {}) {
+    return cloudListItems(this.cloud, "breakdown", q({ by: "project", period: query.period, since: query.since }));
+  }
+  async accountBreakdown(query = {}) {
+    return cloudListItems(this.cloud, "breakdown", q({ by: "account", period: query.period, since: query.since }));
+  }
+  async accounts(period) {
+    return cloudListItems(this.cloud, "accounts", q({ period }));
+  }
+  async daily(days, machine) {
+    return cloudListItems(this.cloud, "daily", q({ days, machine }));
+  }
+  async machines() {
+    return cloudListItems(this.cloud, "machines");
+  }
+  async fleet(period) {
+    const data = await cloudObject(this.cloud, "/fleet", q({ period }));
+    return {
+      summary: data.summary,
+      machines: data.machines ?? [],
+      registry: data.registry ?? []
+    };
+  }
+  async billingSummary(period) {
+    return cloudObject(this.cloud, "/billing", q({ period }));
+  }
+  async billingDiff(period) {
+    return cloudObject(this.cloud, "/billing/diff", q({ period }));
+  }
+  async usage(period, agent) {
+    return cloudObject(this.cloud, "/usage", q({ period, agent }));
+  }
+  async savings(period, agent) {
+    return cloudObject(this.cloud, "/savings", q({ period, agent }));
+  }
+  async listBudgets() {
+    return cloudListItems(this.cloud, "budgets");
+  }
+  async listGoals() {
+    return cloudListItems(this.cloud, "goals");
+  }
+  async listPricing() {
+    return cloudListItems(this.cloud, "pricing");
+  }
+  async listSubscriptions() {
+    return cloudListItems(this.cloud, "subscriptions");
+  }
+  async listProjects() {
+    return cloudListItems(this.cloud, "projects");
+  }
+  async brief(query = {}) {
+    return cloudObject(this.cloud, "/brief", q({ since: query.since, machine: query.machine }));
+  }
+  async projectDetail(nameOrPath) {
+    return cloudObject(this.cloud, "/projects/detail", q({ q: nameOrPath }));
+  }
+  async exportRows(type, period) {
+    return cloudListItems(this.cloud, "export", q({ type, period }));
+  }
+  async rangeStats(from, to) {
+    return cloudObject(this.cloud, "/compare", q({ from, to }));
+  }
+  async forecast() {
+    return cloudObject(this.cloud, "/forecast");
+  }
+  async efficiency() {
+    return cloudListItems(this.cloud, "efficiency");
+  }
+  async recentRequests(since) {
+    return cloudListItems(this.cloud, "requests", q({ since }));
+  }
+  async estimate(input) {
+    const rows = await this.listPricing();
+    return estimateCostFromRows(rows, input.model, input.inputTokens, input.outputTokens, input.cacheReadTokens ?? 0, input.cacheWriteTokens ?? 0, input.cacheWrite1hTokens ?? 0, input.cacheStorageTokenHours ?? 0);
+  }
+  async setBudget(input) {
+    const created = await this.cloud.client.create("budgets", {
+      project_path: input.project_path,
+      ...input.agent ? { agent: input.agent } : {},
+      period: input.period,
+      limit_usd: input.limit_usd,
+      alert_at_percent: input.alert_at_percent
+    });
+    return created?.id ?? "";
+  }
+  async removeBudget(id) {
+    await this.cloud.client.delete("budgets", id);
+  }
+  async setGoal(input) {
+    await this.cloud.client.create("goals", {
+      period: input.period,
+      project_path: input.project_path,
+      ...input.agent ? { agent: input.agent } : {},
+      limit_usd: input.limit_usd
+    });
+  }
+  async removeGoal(id) {
+    await this.cloud.client.delete("goals", id);
+  }
+  async setPricing(input) {
+    await this.cloud.client.create("pricing", { ...input, updated_at: new Date().toISOString() });
+  }
+  async removePricing(model) {
+    await this.cloud.client.delete("pricing", model);
+  }
+  async setSubscription(input) {
+    const now = new Date().toISOString();
+    const row = {
+      id: input.id ?? randomUUID(),
+      provider: input.provider,
+      plan: input.plan,
+      agent: input.agent,
+      monthly_fee_usd: input.monthly_fee_usd,
+      included_usage_usd: input.included_usage_usd,
+      billing_cycle_start: input.billing_cycle_start,
+      reset_policy: input.reset_policy,
+      active: input.active,
+      created_at: now,
+      updated_at: now
+    };
+    await this.cloud.client.create("subscriptions", row);
+    return row;
+  }
+  async removeSubscription(id) {
+    await this.cloud.client.delete("subscriptions", id);
+  }
+  async addProject(path, name) {
+    await this.cloud.client.create("project-registry", { path, name, description: null, tags: [] });
+  }
+  async renameProject(path, name) {
+    await this.cloud.client.delete("project-registry", path);
+    await this.cloud.client.create("project-registry", { path, name, description: null, tags: [] });
+  }
+  async removeProject(path) {
+    await this.cloud.client.delete("project-registry", path);
+  }
+}
+function getStore(env = process.env) {
+  const cloud = economyCloudStorage(env);
+  return cloud.active ? new ApiStore(cloud) : new LocalStore;
+}
+function isCloudStore(env = process.env) {
+  return economyCloudStorage(env).active;
+}
+
+// src/mcp/server.ts
+var MCP_NAME = "economy";
+var DEFAULT_MCP_HTTP_PORT = 8860;
+function buildServer() {
+  const db = openDatabase();
+  ensurePricingSeeded(db);
+  const store = getStore();
+  const server = new McpServer({
+    name: MCP_NAME,
+    version: packageMetadata.version
+  });
+  const TOOL_NAMES = [
+    "get_cost_summary",
+    "get_sessions",
+    "get_top_sessions",
+    "get_model_breakdown",
+    "get_project_breakdown",
+    "get_agent_breakdown",
+    "get_account_breakdown",
+    "get_budget_status",
+    "set_budget",
+    "remove_budget",
+    "get_pricing",
+    "set_pricing",
+    "remove_pricing",
+    "get_daily",
+    "get_billing_summary",
+    "get_session_detail",
+    "get_usage",
+    "get_savings",
+    "list_subscriptions",
+    "set_subscription",
+    "remove_subscription",
+    "sync",
+    "search_tools",
+    "describe_tools",
+    "get_goals",
+    "set_goal",
+    "remove_goal",
+    "list_machines",
+    "register_agent",
+    "heartbeat",
+    "set_focus",
+    "list_agents",
+    "send_feedback"
+  ];
+  const TOOL_DESCRIPTIONS = {
+    get_cost_summary: "period(today|week|month|year|all), machine?(hostname) -> {total_usd, sessions, requests, tokens, summary}",
+    get_sessions: `agent(${AGENTS.join("|")}), project(partial), account?(key/name/email), machine?(hostname), limit(20) -> compact session table`,
+    get_top_sessions: `n(10), agent(${AGENTS.join("|")}) -> top sessions by cost`,
+    list_machines: "no params -> machine_id, sessions, requests, cost, last_active",
+    get_model_breakdown: "no params -> model, requests, tokens, cost",
+    get_project_breakdown: "period?(today|week|month|year|all) -> project_name, sessions, tokens, cost",
+    get_agent_breakdown: "period?(today|week|month|year|all) -> agent, sessions, requests, tokens, api-equivalent, billable, included",
+    get_account_breakdown: "period?(today|week|month|year|all) -> account profile, sessions, requests, tokens, api-equivalent, billable, included",
+    get_budget_status: "no params -> budget limits, current spend, percent_used, is_over_alert",
+    set_budget: "period(daily|weekly|monthly), limit_usd, project_path?, agent?, alert_at_percent? -> create budget",
+    remove_budget: "id -> delete budget",
+    get_pricing: "no params -> model pricing rows with input, output, cache read/write, and cache storage rates",
+    set_pricing: "model, input_per_1m, output_per_1m, cache_read_per_1m?, cache_write_per_1m?, cache_write_1h_per_1m?, cache_storage_per_1m_hour? -> create/update pricing",
+    remove_pricing: "model -> delete pricing row",
+    get_daily: "days(30) -> daily cost table grouped by date and agent",
+    get_billing_summary: "period(today|yesterday|week|month|year|all) -> actual provider billing totals",
+    get_session_detail: "session_id(prefix ok) -> per-request breakdown with model, tokens, cost",
+    get_usage: `period(today|week|month|year|all), agent?(${AGENTS.join("|")}) -> usage snapshots and all-machine summary`,
+    get_savings: `period(today|week|month|year|all), agent?(${AGENTS.join("|")}) -> subscription/API-equivalent savings`,
+    list_subscriptions: "no params -> configured subscription plans and included usage",
+    set_subscription: `provider, plan, monthly_fee_usd?, included_usage_usd?, agent?(${AGENTS.join("|")}) -> create/update subscription plan`,
+    remove_subscription: "id -> delete subscription plan",
+    sync: `sources(all|${AGENTS.join("|")}) -> ingest latest cost data`,
+    search_tools: "query substring -> tool name list",
+    describe_tools: "names[] -> one-line parameter hints",
+    get_goals: "no params -> goal progress summary",
+    set_goal: "period(day|week|month|year), limit_usd, project_path?, agent? -> create goal",
+    remove_goal: "id -> delete goal",
+    register_agent: "name, session_id? -> register agent session",
+    heartbeat: "agent_id -> update last_seen_at",
+    set_focus: "agent_id, project_id? -> set active project context",
+    list_agents: "no params -> registered agent list",
+    send_feedback: "message, email?, category? -> save feedback locally"
+  };
+  const fmtUsd = (n) => "$" + n.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+  const fmtTok = (n) => n >= 1e9 ? `${(n / 1e9).toFixed(1)}B` : n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n);
+  function fmtSession(s) {
+    const id = String(s["id"] ?? "").slice(0, 8);
+    const agent = String(s["agent"] ?? "");
+    const proj = String(s["project_name"] || s["project_path"] || "\u2014").slice(0, 20);
+    const cost = fmtUsd(Number(s["total_cost_usd"] ?? 0));
+    const tok = fmtTok(Number(s["total_tokens"] ?? 0));
+    return `${id} ${agent.padEnd(6)} ${cost.padEnd(10)} ${tok.padEnd(8)} ${proj}`;
+  }
+  function text(text2) {
+    return { content: [{ type: "text", text: text2 }] };
+  }
+  function textError(message) {
+    return { content: [{ type: "text", text: message }], isError: true };
+  }
+  server.tool("search_tools", "List tool names matching query. Use first to find relevant tools.", { query: z.string().optional() }, async ({ query }) => {
+    const q2 = query?.toLowerCase();
+    const matches = q2 ? TOOL_NAMES.filter((name) => name.includes(q2)) : [...TOOL_NAMES];
+    return text(matches.join(", "));
+  });
   server.tool("describe_tools", "Get param hints for specific tools by name.", { names: z.array(z.string()) }, async ({ names }) => {
     const result = names.map((name) => `${name}: ${TOOL_DESCRIPTIONS[name] ?? "see tool schema"}`).join(`
 `);
@@ -3760,7 +5219,7 @@ function buildServer() {
   });
   server.tool("get_cost_summary", "Cost summary (total_usd, sessions, requests, tokens, human summary). period: today|week|month|year|all. machine: filter by hostname.", { period: z.enum(["today", "week", "month", "year", "all"]).optional(), machine: z.string().optional() }, async ({ period, machine }) => {
     const resolved = period ?? "today";
-    const s = querySummary(db, resolved, machine);
+    const s = await store.summary(resolved, machine);
     const machineLabel = machine ? ` on ${machine}` : "";
     return text([
       `period: ${resolved}${machineLabel}`,
@@ -3779,13 +5238,7 @@ function buildServer() {
     machine: z.string().optional(),
     limit: z.number().int().positive().max(100).optional()
   }, async ({ agent, project, account, machine, limit }) => {
-    const sessions = querySessions(db, {
-      agent,
-      project,
-      account,
-      machine,
-      limit: limit ?? 20
-    });
+    const sessions = await store.sessions({ agent, project, account, machine, limit: limit ?? 20 });
     const lines = ["id       agent  cost       tokens   project"];
     for (const session of sessions)
       lines.push(fmtSession(session));
@@ -3796,14 +5249,14 @@ function buildServer() {
     n: z.number().int().positive().max(100).optional(),
     agent: z.enum(AGENTS).optional()
   }, async ({ n, agent }) => {
-    const sessions = queryTopSessions(db, n ?? 10, agent);
+    const sessions = await store.topSessions(n ?? 10, agent);
     const lines = ["rank  id       agent  cost       tokens   project"];
     sessions.forEach((session, i) => lines.push(`${String(i + 1).padEnd(5)} ${fmtSession(session)}`));
     return text(lines.join(`
 `));
   });
   server.tool("get_model_breakdown", "Cost per model. No params.", {}, async () => {
-    const rows = queryModelBreakdown(db);
+    const rows = await store.modelBreakdown();
     const lines = ["model                          agent     reqs    tokens   cost"];
     for (const row of rows) {
       lines.push(`${String(row["model"]).slice(0, 30).padEnd(31)}${String(row["agent"]).padEnd(10)}${String(row["requests"]).padEnd(8)}${fmtTok(Number(row["total_tokens"])).padEnd(9)}${fmtUsd(Number(row["cost_usd"]))}`);
@@ -3812,7 +5265,7 @@ function buildServer() {
 `));
   });
   server.tool("get_project_breakdown", "Cost per project. Params: period(today|week|month|year|all).", { period: z.enum(["today", "week", "month", "year", "all"]).optional() }, async ({ period }) => {
-    const rows = queryProjectBreakdown(db, period ?? "all");
+    const rows = await store.projectBreakdown({ period: period ?? "all" });
     const lines = ["project              sessions tokens   cost"];
     for (const row of rows) {
       const name = String(row["project_name"] || row["project_path"] || "\u2014").slice(0, 20);
@@ -3822,7 +5275,7 @@ function buildServer() {
 `));
   });
   server.tool("get_agent_breakdown", "Cost per coding agent. Params: period(today|week|month|year|all). Shows API-equivalent, billable API, and subscription-included usage.", { period: z.enum(["today", "week", "month", "year", "all"]).optional() }, async ({ period }) => {
-    const rows = queryAgentBreakdown(db, period ?? "all");
+    const rows = await store.agentBreakdown({ period: period ?? "all" });
     if (rows.length === 0)
       return text("No agent usage yet.");
     const lines = ["agent      sessions requests tokens   api_eq    billable  included"];
@@ -3833,7 +5286,7 @@ function buildServer() {
 `));
   });
   server.tool("get_account_breakdown", "Cost per account/profile. Params: period(today|week|month|year|all). Shows API-equivalent, billable API, and subscription-included usage.", { period: z.enum(["today", "week", "month", "year", "all"]).optional() }, async ({ period }) => {
-    const rows = queryAccountBreakdown(db, period ?? "all");
+    const rows = await store.accountBreakdown({ period: period ?? "all" });
     if (rows.length === 0)
       return text("No account-attributed sessions yet.");
     const lines = ["account              agent      sessions requests tokens   api_eq    billable  included"];
@@ -3845,7 +5298,7 @@ function buildServer() {
 `));
   });
   server.tool("get_budget_status", "Budget limits vs spend, percent used, alert flags. No params.", {}, async () => {
-    const budgets = getBudgetStatuses(db);
+    const budgets = await store.listBudgets();
     if (budgets.length === 0)
       return text("No budgets set.");
     const lines = ["scope                period   spent      limit      used%  status"];
@@ -3865,26 +5318,21 @@ function buildServer() {
     agent: z.enum(AGENTS).optional(),
     alert_at_percent: z.number().positive().max(100).optional()
   }, async ({ period, limit_usd, project_path, agent, alert_at_percent }) => {
-    const now = new Date().toISOString();
-    const id = randomUUID();
-    upsertBudget(db, {
-      id,
+    const id = await store.setBudget({
       project_path: project_path ?? null,
       agent: agent ?? null,
       period,
       limit_usd,
-      alert_at_percent: alert_at_percent ?? 80,
-      created_at: now,
-      updated_at: now
+      alert_at_percent: alert_at_percent ?? 80
     });
     return text(`Budget set: ${id}`);
   });
   server.tool("remove_budget", "Delete a budget by id.", { id: z.string() }, async ({ id }) => {
-    deleteBudget(db, id);
+    await store.removeBudget(id);
     return text("Budget removed.");
   });
   server.tool("get_pricing", "Editable model pricing rows. Includes input/output/cache rates and context-cache storage.", {}, async () => {
-    const rows = listModelPricing(db);
+    const rows = await store.listPricing();
     const lines = ["model                          input    output   cache-r  cache-w  cache-1h storage-h"];
     for (const row of rows) {
       lines.push(`${row.model.slice(0, 30).padEnd(31)}` + `${fmtUsd(row.input_per_1m).padEnd(9)}` + `${fmtUsd(row.output_per_1m).padEnd(9)}` + `${fmtUsd(row.cache_read_per_1m).padEnd(9)}` + `${fmtUsd(row.cache_write_per_1m).padEnd(9)}` + `${fmtUsd(row.cache_write_1h_per_1m ?? 0).padEnd(9)}` + `${fmtUsd(row.cache_storage_per_1m_hour ?? 0)}`);
@@ -3904,24 +5352,23 @@ function buildServer() {
     const model = input.model.trim();
     if (!model)
       return textError("model is required");
-    upsertModelPricing(db, {
+    await store.setPricing({
       model,
       input_per_1m: input.input_per_1m,
       output_per_1m: input.output_per_1m,
       cache_read_per_1m: input.cache_read_per_1m ?? 0,
       cache_write_per_1m: input.cache_write_per_1m ?? 0,
       cache_write_1h_per_1m: input.cache_write_1h_per_1m ?? 0,
-      cache_storage_per_1m_hour: input.cache_storage_per_1m_hour ?? 0,
-      updated_at: new Date().toISOString()
+      cache_storage_per_1m_hour: input.cache_storage_per_1m_hour ?? 0
     });
     return text(`Pricing set: ${model}`);
   });
   server.tool("remove_pricing", "Delete a model pricing row by model id.", { model: z.string() }, async ({ model }) => {
-    deleteModelPricing(db, model);
+    await store.removePricing(model);
     return text("Pricing removed.");
   });
   server.tool("get_daily", "Daily cost table by agent. Params: days(30)", { days: z.number().int().positive().max(365).optional() }, async ({ days }) => {
-    const rows = queryDailyBreakdown(db, days ?? 30);
+    const rows = await store.daily(days ?? 30);
     const byDate = new Map;
     for (const row of rows) {
       const date = String(row["date"]);
@@ -3945,7 +5392,7 @@ function buildServer() {
 `));
   });
   server.tool("get_billing_summary", "Actual provider billing totals from admin API sync. Params: period(today|yesterday|week|month|year|all)", { period: z.enum(["today", "yesterday", "week", "month", "year", "all"]).optional() }, async ({ period }) => {
-    const summary = queryBillingSummary(db, period ?? "month");
+    const summary = await store.billingSummary(period ?? "month");
     const lines = ["provider    billed"];
     for (const [provider, cost] of Object.entries(summary.by_provider)) {
       lines.push(`${provider.padEnd(11)}${fmtUsd(cost)}`);
@@ -3955,10 +5402,10 @@ function buildServer() {
 `));
   });
   server.tool("get_session_detail", "Per-request breakdown of a single session. Params: session_id (prefix ok)", { session_id: z.string() }, async ({ session_id }) => {
-    const session = db.prepare(`SELECT * FROM sessions WHERE id = ? OR id LIKE ?`).get(session_id, `${session_id}%`);
-    if (!session)
+    const detail = await store.sessionDetail(session_id);
+    if (!detail)
       return textError(`Session not found: ${session_id}`);
-    const requests = db.prepare(`SELECT * FROM requests WHERE session_id = ? ORDER BY timestamp ASC LIMIT 50`).all(session["id"]);
+    const { session, requests } = detail;
     const lines = [
       `session: ${String(session["id"]).slice(0, 16)}`,
       `agent: ${session["agent"]}  project: ${session["project_name"] || "\u2014"}`,
@@ -3966,13 +5413,16 @@ function buildServer() {
       "",
       "time      model                  input    output   cache-r  cache-5m cache-1h cost"
     ];
-    for (const request of requests) {
+    for (const request of requests.slice(0, 50)) {
       lines.push(`${String(request["timestamp"]).slice(11, 19)}  ` + `${String(request["model"]).slice(0, 22).padEnd(23)}` + `${fmtTok(Number(request["input_tokens"])).padEnd(9)}` + `${fmtTok(Number(request["output_tokens"])).padEnd(9)}` + `${fmtTok(Number(request["cache_read_tokens"])).padEnd(9)}` + `${fmtTok(Number(request["cache_create_5m_tokens"] ?? request["cache_create_tokens"] ?? 0)).padEnd(9)}` + `${fmtTok(Number(request["cache_create_1h_tokens"] ?? 0)).padEnd(9)}` + `${fmtUsd(Number(request["cost_usd"]))}`);
     }
     return text(lines.join(`
 `));
   });
   server.tool("sync", `Ingest new cost data. sources: all|${AGENTS.join("|")}`, { sources: z.enum(["all", ...AGENTS]).optional() }, async ({ sources }) => {
+    if (isCloudStore()) {
+      return text("cloud mode: ingest is a local-only operation; nothing to sync (reads/writes route to the cloud API)");
+    }
     const selected = sources ?? "all";
     const opts = selected === "all" ? {} : { [selected]: true };
     const result = await syncAll(db, opts);
@@ -3980,15 +5430,13 @@ function buildServer() {
   });
   server.tool("get_usage", "Usage snapshots and fleet summary. period: today|week|month|year|all", { period: z.enum(["today", "week", "month", "year", "all"]).optional(), agent: z.enum(AGENTS).optional() }, async ({ period, agent }) => {
     const p = period ?? "month";
-    const snaps = queryUsageSnapshots(db, { agent, ...usageSnapshotFilterForPeriod(p) });
-    const summary = querySummary(db, p, undefined, true);
-    return text(JSON.stringify({ snapshots: snaps, summary }, null, 2));
+    return text(JSON.stringify(await store.usage(p, agent), null, 2));
   });
   server.tool("get_savings", "Subscription vs API savings summary", { period: z.enum(["today", "week", "month", "year", "all"]).optional(), agent: z.enum(AGENTS).optional() }, async ({ period, agent }) => {
-    return text(JSON.stringify(querySavingsSummary(db, period ?? "month", agent), null, 2));
+    return text(JSON.stringify(await store.savings(period ?? "month", agent), null, 2));
   });
   server.tool("list_subscriptions", "List configured subscription plans used by savings calculations.", {}, async () => {
-    const rows = listSubscriptions(db);
+    const rows = await store.listSubscriptions();
     if (rows.length === 0)
       return text("No subscriptions configured.");
     const lines = ["id                 provider   plan       agent      fee       included  active"];
@@ -4009,9 +5457,8 @@ function buildServer() {
     reset_policy: z.string().optional(),
     active: z.boolean().optional()
   }, async (input) => {
-    const now = new Date().toISOString();
-    const row = {
-      id: input.id ?? randomUUID(),
+    const row = await store.setSubscription({
+      id: input.id,
       provider: input.provider,
       plan: input.plan,
       agent: input.agent ?? null,
@@ -4019,23 +5466,20 @@ function buildServer() {
       included_usage_usd: input.included_usage_usd ?? 0,
       billing_cycle_start: input.billing_cycle_start ?? null,
       reset_policy: input.reset_policy ?? "monthly",
-      active: input.active === false ? 0 : 1,
-      created_at: now,
-      updated_at: now
-    };
-    upsertSubscription(db, row);
+      active: input.active === false ? 0 : 1
+    });
     return text(JSON.stringify(row, null, 2));
   });
   server.tool("remove_subscription", "Delete a subscription plan by id.", { id: z.string() }, async ({ id }) => {
-    deleteSubscription(db, id);
+    await store.removeSubscription(id);
     return text("Subscription removed.");
   });
   server.tool("estimate_cost", "Pre-flight cost estimate for token counts", { model: z.string(), input_tokens: z.number().optional(), output_tokens: z.number().optional() }, async ({ model, input_tokens, output_tokens }) => {
-    const cost = computeCostFromDb(db, model, input_tokens ?? 0, output_tokens ?? 0, 0, 0, 0);
+    const cost = await store.estimate({ model, inputTokens: input_tokens ?? 0, outputTokens: output_tokens ?? 0 });
     return text(`${model}: ${fmtUsd(cost)} (${input_tokens ?? 0} in / ${output_tokens ?? 0} out)`);
   });
   server.tool("get_goals", "All spending goals with current progress. No params.", {}, async () => {
-    const goals = getGoalStatuses(db);
+    const goals = await store.listGoals();
     if (goals.length === 0)
       return text("No goals set.");
     const lines = ["period   scope                limit      spent      used%  status"];
@@ -4054,24 +5498,20 @@ function buildServer() {
     project_path: z.string().optional(),
     agent: z.string().optional()
   }, async ({ period, limit_usd, project_path, agent }) => {
-    const now = new Date().toISOString();
-    upsertGoal(db, {
-      id: randomUUID(),
+    await store.setGoal({
       period,
       project_path: project_path ?? null,
       agent: agent ?? null,
-      limit_usd,
-      created_at: now,
-      updated_at: now
+      limit_usd
     });
     return text(`Goal set: ${period} $${limit_usd}`);
   });
   server.tool("remove_goal", "Delete a goal by id.", { id: z.string() }, async ({ id }) => {
-    deleteGoal(db, id);
+    await store.removeGoal(id);
     return text("Goal removed.");
   });
   server.tool("list_machines", "List all machines that have synced data. No params.", {}, async () => {
-    const machines = listMachines(db);
+    const machines = await store.machines();
     if (machines.length === 0)
       return text(`No machine data yet. Current machine: ${getMachineId()}`);
     const lines = ["machine          sessions  requests  cost        last_active"];
@@ -4083,32 +5523,7 @@ current machine: ${getMachineId()}`);
     return text(lines.join(`
 `));
   });
-  server.tool("register_agent", "Register agent session.", { name: z.string(), session_id: z.string().optional() }, async ({ name }) => {
-    const existing = [..._econAgents.values()].find((agent2) => agent2.name === name);
-    if (existing) {
-      existing.last_seen_at = new Date().toISOString();
-      return text(JSON.stringify(existing));
-    }
-    const id = Math.random().toString(36).slice(2, 10);
-    const agent = { id, name, last_seen_at: new Date().toISOString() };
-    _econAgents.set(id, agent);
-    return text(JSON.stringify(agent));
-  });
-  server.tool("heartbeat", "Update last_seen_at.", { agent_id: z.string() }, async ({ agent_id }) => {
-    const agent = _econAgents.get(agent_id);
-    if (!agent)
-      return textError("Agent not found");
-    agent.last_seen_at = new Date().toISOString();
-    return text(`\u2665 ${agent.name}`);
-  });
-  server.tool("set_focus", "Set active project context.", { agent_id: z.string(), project_id: z.string().optional().nullable() }, async ({ agent_id, project_id }) => {
-    const agent = _econAgents.get(agent_id);
-    if (!agent)
-      return textError("Agent not found");
-    agent.project_id = project_id ?? undefined;
-    return text(project_id ? `Focus: ${project_id}` : "Focus cleared");
-  });
-  server.tool("list_agents", "List all registered agents.", {}, async () => text(JSON.stringify([..._econAgents.values()])));
+  registerAgentTools(server, { includeFeedback: false });
   server.tool("send_feedback", "Send feedback about this service.", {
     message: z.string(),
     email: z.string().optional(),
@@ -4126,48 +5541,31 @@ current machine: ${getMachineId()}`);
 }
 
 // src/mcp/http.ts
-import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import {
+  healthPayload,
+  isHttpMode as harnessIsHttpMode,
+  isStdioMode as harnessIsStdioMode,
+  resolveMcpHttpPort as harnessResolveMcpHttpPort
+} from "@hasna/mcp-harness";
+import { handleMcpHttpRequest as harnessHandleMcpHttpRequest } from "@hasna/mcp-harness/bun";
 var MCP_HTTP_IDLE_TIMEOUT_SECONDS = 0;
 function isHttpMode(argv = process.argv.slice(2)) {
-  return argv.includes("--http") || process.env["MCP_HTTP"] === "1";
+  return harnessIsHttpMode(argv);
 }
 function isStdioMode(argv = process.argv.slice(2)) {
-  return argv.includes("--stdio") || process.env["MCP_STDIO"] === "1";
+  return harnessIsStdioMode(argv);
 }
 function resolveHttpPort(argv = process.argv.slice(2)) {
-  for (let i = 0;i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg === "--port" || arg === "-p") {
-      const raw = argv[i + 1];
-      if (!raw)
-        throw new Error(`Invalid port: ${raw ?? ""}`);
-      return parsePort(raw, "port");
-    }
-  }
-  const fromEnv = process.env["MCP_HTTP_PORT"];
-  if (fromEnv)
-    return parsePort(fromEnv, "MCP_HTTP_PORT");
-  return DEFAULT_MCP_HTTP_PORT;
-}
-function parsePort(raw, label) {
-  const value = Number(raw);
-  if (!Number.isInteger(value) || value < 1 || value > 65535) {
-    throw new Error(`Invalid ${label}: ${raw}`);
-  }
-  return value;
+  const normalized = argv.map((arg) => arg === "-p" ? "--port" : arg);
+  return harnessResolveMcpHttpPort({ argv: normalized, default: DEFAULT_MCP_HTTP_PORT });
 }
 async function handleMcpHttpRequest(req) {
   const url = new URL(req.url);
   if (url.pathname === "/health" && req.method === "GET") {
-    return Response.json({ status: "ok", name: MCP_NAME });
+    return Response.json(healthPayload(MCP_NAME));
   }
   if (url.pathname === "/mcp") {
-    const transport = new WebStandardStreamableHTTPServerTransport({
-      sessionIdGenerator: undefined
-    });
-    const server = buildServer();
-    await server.connect(transport);
-    return transport.handleRequest(req);
+    return harnessHandleMcpHttpRequest(req, buildServer);
   }
   return new Response("Not Found", { status: 404 });
 }