@hasna/economy 0.5.3 → 0.5.5

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.5.5
+
+### Patch Changes
+
+- Read Codex and Claude usage and quota credentials from their selected native profile directories while preserving explicit Economy source overrides. A missing selected profile stays missing instead of reading another account's default directory. An explicitly selected Codex profile includes the legacy Codewith reader only when its source is explicitly configured too.
+
+## 0.5.4
+
+### Patch Changes
+
+- Resolve account attribution through the current hosted Subscriptions client using its station-local paths and applied bindings. Preserve explicit legacy Accounts connections, reject ambiguous bindings, and avoid attributing an unmatched local profile to another station's shared selection.
+
 ## 0.5.3
 
 ### Patch Changes

package/README.md

@@ -9,7 +9,7 @@ AI coding cost tracker for Claude Code, Takumi, Codex, Gemini, OpenCode, Cursor,
 
 - Ingests local Claude Code, Takumi, Codex, Gemini, OpenCode, Cursor, Pi, and Hermes usage.
 - Tracks sessions, requests, projects, machines, models, cache tokens, cost centers, budgets, goals, and provider billing.
-- Attributes usage to `@hasna/accounts` profiles when agents run under managed account/profile config dirs.
+- Attributes usage to hosted Subscriptions profiles using their station-local configuration directories or applied bindings; explicit legacy Accounts connections remain supported.
 - Breaks down API-equivalent, metered API, subscription-included, estimated, and unknown cost by account, coding agent, and cost center.
 - Seeds editable model pricing with input, output, cache-read, 5-minute cache-write, 1-hour cache-write, and context-cache storage rates.
 - Handles tiered pricing such as Gemini long-prompt rates and OpenAI long-context rates.
@@ -128,9 +128,13 @@ economy sync --recalculate
 economy sync --backfill-machine
 ```
 
-Full sync also imports active project metadata from `@hasna/projects` when the registry is available. The Codex source reads both `~/.codex/state_5.sqlite` and the Codewith store at `~/.codewith/state_5.sqlite` by default; explicit `HASNA_ECONOMY_CODEX_DB_PATH` and `HASNA_ECONOMY_CODEWITH_DB_PATH` values override those locations.
+Full sync also imports active project metadata from `@hasna/projects` when the registry is available. Codex reads `CODEX_HOME/state_5.sqlite` and Claude reads `CLAUDE_CONFIG_DIR/projects` when those native profile directories are set; otherwise they use `~/.codex/state_5.sqlite` and `~/.claude/projects`. Explicit `HASNA_ECONOMY_CODEX_DB_PATH` and `HASNA_ECONOMY_CLAUDE_PROJECTS_DIR` overrides take precedence. Codex configuration follows `CODEX_HOME/config.toml` unless `HASNA_ECONOMY_CODEX_CONFIG_PATH` is set. Quota credentials follow those same native profile directories, retaining the existing OAuth-token environment overrides. A missing selected source or credential is reported as missing, without falling back to another profile.
 
-Account attribution is automatic when the accounts API (`HASNA_ACCOUNTS_API_KEY`, the accounts credentials file, or the Keychain item `hasna.credentials.accounts.api-key`) resolves a matching active, applied, or env-dir profile for the agent. With **no** accounts credential the on-box registry `~/.hasna/accounts/accounts.json` is **not** read unless `HASNA_ECONOMY_LOCAL=1` is set: attribution is simply omitted, announced once on stderr, rather than filling hosted rows from an on-box file. Account identity is the email address plus coding agent, so `work@example.com` under Codex and Claude is reported as two accounts. You can also force attribution for a process with `ECONOMY_ACCOUNT=tool:name` or agent-specific overrides such as `ECONOMY_CODEX_ACCOUNT=codex:work`.
+The existing Codewith compatibility reader uses `~/.codewith/state_5.sqlite`, with `HASNA_ECONOMY_CODEWITH_DB_PATH` as its explicit override. When `CODEX_HOME` or `HASNA_ECONOMY_CODEX_DB_PATH` explicitly selects a Codex source, the compatibility reader runs only if `HASNA_ECONOMY_CODEWITH_DB_PATH` is also set.
+
+Account attribution uses the hosted Subscriptions registry through the installed `subscriptions` CLI and its own credential resolver. Economy reads `subscriptions list --json` and `subscriptions tools list --json` once per resolution, retaining the owning package's station-local paths and applied bindings. It does not activate a profile or copy credentials. A matching explicit agent directory takes precedence; an unmatched or ambiguous directory cannot inherit another profile. With no explicit directory, a station's applied binding can supply attribution; the shared registry's current selection alone cannot identify the local account.
+
+An explicitly configured legacy Accounts connection (`HASNA_ACCOUNTS_API_KEY`, its credentials file or Keychain entry) keeps its authority and compatibility behavior. A configured but unusable legacy or Subscriptions connection fails closed. If neither is configured, `~/.hasna/accounts/accounts.json` is **not** read unless `HASNA_ECONOMY_LOCAL=1` is set; attribution is omitted with a diagnostic. The Subscriptions CLI is required when using its registry. Profile counts are not paid-subscription counts, and this read path does not create subscription fees or backfill historical usage. Account identity remains email plus coding agent (profile name when email is unknown). Explicit process overrides such as `ECONOMY_ACCOUNT=tool:name` or `ECONOMY_CODEX_ACCOUNT=codex:work` still take precedence.
 
 Session drilldown can be scoped to an account key, account name, or email:
 

package/dist/chunks/{index-s9mvven6.js → index-61c0vz9p.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   LOCAL_STORAGE_OPT_IN_KEYS
-} from "./index-1vz1arz5.js";
+} from "./index-pnnqdv3r.js";
 import {
   assessCostFromDb,
   getIngestState,
@@ -71,41 +71,148 @@ function sourceTimeMillis(value) {
 
 // src/ingest/claude.ts
 import { readdirSync, readFileSync as readFileSync2, existsSync as existsSync2, statSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2, basename } from "path";
+import { homedir as homedir3 } from "os";
+import { join as join3, basename } from "path";
 
 // src/lib/accounts-store.ts
 import { existsSync, readFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
-import { z } from "zod";
+import { z as z2 } 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");
+
+// src/lib/subscriptions-registry.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { isAbsolute } from "path";
+import { z } from "zod";
+var execute = promisify(execFile);
+var readSubscriptionsMetadata = async (args, env) => {
+  let stdout;
+  try {
+    const result = await execute("subscriptions", args, {
+      env,
+      encoding: "utf8",
+      timeout: 30000,
+      maxBuffer: 16 * 1024 * 1024,
+      windowsHide: true
+    });
+    stdout = result.stdout;
+  } catch (error) {
+    const code = error?.code;
+    if (code === "ENOENT")
+      throw new Error("subscriptions: CLI not found on PATH; install the Subscriptions CLI to resolve station account metadata");
+    const status = typeof code === "number" && Number.isInteger(code) ? `exit ${code}` : "execution limit or transport failure";
+    throw new Error(`subscriptions: read-only metadata command failed (${status}); verify the installed CLI and its hosted credentials`);
+  }
+  try {
+    return JSON.parse(stdout);
+  } catch {
+    throw new Error("subscriptions: metadata command returned invalid JSON");
+  }
+};
+var nonempty = z.string().min(1);
 var profileSchema = z.object({
-  name: z.string(),
-  tool: z.string(),
+  name: nonempty,
+  tool: nonempty,
   email: z.string().optional(),
   displayName: z.string().optional(),
-  dir: z.string(),
+  dir: nonempty.refine(isAbsolute).refine((value) => !/[\0\r\n]/.test(value)),
+  createdAt: nonempty,
+  lastUsedAt: z.string().optional(),
   description: z.string().optional(),
-  createdAt: z.string(),
-  lastUsedAt: z.string().optional()
+  active: z.boolean(),
+  applied: z.boolean(),
+  switchedAway: z.object({ profile: nonempty, email: z.string().optional() }).optional()
+});
+var toolsSchema = z.array(z.object({
+  id: nonempty,
+  label: nonempty,
+  envVar: nonempty,
+  defaultDir: nonempty,
+  bin: nonempty
+}));
+function unique(rows, identity) {
+  if (new Set(rows.map(identity)).size !== rows.length) {
+    throw new Error("subscriptions: duplicate identity in metadata response");
+  }
+  return rows;
+}
+
+class SubscriptionsRegistry {
+  read;
+  transport = "api";
+  registry = "subscriptions";
+  env;
+  profiles;
+  tools;
+  constructor(baseUrl, env, read = readSubscriptionsMetadata) {
+    this.read = read;
+    this.env = { ...env, HASNA_SUBSCRIPTIONS_API_URL: baseUrl.replace(/\/v1\/?$/, "") };
+  }
+  allProfiles() {
+    return this.profiles ??= this.read(["list", "--json"], this.env).then((raw) => {
+      const parsed = z.array(profileSchema).safeParse(raw);
+      if (!parsed.success)
+        throw new Error("subscriptions: invalid profile metadata response");
+      return unique(parsed.data, (row) => JSON.stringify([row.tool, row.name]));
+    });
+  }
+  async listProfiles(tool) {
+    const rows = await this.allProfiles();
+    return rows.filter((row) => !tool || row.tool === tool);
+  }
+  async findProfile(name, tool) {
+    const matches = (await this.listProfiles(tool)).filter((row) => row.name === name);
+    return matches.length === 1 ? matches[0] : undefined;
+  }
+  async appliedProfile(tool) {
+    const matches = (await this.allProfiles()).filter((row) => row.tool === tool && row.applied);
+    if (matches.length > 1)
+      throw new Error("subscriptions: ambiguous station applied-profile binding");
+    return matches[0];
+  }
+  async currentProfile(_tool) {
+    return;
+  }
+  async listTools() {
+    return this.tools ??= this.read(["tools", "list", "--json"], this.env).then((raw) => {
+      const parsed = toolsSchema.safeParse(raw);
+      if (!parsed.success)
+        throw new Error("subscriptions: invalid tool metadata response");
+      return unique(parsed.data, (row) => row.id);
+    });
+  }
+}
+
+// src/lib/accounts-store.ts
+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 profileSchema2 = 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(),
+  switchedAway: z2.object({ profile: z2.string().min(1), email: z2.string().optional() }).optional()
 });
-var toolDefSchema = z.object({
-  id: z.string(),
-  label: z.string(),
-  envVar: z.string(),
-  defaultDir: z.string(),
-  bin: z.string()
+var toolDefSchema = z2.object({
+  id: z2.string(),
+  label: z2.string(),
+  envVar: z2.string(),
+  defaultDir: z2.string(),
+  bin: z2.string()
 });
-var storeSchema = z.object({
-  version: z.literal(1),
-  current: z.record(z.string(), z.string()).default({}),
-  applied: z.record(z.string(), z.string()).default({}),
-  toolLocks: z.record(z.string(), z.string()).default({}),
-  profiles: z.array(profileSchema).default([]),
-  tools: z.array(toolDefSchema).default([])
+var 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(profileSchema2).default([]),
+  tools: z2.array(toolDefSchema).default([])
 });
 function localRegistryAllowed(env = process.env) {
   return LOCAL_STORAGE_OPT_IN_KEYS.some((key) => {
@@ -387,25 +494,34 @@ class ApiStore {
   }
 }
 function resolveStore(env = process.env, options = {}) {
+  const legacy = resolveRegistryTransport(ACCOUNTS_APP, env, options.credentials);
+  if (legacy)
+    return new ApiStore(legacy.baseUrl, legacy.apiKey);
+  const current = resolveRegistryTransport("subscriptions", env, options.subscriptionsCredentials);
+  if (current)
+    return new SubscriptionsRegistry(current.baseUrl, env, options.readSubscriptionsMetadata);
+  return unconfiguredStore(env);
+}
+function resolveRegistryTransport(app, env, credentials) {
   const clientEnv = env;
-  const credential = resolveCredential(ACCOUNTS_APP, clientEnv, options.credentials);
+  const credential = resolveCredential(app, clientEnv, credentials);
   if (credential === null) {
     try {
-      resolveClientTransport(ACCOUNTS_APP, clientEnv, options.credentials ? { credentials: options.credentials } : {});
+      resolveClientTransport(app, clientEnv, credentials ? { credentials } : {});
     } catch (err) {
       if (isNoAccountsCredentialConfigurationError(err))
-        return unconfiguredStore(env);
+        return null;
       throw err;
     }
-    return unconfiguredStore(env);
+    return null;
   }
   if (credential.tier === "pointer") {
-    throw new Error(`accounts: ${credential.source} names a secrets-vault item, and the local accounts API store resolves ` + "credentials synchronously, so it cannot complete the pointer per request. It is a deliberate " + "selection and is not resolved around. Use a literal tier instead \u2014 the Keychain item " + "hasna.credentials.accounts.api-key, ~/.hasna/accounts/config/credentials, or HASNA_ACCOUNTS_API_KEY.");
+    throw new Error(`${app}: ${credential.source} names a secrets-vault item, and the registry adapter resolves ` + "credentials synchronously, so it cannot complete the pointer per request. It is a deliberate " + "selection and is not resolved around. Use a literal tier instead \u2014 the Keychain item " + `hasna.credentials.${app}.api-key, ~/.hasna/${app}/config/credentials, or HASNA_${app.toUpperCase()}_API_KEY.`);
   }
-  const resolution = resolveClientTransport(ACCOUNTS_APP, clientEnv, {
-    credentials: { ...options.credentials, apiKey: credential.apiKey }
+  const resolution = resolveClientTransport(app, clientEnv, {
+    credentials: { ...credentials, apiKey: credential.apiKey }
   });
-  return new ApiStore(resolution.baseUrl, credential.apiKey);
+  return { baseUrl: resolution.baseUrl, apiKey: credential.apiKey };
 }
 function isNoAccountsCredentialConfigurationError(error) {
   if (typeof error !== "object" || error === null)
@@ -422,10 +538,10 @@ function unconfiguredStore(env) {
   return new NoRegistryStore;
 }
 function accountsLocalModeNotice() {
-  return `accounts: LOCAL mode (${LOCAL_STORAGE_OPT_IN_KEYS[0]}=1) \u2014 no Hasna Accounts credential resolved, so ` + "attribution reads the on-box JSON registry (~/.hasna/accounts/accounts.json) instead of accounts-serve. " + "To go hosted, put the fleet key in the Keychain item hasna.credentials.accounts.api-key, write " + "~/.hasna/accounts/config/credentials, or set HASNA_ACCOUNTS_API_KEY.";
+  return `accounts: LOCAL mode (${LOCAL_STORAGE_OPT_IN_KEYS[0]}=1) \u2014 neither Accounts nor Subscriptions credentials resolved, so ` + "attribution reads the on-box JSON registry (~/.hasna/accounts/accounts.json) instead of accounts-serve. " + "For hosted attribution, configure the Subscriptions CLI through its normal sign-in or credential resolver.";
 }
 function accountsRefusalNotice() {
-  return "accounts: no Hasna Accounts credential resolved (Keychain item hasna.credentials.accounts.api-key, " + "~/.hasna/accounts/config/credentials, HASNA_ACCOUNTS_API_KEY), so spend attribution is omitted. The " + `on-box registry (~/.hasna/accounts/accounts.json) is NOT read without ${LOCAL_STORAGE_OPT_IN_KEYS[0]}=1 \u2014 ` + "economy fails closed instead of attributing hosted spend from an on-box file.";
+  return "accounts: neither Accounts nor Subscriptions credentials resolved (legacy hasna.credentials.accounts.api-key, " + "~/.hasna/accounts/config/credentials, HASNA_ACCOUNTS_API_KEY; current hasna.credentials.subscriptions.api-key, " + "~/.hasna/subscriptions/config/credentials, HASNA_SUBSCRIPTIONS_API_KEY), so spend attribution is omitted. The " + `on-box registry (~/.hasna/accounts/accounts.json) is NOT read without ${LOCAL_STORAGE_OPT_IN_KEYS[0]}=1 \u2014 ` + "economy fails closed instead of attributing hosted spend from an on-box file.";
 }
 var accountsLocalNoticePrinted = false;
 function announceAccountsLocalMode() {
@@ -513,7 +629,10 @@ async function profileForEnvDir(store, tool, env) {
   if (!configuredDir)
     return null;
   const normalized = normalizeDir(configuredDir);
-  return (await store.listProfiles(tool.id)).find((profile) => normalizeDir(profile.dir) === normalized) ?? null;
+  const matches = (await store.listProfiles(tool.id)).filter((profile) => normalizeDir(profile.dir) === normalized);
+  if (matches.length > 1)
+    throw new Error("account attribution: multiple profiles match the configured directory");
+  return matches[0] ?? null;
 }
 async function resolveAccountForAgent(agent, env = process.env, options = {}) {
   const override = envOverride(agent, env);
@@ -527,8 +646,15 @@ async function resolveAccountForAgent(agent, env = process.env, options = {}) {
       continue;
     const envProfile = await profileForEnvDir(store, tool, env);
     if (envProfile)
-      return fromProfile(envProfile, "env");
-    const appliedName = appliedProfileName(toolId);
+      return envProfile.switchedAway ? null : fromProfile(envProfile, "env");
+    if (store.registry === "subscriptions" && env[tool.envVar])
+      return null;
+    if (store.appliedProfile) {
+      const applied = await store.appliedProfile(toolId);
+      if (applied)
+        return applied.switchedAway ? null : fromProfile(applied, "applied");
+    }
+    const appliedName = store.registry === "subscriptions" ? undefined : appliedProfileName(toolId);
     if (appliedName) {
       const applied = await store.findProfile(appliedName, toolId);
       if (applied)
@@ -553,12 +679,41 @@ function withAccount(record, account) {
   };
 }
 
+// src/lib/paths.ts
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+function getHomeDir() {
+  return process.env["USERPROFILE"] ?? process.env["HOME"] ?? homedir2();
+}
+function agentPaths() {
+  const home = getHomeDir();
+  const claudeHome = process.env["CLAUDE_CONFIG_DIR"] || join2(home, ".claude");
+  const codexHome = process.env["CODEX_HOME"] || join2(home, ".codex");
+  return {
+    claudeProjects: join2(claudeHome, "projects"),
+    claudeCredentials: join2(claudeHome, ".credentials.json"),
+    takumiProjects: join2(home, ".takumi", "projects"),
+    codexDir: codexHome,
+    codexDb: join2(codexHome, "state_5.sqlite"),
+    codexAuth: join2(codexHome, "auth.json"),
+    codexConfig: join2(codexHome, "config.toml"),
+    geminiTmp: join2(home, ".gemini", "tmp"),
+    geminiHistory: join2(home, ".gemini", "history"),
+    opencodeMessages: join2(home, ".local", "share", "opencode", "storage", "message"),
+    piSessions: join2(home, ".pi", "agent", "sessions"),
+    hermesDir: join2(home, ".hermes"),
+    hermesDb: join2(home, ".hermes", "state.db")
+  };
+}
+
 // src/ingest/claude.ts
 function autoDetectProject(cwd, projects) {
   return projects.find((p) => cwd === p.path || cwd.startsWith(p.path + "/"));
 }
-var CLAUDE_PROJECTS_DIR = process.env["HASNA_ECONOMY_CLAUDE_PROJECTS_DIR"] ?? join2(homedir2(), ".claude", "projects");
-var TAKUMI_PROJECTS_DIR = process.env["HASNA_ECONOMY_TAKUMI_PROJECTS_DIR"] ?? join2(homedir2(), ".takumi", "projects");
+var TAKUMI_PROJECTS_DIR = process.env["HASNA_ECONOMY_TAKUMI_PROJECTS_DIR"] ?? join3(homedir3(), ".takumi", "projects");
+function claudeProjectsDir() {
+  return process.env["HASNA_ECONOMY_CLAUDE_PROJECTS_DIR"] ?? agentPaths().claudeProjects;
+}
 function dirNameToPath(dirName) {
   return dirName.replace(/^-/, "/").replace(/-/g, "/").replace(/\/\//g, "/-");
 }
@@ -568,9 +723,9 @@ function collectJsonlFiles(projectDir) {
     try {
       for (const entry of readdirSync(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 {
       collectionProblem("failed", "source_unreadable");
@@ -579,7 +734,7 @@ function collectJsonlFiles(projectDir) {
   walk(projectDir);
   return files;
 }
-async function ingestClaude(db, verbose = false, projectsDir = CLAUDE_PROJECTS_DIR) {
+async function ingestClaude(db, verbose = false, projectsDir = claudeProjectsDir()) {
   return ingestJsonlProjects(db, projectsDir, "claude", verbose);
 }
 async function ingestTakumi(db, verbose = false, projectsDir = TAKUMI_PROJECTS_DIR) {
@@ -601,7 +756,7 @@ async function ingestJsonlProjects(db, projectsDir, agentName, verbose = false)
   const ingestState = loadIngestState(db, agentName);
   const projectDirs = readdirSync(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) {
@@ -750,24 +905,19 @@ function supportsClaudeDataResidencyPricing(model) {
 // src/ingest/codex.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
 import { createHash } from "crypto";
-import { homedir as homedir3 } from "os";
-import { join as join3, basename as basename2 } from "path";
-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");
+import { join as join4, basename as basename2 } from "path";
 var CODEX_INGEST_VERSION = "rollout-events-v4";
 function codexDbPath() {
-  return process.env["HASNA_ECONOMY_CODEX_DB_PATH"] ?? DEFAULT_CODEX_DB_PATH;
+  return process.env["HASNA_ECONOMY_CODEX_DB_PATH"] ?? agentPaths().codexDb;
 }
 function codexConfigPath() {
-  return process.env["HASNA_ECONOMY_CODEX_CONFIG_PATH"] ?? DEFAULT_CODEX_CONFIG_PATH;
+  return process.env["HASNA_ECONOMY_CODEX_CONFIG_PATH"] ?? agentPaths().codexConfig;
 }
 function codewithDbPath() {
-  return process.env["HASNA_ECONOMY_CODEWITH_DB_PATH"] ?? DEFAULT_CODEWITH_DB_PATH;
+  return process.env["HASNA_ECONOMY_CODEWITH_DB_PATH"] ?? join4(getHomeDir(), ".codewith", "state_5.sqlite");
 }
 function codewithConfigPath() {
-  return process.env["HASNA_ECONOMY_CODEWITH_CONFIG_PATH"] ?? DEFAULT_CODEWITH_CONFIG_PATH;
+  return process.env["HASNA_ECONOMY_CODEWITH_CONFIG_PATH"] ?? join4(getHomeDir(), ".codewith", "config.toml");
 }
 function codexSources() {
   const explicitCodexPath = process.env["HASNA_ECONOMY_CODEX_DB_PATH"];
@@ -779,7 +929,7 @@ function codexSources() {
     sessionPrefix: "codex",
     stateSource: "codex"
   }];
-  if (!explicitCodexPath || explicitCodewithPath) {
+  if (!explicitCodexPath && !process.env["CODEX_HOME"] || explicitCodewithPath) {
     sources.push({
       label: "Codewith",
       dbPath: codewithDbPath(),
@@ -1017,9 +1167,9 @@ async function ingestCodex(db, verbose = false) {
 // src/ingest/gemini.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync4, 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 { join as join5, basename as basename3 } from "path";
+var DEFAULT_GEMINI_TMP_DIR = join5(homedir4(), ".gemini", "tmp");
+var DEFAULT_GEMINI_HISTORY_DIR = join5(homedir4(), ".gemini", "history");
 function geminiTmpDir() {
   return process.env["HASNA_ECONOMY_GEMINI_TMP_DIR"] ?? DEFAULT_GEMINI_TMP_DIR;
 }
@@ -1041,7 +1191,7 @@ function listProjectDirs(...roots) {
     try {
       for (const entry of readdirSync2(root, { withFileTypes: true })) {
         if (entry.isDirectory())
-          dirs.add(join4(root, entry.name));
+          dirs.add(join5(root, entry.name));
       }
     } catch {
       collectionProblem("failed", "source_unreadable");
@@ -1054,7 +1204,7 @@ 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 readFileSync4(rootFile, "utf-8").trim();
@@ -1079,12 +1229,12 @@ 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");
+    const chatsDir = join5(projectDir, "chats");
     if (!existsSync4(chatsDir))
       continue;
     let chatFiles = [];
     try {
-      chatFiles = readdirSync2(chatsDir).filter((f) => f.endsWith(".json")).map((f) => join4(chatsDir, f));
+      chatFiles = readdirSync2(chatsDir).filter((f) => f.endsWith(".json")).map((f) => join5(chatsDir, f));
     } catch {
       collectionProblem("failed", "source_unreadable");
       continue;
@@ -1194,13 +1344,13 @@ async function ingestGemini(db, verbose) {
 // src/ingest/opencode.ts
 import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync as readdirSync3, 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 { join as join6 } from "path";
+var OPENCODE_STORAGE = join6(homedir5(), ".local", "share", "opencode", "storage");
 function walkJsonFiles(dir, acc = []) {
   if (!existsSync5(dir))
     return acc;
   for (const entry of readdirSync3(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"))
@@ -1220,7 +1370,7 @@ function parseSessionIdFromPath(filePath) {
   return null;
 }
 async function ingestOpenCode(db, verbose = false, sourceDir = OPENCODE_STORAGE) {
-  const messageDir = join5(sourceDir, "message");
+  const messageDir = join6(sourceDir, "message");
   if (!existsSync5(messageDir))
     collectionProblem("missing", "source_missing");
   const files = walkJsonFiles(messageDir);
@@ -1412,13 +1562,13 @@ async function ingestCursor(db, verbose = false) {
 // src/ingest/pi.ts
 import { existsSync as existsSync6, readFileSync as readFileSync6, readdirSync as readdirSync4, 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 { join as join7 } from "path";
+var PI_SESSION_DIR = process.env["PI_CODING_AGENT_SESSION_DIR"] ?? join7(homedir6(), ".pi", "agent", "sessions");
 function walkSessions(dir, acc = []) {
   if (!existsSync6(dir))
     return acc;
   for (const entry of readdirSync4(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"))
@@ -1518,8 +1668,8 @@ async function ingestPi(db, verbose = false, sourceDir = PI_SESSION_DIR) {
 // src/ingest/hermes.ts
 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 { join as join8 } from "path";
+var HERMES_DB = join8(homedir7(), ".hermes", "state.db");
 async function ingestHermes(db, verbose = false, sourcePath = HERMES_DB) {
   if (!existsSync7(sourcePath)) {
     collectionProblem("missing", "source_missing");
@@ -1587,7 +1737,7 @@ function statSyncSafe(path) {
 // src/ingest/loops.ts
 import { existsSync as existsSync8 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 import { homedir as pathsResolverHomedir } from "os";
 import { join as pathsResolverJoin } from "path";
 var PATHS_RESOLVER_KIND_ENV = {
@@ -1654,8 +1804,8 @@ function defaultLoopsDbPath() {
     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 = join9(process.env["HOME"] || process.env["USERPROFILE"] || homedir8(), ".hasna", "loops", "loops.db");
+  return existsSync8(join9(resolved, "loops.db")) ? join9(resolved, "loops.db") : legacy;
 }
 function loopsDbPath() {
   return process.env["HASNA_ECONOMY_LOOPS_DB_PATH"] ?? defaultLoopsDbPath();
@@ -1839,33 +1989,6 @@ async function ingestLoops(db, verbose = false) {
 
 // src/ingest/claude-quota.ts
 import { existsSync as existsSync9, 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();
-}
-function agentPaths() {
-  const home = getHomeDir();
-  return {
-    claudeProjects: join9(home, ".claude", "projects"),
-    claudeCredentials: join9(home, ".claude", ".credentials.json"),
-    takumiProjects: join9(home, ".takumi", "projects"),
-    codexDir: join9(home, ".codex"),
-    codexDb: join9(home, ".codex", "state_5.sqlite"),
-    codexAuth: join9(home, ".codex", "auth.json"),
-    codexConfig: join9(home, ".codex", "config.toml"),
-    geminiTmp: join9(home, ".gemini", "tmp"),
-    geminiHistory: join9(home, ".gemini", "history"),
-    opencodeMessages: join9(home, ".local", "share", "opencode", "storage", "message"),
-    piSessions: join9(home, ".pi", "agent", "sessions"),
-    hermesDir: join9(home, ".hermes"),
-    hermesDb: join9(home, ".hermes", "state.db")
-  };
-}
-
-// src/ingest/claude-quota.ts
 var USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
 var OAUTH_BETA = "oauth-2025-04-20";
 function readClaudeToken() {

package/dist/chunks/{index-bn04v378.js → index-7k1xt8mj.js}

@@ -4,7 +4,7 @@ import {
 } from "./index-w3bvv0ns.js";
 import {
   getStore
-} from "./index-mhrkwvtk.js";
+} from "./index-z9psed59.js";
 import {
   formatReportedUsd,
   formatSummaryCoverage,

package/dist/chunks/{index-1vz1arz5.js → index-pnnqdv3r.js}

@@ -20,7 +20,7 @@ import {
 // package.json
 var package_default = {
   name: "@hasna/economy",
-  version: "0.5.3",
+  version: "0.5.5",
   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",

package/dist/chunks/{index-mhrkwvtk.js → index-z9psed59.js}

@@ -14,7 +14,7 @@ import {
   querySavingsSummary,
   requireCurrentBillingDiffSummary,
   requireCurrentSavingsReport
-} from "./index-1vz1arz5.js";
+} from "./index-pnnqdv3r.js";
 import {
   deleteBudget,
   deleteGoal,

package/dist/chunks/{serve-8yqe7nhs.js → serve-zp5a3qzw.js}

@@ -5,7 +5,7 @@ import {
 } from "./index-w3bvv0ns.js";
 import {
   syncAll
-} from "./index-s9mvven6.js";
+} from "./index-61c0vz9p.js";
 import {
   buildBrief,
   packageMetadata,
@@ -16,7 +16,7 @@ import {
   queryProjectDetail,
   queryRangeStats,
   querySavingsSummary
-} from "./index-1vz1arz5.js";
+} from "./index-pnnqdv3r.js";
 import {
   AGENTS,
   INGEST_SCHEMA_SQL,

package/dist/chunks/{tui-fe94bvp9.js → tui-2yea642b.js}

@@ -6,10 +6,10 @@ import {
   printStatusLine,
   printWaybarJson,
   runTui
-} from "./index-bn04v378.js";
+} from "./index-7k1xt8mj.js";
 import"./index-w3bvv0ns.js";
-import"./index-mhrkwvtk.js";
-import"./index-1vz1arz5.js";
+import"./index-z9psed59.js";
+import"./index-pnnqdv3r.js";
 import"./index-f5jv6q5q.js";
 import"./index-p35cyhc4.js";
 export {