@hasna/economy 0.3.27 → 0.4.0

package/dist/server/index.js

@@ -595,7 +595,60 @@ import { execFileSync } from "child_process";
 import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
 import { hostname, platform } from "os";
 import { homedir } from "os";
-import { join } from "path";
+import { join, resolve } from "path";
+import { homedir as pathsResolverHomedir } from "os";
+import { join as pathsResolverJoin } from "path";
+function pathsResolverAssertApp(app) {
+  if (typeof app !== "string" || app.length === 0) {
+    throw new TypeError("paths: app must be a non-empty string");
+  }
+  if (!PATHS_RESOLVER_APP_SLUG_RE.test(app)) {
+    throw new TypeError(`paths: invalid app slug "${app}" \u2014 expected lowercase kebab-case ([a-z0-9]+(-[a-z0-9]+)*)`);
+  }
+}
+function pathsResolverAssertKind(kind) {
+  if (!Object.keys(PATHS_RESOLVER_KIND_ENV).includes(kind)) {
+    throw new TypeError(`paths: invalid path kind "${kind}" \u2014 expected one of ${Object.keys(PATHS_RESOLVER_KIND_ENV).join(", ")}`);
+  }
+}
+function pathsResolverBaseDir(kind, options) {
+  pathsResolverAssertKind(kind);
+  const env = options.env ?? process.env;
+  const override = env[PATHS_RESOLVER_KIND_ENV[kind]];
+  if (typeof override === "string" && override.length > 0)
+    return override;
+  const home = options.home ?? pathsResolverHomedir();
+  const platform2 = options.platform ?? process.platform;
+  if (platform2 === "darwin") {
+    switch (kind) {
+      case "config":
+      case "data":
+        return pathsResolverJoin(home, "Library", "Application Support", "Hasna");
+      case "cache":
+        return pathsResolverJoin(home, "Library", "Caches", "Hasna");
+      case "state":
+        return pathsResolverJoin(home, "Library", "Logs", "Hasna");
+    }
+  }
+  switch (kind) {
+    case "config":
+      return pathsResolverJoin(home, ".config", "hasna");
+    case "data":
+      return pathsResolverJoin(home, ".local", "share", "hasna");
+    case "state":
+      return pathsResolverJoin(home, ".local", "state", "hasna");
+    case "cache":
+      return pathsResolverJoin(home, ".cache", "hasna");
+  }
+}
+function pathsResolverResolve(kind, options) {
+  pathsResolverAssertApp(options.app);
+  const appSegment = options.internal === true ? pathsResolverJoin("internal", options.app) : options.app;
+  return pathsResolverJoin(pathsResolverBaseDir(kind, options), appSegment);
+}
+function dataDir(options) {
+  return pathsResolverResolve("data", options);
+}
 function normalizeMachineId(value) {
   const id = value?.trim().toLowerCase().split(".")[0];
   return id && id.length > 0 ? id : null;
@@ -618,7 +671,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";
@@ -626,21 +679,48 @@ function getMachineId() {
     return macHostMachineId() ?? hostMachine;
   return hostMachine;
 }
-function getDataDir() {
+function getHomeDir() {
   const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir();
-  const newDir = join(home, ".hasna", "economy");
-  const oldDir = join(home, ".economy");
-  if (existsSync(oldDir) && !existsSync(newDir)) {
-    mkdirSync(newDir, { recursive: true });
+  if (!home)
+    throw new Error("Could not resolve the user home directory");
+  return home;
+}
+function getResolverDataRoot() {
+  return dataDir({
+    app: "economy",
+    home: process.env["HOME"] || process.env["USERPROFILE"] || undefined
+  });
+}
+function getLegacyDataRoot() {
+  return join(getHomeDir(), ".hasna", "economy");
+}
+function adoptResolverDataRoot(resolved, env = process.env) {
+  const dataOverride = env.HASNA_DATA_HOME;
+  if (typeof dataOverride === "string" && dataOverride.trim().length > 0)
+    return true;
+  return existsSync(join(resolved, "economy.db"));
+}
+function getExactDataRoot() {
+  const dir = process.env["HASNA_ECONOMY_HOME"] ?? process.env["ECONOMY_HOME"];
+  if (dir && dir.trim())
+    return dir.trim();
+  return;
+}
+function getDataDir() {
+  const exact = getExactDataRoot();
+  const effective = exact ? resolve(exact) : adoptResolverDataRoot(getResolverDataRoot()) ? resolve(getResolverDataRoot()) : getLegacyDataRoot();
+  const oldDir = join(getHomeDir(), ".economy");
+  if (existsSync(oldDir) && !existsSync(effective)) {
+    mkdirSync(effective, { recursive: true });
     for (const file of readdirSync(oldDir)) {
       const oldPath = join(oldDir, file);
       if (statSync(oldPath).isFile()) {
-        copyFileSync(oldPath, join(newDir, file));
+        copyFileSync(oldPath, join(effective, file));
       }
     }
   }
-  mkdirSync(newDir, { recursive: true });
-  return newDir;
+  mkdirSync(effective, { recursive: true });
+  return effective;
 }
 function getDbPath() {
   if (process.env["HASNA_ECONOMY_DB_PATH"])
@@ -1898,6 +1978,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);
 }
@@ -2336,7 +2420,7 @@ function bulkIngest(db, body) {
   const total = Object.values(ingested).reduce((a, b) => a + b, 0);
   return { ingested, total };
 }
-var numOr = (v, d = 0) => {
+var PATHS_RESOLVER_KIND_ENV, PATHS_RESOLVER_APP_SLUG_RE, numOr = (v, d = 0) => {
   if (v == null)
     return d;
   const num = Number(v);
@@ -2344,6 +2428,13 @@ var numOr = (v, d = 0) => {
 }, strOr = (v, d = "") => v == null ? d : String(v);
 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/db/dialect.ts
@@ -2386,8 +2477,8 @@ function sqliteToPostgres(sql) {
 // src/db/sync-pg.ts
 import { Worker, MessageChannel, receiveMessageOnPort } from "worker_threads";
 import { fileURLToPath } from "url";
-import { dirname, join as join10 } from "path";
-import { existsSync as existsSync11 } from "fs";
+import { dirname, join as join11 } from "path";
+import { existsSync as existsSync12 } from "fs";
 function translateSqliteDates(sql) {
   let s = sql;
   const isoDate = (expr) => `to_char(${expr}, 'YYYY-MM-DD')`;
@@ -2412,12 +2503,12 @@ function translateSqliteDates(sql) {
 function resolveWorkerPath() {
   const here = dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    join10(here, "pg-sync-worker.ts"),
-    join10(here, "pg-sync-worker.js"),
-    join10(here, "..", "db", "pg-sync-worker.js")
+    join11(here, "pg-sync-worker.ts"),
+    join11(here, "pg-sync-worker.js"),
+    join11(here, "..", "db", "pg-sync-worker.js")
   ];
   for (const candidate of candidates)
-    if (existsSync11(candidate))
+    if (existsSync12(candidate))
       return candidate;
   return candidates[0];
 }
@@ -2874,7 +2965,7 @@ __export(exports_billing, {
   syncGeminiBilling: () => syncGeminiBilling,
   syncAnthropicBilling: () => syncAnthropicBilling
 });
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 function getAnthropicAdminKey() {
   return process.env["HASNAXYZ_ANTHROPIC_LIVE_ADMIN_API_KEY"] ?? process.env["ANTHROPIC_ADMIN_API_KEY"] ?? null;
 }
@@ -3101,7 +3192,7 @@ async function syncGeminiBilling(db, opts = {}) {
   const start = opts.fromDate ? new Date(opts.fromDate) : new Date(end.getTime() - days * 24 * 3600000);
   const fromDateStr = toISODate(start);
   const toDateStr = toISODate(end);
-  const rows = parseBillingRows(readFileSync8(exportPath, "utf-8"));
+  const rows = parseBillingRows(readFileSync9(exportPath, "utf-8"));
   clearBillingRange(db, "gemini", fromDateStr, toDateStr);
   const updatedAt = new Date().toISOString();
   let totalUsd = 0;
@@ -3165,16 +3256,16 @@ var init_open_projects = __esm(() => {
 });
 
 // src/lib/config.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
-import { dirname as dirname2, join as join11 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync10, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2, join as join12 } from "path";
 function getConfigPath() {
-  return process.env["HASNA_ECONOMY_CONFIG_PATH"] ?? join11(getDataDir(), "config.json");
+  return process.env["HASNA_ECONOMY_CONFIG_PATH"] ?? join12(getDataDir(), "config.json");
 }
 function loadConfig() {
   try {
     const configPath = getConfigPath();
-    if (existsSync12(configPath)) {
-      const raw = readFileSync9(configPath, "utf-8");
+    if (existsSync13(configPath)) {
+      const raw = readFileSync10(configPath, "utf-8");
       return { ...DEFAULTS, ...JSON.parse(raw) };
     }
   } catch {}
@@ -3319,9 +3410,9 @@ function isAgent(value) {
 // 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 existsSync3, statSync as statSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3, basename } from "path";
 
 // src/lib/savings.ts
 function periodWhere2(period, column) {
@@ -3477,8 +3568,319 @@ function defaultCostBasisForAgent(agent) {
   return "estimated";
 }
 
+// src/lib/accounts-store.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { z } from "zod";
+import { resolveClientTransport, resolveCredential } from "@hasna/contracts/client";
+var ACCOUNTS_APP = "accounts";
+var profileNameSchema = z.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9-]*$/, "must be lowercase alphanumeric/hyphen and start with a letter or digit");
+var profileSchema = z.object({
+  name: z.string(),
+  tool: z.string(),
+  email: z.string().optional(),
+  displayName: z.string().optional(),
+  dir: z.string(),
+  description: z.string().optional(),
+  createdAt: z.string(),
+  lastUsedAt: z.string().optional()
+});
+var toolDefSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  envVar: z.string(),
+  defaultDir: z.string(),
+  bin: z.string()
+});
+var storeSchema = z.object({
+  version: z.literal(1),
+  current: z.record(z.string(), z.string()).default({}),
+  applied: z.record(z.string(), z.string()).default({}),
+  toolLocks: z.record(z.string(), z.string()).default({}),
+  profiles: z.array(profileSchema).default([]),
+  tools: z.array(toolDefSchema).default([])
+});
+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 join2(homedir2(), ".hasna", "accounts");
+}
+function storePath() {
+  const override = process.env.ACCOUNTS_STORE_PATH;
+  if (override && override.trim())
+    return validateEnvPath(override, "ACCOUNTS_STORE_PATH");
+  return join2(accountsHome(), "accounts.json");
+}
+var EMPTY_STORE = {
+  version: 1,
+  current: {},
+  applied: {},
+  toolLocks: {},
+  profiles: [],
+  tools: []
+};
+function parseStoreFile() {
+  const path = storePath();
+  if (!existsSync2(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: join2(homedir2(), ".claude"), bin: "claude" },
+  { id: "codex-app", label: "Codex App", envVar: "CODEX_HOME", defaultDir: join2(homedir2(), ".codex"), bin: "/Applications/Codex.app/Contents/MacOS/Codex" },
+  { id: "codex", label: "Codex CLI", envVar: "CODEX_HOME", defaultDir: join2(homedir2(), ".codex"), bin: "codex" },
+  { id: "codewith", label: "Codewith", envVar: "CODEWITH_HOME", defaultDir: join2(homedir2(), ".codewith"), bin: "codewith" },
+  { id: "takumi", label: "Takumi", envVar: "TAKUMI_CONFIG_DIR", defaultDir: join2(homedir2(), ".takumi"), bin: "takumi" },
+  { id: "gemini", label: "Gemini CLI", envVar: "GEMINI_CONFIG_DIR", defaultDir: join2(homedir2(), ".gemini"), bin: "gemini" },
+  { id: "opencode", label: "opencode", envVar: "OPENCODE_CONFIG_DIR", defaultDir: join2(homedir2(), ".config", "opencode"), bin: "opencode" },
+  { id: "cursor", label: "Cursor Agent", envVar: "CURSOR_CONFIG_DIR", defaultDir: join2(homedir2(), ".cursor"), bin: "cursor-agent" },
+  { id: "pi", label: "Pi Coding Agent", envVar: "PI_CODING_AGENT_HOME", defaultDir: join2(homedir2(), ".pi"), bin: "pi" },
+  { id: "hermes", label: "Hermes", envVar: "HERMES_HOME", defaultDir: join2(homedir2(), ".hermes"), bin: "hermes" },
+  { id: "kimi", label: "Kimi Code", envVar: "KIMI_CODE_HOME", defaultDir: join2(homedir2(), ".kimi-code"), bin: "kimi" },
+  { id: "grok", label: "Grok Build", envVar: "HOME", defaultDir: join2(homedir2(), ".grok"), bin: "grok" }
+];
+
+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_KEYS = [
+  "HASNA_ACCOUNTS_STORAGE_MODE",
+  "ACCOUNTS_STORAGE_MODE",
+  "HASNA_ACCOUNTS_MODE",
+  "ACCOUNTS_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 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 = {}) {
+  assertNoRetiredStorageMode(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"],
@@ -3550,11 +3952,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);
@@ -3592,8 +3994,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"] ?? join3(homedir3(), ".claude", "projects");
+var TAKUMI_PROJECTS_DIR = process.env["HASNA_ECONOMY_TAKUMI_PROJECTS_DIR"] ?? join3(homedir3(), ".takumi", "projects");
 function dirNameToPath(dirName) {
   return dirName.replace(/^-/, "/").replace(/-/g, "/").replace(/\/\//g, "/-");
 }
@@ -3603,9 +4005,9 @@ function collectJsonlFiles(projectDir) {
     try {
       for (const entry of readdirSync2(dir, { withFileTypes: true })) {
         if (entry.isDirectory())
-          walk(join2(dir, entry.name));
+          walk(join3(dir, entry.name));
         else if (entry.name.endsWith(".jsonl"))
-          files.push(join2(dir, entry.name));
+          files.push(join3(dir, entry.name));
       }
     } catch {}
   }
@@ -3619,7 +4021,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 (!existsSync3(projectsDir)) {
     if (verbose)
       console.log(`${agentName} projects dir not found:`, projectsDir);
     return { files: 0, requests: 0, sessions: 0 };
@@ -3630,9 +4032,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 = join3(projectsDir, projectDirEntry.name);
     const projectPath = dirNameToPath(projectDirEntry.name);
     const jsonlFiles = collectJsonlFiles(projectDirPath);
     for (const filePath of jsonlFiles) {
@@ -3643,12 +4046,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;
@@ -3768,14 +4171,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 existsSync4, readFileSync as readFileSync3 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4, 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 = join4(homedir4(), ".codex", "state_5.sqlite");
+var DEFAULT_CODEX_CONFIG_PATH = join4(homedir4(), ".codex", "config.toml");
+var DEFAULT_CODEWITH_DB_PATH = join4(homedir4(), ".codewith", "state_5.sqlite");
+var DEFAULT_CODEWITH_CONFIG_PATH = join4(homedir4(), ".codewith", "config.toml");
 var CODEX_INGEST_VERSION = "rollout-aggregate-v3";
 function codexDbPath() {
   return process.env["HASNA_ECONOMY_CODEX_DB_PATH"] ?? DEFAULT_CODEX_DB_PATH;
@@ -3817,10 +4220,10 @@ function codexSources() {
   });
 }
 function readCodexModel(configPath = codexConfigPath()) {
-  if (!existsSync3(configPath))
+  if (!existsSync4(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 {
@@ -3858,12 +4261,12 @@ function openCodexDb(dbPath, verbose) {
   return null;
 }
 function readTokenEvents(rolloutPath) {
-  if (!rolloutPath || !existsSync3(rolloutPath))
+  if (!rolloutPath || !existsSync4(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;
@@ -3939,7 +4342,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 (!existsSync4(source.dbPath)) {
       if (verbose)
         console.log(`${source.label} DB not found:`, source.dbPath);
       continue;
@@ -4020,11 +4423,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 existsSync5, statSync as statSync3 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join5, basename as basename3 } from "path";
+var DEFAULT_GEMINI_TMP_DIR = join5(homedir5(), ".gemini", "tmp");
+var DEFAULT_GEMINI_HISTORY_DIR = join5(homedir5(), ".gemini", "history");
 function geminiTmpDir() {
   return process.env["HASNA_ECONOMY_GEMINI_TMP_DIR"] ?? DEFAULT_GEMINI_TMP_DIR;
 }
@@ -4041,12 +4444,12 @@ function numberField(...values) {
 function listProjectDirs(...roots) {
   const dirs = new Set;
   for (const root of roots) {
-    if (!existsSync4(root))
+    if (!existsSync5(root))
       continue;
     try {
       for (const entry of readdirSync3(root, { withFileTypes: true })) {
         if (entry.isDirectory())
-          dirs.add(join4(root, entry.name));
+          dirs.add(join5(root, entry.name));
       }
     } catch {}
   }
@@ -4057,17 +4460,17 @@ function projectRoot(projectDir, chatData) {
     return chatData.projectPath;
   if (chatData.project_path)
     return chatData.project_path;
-  const rootFile = join4(projectDir, ".project_root");
+  const rootFile = join5(projectDir, ".project_root");
   try {
-    if (existsSync4(rootFile))
-      return readFileSync3(rootFile, "utf-8").trim();
+    if (existsSync5(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 (!existsSync5(tmpDir) && !existsSync5(historyDir)) {
     if (verbose)
       console.log("Gemini tmp/history dirs not found:", tmpDir, historyDir);
     return { sessions: 0, requests: 0 };
@@ -4079,17 +4482,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 = join5(projectDir, "chats");
+    if (!existsSync5(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) => join5(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();
@@ -4101,7 +4504,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;
       }
@@ -4179,15 +4582,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 existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join6 } from "path";
+var OPENCODE_STORAGE = join6(homedir6(), ".local", "share", "opencode", "storage");
 function walkJsonFiles(dir, acc = []) {
-  if (!existsSync5(dir))
+  if (!existsSync6(dir))
     return acc;
   for (const entry of readdirSync4(dir, { withFileTypes: true })) {
-    const p = join5(dir, entry.name);
+    const p = join6(dir, entry.name);
     if (entry.isDirectory())
       walkJsonFiles(p, acc);
     else if (entry.name.endsWith(".json"))
@@ -4207,7 +4610,7 @@ function parseSessionIdFromPath(filePath) {
   return null;
 }
 async function ingestOpenCode(db, verbose = false) {
-  const messageDir = join5(OPENCODE_STORAGE, "message");
+  const messageDir = join6(OPENCODE_STORAGE, "message");
   const files = walkJsonFiles(messageDir);
   let requests = 0;
   const touched = new Set;
@@ -4222,7 +4625,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;
     }
@@ -4409,15 +4812,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 existsSync7, readFileSync as readFileSync6, readdirSync as readdirSync5, statSync as statSync5 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join7 } from "path";
+var PI_SESSION_DIR = process.env["PI_CODING_AGENT_SESSION_DIR"] ?? join7(homedir7(), ".pi", "agent", "sessions");
 function walkSessions(dir, acc = []) {
-  if (!existsSync6(dir))
+  if (!existsSync7(dir))
     return acc;
   for (const entry of readdirSync5(dir, { withFileTypes: true })) {
-    const p = join6(dir, entry.name);
+    const p = join7(dir, entry.name);
     if (entry.isDirectory())
       walkSessions(p, acc);
     else if (entry.name.endsWith(".json"))
@@ -4439,7 +4842,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;
     }
@@ -4503,10 +4906,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 existsSync8, statSync as statSync6 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join8 } from "path";
+var HERMES_DB = join8(homedir8(), ".hermes", "state.db");
 function mapCostBasis(billingMode) {
   if (billingMode === "subscription")
     return "subscription_included";
@@ -4515,7 +4918,7 @@ function mapCostBasis(billingMode) {
   return defaultCostBasisForAgent("hermes");
 }
 async function ingestHermes(db, verbose = false) {
-  if (!existsSync7(HERMES_DB)) {
+  if (!existsSync8(HERMES_DB)) {
     return { sessions: 0, requests: 0 };
   }
   const { Database: Sqlite } = await import("bun:sqlite");
@@ -4595,14 +4998,81 @@ 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 existsSync9 } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join9 } from "path";
 import { Database as BunDatabase2 } from "bun:sqlite";
-var DEFAULT_LOOPS_DB_PATH = join8(homedir8(), ".hasna", "loops", "loops.db");
+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 = join9(process.env["HOME"] || process.env["USERPROFILE"] || homedir9(), ".hasna", "loops", "loops.db");
+  return existsSync9(join9(resolved, "loops.db")) ? join9(resolved, "loops.db") : legacy;
+}
 function loopsDbPath() {
-  return process.env["HASNA_ECONOMY_LOOPS_DB_PATH"] ?? DEFAULT_LOOPS_DB_PATH;
+  return process.env["HASNA_ECONOMY_LOOPS_DB_PATH"] ?? defaultLoopsDbPath();
 }
 function loopsModel() {
   return process.env["HASNA_ECONOMY_LOOPS_MODEL"] ?? process.env["ECONOMY_LOOPS_MODEL"] ?? "gpt-5.3-codex";
@@ -4691,7 +5161,7 @@ function readLoopGoalRuns(loopsDb) {
 }
 async function ingestLoops(db, verbose = false) {
   const dbPath = loopsDbPath();
-  if (!existsSync8(dbPath)) {
+  if (!existsSync9(dbPath)) {
     if (verbose)
       console.log("OpenLoops DB not found:", dbPath);
     return { sessions: 0, requests: 0 };
@@ -4781,30 +5251,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 existsSync10, readFileSync as readFileSync7 } from "fs";
 
 // src/lib/paths.ts
-import { homedir as homedir9 } from "os";
-import { join as join9 } from "path";
-function getHomeDir() {
-  return process.env["USERPROFILE"] ?? process.env["HOME"] ?? homedir9();
+import { homedir as homedir10 } from "os";
+import { join as join10 } from "path";
+function getHomeDir2() {
+  return process.env["USERPROFILE"] ?? process.env["HOME"] ?? homedir10();
 }
 function agentPaths() {
-  const home = getHomeDir();
+  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: join10(home, ".claude", "projects"),
+    claudeCredentials: join10(home, ".claude", ".credentials.json"),
+    takumiProjects: join10(home, ".takumi", "projects"),
+    codexDir: join10(home, ".codex"),
+    codexDb: join10(home, ".codex", "state_5.sqlite"),
+    codexAuth: join10(home, ".codex", "auth.json"),
+    codexConfig: join10(home, ".codex", "config.toml"),
+    geminiTmp: join10(home, ".gemini", "tmp"),
+    geminiHistory: join10(home, ".gemini", "history"),
+    opencodeMessages: join10(home, ".local", "share", "opencode", "storage", "message"),
+    piSessions: join10(home, ".pi", "agent", "sessions"),
+    hermesDir: join10(home, ".hermes"),
+    hermesDb: join10(home, ".hermes", "state.db")
   };
 }
 
@@ -4816,10 +5286,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 (!existsSync10(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;
@@ -4955,17 +5425,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 existsSync11, 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 (!existsSync11(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;
@@ -5950,7 +6420,7 @@ init_database();
 
 // src/lib/serve-auth.ts
 function getServeApiToken() {
-  return process.env["ECONOMY_API_TOKEN"] ?? process.env["HASNA_ECONOMY_API_TOKEN"];
+  return process.env["HASNA_ECONOMY_API_TOKEN"];
 }
 function getServeBindHost() {
   const explicit = process.env["ECONOMY_BIND"] ?? process.env["ECONOMY_HOST"];
@@ -5974,13 +6444,11 @@ function isAuthorizedRequest(req, path) {
 
 // src/server/serve.ts
 import { randomUUID } from "crypto";
-import { existsSync as existsSync13 } from "fs";
-import { resolve, sep } from "path";
 // package.json
 var package_default = {
   name: "@hasna/economy",
-  version: "0.3.27",
-  description: "AI coding cost tracker \u2014 CLI + MCP server + REST API + web dashboard for Claude Code, Codex, OpenCode, Cursor, Pi, and Hermes, with legacy Gemini CLI session and Gemini API billing ingestion",
+  version: "0.4.0",
+  description: "AI coding cost tracker \u2014 CLI + MCP server + REST API for Claude Code, Codex, OpenCode, Cursor, Pi, and Hermes, with legacy Gemini CLI session and Gemini API billing ingestion",
   repository: {
     type: "git",
     url: "git+https://github.com/hasna/economy.git"
@@ -6011,7 +6479,7 @@ var package_default = {
   files: [
     "dist",
     "docs",
-    "dashboard/dist",
+    "postinstall.js",
     "LICENSE",
     "README.md",
     "CHANGELOG.md",
@@ -6020,12 +6488,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",
@@ -6034,7 +6501,7 @@ var package_default = {
     "dev:mcp": "bun run src/mcp/index.ts",
     "dev:serve": "bun run src/server/index.ts",
     "dev:otel": "bun run src/otel/index.ts",
-    postinstall: "mkdir -p $HOME/.hasna/economy/training 2>/dev/null || true"
+    postinstall: "node postinstall.js"
   },
   keywords: [
     "economy",
@@ -6055,11 +6522,8 @@ var package_default = {
     access: "public"
   },
   dependencies: {
-    "@hasna/accounts": "0.2.23",
-    "@hasna/agent-registry": "^0.1.0",
-    "@hasna/contracts": "0.13.4",
+    "@hasna/contracts": "1.0.2",
     "@hasna/events": "^0.1.16",
-    "@hasna/mcp-harness": "^0.1.0",
     "@hasna/projects": "1.0.0",
     "@modelcontextprotocol/sdk": "^1.12.1",
     chalk: "^5.4.1",
@@ -6068,7 +6532,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"
@@ -7746,7 +8210,6 @@ var APP = "economy";
 var ECONOMY_WRITE_SCOPE = `${APP}:write`;
 var AGENT_ERROR = `agent must be one of: ${AGENTS.join(", ")}`;
 var SYNC_SOURCES = ["all", ...AGENTS, "loops"];
-var DEFAULT_DASHBOARD_DIR = new URL("../../dashboard/dist", import.meta.url).pathname;
 function json(data, status = 200) {
   return new Response(JSON.stringify(data), {
     status,
@@ -7799,38 +8262,6 @@ function requiredScopesForRequest(method, path) {
 function stringArray(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
-function dashboardPath(root, pathname) {
-  let decoded;
-  try {
-    decoded = decodeURIComponent(pathname);
-  } catch {
-    return null;
-  }
-  const relativePath = decoded === "/" ? "index.html" : decoded.replace(/^\/+/, "");
-  const rootPath = resolve(root);
-  const filePath = resolve(rootPath, relativePath);
-  return filePath === rootPath || filePath.startsWith(rootPath + sep) ? filePath : null;
-}
-var FOUNDATION_PATHS = new Set(["/health", "/healthz", "/ready", "/readyz", "/version", "/openapi.json"]);
-function createServerFetch(apiHandler, dashboardDir = DEFAULT_DASHBOARD_DIR) {
-  return async function fetch2(req) {
-    const url = new URL(req.url);
-    if (url.pathname.startsWith("/api") || url.pathname.startsWith("/v1") || FOUNDATION_PATHS.has(url.pathname)) {
-      return apiHandler(req);
-    }
-    if (existsSync13(dashboardDir)) {
-      const filePath = dashboardPath(dashboardDir, url.pathname);
-      if (filePath && existsSync13(filePath)) {
-        return new Response(Bun.file(filePath));
-      }
-      const indexPath = dashboardPath(dashboardDir, "/");
-      if (indexPath && existsSync13(indexPath)) {
-        return new Response(Bun.file(indexPath));
-      }
-    }
-    return apiHandler(req);
-  };
-}
 function applyFields(obj, fields) {
   if (!fields || fields.length === 0)
     return obj;
@@ -8354,7 +8785,7 @@ function startServer(port = 3456, options = {}) {
   const server = Bun.serve({
     port,
     hostname: hostname2,
-    fetch: createServerFetch(apiHandler, options.dashboardDir)
+    fetch: apiHandler
   });
   const address = `http://${hostname2 === "0.0.0.0" ? "localhost" : hostname2}:${server.port}`;
   log(`economy-serve listening on ${address}`);