@hasna/economy 0.2.36 → 0.2.37

package/README.md

@@ -102,7 +102,7 @@ economy sync --recalculate
 economy sync --backfill-machine
 ```
 
-Full sync also imports active project metadata from `@hasna/projects` when the registry is available.
+Full sync also imports active project metadata from `@hasna/projects` when the registry is available. The Codex source reads both legacy `~/.codex/state_5.sqlite` and current Codewith `~/.codewith/state_5.sqlite` usage stores by default; explicit `HASNA_ECONOMY_CODEX_DB_PATH` and `HASNA_ECONOMY_CODEWITH_DB_PATH` values override those locations.
 
 Account attribution is automatic when `@hasna/accounts` has a matching active, applied, or env-dir profile for the agent. 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`.
 

package/dist/cli/index.js

@@ -2766,8 +2766,40 @@ function codexDbPath() {
 function codexConfigPath() {
   return process.env["HASNA_ECONOMY_CODEX_CONFIG_PATH"] ?? DEFAULT_CODEX_CONFIG_PATH;
 }
-function readCodexModel() {
-  const configPath = codexConfigPath();
+function codewithDbPath() {
+  return process.env["HASNA_ECONOMY_CODEWITH_DB_PATH"] ?? DEFAULT_CODEWITH_DB_PATH;
+}
+function codewithConfigPath() {
+  return process.env["HASNA_ECONOMY_CODEWITH_CONFIG_PATH"] ?? DEFAULT_CODEWITH_CONFIG_PATH;
+}
+function codexSources() {
+  const explicitCodexPath = process.env["HASNA_ECONOMY_CODEX_DB_PATH"];
+  const explicitCodewithPath = process.env["HASNA_ECONOMY_CODEWITH_DB_PATH"];
+  const sources = [{
+    label: "Codex",
+    dbPath: codexDbPath(),
+    configPath: codexConfigPath(),
+    sessionPrefix: "codex",
+    stateSource: "codex"
+  }];
+  if (!explicitCodexPath || explicitCodewithPath) {
+    sources.push({
+      label: "Codewith",
+      dbPath: codewithDbPath(),
+      configPath: codewithConfigPath(),
+      sessionPrefix: "codex-codewith",
+      stateSource: "codex-codewith"
+    });
+  }
+  const seen = new Set;
+  return sources.filter((source) => {
+    if (seen.has(source.dbPath))
+      return false;
+    seen.add(source.dbPath);
+    return true;
+  });
+}
+function readCodexModel(configPath = codexConfigPath()) {
   if (!existsSync5(configPath))
     return "gpt-5-codex";
   try {
@@ -2885,94 +2917,97 @@ function fallbackEvents(totalTokens) {
   }];
 }
 async function ingestCodex(db, verbose = false) {
-  const dbPath = codexDbPath();
-  if (!existsSync5(dbPath)) {
-    if (verbose)
-      console.log("Codex DB not found:", dbPath);
-    return { sessions: 0, requests: 0 };
-  }
   const machineId = getMachineId();
-  let codexDb = null;
   let ingested = 0;
   let requests = 0;
   const account = await resolveAccountForAgent("codex");
-  try {
-    codexDb = openCodexDb(dbPath, verbose);
-    if (!codexDb)
-      return { sessions: 0, requests: 0 };
-    const threads = codexDb.prepare(buildThreadQuery(codexDb)).all();
-    for (const thread of threads) {
-      const model = thread.model ?? readCodexModel();
-      const stateValue = `${CODEX_INGEST_VERSION}:${thread.updated_at}:${thread.tokens_used}:${model}`;
-      const processed = getIngestState(db, "codex", thread.id);
-      if (processed === stateValue)
+  for (const source of codexSources()) {
+    if (!existsSync5(source.dbPath)) {
+      if (verbose)
+        console.log(`${source.label} DB not found:`, source.dbPath);
+      continue;
+    }
+    let codexDb = null;
+    try {
+      codexDb = openCodexDb(source.dbPath, verbose);
+      if (!codexDb)
         continue;
-      const projectPath = thread.cwd ?? "";
-      const projectName = projectPath ? basename2(projectPath) : "unknown";
-      const sessionId = `codex-${thread.id}`;
-      const startedAt = thread.created_at ? new Date(thread.created_at * 1000).toISOString() : new Date().toISOString();
-      const endedAt = thread.updated_at ? new Date(thread.updated_at * 1000).toISOString() : null;
-      upsertSession(db, withAccount({
-        id: sessionId,
-        agent: "codex",
-        project_path: projectPath,
-        project_name: projectName,
-        started_at: startedAt,
-        ended_at: endedAt,
-        total_cost_usd: 0,
-        total_tokens: 0,
-        request_count: 0,
-        machine_id: machineId
-      }, account));
-      const events = readTokenEvents(thread.rollout_path);
-      const tokenEvents = events.length > 0 ? events : fallbackEvents(thread.tokens_used);
-      const ingestedTokens = tokenEvents.reduce((sum, event) => sum + tokenTotal(event.usage), 0);
-      db.prepare(`DELETE FROM requests WHERE session_id = ?`).run(sessionId);
-      tokenEvents.forEach((event, index) => {
-        const usage = event.usage;
-        const inputTotal = usage.input_tokens ?? 0;
-        const cacheReadTokens = usage.cached_input_tokens ?? 0;
-        const inputTokens = Math.max(inputTotal - cacheReadTokens, 0);
-        const outputTokens = usage.output_tokens ?? Math.max((usage.total_tokens ?? 0) - inputTotal, 0);
-        const costUsd = computeCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens, 0);
-        const timestamp = event.timestamp ?? (thread.created_at ? new Date(thread.created_at * 1000 + index).toISOString() : new Date().toISOString());
-        const requestId = `${sessionId}-${index}`;
-        upsertRequest(db, withAccount({
-          id: requestId,
+      const threads = codexDb.prepare(buildThreadQuery(codexDb)).all();
+      for (const thread of threads) {
+        const model = thread.model ?? readCodexModel(source.configPath);
+        const stateValue = `${CODEX_INGEST_VERSION}:${thread.updated_at}:${thread.tokens_used}:${model}`;
+        const processed = getIngestState(db, source.stateSource, thread.id);
+        if (processed === stateValue)
+          continue;
+        const projectPath = thread.cwd ?? "";
+        const projectName = projectPath ? basename2(projectPath) : "unknown";
+        const sessionId = `${source.sessionPrefix}-${thread.id}`;
+        const startedAt = thread.created_at ? new Date(thread.created_at * 1000).toISOString() : new Date().toISOString();
+        const endedAt = thread.updated_at ? new Date(thread.updated_at * 1000).toISOString() : null;
+        upsertSession(db, withAccount({
+          id: sessionId,
           agent: "codex",
-          session_id: sessionId,
-          model,
-          input_tokens: inputTokens,
-          output_tokens: outputTokens,
-          cache_read_tokens: cacheReadTokens,
-          cache_create_tokens: 0,
-          cost_usd: costUsd,
-          cost_basis: defaultCostBasisForAgent("codex"),
-          duration_ms: 0,
-          timestamp,
-          source_request_id: requestId,
+          project_path: projectPath,
+          project_name: projectName,
+          started_at: startedAt,
+          ended_at: endedAt,
+          total_cost_usd: 0,
+          total_tokens: 0,
+          request_count: 0,
           machine_id: machineId
         }, account));
-        requests++;
-      });
-      rollupSession(db, sessionId);
-      setIngestState(db, "codex", thread.id, stateValue);
-      ingested++;
-      if (verbose)
-        console.log(`Codex session ${thread.id}: ${ingestedTokens} tokens on ${model}`);
+        const events = readTokenEvents(thread.rollout_path);
+        const tokenEvents = events.length > 0 ? events : fallbackEvents(thread.tokens_used);
+        const ingestedTokens = tokenEvents.reduce((sum, event) => sum + tokenTotal(event.usage), 0);
+        db.prepare(`DELETE FROM requests WHERE session_id = ?`).run(sessionId);
+        tokenEvents.forEach((event, index) => {
+          const usage = event.usage;
+          const inputTotal = usage.input_tokens ?? 0;
+          const cacheReadTokens = usage.cached_input_tokens ?? 0;
+          const inputTokens = Math.max(inputTotal - cacheReadTokens, 0);
+          const outputTokens = usage.output_tokens ?? Math.max((usage.total_tokens ?? 0) - inputTotal, 0);
+          const costUsd = computeCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens, 0);
+          const timestamp = event.timestamp ?? (thread.created_at ? new Date(thread.created_at * 1000 + index).toISOString() : new Date().toISOString());
+          const requestId = `${sessionId}-${index}`;
+          upsertRequest(db, withAccount({
+            id: requestId,
+            agent: "codex",
+            session_id: sessionId,
+            model,
+            input_tokens: inputTokens,
+            output_tokens: outputTokens,
+            cache_read_tokens: cacheReadTokens,
+            cache_create_tokens: 0,
+            cost_usd: costUsd,
+            cost_basis: defaultCostBasisForAgent("codex"),
+            duration_ms: 0,
+            timestamp,
+            source_request_id: requestId,
+            machine_id: machineId
+          }, account));
+          requests++;
+        });
+        rollupSession(db, sessionId);
+        setIngestState(db, source.stateSource, thread.id, stateValue);
+        ingested++;
+        if (verbose)
+          console.log(`${source.label} session ${thread.id}: ${ingestedTokens} tokens on ${model}`);
+      }
+    } finally {
+      codexDb?.close();
     }
-  } finally {
-    codexDb?.close();
   }
   return { sessions: ingested, requests };
 }
-var DEFAULT_CODEX_DB_PATH, DEFAULT_CODEX_CONFIG_PATH, CODEX_INGEST_VERSION = "rollout-aggregate-v3";
+var DEFAULT_CODEX_DB_PATH, DEFAULT_CODEX_CONFIG_PATH, DEFAULT_CODEWITH_DB_PATH, DEFAULT_CODEWITH_CONFIG_PATH, CODEX_INGEST_VERSION = "rollout-aggregate-v3";
 var init_codex = __esm(() => {
   init_database();
   init_pricing();
   init_accounts();
   DEFAULT_CODEX_DB_PATH = join7(homedir4(), ".codex", "state_5.sqlite");
   DEFAULT_CODEX_CONFIG_PATH = join7(homedir4(), ".codex", "config.toml");
+  DEFAULT_CODEWITH_DB_PATH = join7(homedir4(), ".codewith", "state_5.sqlite");
+  DEFAULT_CODEWITH_CONFIG_PATH = join7(homedir4(), ".codewith", "config.toml");
 });
 
 // src/ingest/gemini.ts

package/dist/index.js

@@ -2496,6 +2496,8 @@ import { join as join4, basename as basename2 } from "path";
 import { Database as BunDatabase2 } from "bun:sqlite";
 var DEFAULT_CODEX_DB_PATH = join4(homedir3(), ".codex", "state_5.sqlite");
 var DEFAULT_CODEX_CONFIG_PATH = join4(homedir3(), ".codex", "config.toml");
+var DEFAULT_CODEWITH_DB_PATH = join4(homedir3(), ".codewith", "state_5.sqlite");
+var DEFAULT_CODEWITH_CONFIG_PATH = join4(homedir3(), ".codewith", "config.toml");
 var CODEX_INGEST_VERSION = "rollout-aggregate-v3";
 function codexDbPath() {
   return process.env["HASNA_ECONOMY_CODEX_DB_PATH"] ?? DEFAULT_CODEX_DB_PATH;
@@ -2503,8 +2505,40 @@ function codexDbPath() {
 function codexConfigPath() {
   return process.env["HASNA_ECONOMY_CODEX_CONFIG_PATH"] ?? DEFAULT_CODEX_CONFIG_PATH;
 }
-function readCodexModel() {
-  const configPath = codexConfigPath();
+function codewithDbPath() {
+  return process.env["HASNA_ECONOMY_CODEWITH_DB_PATH"] ?? DEFAULT_CODEWITH_DB_PATH;
+}
+function codewithConfigPath() {
+  return process.env["HASNA_ECONOMY_CODEWITH_CONFIG_PATH"] ?? DEFAULT_CODEWITH_CONFIG_PATH;
+}
+function codexSources() {
+  const explicitCodexPath = process.env["HASNA_ECONOMY_CODEX_DB_PATH"];
+  const explicitCodewithPath = process.env["HASNA_ECONOMY_CODEWITH_DB_PATH"];
+  const sources = [{
+    label: "Codex",
+    dbPath: codexDbPath(),
+    configPath: codexConfigPath(),
+    sessionPrefix: "codex",
+    stateSource: "codex"
+  }];
+  if (!explicitCodexPath || explicitCodewithPath) {
+    sources.push({
+      label: "Codewith",
+      dbPath: codewithDbPath(),
+      configPath: codewithConfigPath(),
+      sessionPrefix: "codex-codewith",
+      stateSource: "codex-codewith"
+    });
+  }
+  const seen = new Set;
+  return sources.filter((source) => {
+    if (seen.has(source.dbPath))
+      return false;
+    seen.add(source.dbPath);
+    return true;
+  });
+}
+function readCodexModel(configPath = codexConfigPath()) {
   if (!existsSync5(configPath))
     return "gpt-5-codex";
   try {
@@ -2622,84 +2656,85 @@ function fallbackEvents(totalTokens) {
   }];
 }
 async function ingestCodex(db, verbose = false) {
-  const dbPath = codexDbPath();
-  if (!existsSync5(dbPath)) {
-    if (verbose)
-      console.log("Codex DB not found:", dbPath);
-    return { sessions: 0, requests: 0 };
-  }
   const machineId = getMachineId();
-  let codexDb = null;
   let ingested = 0;
   let requests = 0;
   const account = await resolveAccountForAgent("codex");
-  try {
-    codexDb = openCodexDb(dbPath, verbose);
-    if (!codexDb)
-      return { sessions: 0, requests: 0 };
-    const threads = codexDb.prepare(buildThreadQuery(codexDb)).all();
-    for (const thread of threads) {
-      const model = thread.model ?? readCodexModel();
-      const stateValue = `${CODEX_INGEST_VERSION}:${thread.updated_at}:${thread.tokens_used}:${model}`;
-      const processed = getIngestState(db, "codex", thread.id);
-      if (processed === stateValue)
+  for (const source of codexSources()) {
+    if (!existsSync5(source.dbPath)) {
+      if (verbose)
+        console.log(`${source.label} DB not found:`, source.dbPath);
+      continue;
+    }
+    let codexDb = null;
+    try {
+      codexDb = openCodexDb(source.dbPath, verbose);
+      if (!codexDb)
         continue;
-      const projectPath = thread.cwd ?? "";
-      const projectName = projectPath ? basename2(projectPath) : "unknown";
-      const sessionId = `codex-${thread.id}`;
-      const startedAt = thread.created_at ? new Date(thread.created_at * 1000).toISOString() : new Date().toISOString();
-      const endedAt = thread.updated_at ? new Date(thread.updated_at * 1000).toISOString() : null;
-      upsertSession(db, withAccount({
-        id: sessionId,
-        agent: "codex",
-        project_path: projectPath,
-        project_name: projectName,
-        started_at: startedAt,
-        ended_at: endedAt,
-        total_cost_usd: 0,
-        total_tokens: 0,
-        request_count: 0,
-        machine_id: machineId
-      }, account));
-      const events = readTokenEvents(thread.rollout_path);
-      const tokenEvents = events.length > 0 ? events : fallbackEvents(thread.tokens_used);
-      const ingestedTokens = tokenEvents.reduce((sum, event) => sum + tokenTotal(event.usage), 0);
-      db.prepare(`DELETE FROM requests WHERE session_id = ?`).run(sessionId);
-      tokenEvents.forEach((event, index) => {
-        const usage = event.usage;
-        const inputTotal = usage.input_tokens ?? 0;
-        const cacheReadTokens = usage.cached_input_tokens ?? 0;
-        const inputTokens = Math.max(inputTotal - cacheReadTokens, 0);
-        const outputTokens = usage.output_tokens ?? Math.max((usage.total_tokens ?? 0) - inputTotal, 0);
-        const costUsd = computeCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens, 0);
-        const timestamp = event.timestamp ?? (thread.created_at ? new Date(thread.created_at * 1000 + index).toISOString() : new Date().toISOString());
-        const requestId = `${sessionId}-${index}`;
-        upsertRequest(db, withAccount({
-          id: requestId,
+      const threads = codexDb.prepare(buildThreadQuery(codexDb)).all();
+      for (const thread of threads) {
+        const model = thread.model ?? readCodexModel(source.configPath);
+        const stateValue = `${CODEX_INGEST_VERSION}:${thread.updated_at}:${thread.tokens_used}:${model}`;
+        const processed = getIngestState(db, source.stateSource, thread.id);
+        if (processed === stateValue)
+          continue;
+        const projectPath = thread.cwd ?? "";
+        const projectName = projectPath ? basename2(projectPath) : "unknown";
+        const sessionId = `${source.sessionPrefix}-${thread.id}`;
+        const startedAt = thread.created_at ? new Date(thread.created_at * 1000).toISOString() : new Date().toISOString();
+        const endedAt = thread.updated_at ? new Date(thread.updated_at * 1000).toISOString() : null;
+        upsertSession(db, withAccount({
+          id: sessionId,
           agent: "codex",
-          session_id: sessionId,
-          model,
-          input_tokens: inputTokens,
-          output_tokens: outputTokens,
-          cache_read_tokens: cacheReadTokens,
-          cache_create_tokens: 0,
-          cost_usd: costUsd,
-          cost_basis: defaultCostBasisForAgent("codex"),
-          duration_ms: 0,
-          timestamp,
-          source_request_id: requestId,
+          project_path: projectPath,
+          project_name: projectName,
+          started_at: startedAt,
+          ended_at: endedAt,
+          total_cost_usd: 0,
+          total_tokens: 0,
+          request_count: 0,
           machine_id: machineId
         }, account));
-        requests++;
-      });
-      rollupSession(db, sessionId);
-      setIngestState(db, "codex", thread.id, stateValue);
-      ingested++;
-      if (verbose)
-        console.log(`Codex session ${thread.id}: ${ingestedTokens} tokens on ${model}`);
+        const events = readTokenEvents(thread.rollout_path);
+        const tokenEvents = events.length > 0 ? events : fallbackEvents(thread.tokens_used);
+        const ingestedTokens = tokenEvents.reduce((sum, event) => sum + tokenTotal(event.usage), 0);
+        db.prepare(`DELETE FROM requests WHERE session_id = ?`).run(sessionId);
+        tokenEvents.forEach((event, index) => {
+          const usage = event.usage;
+          const inputTotal = usage.input_tokens ?? 0;
+          const cacheReadTokens = usage.cached_input_tokens ?? 0;
+          const inputTokens = Math.max(inputTotal - cacheReadTokens, 0);
+          const outputTokens = usage.output_tokens ?? Math.max((usage.total_tokens ?? 0) - inputTotal, 0);
+          const costUsd = computeCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens, 0);
+          const timestamp = event.timestamp ?? (thread.created_at ? new Date(thread.created_at * 1000 + index).toISOString() : new Date().toISOString());
+          const requestId = `${sessionId}-${index}`;
+          upsertRequest(db, withAccount({
+            id: requestId,
+            agent: "codex",
+            session_id: sessionId,
+            model,
+            input_tokens: inputTokens,
+            output_tokens: outputTokens,
+            cache_read_tokens: cacheReadTokens,
+            cache_create_tokens: 0,
+            cost_usd: costUsd,
+            cost_basis: defaultCostBasisForAgent("codex"),
+            duration_ms: 0,
+            timestamp,
+            source_request_id: requestId,
+            machine_id: machineId
+          }, account));
+          requests++;
+        });
+        rollupSession(db, sessionId);
+        setIngestState(db, source.stateSource, thread.id, stateValue);
+        ingested++;
+        if (verbose)
+          console.log(`${source.label} session ${thread.id}: ${ingestedTokens} tokens on ${model}`);
+      }
+    } finally {
+      codexDb?.close();
     }
-  } finally {
-    codexDb?.close();
   }
   return { sessions: ingested, requests };
 }

package/dist/ingest/codex.d.ts

@@ -1,5 +1,5 @@
 import type { SqliteAdapter as Database } from '@hasna/cloud';
-declare function readCodexModel(): string;
+declare function readCodexModel(configPath?: string): string;
 export declare function ingestCodex(db: Database, verbose?: boolean): Promise<{
     sessions: number;
     requests: number;

package/dist/ingest/codex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../../src/ingest/codex.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAA;AA6C7D,iBAAS,cAAc,IAAI,MAAM,CAUhC;AAwGD,wBAAsB,WAAW,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,UAAQ,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CA8FhH;AAED,OAAO,EAAE,cAAc,EAAE,CAAA"}
+{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../../src/ingest/codex.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAA;AA4F7D,iBAAS,cAAc,CAAC,UAAU,SAAoB,GAAG,MAAM,CAS9D;AAwGD,wBAAsB,WAAW,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,UAAQ,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CA+FhH;AAED,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/dist/mcp/index.js

@@ -2240,6 +2240,8 @@ import { join as join3, 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 CODEX_INGEST_VERSION = "rollout-aggregate-v3";
 function codexDbPath() {
   return process.env["HASNA_ECONOMY_CODEX_DB_PATH"] ?? DEFAULT_CODEX_DB_PATH;
@@ -2247,8 +2249,40 @@ function codexDbPath() {
 function codexConfigPath() {
   return process.env["HASNA_ECONOMY_CODEX_CONFIG_PATH"] ?? DEFAULT_CODEX_CONFIG_PATH;
 }
-function readCodexModel() {
-  const configPath = codexConfigPath();
+function codewithDbPath() {
+  return process.env["HASNA_ECONOMY_CODEWITH_DB_PATH"] ?? DEFAULT_CODEWITH_DB_PATH;
+}
+function codewithConfigPath() {
+  return process.env["HASNA_ECONOMY_CODEWITH_CONFIG_PATH"] ?? DEFAULT_CODEWITH_CONFIG_PATH;
+}
+function codexSources() {
+  const explicitCodexPath = process.env["HASNA_ECONOMY_CODEX_DB_PATH"];
+  const explicitCodewithPath = process.env["HASNA_ECONOMY_CODEWITH_DB_PATH"];
+  const sources = [{
+    label: "Codex",
+    dbPath: codexDbPath(),
+    configPath: codexConfigPath(),
+    sessionPrefix: "codex",
+    stateSource: "codex"
+  }];
+  if (!explicitCodexPath || explicitCodewithPath) {
+    sources.push({
+      label: "Codewith",
+      dbPath: codewithDbPath(),
+      configPath: codewithConfigPath(),
+      sessionPrefix: "codex-codewith",
+      stateSource: "codex-codewith"
+    });
+  }
+  const seen = new Set;
+  return sources.filter((source) => {
+    if (seen.has(source.dbPath))
+      return false;
+    seen.add(source.dbPath);
+    return true;
+  });
+}
+function readCodexModel(configPath = codexConfigPath()) {
   if (!existsSync3(configPath))
     return "gpt-5-codex";
   try {
@@ -2366,84 +2400,85 @@ function fallbackEvents(totalTokens) {
   }];
 }
 async function ingestCodex(db, verbose = false) {
-  const dbPath = codexDbPath();
-  if (!existsSync3(dbPath)) {
-    if (verbose)
-      console.log("Codex DB not found:", dbPath);
-    return { sessions: 0, requests: 0 };
-  }
   const machineId = getMachineId();
-  let codexDb = null;
   let ingested = 0;
   let requests = 0;
   const account = await resolveAccountForAgent("codex");
-  try {
-    codexDb = openCodexDb(dbPath, verbose);
-    if (!codexDb)
-      return { sessions: 0, requests: 0 };
-    const threads = codexDb.prepare(buildThreadQuery(codexDb)).all();
-    for (const thread of threads) {
-      const model = thread.model ?? readCodexModel();
-      const stateValue = `${CODEX_INGEST_VERSION}:${thread.updated_at}:${thread.tokens_used}:${model}`;
-      const processed = getIngestState(db, "codex", thread.id);
-      if (processed === stateValue)
+  for (const source of codexSources()) {
+    if (!existsSync3(source.dbPath)) {
+      if (verbose)
+        console.log(`${source.label} DB not found:`, source.dbPath);
+      continue;
+    }
+    let codexDb = null;
+    try {
+      codexDb = openCodexDb(source.dbPath, verbose);
+      if (!codexDb)
         continue;
-      const projectPath = thread.cwd ?? "";
-      const projectName = projectPath ? basename2(projectPath) : "unknown";
-      const sessionId = `codex-${thread.id}`;
-      const startedAt = thread.created_at ? new Date(thread.created_at * 1000).toISOString() : new Date().toISOString();
-      const endedAt = thread.updated_at ? new Date(thread.updated_at * 1000).toISOString() : null;
-      upsertSession(db, withAccount({
-        id: sessionId,
-        agent: "codex",
-        project_path: projectPath,
-        project_name: projectName,
-        started_at: startedAt,
-        ended_at: endedAt,
-        total_cost_usd: 0,
-        total_tokens: 0,
-        request_count: 0,
-        machine_id: machineId
-      }, account));
-      const events = readTokenEvents(thread.rollout_path);
-      const tokenEvents = events.length > 0 ? events : fallbackEvents(thread.tokens_used);
-      const ingestedTokens = tokenEvents.reduce((sum, event) => sum + tokenTotal(event.usage), 0);
-      db.prepare(`DELETE FROM requests WHERE session_id = ?`).run(sessionId);
-      tokenEvents.forEach((event, index) => {
-        const usage = event.usage;
-        const inputTotal = usage.input_tokens ?? 0;
-        const cacheReadTokens = usage.cached_input_tokens ?? 0;
-        const inputTokens = Math.max(inputTotal - cacheReadTokens, 0);
-        const outputTokens = usage.output_tokens ?? Math.max((usage.total_tokens ?? 0) - inputTotal, 0);
-        const costUsd = computeCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens, 0);
-        const timestamp = event.timestamp ?? (thread.created_at ? new Date(thread.created_at * 1000 + index).toISOString() : new Date().toISOString());
-        const requestId = `${sessionId}-${index}`;
-        upsertRequest(db, withAccount({
-          id: requestId,
+      const threads = codexDb.prepare(buildThreadQuery(codexDb)).all();
+      for (const thread of threads) {
+        const model = thread.model ?? readCodexModel(source.configPath);
+        const stateValue = `${CODEX_INGEST_VERSION}:${thread.updated_at}:${thread.tokens_used}:${model}`;
+        const processed = getIngestState(db, source.stateSource, thread.id);
+        if (processed === stateValue)
+          continue;
+        const projectPath = thread.cwd ?? "";
+        const projectName = projectPath ? basename2(projectPath) : "unknown";
+        const sessionId = `${source.sessionPrefix}-${thread.id}`;
+        const startedAt = thread.created_at ? new Date(thread.created_at * 1000).toISOString() : new Date().toISOString();
+        const endedAt = thread.updated_at ? new Date(thread.updated_at * 1000).toISOString() : null;
+        upsertSession(db, withAccount({
+          id: sessionId,
           agent: "codex",
-          session_id: sessionId,
-          model,
-          input_tokens: inputTokens,
-          output_tokens: outputTokens,
-          cache_read_tokens: cacheReadTokens,
-          cache_create_tokens: 0,
-          cost_usd: costUsd,
-          cost_basis: defaultCostBasisForAgent("codex"),
-          duration_ms: 0,
-          timestamp,
-          source_request_id: requestId,
+          project_path: projectPath,
+          project_name: projectName,
+          started_at: startedAt,
+          ended_at: endedAt,
+          total_cost_usd: 0,
+          total_tokens: 0,
+          request_count: 0,
           machine_id: machineId
         }, account));
-        requests++;
-      });
-      rollupSession(db, sessionId);
-      setIngestState(db, "codex", thread.id, stateValue);
-      ingested++;
-      if (verbose)
-        console.log(`Codex session ${thread.id}: ${ingestedTokens} tokens on ${model}`);
+        const events = readTokenEvents(thread.rollout_path);
+        const tokenEvents = events.length > 0 ? events : fallbackEvents(thread.tokens_used);
+        const ingestedTokens = tokenEvents.reduce((sum, event) => sum + tokenTotal(event.usage), 0);
+        db.prepare(`DELETE FROM requests WHERE session_id = ?`).run(sessionId);
+        tokenEvents.forEach((event, index) => {
+          const usage = event.usage;
+          const inputTotal = usage.input_tokens ?? 0;
+          const cacheReadTokens = usage.cached_input_tokens ?? 0;
+          const inputTokens = Math.max(inputTotal - cacheReadTokens, 0);
+          const outputTokens = usage.output_tokens ?? Math.max((usage.total_tokens ?? 0) - inputTotal, 0);
+          const costUsd = computeCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens, 0);
+          const timestamp = event.timestamp ?? (thread.created_at ? new Date(thread.created_at * 1000 + index).toISOString() : new Date().toISOString());
+          const requestId = `${sessionId}-${index}`;
+          upsertRequest(db, withAccount({
+            id: requestId,
+            agent: "codex",
+            session_id: sessionId,
+            model,
+            input_tokens: inputTokens,
+            output_tokens: outputTokens,
+            cache_read_tokens: cacheReadTokens,
+            cache_create_tokens: 0,
+            cost_usd: costUsd,
+            cost_basis: defaultCostBasisForAgent("codex"),
+            duration_ms: 0,
+            timestamp,
+            source_request_id: requestId,
+            machine_id: machineId
+          }, account));
+          requests++;
+        });
+        rollupSession(db, sessionId);
+        setIngestState(db, source.stateSource, thread.id, stateValue);
+        ingested++;
+        if (verbose)
+          console.log(`${source.label} session ${thread.id}: ${ingestedTokens} tokens on ${model}`);
+      }
+    } finally {
+      codexDb?.close();
     }
-  } finally {
-    codexDb?.close();
   }
   return { sessions: ingested, requests };
 }

package/dist/server/index.js

@@ -2698,6 +2698,8 @@ import { join as join3, 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 CODEX_INGEST_VERSION = "rollout-aggregate-v3";
 function codexDbPath() {
   return process.env["HASNA_ECONOMY_CODEX_DB_PATH"] ?? DEFAULT_CODEX_DB_PATH;
@@ -2705,8 +2707,40 @@ function codexDbPath() {
 function codexConfigPath() {
   return process.env["HASNA_ECONOMY_CODEX_CONFIG_PATH"] ?? DEFAULT_CODEX_CONFIG_PATH;
 }
-function readCodexModel() {
-  const configPath = codexConfigPath();
+function codewithDbPath() {
+  return process.env["HASNA_ECONOMY_CODEWITH_DB_PATH"] ?? DEFAULT_CODEWITH_DB_PATH;
+}
+function codewithConfigPath() {
+  return process.env["HASNA_ECONOMY_CODEWITH_CONFIG_PATH"] ?? DEFAULT_CODEWITH_CONFIG_PATH;
+}
+function codexSources() {
+  const explicitCodexPath = process.env["HASNA_ECONOMY_CODEX_DB_PATH"];
+  const explicitCodewithPath = process.env["HASNA_ECONOMY_CODEWITH_DB_PATH"];
+  const sources = [{
+    label: "Codex",
+    dbPath: codexDbPath(),
+    configPath: codexConfigPath(),
+    sessionPrefix: "codex",
+    stateSource: "codex"
+  }];
+  if (!explicitCodexPath || explicitCodewithPath) {
+    sources.push({
+      label: "Codewith",
+      dbPath: codewithDbPath(),
+      configPath: codewithConfigPath(),
+      sessionPrefix: "codex-codewith",
+      stateSource: "codex-codewith"
+    });
+  }
+  const seen = new Set;
+  return sources.filter((source) => {
+    if (seen.has(source.dbPath))
+      return false;
+    seen.add(source.dbPath);
+    return true;
+  });
+}
+function readCodexModel(configPath = codexConfigPath()) {
   if (!existsSync3(configPath))
     return "gpt-5-codex";
   try {
@@ -2824,84 +2858,85 @@ function fallbackEvents(totalTokens) {
   }];
 }
 async function ingestCodex(db, verbose = false) {
-  const dbPath = codexDbPath();
-  if (!existsSync3(dbPath)) {
-    if (verbose)
-      console.log("Codex DB not found:", dbPath);
-    return { sessions: 0, requests: 0 };
-  }
   const machineId = getMachineId();
-  let codexDb = null;
   let ingested = 0;
   let requests = 0;
   const account = await resolveAccountForAgent("codex");
-  try {
-    codexDb = openCodexDb(dbPath, verbose);
-    if (!codexDb)
-      return { sessions: 0, requests: 0 };
-    const threads = codexDb.prepare(buildThreadQuery(codexDb)).all();
-    for (const thread of threads) {
-      const model = thread.model ?? readCodexModel();
-      const stateValue = `${CODEX_INGEST_VERSION}:${thread.updated_at}:${thread.tokens_used}:${model}`;
-      const processed = getIngestState(db, "codex", thread.id);
-      if (processed === stateValue)
+  for (const source of codexSources()) {
+    if (!existsSync3(source.dbPath)) {
+      if (verbose)
+        console.log(`${source.label} DB not found:`, source.dbPath);
+      continue;
+    }
+    let codexDb = null;
+    try {
+      codexDb = openCodexDb(source.dbPath, verbose);
+      if (!codexDb)
         continue;
-      const projectPath = thread.cwd ?? "";
-      const projectName = projectPath ? basename2(projectPath) : "unknown";
-      const sessionId = `codex-${thread.id}`;
-      const startedAt = thread.created_at ? new Date(thread.created_at * 1000).toISOString() : new Date().toISOString();
-      const endedAt = thread.updated_at ? new Date(thread.updated_at * 1000).toISOString() : null;
-      upsertSession(db, withAccount({
-        id: sessionId,
-        agent: "codex",
-        project_path: projectPath,
-        project_name: projectName,
-        started_at: startedAt,
-        ended_at: endedAt,
-        total_cost_usd: 0,
-        total_tokens: 0,
-        request_count: 0,
-        machine_id: machineId
-      }, account));
-      const events = readTokenEvents(thread.rollout_path);
-      const tokenEvents = events.length > 0 ? events : fallbackEvents(thread.tokens_used);
-      const ingestedTokens = tokenEvents.reduce((sum, event) => sum + tokenTotal(event.usage), 0);
-      db.prepare(`DELETE FROM requests WHERE session_id = ?`).run(sessionId);
-      tokenEvents.forEach((event, index) => {
-        const usage = event.usage;
-        const inputTotal = usage.input_tokens ?? 0;
-        const cacheReadTokens = usage.cached_input_tokens ?? 0;
-        const inputTokens = Math.max(inputTotal - cacheReadTokens, 0);
-        const outputTokens = usage.output_tokens ?? Math.max((usage.total_tokens ?? 0) - inputTotal, 0);
-        const costUsd = computeCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens, 0);
-        const timestamp = event.timestamp ?? (thread.created_at ? new Date(thread.created_at * 1000 + index).toISOString() : new Date().toISOString());
-        const requestId = `${sessionId}-${index}`;
-        upsertRequest(db, withAccount({
-          id: requestId,
+      const threads = codexDb.prepare(buildThreadQuery(codexDb)).all();
+      for (const thread of threads) {
+        const model = thread.model ?? readCodexModel(source.configPath);
+        const stateValue = `${CODEX_INGEST_VERSION}:${thread.updated_at}:${thread.tokens_used}:${model}`;
+        const processed = getIngestState(db, source.stateSource, thread.id);
+        if (processed === stateValue)
+          continue;
+        const projectPath = thread.cwd ?? "";
+        const projectName = projectPath ? basename2(projectPath) : "unknown";
+        const sessionId = `${source.sessionPrefix}-${thread.id}`;
+        const startedAt = thread.created_at ? new Date(thread.created_at * 1000).toISOString() : new Date().toISOString();
+        const endedAt = thread.updated_at ? new Date(thread.updated_at * 1000).toISOString() : null;
+        upsertSession(db, withAccount({
+          id: sessionId,
           agent: "codex",
-          session_id: sessionId,
-          model,
-          input_tokens: inputTokens,
-          output_tokens: outputTokens,
-          cache_read_tokens: cacheReadTokens,
-          cache_create_tokens: 0,
-          cost_usd: costUsd,
-          cost_basis: defaultCostBasisForAgent("codex"),
-          duration_ms: 0,
-          timestamp,
-          source_request_id: requestId,
+          project_path: projectPath,
+          project_name: projectName,
+          started_at: startedAt,
+          ended_at: endedAt,
+          total_cost_usd: 0,
+          total_tokens: 0,
+          request_count: 0,
           machine_id: machineId
         }, account));
-        requests++;
-      });
-      rollupSession(db, sessionId);
-      setIngestState(db, "codex", thread.id, stateValue);
-      ingested++;
-      if (verbose)
-        console.log(`Codex session ${thread.id}: ${ingestedTokens} tokens on ${model}`);
+        const events = readTokenEvents(thread.rollout_path);
+        const tokenEvents = events.length > 0 ? events : fallbackEvents(thread.tokens_used);
+        const ingestedTokens = tokenEvents.reduce((sum, event) => sum + tokenTotal(event.usage), 0);
+        db.prepare(`DELETE FROM requests WHERE session_id = ?`).run(sessionId);
+        tokenEvents.forEach((event, index) => {
+          const usage = event.usage;
+          const inputTotal = usage.input_tokens ?? 0;
+          const cacheReadTokens = usage.cached_input_tokens ?? 0;
+          const inputTokens = Math.max(inputTotal - cacheReadTokens, 0);
+          const outputTokens = usage.output_tokens ?? Math.max((usage.total_tokens ?? 0) - inputTotal, 0);
+          const costUsd = computeCostFromDb(db, model, inputTokens, outputTokens, cacheReadTokens, 0);
+          const timestamp = event.timestamp ?? (thread.created_at ? new Date(thread.created_at * 1000 + index).toISOString() : new Date().toISOString());
+          const requestId = `${sessionId}-${index}`;
+          upsertRequest(db, withAccount({
+            id: requestId,
+            agent: "codex",
+            session_id: sessionId,
+            model,
+            input_tokens: inputTokens,
+            output_tokens: outputTokens,
+            cache_read_tokens: cacheReadTokens,
+            cache_create_tokens: 0,
+            cost_usd: costUsd,
+            cost_basis: defaultCostBasisForAgent("codex"),
+            duration_ms: 0,
+            timestamp,
+            source_request_id: requestId,
+            machine_id: machineId
+          }, account));
+          requests++;
+        });
+        rollupSession(db, sessionId);
+        setIngestState(db, source.stateSource, thread.id, stateValue);
+        ingested++;
+        if (verbose)
+          console.log(`${source.label} session ${thread.id}: ${ingestedTokens} tokens on ${model}`);
+      }
+    } finally {
+      codexDb?.close();
     }
-  } finally {
-    codexDb?.close();
   }
   return { sessions: ingested, requests };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/economy",
-  "version": "0.2.36",
+  "version": "0.2.37",
   "description": "AI coding cost tracker — CLI + MCP server + REST API + web dashboard for Claude Code, Codex, Gemini, OpenCode, Cursor, Pi, and Hermes",
   "type": "module",
   "main": "dist/index.js",