@hasna/economy 0.3.6 → 0.3.8

package/dist/mcp/index.js

@@ -17,6 +17,62 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
+// src/db/sqlite-adapter.ts
+import { Database } from "bun:sqlite";
+
+class SqliteAdapter {
+  db;
+  constructor(path) {
+    this.db = new Database(path, { create: true });
+    this.db.exec("PRAGMA journal_mode=WAL");
+    this.db.exec("PRAGMA foreign_keys=ON");
+  }
+  run(sql, ...params) {
+    const result = this.db.prepare(sql).run(...params);
+    return { changes: result.changes, lastInsertRowid: result.lastInsertRowid };
+  }
+  get(sql, ...params) {
+    return this.db.prepare(sql).get(...params);
+  }
+  all(sql, ...params) {
+    return this.db.prepare(sql).all(...params);
+  }
+  exec(sql) {
+    this.db.exec(sql);
+  }
+  query(sql) {
+    return this.db.query(sql);
+  }
+  prepare(sql) {
+    const stmt = this.db.prepare(sql);
+    return {
+      run(...params) {
+        const r = stmt.run(...params);
+        return { changes: r.changes, lastInsertRowid: r.lastInsertRowid };
+      },
+      get(...params) {
+        return stmt.get(...params);
+      },
+      all(...params) {
+        return stmt.all(...params);
+      },
+      finalize() {
+        stmt.finalize();
+      }
+    };
+  }
+  close() {
+    this.db.close();
+  }
+  transaction(fn) {
+    return this.db.transaction(fn)();
+  }
+  get raw() {
+    return this.db;
+  }
+}
+var init_sqlite_adapter = () => {};
+
 // src/lib/pricing.ts
 var exports_pricing = {};
 __export(exports_pricing, {
@@ -535,7 +591,6 @@ var init_pricing = __esm(() => {
 });
 
 // src/db/database.ts
-import { SqliteAdapter as Database } from "@hasna/cloud";
 import { execFileSync } from "child_process";
 import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
 import { hostname, platform } from "os";
@@ -628,7 +683,7 @@ function openDatabase(dbPath, skipSeed = false) {
       mkdirSync(dir, { recursive: true });
   }
   const db = withSqliteBusyRetry(() => {
-    const opened = new Database(path);
+    const opened = new SqliteAdapter(path);
     try {
       opened.exec("PRAGMA busy_timeout = 10000");
       opened.exec("PRAGMA journal_mode = WAL");
@@ -669,6 +724,16 @@ function addColumnIfMissing(db, table, column, definition) {
 }
 function initSchema(db) {
   db.exec(`
+    CREATE TABLE IF NOT EXISTS cost_centers (
+      id TEXT PRIMARY KEY,
+      kind TEXT NOT NULL,
+      name TEXT NOT NULL,
+      repo_path TEXT,
+      labels_json TEXT DEFAULT '{}',
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
     CREATE TABLE IF NOT EXISTS requests (
       id TEXT PRIMARY KEY,
       agent TEXT NOT NULL,
@@ -685,6 +750,7 @@ function initSchema(db) {
       timestamp TEXT NOT NULL,
       source_request_id TEXT,
       machine_id TEXT DEFAULT '',
+      cost_center_id TEXT,
       account_key TEXT DEFAULT '',
       account_tool TEXT DEFAULT '',
       account_name TEXT DEFAULT '',
@@ -703,6 +769,7 @@ function initSchema(db) {
       total_tokens INTEGER DEFAULT 0,
       request_count INTEGER DEFAULT 0,
       machine_id TEXT DEFAULT '',
+      cost_center_id TEXT,
       account_key TEXT DEFAULT '',
       account_tool TEXT DEFAULT '',
       account_name TEXT DEFAULT '',
@@ -723,6 +790,7 @@ function initSchema(db) {
       id TEXT PRIMARY KEY,
       project_path TEXT,
       agent TEXT,
+      cost_center_id TEXT,
       period TEXT NOT NULL,
       limit_usd REAL NOT NULL,
       alert_at_percent INTEGER DEFAULT 80,
@@ -753,6 +821,7 @@ function initSchema(db) {
     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_cost_centers_kind ON cost_centers(kind);
 
     CREATE TABLE IF NOT EXISTS model_pricing (
       model TEXT PRIMARY KEY,
@@ -839,6 +908,12 @@ function initSchema(db) {
   `);
   addColumnIfMissing(db, "requests", "machine_id", `TEXT DEFAULT ''`);
   addColumnIfMissing(db, "sessions", "machine_id", `TEXT DEFAULT ''`);
+  if (addColumnIfMissing(db, "cost_centers", "updated_at", `TEXT DEFAULT ''`)) {
+    db.exec(`UPDATE cost_centers SET updated_at = created_at WHERE updated_at = '' OR updated_at IS NULL`);
+  }
+  addColumnIfMissing(db, "requests", "cost_center_id", `TEXT`);
+  addColumnIfMissing(db, "sessions", "cost_center_id", `TEXT`);
+  addColumnIfMissing(db, "budgets", "cost_center_id", `TEXT`);
   if (addColumnIfMissing(db, "requests", "cache_create_5m_tokens", "INTEGER DEFAULT 0")) {
     db.exec(`UPDATE requests SET cache_create_5m_tokens = cache_create_tokens WHERE cache_create_5m_tokens = 0`);
   }
@@ -867,6 +942,10 @@ function initSchema(db) {
     CREATE INDEX IF NOT EXISTS idx_sessions_machine ON sessions(machine_id);
     CREATE INDEX IF NOT EXISTS idx_requests_account ON requests(account_key);
     CREATE INDEX IF NOT EXISTS idx_sessions_account ON sessions(account_key);
+    CREATE INDEX IF NOT EXISTS idx_requests_cost_center ON requests(cost_center_id);
+    CREATE INDEX IF NOT EXISTS idx_sessions_cost_center ON sessions(cost_center_id);
+    CREATE INDEX IF NOT EXISTS idx_budgets_cost_center ON budgets(cost_center_id);
+    CREATE INDEX IF NOT EXISTS idx_cost_centers_kind ON cost_centers(kind);
   `);
 }
 function periodWhere(period) {
@@ -917,6 +996,14 @@ function requestPeriodWhere(period) {
       return "1=1";
   }
 }
+function upsertCostCenter(db, center) {
+  const updatedAt = center.updated_at ?? center.created_at;
+  db.prepare(`
+    INSERT OR REPLACE INTO cost_centers
+      (id, kind, name, repo_path, labels_json, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(center.id, center.kind, center.name, center.repo_path ?? null, center.labels_json ?? "{}", center.created_at, updatedAt);
+}
 function upsertRequest(db, req) {
   const now = req.updated_at ?? new Date().toISOString();
   db.prepare(`
@@ -924,10 +1011,10 @@ function upsertRequest(db, req) {
       (id, agent, session_id, model, input_tokens, output_tokens,
        cache_read_tokens, cache_create_tokens, cache_create_5m_tokens,
        cache_create_1h_tokens, cost_usd, cost_basis, duration_ms, timestamp,
-       source_request_id, machine_id, attribution_tag, account_key, account_tool,
+       source_request_id, machine_id, cost_center_id, attribution_tag, account_key, account_tool,
        account_name, account_email, account_source, updated_at, synced_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(req.id, req.agent, req.session_id, req.model, req.input_tokens, req.output_tokens, req.cache_read_tokens, req.cache_create_tokens, req.cache_create_5m_tokens ?? req.cache_create_tokens, req.cache_create_1h_tokens ?? 0, req.cost_usd, req.cost_basis ?? "estimated", req.duration_ms, req.timestamp, req.source_request_id, req.machine_id ?? "", req.attribution_tag ?? process.env["ECONOMY_TAG"] ?? "", req.account_key ?? "", req.account_tool ?? "", req.account_name ?? "", req.account_email ?? "", req.account_source ?? "", now, req.synced_at ?? "");
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(req.id, req.agent, req.session_id, req.model, req.input_tokens, req.output_tokens, req.cache_read_tokens, req.cache_create_tokens, req.cache_create_5m_tokens ?? req.cache_create_tokens, req.cache_create_1h_tokens ?? 0, req.cost_usd, req.cost_basis ?? "estimated", req.duration_ms, req.timestamp, req.source_request_id, req.machine_id ?? "", req.cost_center_id ?? null, req.attribution_tag ?? process.env["ECONOMY_TAG"] ?? "", req.account_key ?? "", req.account_tool ?? "", req.account_name ?? "", req.account_email ?? "", req.account_source ?? "", now, req.synced_at ?? "");
 }
 function upsertSession(db, session) {
   const now = session.updated_at ?? new Date().toISOString();
@@ -935,9 +1022,9 @@ function upsertSession(db, session) {
     INSERT OR REPLACE INTO sessions
       (id, agent, project_path, project_name, started_at, ended_at,
        total_cost_usd, total_tokens, request_count, machine_id, attribution_tag,
-       account_key, account_tool, account_name, account_email, account_source, updated_at, synced_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(session.id, session.agent, session.project_path, session.project_name, session.started_at, session.ended_at ?? null, session.total_cost_usd, session.total_tokens, session.request_count, session.machine_id ?? "", session.attribution_tag ?? process.env["ECONOMY_TAG"] ?? "", session.account_key ?? "", session.account_tool ?? "", session.account_name ?? "", session.account_email ?? "", session.account_source ?? "", now, session.synced_at ?? "");
+       cost_center_id, account_key, account_tool, account_name, account_email, account_source, updated_at, synced_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(session.id, session.agent, session.project_path, session.project_name, session.started_at, session.ended_at ?? null, session.total_cost_usd, session.total_tokens, session.request_count, session.machine_id ?? "", session.attribution_tag ?? process.env["ECONOMY_TAG"] ?? "", session.cost_center_id ?? null, session.account_key ?? "", session.account_tool ?? "", session.account_name ?? "", session.account_email ?? "", session.account_source ?? "", now, session.synced_at ?? "");
 }
 function rollupSession(db, sessionId) {
   db.prepare(`
@@ -963,9 +1050,12 @@ function rollupSession(db, sessionId) {
                             ELSE account_email END,
       account_source = CASE WHEN account_source = '' OR account_source IS NULL
                             THEN COALESCE((SELECT account_source FROM requests WHERE session_id = ? AND account_source != '' ORDER BY timestamp DESC LIMIT 1), '')
-                            ELSE account_source END
+                            ELSE account_source END,
+      cost_center_id = CASE WHEN cost_center_id = '' OR cost_center_id IS NULL
+                            THEN COALESCE((SELECT cost_center_id FROM requests WHERE session_id = ? AND cost_center_id IS NOT NULL AND cost_center_id != '' ORDER BY timestamp DESC LIMIT 1), NULL)
+                            ELSE cost_center_id END
     WHERE id = ?
-  `).run(sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId);
+  `).run(sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId, sessionId);
 }
 function querySessions(db, filter = {}) {
   const conditions = [];
@@ -1181,9 +1271,12 @@ function labelForPath(projectPath, projectName) {
 function groupKeyForPath(projectPath, projectName) {
   return labelForPath(projectPath, projectName).trim().toLowerCase();
 }
-function queryProjectBreakdown(db, period = "all", machine) {
-  const requestWhere = requestPeriodWhere(period);
-  const sessionWhere = sessionPeriodWhere(period);
+function laterTimestamp(current, candidate) {
+  if (!candidate)
+    return current;
+  return candidate > current ? candidate : current;
+}
+function queryProjectBreakdownScoped(db, requestWhere, sessionWhere, requestScopeParams = [], sessionScopeParams = [], machine) {
   const sessionMachineClause = machine ? " AND (machine_id = ? OR id IN (SELECT DISTINCT session_id FROM requests WHERE machine_id = ?))" : "";
   const requestMachineClause = machine ? " AND machine_id = ?" : "";
   const sessionMachineParams = machine ? [machine, machine] : [];
@@ -1191,67 +1284,89 @@ function queryProjectBreakdown(db, period = "all", machine) {
   const sessionOnlyMachineClause = machine ? " AND machine_id = ?" : "";
   const sessionOnlyMachineParams = machine ? [machine] : [];
   const sessions = db.prepare(`
-    SELECT id, project_path, project_name, total_cost_usd, started_at
+    SELECT id, project_path, project_name
     FROM sessions
     WHERE (project_path != '' OR project_name != '')${sessionMachineClause}
   `).all(...sessionMachineParams);
   const groups = new Map;
+  const groupKeyBySession = new Map;
   for (const s of sessions) {
     const label = labelForPath(s.project_path, s.project_name);
     if (!label)
       continue;
     const key = groupKeyForPath(s.project_path, s.project_name);
-    const g = groups.get(key) ?? { label, sessionIds: [], samplePath: s.project_path };
-    g.sessionIds.push(s.id);
+    const g = groups.get(key) ?? { label, samplePath: s.project_path, sessions: 0, requests: 0, total_tokens: 0, cost_usd: 0, last_active: "" };
     if (!g.samplePath)
       g.samplePath = s.project_path;
     groups.set(key, g);
+    groupKeyBySession.set(s.id, key);
+  }
+  const groupFor = (sessionId) => {
+    const key = groupKeyBySession.get(sessionId);
+    return key === undefined ? undefined : groups.get(key);
+  };
+  const requestRows = db.prepare(`
+    SELECT session_id,
+           COUNT(*) as requests,
+           COALESCE(SUM(cost_usd), 0) as cost_usd,
+           COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
+           MAX(timestamp) as last_active
+    FROM requests
+    WHERE ${requestWhere}${requestMachineClause}
+    GROUP BY session_id
+  `).all(...requestScopeParams, ...requestMachineParams);
+  for (const row of requestRows) {
+    const g = groupFor(row.session_id);
+    if (!g)
+      continue;
+    g.sessions += 1;
+    g.requests += row.requests;
+    g.cost_usd += row.cost_usd;
+    g.total_tokens += row.total_tokens;
+    g.last_active = laterTimestamp(g.last_active, row.last_active);
+  }
+  const sessionsWithRequests = new Set(db.prepare(`SELECT DISTINCT session_id FROM requests`).all().map((row) => row.session_id));
+  const sessionOnlyRows = db.prepare(`
+    SELECT id,
+           COALESCE(request_count, 0) as request_count,
+           COALESCE(total_tokens, 0) as total_tokens,
+           COALESCE(total_cost_usd, 0) as total_cost_usd,
+           started_at
+    FROM sessions
+    WHERE ${sessionWhere}${sessionOnlyMachineClause}
+  `).all(...sessionScopeParams, ...sessionOnlyMachineParams);
+  for (const row of sessionOnlyRows) {
+    if (sessionsWithRequests.has(row.id))
+      continue;
+    const g = groupFor(row.id);
+    if (!g)
+      continue;
+    g.sessions += 1;
+    g.requests += row.request_count;
+    g.total_tokens += row.total_tokens;
+    g.cost_usd += row.total_cost_usd;
+    g.last_active = laterTimestamp(g.last_active, row.started_at);
   }
   const result = [];
   for (const g of groups.values()) {
-    const placeholders = g.sessionIds.map(() => "?").join(",");
-    const reqStats = placeholders.length ? db.prepare(`
-          SELECT
-            COUNT(DISTINCT session_id) as sessions,
-            COUNT(*) as requests,
-            COALESCE(SUM(cost_usd), 0) as cost_usd,
-            COALESCE(SUM(input_tokens + output_tokens + cache_read_tokens + cache_create_tokens), 0) as total_tokens,
-            MAX(timestamp) as last_active
-          FROM requests
-          WHERE session_id IN (${placeholders})
-            AND ${requestWhere}
-            ${requestMachineClause}
-        `).get(...g.sessionIds, ...requestMachineParams) : { sessions: 0, requests: 0, cost_usd: 0, total_tokens: 0, last_active: null };
-    const sessionOnlyStats = placeholders.length ? db.prepare(`
-          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 id IN (${placeholders})
-            AND ${sessionWhere}
-            ${sessionOnlyMachineClause}
-            AND id NOT IN (SELECT DISTINCT session_id FROM requests)
-        `).get(...g.sessionIds, ...sessionOnlyMachineParams) : { sessions: 0, requests: 0, total_tokens: 0, cost_usd: 0, last_active: null };
-    const totalSessions = reqStats.sessions + sessionOnlyStats.sessions;
-    if (totalSessions === 0)
+    if (g.sessions === 0)
       continue;
-    const lastActive = [reqStats.last_active, sessionOnlyStats.last_active].filter(Boolean).sort().at(-1) ?? "";
     result.push({
       project_path: g.samplePath,
       project_name: g.label,
-      sessions: totalSessions,
-      requests: reqStats.requests + sessionOnlyStats.requests,
-      total_tokens: reqStats.total_tokens + sessionOnlyStats.total_tokens,
-      cost_usd: reqStats.cost_usd + sessionOnlyStats.cost_usd,
-      last_active: lastActive
+      sessions: g.sessions,
+      requests: g.requests,
+      total_tokens: g.total_tokens,
+      cost_usd: g.cost_usd,
+      last_active: g.last_active
     });
   }
   result.sort((a, b) => b.cost_usd - a.cost_usd);
   return result;
 }
+function queryProjectBreakdown(db, period = "all", machine) {
+  return queryProjectBreakdownScoped(db, requestPeriodWhere(period), sessionPeriodWhere(period), [], [], machine);
+}
 function normalizeAccountEmail(email) {
   return (email ?? "").trim().toLowerCase();
 }
@@ -1392,17 +1507,141 @@ 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 kindFromCostCenterId(id) {
+  const prefix = id.split(":", 1)[0] ?? "";
+  return ["loop", "app", "repo", "service", "team"].includes(prefix) ? prefix : "";
+}
+function addCostCenterBreakdownRow(groups, row, sessionOnly) {
+  if (!row.cost_center_id)
+    return;
+  const derivedKind = row.kind || kindFromCostCenterId(row.cost_center_id) || "service";
+  const group = groups.get(row.cost_center_id) ?? {
+    cost_center_id: row.cost_center_id,
+    kind: derivedKind,
+    name: row.name || row.cost_center_id,
+    repo_path: row.repo_path ?? null,
+    labels_json: row.labels_json || "{}",
+    sessionIds: new Set,
+    requests: 0,
+    total_tokens: 0,
+    api_equivalent_usd: 0,
+    metered_api_usd: 0,
+    subscription_included_usd: 0,
+    estimated_usd: 0,
+    unknown_usd: 0,
+    last_active: ""
+  };
+  group.kind = derivedKind;
+  if (row.name)
+    group.name = row.name;
+  if (row.repo_path && !group.repo_path)
+    group.repo_path = row.repo_path;
+  if (row.labels_json && row.labels_json !== "{}")
+    group.labels_json = row.labels_json;
+  if (row.session_id)
+    group.sessionIds.add(row.session_id);
+  group.requests += row.requests;
+  group.total_tokens += row.total_tokens;
+  group.api_equivalent_usd += row.cost_usd;
+  if (sessionOnly) {
+    group.estimated_usd += row.cost_usd;
+  } else if (row.cost_basis === "metered_api") {
+    group.metered_api_usd += row.cost_usd;
+  } else if (row.cost_basis === "subscription_included") {
+    group.subscription_included_usd += row.cost_usd;
+  } else if (row.cost_basis === "unknown") {
+    group.unknown_usd += row.cost_usd;
+  } else {
+    group.estimated_usd += row.cost_usd;
+  }
+  if (!group.last_active || row.last_active > group.last_active)
+    group.last_active = row.last_active;
+  groups.set(row.cost_center_id, group);
+}
+function queryCostCenterBreakdown(db, period = "all", filter = {}) {
+  const requestWhere = filter.since ? "r.timestamp >= ?" : requestPeriodWhere(period);
+  const sessionWhere = filter.since ? "s.started_at >= ?" : sessionPeriodWhere(period);
+  const requestMachineClause = filter.machine ? " AND r.machine_id = ?" : "";
+  const sessionMachineClause = filter.machine ? " AND s.machine_id = ?" : "";
+  const requestParams = [];
+  const sessionParams = [];
+  if (filter.since) {
+    requestParams.push(filter.since);
+    sessionParams.push(filter.since);
+  }
+  if (filter.machine) {
+    requestParams.push(filter.machine);
+    sessionParams.push(filter.machine);
+  }
+  const groups = new Map;
+  const requestRows = db.prepare(`
+    SELECT
+      COALESCE(NULLIF(r.cost_center_id, ''), NULLIF(s.cost_center_id, '')) as cost_center_id,
+      COALESCE(cc.kind, '') as kind,
+      COALESCE(cc.name, COALESCE(NULLIF(r.cost_center_id, ''), NULLIF(s.cost_center_id, ''))) as name,
+      cc.repo_path as repo_path,
+      COALESCE(cc.labels_json, '{}') as labels_json,
+      r.session_id as session_id,
+      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
+    LEFT JOIN cost_centers cc ON cc.id = COALESCE(NULLIF(r.cost_center_id, ''), NULLIF(s.cost_center_id, ''))
+    WHERE ${requestWhere}${requestMachineClause}
+      AND COALESCE(NULLIF(r.cost_center_id, ''), NULLIF(s.cost_center_id, '')) IS NOT NULL
+      AND COALESCE(NULLIF(r.cost_center_id, ''), NULLIF(s.cost_center_id, '')) != ''
+  `).all(...requestParams);
+  for (const row of requestRows)
+    addCostCenterBreakdownRow(groups, row, false);
+  const sessionOnlyRows = db.prepare(`
+    SELECT
+      s.cost_center_id as cost_center_id,
+      COALESCE(cc.kind, '') as kind,
+      COALESCE(cc.name, s.cost_center_id) as name,
+      cc.repo_path as repo_path,
+      COALESCE(cc.labels_json, '{}') as labels_json,
+      s.id as session_id,
+      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
+    LEFT JOIN cost_centers cc ON cc.id = s.cost_center_id
+    WHERE ${sessionWhere}${sessionMachineClause}
+      AND s.id NOT IN (SELECT DISTINCT session_id FROM requests)
+      AND s.cost_center_id IS NOT NULL
+      AND s.cost_center_id != ''
+  `).all(...sessionParams);
+  for (const row of sessionOnlyRows)
+    addCostCenterBreakdownRow(groups, row, true);
+  const result = [...groups.values()].map((group) => ({
+    cost_center_id: group.cost_center_id,
+    kind: group.kind,
+    name: group.name,
+    repo_path: group.repo_path,
+    labels_json: group.labels_json,
+    sessions: group.sessionIds.size,
+    requests: group.requests,
+    total_tokens: group.total_tokens,
+    api_equivalent_usd: group.api_equivalent_usd,
+    billable_usd: group.metered_api_usd,
+    metered_api_usd: group.metered_api_usd,
+    subscription_included_usd: group.subscription_included_usd,
+    estimated_usd: group.estimated_usd,
+    unknown_usd: group.unknown_usd,
+    cost_usd: group.api_equivalent_usd,
+    last_active: group.last_active
+  }));
+  const filtered = filter.kind ? result.filter((row) => row.kind === filter.kind) : result;
+  filtered.sort((a, b) => b.cost_usd - a.cost_usd);
+  return filtered;
+}
+function queryProjectBreakdownSince(db, since, machine) {
+  return queryProjectBreakdownScoped(db, "timestamp >= ?", "started_at >= ?", [since], [since], machine);
 }
 function queryAgentBreakdownSince(db, since) {
   return db.prepare(`
@@ -1563,9 +1802,9 @@ function deleteProject(db, path) {
 function upsertBudget(db, budget) {
   db.prepare(`
     INSERT OR REPLACE INTO budgets
-      (id, project_path, agent, period, limit_usd, alert_at_percent, created_at, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(budget.id, budget.project_path ?? null, budget.agent ?? null, budget.period, budget.limit_usd, budget.alert_at_percent, budget.created_at, budget.updated_at);
+      (id, project_path, agent, cost_center_id, period, limit_usd, alert_at_percent, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(budget.id, budget.project_path ?? null, budget.agent ?? null, budget.cost_center_id ?? null, budget.period, budget.limit_usd, budget.alert_at_percent, budget.created_at, budget.updated_at);
 }
 function listBudgets(db) {
   return db.prepare(`SELECT * FROM budgets ORDER BY created_at DESC`).all();
@@ -1587,6 +1826,10 @@ function getBudgetStatuses(db) {
       spendQuery += ` AND agent = ?`;
       params.push(b.agent);
     }
+    if (b.cost_center_id) {
+      spendQuery += ` AND COALESCE(NULLIF(cost_center_id, ''), (SELECT NULLIF(s.cost_center_id, '') FROM sessions s WHERE s.id = requests.session_id)) = ?`;
+      params.push(b.cost_center_id);
+    }
     const row = db.prepare(spendQuery).get(...params);
     const spend = row.spend;
     const percent = b.limit_usd > 0 ? spend / b.limit_usd * 100 : 0;
@@ -1812,7 +2055,9 @@ function dedupeRequests(db) {
   }
   return removed;
 }
-var init_database = () => {};
+var init_database = __esm(() => {
+  init_sqlite_adapter();
+});
 
 // src/mcp/index.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -1836,7 +2081,6 @@ var packageMetadata = getPackageMetadata();
 // src/mcp/server.ts
 init_database();
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { registerCloudTools } from "@hasna/cloud";
 import { registerAgentTools } from "@hasna/agent-registry";
 import { z } from "zod";
 
@@ -2002,6 +2246,7 @@ function defaultCostBasisForAgent(agent) {
 }
 
 // src/lib/accounts.ts
+import { appliedProfileName, resolveStore } from "@hasna/accounts";
 var AGENT_ACCOUNT_TOOLS = {
   claude: ["claude"],
   takumi: ["takumi", "claude"],
@@ -2066,57 +2311,35 @@ function envOverride(agent, env) {
     account_source: "override"
   };
 }
-function knownToolIds(api) {
-  try {
-    return new Set(api.listTools().map((tool) => tool.id));
-  } catch {
-    return new Set;
-  }
-}
-function profileForEnvDir(api, tool, env) {
+async function profileForEnvDir(store, tool, env) {
   const configuredDir = env[tool.envVar];
   if (!configuredDir)
     return null;
   const normalized = normalizeDir(configuredDir);
-  try {
-    return api.listProfiles(tool.id).find((profile) => normalizeDir(profile.dir) === normalized) ?? null;
-  } catch {
-    return null;
-  }
+  return (await store.listProfiles(tool.id)).find((profile) => normalizeDir(profile.dir) === normalized) ?? null;
 }
 async function resolveAccountForAgent(agent, env = process.env) {
   const override = envOverride(agent, env);
   if (override)
     return override;
-  let api;
-  try {
-    api = await import("@hasna/accounts");
-  } catch {
-    return null;
-  }
-  const toolIds = knownToolIds(api);
+  const store = resolveStore(env);
+  const tools = new Map((await store.listTools()).map((tool) => [tool.id, tool]));
   for (const toolId of AGENT_ACCOUNT_TOOLS[agent]) {
-    if (!toolIds.has(toolId))
-      continue;
-    let tool;
-    try {
-      tool = api.getTool(toolId);
-    } catch {
+    const tool = tools.get(toolId);
+    if (!tool)
       continue;
-    }
-    const envProfile = profileForEnvDir(api, tool, env);
+    const envProfile = await profileForEnvDir(store, tool, env);
     if (envProfile)
       return fromProfile(envProfile, "env");
-    try {
-      const applied = api.appliedProfile(toolId);
+    const appliedName = appliedProfileName(toolId);
+    if (appliedName) {
+      const applied = await store.findProfile(appliedName, toolId);
       if (applied)
         return fromProfile(applied, "applied");
-    } catch {}
-    try {
-      const current = api.currentProfile(toolId);
-      if (current)
-        return fromProfile(current, "current");
-    } catch {}
+    }
+    const current = await store.currentProfile(toolId);
+    if (current)
+      return fromProfile(current, "current");
   }
   return null;
 }
@@ -3137,32 +3360,219 @@ function statSyncSafe(path) {
   }
 }
 
+// src/ingest/loops.ts
+init_database();
+init_pricing();
+import { existsSync as existsSync8 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join8 } from "path";
+import { Database as BunDatabase2 } from "bun:sqlite";
+var DEFAULT_LOOPS_DB_PATH = join8(homedir8(), ".hasna", "loops", "loops.db");
+var LOOPS_INGEST_VERSION = "goal-runs-orchestration-v1";
+function loopsDbPath() {
+  return process.env["HASNA_ECONOMY_LOOPS_DB_PATH"] ?? DEFAULT_LOOPS_DB_PATH;
+}
+function loopsModel() {
+  return process.env["HASNA_ECONOMY_LOOPS_MODEL"] ?? process.env["ECONOMY_LOOPS_MODEL"] ?? "gpt-5.3-codex";
+}
+function openLoopsDb(dbPath, verbose) {
+  let lastError;
+  for (const readonly of [true, false]) {
+    let loopsDb = null;
+    try {
+      loopsDb = readonly ? new BunDatabase2(dbPath, { readonly: true }) : new BunDatabase2(dbPath);
+      loopsDb.prepare("PRAGMA schema_version").get();
+      return loopsDb;
+    } catch (error) {
+      lastError = error;
+      loopsDb?.close();
+    }
+  }
+  if (verbose) {
+    const message = lastError instanceof Error ? lastError.message : String(lastError);
+    console.log("OpenLoops DB unreadable:", dbPath, message);
+  }
+  return null;
+}
+function slug(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "unknown";
+}
+function parseTarget(raw) {
+  if (!raw)
+    return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function stringValue(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function accountFields(row) {
+  const target = parseTarget(row.target_json);
+  const tool = stringValue(row.account_tool) || stringValue(target["account_tool"]) || stringValue(target["tool"]) || stringValue(target["agent"]);
+  const profile = stringValue(row.account_profile) || stringValue(target["account_profile"]) || stringValue(target["profile"]) || stringValue(target["account"]);
+  if (!tool || !profile) {
+    return { account_key: "", account_tool: tool, account_name: profile, account_source: "" };
+  }
+  return {
+    account_key: `${tool}:${profile}`,
+    account_tool: tool,
+    account_name: profile,
+    account_source: "loops"
+  };
+}
+function readLoopGoalRuns(loopsDb) {
+  return loopsDb.prepare(`
+    SELECT
+      gr.id as goal_run_id,
+      gr.goal_id as goal_id,
+      COALESCE(gr.loop_id, g.loop_id, lr.loop_id) as loop_id,
+      COALESCE(gr.loop_run_id, g.loop_run_id, lr.id) as loop_run_id,
+      COALESCE(l.name, lr.loop_name, 'unknown-loop') as loop_name,
+      l.labels_json as labels_json,
+      l.target_json as target_json,
+      g.objective as objective,
+      gr.phase as phase,
+      gr.status as status,
+      COALESCE(gr.tokens_used, 0) as tokens_used,
+      gr.created_at as created_at,
+      gr.updated_at as updated_at,
+      lr.started_at as loop_run_started_at,
+      wsr.account_profile as account_profile,
+      wsr.account_tool as account_tool
+    FROM goal_runs gr
+    LEFT JOIN goals g ON g.id = gr.goal_id
+    LEFT JOIN loop_runs lr ON lr.id = COALESCE(gr.loop_run_id, g.loop_run_id)
+    LEFT JOIN loops l ON l.id = COALESCE(gr.loop_id, g.loop_id, lr.loop_id)
+    LEFT JOIN (
+      SELECT goal_run_id, MIN(account_profile) as account_profile, MIN(account_tool) as account_tool
+      FROM workflow_step_runs
+      WHERE goal_run_id IS NOT NULL
+      GROUP BY goal_run_id
+    ) wsr ON wsr.goal_run_id = gr.id
+    WHERE COALESCE(gr.tokens_used, 0) > 0
+    ORDER BY gr.created_at ASC, gr.id ASC
+  `).all();
+}
+async function ingestLoops(db, verbose = false) {
+  const dbPath = loopsDbPath();
+  if (!existsSync8(dbPath)) {
+    if (verbose)
+      console.log("OpenLoops DB not found:", dbPath);
+    return { sessions: 0, requests: 0 };
+  }
+  const model = loopsModel();
+  const machineId = getMachineId();
+  let loopsDb = null;
+  let requests = 0;
+  const sessions = new Set;
+  try {
+    loopsDb = openLoopsDb(dbPath, verbose);
+    if (!loopsDb)
+      return { sessions: 0, requests: 0 };
+    for (const row of readLoopGoalRuns(loopsDb)) {
+      const loopName = row.loop_name || "unknown-loop";
+      const costCenterId = `loop:${slug(loopName)}`;
+      const sessionId = `loops-${row.loop_run_id ?? row.loop_id ?? row.goal_id}`;
+      const requestId = `loops-${row.goal_run_id}`;
+      const timestamp = row.updated_at ?? row.created_at ?? row.loop_run_started_at ?? new Date().toISOString();
+      const stateValue = `${LOOPS_INGEST_VERSION}:${row.updated_at ?? ""}:${row.tokens_used}:${model}:${costCenterId}`;
+      if (getIngestState(db, "loops", row.goal_run_id) === stateValue)
+        continue;
+      upsertCostCenter(db, {
+        id: costCenterId,
+        kind: "loop",
+        name: loopName,
+        repo_path: null,
+        labels_json: row.labels_json ?? "{}",
+        created_at: row.created_at ?? timestamp
+      });
+      const account = accountFields(row);
+      upsertSession(db, {
+        id: sessionId,
+        agent: "loop",
+        project_path: "",
+        project_name: loopName,
+        started_at: row.loop_run_started_at ?? row.created_at ?? timestamp,
+        ended_at: row.updated_at ?? null,
+        total_cost_usd: 0,
+        total_tokens: 0,
+        request_count: 0,
+        machine_id: machineId,
+        cost_center_id: costCenterId,
+        attribution_tag: "loops-orchestration",
+        ...account
+      });
+      const inputTokens = row.tokens_used;
+      const outputTokens = 0;
+      upsertRequest(db, {
+        id: requestId,
+        agent: "loop",
+        session_id: sessionId,
+        model,
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        cache_read_tokens: 0,
+        cache_create_tokens: 0,
+        cost_usd: computeCostFromDb(db, model, inputTokens, outputTokens),
+        cost_basis: "estimated",
+        duration_ms: 0,
+        timestamp,
+        source_request_id: requestId,
+        machine_id: machineId,
+        cost_center_id: costCenterId,
+        attribution_tag: "loops-orchestration",
+        ...account
+      });
+      sessions.add(sessionId);
+      requests++;
+      setIngestState(db, "loops", row.goal_run_id, stateValue);
+      if (verbose)
+        console.log(`OpenLoops ${loopName}: ${row.tokens_used} orchestration tokens`);
+    }
+  } catch (error) {
+    if (verbose) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log("OpenLoops ingest skipped:", message);
+    }
+    return { sessions: 0, requests: 0 };
+  } finally {
+    loopsDb?.close();
+  }
+  for (const sessionId of sessions)
+    rollupSession(db, sessionId);
+  return { sessions: sessions.size, requests };
+}
+
 // src/ingest/claude-quota.ts
 init_database();
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
 
 // src/lib/paths.ts
-import { homedir as homedir8 } from "os";
-import { join as join8 } from "path";
+import { homedir as homedir9 } from "os";
+import { join as join9 } from "path";
 function getHomeDir() {
-  return process.env["USERPROFILE"] ?? process.env["HOME"] ?? homedir8();
+  return process.env["USERPROFILE"] ?? process.env["HOME"] ?? homedir9();
 }
 function agentPaths() {
   const home = getHomeDir();
   return {
-    claudeProjects: join8(home, ".claude", "projects"),
-    claudeCredentials: join8(home, ".claude", ".credentials.json"),
-    takumiProjects: join8(home, ".takumi", "projects"),
-    codexDir: join8(home, ".codex"),
-    codexDb: join8(home, ".codex", "state_5.sqlite"),
-    codexAuth: join8(home, ".codex", "auth.json"),
-    codexConfig: join8(home, ".codex", "config.toml"),
-    geminiTmp: join8(home, ".gemini", "tmp"),
-    geminiHistory: join8(home, ".gemini", "history"),
-    opencodeMessages: join8(home, ".local", "share", "opencode", "storage", "message"),
-    piSessions: join8(home, ".pi", "agent", "sessions"),
-    hermesDir: join8(home, ".hermes"),
-    hermesDb: join8(home, ".hermes", "state.db")
+    claudeProjects: join9(home, ".claude", "projects"),
+    claudeCredentials: join9(home, ".claude", ".credentials.json"),
+    takumiProjects: join9(home, ".takumi", "projects"),
+    codexDir: join9(home, ".codex"),
+    codexDb: join9(home, ".codex", "state_5.sqlite"),
+    codexAuth: join9(home, ".codex", "auth.json"),
+    codexConfig: join9(home, ".codex", "config.toml"),
+    geminiTmp: join9(home, ".gemini", "tmp"),
+    geminiHistory: join9(home, ".gemini", "history"),
+    opencodeMessages: join9(home, ".local", "share", "opencode", "storage", "message"),
+    piSessions: join9(home, ".pi", "agent", "sessions"),
+    hermesDir: join9(home, ".hermes"),
+    hermesDb: join9(home, ".hermes", "state.db")
   };
 }
 
@@ -3174,7 +3584,7 @@ function readClaudeToken() {
   const fromEnv = process.env["CLAUDE_OAUTH_TOKEN"] ?? process.env["ANTHROPIC_OAUTH_TOKEN"];
   if (fromEnv)
     return { token: fromEnv };
-  if (!existsSync8(CREDENTIALS_PATH))
+  if (!existsSync9(CREDENTIALS_PATH))
     return null;
   try {
     const creds = JSON.parse(readFileSync7(CREDENTIALS_PATH, "utf-8"));
@@ -3313,14 +3723,14 @@ async function ingestClaudeQuota(db, verbose = false) {
 
 // src/ingest/codex-quota.ts
 init_database();
-import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
 var WHAM_USAGE_URL = process.env["CODEX_USAGE_URL"] ?? "https://chatgpt.com/backend-api/wham/usage";
 function readCodexAuth() {
   const fromEnv = process.env["CODEX_OAUTH_TOKEN"];
   if (fromEnv)
     return { token: fromEnv, authMode: "chatgpt" };
   const authPath = agentPaths().codexAuth;
-  if (!existsSync9(authPath))
+  if (!existsSync10(authPath))
     return null;
   try {
     const auth = JSON.parse(readFileSync8(authPath, "utf-8"));
@@ -3453,7 +3863,7 @@ async function ingestCodexQuota(db, verbose = false) {
 // src/lib/sync-all.ts
 init_database();
 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 anySpecific = Boolean(opts.claude || opts.takumi || opts.codex || opts.gemini || opts.opencode || opts.cursor || opts.pi || opts.hermes || opts.loops);
   const all = !anySpecific;
   const result = { deduped: 0 };
   if (all || opts.claude) {
@@ -3476,6 +3886,8 @@ async function syncAll(db, opts = {}) {
     result.pi = await ingestPi(db, opts.verbose);
   if (all || opts.hermes)
     result.hermes = await ingestHermes(db, opts.verbose);
+  if (all || opts.loops)
+    result.loops = await ingestLoops(db, opts.verbose);
   if (opts.dedupe !== false)
     result.deduped = dedupeRequests(db);
   return result;
@@ -4789,11 +5201,18 @@ class LocalStore {
     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);
+    return query.since ? queryProjectBreakdownSince(this.db(), query.since, query.machine) : 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 costCenterBreakdown(query = {}) {
+    return queryCostCenterBreakdown(this.db(), query.period ?? "all", {
+      kind: query.kind,
+      machine: query.machine,
+      since: query.since
+    });
+  }
   async accounts(period) {
     return queryAccountBreakdown(this.db(), period);
   }
@@ -4978,11 +5397,19 @@ class ApiStore {
     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 }));
+    return cloudListItems(this.cloud, "breakdown", q({ by: "project", period: query.period, since: query.since, machine: query.machine }));
   }
   async accountBreakdown(query = {}) {
     return cloudListItems(this.cloud, "breakdown", q({ by: "account", period: query.period, since: query.since }));
   }
+  async costCenterBreakdown(query = {}) {
+    const rows = await cloudListItems(this.cloud, "breakdown", q({
+      by: query.kind ?? "cost-center",
+      period: query.period,
+      since: query.since
+    }));
+    return rows.filter((row) => Boolean(row?.cost_center_id));
+  }
   async accounts(period) {
     return cloudListItems(this.cloud, "accounts", q({ period }));
   }
@@ -5056,6 +5483,7 @@ class ApiStore {
     const created = await this.cloud.client.create("budgets", {
       project_path: input.project_path,
       ...input.agent ? { agent: input.agent } : {},
+      ...input.cost_center_id ? { cost_center_id: input.cost_center_id } : {},
       period: input.period,
       limit_usd: input.limit_usd,
       alert_at_percent: input.alert_at_percent
@@ -5146,6 +5574,7 @@ function buildServer() {
     name: MCP_NAME,
     version: packageMetadata.version
   });
+  const SYNC_SOURCES = ["all", ...AGENTS, "loops"];
   const TOOL_NAMES = [
     "get_cost_summary",
     "get_sessions",
@@ -5154,6 +5583,7 @@ function buildServer() {
     "get_project_breakdown",
     "get_agent_breakdown",
     "get_account_breakdown",
+    "get_cost_center_breakdown",
     "get_budget_status",
     "set_budget",
     "remove_budget",
@@ -5186,30 +5616,31 @@ function buildServer() {
     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",
+    list_machines: "limit(20), verbose?, json? -> machine_id, sessions, requests, cost, last_active",
+    get_model_breakdown: "limit(20), verbose?, json? -> model, requests, tokens, cost",
+    get_project_breakdown: "period?(today|week|month|year|all), limit(20), verbose?, json? -> 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",
+    get_account_breakdown: "period?(today|week|month|year|all), limit(20), verbose?, json? -> account profile, sessions, requests, tokens, api-equivalent, billable, included",
+    get_cost_center_breakdown: "period?(today|week|month|year|all), kind?(loop|app|repo|service|team) -> cost center, sessions, requests, tokens, cost",
+    get_budget_status: "limit(20), verbose?, json? -> budget limits, current spend, percent_used, is_over_alert",
+    set_budget: "period(daily|weekly|monthly), limit_usd, project_path?, agent?, cost_center_id?, 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",
+    get_pricing: "limit(20), verbose?, json? -> 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`,
+    get_session_detail: "session_id(prefix ok), limit(20), verbose? -> per-request breakdown with model, tokens, cost",
+    get_usage: `period(today|week|month|year|all), agent?(${AGENTS.join("|")}), limit(20), json? -> usage snapshots and all-machine summary`,
+    get_savings: `period(today|week|month|year|all), agent?(${AGENTS.join("|")}), limit(20), json? -> subscription/API-equivalent savings`,
     estimate_cost: "model, input_tokens?, output_tokens? -> pre-flight cost estimate priced from the store pricing table",
     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`,
+    set_subscription: `provider, plan, monthly_fee_usd?, included_usage_usd?, agent?(${AGENTS.join("|")}), json? -> create/update subscription plan`,
     remove_subscription: "id -> delete subscription plan",
-    sync: `sources(all|${AGENTS.join("|")}) -> ingest latest cost data`,
+    sync: `sources(${SYNC_SOURCES.join("|")}), json? -> 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",
+    get_goals: "limit(20), verbose?, json? -> 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",
@@ -5220,6 +5651,20 @@ function buildServer() {
   };
   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);
+  const DEFAULT_MCP_ROW_LIMIT = 20;
+  function clampLimit(limit, fallback = DEFAULT_MCP_ROW_LIMIT, max = 100) {
+    if (limit == null)
+      return fallback;
+    if (!Number.isFinite(limit))
+      return fallback;
+    return Math.max(1, Math.min(max, Math.floor(limit)));
+  }
+  function rowLimit(limit, verbose) {
+    return verbose ? Number.POSITIVE_INFINITY : clampLimit(limit);
+  }
+  function hiddenRowsHint(total, shown, noun) {
+    return total > shown ? `... ${total - shown} more ${noun} hidden; call with limit, verbose=true, or json=true.` : undefined;
+  }
   function fmtSession(s) {
     const id = String(s["id"] ?? "").slice(0, 8);
     const agent = String(s["agent"] ?? "");
@@ -5228,6 +5673,26 @@ function buildServer() {
     const tok = fmtTok(Number(s["total_tokens"] ?? 0));
     return `${id} ${agent.padEnd(6)} ${cost.padEnd(10)} ${tok.padEnd(8)} ${proj}`;
   }
+  function compactPrimitive(value) {
+    if (value == null)
+      return "none";
+    if (typeof value === "number")
+      return Number.isFinite(value) ? value.toLocaleString("en-US") : String(value);
+    if (typeof value === "boolean")
+      return value ? "yes" : "no";
+    return String(value);
+  }
+  function compactObject(value) {
+    if (value == null)
+      return "none";
+    if (Array.isArray(value))
+      return `${value.length} rows`;
+    if (typeof value !== "object")
+      return compactPrimitive(value);
+    const entries = Object.entries(value);
+    const primitives = entries.filter(([, entry]) => entry == null || ["string", "number", "boolean"].includes(typeof entry)).slice(0, 6).map(([key, entry]) => `${key}=${compactPrimitive(entry)}`);
+    return primitives.length ? primitives.join(", ") : `${entries.length} fields`;
+  }
   function text(text2) {
     return { content: [{ type: "text", text: text2 }] };
   }
@@ -5282,22 +5747,34 @@ function buildServer() {
     return text(lines.join(`
 `));
   });
-  server.tool("get_model_breakdown", "Cost per model. No params.", {}, async () => {
+  server.tool("get_model_breakdown", "Cost per model. Params: limit(20), verbose, json.", { limit: z.number().int().positive().max(100).optional(), verbose: z.boolean().optional(), json: z.boolean().optional() }, async ({ limit, verbose, json }) => {
     const rows = await store.modelBreakdown();
+    if (json)
+      return text(JSON.stringify(rows, null, 2));
+    const visibleRows = rows.slice(0, rowLimit(limit, verbose));
     const lines = ["model                          agent     reqs    tokens   cost"];
-    for (const row of rows) {
+    for (const row of visibleRows) {
       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"]))}`);
     }
+    const hint = hiddenRowsHint(rows.length, visibleRows.length, "models");
+    if (hint)
+      lines.push(hint);
     return text(lines.join(`
 `));
   });
-  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 }) => {
+  server.tool("get_project_breakdown", "Cost per project. Params: period(today|week|month|year|all), limit(20), verbose, json.", { period: z.enum(["today", "week", "month", "year", "all"]).optional(), limit: z.number().int().positive().max(100).optional(), verbose: z.boolean().optional(), json: z.boolean().optional() }, async ({ period, limit, verbose, json }) => {
     const rows = await store.projectBreakdown({ period: period ?? "all" });
+    if (json)
+      return text(JSON.stringify(rows, null, 2));
+    const visibleRows = rows.slice(0, rowLimit(limit, verbose));
     const lines = ["project              sessions tokens   cost"];
-    for (const row of rows) {
+    for (const row of visibleRows) {
       const name = String(row["project_name"] || row["project_path"] || "\u2014").slice(0, 20);
       lines.push(`${name.padEnd(21)}${String(row["sessions"]).padEnd(9)}${fmtTok(Number(row["total_tokens"])).padEnd(9)}${fmtUsd(Number(row["cost_usd"]))}`);
     }
+    const hint = hiddenRowsHint(rows.length, visibleRows.length, "projects");
+    if (hint)
+      lines.push(hint);
     return text(lines.join(`
 `));
   });
@@ -5312,29 +5789,55 @@ function buildServer() {
     return text(lines.join(`
 `));
   });
-  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 }) => {
+  server.tool("get_account_breakdown", "Cost per account/profile. Params: period(today|week|month|year|all), limit(20), verbose, json. Shows API-equivalent, billable API, and subscription-included usage.", { period: z.enum(["today", "week", "month", "year", "all"]).optional(), limit: z.number().int().positive().max(100).optional(), verbose: z.boolean().optional(), json: z.boolean().optional() }, async ({ period, limit, verbose, json }) => {
     const rows = await store.accountBreakdown({ period: period ?? "all" });
+    if (json)
+      return text(JSON.stringify(rows, null, 2));
     if (rows.length === 0)
       return text("No account-attributed sessions yet.");
+    const visibleRows = rows.slice(0, rowLimit(limit, verbose));
     const lines = ["account              agent      sessions requests tokens   api_eq    billable  included"];
-    for (const row of rows) {
+    for (const row of visibleRows) {
       const label = String(row["account_email"] || row["account_name"] || row["account_key"] || "\u2014").slice(0, 20);
       lines.push(`${label.padEnd(21)}` + `${String(row["account_tool"] ?? "").slice(0, 10).padEnd(11)}` + `${String(row["sessions"]).padEnd(9)}` + `${String(row["requests"]).padEnd(9)}` + `${fmtTok(Number(row["total_tokens"])).padEnd(9)}` + `${fmtUsd(Number(row["api_equivalent_usd"] ?? row["cost_usd"])).padEnd(10)}` + `${fmtUsd(Number(row["billable_usd"] ?? 0)).padEnd(10)}` + `${fmtUsd(Number(row["subscription_included_usd"] ?? 0))}`);
     }
+    const hint = hiddenRowsHint(rows.length, visibleRows.length, "accounts");
+    if (hint)
+      lines.push(hint);
+    return text(lines.join(`
+`));
+  });
+  server.tool("get_cost_center_breakdown", "Cost per cost center. Params: period(today|week|month|year|all), kind(loop|app|repo|service|team).", {
+    period: z.enum(["today", "week", "month", "year", "all"]).optional(),
+    kind: z.enum(["loop", "app", "repo", "service", "team"]).optional()
+  }, async ({ period, kind }) => {
+    const rows = await store.costCenterBreakdown({ period: period ?? "all", kind });
+    if (rows.length === 0)
+      return text("No cost-center usage yet.");
+    const lines = ["kind     cost_center          sessions requests tokens   cost"];
+    for (const row of rows) {
+      lines.push(`${String(row["kind"]).slice(0, 8).padEnd(9)}` + `${String(row["name"] || row["cost_center_id"] || "\u2014").slice(0, 20).padEnd(21)}` + `${String(row["sessions"]).padEnd(9)}` + `${String(row["requests"]).padEnd(9)}` + `${fmtTok(Number(row["total_tokens"])).padEnd(9)}` + `${fmtUsd(Number(row["cost_usd"]))}`);
+    }
     return text(lines.join(`
 `));
   });
-  server.tool("get_budget_status", "Budget limits vs spend, percent used, alert flags. No params.", {}, async () => {
+  server.tool("get_budget_status", "Budget limits vs spend, percent used, alert flags. Params: limit(20), verbose, json.", { limit: z.number().int().positive().max(100).optional(), verbose: z.boolean().optional(), json: z.boolean().optional() }, async ({ limit, verbose, json }) => {
     const budgets = await store.listBudgets();
+    if (json)
+      return text(JSON.stringify(budgets, null, 2));
     if (budgets.length === 0)
       return text("No budgets set.");
+    const visibleBudgets = budgets.slice(0, rowLimit(limit, verbose));
     const lines = ["scope                period   spent      limit      used%  status"];
-    for (const budget of budgets) {
-      const scope = String(budget["project_path"] ?? "global").slice(0, 20);
+    for (const budget of visibleBudgets) {
+      const scope = String(budget["cost_center_id"] ?? budget["project_path"] ?? "global").slice(0, 20);
       const pct = Number(budget["percent_used"]).toFixed(1);
       const status = budget["is_over_limit"] ? "OVER" : budget["is_over_alert"] ? "ALERT" : "OK";
       lines.push(`${scope.padEnd(21)}${String(budget["period"]).padEnd(9)}${fmtUsd(Number(budget["current_spend_usd"])).padEnd(11)}${fmtUsd(Number(budget["limit_usd"])).padEnd(11)}${pct}%`.padEnd(49) + `  ${status}`);
     }
+    const hint = hiddenRowsHint(budgets.length, visibleBudgets.length, "budgets");
+    if (hint)
+      lines.push(hint);
     return text(lines.join(`
 `));
   });
@@ -5343,11 +5846,13 @@ function buildServer() {
     limit_usd: z.number().positive(),
     project_path: z.string().optional(),
     agent: z.enum(AGENTS).optional(),
+    cost_center_id: z.string().optional(),
     alert_at_percent: z.number().positive().max(100).optional()
-  }, async ({ period, limit_usd, project_path, agent, alert_at_percent }) => {
+  }, async ({ period, limit_usd, project_path, agent, cost_center_id, alert_at_percent }) => {
     const id = await store.setBudget({
       project_path: project_path ?? null,
       agent: agent ?? null,
+      cost_center_id: cost_center_id ?? null,
       period,
       limit_usd,
       alert_at_percent: alert_at_percent ?? 80
@@ -5358,12 +5863,18 @@ function buildServer() {
     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 () => {
+  server.tool("get_pricing", "Editable model pricing rows. Includes input/output/cache rates and context-cache storage. Params: limit(20), verbose, json.", { limit: z.number().int().positive().max(100).optional(), verbose: z.boolean().optional(), json: z.boolean().optional() }, async ({ limit, verbose, json }) => {
     const rows = await store.listPricing();
+    if (json)
+      return text(JSON.stringify(rows, null, 2));
+    const visibleRows = rows.slice(0, rowLimit(limit, verbose));
     const lines = ["model                          input    output   cache-r  cache-w  cache-1h storage-h"];
-    for (const row of rows) {
+    for (const row of visibleRows) {
       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)}`);
     }
+    const hint = hiddenRowsHint(rows.length, visibleRows.length, "pricing rows");
+    if (hint)
+      lines.push(hint);
     return text(lines.join(`
 `));
   });
@@ -5428,11 +5939,14 @@ function buildServer() {
     return text(lines.join(`
 `));
   });
-  server.tool("get_session_detail", "Per-request breakdown of a single session. Params: session_id (prefix ok)", { session_id: z.string() }, async ({ session_id }) => {
+  server.tool("get_session_detail", "Per-request breakdown of a single session. Params: session_id (prefix ok), limit(20), verbose.", { session_id: z.string(), limit: z.number().int().positive().max(100).optional(), verbose: z.boolean().optional() }, async ({ session_id, limit, verbose }) => {
     const detail = await store.sessionDetail(session_id);
     if (!detail)
       return textError(`Session not found: ${session_id}`);
-    const { session, requests } = detail;
+    const { session, requests: allRequests } = detail;
+    const requestLimit = clampLimit(limit, verbose ? 50 : DEFAULT_MCP_ROW_LIMIT);
+    const requestCount = { count: allRequests.length };
+    const requests = allRequests.slice(0, requestLimit);
     const lines = [
       `session: ${String(session["id"]).slice(0, 16)}`,
       `agent: ${session["agent"]}  project: ${session["project_name"] || "\u2014"}`,
@@ -5440,27 +5954,85 @@ function buildServer() {
       "",
       "time      model                  input    output   cache-r  cache-5m cache-1h cost"
     ];
-    for (const request of requests.slice(0, 50)) {
+    for (const request of requests) {
       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"]))}`);
     }
+    if (requestCount.count > requests.length) {
+      lines.push(`... ${requestCount.count - requests.length} more requests hidden; call with limit or verbose=true for more.`);
+    }
     return text(lines.join(`
 `));
   });
-  server.tool("sync", `Ingest new cost data. sources: all|${AGENTS.join("|")}`, { sources: z.enum(["all", ...AGENTS]).optional() }, async ({ sources }) => {
+  server.tool("sync", `Ingest new cost data. sources: ${SYNC_SOURCES.join("|")}. Set json=true for the full result object.`, { sources: z.enum([...SYNC_SOURCES]).optional(), json: z.boolean().optional() }, async ({ sources, json }) => {
     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(localDb(), opts);
-    return text(JSON.stringify(result, null, 2));
+    if (json)
+      return text(JSON.stringify(result, null, 2));
+    const lines = [
+      `sync: ${selected}`,
+      `deduped: ${result.deduped}`
+    ];
+    for (const [source, value] of Object.entries(result)) {
+      if (source === "deduped")
+        continue;
+      if (value == null)
+        continue;
+      lines.push(`${source}: ${compactObject(value)}`);
+    }
+    lines.push("Use json=true for the full sync result.");
+    return text(lines.join(`
+`));
   });
-  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 }) => {
+  server.tool("get_usage", "Usage snapshots and fleet summary. period: today|week|month|year|all, agent, limit(20). Set json=true for full data.", { period: z.enum(["today", "week", "month", "year", "all"]).optional(), agent: z.enum(AGENTS).optional(), limit: z.number().int().positive().max(100).optional(), json: z.boolean().optional() }, async ({ period, agent, limit, json }) => {
     const p = period ?? "month";
-    return text(JSON.stringify(await store.usage(p, agent), null, 2));
+    const { snapshots: snaps, summary } = await store.usage(p, agent);
+    if (json)
+      return text(JSON.stringify({ snapshots: snaps, summary }, null, 2));
+    const snapshotLimit = clampLimit(limit);
+    const lines = [
+      `period: ${p}${agent ? `  agent: ${agent}` : ""}`,
+      `fleet: ${fmtUsd(summary.total_usd)}  sessions: ${summary.sessions}  requests: ${summary.requests.toLocaleString()}  tokens: ${fmtTok(summary.tokens)}`,
+      `snapshots: ${snaps.length}${snaps.length > snapshotLimit ? ` (showing ${snapshotLimit})` : ""}`
+    ];
+    if (snaps.length > 0) {
+      lines.push("", "date        agent      metric                      value        unit     machine");
+      for (const snapshot of snaps.slice(0, snapshotLimit)) {
+        lines.push(`${snapshot.date.padEnd(12)}` + `${snapshot.agent.slice(0, 10).padEnd(11)}` + `${snapshot.metric.slice(0, 27).padEnd(28)}` + `${compactPrimitive(snapshot.value).padEnd(13)}` + `${(snapshot.unit ?? "").slice(0, 8).padEnd(9)}` + `${snapshot.machine_id ?? "\u2014"}`);
+      }
+      if (snaps.length > snapshotLimit)
+        lines.push(`... ${snaps.length - snapshotLimit} more snapshots hidden; call with limit or json=true.`);
+    }
+    return text(lines.join(`
+`));
   });
-  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(await store.savings(period ?? "month", agent), null, 2));
+  server.tool("get_savings", "Subscription vs API savings summary. Params: period, agent, limit(20). Set json=true for full data.", { period: z.enum(["today", "week", "month", "year", "all"]).optional(), agent: z.enum(AGENTS).optional(), limit: z.number().int().positive().max(100).optional(), json: z.boolean().optional() }, async ({ period, agent, limit, json }) => {
+    const savings = await store.savings(period ?? "month", agent);
+    if (json)
+      return text(JSON.stringify(savings, null, 2));
+    const lines = [
+      `period: ${savings.period}${agent ? `  agent: ${agent}` : ""}`,
+      `api_equivalent: ${fmtUsd(savings.api_equivalent_usd)}`,
+      `subscription_fee: ${fmtUsd(savings.subscription_fee_usd)}`,
+      `included_consumed: ${fmtUsd(savings.included_consumed_usd)}`,
+      `on_demand: ${fmtUsd(savings.on_demand_usd)}`,
+      `saved: ${fmtUsd(savings.saved_usd)}`
+    ];
+    const rows = Object.entries(savings.by_agent ?? {});
+    if (rows.length > 0) {
+      const agentLimit = clampLimit(limit);
+      lines.push("", `by_agent: ${rows.length}${rows.length > agentLimit ? ` (showing ${agentLimit})` : ""}`, "agent      api_eq    sub_fee   included  on_demand saved");
+      for (const [agentName, row] of rows.slice(0, agentLimit)) {
+        lines.push(`${agentName.slice(0, 10).padEnd(11)}` + `${fmtUsd(Number(row.api_equivalent_usd ?? 0)).padEnd(10)}` + `${fmtUsd(Number(row.subscription_fee_usd ?? 0)).padEnd(10)}` + `${fmtUsd(Number(row.included_consumed_usd ?? 0)).padEnd(10)}` + `${fmtUsd(Number(row.on_demand_usd ?? 0)).padEnd(10)}` + `${fmtUsd(Number(row.saved_usd ?? 0))}`);
+      }
+      if (rows.length > agentLimit)
+        lines.push(`... ${rows.length - agentLimit} more agents hidden; call with limit or json=true.`);
+    }
+    return text(lines.join(`
+`));
   });
   server.tool("list_subscriptions", "List configured subscription plans used by savings calculations.", {}, async () => {
     const rows = await store.listSubscriptions();
@@ -5482,7 +6054,8 @@ function buildServer() {
     included_usage_usd: z.number().nonnegative().optional(),
     billing_cycle_start: z.string().optional(),
     reset_policy: z.string().optional(),
-    active: z.boolean().optional()
+    active: z.boolean().optional(),
+    json: z.boolean().optional()
   }, async (input) => {
     const row = await store.setSubscription({
       id: input.id,
@@ -5495,7 +6068,14 @@ function buildServer() {
       reset_policy: input.reset_policy ?? "monthly",
       active: input.active === false ? 0 : 1
     });
-    return text(JSON.stringify(row, null, 2));
+    if (input.json)
+      return text(JSON.stringify(row, null, 2));
+    return text(`Subscription set: ${row.id}
+provider: ${row.provider}
+plan: ${row.plan}
+agent: ${row.agent ?? "all"}
+fee: ${fmtUsd(row.monthly_fee_usd)}
+included: ${fmtUsd(row.included_usage_usd)}`);
   });
   server.tool("remove_subscription", "Delete a subscription plan by id.", { id: z.string() }, async ({ id }) => {
     await store.removeSubscription(id);
@@ -5505,17 +6085,23 @@ function buildServer() {
     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 () => {
+  server.tool("get_goals", "All spending goals with current progress. Params: limit(20), verbose, json.", { limit: z.number().int().positive().max(100).optional(), verbose: z.boolean().optional(), json: z.boolean().optional() }, async ({ limit, verbose, json }) => {
     const goals = await store.listGoals();
+    if (json)
+      return text(JSON.stringify(goals, null, 2));
     if (goals.length === 0)
       return text("No goals set.");
+    const visibleGoals = goals.slice(0, rowLimit(limit, verbose));
     const lines = ["period   scope                limit      spent      used%  status"];
-    for (const goal of goals) {
+    for (const goal of visibleGoals) {
       const scope = String(goal["project_path"] ?? goal["agent"] ?? "global").slice(0, 20);
       const pct = Number(goal["percent_used"]).toFixed(1);
       const status = goal["is_over"] ? "OVER" : goal["is_at_risk"] ? "AT RISK" : "ON TRACK";
       lines.push(`${String(goal["period"]).padEnd(9)}${scope.padEnd(21)}${fmtUsd(Number(goal["limit_usd"])).padEnd(11)}${fmtUsd(Number(goal["current_spend_usd"])).padEnd(11)}${pct}%  ${status}`);
     }
+    const hint = hiddenRowsHint(goals.length, visibleGoals.length, "goals");
+    if (hint)
+      lines.push(hint);
     return text(lines.join(`
 `));
   });
@@ -5537,14 +6123,20 @@ function buildServer() {
     await store.removeGoal(id);
     return text("Goal removed.");
   });
-  server.tool("list_machines", "List all machines that have synced data. No params.", {}, async () => {
+  server.tool("list_machines", "List all machines that have synced data. Params: limit(20), verbose, json.", { limit: z.number().int().positive().max(100).optional(), verbose: z.boolean().optional(), json: z.boolean().optional() }, async ({ limit, verbose, json }) => {
     const machines = await store.machines();
+    if (json)
+      return text(JSON.stringify(machines, null, 2));
     if (machines.length === 0)
       return text(`No machine data yet. Current machine: ${getMachineId()}`);
+    const visibleMachines = machines.slice(0, rowLimit(limit, verbose));
     const lines = ["machine          sessions  requests  cost        last_active"];
-    for (const m of machines) {
+    for (const m of visibleMachines) {
       lines.push(`${m.machine_id.padEnd(17)}${String(m.sessions).padEnd(10)}${String(m.requests).padEnd(10)}${fmtUsd(m.total_cost_usd).padEnd(12)}${m.last_active?.substring(0, 16) ?? "\u2014"}`);
     }
+    const hint = hiddenRowsHint(machines.length, visibleMachines.length, "machines");
+    if (hint)
+      lines.push(hint);
     lines.push(`
 current machine: ${getMachineId()}`);
     return text(lines.join(`
@@ -5563,7 +6155,6 @@ current machine: ${getMachineId()}`);
       return textError(String(error));
     }
   });
-  registerCloudTools(server, MCP_NAME);
   return server;
 }