@hasna/economy 0.3.27 → 0.4.0

package/dist/mcp/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,QAAQ,YAAY,CAAA;AACjC,eAAO,MAAM,qBAAqB,OAAO,CAAA;AAEzC,wBAAgB,WAAW,IAAI,GAAG,CAw1BjC"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,QAAQ,YAAY,CAAA;AACjC,eAAO,MAAM,qBAAqB,OAAO,CAAA;AAEzC,wBAAgB,WAAW,IAAI,GAAG,CA81BjC"}

package/dist/otel/index.js

@@ -594,7 +594,60 @@ import { execFileSync } from "child_process";
 import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
 import { hostname, platform } from "os";
 import { homedir } from "os";
-import { join } from "path";
+import { join, resolve } from "path";
+import { homedir as pathsResolverHomedir } from "os";
+import { join as pathsResolverJoin } from "path";
+function pathsResolverAssertApp(app) {
+  if (typeof app !== "string" || app.length === 0) {
+    throw new TypeError("paths: app must be a non-empty string");
+  }
+  if (!PATHS_RESOLVER_APP_SLUG_RE.test(app)) {
+    throw new TypeError(`paths: invalid app slug "${app}" \u2014 expected lowercase kebab-case ([a-z0-9]+(-[a-z0-9]+)*)`);
+  }
+}
+function pathsResolverAssertKind(kind) {
+  if (!Object.keys(PATHS_RESOLVER_KIND_ENV).includes(kind)) {
+    throw new TypeError(`paths: invalid path kind "${kind}" \u2014 expected one of ${Object.keys(PATHS_RESOLVER_KIND_ENV).join(", ")}`);
+  }
+}
+function pathsResolverBaseDir(kind, options) {
+  pathsResolverAssertKind(kind);
+  const env = options.env ?? process.env;
+  const override = env[PATHS_RESOLVER_KIND_ENV[kind]];
+  if (typeof override === "string" && override.length > 0)
+    return override;
+  const home = options.home ?? pathsResolverHomedir();
+  const platform2 = options.platform ?? process.platform;
+  if (platform2 === "darwin") {
+    switch (kind) {
+      case "config":
+      case "data":
+        return pathsResolverJoin(home, "Library", "Application Support", "Hasna");
+      case "cache":
+        return pathsResolverJoin(home, "Library", "Caches", "Hasna");
+      case "state":
+        return pathsResolverJoin(home, "Library", "Logs", "Hasna");
+    }
+  }
+  switch (kind) {
+    case "config":
+      return pathsResolverJoin(home, ".config", "hasna");
+    case "data":
+      return pathsResolverJoin(home, ".local", "share", "hasna");
+    case "state":
+      return pathsResolverJoin(home, ".local", "state", "hasna");
+    case "cache":
+      return pathsResolverJoin(home, ".cache", "hasna");
+  }
+}
+function pathsResolverResolve(kind, options) {
+  pathsResolverAssertApp(options.app);
+  const appSegment = options.internal === true ? pathsResolverJoin("internal", options.app) : options.app;
+  return pathsResolverJoin(pathsResolverBaseDir(kind, options), appSegment);
+}
+function dataDir(options) {
+  return pathsResolverResolve("data", options);
+}
 function normalizeMachineId(value) {
   const id = value?.trim().toLowerCase().split(".")[0];
   return id && id.length > 0 ? id : null;
@@ -617,7 +670,7 @@ function macHostMachineId() {
   return null;
 }
 function getMachineId() {
-  const envMachine = normalizeMachineId(process.env["ECONOMY_MACHINE_ID"]);
+  const envMachine = normalizeMachineId(process.env["HASNA_ECONOMY_MACHINE_ID"]);
   if (envMachine)
     return envMachine;
   const hostMachine = normalizeMachineId(hostname()) ?? "unknown";
@@ -625,21 +678,48 @@ function getMachineId() {
     return macHostMachineId() ?? hostMachine;
   return hostMachine;
 }
-function getDataDir() {
+function getHomeDir() {
   const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir();
-  const newDir = join(home, ".hasna", "economy");
-  const oldDir = join(home, ".economy");
-  if (existsSync(oldDir) && !existsSync(newDir)) {
-    mkdirSync(newDir, { recursive: true });
+  if (!home)
+    throw new Error("Could not resolve the user home directory");
+  return home;
+}
+function getResolverDataRoot() {
+  return dataDir({
+    app: "economy",
+    home: process.env["HOME"] || process.env["USERPROFILE"] || undefined
+  });
+}
+function getLegacyDataRoot() {
+  return join(getHomeDir(), ".hasna", "economy");
+}
+function adoptResolverDataRoot(resolved, env = process.env) {
+  const dataOverride = env.HASNA_DATA_HOME;
+  if (typeof dataOverride === "string" && dataOverride.trim().length > 0)
+    return true;
+  return existsSync(join(resolved, "economy.db"));
+}
+function getExactDataRoot() {
+  const dir = process.env["HASNA_ECONOMY_HOME"] ?? process.env["ECONOMY_HOME"];
+  if (dir && dir.trim())
+    return dir.trim();
+  return;
+}
+function getDataDir() {
+  const exact = getExactDataRoot();
+  const effective = exact ? resolve(exact) : adoptResolverDataRoot(getResolverDataRoot()) ? resolve(getResolverDataRoot()) : getLegacyDataRoot();
+  const oldDir = join(getHomeDir(), ".economy");
+  if (existsSync(oldDir) && !existsSync(effective)) {
+    mkdirSync(effective, { recursive: true });
     for (const file of readdirSync(oldDir)) {
       const oldPath = join(oldDir, file);
       if (statSync(oldPath).isFile()) {
-        copyFileSync(oldPath, join(newDir, file));
+        copyFileSync(oldPath, join(effective, file));
       }
     }
   }
-  mkdirSync(newDir, { recursive: true });
-  return newDir;
+  mkdirSync(effective, { recursive: true });
+  return effective;
 }
 function getDbPath() {
   if (process.env["HASNA_ECONOMY_DB_PATH"])
@@ -1039,8 +1119,16 @@ function seedModelPricing(db, defaults) {
     });
   }
 }
+var PATHS_RESOLVER_KIND_ENV, PATHS_RESOLVER_APP_SLUG_RE;
 var init_database = __esm(() => {
   init_sqlite_adapter();
+  PATHS_RESOLVER_KIND_ENV = {
+    config: "HASNA_CONFIG_HOME",
+    data: "HASNA_DATA_HOME",
+    state: "HASNA_STATE_HOME",
+    cache: "HASNA_CACHE_HOME"
+  };
+  PATHS_RESOLVER_APP_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 });
 
 // src/otel/index.ts
@@ -1385,11 +1473,334 @@ async function ingestOtelRows(db, rows) {
     rollupSession(db, sessionId);
   return { requests, sessions: sessions.size };
 }
+
+// src/lib/cloud-ingest.ts
+init_database();
+init_pricing();
+
+// src/ingest/claude.ts
+init_database();
+init_pricing();
+import { homedir as homedir3 } from "os";
+import { join as join3, basename } from "path";
+
+// src/lib/accounts-store.ts
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { z } from "zod";
+import { resolveClientTransport, resolveCredential } from "@hasna/contracts/client";
+var profileNameSchema = z.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9-]*$/, "must be lowercase alphanumeric/hyphen and start with a letter or digit");
+var profileSchema = z.object({
+  name: z.string(),
+  tool: z.string(),
+  email: z.string().optional(),
+  displayName: z.string().optional(),
+  dir: z.string(),
+  description: z.string().optional(),
+  createdAt: z.string(),
+  lastUsedAt: z.string().optional()
+});
+var toolDefSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  envVar: z.string(),
+  defaultDir: z.string(),
+  bin: z.string()
+});
+var storeSchema = z.object({
+  version: z.literal(1),
+  current: z.record(z.string(), z.string()).default({}),
+  applied: z.record(z.string(), z.string()).default({}),
+  toolLocks: z.record(z.string(), z.string()).default({}),
+  profiles: z.array(profileSchema).default([]),
+  tools: z.array(toolDefSchema).default([])
+});
+var BUILTIN_TOOLS = [
+  { id: "claude", label: "Claude Code", envVar: "CLAUDE_CONFIG_DIR", defaultDir: join2(homedir2(), ".claude"), bin: "claude" },
+  { id: "codex-app", label: "Codex App", envVar: "CODEX_HOME", defaultDir: join2(homedir2(), ".codex"), bin: "/Applications/Codex.app/Contents/MacOS/Codex" },
+  { id: "codex", label: "Codex CLI", envVar: "CODEX_HOME", defaultDir: join2(homedir2(), ".codex"), bin: "codex" },
+  { id: "codewith", label: "Codewith", envVar: "CODEWITH_HOME", defaultDir: join2(homedir2(), ".codewith"), bin: "codewith" },
+  { id: "takumi", label: "Takumi", envVar: "TAKUMI_CONFIG_DIR", defaultDir: join2(homedir2(), ".takumi"), bin: "takumi" },
+  { id: "gemini", label: "Gemini CLI", envVar: "GEMINI_CONFIG_DIR", defaultDir: join2(homedir2(), ".gemini"), bin: "gemini" },
+  { id: "opencode", label: "opencode", envVar: "OPENCODE_CONFIG_DIR", defaultDir: join2(homedir2(), ".config", "opencode"), bin: "opencode" },
+  { id: "cursor", label: "Cursor Agent", envVar: "CURSOR_CONFIG_DIR", defaultDir: join2(homedir2(), ".cursor"), bin: "cursor-agent" },
+  { id: "pi", label: "Pi Coding Agent", envVar: "PI_CODING_AGENT_HOME", defaultDir: join2(homedir2(), ".pi"), bin: "pi" },
+  { id: "hermes", label: "Hermes", envVar: "HERMES_HOME", defaultDir: join2(homedir2(), ".hermes"), bin: "hermes" },
+  { id: "kimi", label: "Kimi Code", envVar: "KIMI_CODE_HOME", defaultDir: join2(homedir2(), ".kimi-code"), bin: "kimi" },
+  { id: "grok", label: "Grok Build", envVar: "HOME", defaultDir: join2(homedir2(), ".grok"), bin: "grok" }
+];
+
+// src/ingest/claude.ts
+var CLAUDE_PROJECTS_DIR = process.env["HASNA_ECONOMY_CLAUDE_PROJECTS_DIR"] ?? join3(homedir3(), ".claude", "projects");
+var TAKUMI_PROJECTS_DIR = process.env["HASNA_ECONOMY_TAKUMI_PROJECTS_DIR"] ?? join3(homedir3(), ".takumi", "projects");
+
+// src/ingest/codex.ts
+import { homedir as homedir4 } from "os";
+import { join as join4, basename as basename2 } from "path";
+init_database();
+init_pricing();
+var DEFAULT_CODEX_DB_PATH = join4(homedir4(), ".codex", "state_5.sqlite");
+var DEFAULT_CODEX_CONFIG_PATH = join4(homedir4(), ".codex", "config.toml");
+var DEFAULT_CODEWITH_DB_PATH = join4(homedir4(), ".codewith", "state_5.sqlite");
+var DEFAULT_CODEWITH_CONFIG_PATH = join4(homedir4(), ".codewith", "config.toml");
+
+// src/ingest/gemini.ts
+init_database();
+init_pricing();
+import { homedir as homedir5 } from "os";
+import { join as join5, basename as basename3 } from "path";
+var DEFAULT_GEMINI_TMP_DIR = join5(homedir5(), ".gemini", "tmp");
+var DEFAULT_GEMINI_HISTORY_DIR = join5(homedir5(), ".gemini", "history");
+
+// src/ingest/opencode.ts
+init_database();
+init_pricing();
+import { homedir as homedir6 } from "os";
+import { join as join6 } from "path";
+var OPENCODE_STORAGE = join6(homedir6(), ".local", "share", "opencode", "storage");
+
+// src/ingest/cursor.ts
+init_database();
+
+// src/ingest/pi.ts
+init_database();
+import { homedir as homedir7 } from "os";
+import { join as join7 } from "path";
+var PI_SESSION_DIR = process.env["PI_CODING_AGENT_SESSION_DIR"] ?? join7(homedir7(), ".pi", "agent", "sessions");
+
+// src/ingest/hermes.ts
+init_database();
+import { homedir as homedir8 } from "os";
+import { join as join8 } from "path";
+var HERMES_DB = join8(homedir8(), ".hermes", "state.db");
+
+// src/ingest/loops.ts
+init_database();
+init_pricing();
+
+// src/ingest/claude-quota.ts
+init_database();
+
+// src/lib/paths.ts
+import { homedir as homedir9 } from "os";
+import { join as join9 } from "path";
+function getHomeDir2() {
+  return process.env["USERPROFILE"] ?? process.env["HOME"] ?? homedir9();
+}
+function agentPaths() {
+  const home = getHomeDir2();
+  return {
+    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")
+  };
+}
+
+// src/ingest/claude-quota.ts
+var CREDENTIALS_PATH = agentPaths().claudeCredentials;
+
+// src/ingest/codex-quota.ts
+init_database();
+var WHAM_USAGE_URL = process.env["CODEX_USAGE_URL"] ?? "https://chatgpt.com/backend-api/wham/usage";
+
+// src/lib/sync-all.ts
+init_database();
+
+// src/ingest/billing.ts
+init_database();
+
+// src/lib/sync-maintenance.ts
+init_database();
+
+// src/lib/cloud-ingest.ts
+var CLOUD_INGEST_TABLES = ["requests", "sessions", "billing_daily", "usage_snapshots", "subscriptions"];
+function exportIngestRows(db) {
+  const body = {};
+  for (const table of CLOUD_INGEST_TABLES) {
+    const rows = db.prepare(`SELECT * FROM ${table}`).all();
+    if (rows.length > 0)
+      body[table] = rows;
+  }
+  return body;
+}
+function unwrapEnvelope(raw) {
+  if (raw && typeof raw === "object" && "data" in raw) {
+    const data = raw.data;
+    return data && typeof data === "object" ? data : {};
+  }
+  return raw ?? {};
+}
+async function postIngest(cloud, body) {
+  const raw = await cloud.client.transport.post("/ingest", body);
+  const payload = unwrapEnvelope(raw);
+  return {
+    ingested: payload["ingested"] ?? {},
+    total: Number(payload["total"] ?? 0)
+  };
+}
+async function pushIngestRows(cloud, scratch) {
+  const body = exportIngestRows(scratch);
+  if (Object.keys(body).length === 0)
+    return { posted: false, ingested: {}, total: 0 };
+  const response = await postIngest(cloud, body);
+  return { posted: true, ingested: response.ingested, total: response.total };
+}
+
+// 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 RETIRED_STORAGE_MODE_KEYS = [
+  "HASNA_ECONOMY_STORAGE_MODE",
+  "HASNA_ECONOMY_MODE",
+  "ECONOMY_STORAGE_MODE",
+  "ECONOMY_MODE"
+];
+function assertNoRetiredStorageMode(env) {
+  const legacyKey = RETIRED_STORAGE_MODE_KEYS.find((key) => Object.hasOwn(env, key) && env[key] !== undefined);
+  if (!legacyKey)
+    return;
+  throw new Error(`${legacyKey} was removed. Deployment modes no longer exist: delete the storage-mode variable. ` + `The client routes through the HTTP API resolved by @hasna/contracts ` + `(HASNA_ECONOMY_API_URL + HASNA_ECONOMY_API_KEY, the Keychain, or ` + `~/.hasna/economy/config/credentials), or serves the local SQLite store only when ` + `HASNA_ECONOMY_LOCAL=1 is set.`);
+}
+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) {
+  assertNoRetiredStorageMode(env);
+  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;
+}
 // package.json
 var package_default = {
   name: "@hasna/economy",
-  version: "0.3.27",
-  description: "AI coding cost tracker \u2014 CLI + MCP server + REST API + web dashboard for Claude Code, Codex, OpenCode, Cursor, Pi, and Hermes, with legacy Gemini CLI session and Gemini API billing ingestion",
+  version: "0.4.0",
+  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: "git+https://github.com/hasna/economy.git"
@@ -1420,7 +1831,7 @@ var package_default = {
   files: [
     "dist",
     "docs",
-    "dashboard/dist",
+    "postinstall.js",
     "LICENSE",
     "README.md",
     "CHANGELOG.md",
@@ -1429,12 +1840,11 @@ var package_default = {
     "CODE_OF_CONDUCT.md"
   ],
   scripts: {
-    build: "cd dashboard && bun install --frozen-lockfile && bun run build && cd .. && bun build src/cli/index.ts --outdir dist/cli --target bun --packages external && bun build src/mcp/index.ts --outdir dist/mcp --target bun --packages external && 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/otel/index.ts --outdir dist/otel --target bun --packages external && bun build src/index.ts --outdir dist --target bun --packages external && tsc --emitDeclarationOnly --outDir dist",
+    build: "bun build src/cli/index.ts --outdir dist/cli --target bun --packages external && bun build src/mcp/index.ts --outdir dist/mcp --target bun --packages external && 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/otel/index.ts --outdir dist/otel --target bun --packages external && bun build src/index.ts --outdir dist --target bun --packages external && tsc --emitDeclarationOnly --outDir dist",
     "build:cli": "bun build src/cli/index.ts --outdir dist/cli --target bun --packages external",
     "build:mcp": "bun build src/mcp/index.ts --outdir dist/mcp --target bun --packages external",
     "build:server": "bun build src/server/index.ts --outdir dist/server --target bun --packages external",
     "build:lib": "bun build src/index.ts --outdir dist --target bun --packages external",
-    "build:dashboard": "cd dashboard && bun run build",
     "artifact-scan": "bun scripts/contracts-cli.mjs artifact-scan dist",
     prepack: "bun run build && bun run artifact-scan",
     typecheck: "tsc --noEmit",
@@ -1443,7 +1853,7 @@ var package_default = {
     "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: "mkdir -p $HOME/.hasna/economy/training 2>/dev/null || true"
+    postinstall: "node postinstall.js"
   },
   keywords: [
     "economy",
@@ -1464,11 +1874,8 @@ var package_default = {
     access: "public"
   },
   dependencies: {
-    "@hasna/accounts": "0.2.23",
-    "@hasna/agent-registry": "^0.1.0",
-    "@hasna/contracts": "0.13.4",
+    "@hasna/contracts": "1.0.2",
     "@hasna/events": "^0.1.16",
-    "@hasna/mcp-harness": "^0.1.0",
     "@hasna/projects": "1.0.0",
     "@modelcontextprotocol/sdk": "^1.12.1",
     chalk: "^5.4.1",
@@ -1477,7 +1884,7 @@ var package_default = {
     zod: "^3.24.2"
   },
   devDependencies: {
-    "@types/bun": "latest",
+    "@types/bun": "1.3.14",
     "@types/pg": "^8.20.0",
     "bun-types": "latest",
     typescript: "^5.7.2"
@@ -1517,7 +1924,7 @@ if (args.includes("--version") || args.includes("-V")) {
 if (args.includes("--help") || args.includes("-h")) {
   console.log(`Usage: economy-otel [options]
 
-OTLP/HTTP metrics sidecar \u2014 ingests *.cost.* / *.token.* metrics into economy.db
+OTLP/HTTP metrics sidecar \u2014 ingests *.cost.* / *.token.* metrics into Economy
 
 Options:
   -p, --port <port>  Port to bind (default: ECONOMY_OTEL_PORT or 4318)
@@ -1528,6 +1935,13 @@ Environment:
   ECONOMY_OTEL_PORT  Override the default port (4318)
   ECONOMY_OTEL_BIND  Bind address (default: 127.0.0.1)
 
+Storage (decided at startup, before the listener binds):
+  A credential resolved by @hasna/contracts (Keychain item
+  hasna.credentials.economy.api-key, ~/.hasna/economy/config/credentials,
+  HASNA_ECONOMY_API_KEY) forwards every accepted payload to the hosted
+  API's /v1/ingest. HASNA_ECONOMY_LOCAL=1 writes the on-box SQLite store
+  instead. With neither the sidecar fails closed (exit 1, no listener).
+
 Endpoints:
   POST /v1/metrics     OTLP JSON metrics
   POST /ingest         Simplified single-event JSON
@@ -1535,7 +1949,28 @@ Endpoints:
   process.exit(0);
 }
 var port = resolvePort(args);
-var db = openDatabase();
+function resolveStorage() {
+  try {
+    return economyCloudStorage();
+  } catch (error) {
+    console.error(`economy-otel: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+var storage = resolveStorage();
+var localDb = storage.active ? null : openDatabase();
+async function forwardRows(cloud, rows) {
+  const scratch = openDatabase(":memory:", true);
+  try {
+    const result = await ingestOtelRows(scratch, rows);
+    const pushed = await pushIngestRows(cloud, scratch);
+    return { ...result, forwarded: pushed.total };
+  } finally {
+    try {
+      scratch.close();
+    } catch {}
+  }
+}
 var server = Bun.serve({
   port,
   hostname: process.env["ECONOMY_OTEL_BIND"] ?? "127.0.0.1",
@@ -1560,7 +1995,16 @@ var server = Bun.serve({
     if (rows.length === 0) {
       return Response.json({ ingested: 0, message: "no matching metrics" });
     }
-    const result = await ingestOtelRows(db, rows);
+    if (storage.active) {
+      try {
+        const result2 = await forwardRows(storage, rows);
+        return Response.json({ ingested: result2.requests, sessions: result2.sessions, forwarded: result2.forwarded });
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        return Response.json({ error: `forward to the economy API failed: ${reason}` }, { status: 502 });
+      }
+    }
+    const result = await ingestOtelRows(localDb, rows);
     return Response.json({ ingested: result.requests, sessions: result.sessions });
   }
 });