@hasna/economy 0.3.28 → 0.4.0

package/dist/mcp/index.js

@@ -596,7 +596,62 @@ import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
 import { hostname, platform } from "os";
 import { homedir } from "os";
 import { join, resolve } from "path";
-import { dataDir } from "@hasna/paths";
+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 cacheDir(options) {
+  return pathsResolverResolve("cache", options);
+}
 function normalizeMachineId(value) {
   const id = value?.trim().toLowerCase().split(".")[0];
   return id && id.length > 0 ? id : null;
@@ -619,7 +674,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";
@@ -1929,6 +1984,10 @@ function getIngestState(db, source, key) {
   const row = db.prepare(`SELECT value FROM ingest_state WHERE source = ? AND key = ?`).get(source, key);
   return row?.value ?? null;
 }
+function loadIngestState(db, source) {
+  const rows = db.prepare(`SELECT key, value FROM ingest_state WHERE source = ?`).all(source);
+  return new Map(rows.map((row) => [row.key, row.value]));
+}
 function setIngestState(db, source, key, value) {
   db.prepare(`INSERT OR REPLACE INTO ingest_state (source, key, value) VALUES (?, ?, ?)`).run(source, key, value);
 }
@@ -2104,8 +2163,16 @@ function dedupeRequests(db) {
   }
   return removed;
 }
+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/mcp/index.ts
@@ -2113,8 +2180,8 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 // package.json
 var package_default = {
   name: "@hasna/economy",
-  version: "0.3.28",
-  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"
@@ -2145,7 +2212,6 @@ var package_default = {
   files: [
     "dist",
     "docs",
-    "dashboard/dist",
     "postinstall.js",
     "LICENSE",
     "README.md",
@@ -2155,12 +2221,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",
@@ -2190,12 +2255,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/paths": "0.1.0",
     "@hasna/projects": "1.0.0",
     "@modelcontextprotocol/sdk": "^1.12.1",
     chalk: "^5.4.1",
@@ -2204,7 +2265,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"
@@ -2228,17 +2289,572 @@ function getPackageMetadata() {
 var packageMetadata = getPackageMetadata();
 
 // src/mcp/server.ts
-init_database();
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { registerAgentTools } from "@hasna/agent-registry";
+
+// src/mcp/agent-registry.ts
+init_database();
+import { Database as Database2 } from "bun:sqlite";
+import { dirname, join as join2 } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
 import { z } from "zod";
 
+// 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;
+}
+function cleanQuery(query) {
+  if (!query)
+    return;
+  const out = {};
+  for (const [k, v] of Object.entries(query)) {
+    if (v !== undefined && v !== null && v !== "")
+      out[k] = v;
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+async function cloudListItems(storage, resource, query) {
+  const cleaned = cleanQuery(query);
+  const res = await storage.client.list(resource, cleaned ? { query: cleaned } : {});
+  return res.items;
+}
+async function cloudObject(storage, path, query) {
+  const cleaned = cleanQuery(query);
+  const raw = await storage.client.transport.get(path, cleaned ? { query: cleaned } : {});
+  if (raw && typeof raw === "object" && "data" in raw) {
+    return raw.data;
+  }
+  return raw;
+}
+
+// src/mcp/agent-registry.ts
+var SERVICE_NAME = "agent-registry";
+var DEFAULT_ACTIVE_WINDOW_MS = 30 * 60 * 1000;
+function envVar(suffix) {
+  return process.env[`HASNA_AGENT_REGISTRY_${suffix}`] ?? process.env[`HASNA_AGENT_${suffix}`];
+}
+function getActiveWindowMs() {
+  const env = envVar("TIMEOUT_MS");
+  if (env) {
+    const parsed = Number.parseInt(env, 10);
+    if (Number.isFinite(parsed) && parsed > 0)
+      return parsed;
+  }
+  return DEFAULT_ACTIVE_WINDOW_MS;
+}
+function envSessionId() {
+  return envVar("SESSION_ID") ?? null;
+}
+var MEMORY_REGISTRY_PATH = ":memory:";
+function resolveRegistryDbPath() {
+  const explicit = process.env.HASNA_AGENT_REGISTRY_DB_PATH;
+  if (explicit && explicit.trim())
+    return explicit;
+  if (economyCloudStorage().active)
+    return MEMORY_REGISTRY_PATH;
+  return join2(getDataDir(), "agent-registry.db");
+}
+var defaultDb = null;
+
+class RegistryDb {
+  db;
+  constructor(path) {
+    if (path !== MEMORY_REGISTRY_PATH && dirname(path) && !existsSync2(dirname(path))) {
+      mkdirSync2(dirname(path), { recursive: true, mode: 448 });
+    }
+    this.db = new Database2(path);
+    this.db.exec("PRAGMA journal_mode = WAL");
+    this.db.exec("PRAGMA busy_timeout = 10000");
+  }
+  get(sql, ...params) {
+    return this.db.prepare(sql).get(...params);
+  }
+  all(sql, ...params) {
+    return this.db.prepare(sql).all(...params);
+  }
+  run(sql, ...params) {
+    return this.db.prepare(sql).run(...params);
+  }
+  exec(sql) {
+    this.db.exec(sql);
+  }
+  close() {
+    this.db.close();
+  }
+}
+function getDefaultStore() {
+  if (!defaultDb) {
+    defaultDb = new RegistryDb(resolveRegistryDbPath());
+    ensureAgentsTable(defaultDb);
+  }
+  return defaultDb;
+}
+var AGENTS_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS agents (
+  id                TEXT PRIMARY KEY,
+  name              TEXT NOT NULL,
+  session_id        TEXT,
+  role              TEXT NOT NULL DEFAULT 'agent',
+  status            TEXT NOT NULL DEFAULT 'active',
+  active_project_id TEXT,
+  working_dir       TEXT,
+  machine_id        TEXT,
+  capabilities      TEXT NOT NULL DEFAULT '[]',
+  metadata          TEXT NOT NULL DEFAULT '{}',
+  last_seen_at      TEXT NOT NULL,
+  created_at        TEXT NOT NULL
+)`;
+var AGENTS_NAME_INDEX_SQL = `CREATE INDEX IF NOT EXISTS agents_name_idx ON agents(name)`;
+function ensureAgentsTable(db) {
+  db.exec(AGENTS_TABLE_SQL);
+  db.exec(AGENTS_NAME_INDEX_SQL);
+}
+function newAgentId() {
+  return `ag_${crypto.randomUUID().slice(0, 8)}`;
+}
+function now() {
+  return new Date().toISOString();
+}
+function normalizeName(name) {
+  return name.trim().toLowerCase();
+}
+function rowToAgent(row) {
+  return {
+    id: String(row.id),
+    name: String(row.name),
+    session_id: row.session_id ?? null,
+    role: row.role ?? "agent",
+    status: row.status ?? "active",
+    active_project_id: row.active_project_id ?? null,
+    working_dir: row.working_dir ?? null,
+    machine_id: row.machine_id ?? null,
+    capabilities: safeParseArray(row.capabilities),
+    metadata: safeParseObject(row.metadata),
+    last_seen_at: String(row.last_seen_at),
+    created_at: String(row.created_at)
+  };
+}
+function safeParseArray(value) {
+  if (!value)
+    return [];
+  try {
+    const parsed = JSON.parse(String(value));
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function safeParseObject(value) {
+  if (!value)
+    return {};
+  try {
+    const parsed = JSON.parse(String(value));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function isActiveAt(lastSeenAt, windowMs) {
+  return Date.now() - new Date(lastSeenAt).getTime() < windowMs;
+}
+function isAgentConflict(result) {
+  return Boolean(result) && result.conflict === true;
+}
+function getAgent(id, db) {
+  const row = db.get("SELECT * FROM agents WHERE id = ?", id);
+  return row ? rowToAgent(row) : null;
+}
+function getAgentByName(name, db) {
+  const row = db.get("SELECT * FROM agents WHERE name = ? AND status = 'active' ORDER BY last_seen_at DESC LIMIT 1", normalizeName(name));
+  return row ? rowToAgent(row) : null;
+}
+function resolveAgent(idOrName, db) {
+  const key = idOrName ?? envSessionId();
+  if (!key)
+    return null;
+  return getAgentByName(key, db) ?? getAgent(key, db);
+}
+function listAgents(opts = {}, db) {
+  const includeArchived = opts.include_archived ?? false;
+  const where = includeArchived ? "" : "WHERE status = 'active'";
+  const rows = db.all(`SELECT * FROM agents ${where} ORDER BY name`);
+  let agents = rows.map(rowToAgent);
+  if (opts.online_only) {
+    const windowMs = getActiveWindowMs();
+    agents = agents.filter((a) => a.status === "active" && isActiveAt(a.last_seen_at, windowMs));
+  }
+  return agents;
+}
+function registerAgent(input, db) {
+  const name = normalizeName(input.name);
+  if (!name) {
+    throw new Error("register_agent: name is required");
+  }
+  const sessionId = input.session_id ?? envSessionId() ?? null;
+  const windowMs = getActiveWindowMs();
+  const existing = getAgentByName(name, db);
+  if (existing) {
+    const active = isActiveAt(existing.last_seen_at, windowMs);
+    const sameSession = Boolean(sessionId) && Boolean(existing.session_id) && sessionId === existing.session_id;
+    const differentSession = Boolean(sessionId) && Boolean(existing.session_id) && sessionId !== existing.session_id;
+    const callerHasNoSession = !sessionId;
+    const existingHasActiveSession = Boolean(existing.session_id) && active;
+    if (!input.force) {
+      if (active && differentSession)
+        return buildConflict(existing);
+      if (callerHasNoSession && existingHasActiveSession)
+        return buildConflict(existing);
+    }
+    const sets = ["last_seen_at = ?"];
+    const params = [now()];
+    if (sessionId && !sameSession) {
+      sets.push("session_id = ?");
+      params.push(sessionId);
+    }
+    if (input.role !== undefined) {
+      sets.push("role = ?");
+      params.push(input.role);
+    }
+    if (input.working_dir !== undefined) {
+      sets.push("working_dir = ?");
+      params.push(input.working_dir);
+    }
+    if (input.machine_id !== undefined) {
+      sets.push("machine_id = ?");
+      params.push(input.machine_id);
+    }
+    if (input.project_id !== undefined) {
+      sets.push("active_project_id = ?");
+      params.push(input.project_id);
+    }
+    if (input.capabilities !== undefined) {
+      sets.push("capabilities = ?");
+      params.push(JSON.stringify(input.capabilities));
+    }
+    if (input.metadata !== undefined) {
+      sets.push("metadata = ?");
+      params.push(JSON.stringify(input.metadata));
+    }
+    sets.push("status = 'active'");
+    params.push(existing.id);
+    db.run(`UPDATE agents SET ${sets.join(", ")} WHERE id = ?`, ...params);
+    return getAgent(existing.id, db);
+  }
+  const id = newAgentId();
+  const ts = now();
+  db.run(`INSERT INTO agents
+       (id, name, session_id, role, status, active_project_id, working_dir, machine_id, capabilities, metadata, last_seen_at, created_at)
+     VALUES (?, ?, ?, ?, 'active', ?, ?, ?, ?, ?, ?, ?)`, id, name, sessionId, input.role ?? "agent", input.project_id ?? null, input.working_dir ?? null, input.machine_id ?? null, JSON.stringify(input.capabilities ?? []), JSON.stringify(input.metadata ?? {}), ts, ts);
+  return getAgent(id, db);
+}
+function buildConflict(existing) {
+  const minutesAgo = Math.round((Date.now() - new Date(existing.last_seen_at).getTime()) / 60000);
+  return {
+    conflict: true,
+    existing_id: existing.id,
+    existing_name: existing.name,
+    last_seen_at: existing.last_seen_at,
+    session_hint: existing.session_id ? existing.session_id.slice(0, 8) : null,
+    working_dir: existing.working_dir,
+    message: `Agent "${existing.name}" is already active (last seen ${minutesAgo}m ago). ` + (existing.session_id ? `Pass session_id="${existing.session_id}" to reclaim it, ` : "") + "use force:true to take over, or choose a different name."
+  };
+}
+function heartbeat(idOrName, db) {
+  const agent = resolveAgent(idOrName, db);
+  if (!agent)
+    return null;
+  db.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", now(), agent.id);
+  return getAgent(agent.id, db);
+}
+function setFocus(idOrName, projectId, db) {
+  const agent = resolveAgent(idOrName, db);
+  if (!agent)
+    return null;
+  db.run("UPDATE agents SET active_project_id = ?, last_seen_at = ? WHERE id = ?", projectId, now(), agent.id);
+  return getAgent(agent.id, db);
+}
+function agentData(agent) {
+  return {
+    agent_id: agent.id,
+    session_id: agent.session_id,
+    project_id: agent.active_project_id,
+    machine_id: agent.machine_id,
+    role: agent.role
+  };
+}
+async function emitAgentEvent(client, type, agent, extra = {}) {
+  if (!client)
+    return;
+  try {
+    await client.emit({
+      source: SERVICE_NAME,
+      type,
+      subject: agent.name,
+      severity: type === "agent.heartbeat" ? "debug" : "info",
+      data: { ...agentData(agent), ...extra }
+    });
+  } catch {}
+}
+async function emitConflictEvent(client, conflict) {
+  if (!client)
+    return;
+  try {
+    await client.emit({
+      source: SERVICE_NAME,
+      type: "agent.conflict",
+      subject: conflict.existing_name,
+      severity: "warning",
+      data: {
+        existing_id: conflict.existing_id,
+        last_seen_at: conflict.last_seen_at,
+        session_hint: conflict.session_hint
+      },
+      message: conflict.message
+    });
+  } catch {}
+}
+function jsonText(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function errorText(message) {
+  return { content: [{ type: "text", text: message }], isError: true };
+}
+function registerAgentTools(server, opts = {}) {
+  let resolved;
+  const db = () => resolved ??= opts.db ?? getDefaultStore();
+  const events = opts.events;
+  const focus = opts.agentFocus;
+  const includeExtended = opts.includeExtendedTools ?? false;
+  const allow = (name) => opts.toolFilter ? opts.toolFilter(name) : true;
+  const tool = (name, description, schema, handler) => {
+    if (!allow(name))
+      return;
+    server.tool(name, description, schema, handler);
+  };
+  tool("register_agent", "Register or heartbeat an agent by name. Returns the agent, or a structured conflict descriptor if the name is actively held by another session.", {
+    name: z.string().describe("Agent name (normalized to lowercase; unique among active agents)"),
+    session_id: z.string().optional().describe("Stable session id used to reclaim the name"),
+    role: z.string().optional().describe("Agent role (default: agent)"),
+    working_dir: z.string().optional().describe("Working directory of the agent"),
+    project_id: z.string().optional().describe("Set active project focus on register"),
+    capabilities: z.array(z.string()).optional().describe("Declared capabilities"),
+    force: z.boolean().optional().describe("Take over the name even if actively held")
+  }, async (args) => {
+    const result = registerAgent({
+      name: args.name,
+      session_id: args.session_id,
+      role: args.role,
+      working_dir: args.working_dir,
+      project_id: args.project_id,
+      capabilities: args.capabilities,
+      force: args.force
+    }, db());
+    if (isAgentConflict(result)) {
+      await emitConflictEvent(events, result);
+      return { ...jsonText(result), isError: true };
+    }
+    await emitAgentEvent(events, "agent.registered", result);
+    return jsonText(result);
+  });
+  tool("heartbeat", "Update an agent's last_seen_at to signal it is still active.", {
+    agent_id: z.string().optional().describe("Agent id"),
+    name: z.string().optional().describe("Agent name (alternative to agent_id)")
+  }, async (args) => {
+    const agent = heartbeat(args.agent_id ?? args.name, db());
+    if (!agent)
+      return errorText(`Agent not found: ${args.agent_id ?? args.name ?? "(none)"}`);
+    await emitAgentEvent(events, "agent.heartbeat", agent);
+    return jsonText(agent);
+  });
+  tool("set_focus", "Set (or clear) the active project context for an agent. Omit project_id to clear.", {
+    agent_id: z.string().optional().describe("Agent id"),
+    name: z.string().optional().describe("Agent name (alternative to agent_id)"),
+    project_id: z.string().optional().describe("Project id to focus on; omit to clear")
+  }, async (args) => {
+    const projectId = args.project_id ?? null;
+    const agent = setFocus(args.agent_id ?? args.name, projectId, db());
+    if (!agent)
+      return errorText(`Agent not found: ${args.agent_id ?? args.name ?? "(none)"}`);
+    focus?.set(agent.id, { project_id: projectId });
+    await emitAgentEvent(events, "agent.focus_changed", agent, { project_id: projectId });
+    return jsonText(agent);
+  });
+  tool("list_agents", "List registered agents.", {
+    online_only: z.boolean().optional().describe("Only agents seen within the active window"),
+    include_archived: z.boolean().optional().describe("Include archived agents")
+  }, async (args) => {
+    const agents = listAgents({ online_only: args.online_only, include_archived: args.include_archived }, db());
+    return jsonText(agents);
+  });
+  if (includeExtended) {
+    tool("get_focus", "Get the active project context for an agent.", {
+      agent_id: z.string().optional(),
+      name: z.string().optional()
+    }, async (args) => {
+      const agent = resolveAgent(args.agent_id ?? args.name, db());
+      if (!agent)
+        return errorText(`Agent not found: ${args.agent_id ?? args.name ?? "(none)"}`);
+      return jsonText({ agent_id: agent.id, project_id: agent.active_project_id });
+    });
+    tool("unfocus", "Clear the active project context for an agent.", {
+      agent_id: z.string().optional(),
+      name: z.string().optional()
+    }, async (args) => {
+      const agent = setFocus(args.agent_id ?? args.name, null, db());
+      if (!agent)
+        return errorText(`Agent not found: ${args.agent_id ?? args.name ?? "(none)"}`);
+      focus?.set(agent.id, { project_id: null });
+      await emitAgentEvent(events, "agent.focus_changed", agent, { project_id: null });
+      return jsonText(agent);
+    });
+  }
+}
+
+// src/mcp/server.ts
+init_database();
+import { z as z3 } from "zod";
+
 // src/ingest/claude.ts
 init_database();
 init_pricing();
-import { readdirSync as readdirSync2, readFileSync, existsSync as existsSync2, statSync as statSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2, basename } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync2, existsSync as existsSync4, statSync as statSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4, basename } from "path";
 
 // src/lib/savings.ts
 function periodWhere2(period, column) {
@@ -2258,8 +2874,8 @@ function periodWhere2(period, column) {
   }
 }
 function prorateMonthlyFee(monthlyFee, period) {
-  const now = new Date;
-  const daysInMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0).getDate();
+  const now2 = new Date;
+  const daysInMonth = new Date(now2.getFullYear(), now2.getMonth() + 1, 0).getDate();
   switch (period) {
     case "today":
     case "yesterday":
@@ -2394,8 +3010,319 @@ function defaultCostBasisForAgent(agent) {
   return "estimated";
 }
 
+// src/lib/accounts-store.ts
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+import { z as z2 } from "zod";
+import { resolveClientTransport, resolveCredential } from "@hasna/contracts/client";
+var ACCOUNTS_APP = "accounts";
+var profileNameSchema = z2.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 = z2.object({
+  name: z2.string(),
+  tool: z2.string(),
+  email: z2.string().optional(),
+  displayName: z2.string().optional(),
+  dir: z2.string(),
+  description: z2.string().optional(),
+  createdAt: z2.string(),
+  lastUsedAt: z2.string().optional()
+});
+var toolDefSchema = z2.object({
+  id: z2.string(),
+  label: z2.string(),
+  envVar: z2.string(),
+  defaultDir: z2.string(),
+  bin: z2.string()
+});
+var storeSchema = z2.object({
+  version: z2.literal(1),
+  current: z2.record(z2.string(), z2.string()).default({}),
+  applied: z2.record(z2.string(), z2.string()).default({}),
+  toolLocks: z2.record(z2.string(), z2.string()).default({}),
+  profiles: z2.array(profileSchema).default([]),
+  tools: z2.array(toolDefSchema).default([])
+});
+function validateEnvPath(value, label) {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.includes("\x00") || /[\r\n]/.test(trimmed))
+    throw new Error(`invalid ${label}`);
+  return trimmed;
+}
+function accountsHome() {
+  const override = process.env.ACCOUNTS_HOME;
+  if (override && override.trim())
+    return validateEnvPath(override, "ACCOUNTS_HOME");
+  return join3(homedir2(), ".hasna", "accounts");
+}
+function storePath() {
+  const override = process.env.ACCOUNTS_STORE_PATH;
+  if (override && override.trim())
+    return validateEnvPath(override, "ACCOUNTS_STORE_PATH");
+  return join3(accountsHome(), "accounts.json");
+}
+var EMPTY_STORE = {
+  version: 1,
+  current: {},
+  applied: {},
+  toolLocks: {},
+  profiles: [],
+  tools: []
+};
+function parseStoreFile() {
+  const path = storePath();
+  if (!existsSync3(path))
+    return structuredClone(EMPTY_STORE);
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf8"));
+  } catch (err) {
+    throw new Error(`could not parse store at ${path}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const parsed = storeSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new Error(`invalid store at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+  }
+  return parsed.data;
+}
+function loadAppliedMap() {
+  const applied = {};
+  for (const [toolId, name] of Object.entries(parseStoreFile().applied)) {
+    if (name && profileNameSchema.safeParse(name).success)
+      applied[toolId] = name;
+  }
+  return applied;
+}
+function appliedProfileName(toolId) {
+  return loadAppliedMap()[toolId];
+}
+var BUILTIN_TOOLS = [
+  { id: "claude", label: "Claude Code", envVar: "CLAUDE_CONFIG_DIR", defaultDir: join3(homedir2(), ".claude"), bin: "claude" },
+  { id: "codex-app", label: "Codex App", envVar: "CODEX_HOME", defaultDir: join3(homedir2(), ".codex"), bin: "/Applications/Codex.app/Contents/MacOS/Codex" },
+  { id: "codex", label: "Codex CLI", envVar: "CODEX_HOME", defaultDir: join3(homedir2(), ".codex"), bin: "codex" },
+  { id: "codewith", label: "Codewith", envVar: "CODEWITH_HOME", defaultDir: join3(homedir2(), ".codewith"), bin: "codewith" },
+  { id: "takumi", label: "Takumi", envVar: "TAKUMI_CONFIG_DIR", defaultDir: join3(homedir2(), ".takumi"), bin: "takumi" },
+  { id: "gemini", label: "Gemini CLI", envVar: "GEMINI_CONFIG_DIR", defaultDir: join3(homedir2(), ".gemini"), bin: "gemini" },
+  { id: "opencode", label: "opencode", envVar: "OPENCODE_CONFIG_DIR", defaultDir: join3(homedir2(), ".config", "opencode"), bin: "opencode" },
+  { id: "cursor", label: "Cursor Agent", envVar: "CURSOR_CONFIG_DIR", defaultDir: join3(homedir2(), ".cursor"), bin: "cursor-agent" },
+  { id: "pi", label: "Pi Coding Agent", envVar: "PI_CODING_AGENT_HOME", defaultDir: join3(homedir2(), ".pi"), bin: "pi" },
+  { id: "hermes", label: "Hermes", envVar: "HERMES_HOME", defaultDir: join3(homedir2(), ".hermes"), bin: "hermes" },
+  { id: "kimi", label: "Kimi Code", envVar: "KIMI_CODE_HOME", defaultDir: join3(homedir2(), ".kimi-code"), bin: "kimi" },
+  { id: "grok", label: "Grok Build", envVar: "HOME", defaultDir: join3(homedir2(), ".grok"), bin: "grok" }
+];
+
+class LocalStore {
+  transport = "local";
+  async listProfiles(tool) {
+    const profiles = parseStoreFile().profiles;
+    const filtered = tool ? profiles.filter((profile) => profile.tool === tool) : profiles;
+    return filtered.slice().sort((a, b) => a.tool.localeCompare(b.tool) || a.name.localeCompare(b.name));
+  }
+  async findProfile(name, tool) {
+    const matches = parseStoreFile().profiles.filter((profile) => profile.name === name && (!tool || profile.tool === tool));
+    return matches.length === 1 ? matches[0] : undefined;
+  }
+  async currentProfile(tool) {
+    const store = parseStoreFile();
+    const name = store.current[tool];
+    if (!name)
+      return;
+    return store.profiles.find((profile) => profile.name === name && profile.tool === tool);
+  }
+  async listTools() {
+    const custom = parseStoreFile().tools;
+    const byId = new Map;
+    for (const tool of BUILTIN_TOOLS)
+      byId.set(tool.id, tool);
+    for (const tool of custom)
+      byId.set(tool.id, tool);
+    return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
+  }
+}
+var RETIRED_STORAGE_MODE_KEYS2 = [
+  "HASNA_ACCOUNTS_STORAGE_MODE",
+  "ACCOUNTS_STORAGE_MODE",
+  "HASNA_ACCOUNTS_MODE",
+  "ACCOUNTS_MODE"
+];
+function assertNoRetiredStorageMode2(env) {
+  const legacyKey = RETIRED_STORAGE_MODE_KEYS2.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 accounts registry uses the local JSON store, or the HTTP API selected by ` + `HASNA_ACCOUNTS_API_URL + HASNA_ACCOUNTS_API_KEY.`);
+}
+var RETRY_STATUSES = [408, 425, 429, 500, 502, 503, 504];
+
+class AccountsApiError extends Error {
+  status;
+  body;
+  constructor(method, path, status, body) {
+    super(`accounts cloud request failed: ${method} ${path} -> ${status}`);
+    this.name = "AccountsApiError";
+    this.status = status;
+    this.body = body;
+  }
+}
+function isNotFound(err) {
+  return Boolean(err && typeof err === "object" && err.status === 404);
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function cloudRequest(baseUrl, apiKey, path, query) {
+  const rel = path.startsWith("/") ? path : `/${path}`;
+  const url = query && Object.keys(query).length > 0 ? `${baseUrl}${rel}?${new URLSearchParams(query).toString()}` : `${baseUrl}${rel}`;
+  let lastError;
+  for (let attempt = 0;attempt < 3; attempt += 1) {
+    const controller = new AbortController;
+    const timer = setTimeout(() => controller.abort(), 30000);
+    let res;
+    try {
+      res = await fetch(url, {
+        method: "GET",
+        headers: {
+          "x-api-key": apiKey,
+          Authorization: `Bearer ${apiKey}`,
+          Accept: "application/json"
+        },
+        signal: controller.signal
+      });
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      clearTimeout(timer);
+      if (attempt < 2) {
+        const backoff = Math.min(2000, 200 * 2 ** attempt);
+        const jitter = Math.floor(Math.random() * (backoff / 2 + 1));
+        await sleep(backoff + jitter);
+      }
+      continue;
+    } finally {
+      clearTimeout(timer);
+    }
+    const text = await res.text();
+    let parsed;
+    if (text.length > 0) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = text;
+      }
+    }
+    if (!res.ok) {
+      lastError = new AccountsApiError("GET", rel, res.status, parsed);
+      if (attempt < 2 && RETRY_STATUSES.includes(res.status)) {
+        const backoff = Math.min(2000, 200 * 2 ** attempt);
+        const jitter = Math.floor(Math.random() * (backoff / 2 + 1));
+        await sleep(backoff + jitter);
+        continue;
+      }
+      break;
+    }
+    return parsed;
+  }
+  throw lastError;
+}
+function toProfile(account) {
+  const profile = {
+    name: String(account.name),
+    tool: String(account.tool),
+    dir: typeof account.dir === "string" ? account.dir : "",
+    createdAt: String(account.createdAt)
+  };
+  if (typeof account.email === "string")
+    profile.email = account.email;
+  if (typeof account.displayName === "string")
+    profile.displayName = account.displayName;
+  if (typeof account.description === "string")
+    profile.description = account.description;
+  if (typeof account.lastUsedAt === "string")
+    profile.lastUsedAt = account.lastUsedAt;
+  return profile;
+}
+
+class ApiStore {
+  baseUrl;
+  apiKey;
+  transport = "api";
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+  }
+  async listProfiles(tool) {
+    const raw = await cloudRequest(this.baseUrl, this.apiKey, "/accounts", tool ? { tool } : undefined);
+    const accounts = Array.isArray(raw?.accounts) ? raw.accounts : [];
+    return accounts.map((account) => toProfile(account)).sort((a, b) => a.tool.localeCompare(b.tool) || a.name.localeCompare(b.name));
+  }
+  async findProfile(name, tool) {
+    if (tool) {
+      try {
+        const account = await cloudRequest(this.baseUrl, this.apiKey, `/accounts/${encodeURIComponent(tool)}/${encodeURIComponent(name)}`);
+        return account ? toProfile(account) : undefined;
+      } catch (err) {
+        if (isNotFound(err))
+          return;
+        throw err;
+      }
+    }
+    const matches = (await this.listProfiles()).filter((profile) => profile.name === name);
+    return matches.length === 1 ? matches[0] : undefined;
+  }
+  async currentProfile(tool) {
+    let current;
+    try {
+      const raw = await cloudRequest(this.baseUrl, this.apiKey, `/current/${encodeURIComponent(tool)}`);
+      current = raw && typeof raw === "object" ? raw : null;
+    } catch (err) {
+      if (isNotFound(err))
+        return;
+      throw err;
+    }
+    if (!current || typeof current.name !== "string")
+      return;
+    return this.findProfile(current.name, tool);
+  }
+  async listTools() {
+    const raw = await cloudRequest(this.baseUrl, this.apiKey, "/tools");
+    const tools = Array.isArray(raw?.tools) ? raw.tools : [];
+    const custom = [];
+    for (const item of tools) {
+      if (item === null || typeof item !== "object")
+        continue;
+      const record = item;
+      if (record.builtin !== false)
+        continue;
+      const parsed = toolDefSchema.safeParse(item);
+      if (!parsed.success) {
+        throw new Error(`invalid custom tool "${String(record.id)}" returned by accounts-serve: ` + parsed.error.issues.map((issue) => issue.message).join("; "));
+      }
+      custom.push(parsed.data);
+    }
+    const byId = new Map;
+    for (const tool of BUILTIN_TOOLS)
+      byId.set(tool.id, tool);
+    for (const tool of custom)
+      byId.set(tool.id, tool);
+    return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
+  }
+}
+function resolveStore(env = process.env, options = {}) {
+  assertNoRetiredStorageMode2(env);
+  const clientEnv = env;
+  try {
+    const credential = resolveCredential(ACCOUNTS_APP, clientEnv, options.credentials);
+    if (credential === null)
+      return new LocalStore;
+    const resolution = resolveClientTransport(ACCOUNTS_APP, clientEnv, {
+      credentials: credential ? { ...options.credentials, apiKey: credential.apiKey } : options.credentials
+    });
+    return new ApiStore(resolution.baseUrl, credential.apiKey);
+  } catch (err) {
+    console.warn(`accounts: API configuration unusable (${err instanceof Error ? err.message : String(err)}); using local store`);
+    return new LocalStore;
+  }
+}
+
 // src/lib/accounts.ts
-import { appliedProfileName, resolveStore } from "@hasna/accounts";
 var AGENT_ACCOUNT_TOOLS = {
   claude: ["claude"],
   takumi: ["takumi", "claude"],
@@ -2467,11 +3394,11 @@ async function profileForEnvDir(store, tool, env) {
   const normalized = normalizeDir(configuredDir);
   return (await store.listProfiles(tool.id)).find((profile) => normalizeDir(profile.dir) === normalized) ?? null;
 }
-async function resolveAccountForAgent(agent, env = process.env) {
+async function resolveAccountForAgent(agent, env = process.env, options = {}) {
   const override = envOverride(agent, env);
   if (override)
     return override;
-  const store = resolveStore(env);
+  const store = resolveStore(env, options);
   const tools = new Map((await store.listTools()).map((tool) => [tool.id, tool]));
   for (const toolId of AGENT_ACCOUNT_TOOLS[agent]) {
     const tool = tools.get(toolId);
@@ -2509,8 +3436,8 @@ function withAccount(record, account) {
 function autoDetectProject(cwd, projects) {
   return projects.find((p) => cwd === p.path || cwd.startsWith(p.path + "/"));
 }
-var CLAUDE_PROJECTS_DIR = join2(homedir2(), ".claude", "projects");
-var TAKUMI_PROJECTS_DIR = join2(homedir2(), ".takumi", "projects");
+var CLAUDE_PROJECTS_DIR = process.env["HASNA_ECONOMY_CLAUDE_PROJECTS_DIR"] ?? join4(homedir3(), ".claude", "projects");
+var TAKUMI_PROJECTS_DIR = process.env["HASNA_ECONOMY_TAKUMI_PROJECTS_DIR"] ?? join4(homedir3(), ".takumi", "projects");
 function dirNameToPath(dirName) {
   return dirName.replace(/^-/, "/").replace(/-/g, "/").replace(/\/\//g, "/-");
 }
@@ -2520,9 +3447,9 @@ function collectJsonlFiles(projectDir) {
     try {
       for (const entry of readdirSync2(dir, { withFileTypes: true })) {
         if (entry.isDirectory())
-          walk(join2(dir, entry.name));
+          walk(join4(dir, entry.name));
         else if (entry.name.endsWith(".jsonl"))
-          files.push(join2(dir, entry.name));
+          files.push(join4(dir, entry.name));
       }
     } catch {}
   }
@@ -2536,7 +3463,7 @@ async function ingestTakumi(db, verbose = false, projectsDir = TAKUMI_PROJECTS_D
   return ingestJsonlProjects(db, projectsDir, "takumi", verbose);
 }
 async function ingestJsonlProjects(db, projectsDir, agentName, verbose = false) {
-  if (!existsSync2(projectsDir)) {
+  if (!existsSync4(projectsDir)) {
     if (verbose)
       console.log(`${agentName} projects dir not found:`, projectsDir);
     return { files: 0, requests: 0, sessions: 0 };
@@ -2547,9 +3474,10 @@ async function ingestJsonlProjects(db, projectsDir, agentName, verbose = false)
   const touchedSessions = new Set;
   const registeredProjects = db.prepare(`SELECT path, name FROM projects ORDER BY LENGTH(path) DESC`).all();
   const account = await resolveAccountForAgent(agentName);
+  const ingestState = loadIngestState(db, agentName);
   const projectDirs = readdirSync2(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
   for (const projectDirEntry of projectDirs) {
-    const projectDirPath = join2(projectsDir, projectDirEntry.name);
+    const projectDirPath = join4(projectsDir, projectDirEntry.name);
     const projectPath = dirNameToPath(projectDirEntry.name);
     const jsonlFiles = collectJsonlFiles(projectDirPath);
     for (const filePath of jsonlFiles) {
@@ -2560,12 +3488,12 @@ async function ingestJsonlProjects(db, projectsDir, agentName, verbose = false)
       } catch {
         continue;
       }
-      const processed = getIngestState(db, agentName, stateKey);
+      const processed = ingestState.get(stateKey) ?? null;
       if (processed === fileMtime)
         continue;
       let lines;
       try {
-        lines = readFileSync(filePath, "utf-8").split(`
+        lines = readFileSync2(filePath, "utf-8").split(`
 `).filter((l) => l.trim());
       } catch {
         continue;
@@ -2685,14 +3613,14 @@ function supportsClaudeDataResidencyPricing(model) {
 // src/ingest/codex.ts
 init_database();
 init_pricing();
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join3, basename as basename2 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join5, basename as basename2 } from "path";
 import { Database as BunDatabase } from "bun:sqlite";
-var DEFAULT_CODEX_DB_PATH = join3(homedir3(), ".codex", "state_5.sqlite");
-var DEFAULT_CODEX_CONFIG_PATH = join3(homedir3(), ".codex", "config.toml");
-var DEFAULT_CODEWITH_DB_PATH = join3(homedir3(), ".codewith", "state_5.sqlite");
-var DEFAULT_CODEWITH_CONFIG_PATH = join3(homedir3(), ".codewith", "config.toml");
+var DEFAULT_CODEX_DB_PATH = join5(homedir4(), ".codex", "state_5.sqlite");
+var DEFAULT_CODEX_CONFIG_PATH = join5(homedir4(), ".codex", "config.toml");
+var DEFAULT_CODEWITH_DB_PATH = join5(homedir4(), ".codewith", "state_5.sqlite");
+var DEFAULT_CODEWITH_CONFIG_PATH = join5(homedir4(), ".codewith", "config.toml");
 var CODEX_INGEST_VERSION = "rollout-aggregate-v3";
 function codexDbPath() {
   return process.env["HASNA_ECONOMY_CODEX_DB_PATH"] ?? DEFAULT_CODEX_DB_PATH;
@@ -2734,10 +3662,10 @@ function codexSources() {
   });
 }
 function readCodexModel(configPath = codexConfigPath()) {
-  if (!existsSync3(configPath))
+  if (!existsSync5(configPath))
     return "gpt-5-codex";
   try {
-    const content = readFileSync2(configPath, "utf-8");
+    const content = readFileSync3(configPath, "utf-8");
     const match = content.match(/^model\s*=\s*"([^"]+)"/m);
     return match?.[1] ?? "gpt-5-codex";
   } catch {
@@ -2775,12 +3703,12 @@ function openCodexDb(dbPath, verbose) {
   return null;
 }
 function readTokenEvents(rolloutPath) {
-  if (!rolloutPath || !existsSync3(rolloutPath))
+  if (!rolloutPath || !existsSync5(rolloutPath))
     return [];
   const fallbackUsages = new Map;
   let fallbackTimestamp;
   let aggregate = null;
-  for (const line of readFileSync2(rolloutPath, "utf-8").split(`
+  for (const line of readFileSync3(rolloutPath, "utf-8").split(`
 `)) {
     if (!line.trim())
       continue;
@@ -2856,7 +3784,7 @@ async function ingestCodex(db, verbose = false) {
   let requests = 0;
   const account = await resolveAccountForAgent("codex");
   for (const source of codexSources()) {
-    if (!existsSync3(source.dbPath)) {
+    if (!existsSync5(source.dbPath)) {
       if (verbose)
         console.log(`${source.label} DB not found:`, source.dbPath);
       continue;
@@ -2937,11 +3865,11 @@ async function ingestCodex(db, verbose = false) {
 // src/ingest/gemini.ts
 init_database();
 init_pricing();
-import { readdirSync as readdirSync3, readFileSync as readFileSync3, existsSync as existsSync4, statSync as statSync3 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join4, basename as basename3 } from "path";
-var DEFAULT_GEMINI_TMP_DIR = join4(homedir4(), ".gemini", "tmp");
-var DEFAULT_GEMINI_HISTORY_DIR = join4(homedir4(), ".gemini", "history");
+import { readdirSync as readdirSync3, readFileSync as readFileSync4, existsSync as existsSync6, statSync as statSync3 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join6, basename as basename3 } from "path";
+var DEFAULT_GEMINI_TMP_DIR = join6(homedir5(), ".gemini", "tmp");
+var DEFAULT_GEMINI_HISTORY_DIR = join6(homedir5(), ".gemini", "history");
 function geminiTmpDir() {
   return process.env["HASNA_ECONOMY_GEMINI_TMP_DIR"] ?? DEFAULT_GEMINI_TMP_DIR;
 }
@@ -2958,12 +3886,12 @@ function numberField(...values) {
 function listProjectDirs(...roots) {
   const dirs = new Set;
   for (const root of roots) {
-    if (!existsSync4(root))
+    if (!existsSync6(root))
       continue;
     try {
       for (const entry of readdirSync3(root, { withFileTypes: true })) {
         if (entry.isDirectory())
-          dirs.add(join4(root, entry.name));
+          dirs.add(join6(root, entry.name));
       }
     } catch {}
   }
@@ -2974,17 +3902,17 @@ function projectRoot(projectDir, chatData) {
     return chatData.projectPath;
   if (chatData.project_path)
     return chatData.project_path;
-  const rootFile = join4(projectDir, ".project_root");
+  const rootFile = join6(projectDir, ".project_root");
   try {
-    if (existsSync4(rootFile))
-      return readFileSync3(rootFile, "utf-8").trim();
+    if (existsSync6(rootFile))
+      return readFileSync4(rootFile, "utf-8").trim();
   } catch {}
   return "";
 }
 async function ingestGemini(db, verbose) {
   const tmpDir = geminiTmpDir();
   const historyDir = geminiHistoryDir();
-  if (!existsSync4(tmpDir) && !existsSync4(historyDir)) {
+  if (!existsSync6(tmpDir) && !existsSync6(historyDir)) {
     if (verbose)
       console.log("Gemini tmp/history dirs not found:", tmpDir, historyDir);
     return { sessions: 0, requests: 0 };
@@ -2996,17 +3924,17 @@ async function ingestGemini(db, verbose) {
   const account = await resolveAccountForAgent("gemini");
   const projectDirs = listProjectDirs(tmpDir, historyDir);
   for (const projectDir of projectDirs) {
-    const chatsDir = join4(projectDir, "chats");
-    if (!existsSync4(chatsDir))
+    const chatsDir = join6(projectDir, "chats");
+    if (!existsSync6(chatsDir))
       continue;
     let chatFiles = [];
     try {
-      chatFiles = readdirSync3(chatsDir).filter((f) => f.endsWith(".json")).map((f) => join4(chatsDir, f));
+      chatFiles = readdirSync3(chatsDir).filter((f) => f.endsWith(".json")).map((f) => join6(chatsDir, f));
     } catch {
       continue;
     }
     for (const filePath of chatFiles) {
-      const stateKey = filePath.replace(homedir4(), "~");
+      const stateKey = filePath.replace(homedir5(), "~");
       let fileMtime = "0";
       try {
         fileMtime = statSync3(filePath).mtimeMs.toString();
@@ -3018,7 +3946,7 @@ async function ingestGemini(db, verbose) {
         continue;
       let chatData;
       try {
-        chatData = JSON.parse(readFileSync3(filePath, "utf-8"));
+        chatData = JSON.parse(readFileSync4(filePath, "utf-8"));
       } catch {
         continue;
       }
@@ -3096,15 +4024,15 @@ async function ingestGemini(db, verbose) {
 // src/ingest/opencode.ts
 init_database();
 init_pricing();
-import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join5 } from "path";
-var OPENCODE_STORAGE = join5(homedir5(), ".local", "share", "opencode", "storage");
+import { existsSync as existsSync7, readFileSync as readFileSync5, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join7 } from "path";
+var OPENCODE_STORAGE = join7(homedir6(), ".local", "share", "opencode", "storage");
 function walkJsonFiles(dir, acc = []) {
-  if (!existsSync5(dir))
+  if (!existsSync7(dir))
     return acc;
   for (const entry of readdirSync4(dir, { withFileTypes: true })) {
-    const p = join5(dir, entry.name);
+    const p = join7(dir, entry.name);
     if (entry.isDirectory())
       walkJsonFiles(p, acc);
     else if (entry.name.endsWith(".json"))
@@ -3124,12 +4052,12 @@ function parseSessionIdFromPath(filePath) {
   return null;
 }
 async function ingestOpenCode(db, verbose = false) {
-  const messageDir = join5(OPENCODE_STORAGE, "message");
+  const messageDir = join7(OPENCODE_STORAGE, "message");
   const files = walkJsonFiles(messageDir);
   let requests = 0;
   const touched = new Set;
   const machineId = getMachineId();
-  const now = new Date().toISOString();
+  const now2 = new Date().toISOString();
   const account = await resolveAccountForAgent("opencode");
   for (const file of files) {
     const mtime = statSync4(file).mtimeMs;
@@ -3139,7 +4067,7 @@ async function ingestOpenCode(db, verbose = false) {
       continue;
     let parsed;
     try {
-      parsed = JSON.parse(readFileSync4(file, "utf-8"));
+      parsed = JSON.parse(readFileSync5(file, "utf-8"));
     } catch {
       continue;
     }
@@ -3175,7 +4103,7 @@ async function ingestOpenCode(db, verbose = false) {
       timestamp,
       source_request_id: sourceId,
       machine_id: machineId,
-      updated_at: now
+      updated_at: now2
     }, account));
     requests++;
     if (!touched.has(sessionId)) {
@@ -3190,7 +4118,7 @@ async function ingestOpenCode(db, verbose = false) {
         total_tokens: 0,
         request_count: 0,
         machine_id: machineId,
-        updated_at: now
+        updated_at: now2
       }, account));
       touched.add(sessionId);
     }
@@ -3236,7 +4164,7 @@ async function ingestCursor(db, verbose = false) {
   if (prev)
     return { requests: 0, snapshots: 0 };
   const machineId = getMachineId();
-  const now = new Date().toISOString();
+  const now2 = new Date().toISOString();
   let snapshots = 0;
   const account = await resolveAccountForAgent("cursor");
   const usage = await cursorFetch("/api/usage", token);
@@ -3292,12 +4220,12 @@ async function ingestCursor(db, verbose = false) {
       project_path: "",
       project_name: "Cursor subscription",
       started_at: `${today}T00:00:00.000Z`,
-      ended_at: now,
+      ended_at: now2,
       total_cost_usd: onDemand + included,
       total_tokens: 0,
       request_count: 1,
       machine_id: machineId,
-      updated_at: now
+      updated_at: now2
     }, account));
     upsertRequest(db, withAccount({
       id: `cursor-${today}-${machineId}-usage`,
@@ -3311,14 +4239,14 @@ async function ingestCursor(db, verbose = false) {
       cost_usd: onDemand + included,
       cost_basis: "subscription_included",
       duration_ms: 0,
-      timestamp: now,
+      timestamp: now2,
       source_request_id: today,
       machine_id: machineId,
-      updated_at: now
+      updated_at: now2
     }, account));
     rollupSession(db, sessionId);
   }
-  setIngestState(db, "cursor", `sync-${today}`, now);
+  setIngestState(db, "cursor", `sync-${today}`, now2);
   if (verbose)
     console.log(`  cursor: on-demand $${onDemand.toFixed(2)}, included $${included.toFixed(2)}`);
   return { requests: onDemand + included > 0 ? 1 : 0, snapshots };
@@ -3326,15 +4254,15 @@ async function ingestCursor(db, verbose = false) {
 
 // src/ingest/pi.ts
 init_database();
-import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync5, statSync as statSync5 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join6 } from "path";
-var PI_SESSION_DIR = process.env["PI_CODING_AGENT_SESSION_DIR"] ?? join6(homedir6(), ".pi", "agent", "sessions");
+import { existsSync as existsSync8, readFileSync as readFileSync6, readdirSync as readdirSync5, statSync as statSync5 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join8 } from "path";
+var PI_SESSION_DIR = process.env["PI_CODING_AGENT_SESSION_DIR"] ?? join8(homedir7(), ".pi", "agent", "sessions");
 function walkSessions(dir, acc = []) {
-  if (!existsSync6(dir))
+  if (!existsSync8(dir))
     return acc;
   for (const entry of readdirSync5(dir, { withFileTypes: true })) {
-    const p = join6(dir, entry.name);
+    const p = join8(dir, entry.name);
     if (entry.isDirectory())
       walkSessions(p, acc);
     else if (entry.name.endsWith(".json"))
@@ -3347,7 +4275,7 @@ async function ingestPi(db, verbose = false) {
   let requests = 0;
   const touched = new Set;
   const machineId = getMachineId();
-  const now = new Date().toISOString();
+  const now2 = new Date().toISOString();
   const account = await resolveAccountForAgent("pi");
   for (const file of files) {
     const mtime = statSync5(file).mtimeMs;
@@ -3356,7 +4284,7 @@ async function ingestPi(db, verbose = false) {
       continue;
     let data;
     try {
-      data = JSON.parse(readFileSync5(file, "utf-8"));
+      data = JSON.parse(readFileSync6(file, "utf-8"));
     } catch {
       continue;
     }
@@ -3389,7 +4317,7 @@ async function ingestPi(db, verbose = false) {
         timestamp,
         source_request_id: `${sessionId}-${i}`,
         machine_id: machineId,
-        updated_at: now
+        updated_at: now2
       }, account));
       requests++;
     }
@@ -3399,13 +4327,13 @@ async function ingestPi(db, verbose = false) {
         agent: "pi",
         project_path: "",
         project_name: "",
-        started_at: turns[0]?.timestamp ?? now,
+        started_at: turns[0]?.timestamp ?? now2,
         ended_at: null,
         total_cost_usd: 0,
         total_tokens: 0,
         request_count: 0,
         machine_id: machineId,
-        updated_at: now
+        updated_at: now2
       }, account));
       touched.add(sessionId);
     }
@@ -3420,10 +4348,10 @@ async function ingestPi(db, verbose = false) {
 
 // src/ingest/hermes.ts
 init_database();
-import { existsSync as existsSync7, statSync as statSync6 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join7 } from "path";
-var HERMES_DB = join7(homedir7(), ".hermes", "state.db");
+import { existsSync as existsSync9, statSync as statSync6 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join9 } from "path";
+var HERMES_DB = join9(homedir8(), ".hermes", "state.db");
 function mapCostBasis(billingMode) {
   if (billingMode === "subscription")
     return "subscription_included";
@@ -3432,7 +4360,7 @@ function mapCostBasis(billingMode) {
   return defaultCostBasisForAgent("hermes");
 }
 async function ingestHermes(db, verbose = false) {
-  if (!existsSync7(HERMES_DB)) {
+  if (!existsSync9(HERMES_DB)) {
     return { sessions: 0, requests: 0 };
   }
   const { Database: Sqlite } = await import("bun:sqlite");
@@ -3452,7 +4380,7 @@ async function ingestHermes(db, verbose = false) {
     return { sessions: 0, requests: 0 };
   }
   const machineId = getMachineId();
-  const now = new Date().toISOString();
+  const now2 = new Date().toISOString();
   let requests = 0;
   const account = await resolveAccountForAgent("hermes");
   for (const row of rows) {
@@ -3472,7 +4400,7 @@ async function ingestHermes(db, verbose = false) {
       total_tokens: tokens,
       request_count: 1,
       machine_id: machineId,
-      updated_at: now
+      updated_at: now2
     }, account));
     const reqId = `hermes-${row.id}-rollup`;
     upsertRequest(db, withAccount({
@@ -3490,7 +4418,7 @@ async function ingestHermes(db, verbose = false) {
       timestamp: endedAt ?? startedAt,
       source_request_id: row.id,
       machine_id: machineId,
-      updated_at: now
+      updated_at: now2
     }, account));
     requests++;
     rollupSession(db, sessionId);
@@ -3512,19 +4440,78 @@ 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 { existsSync as existsSync10 } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join10 } from "path";
 import { Database as BunDatabase2 } from "bun:sqlite";
-import { dataDir as dataDir2 } from "@hasna/paths";
+import { homedir as pathsResolverHomedir2 } from "os";
+import { join as pathsResolverJoin2 } from "path";
+var PATHS_RESOLVER_KIND_ENV2 = {
+  config: "HASNA_CONFIG_HOME",
+  data: "HASNA_DATA_HOME",
+  state: "HASNA_STATE_HOME",
+  cache: "HASNA_CACHE_HOME"
+};
+var PATHS_RESOLVER_APP_SLUG_RE2 = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function pathsResolverAssertApp2(app) {
+  if (typeof app !== "string" || app.length === 0) {
+    throw new TypeError("paths: app must be a non-empty string");
+  }
+  if (!PATHS_RESOLVER_APP_SLUG_RE2.test(app)) {
+    throw new TypeError(`paths: invalid app slug "${app}" \u2014 expected lowercase kebab-case ([a-z0-9]+(-[a-z0-9]+)*)`);
+  }
+}
+function pathsResolverAssertKind2(kind) {
+  if (!Object.keys(PATHS_RESOLVER_KIND_ENV2).includes(kind)) {
+    throw new TypeError(`paths: invalid path kind "${kind}" \u2014 expected one of ${Object.keys(PATHS_RESOLVER_KIND_ENV2).join(", ")}`);
+  }
+}
+function pathsResolverBaseDir2(kind, options) {
+  pathsResolverAssertKind2(kind);
+  const env = options.env ?? process.env;
+  const override = env[PATHS_RESOLVER_KIND_ENV2[kind]];
+  if (typeof override === "string" && override.length > 0)
+    return override;
+  const home = options.home ?? pathsResolverHomedir2();
+  const platform2 = options.platform ?? process.platform;
+  if (platform2 === "darwin") {
+    switch (kind) {
+      case "config":
+      case "data":
+        return pathsResolverJoin2(home, "Library", "Application Support", "Hasna");
+      case "cache":
+        return pathsResolverJoin2(home, "Library", "Caches", "Hasna");
+      case "state":
+        return pathsResolverJoin2(home, "Library", "Logs", "Hasna");
+    }
+  }
+  switch (kind) {
+    case "config":
+      return pathsResolverJoin2(home, ".config", "hasna");
+    case "data":
+      return pathsResolverJoin2(home, ".local", "share", "hasna");
+    case "state":
+      return pathsResolverJoin2(home, ".local", "state", "hasna");
+    case "cache":
+      return pathsResolverJoin2(home, ".cache", "hasna");
+  }
+}
+function pathsResolverResolve2(kind, options) {
+  pathsResolverAssertApp2(options.app);
+  const appSegment = options.internal === true ? pathsResolverJoin2("internal", options.app) : options.app;
+  return pathsResolverJoin2(pathsResolverBaseDir2(kind, options), appSegment);
+}
+function dataDir2(options) {
+  return pathsResolverResolve2("data", options);
+}
 var LOOPS_INGEST_VERSION = "goal-runs-orchestration-v1";
 function defaultLoopsDbPath() {
   const resolved = dataDir2({
     app: "loops",
     home: process.env["HOME"] || process.env["USERPROFILE"] || undefined
   });
-  const legacy = join8(process.env["HOME"] || process.env["USERPROFILE"] || homedir8(), ".hasna", "loops", "loops.db");
-  return existsSync8(join8(resolved, "loops.db")) ? join8(resolved, "loops.db") : legacy;
+  const legacy = join10(process.env["HOME"] || process.env["USERPROFILE"] || homedir9(), ".hasna", "loops", "loops.db");
+  return existsSync10(join10(resolved, "loops.db")) ? join10(resolved, "loops.db") : legacy;
 }
 function loopsDbPath() {
   return process.env["HASNA_ECONOMY_LOOPS_DB_PATH"] ?? defaultLoopsDbPath();
@@ -3616,7 +4603,7 @@ function readLoopGoalRuns(loopsDb) {
 }
 async function ingestLoops(db, verbose = false) {
   const dbPath = loopsDbPath();
-  if (!existsSync8(dbPath)) {
+  if (!existsSync10(dbPath)) {
     if (verbose)
       console.log("OpenLoops DB not found:", dbPath);
     return { sessions: 0, requests: 0 };
@@ -3706,30 +4693,30 @@ async function ingestLoops(db, verbose = false) {
 
 // src/ingest/claude-quota.ts
 init_database();
-import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync7 } from "fs";
 
 // src/lib/paths.ts
-import { homedir as homedir9 } from "os";
-import { join as join9 } from "path";
+import { homedir as homedir10 } from "os";
+import { join as join11 } from "path";
 function getHomeDir2() {
-  return process.env["USERPROFILE"] ?? process.env["HOME"] ?? homedir9();
+  return process.env["USERPROFILE"] ?? process.env["HOME"] ?? homedir10();
 }
 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")
+    claudeProjects: join11(home, ".claude", "projects"),
+    claudeCredentials: join11(home, ".claude", ".credentials.json"),
+    takumiProjects: join11(home, ".takumi", "projects"),
+    codexDir: join11(home, ".codex"),
+    codexDb: join11(home, ".codex", "state_5.sqlite"),
+    codexAuth: join11(home, ".codex", "auth.json"),
+    codexConfig: join11(home, ".codex", "config.toml"),
+    geminiTmp: join11(home, ".gemini", "tmp"),
+    geminiHistory: join11(home, ".gemini", "history"),
+    opencodeMessages: join11(home, ".local", "share", "opencode", "storage", "message"),
+    piSessions: join11(home, ".pi", "agent", "sessions"),
+    hermesDir: join11(home, ".hermes"),
+    hermesDb: join11(home, ".hermes", "state.db")
   };
 }
 
@@ -3741,10 +4728,10 @@ function readClaudeToken() {
   const fromEnv = process.env["CLAUDE_OAUTH_TOKEN"] ?? process.env["ANTHROPIC_OAUTH_TOKEN"];
   if (fromEnv)
     return { token: fromEnv };
-  if (!existsSync9(CREDENTIALS_PATH))
+  if (!existsSync11(CREDENTIALS_PATH))
     return null;
   try {
-    const creds = JSON.parse(readFileSync6(CREDENTIALS_PATH, "utf-8"));
+    const creds = JSON.parse(readFileSync7(CREDENTIALS_PATH, "utf-8"));
     const oauth = creds.claudeAiOauth;
     if (!oauth?.accessToken)
       return null;
@@ -3858,7 +4845,7 @@ async function ingestClaudeQuota(db, verbose = false) {
     snapshots++;
   }
   const monthlyFee = inferMonthlyFee(auth.subscriptionType, auth.rateLimitTier);
-  const now = new Date().toISOString();
+  const now2 = new Date().toISOString();
   upsertSubscription(db, {
     id: "anthropic-claude-oauth",
     provider: "anthropic",
@@ -3869,8 +4856,8 @@ async function ingestClaudeQuota(db, verbose = false) {
     billing_cycle_start: null,
     reset_policy: "monthly",
     active: 1,
-    created_at: now,
-    updated_at: now
+    created_at: now2,
+    updated_at: now2
   });
   setIngestState(db, "claude", `quota-${today}`, new Date().toISOString());
   if (verbose)
@@ -3880,17 +4867,17 @@ async function ingestClaudeQuota(db, verbose = false) {
 
 // src/ingest/codex-quota.ts
 init_database();
-import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync12, 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 (!existsSync10(authPath))
+  if (!existsSync12(authPath))
     return null;
   try {
-    const auth = JSON.parse(readFileSync7(authPath, "utf-8"));
+    const auth = JSON.parse(readFileSync8(authPath, "utf-8"));
     const token = auth.tokens?.access_token;
     if (!token)
       return null;
@@ -3957,7 +4944,7 @@ async function ingestCodexQuota(db, verbose = false) {
   }
   const machineId = getMachineId();
   let snapshots = 0;
-  const now = new Date().toISOString();
+  const now2 = new Date().toISOString();
   const windows = [
     ["five_hour_utilization", usage.rate_limit?.primary_window],
     ["seven_day_utilization", usage.rate_limit?.secondary_window]
@@ -4008,10 +4995,10 @@ async function ingestCodexQuota(db, verbose = false) {
     billing_cycle_start: null,
     reset_policy: "monthly",
     active: 1,
-    created_at: now,
-    updated_at: now
+    created_at: now2,
+    updated_at: now2
   });
-  setIngestState(db, "codex", `quota-${today}`, now);
+  setIngestState(db, "codex", `quota-${today}`, now2);
   if (verbose)
     console.log(`  codex quota: ${snapshots} snapshots (${usage.plan_type ?? "unknown plan"})`);
   return { snapshots };
@@ -4053,7 +5040,8 @@ async function syncAll(db, opts = {}) {
 // src/lib/cloud-ingest.ts
 init_database();
 init_pricing();
-import { join as join10 } from "path";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync9, renameSync, writeFileSync } from "fs";
+import { dirname as dirname2, join as join12 } from "path";
 
 // src/ingest/billing.ts
 init_database();
@@ -4097,15 +5085,39 @@ var CLOUD_INGEST_TABLES = ["requests", "sessions", "billing_daily", "usage_snaps
 function getIngestCachePath() {
   if (process.env["HASNA_ECONOMY_INGEST_CACHE"])
     return process.env["HASNA_ECONOMY_INGEST_CACHE"];
-  return join10(getDataDir(), "ingest-cache.db");
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || undefined;
+  return join12(cacheDir({ app: "economy", home }), "ingest-cache.json");
+}
+function readIngestCache(path) {
+  let text;
+  try {
+    text = readFileSync9(path, "utf8");
+  } catch {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(text);
+    const rows = Array.isArray(parsed?.ingest_state) ? parsed.ingest_state : [];
+    return rows.filter((row) => typeof row === "object" && row !== null && typeof row.source === "string" && typeof row.key === "string" && typeof row.value === "string");
+  } catch {
+    return [];
+  }
+}
+function writeIngestCache(path, rows) {
+  mkdirSync3(dirname2(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify({ version: 1, ingest_state: rows }), { mode: 384 });
+  renameSync(tmp, path);
 }
-function copyIngestState(from, to) {
-  const rows = from.prepare(`SELECT source, key, value FROM ingest_state`).all();
-  to.prepare(`DELETE FROM ingest_state`).run();
-  const insert = to.prepare(`INSERT INTO ingest_state (source, key, value) VALUES (?, ?, ?)`);
+function loadIngestState2(scratch, rows) {
+  scratch.prepare(`DELETE FROM ingest_state`).run();
+  const insert = scratch.prepare(`INSERT INTO ingest_state (source, key, value) VALUES (?, ?, ?)`);
   for (const row of rows)
     insert.run(row.source, row.key, row.value);
 }
+function dumpIngestState(scratch) {
+  return scratch.prepare(`SELECT source, key, value FROM ingest_state`).all();
+}
 function exportIngestRows(db) {
   const body = {};
   for (const table of CLOUD_INGEST_TABLES) {
@@ -4133,11 +5145,9 @@ async function postIngest(cloud, body) {
 async function syncAllToCloud(cloud, opts = {}) {
   const scratch = openDatabase(":memory:", true);
   ensurePricingSeeded(scratch);
-  const cache = openDatabase(opts.cachePath ?? getIngestCachePath(), true);
+  const cachePath = opts.cachePath ?? getIngestCachePath();
   try {
-    if (opts.force)
-      cache.prepare(`DELETE FROM ingest_state`).run();
-    copyIngestState(cache, scratch);
+    loadIngestState2(scratch, opts.force ? [] : readIngestCache(cachePath));
     const result = await syncAll(scratch, opts);
     if (opts.backfillMachine)
       backfillMachineId(scratch);
@@ -4145,61 +5155,19 @@ async function syncAllToCloud(cloud, opts = {}) {
       await recalculateZeroCostRequests(scratch);
     const body = exportIngestRows(scratch);
     if (Object.keys(body).length === 0) {
-      copyIngestState(scratch, cache);
+      writeIngestCache(cachePath, dumpIngestState(scratch));
       return { ...result, posted: false };
     }
     const response = await postIngest(cloud, body);
-    copyIngestState(scratch, cache);
+    writeIngestCache(cachePath, dumpIngestState(scratch));
     return { ...result, posted: true, ingested: response.ingested, total: response.total };
   } finally {
     try {
       scratch.close();
     } catch {}
-    try {
-      cache.close();
-    } catch {}
   }
 }
 
-// src/lib/contracts-client/storage.ts
-import { resolveStorageClient } from "@hasna/contracts/client/storage";
-
-// src/lib/cloud-storage.ts
-var ECONOMY_APP = "economy";
-var cache;
-function resolveEconomyCloudStorage(env = process.env, overrides) {
-  const resolved = resolveStorageClient(ECONOMY_APP, env, overrides);
-  return resolved.transport === "http" ? { active: true, client: resolved.client } : { active: false, client: null };
-}
-function economyCloudStorage(env = process.env) {
-  if (cache === undefined)
-    cache = resolveEconomyCloudStorage(env);
-  return cache;
-}
-function cleanQuery(query) {
-  if (!query)
-    return;
-  const out = {};
-  for (const [k, v] of Object.entries(query)) {
-    if (v !== undefined && v !== null && v !== "")
-      out[k] = v;
-  }
-  return Object.keys(out).length > 0 ? out : undefined;
-}
-async function cloudListItems(storage, resource, query) {
-  const cleaned = cleanQuery(query);
-  const res = await storage.client.list(resource, cleaned ? { query: cleaned } : {});
-  return res.items;
-}
-async function cloudObject(storage, path, query) {
-  const cleaned = cleanQuery(query);
-  const raw = await storage.client.transport.get(path, cleaned ? { query: cleaned } : {});
-  if (raw && typeof raw === "object" && "data" in raw) {
-    return raw.data;
-  }
-  return raw;
-}
-
 // src/lib/agents.ts
 var AGENTS = [
   "claude",
@@ -4297,24 +5265,24 @@ function ymd(date) {
   return date.toISOString().substring(0, 10);
 }
 function usageSnapshotFilterForPeriod(period) {
-  const now = new Date;
+  const now2 = new Date;
   switch (period) {
     case "today":
-      return { date: ymd(now) };
+      return { date: ymd(now2) };
     case "yesterday": {
-      const yesterday = new Date(now);
+      const yesterday = new Date(now2);
       yesterday.setUTCDate(yesterday.getUTCDate() - 1);
       return { date: ymd(yesterday) };
     }
     case "week": {
-      const weekAgo = new Date(now);
+      const weekAgo = new Date(now2);
       weekAgo.setUTCDate(weekAgo.getUTCDate() - 7);
       return { since: ymd(weekAgo) };
     }
     case "month":
-      return { since: ymd(new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1))) };
+      return { since: ymd(new Date(Date.UTC(now2.getUTCFullYear(), now2.getUTCMonth(), 1))) };
     case "year":
-      return { since: ymd(new Date(Date.UTC(now.getUTCFullYear(), 0, 1))) };
+      return { since: ymd(new Date(Date.UTC(now2.getUTCFullYear(), 0, 1))) };
     case "all":
       return {};
   }
@@ -4343,13 +5311,13 @@ var ZERO_SESSION_TOTALS = {
   cost_usd: 0,
   last_active: null
 };
-function formatAge(timestamp, now) {
+function formatAge(timestamp, now2) {
   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 ageMs = Math.max(0, now2.getTime() - t);
   const minutes = Math.floor(ageMs / 60000);
   if (minutes < 1)
     return "<1m";
@@ -4498,7 +5466,7 @@ function querySinceTotals(db, since, machine) {
   const sessions = querySessionOnlyTotals(db, "started_at >= ?", [since], machine);
   return combineTotals(requests, sessions);
 }
-function parseSinceDate(input, now) {
+function parseSinceDate(input, now2) {
   const value = input.trim();
   const match = value.match(/^(\d+(?:\.\d+)?)(m|h|d|w)$/i);
   if (match) {
@@ -4506,7 +5474,7 @@ function parseSinceDate(input, now) {
     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(),
+      timestamp: new Date(now2.getTime() - amount * multiplier).toISOString(),
       label: value
     };
   }
@@ -4847,7 +5815,7 @@ function accountBreakdownToBriefRow(row) {
     last_active: row.last_active
   };
 }
-function queryFreshness(db, now, machine, localSync) {
+function queryFreshness(db, now2, machine, localSync) {
   const requestFilter = machine ? " AND machine_id = ?" : "";
   const requestRows = db.prepare(`
     SELECT machine_id, MAX(timestamp) as max_request_at
@@ -4861,7 +5829,7 @@ function queryFreshness(db, now, machine, localSync) {
     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),
+      request_age: formatAge(row.max_request_at, now2),
       last_merge_sync_at: null,
       merge_sync_age: "never"
     });
@@ -4876,7 +5844,7 @@ function queryFreshness(db, now, machine, localSync) {
     };
     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);
+    current.merge_sync_age = formatAge(syncAt, now2);
     machines.set(row.machine_id, current);
   }
   if (localSync && (!machine || machine === localSync.machineId)) {
@@ -4888,7 +5856,7 @@ function queryFreshness(db, now, machine, localSync) {
       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);
+    current.merge_sync_age = formatAge(current.last_merge_sync_at, now2);
     machines.set(localSync.machineId, current);
   }
   const rows = [...machines.values()].sort((a, b) => a.machine_id.localeCompare(b.machine_id));
@@ -4899,10 +5867,10 @@ function queryFreshness(db, now, machine, localSync) {
   };
 }
 function buildBrief(db, opts = {}) {
-  const now = opts.now ?? new Date;
+  const now2 = opts.now ?? new Date;
   const machine = machineFilter(opts.machine);
   const sinceInput = opts.since ?? "24h";
-  const since = parseSinceDate(sinceInput, now);
+  const since = parseSinceDate(sinceInput, now2);
   const summaries = [
     {
       label: "Today",
@@ -4923,10 +5891,10 @@ function buildBrief(db, opts = {}) {
   ];
   const machines = queryMachineSinceRows(db, since.timestamp, machine);
   for (const row of machines) {
-    row.last_data_age = formatAge(row.last_data_at, now);
+    row.last_data_age = formatAge(row.last_data_at, now2);
   }
   return {
-    generated_at: now.toISOString(),
+    generated_at: now2.toISOString(),
     machine: machine ?? "all",
     since: {
       input: sinceInput,
@@ -4937,7 +5905,7 @@ function buildBrief(db, opts = {}) {
     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)
+    freshness: queryFreshness(db, now2, machine, opts.currentMachineId && opts.localSyncAt ? { machineId: opts.currentMachineId, syncedAt: opts.localSyncAt.toISOString() } : undefined)
   };
 }
 
@@ -5001,14 +5969,14 @@ function queryRangeStats(db, from, to) {
   const s = db.prepare(`SELECT COUNT(*) as sessions FROM sessions WHERE DATE(started_at) BETWEEN ? AND ?`).get(from, to);
   return { cost: r.cost, requests: r.requests, tokens: r.tokens, sessions: s.sessions };
 }
-function queryForecast(db, now = new Date) {
-  const daysInMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0).getDate();
-  const dayOfMonth = now.getDate();
-  const monthStart = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-01`;
+function queryForecast(db, now2 = new Date) {
+  const daysInMonth = new Date(now2.getFullYear(), now2.getMonth() + 1, 0).getDate();
+  const dayOfMonth = now2.getDate();
+  const monthStart = `${now2.getFullYear()}-${String(now2.getMonth() + 1).padStart(2, "0")}-01`;
   const monthSoFar = db.prepare(`SELECT COALESCE(SUM(cost_usd),0) as cost FROM requests WHERE DATE(timestamp) >= ?`).get(monthStart);
   const dailyAvg = dayOfMonth > 0 ? monthSoFar.cost / dayOfMonth : 0;
   const projected = dailyAvg * daysInMonth;
-  const sevenDaysAgo = new Date(now);
+  const sevenDaysAgo = new Date(now2);
   sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
   const last7 = db.prepare(`SELECT COALESCE(SUM(cost_usd),0) as cost FROM requests WHERE DATE(timestamp) >= ?`).get(sevenDaysAgo.toISOString().substring(0, 10));
   const last7DailyAvg = last7.cost / 7;
@@ -5038,7 +6006,7 @@ function queryModelEfficiency(db) {
 }
 
 // src/lib/store/index.ts
-class LocalStore {
+class LocalStore2 {
   transport = "local";
   _db;
   db() {
@@ -5154,8 +6122,8 @@ class LocalStore {
     return estimateCostFromRows(listModelPricing(this.db()), input.model, input.inputTokens, input.outputTokens, input.cacheReadTokens ?? 0, input.cacheWriteTokens ?? 0, input.cacheWrite1hTokens ?? 0, input.cacheStorageTokenHours ?? 0);
   }
   async setBudget(input) {
-    const now = new Date().toISOString();
-    const budget = { id: randomUUID(), ...input, created_at: now, updated_at: now };
+    const now2 = new Date().toISOString();
+    const budget = { id: randomUUID(), ...input, created_at: now2, updated_at: now2 };
     upsertBudget(this.db(), budget);
     return budget.id;
   }
@@ -5163,8 +6131,8 @@ class LocalStore {
     deleteBudget(this.db(), id);
   }
   async setGoal(input) {
-    const now = new Date().toISOString();
-    upsertGoal(this.db(), { id: randomUUID(), ...input, created_at: now, updated_at: now });
+    const now2 = new Date().toISOString();
+    upsertGoal(this.db(), { id: randomUUID(), ...input, created_at: now2, updated_at: now2 });
   }
   async removeGoal(id) {
     deleteGoal(this.db(), id);
@@ -5176,7 +6144,7 @@ class LocalStore {
     deleteModelPricing(this.db(), model);
   }
   async setSubscription(input) {
-    const now = new Date().toISOString();
+    const now2 = new Date().toISOString();
     const row = {
       id: input.id ?? randomUUID(),
       provider: input.provider,
@@ -5187,8 +6155,8 @@ class LocalStore {
       billing_cycle_start: input.billing_cycle_start,
       reset_policy: input.reset_policy,
       active: input.active,
-      created_at: now,
-      updated_at: now
+      created_at: now2,
+      updated_at: now2
     };
     upsertSubscription(this.db(), row);
     return row;
@@ -5233,7 +6201,7 @@ function q(params) {
   return out;
 }
 
-class ApiStore {
+class ApiStore2 {
   cloud;
   transport = "cloud-http";
   constructor(cloud) {
@@ -5377,7 +6345,7 @@ class ApiStore {
     await this.cloud.client.delete("pricing", model);
   }
   async setSubscription(input) {
-    const now = new Date().toISOString();
+    const now2 = new Date().toISOString();
     const row = {
       id: input.id ?? randomUUID(),
       provider: input.provider,
@@ -5388,8 +6356,8 @@ class ApiStore {
       billing_cycle_start: input.billing_cycle_start,
       reset_policy: input.reset_policy,
       active: input.active,
-      created_at: now,
-      updated_at: now
+      created_at: now2,
+      updated_at: now2
     };
     await this.cloud.client.create("subscriptions", row);
     return row;
@@ -5417,7 +6385,7 @@ class ApiStore {
 }
 function getStore(env = process.env) {
   const cloud = economyCloudStorage(env);
-  return cloud.active ? new ApiStore(cloud) : new LocalStore;
+  return cloud.active ? new ApiStore2(cloud) : new LocalStore2;
 }
 function isCloudStore(env = process.env) {
   return economyCloudStorage(env).active;
@@ -5565,17 +6533,17 @@ function buildServer() {
   function textError(message) {
     return { content: [{ type: "text", text: message }], isError: true };
   }
-  server.tool("search_tools", "List tool names matching query. Use first to find relevant tools.", { query: z.string().optional() }, async ({ query }) => {
+  server.tool("search_tools", "List tool names matching query. Use first to find relevant tools.", { query: z3.string().optional() }, async ({ query }) => {
     const q2 = query?.toLowerCase();
     const matches = q2 ? TOOL_NAMES.filter((name) => name.includes(q2)) : [...TOOL_NAMES];
     return text(matches.join(", "));
   });
-  server.tool("describe_tools", "Get param hints for specific tools by name.", { names: z.array(z.string()) }, async ({ names }) => {
+  server.tool("describe_tools", "Get param hints for specific tools by name.", { names: z3.array(z3.string()) }, async ({ names }) => {
     const result = names.map((name) => `${name}: ${TOOL_DESCRIPTIONS[name] ?? "see tool schema"}`).join(`
 `);
     return text(result);
   });
-  server.tool("get_cost_summary", "Cost summary (total_usd, sessions, requests, tokens, human summary). period: today|week|month|year|all. machine: filter by hostname.", { period: z.enum(["today", "week", "month", "year", "all"]).optional(), machine: z.string().optional() }, async ({ period, machine }) => {
+  server.tool("get_cost_summary", "Cost summary (total_usd, sessions, requests, tokens, human summary). period: today|week|month|year|all. machine: filter by hostname.", { period: z3.enum(["today", "week", "month", "year", "all"]).optional(), machine: z3.string().optional() }, async ({ period, machine }) => {
     const resolved = period ?? "today";
     const s = await store.summary(resolved, machine);
     const machineLabel = machine ? ` on ${machine}` : "";
@@ -5590,11 +6558,11 @@ function buildServer() {
 `));
   });
   server.tool("get_sessions", "List sessions. Returns compact table. Params: agent, project, account, machine, limit(20)", {
-    agent: z.enum(AGENTS).optional(),
-    project: z.string().optional(),
-    account: z.string().optional(),
-    machine: z.string().optional(),
-    limit: z.number().int().positive().max(100).optional()
+    agent: z3.enum(AGENTS).optional(),
+    project: z3.string().optional(),
+    account: z3.string().optional(),
+    machine: z3.string().optional(),
+    limit: z3.number().int().positive().max(100).optional()
   }, async ({ agent, project, account, machine, limit }) => {
     const sessions = await store.sessions({ agent, project, account, machine, limit: limit ?? 20 });
     const lines = ["id       agent  cost       tokens   project"];
@@ -5604,8 +6572,8 @@ function buildServer() {
 `));
   });
   server.tool("get_top_sessions", "Top sessions by cost. Params: n(10), agent", {
-    n: z.number().int().positive().max(100).optional(),
-    agent: z.enum(AGENTS).optional()
+    n: z3.number().int().positive().max(100).optional(),
+    agent: z3.enum(AGENTS).optional()
   }, async ({ n, agent }) => {
     const sessions = await store.topSessions(n ?? 10, agent);
     const lines = ["rank  id       agent  cost       tokens   project"];
@@ -5613,7 +6581,7 @@ function buildServer() {
     return text(lines.join(`
 `));
   });
-  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 }) => {
+  server.tool("get_model_breakdown", "Cost per model. Params: limit(20), verbose, json.", { limit: z3.number().int().positive().max(100).optional(), verbose: z3.boolean().optional(), json: z3.boolean().optional() }, async ({ limit, verbose, json }) => {
     const rows = await store.modelBreakdown();
     if (json)
       return text(JSON.stringify(rows, null, 2));
@@ -5628,7 +6596,7 @@ function buildServer() {
     return text(lines.join(`
 `));
   });
-  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 }) => {
+  server.tool("get_project_breakdown", "Cost per project. Params: period(today|week|month|year|all), limit(20), verbose, json.", { period: z3.enum(["today", "week", "month", "year", "all"]).optional(), limit: z3.number().int().positive().max(100).optional(), verbose: z3.boolean().optional(), json: z3.boolean().optional() }, async ({ period, limit, verbose, json }) => {
     const rows = await store.projectBreakdown({ period: period ?? "all" });
     if (json)
       return text(JSON.stringify(rows, null, 2));
@@ -5644,7 +6612,7 @@ function buildServer() {
     return text(lines.join(`
 `));
   });
-  server.tool("get_agent_breakdown", "Cost per coding agent. Params: period(today|week|month|year|all). Shows API-equivalent, billable API, and subscription-included usage.", { period: z.enum(["today", "week", "month", "year", "all"]).optional() }, async ({ period }) => {
+  server.tool("get_agent_breakdown", "Cost per coding agent. Params: period(today|week|month|year|all). Shows API-equivalent, billable API, and subscription-included usage.", { period: z3.enum(["today", "week", "month", "year", "all"]).optional() }, async ({ period }) => {
     const rows = await store.agentBreakdown({ period: period ?? "all" });
     if (rows.length === 0)
       return text("No agent usage yet.");
@@ -5655,7 +6623,7 @@ function buildServer() {
     return text(lines.join(`
 `));
   });
-  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 }) => {
+  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: z3.enum(["today", "week", "month", "year", "all"]).optional(), limit: z3.number().int().positive().max(100).optional(), verbose: z3.boolean().optional(), json: z3.boolean().optional() }, async ({ period, limit, verbose, json }) => {
     const rows = await store.accountBreakdown({ period: period ?? "all" });
     if (json)
       return text(JSON.stringify(rows, null, 2));
@@ -5674,8 +6642,8 @@ function buildServer() {
 `));
   });
   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()
+    period: z3.enum(["today", "week", "month", "year", "all"]).optional(),
+    kind: z3.enum(["loop", "app", "repo", "service", "team"]).optional()
   }, async ({ period, kind }) => {
     const rows = await store.costCenterBreakdown({ period: period ?? "all", kind });
     if (rows.length === 0)
@@ -5687,7 +6655,7 @@ function buildServer() {
     return text(lines.join(`
 `));
   });
-  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 }) => {
+  server.tool("get_budget_status", "Budget limits vs spend, percent used, alert flags. Params: limit(20), verbose, json.", { limit: z3.number().int().positive().max(100).optional(), verbose: z3.boolean().optional(), json: z3.boolean().optional() }, async ({ limit, verbose, json }) => {
     const budgets = await store.listBudgets();
     if (json)
       return text(JSON.stringify(budgets, null, 2));
@@ -5708,12 +6676,12 @@ function buildServer() {
 `));
   });
   server.tool("set_budget", "Create a spending budget. period: daily|weekly|monthly. limit_usd must be positive. alert_at_percent defaults to 80.", {
-    period: z.enum(["daily", "weekly", "monthly"]),
-    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()
+    period: z3.enum(["daily", "weekly", "monthly"]),
+    limit_usd: z3.number().positive(),
+    project_path: z3.string().optional(),
+    agent: z3.enum(AGENTS).optional(),
+    cost_center_id: z3.string().optional(),
+    alert_at_percent: z3.number().positive().max(100).optional()
   }, async ({ period, limit_usd, project_path, agent, cost_center_id, alert_at_percent }) => {
     const id = await store.setBudget({
       project_path: project_path ?? null,
@@ -5725,11 +6693,11 @@ function buildServer() {
     });
     return text(`Budget set: ${id}`);
   });
-  server.tool("remove_budget", "Delete a budget by id.", { id: z.string() }, async ({ id }) => {
+  server.tool("remove_budget", "Delete a budget by id.", { id: z3.string() }, async ({ id }) => {
     await store.removeBudget(id);
     return text("Budget removed.");
   });
-  server.tool("get_pricing", "Editable model pricing rows. Includes input/output/cache rates and context-cache storage. 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 }) => {
+  server.tool("get_pricing", "Editable model pricing rows. Includes input/output/cache rates and context-cache storage. Params: limit(20), verbose, json.", { limit: z3.number().int().positive().max(100).optional(), verbose: z3.boolean().optional(), json: z3.boolean().optional() }, async ({ limit, verbose, json }) => {
     const rows = await store.listPricing();
     if (json)
       return text(JSON.stringify(rows, null, 2));
@@ -5745,13 +6713,13 @@ function buildServer() {
 `));
   });
   server.tool("set_pricing", "Create or update a model pricing row. Values are USD per 1M tokens except cache_storage_per_1m_hour.", {
-    model: z.string().min(1),
-    input_per_1m: z.number().nonnegative(),
-    output_per_1m: z.number().nonnegative(),
-    cache_read_per_1m: z.number().nonnegative().optional(),
-    cache_write_per_1m: z.number().nonnegative().optional(),
-    cache_write_1h_per_1m: z.number().nonnegative().optional(),
-    cache_storage_per_1m_hour: z.number().nonnegative().optional()
+    model: z3.string().min(1),
+    input_per_1m: z3.number().nonnegative(),
+    output_per_1m: z3.number().nonnegative(),
+    cache_read_per_1m: z3.number().nonnegative().optional(),
+    cache_write_per_1m: z3.number().nonnegative().optional(),
+    cache_write_1h_per_1m: z3.number().nonnegative().optional(),
+    cache_storage_per_1m_hour: z3.number().nonnegative().optional()
   }, async (input) => {
     const model = input.model.trim();
     if (!model)
@@ -5767,11 +6735,11 @@ function buildServer() {
     });
     return text(`Pricing set: ${model}`);
   });
-  server.tool("remove_pricing", "Delete a model pricing row by model id.", { model: z.string() }, async ({ model }) => {
+  server.tool("remove_pricing", "Delete a model pricing row by model id.", { model: z3.string() }, async ({ model }) => {
     await store.removePricing(model);
     return text("Pricing removed.");
   });
-  server.tool("get_daily", "Daily cost table by agent. Params: days(30)", { days: z.number().int().positive().max(365).optional() }, async ({ days }) => {
+  server.tool("get_daily", "Daily cost table by agent. Params: days(30)", { days: z3.number().int().positive().max(365).optional() }, async ({ days }) => {
     const rows = await store.daily(days ?? 30);
     const byDate = new Map;
     for (const row of rows) {
@@ -5795,7 +6763,7 @@ function buildServer() {
     return text(lines.join(`
 `));
   });
-  server.tool("get_billing_summary", "Actual provider billing totals from admin API sync. Params: period(today|yesterday|week|month|year|all)", { period: z.enum(["today", "yesterday", "week", "month", "year", "all"]).optional() }, async ({ period }) => {
+  server.tool("get_billing_summary", "Actual provider billing totals from admin API sync. Params: period(today|yesterday|week|month|year|all)", { period: z3.enum(["today", "yesterday", "week", "month", "year", "all"]).optional() }, async ({ period }) => {
     const summary = await store.billingSummary(period ?? "month");
     const lines = ["provider    billed"];
     for (const [provider, cost] of Object.entries(summary.by_provider)) {
@@ -5805,7 +6773,7 @@ function buildServer() {
     return text(lines.join(`
 `));
   });
-  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 }) => {
+  server.tool("get_session_detail", "Per-request breakdown of a single session. Params: session_id (prefix ok), limit(20), verbose.", { session_id: z3.string(), limit: z3.number().int().positive().max(100).optional(), verbose: z3.boolean().optional() }, async ({ session_id, limit, verbose }) => {
     const detail = await store.sessionDetail(session_id);
     if (!detail)
       return textError(`Session not found: ${session_id}`);
@@ -5829,13 +6797,13 @@ function buildServer() {
     return text(lines.join(`
 `));
   });
-  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 }) => {
+  server.tool("sync", `Ingest new cost data. sources: ${SYNC_SOURCES.join("|")}. Set json=true for the full result object.`, { sources: z3.enum([...SYNC_SOURCES]).optional(), json: z3.boolean().optional() }, async ({ sources, json }) => {
     const selected = sources ?? "all";
     const opts = selected === "all" ? {} : { [selected]: true };
     if (isCloudStore()) {
       const cloud = economyCloudStorage();
       if (!cloud.active) {
-        return text("cloud mode: sync transport unavailable (set HASNA_ECONOMY_API_URL and HASNA_ECONOMY_API_KEY)");
+        return text("cloud mode: sync transport unavailable (no credential resolved; set HASNA_ECONOMY_API_KEY or write ~/.hasna/economy/config/credentials)");
       }
       const result2 = await syncAllToCloud(cloud, opts);
       if (json)
@@ -5877,7 +6845,7 @@ function buildServer() {
     return text(lines.join(`
 `));
   });
-  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 }) => {
+  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: z3.enum(["today", "week", "month", "year", "all"]).optional(), agent: z3.enum(AGENTS).optional(), limit: z3.number().int().positive().max(100).optional(), json: z3.boolean().optional() }, async ({ period, agent, limit, json }) => {
     const p = period ?? "month";
     const { snapshots: snaps, summary } = await store.usage(p, agent);
     if (json)
@@ -5899,7 +6867,7 @@ function buildServer() {
     return text(lines.join(`
 `));
   });
-  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 }) => {
+  server.tool("get_savings", "Subscription vs API savings summary. Params: period, agent, limit(20). Set json=true for full data.", { period: z3.enum(["today", "week", "month", "year", "all"]).optional(), agent: z3.enum(AGENTS).optional(), limit: z3.number().int().positive().max(100).optional(), json: z3.boolean().optional() }, async ({ period, agent, limit, json }) => {
     const savings = await store.savings(period ?? "month", agent);
     if (json)
       return text(JSON.stringify(savings, null, 2));
@@ -5936,16 +6904,16 @@ function buildServer() {
 `));
   });
   server.tool("set_subscription", "Create or update a subscription plan used by subscription-vs-API savings calculations.", {
-    id: z.string().optional(),
-    provider: z.string().min(1),
-    plan: z.string().min(1),
-    agent: z.enum(AGENTS).optional(),
-    monthly_fee_usd: z.number().nonnegative().optional(),
-    included_usage_usd: z.number().nonnegative().optional(),
-    billing_cycle_start: z.string().optional(),
-    reset_policy: z.string().optional(),
-    active: z.boolean().optional(),
-    json: z.boolean().optional()
+    id: z3.string().optional(),
+    provider: z3.string().min(1),
+    plan: z3.string().min(1),
+    agent: z3.enum(AGENTS).optional(),
+    monthly_fee_usd: z3.number().nonnegative().optional(),
+    included_usage_usd: z3.number().nonnegative().optional(),
+    billing_cycle_start: z3.string().optional(),
+    reset_policy: z3.string().optional(),
+    active: z3.boolean().optional(),
+    json: z3.boolean().optional()
   }, async (input) => {
     const row = await store.setSubscription({
       id: input.id,
@@ -5967,15 +6935,15 @@ 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 }) => {
+  server.tool("remove_subscription", "Delete a subscription plan by id.", { id: z3.string() }, async ({ id }) => {
     await store.removeSubscription(id);
     return text("Subscription removed.");
   });
-  server.tool("estimate_cost", "Pre-flight cost estimate for token counts", { model: z.string(), input_tokens: z.number().optional(), output_tokens: z.number().optional() }, async ({ model, input_tokens, output_tokens }) => {
+  server.tool("estimate_cost", "Pre-flight cost estimate for token counts", { model: z3.string(), input_tokens: z3.number().optional(), output_tokens: z3.number().optional() }, async ({ model, input_tokens, output_tokens }) => {
     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. 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 }) => {
+  server.tool("get_goals", "All spending goals with current progress. Params: limit(20), verbose, json.", { limit: z3.number().int().positive().max(100).optional(), verbose: z3.boolean().optional(), json: z3.boolean().optional() }, async ({ limit, verbose, json }) => {
     const goals = await store.listGoals();
     if (json)
       return text(JSON.stringify(goals, null, 2));
@@ -5996,10 +6964,10 @@ included: ${fmtUsd(row.included_usage_usd)}`);
 `));
   });
   server.tool("set_goal", "Create/update a spending goal. period(day|week|month|year), limit_usd, project_path?, agent?", {
-    period: z.enum(["day", "week", "month", "year"]),
-    limit_usd: z.number().positive(),
-    project_path: z.string().optional(),
-    agent: z.string().optional()
+    period: z3.enum(["day", "week", "month", "year"]),
+    limit_usd: z3.number().positive(),
+    project_path: z3.string().optional(),
+    agent: z3.string().optional()
   }, async ({ period, limit_usd, project_path, agent }) => {
     await store.setGoal({
       period,
@@ -6009,11 +6977,11 @@ included: ${fmtUsd(row.included_usage_usd)}`);
     });
     return text(`Goal set: ${period} $${limit_usd}`);
   });
-  server.tool("remove_goal", "Delete a goal by id.", { id: z.string() }, async ({ id }) => {
+  server.tool("remove_goal", "Delete a goal by id.", { id: z3.string() }, async ({ id }) => {
     await store.removeGoal(id);
     return text("Goal removed.");
   });
-  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 }) => {
+  server.tool("list_machines", "List all machines that have synced data. Params: limit(20), verbose, json.", { limit: z3.number().int().positive().max(100).optional(), verbose: z3.boolean().optional(), json: z3.boolean().optional() }, async ({ limit, verbose, json }) => {
     const machines = await store.machines();
     if (json)
       return text(JSON.stringify(machines, null, 2));
@@ -6032,11 +7000,11 @@ current machine: ${getMachineId()}`);
     return text(lines.join(`
 `));
   });
-  registerAgentTools(server, { includeFeedback: false });
+  registerAgentTools(server, { service: "economy" });
   server.tool("send_feedback", "Send feedback about this service.", {
-    message: z.string(),
-    email: z.string().optional(),
-    category: z.enum(["bug", "feature", "general"]).optional()
+    message: z3.string(),
+    email: z3.string().optional(),
+    category: z3.enum(["bug", "feature", "general"]).optional()
   }, async ({ message, email, category }) => {
     try {
       await store.sendFeedback({ message, email, category });
@@ -6048,32 +7016,102 @@ current machine: ${getMachineId()}`);
   return server;
 }
 
+// src/mcp/harness.ts
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+var PORT_MIN = 0;
+var PORT_MAX = 65535;
+var DEFAULT_MCP_HTTP_PORT2 = 8899;
+function invalidPortMessage(source, value) {
+  return `Invalid ${source} "${value}". Expected an integer between ${PORT_MIN} and ${PORT_MAX}.`;
+}
+function validatePort(port, source) {
+  if (!Number.isInteger(port) || port < PORT_MIN || port > PORT_MAX) {
+    throw new Error(invalidPortMessage(source, String(port)));
+  }
+  return port;
+}
+function parsePortValue(value, source) {
+  const trimmed = value.trim();
+  if (!/^\d+$/.test(trimmed)) {
+    throw new Error(invalidPortMessage(source, value));
+  }
+  return validatePort(Number(trimmed), source);
+}
+function isStdioMode(argv = process.argv, env = process.env) {
+  return argv.includes("--stdio") || env.MCP_STDIO === "1";
+}
+function isHttpMode(argv = process.argv, env = process.env) {
+  return argv.includes("--http") || env.MCP_HTTP === "1";
+}
+function parseHttpArgv(argv = process.argv) {
+  const http = isHttpMode(argv);
+  let port;
+  const portEqualsArg = argv.find((arg) => arg.startsWith("--port="));
+  if (portEqualsArg) {
+    port = parsePortValue(portEqualsArg.slice("--port=".length), "--port");
+  }
+  const portIdx = argv.indexOf("--port");
+  if (portIdx !== -1) {
+    const value = argv[portIdx + 1];
+    if (value === undefined) {
+      throw new Error(invalidPortMessage("--port", ""));
+    }
+    port = parsePortValue(value, "--port");
+  }
+  return { http, port };
+}
+function resolveMcpHttpPort(opts) {
+  const argv = opts?.argv ?? process.argv;
+  const env = opts?.env ?? process.env;
+  if (opts?.explicit != null) {
+    return validatePort(opts.explicit, "--port");
+  }
+  const { port } = parseHttpArgv(argv);
+  if (port != null)
+    return port;
+  const envPort = env.MCP_HTTP_PORT;
+  if (envPort && envPort.trim() !== "") {
+    return parsePortValue(envPort, "MCP_HTTP_PORT");
+  }
+  return opts?.default ?? DEFAULT_MCP_HTTP_PORT2;
+}
+function healthPayload(name) {
+  return { status: "ok", name };
+}
+async function handleMcpHttpRequest(req, buildServer2, options) {
+  try {
+    const server = await buildServer2();
+    const transport = new WebStandardStreamableHTTPServerTransport({
+      sessionIdGenerator: undefined,
+      enableJsonResponse: options?.enableJsonResponse
+    });
+    await server.connect(transport);
+    return await transport.handleRequest(req);
+  } catch (error) {
+    console.error("[mcp] HTTP error:", error);
+    return Response.json({ jsonrpc: "2.0", error: { code: -32603, message: "Internal server error" }, id: null }, { status: 500 });
+  }
+}
+
 // src/mcp/http.ts
-import {
-  healthPayload,
-  isHttpMode as harnessIsHttpMode,
-  isStdioMode as harnessIsStdioMode,
-  resolveMcpHttpPort as harnessResolveMcpHttpPort
-} from "@hasna/mcp-harness";
-import { handleMcpHttpRequest as harnessHandleMcpHttpRequest } from "@hasna/mcp-harness/bun";
 var MCP_HTTP_IDLE_TIMEOUT_SECONDS = 0;
-function isHttpMode(argv = process.argv.slice(2)) {
-  return harnessIsHttpMode(argv);
+function isHttpMode2(argv = process.argv.slice(2)) {
+  return isHttpMode(argv);
 }
-function isStdioMode(argv = process.argv.slice(2)) {
-  return harnessIsStdioMode(argv);
+function isStdioMode2(argv = process.argv.slice(2)) {
+  return isStdioMode(argv);
 }
 function resolveHttpPort(argv = process.argv.slice(2)) {
   const normalized = argv.map((arg) => arg === "-p" ? "--port" : arg);
-  return harnessResolveMcpHttpPort({ argv: normalized, default: DEFAULT_MCP_HTTP_PORT });
+  return resolveMcpHttpPort({ argv: normalized, default: DEFAULT_MCP_HTTP_PORT });
 }
-async function handleMcpHttpRequest(req) {
+async function handleMcpHttpRequest2(req) {
   const url = new URL(req.url);
   if (url.pathname === "/health" && req.method === "GET") {
     return Response.json(healthPayload(MCP_NAME));
   }
   if (url.pathname === "/mcp") {
-    return harnessHandleMcpHttpRequest(req, buildServer);
+    return handleMcpHttpRequest(req, buildServer);
   }
   return new Response("Not Found", { status: 404 });
 }
@@ -6085,7 +7123,7 @@ function startHttpServer(options = {}) {
     port,
     hostname: hostname2,
     idleTimeout: MCP_HTTP_IDLE_TIMEOUT_SECONDS,
-    fetch: handleMcpHttpRequest
+    fetch: handleMcpHttpRequest2
   });
   const address = `http://${hostname2}:${server.port}`;
   log(`${MCP_NAME}-mcp HTTP listening on ${address}/mcp (health: ${address}/health)`);
@@ -6118,7 +7156,7 @@ if (args.includes("--version") || args.includes("-V")) {
   process.exit(0);
 }
 async function main() {
-  if (isStdioMode(args) || !isHttpMode(args)) {
+  if (isStdioMode2(args) || !isHttpMode2(args)) {
     const server = buildServer();
     const transport = new StdioServerTransport;
     await server.connect(transport);
@@ -6128,6 +7166,6 @@ async function main() {
   await new Promise(() => {});
 }
 main().catch((error) => {
-  console.error("MCP server error:", error);
+  console.error("MCP server error:", error instanceof Error ? error.message : String(error));
   process.exit(1);
 });