@aion0/forge 0.4.14 → 0.4.16

package/lib/init.ts

@@ -106,6 +106,13 @@ export function ensureInitialized() {
     setInterval(() => { syncSkills().catch(() => {}); }, 60 * 60 * 1000);
   } catch {}
 
+  // Usage scanner — scan JSONL files for token usage on startup + every hour
+  try {
+    const { scanUsage } = require('./usage-scanner');
+    scanUsage();
+    setInterval(() => { try { scanUsage(); } catch {} }, 60 * 60 * 1000);
+  } catch {}
+
   // Task runner is safe in every worker (DB-level coordination)
   ensureRunnerStarted();
 
@@ -175,7 +182,7 @@ function startTelegramProcess() {
   const script = join(process.cwd(), 'lib', 'telegram-standalone.ts');
   telegramChild = spawn('npx', ['tsx', script], {
     stdio: ['ignore', 'inherit', 'inherit'],
-    env: { ...process.env, PORT: String(process.env.PORT || 3000) },
+    env: { ...process.env, PORT: String(process.env.PORT || 8403) },
     detached: false,
   });
   telegramChild.on('exit', () => { telegramChild = null; });
@@ -187,7 +194,7 @@ let terminalChild: ReturnType<typeof spawn> | null = null;
 function startTerminalProcess() {
   if (terminalChild) return;
 
-  const termPort = Number(process.env.TERMINAL_PORT) || 3001;
+  const termPort = Number(process.env.TERMINAL_PORT) || 8404;
 
   const net = require('node:net');
   const tester = net.createServer();

package/lib/task-manager.ts

@@ -322,6 +322,8 @@ function executeTask(task: Task): Promise<void> {
     let totalCost = 0;
     let sessionId = '';
     let modelUsed = '';
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
 
     child.on('error', (err) => {
       console.error(`[task-runner] Spawn error:`, err.message);
@@ -355,9 +357,16 @@ function executeTask(task: Task): Promise<void> {
           if (parsed.type === 'system' && parsed.subtype === 'init' && parsed.model) {
             modelUsed = parsed.model;
           }
+          // Accumulate token usage from assistant messages
+          if (parsed.type === 'assistant' && parsed.message?.usage) {
+            totalInputTokens += parsed.message.usage.input_tokens || 0;
+            totalOutputTokens += parsed.message.usage.output_tokens || 0;
+          }
           if (parsed.type === 'result') {
             resultText = typeof parsed.result === 'string' ? parsed.result : JSON.stringify(parsed.result);
             totalCost = parsed.total_cost_usd || 0;
+            if (parsed.total_input_tokens) totalInputTokens = parsed.total_input_tokens;
+            if (parsed.total_output_tokens) totalOutputTokens = parsed.total_output_tokens;
           }
         } catch {}
       }
@@ -412,7 +421,23 @@ function executeTask(task: Task): Promise<void> {
           WHERE id = ?
         `).run(resultText, totalCost, task.id);
         emit(task.id, 'status', 'done');
-        console.log(`[task] Done: ${task.id} ${task.projectName} (cost: $${totalCost?.toFixed(4) || '0'})`);
+        console.log(`[task] Done: ${task.id} ${task.projectName} (cost: $${totalCost?.toFixed(4) || '0'}, ${totalInputTokens}in/${totalOutputTokens}out)`);
+        // Record usage
+        try {
+          const { recordUsage } = require('./usage-scanner');
+          let isPipeline = false;
+          try { const { pipelineTaskIds: ptids } = require('./pipeline'); isPipeline = ptids.has(task.id); } catch {}
+          recordUsage({
+            sessionId: sessionId || task.id,
+            source: isPipeline ? 'pipeline' : 'task',
+            projectPath: task.projectPath,
+            projectName: task.projectName,
+            model: modelUsed || 'unknown',
+            inputTokens: totalInputTokens,
+            outputTokens: totalOutputTokens,
+            taskId: task.id,
+          });
+        } catch {}
         const doneTask = getTask(task.id);
         if (doneTask) notifyTaskComplete(doneTask).catch(() => {});
         notifyTerminalSession(task, 'done', sessionId);

package/lib/telegram-standalone.ts

@@ -61,7 +61,7 @@ async function poll() {
 
           // Forward to Next.js API for processing
           try {
-            await fetch(`http://localhost:${process.env.PORT || 3000}/api/telegram`, {
+            await fetch(`http://localhost:${process.env.PORT || 8403}/api/telegram`, {
               method: 'POST',
               headers: { 'Content-Type': 'application/json', 'x-telegram-secret': TOKEN },
               body: JSON.stringify(update.message),

package/lib/terminal-server.ts

@@ -1,6 +1,6 @@
 /**
  * Terminal Server — standalone WebSocket PTY server.
- * Runs on port 3001 alongside the Next.js dev server on 3000.
+ * Runs on port 8404 alongside the Next.js server on 8403.
  */
 
 import { WebSocketServer, WebSocket } from 'ws';
@@ -9,7 +9,7 @@ import { homedir } from 'node:os';
 
 let wss: WebSocketServer | null = null;
 
-export function startTerminalServer(port = 3001) {
+export function startTerminalServer(port = 8404) {
   if (wss) return;
 
   wss = new WebSocketServer({ port });

package/lib/terminal-standalone.ts

@@ -33,7 +33,7 @@ import { getDataDir } from './dirs';
 import { readFileSync, writeFileSync, mkdirSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 
-const PORT = Number(process.env.TERMINAL_PORT) || 3001;
+const PORT = Number(process.env.TERMINAL_PORT) || 8404;
 // Session prefix based on DATA_DIR hash — default instance keeps 'mw-' for backward compat
 const _dataDir = process.env.FORGE_DATA_DIR || '';
 const _isDefault = !_dataDir || _dataDir.endsWith('/data') || _dataDir.endsWith('/.forge');

package/lib/usage-scanner.ts

@@ -0,0 +1,249 @@
+/**
+ * Usage Scanner — scans Claude Code JSONL session files for token usage data.
+ * Stores per-day aggregated results in SQLite for accurate daily breakdown.
+ */
+
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { getDb } from '@/src/core/db/database';
+import { getDbPath } from '@/src/config';
+import { getClaudeDir } from './dirs';
+
+function db() { return getDb(getDbPath()); }
+
+const PRICING: Record<string, { input: number; output: number }> = {
+  'claude-opus-4': { input: 15, output: 75 },
+  'claude-sonnet-4': { input: 3, output: 15 },
+  'claude-haiku-4': { input: 0.80, output: 4 },
+  'default': { input: 3, output: 15 },
+};
+
+function getModelFamily(model: string): string {
+  if (!model) return 'unknown';
+  if (model.includes('opus')) return 'claude-opus-4';
+  if (model.includes('haiku')) return 'claude-haiku-4';
+  if (model.includes('sonnet')) return 'claude-sonnet-4';
+  return 'unknown';
+}
+
+function calcCost(family: string, input: number, output: number): number {
+  const p = PRICING[family] || PRICING['default'];
+  // Only count input + output tokens. Cache tokens excluded from cost estimate
+  // because subscriptions (Max/Pro) don't charge per-token for cache.
+  return (input * p.input / 1_000_000) + (output * p.output / 1_000_000);
+}
+
+function dirToProjectPath(dirName: string): string {
+  return dirName.replace(/^-/, '/').replace(/-/g, '/');
+}
+
+function dirToProjectName(dirName: string): string {
+  return dirToProjectPath(dirName).split('/').pop() || dirName;
+}
+
+/** Get local date string from UTC timestamp */
+function toLocalDate(ts: string): string {
+  if (!ts) return 'unknown';
+  try {
+    const d = new Date(ts);
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+  } catch {
+    return ts.slice(0, 10) || 'unknown';
+  }
+}
+
+interface DayModelBucket {
+  input: number; output: number; cacheRead: number; cacheCreate: number; count: number;
+}
+
+/** Parse JSONL and aggregate by day + model */
+function parseByDayModel(content: string): Map<string, DayModelBucket> {
+  // key: "day|model"
+  const buckets = new Map<string, DayModelBucket>();
+
+  for (const line of content.split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      const obj = JSON.parse(line);
+      if (obj.type === 'assistant' && obj.message?.usage) {
+        const u = obj.message.usage;
+        const model = getModelFamily(obj.message.model || '');
+        const day = toLocalDate(obj.timestamp || '');
+        const key = `${day}|${model}`;
+
+        let b = buckets.get(key);
+        if (!b) { b = { input: 0, output: 0, cacheRead: 0, cacheCreate: 0, count: 0 }; buckets.set(key, b); }
+        b.input += u.input_tokens || 0;
+        b.output += u.output_tokens || 0;
+        b.cacheRead += u.cache_read_input_tokens || 0;
+        b.cacheCreate += u.cache_creation_input_tokens || 0;
+        b.count++;
+      }
+    } catch {}
+  }
+  return buckets;
+}
+
+/** Scan all JSONL files */
+export function scanUsage(): { scanned: number; updated: number; errors: number } {
+  const projectsDir = join(getClaudeDir(), 'projects');
+  let scanned = 0, updated = 0, errors = 0;
+
+  let projectDirs: string[];
+  try { projectDirs = readdirSync(projectsDir); } catch { return { scanned: 0, updated: 0, errors: 0 }; }
+
+  const upsert = db().prepare(`
+    INSERT INTO token_usage (session_id, source, project_path, project_name, model, day, input_tokens, output_tokens, cache_read_tokens, cache_create_tokens, cost_usd, message_count)
+    VALUES (?, 'terminal', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(session_id, source, model, day) DO UPDATE SET
+      input_tokens = excluded.input_tokens, output_tokens = excluded.output_tokens,
+      cache_read_tokens = excluded.cache_read_tokens, cache_create_tokens = excluded.cache_create_tokens,
+      cost_usd = excluded.cost_usd, message_count = excluded.message_count
+  `);
+
+  const getScanState = db().prepare('SELECT last_size FROM usage_scan_state WHERE file_path = ?');
+  const setScanState = db().prepare(`
+    INSERT INTO usage_scan_state (file_path, last_size) VALUES (?, ?)
+    ON CONFLICT(file_path) DO UPDATE SET last_size = excluded.last_size, last_scan = datetime('now')
+  `);
+
+  for (const projDir of projectDirs) {
+    const projPath = join(projectsDir, projDir);
+    try { if (!statSync(projPath).isDirectory()) continue; } catch { continue; }
+
+    const projectPath = dirToProjectPath(projDir);
+    const projectName = dirToProjectName(projDir);
+    let files: string[];
+    try { files = readdirSync(projPath).filter(f => f.endsWith('.jsonl') && !f.startsWith('agent-')); } catch { continue; }
+
+    for (const file of files) {
+      const filePath = join(projPath, file);
+      const sessionId = basename(file, '.jsonl');
+      scanned++;
+
+      try {
+        const currentSize = statSync(filePath).size;
+        const scanState = getScanState.get(filePath) as { last_size: number } | undefined;
+        if (currentSize === (scanState?.last_size || 0)) continue;
+
+        const content = readFileSync(filePath, 'utf-8');
+        const buckets = parseByDayModel(content);
+
+        if (buckets.size === 0) { setScanState.run(filePath, currentSize); continue; }
+
+        for (const [key, b] of buckets) {
+          const [day, model] = key.split('|');
+          const cost = calcCost(model, b.input, b.output);
+          upsert.run(sessionId, projectPath, projectName, model, day, b.input, b.output, b.cacheRead, b.cacheCreate, cost, b.count);
+        }
+
+        setScanState.run(filePath, currentSize);
+        updated++;
+      } catch { errors++; }
+    }
+  }
+  return { scanned, updated, errors };
+}
+
+/** Record usage from task/mobile/pipeline */
+export function recordUsage(opts: {
+  sessionId: string;
+  source: 'task' | 'mobile' | 'pipeline';
+  projectPath: string;
+  projectName: string;
+  model: string;
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens?: number;
+  cacheCreateTokens?: number;
+  taskId?: string;
+}): void {
+  const family = getModelFamily(opts.model);
+  const cost = calcCost(family, opts.inputTokens, opts.outputTokens);
+  const day = toLocalDate(new Date().toISOString());
+
+  db().prepare(`
+    INSERT INTO token_usage (session_id, source, project_path, project_name, model, day, input_tokens, output_tokens, cache_read_tokens, cache_create_tokens, cost_usd, message_count, task_id)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?)
+    ON CONFLICT(session_id, source, model, day) DO UPDATE SET
+      input_tokens = token_usage.input_tokens + excluded.input_tokens,
+      output_tokens = token_usage.output_tokens + excluded.output_tokens,
+      cost_usd = token_usage.cost_usd + excluded.cost_usd,
+      message_count = token_usage.message_count + 1
+  `).run(opts.sessionId, opts.source, opts.projectPath, opts.projectName, family, day, opts.inputTokens, opts.outputTokens, opts.cacheReadTokens || 0, opts.cacheCreateTokens || 0, cost, opts.taskId || null);
+}
+
+/** Query usage data */
+export function queryUsage(opts: {
+  days?: number;
+  projectName?: string;
+  source?: string;
+  model?: string;
+}): {
+  total: { input: number; output: number; cost: number; sessions: number; messages: number };
+  byProject: { name: string; input: number; output: number; cost: number; sessions: number }[];
+  byModel: { model: string; input: number; output: number; cost: number; messages: number }[];
+  byDay: { date: string; input: number; output: number; cost: number }[];
+  bySource: { source: string; input: number; output: number; cost: number; messages: number }[];
+} {
+  let where = '1=1';
+  const params: any[] = [];
+
+  if (opts.days) {
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - opts.days);
+    const cutoffDay = `${cutoff.getFullYear()}-${String(cutoff.getMonth() + 1).padStart(2, '0')}-${String(cutoff.getDate()).padStart(2, '0')}`;
+    where += ' AND day >= ?';
+    params.push(cutoffDay);
+  }
+  if (opts.projectName) { where += ' AND project_name = ?'; params.push(opts.projectName); }
+  if (opts.source) { where += ' AND source = ?'; params.push(opts.source); }
+  if (opts.model) { where += ' AND model = ?'; params.push(opts.model); }
+
+  const totalRow = db().prepare(`
+    SELECT COALESCE(SUM(input_tokens), 0) as input, COALESCE(SUM(output_tokens), 0) as output,
+           COALESCE(SUM(cost_usd), 0) as cost, COUNT(DISTINCT session_id) as sessions,
+           COALESCE(SUM(message_count), 0) as messages
+    FROM token_usage WHERE ${where}
+  `).get(...params) as any;
+
+  const byProject = (db().prepare(`
+    SELECT project_name as name, SUM(input_tokens) as input, SUM(output_tokens) as output,
+           SUM(cost_usd) as cost, COUNT(DISTINCT session_id) as sessions
+    FROM token_usage WHERE ${where}
+    GROUP BY project_name ORDER BY cost DESC LIMIT 20
+  `).all(...params) as any[]).map(r => ({
+    name: r.name, input: r.input, output: r.output, cost: +r.cost.toFixed(4), sessions: r.sessions,
+  }));
+
+  const byModel = (db().prepare(`
+    SELECT model, SUM(input_tokens) as input, SUM(output_tokens) as output,
+           SUM(cost_usd) as cost, SUM(message_count) as messages
+    FROM token_usage WHERE ${where}
+    GROUP BY model ORDER BY cost DESC
+  `).all(...params) as any[]).map(r => ({
+    model: r.model, input: r.input, output: r.output, cost: +r.cost.toFixed(4), messages: r.messages,
+  }));
+
+  const byDay = (db().prepare(`
+    SELECT day as date, SUM(input_tokens) as input, SUM(output_tokens) as output, SUM(cost_usd) as cost
+    FROM token_usage WHERE ${where} AND day != 'unknown'
+    GROUP BY day ORDER BY day DESC LIMIT 30
+  `).all(...params) as any[]).map(r => ({
+    date: r.date, input: r.input, output: r.output, cost: +r.cost.toFixed(4),
+  }));
+
+  const bySource = (db().prepare(`
+    SELECT source, SUM(input_tokens) as input, SUM(output_tokens) as output,
+           SUM(cost_usd) as cost, SUM(message_count) as messages
+    FROM token_usage WHERE ${where}
+    GROUP BY source ORDER BY cost DESC
+  `).all(...params) as any[]).map(r => ({
+    source: r.source, input: r.input, output: r.output, cost: +r.cost.toFixed(4), messages: r.messages,
+  }));
+
+  return {
+    total: { input: totalRow.input, output: totalRow.output, cost: +totalRow.cost.toFixed(4), sessions: totalRow.sessions, messages: totalRow.messages },
+    byProject, byModel, byDay, bySource,
+  };
+}

package/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/dev/types/routes.d.ts";
+import "./.next/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.4.14",
+  "version": "0.4.16",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {
@@ -37,7 +37,7 @@
     "@xyflow/react": "^12.10.1",
     "ai": "^6.0.116",
     "better-sqlite3": "^12.6.2",
-    "next": "^16.1.6",
+    "next": "^16.2.1",
     "next-auth": "5.0.0-beta.30",
     "node-pty": "1.0.0",
     "react": "^19.2.4",

package/scripts/verify-usage.ts

@@ -0,0 +1,178 @@
+/**
+ * Verification script — compares direct JSONL scanning with DB scanner results.
+ * Run: npx tsx scripts/verify-usage.ts
+ */
+
+import { readdirSync, readFileSync, statSync } from 'fs';
+import { join, basename } from 'path';
+import { homedir } from 'os';
+
+const CLAUDE_DIR = join(homedir(), '.claude', 'projects');
+
+const PRICING: Record<string, { input: number; output: number }> = {
+  'claude-opus-4': { input: 15, output: 75 },
+  'claude-sonnet-4': { input: 3, output: 15 },
+  'claude-haiku-4': { input: 0.80, output: 4 },
+  'default': { input: 3, output: 15 },
+};
+
+function getModelFamily(model: string): string {
+  if (!model) return 'unknown';
+  if (model.includes('opus')) return 'claude-opus-4';
+  if (model.includes('haiku')) return 'claude-haiku-4';
+  if (model.includes('sonnet')) return 'claude-sonnet-4';
+  return 'unknown';
+}
+
+function calcCost(family: string, input: number, output: number, cacheRead: number, cacheCreate: number): number {
+  const p = PRICING[family] || PRICING['default'];
+  return (
+    (input * p.input / 1_000_000) +
+    (output * p.output / 1_000_000) +
+    (cacheRead * p.input * 0.1 / 1_000_000) +
+    (cacheCreate * p.input * 0.25 / 1_000_000)
+  );
+}
+
+interface ProjectStats {
+  input: number; output: number; cost: number; sessions: number; messages: number;
+  cacheRead: number; cacheCreate: number;
+}
+
+interface ModelStats {
+  input: number; output: number; cost: number; messages: number;
+}
+
+interface DayStats {
+  input: number; output: number; cost: number;
+}
+
+const byProject: Record<string, ProjectStats> = {};
+const byModel: Record<string, ModelStats> = {};
+const byDay: Record<string, DayStats> = {};
+let totalInput = 0, totalOutput = 0, totalCost = 0, totalSessions = 0, totalMessages = 0;
+
+console.log('Scanning JSONL files...\n');
+
+const projectDirs = readdirSync(CLAUDE_DIR);
+let fileCount = 0;
+
+for (const projDir of projectDirs) {
+  const projPath = join(CLAUDE_DIR, projDir);
+  try { if (!statSync(projPath).isDirectory()) continue; } catch { continue; }
+
+  const projectName = projDir.replace(/^-/, '/').replace(/-/g, '/').split('/').pop() || projDir;
+  const files = readdirSync(projPath).filter(f => f.endsWith('.jsonl') && !f.startsWith('agent-'));
+
+  for (const file of files) {
+    const filePath = join(projPath, file);
+    fileCount++;
+    let sessionInput = 0, sessionOutput = 0, sessionCost = 0, sessionMsgs = 0;
+
+    try {
+      const content = readFileSync(filePath, 'utf-8');
+      for (const line of content.split('\n')) {
+        if (!line.trim()) continue;
+        try {
+          const obj = JSON.parse(line);
+          if (obj.type === 'assistant' && obj.message?.usage) {
+            const u = obj.message.usage;
+            const model = obj.message.model || '';
+            const family = getModelFamily(model);
+            const input = u.input_tokens || 0;
+            const output = u.output_tokens || 0;
+            const cacheRead = u.cache_read_input_tokens || 0;
+            const cacheCreate = u.cache_creation_input_tokens || 0;
+            const cost = calcCost(family, input, output, cacheRead, cacheCreate);
+
+            sessionInput += input;
+            sessionOutput += output;
+            sessionCost += cost;
+            sessionMsgs++;
+
+            if (!byModel[family]) byModel[family] = { input: 0, output: 0, cost: 0, messages: 0 };
+            byModel[family].input += input;
+            byModel[family].output += output;
+            byModel[family].cost += cost;
+            byModel[family].messages++;
+
+            const day = (obj.timestamp || '').slice(0, 10) || 'unknown';
+            if (!byDay[day]) byDay[day] = { input: 0, output: 0, cost: 0 };
+            byDay[day].input += input;
+            byDay[day].output += output;
+            byDay[day].cost += cost;
+          }
+        } catch {}
+      }
+    } catch { continue; }
+
+    if (sessionMsgs > 0) {
+      totalSessions++;
+      totalMessages += sessionMsgs;
+      totalInput += sessionInput;
+      totalOutput += sessionOutput;
+      totalCost += sessionCost;
+
+      if (!byProject[projectName]) byProject[projectName] = { input: 0, output: 0, cost: 0, sessions: 0, messages: 0, cacheRead: 0, cacheCreate: 0 };
+      byProject[projectName].input += sessionInput;
+      byProject[projectName].output += sessionOutput;
+      byProject[projectName].cost += sessionCost;
+      byProject[projectName].sessions++;
+      byProject[projectName].messages += sessionMsgs;
+    }
+  }
+}
+
+// Now run the DB scanner and compare
+console.log('Running DB scanner...\n');
+
+// Set up environment for the scanner
+process.env.FORGE_DATA_DIR = process.env.FORGE_DATA_DIR || join(homedir(), '.forge', 'data');
+
+// Dynamic import to use the actual scanner
+const { scanUsage, queryUsage } = await import('../lib/usage-scanner');
+
+const scanResult = scanUsage();
+console.log(`Scan result: ${scanResult.scanned} files scanned, ${scanResult.updated} updated, ${scanResult.errors} errors\n`);
+
+const dbData = queryUsage({});
+
+// Compare
+console.log('=== COMPARISON ===\n');
+
+console.log('TOTAL:');
+console.log(`  Direct:  ${(totalInput/1000).toFixed(0)}K in, ${(totalOutput/1000).toFixed(0)}K out, $${totalCost.toFixed(2)}, ${totalSessions} sessions, ${totalMessages} msgs`);
+console.log(`  DB:      ${(dbData.total.input/1000).toFixed(0)}K in, ${(dbData.total.output/1000).toFixed(0)}K out, $${dbData.total.cost.toFixed(2)}, ${dbData.total.sessions} sessions, ${dbData.total.messages} msgs`);
+
+const costDiff = Math.abs(totalCost - dbData.total.cost);
+const costMatch = costDiff < 0.1;
+console.log(`  Match:   ${costMatch ? '✅' : '❌'} (diff: $${costDiff.toFixed(2)})\n`);
+
+console.log('BY MODEL:');
+for (const [model, d] of Object.entries(byModel).sort((a, b) => b[1].cost - a[1].cost)) {
+  const dbModel = dbData.byModel.find(m => m.model === model);
+  const dbCost = dbModel?.cost || 0;
+  const match = Math.abs(d.cost - dbCost) < 0.1;
+  console.log(`  ${model.padEnd(20)} Direct: $${d.cost.toFixed(2).padStart(8)}  DB: $${dbCost.toFixed(2).padStart(8)}  ${match ? '✅' : '❌'}`);
+}
+
+console.log('\nBY PROJECT (top 10):');
+const sortedProjects = Object.entries(byProject).sort((a, b) => b[1].cost - a[1].cost).slice(0, 10);
+for (const [name, d] of sortedProjects) {
+  const dbProj = dbData.byProject.find(p => p.name === name);
+  const dbCost = dbProj?.cost || 0;
+  const match = Math.abs(d.cost - dbCost) < 0.1;
+  console.log(`  ${name.padEnd(25)} Direct: $${d.cost.toFixed(2).padStart(8)}  DB: $${dbCost.toFixed(2).padStart(8)}  ${match ? '✅' : '❌'}`);
+}
+
+console.log('\nBY DAY (last 7):');
+const sortedDays = Object.entries(byDay).filter(([d]) => d !== 'unknown').sort((a, b) => b[0].localeCompare(a[0])).slice(0, 7);
+for (const [day, d] of sortedDays) {
+  const dbDay = dbData.byDay.find(dd => dd.date === day);
+  const dbCost = dbDay?.cost || 0;
+  const match = Math.abs(d.cost - dbCost) < 0.1;
+  console.log(`  ${day}  Direct: $${d.cost.toFixed(2).padStart(8)}  DB: $${dbCost.toFixed(2).padStart(8)}  ${match ? '✅' : '❌'}`);
+}
+
+console.log(`\nFiles scanned: ${fileCount}`);
+console.log('');

package/src/config/index.ts

@@ -102,7 +102,7 @@ function getDefaultConfig(): AppConfig {
     },
     server: {
       host: '0.0.0.0',
-      port: 3000,
+      port: 8403,
     },
   };
 }

package/src/core/db/database.ts

@@ -36,6 +36,8 @@ function initSchema(db: Database.Database) {
   migrate('ALTER TABLE skills ADD COLUMN deleted_remotely INTEGER NOT NULL DEFAULT 0');
   migrate('ALTER TABLE project_pipelines ADD COLUMN last_run_at TEXT');
   migrate('ALTER TABLE pipeline_runs ADD COLUMN dedup_key TEXT');
+  // Recreate token_usage with day column (drop old version if schema changed)
+  try { db.exec("SELECT day FROM token_usage LIMIT 1"); } catch { try { db.exec("DROP TABLE IF EXISTS token_usage"); db.exec("DROP TABLE IF EXISTS usage_scan_state"); } catch {} }
   // Unique index for dedup (only applies when dedup_key is NOT NULL)
   try { db.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_pipeline_runs_dedup ON pipeline_runs(project_path, workflow_name, dedup_key)'); } catch {}
   // Migrate old issue_autofix_processed → pipeline_runs
@@ -219,6 +221,32 @@ function initSchema(db: Database.Database) {
       active INTEGER NOT NULL DEFAULT 1,
       created_at TEXT NOT NULL DEFAULT (datetime('now'))
     );
+
+    -- Token usage tracking (per session + day + model for accurate daily breakdown)
+    CREATE TABLE IF NOT EXISTS token_usage (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      source TEXT NOT NULL DEFAULT 'terminal',
+      project_path TEXT NOT NULL,
+      project_name TEXT NOT NULL,
+      model TEXT NOT NULL DEFAULT 'unknown',
+      day TEXT NOT NULL,
+      input_tokens INTEGER NOT NULL DEFAULT 0,
+      output_tokens INTEGER NOT NULL DEFAULT 0,
+      cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+      cache_create_tokens INTEGER NOT NULL DEFAULT 0,
+      cost_usd REAL NOT NULL DEFAULT 0,
+      message_count INTEGER NOT NULL DEFAULT 0,
+      task_id TEXT,
+      UNIQUE(session_id, source, model, day)
+    );
+
+    -- Track scan progress for incremental JSONL scanning
+    CREATE TABLE IF NOT EXISTS usage_scan_state (
+      file_path TEXT PRIMARY KEY,
+      last_size INTEGER NOT NULL DEFAULT 0,
+      last_scan TEXT NOT NULL DEFAULT (datetime('now'))
+    );
   `);
 }
 

package/start.sh

@@ -14,6 +14,9 @@ pkill -f 'next start' 2>/dev/null
 pkill -f 'next dev' 2>/dev/null
 sleep 1
 
+export PORT=${PORT:-8403}
+export TERMINAL_PORT=${TERMINAL_PORT:-8404}
+
 if [ "$1" = "dev" ]; then
   pnpm dev
 else