@hasna/economy 0.4.0 → 0.5.1

package/dist/chunks/index-d480p2wh.js

@@ -0,0 +1,1322 @@
+// @bun
+import {
+  calendarPeriodBounds,
+  calendarPeriodWhere,
+  formatBillingValue,
+  formatReportedUsd,
+  hasKnownUsagePrice,
+  listMachineRegistry,
+  listMachines,
+  listModelPricing,
+  queryAccountBreakdown,
+  queryAgentBreakdown,
+  queryBillingSummary,
+  querySummary,
+  requireCurrentBillingSummary,
+  requireCurrentCostSummary,
+  sessionOverlapWhere
+} from "./index-ez9thsr7.js";
+// package.json
+var package_default = {
+  name: "@hasna/economy",
+  version: "0.5.1",
+  description: "AI coding cost tracker \u2014 CLI + MCP server + REST API for Claude Code, Codex, OpenCode, Cursor, Pi, and Hermes, with legacy Gemini CLI session and Gemini API billing ingestion",
+  repository: {
+    type: "git",
+    url: "https://github.com/hasna/apps.git",
+    directory: "apps/economy"
+  },
+  bugs: {
+    url: "https://github.com/hasna/apps/issues"
+  },
+  homepage: "https://github.com/hasna/apps/tree/main/apps/economy#readme",
+  type: "module",
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  bin: {
+    economy: "dist/cli/index.js",
+    "economy-mcp": "dist/mcp/index.js",
+    "economy-serve": "dist/server/index.js",
+    "economy-otel": "dist/otel/index.js"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./sdk": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    }
+  },
+  files: [
+    "dist",
+    "docs",
+    "postinstall.js",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md",
+    "SECURITY.md",
+    "CONTRIBUTING.md",
+    "CODE_OF_CONDUCT.md",
+    "!dist/lib/test-hermetic-*"
+  ],
+  scripts: {
+    build: 'bun build src/cli/index.ts --outdir dist --root src --target bun --packages external --splitting --chunk-naming "chunks/[name]-[hash].[ext]" && bun build src/mcp/index.ts --outdir dist --root src --target bun --packages external --splitting --chunk-naming "chunks/[name]-[hash].[ext]" && bun build src/server/index.ts --outdir dist/server --target bun --packages external && bun build src/db/pg-sync-worker.ts --outdir dist/server --target bun --packages external && bun build src/server/service-worker.ts --outdir dist/server --target bun --packages external && bun build src/otel/index.ts --outdir dist/otel --target bun --packages external && bun build src/index.ts --outdir dist --root src --target bun --packages external --splitting --chunk-naming "chunks/[name]-[hash].[ext]" && tsc --emitDeclarationOnly --outDir dist',
+    "build:cli": 'bun build src/cli/index.ts --outdir dist --root src --target bun --packages external --splitting --chunk-naming "chunks/[name]-[hash].[ext]"',
+    "build:mcp": 'bun build src/mcp/index.ts --outdir dist --root src --target bun --packages external --splitting --chunk-naming "chunks/[name]-[hash].[ext]"',
+    "build:server": "bun build src/server/index.ts --outdir dist/server --target bun --packages external && bun build src/db/pg-sync-worker.ts --outdir dist/server --target bun --packages external && bun build src/server/service-worker.ts --outdir dist/server --target bun --packages external",
+    "build:lib": 'bun build src/index.ts --outdir dist --root src --target bun --packages external --splitting --chunk-naming "chunks/[name]-[hash].[ext]"',
+    "artifact-scan": "bun scripts/contracts-cli.mjs artifact-scan dist",
+    prepack: "bun run build && bun run artifact-scan",
+    typecheck: "tsc --noEmit",
+    test: "bun test",
+    "dev:cli": "bun run src/cli/index.ts",
+    "dev:mcp": "bun run src/mcp/index.ts",
+    "dev:serve": "bun run src/server/index.ts",
+    "dev:otel": "bun run src/otel/index.ts",
+    postinstall: "node postinstall.js"
+  },
+  keywords: [
+    "economy",
+    "cost",
+    "ai",
+    "claude",
+    "codex",
+    "gemini",
+    "mcp",
+    "cli",
+    "budget",
+    "tracking"
+  ],
+  author: "hasna",
+  license: "Apache-2.0",
+  publishConfig: {
+    registry: "https://registry.npmjs.org",
+    access: "public"
+  },
+  dependencies: {
+    "@hasna/contracts": "1.0.2",
+    "@hasna/events": "^0.1.16",
+    "@hasna/projects": "1.0.0",
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    chalk: "^5.4.1",
+    commander: "^13.1.0",
+    pg: "8.13.1",
+    zod: "^3.24.2",
+    "@hasna/trash": "0.2.3"
+  },
+  devDependencies: {
+    "@types/bun": "1.3.14",
+    "@types/pg": "^8.20.0",
+    "bun-types": "latest",
+    typescript: "^5.7.2"
+  },
+  trustedDependencies: [
+    "@hasna/projects"
+  ],
+  overrides: {
+    "fast-uri": "3.1.8",
+    hono: "4.13.7",
+    "ip-address": "10.7.1",
+    nanoid: "5.1.16",
+    "path-to-regexp": "8.4.0",
+    undici: "6.28.1",
+    "express-rate-limit": "8.7.0"
+  }
+};
+
+// src/lib/package-metadata.ts
+var cachedMetadata = null;
+function getPackageMetadata() {
+  if (cachedMetadata)
+    return cachedMetadata;
+  cachedMetadata = {
+    name: package_default.name ?? "@hasna/economy",
+    version: package_default.version ?? "0.0.0"
+  };
+  return cachedMetadata;
+}
+var packageMetadata = getPackageMetadata();
+
+// src/lib/cloud-storage.ts
+import {
+  appConfigDiskValue,
+  ClientTransportConfigurationError,
+  clientTransportEnvKeys,
+  createClientTransport,
+  credentialDiskSources,
+  credentialOverrideEnvKey,
+  credentialPointerEnvKey,
+  CREDENTIAL_PROFILE_ENV_KEY,
+  keychainConfigValue
+} from "@hasna/contracts/client";
+import { createHasnaStorageClient } from "@hasna/contracts/client/storage";
+var ECONOMY_APP = "economy";
+var LOCAL_STORAGE_OPT_IN_KEYS = ["HASNA_ECONOMY_LOCAL", "ECONOMY_LOCAL"];
+function envFlagSet(env, key) {
+  const raw = env[key];
+  if (raw === undefined)
+    return false;
+  const value = raw.trim().toLowerCase();
+  return value !== "" && value !== "0" && value !== "false" && value !== "no" && value !== "off";
+}
+function localStorageExplicitlyOptedIn(env) {
+  return LOCAL_STORAGE_OPT_IN_KEYS.some((key) => envFlagSet(env, key));
+}
+function economyAuthorityEnvKeys() {
+  const keys = clientTransportEnvKeys(ECONOMY_APP);
+  return [
+    ...keys.apiUrlKeys,
+    ...keys.apiKeyKeys,
+    credentialOverrideEnvKey(ECONOMY_APP),
+    credentialPointerEnvKey(ECONOMY_APP),
+    CREDENTIAL_PROFILE_ENV_KEY
+  ];
+}
+function hasEconomyEnvAuthorityIntent(env) {
+  return economyAuthorityEnvKeys().some((key) => (env[key] ?? "").trim().length > 0);
+}
+function hostedAuthorityConfigured(env, options = {}) {
+  const keys = clientTransportEnvKeys(ECONOMY_APP);
+  if (keys.apiUrlKeys.some((key) => (env[key] ?? "").trim().length > 0))
+    return true;
+  if (keychainConfigValue(ECONOMY_APP, env, options.credentials?.keychain) !== null)
+    return true;
+  return appConfigDiskValue(ECONOMY_APP, env, keys.apiUrlKeys) !== null;
+}
+function economyResolverEnv(env) {
+  const blanks = economyAuthorityEnvKeys().filter((key) => (key in env) && (env[key] ?? "").trim() === "");
+  if (blanks.length === 0)
+    return env;
+  const next = { ...env };
+  for (const key of blanks)
+    delete next[key];
+  return next;
+}
+var CONTRACTS_AMBIENT_ENVIRONMENT = Symbol.for("hasna:contracts:ambientClientEnvironment");
+function isAmbientEconomyEnv(env) {
+  if (typeof process !== "undefined" && env === process.env)
+    return true;
+  return env[CONTRACTS_AMBIENT_ENVIRONMENT] === true;
+}
+function economyResolverInputs(env, credentials = {}) {
+  const normalised = economyResolverEnv(env);
+  if (normalised === env)
+    return { env: normalised, credentials };
+  const keychain = { ...credentials.keychain };
+  if (keychain.enabled === undefined && keychain.run === undefined) {
+    keychain.enabled = isAmbientEconomyEnv(env);
+  }
+  return { env: normalised, credentials: { ...credentials, keychain } };
+}
+function resolveEconomyStorageClient(name, env, overrides = {}) {
+  const { env: resolverEnv, credentials } = economyResolverInputs(env, overrides.credentials);
+  const wired = createClientTransport(name, resolverEnv, {
+    credentials,
+    ...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 } : {}
+  });
+  return {
+    transport: "http",
+    client: createHasnaStorageClient(name, wired.client),
+    resolution: wired.resolution
+  };
+}
+function localEconomyNotice() {
+  return `economy: LOCAL mode (${LOCAL_STORAGE_OPT_IN_KEYS[0]}=1) \u2014 reading and writing the on-box ` + `SQLite store, not the hosted fleet. Data in the shared economy API is NOT included.`;
+}
+function credentialRequiredError(env, cause) {
+  const keys = clientTransportEnvKeys(ECONOMY_APP);
+  const clientEnv = env;
+  const detail = cause instanceof Error ? cause.message : `No API key could be resolved for '${ECONOMY_APP}'. Looked in the Keychain (macOS only), ` + `then for a credential file at ${credentialDiskSources(ECONOMY_APP, clientEnv).join(" or ") || "<no HOME set>"}, ` + `then for ${keys.apiKeyKeys[0]} in the environment.`;
+  const wayOut = hostedAuthorityConfigured(clientEnv) ? `${keys.apiUrlKeys[0]} (or the Keychain hasna.credentials.${ECONOMY_APP}.api-url item, or ` + `~/.hasna/${ECONOMY_APP}/config/credentials) selects a hosted service, so ${LOCAL_STORAGE_OPT_IN_KEYS[0]} ` + `does not apply; unset the authority to use the local store.` : `Or set ${LOCAL_STORAGE_OPT_IN_KEYS[0]}=1 to explicitly opt into the local store.`;
+  return new Error(`Economy fails closed instead of silently serving the local SQLite store: ${detail} ` + `Set ${keys.apiUrlKeys[0]} and ${keys.apiKeyKeys[0]} (or store the key in the Keychain item ` + `hasna.credentials.${ECONOMY_APP}.api-key, or in ~/.hasna/${ECONOMY_APP}/config/credentials) to use the ` + `hosted economy API at ${keys.apiUrlKeys[0]} or the default fleet gateway. ` + wayOut);
+}
+var cache;
+var localNoticePrinted = false;
+function resolveEconomyCloudStorage(env = process.env, overrides) {
+  const clientEnv = env;
+  if (localStorageExplicitlyOptedIn(env) && !hasEconomyEnvAuthorityIntent(clientEnv)) {
+    return { active: false, client: null };
+  }
+  let resolved;
+  try {
+    resolved = resolveEconomyStorageClient(ECONOMY_APP, clientEnv, overrides ?? {});
+  } catch (error) {
+    if (error instanceof ClientTransportConfigurationError) {
+      throw credentialRequiredError(env, error);
+    }
+    throw error;
+  }
+  return { active: true, client: resolved.client };
+}
+function economyCloudStorage(env = process.env) {
+  if (cache === undefined) {
+    cache = resolveEconomyCloudStorage(env);
+    if (!cache.active && !localNoticePrinted) {
+      localNoticePrinted = true;
+      if (typeof process !== "undefined")
+        process.stderr.write(`${localEconomyNotice()}
+`);
+    }
+  }
+  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;
+}
+function economyTransportReport(env = process.env, overrides) {
+  const clientEnv = env;
+  if (localStorageExplicitlyOptedIn(env) && !hasEconomyEnvAuthorityIntent(clientEnv)) {
+    return {
+      ok: true,
+      selected: true,
+      transport: "sqlite",
+      source: "local-opt-in",
+      authority: null,
+      issues: []
+    };
+  }
+  try {
+    const resolved = resolveEconomyStorageClient(ECONOMY_APP, clientEnv, overrides ?? {});
+    return {
+      ok: true,
+      selected: true,
+      transport: "http",
+      source: resolved.resolution.transportSource,
+      authority: {
+        baseUrl: resolved.resolution.baseUrl,
+        apiUrlSource: resolved.resolution.apiUrlSource,
+        apiKeySource: resolved.resolution.apiKeySource,
+        apiKeyTier: resolved.resolution.apiKeyTier,
+        warning: resolved.resolution.warning
+      },
+      issues: []
+    };
+  } catch (error) {
+    if (error instanceof ClientTransportConfigurationError) {
+      return {
+        ok: false,
+        selected: true,
+        transport: "http",
+        source: null,
+        authority: null,
+        issues: [error.message]
+      };
+    }
+    throw error;
+  }
+}
+
+// src/lib/savings.ts
+function requireCurrentSavingsReport(value) {
+  if (!value || typeof value !== "object")
+    throw new Error("SAVINGS_REPORT_UNAVAILABLE: Invalid savings response");
+  const report = value;
+  if (report.comparison_basis !== "included_usage_vs_current_plan_estimate" || !["estimated", "not_applicable", "unavailable"].includes(String(report.comparison_status))) {
+    throw new Error("SAVINGS_REPORT_UNAVAILABLE: The service must support the current subscription comparison contract");
+  }
+  for (const field of ["api_equivalent_usd", "subscription_fee_usd", "on_demand_usd", "saved_usd", "net_comparison_usd"]) {
+    const number = report[field];
+    if (number !== null && (typeof number !== "number" || !Number.isFinite(number))) {
+      throw new Error("SAVINGS_REPORT_UNAVAILABLE: Invalid monetary field " + field);
+    }
+  }
+  if (report.comparison_status === "unavailable" && (report.saved_usd !== null || report.net_comparison_usd !== null)) {
+    throw new Error("SAVINGS_REPORT_UNAVAILABLE: Unavailable comparison carries a monetary claim");
+  }
+  return value;
+}
+function prorateMonthlyFee(monthlyFee, period, now = new Date) {
+  if (!Number.isFinite(monthlyFee) || monthlyFee < 0)
+    throw new RangeError("Monthly fee must be finite and nonnegative");
+  const bounds = calendarPeriodBounds(period, now);
+  if (bounds.start_date === null)
+    return null;
+  let cursor = new Date(bounds.start_date + "T00:00:00.000Z");
+  const end = new Date(bounds.end_date_exclusive + "T00:00:00.000Z");
+  let fee = 0;
+  while (cursor < end) {
+    const monthEnd = new Date(Date.UTC(cursor.getUTCFullYear(), cursor.getUTCMonth() + 1, 1));
+    const next = new Date(Math.min(end.getTime(), monthEnd.getTime()));
+    const days = (next.getTime() - cursor.getTime()) / 86400000;
+    const monthDays = new Date(Date.UTC(cursor.getUTCFullYear(), cursor.getUTCMonth() + 1, 0)).getUTCDate();
+    fee += monthlyFee / monthDays * days;
+    cursor = next;
+  }
+  return fee;
+}
+function feeFor(plans, period, now) {
+  let known = 0;
+  let complete = true;
+  for (const plan of plans) {
+    if (plan.fee_basis !== "observed" && plan.fee_basis !== "configured" || plan.monthly_fee_usd === null || !Number.isFinite(plan.monthly_fee_usd) || plan.monthly_fee_usd < 0) {
+      complete = false;
+      continue;
+    }
+    const amount = prorateMonthlyFee(plan.monthly_fee_usd, period, now);
+    if (amount === null || !Number.isFinite(amount) || !Number.isFinite(known + amount))
+      complete = false;
+    else
+      known += amount;
+  }
+  return { known, total: complete ? known : null };
+}
+function summarizeOnDemand(observations, period, now = new Date) {
+  const rows = observations.filter((row) => row.metric === "on_demand_usd");
+  if (!rows.length)
+    return { usd: null, status: "not_observed" };
+  const bounds = calendarPeriodBounds(period, now);
+  const start = bounds.start_date ? Date.parse(bounds.start_date + "T00:00:00Z") : -Infinity;
+  const end = bounds.end_date_exclusive ? Date.parse(bounds.end_date_exclusive + "T00:00:00Z") : Infinity;
+  const windows = new Map;
+  for (const row of rows) {
+    const from = Date.parse(row.window_start ?? "");
+    const until = Date.parse(row.window_end ?? "");
+    const at = Date.parse(row.source_timestamp ?? row.observed_at ?? "");
+    if (row.unit.toLowerCase() !== "usd" || !Number.isFinite(row.value) || row.value < 0 || !row.provider || !row.account_key || !Number.isFinite(from) || !Number.isFinite(until) || from >= until || !Number.isFinite(at) || row.value_kind !== "cumulative" && row.value_kind !== "delta") {
+      return { usd: null, status: "unavailable" };
+    }
+    if (until <= start || from >= end)
+      continue;
+    if (from < start || until > end)
+      return { usd: null, status: "unavailable" };
+    const key = JSON.stringify([row.provider, row.account_key, from, until]);
+    const previous = windows.get(key);
+    if (previous && previous.row.value_kind !== row.value_kind)
+      return { usd: null, status: "unavailable" };
+    if (previous && ((row.value_kind === "delta" || at === previous.at) && previous.row.value !== row.value)) {
+      return { usd: null, status: "unavailable" };
+    }
+    if (!previous || at > previous.at)
+      windows.set(key, { row, at, start: from, end: until });
+  }
+  const byAccount = new Map;
+  let total = 0;
+  for (const window of windows.values()) {
+    const key = JSON.stringify([window.row.provider, window.row.account_key]);
+    const intervals = byAccount.get(key) ?? [];
+    if (intervals.some((other) => window.start < other.end && window.end > other.start)) {
+      return { usd: null, status: "unavailable" };
+    }
+    intervals.push(window);
+    byAccount.set(key, intervals);
+    total += window.row.value;
+  }
+  return windows.size ? { usd: total, status: "observed" } : { usd: null, status: "not_observed" };
+}
+function buildSavingsSummary(period, usage, plans, observations, agent, now = new Date, prices = []) {
+  const selected = usage.filter((row) => !agent || row.agent === agent);
+  const activePlans = plans.filter((row) => row.active === 1);
+  const selectedPlans = activePlans.filter((row) => !agent || row.agent === agent);
+  const sharedPlans = activePlans.filter((row) => !row.agent || !row.account_key);
+  const fee = feeFor(selectedPlans, period, now);
+  const unallocated = feeFor(sharedPlans, period, now);
+  const reasons = new Set;
+  let priced = 0, metered = 0, estimated = 0, included = 0, unknownPrices = 0, unknownBilling = 0, estimatedSessions = 0;
+  for (const row of selected) {
+    if (row.session_count) {
+      estimatedSessions += row.session_count;
+      reasons.add("billing_route_unknown");
+    }
+    if (!hasKnownUsagePrice(row, prices)) {
+      unknownPrices += row.requests;
+      reasons.add("model_price_unknown");
+      continue;
+    }
+    priced += row.cost_usd;
+    if (row.cost_basis === "metered_api")
+      metered += row.cost_usd;
+    else if (row.cost_basis === "subscription_included") {
+      included += row.cost_usd;
+      const matches = selectedPlans.filter((plan) => !!row.account_key && plan.account_key === row.account_key);
+      if (matches.length === 0)
+        reasons.add("subscription_account_unmapped");
+      if (matches.length > 1)
+        reasons.add("subscription_account_ambiguous");
+    } else {
+      estimated += row.cost_usd;
+      unknownBilling += row.requests;
+      reasons.add("billing_route_unknown");
+    }
+  }
+  if (unknownPrices)
+    reasons.add("model_price_unknown");
+  if (unknownBilling)
+    reasons.add("billing_route_unknown");
+  if (fee.total === null)
+    reasons.add(period === "all" ? "historical_plan_fees_unavailable" : "plan_fee_unknown");
+  if (included > 0 && !agent && sharedPlans.some((plan) => !plan.account_key))
+    reasons.add("subscription_account_unmapped");
+  const demand = summarizeOnDemand(observations.filter((row) => !agent || row.agent === agent), period, now);
+  const applicable = selectedPlans.length > 0 || selected.some((row) => row.cost_basis === "subscription_included");
+  const net = reasons.size ? null : applicable ? included - fee.known : 0;
+  const byAgent = {};
+  if (!agent) {
+    const agents = new Set([...usage.map((row) => row.agent), ...activePlans.flatMap((row) => row.agent ? [row.agent] : [])]);
+    for (const name of [...agents].sort()) {
+      const result = buildSavingsSummary(period, usage, plans, observations, name, now, prices);
+      const { by_agent: _, ...scalars } = result;
+      byAgent[name] = scalars;
+    }
+  }
+  return {
+    period,
+    api_equivalent_usd: reasons.has("model_price_unknown") ? null : priced,
+    priced_usage_value_usd: priced,
+    recorded_metered_api_usd: metered,
+    estimated_usage_value_usd: estimated,
+    subscription_fee_usd: fee.total,
+    known_subscription_fee_usd: fee.known,
+    unallocated_subscription_fee_usd: unallocated.total,
+    included_consumed_usd: included,
+    on_demand_usd: demand.usd,
+    on_demand_status: demand.status,
+    saved_usd: net === null ? null : Math.max(0, net),
+    net_comparison_usd: net,
+    comparison_status: reasons.size ? "unavailable" : applicable ? "estimated" : "not_applicable",
+    comparison_basis: "included_usage_vs_current_plan_estimate",
+    unavailable_reasons: [...reasons].sort(),
+    unknown_price_requests: unknownPrices,
+    unknown_billing_requests: unknownBilling,
+    estimated_only_sessions: estimatedSessions,
+    by_agent: byAgent
+  };
+}
+function querySavingsSummary(db, period, agent) {
+  const now = new Date;
+  const usage = db.prepare(`
+    SELECT agent, account_key, cost_basis, model,
+      CASE WHEN cost_usd = 0 THEN 1 WHEN cost_usd < 0 THEN 2 ELSE 0 END AS zero_cost,
+      COALESCE(SUM(cost_usd), 0) AS cost_usd, 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(cache_create_1h_tokens),0) AS cache_create_1h_tokens
+    FROM economy_effective_requests WHERE ${calendarPeriodWhere(period, "timestamp", now)}
+    GROUP BY agent, account_key, cost_basis, model, CASE WHEN cost_usd = 0 THEN 1 WHEN cost_usd < 0 THEN 2 ELSE 0 END
+  `).all();
+  const plans = db.prepare("SELECT * FROM subscriptions WHERE active = 1").all();
+  usage.push(...db.prepare(`
+    SELECT s.agent, s.account_key, 'estimated' AS cost_basis,
+      COALESCE(SUM(s.total_cost_usd), 0) AS cost_usd,
+      COALESCE(SUM(s.request_count), 0) AS requests, COUNT(*) AS session_count
+    FROM economy_effective_sessions s WHERE ${sessionOverlapWhere(period, "s", now)}
+      AND NOT EXISTS (SELECT 1 FROM economy_effective_requests r WHERE r.session_id = s.id)
+    GROUP BY s.agent, s.account_key
+  `).all());
+  const bounds = calendarPeriodBounds(period, now);
+  const windowWhere = bounds.start_date === null ? "1=1" : `(
+    (window_start IS NOT NULL AND window_end IS NOT NULL
+      AND window_start < '${bounds.end_date_exclusive}T00:00:00.000Z'
+      AND window_end > '${bounds.start_date}T00:00:00.000Z')
+    OR ((window_start IS NULL OR window_end IS NULL) AND ${calendarPeriodWhere(period, "date", now)})
+  )`;
+  const observations = db.prepare(`
+    SELECT * FROM usage_snapshots WHERE metric = 'on_demand_usd'
+      AND ${windowWhere}
+  `).all();
+  return buildSavingsSummary(period, usage, plans, observations, agent, now, listModelPricing(db));
+}
+
+// src/lib/billing-diff.ts
+function queryBillingDiff(db, period, thresholdPct = 15) {
+  if (!Number.isFinite(thresholdPct) || thresholdPct < 0)
+    throw new RangeError("thresholdPct must be a finite nonnegative number");
+  const usage = querySummary(db, period, undefined, true);
+  const billing = queryBillingSummary(db, period);
+  const rows = db.prepare(`
+    SELECT agent, COALESCE(SUM(cost_usd), 0) AS estimated_usd
+    FROM economy_effective_requests WHERE ${calendarPeriodWhere(period, "timestamp")}
+    GROUP BY agent ORDER BY agent
+  `).all();
+  return requireCurrentBillingDiffSummary({
+    period,
+    basis: "unmatched_subtotals",
+    estimated_usd: usage.total_usd,
+    actual_usd: billing.total_usd,
+    usage_summary: usage,
+    billing_summary: billing,
+    delta_usd: null,
+    delta_pct: null,
+    threshold_pct: thresholdPct,
+    is_alert: null,
+    comparable: false,
+    incomparable_reason: billing.record_count === 0 ? "no_billing_records" : "account_window_source_unverified",
+    by_agent: rows.map((row) => ({ ...row, basis: "stored_request_rows_subtotal", actual_usd: null, delta_usd: null, delta_pct: null })),
+    by_provider: billing.by_provider
+  });
+}
+function requireCurrentBillingDiffSummary(value) {
+  const invalid = () => {
+    throw new Error("BILLING_COMPARISON_UNAVAILABLE: The service must return scoped unmatched subtotals");
+  };
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return invalid();
+  const s = value;
+  if (s.basis !== "unmatched_subtotals" || s.comparable !== false || s.delta_usd !== null || s.delta_pct !== null || s.is_alert !== null)
+    return invalid();
+  if (!["today", "yesterday", "week", "month", "year", "all"].includes(String(s.period)) || typeof s.threshold_pct !== "number" || !Number.isFinite(s.threshold_pct) || s.threshold_pct < 0)
+    return invalid();
+  let usage, billing;
+  try {
+    usage = requireCurrentCostSummary(s.usage_summary);
+    billing = requireCurrentBillingSummary(s.billing_summary);
+  } catch {
+    return invalid();
+  }
+  if (usage.period !== s.period || s.estimated_usd !== usage.total_usd || s.actual_usd !== billing.total_usd || billing.recorded_total_usd !== (billing.record_count ? billing.total_usd : null))
+    return invalid();
+  if (s.incomparable_reason !== (billing.record_count === 0 ? "no_billing_records" : "account_window_source_unverified"))
+    return invalid();
+  const providers = s.by_provider;
+  if (!providers || typeof providers !== "object" || Array.isArray(providers) || !billing.by_provider || typeof billing.by_provider !== "object")
+    return invalid();
+  const expected = Object.entries(billing.by_provider);
+  if (Object.keys(providers).length !== expected.length || expected.some(([key, amount]) => typeof amount !== "number" || !Number.isFinite(amount) || providers[key] !== amount))
+    return invalid();
+  if (!Array.isArray(s.by_agent) || s.by_agent.some((row) => !row || typeof row !== "object" || typeof row.agent !== "string" || row.basis !== "stored_request_rows_subtotal" || typeof row.estimated_usd !== "number" || !Number.isFinite(row.estimated_usd) || row.actual_usd !== null || row.delta_usd !== null || row.delta_pct !== null))
+    return invalid();
+  return value;
+}
+function billingDriftCheck(diff) {
+  try {
+    requireCurrentBillingDiffSummary(diff);
+  } catch {
+    return { ok: false, msg: "billing drift: UNKNOWN \u2014 summary coverage unsupported; update the service" };
+  }
+  const detail = diff.incomparable_reason === "no_billing_records" ? "no provider billing records imported for this period" : "account, billing window, and source coverage are not established";
+  return { ok: false, msg: `billing drift ${diff.period}: UNKNOWN \u2014 comparison unavailable; ${detail}; ` + `known usage-value subtotal ${formatReportedUsd(diff.estimated_usd)}; provider rows ${formatBillingValue(diff.billing_summary)}` };
+}
+
+// src/lib/brief.ts
+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 requestPeriodWhere(period) {
+  return calendarPeriodWhere(period, "timestamp");
+}
+function sessionPeriodWhere(period) {
+  return calendarPeriodWhere(period, "started_at");
+}
+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
+  };
+}
+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);
+  }
+  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 economy_effective_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 economy_effective_sessions
+      WHERE ${where}${machineClause}
+        AND NOT EXISTS (SELECT 1 FROM economy_effective_requests r WHERE r.session_id = economy_effective_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, requestPeriodWhere(period), [], machine);
+  const sessions = querySessionOnlyTotals(db, sessionPeriodWhere(period), [], machine);
+  const totals = combineTotals(requests, sessions);
+  return {
+    ...totals,
+    sessions: summary.sessions,
+    requests: summary.requests,
+    total_tokens: summary.tokens,
+    cost_usd: summary.total_usd,
+    cost_summary: summary
+  };
+}
+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 economy_effective_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 economy_effective_sessions
+    WHERE started_at >= ?
+      AND machine_id != ''
+      ${sessionMachineClause}
+      AND NOT EXISTS (SELECT 1 FROM economy_effective_requests r WHERE r.session_id = economy_effective_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 economy_effective_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 economy_effective_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 economy_effective_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 economy_effective_sessions
+      WHERE started_at >= ?${sessionMachineClause}
+        AND NOT EXISTS (SELECT 1 FROM economy_effective_requests r WHERE r.session_id = economy_effective_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 normalizeAccountEmail(email) {
+  return email.trim().toLowerCase();
+}
+function accountKey(row) {
+  const agent = row.agent || row.account_tool || "unknown";
+  const email = normalizeAccountEmail(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 = accountKey(row);
+  const email = normalizeAccountEmail(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 economy_effective_requests r
+    LEFT JOIN economy_effective_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 economy_effective_sessions s
+    WHERE s.started_at >= ?${sessionMachineClause}
+      AND NOT EXISTS (SELECT 1 FROM economy_effective_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 economy_effective_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 economy_effective_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 economy_effective_requests r JOIN economy_effective_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 economy_effective_requests r JOIN economy_effective_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) {
+  if (!["today", "yesterday", "week", "month", "year", "all"].includes(period)) {
+    throw new RangeError("Invalid export period");
+  }
+  return calendarPeriodWhere(period, column);
+}
+function queryExportRows(db, type, period) {
+  if (type === "requests") {
+    const where2 = exportDateWhere("timestamp", period);
+    return db.prepare(`SELECT * FROM economy_effective_requests WHERE ${where2} ORDER BY timestamp ASC`).all();
+  }
+  const where = exportDateWhere("started_at", period);
+  return db.prepare(`SELECT * FROM economy_effective_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 economy_effective_requests WHERE DATE(timestamp) BETWEEN ? AND ?`).get(from, to);
+  const s = db.prepare(`SELECT COUNT(*) as sessions FROM economy_effective_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 economy_effective_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 economy_effective_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 economy_effective_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 economy_effective_requests GROUP BY model ORDER BY cost DESC`).all();
+}
+
+export { packageMetadata, requireCurrentSavingsReport, querySavingsSummary, queryBillingDiff, requireCurrentBillingDiffSummary, billingDriftCheck, buildBrief, queryProjectDetail, queryExportRows, queryRangeStats, queryForecast, queryModelEfficiency, LOCAL_STORAGE_OPT_IN_KEYS, economyCloudStorage, cloudListItems, cloudObject, economyTransportReport };