@aion0/forge 0.4.14 → 0.4.15

package/RELEASE_NOTES.md

@@ -1,18 +1,25 @@
-# Forge v0.4.14
+# Forge v0.4.15
 
 Released: 2026-03-23
 
-## Changes since v0.4.13
+## Changes since v0.4.14
+
+### Features
+- feat: record token usage from task, pipeline, and mobile sources
+- feat: Usage dashboard — token cost by project, model, day, source
+- feat: token usage tracking — scanner, DB, API
 
 ### Bug Fixes
-- fix: bell idle timer 10s + 90s fallback
-- fix: bell uses idle detection instead of output pattern matching
-- fix: bell resets only on Enter key, not every keystroke
-- fix: bell cooldown 2min per tab label, prevents duplicate notifications
-- fix: bell requires 2000+ bytes of new output before checking markers
-- fix: notification timestamps display in correct timezone
-- fix: bell fires once per claude task, suppressed on attach/redraw
-- fix: bell detects claude completion markers (Cogitated, tokens, prompt)
+- fix: exclude cache tokens from cost estimate
+- fix: usage stored per day+model for accurate daily breakdown
+- fix: usage query uses local timezone for daily grouping
+
+### Performance
+- perf: usage scan interval from 5min to 1 hour
+
+### Other
+- ui: show author and source URL in skills detail view
+- ui: move Usage button next to Browser in header right section
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.4.13...v0.4.14
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.4.14...v0.4.15

package/app/api/mobile-chat/route.ts

@@ -19,6 +19,7 @@ export async function POST(req: Request) {
 
   const settings = loadSettings();
   const claudePath = settings.claudePath || 'claude';
+  const projectName = projectPath.split('/').pop() || projectPath;
 
   const args = ['-p', '--dangerously-skip-permissions', '--output-format', 'json'];
   if (resume) args.push('-c');
@@ -34,13 +35,16 @@ export async function POST(req: Request) {
 
   const encoder = new TextEncoder();
   let closed = false;
+  let fullOutput = '';
 
   const stream = new ReadableStream({
     start(controller) {
       child.stdout.on('data', (chunk: Buffer) => {
         if (closed) return;
+        const text = chunk.toString();
+        fullOutput += text;
         try {
-          controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'chunk', text: chunk.toString() })}\n\n`));
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'chunk', text })}\n\n`));
         } catch {}
       });
 
@@ -56,6 +60,24 @@ export async function POST(req: Request) {
       child.on('exit', (code) => {
         if (closed) return;
         closed = true;
+
+        // Record usage from the JSON output
+        try {
+          const parsed = JSON.parse(fullOutput);
+          if (parsed.session_id) {
+            const { recordUsage } = require('@/lib/usage-scanner');
+            recordUsage({
+              sessionId: parsed.session_id,
+              source: 'mobile',
+              projectPath,
+              projectName,
+              model: parsed.model || 'unknown',
+              inputTokens: parsed.usage?.input_tokens || parsed.total_input_tokens || 0,
+              outputTokens: parsed.usage?.output_tokens || parsed.total_output_tokens || 0,
+            });
+          }
+        } catch {}
+
         try {
           controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', code })}\n\n`));
           controller.close();

package/app/api/usage/route.ts

@@ -0,0 +1,20 @@
+import { NextResponse } from 'next/server';
+import { scanUsage, queryUsage } from '@/lib/usage-scanner';
+
+// GET /api/usage?days=7&project=forge&source=task&model=claude-opus-4
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url);
+  const days = searchParams.get('days') ? parseInt(searchParams.get('days')!) : undefined;
+  const projectName = searchParams.get('project') || undefined;
+  const source = searchParams.get('source') || undefined;
+  const model = searchParams.get('model') || undefined;
+
+  const data = queryUsage({ days, projectName, source, model });
+  return NextResponse.json(data);
+}
+
+// POST /api/usage — trigger scan
+export async function POST() {
+  const result = scanUsage();
+  return NextResponse.json(result);
+}

package/components/Dashboard.tsx

@@ -21,6 +21,7 @@ const PipelineView = lazy(() => import('./PipelineView'));
 const HelpDialog = lazy(() => import('./HelpDialog'));
 const LogViewer = lazy(() => import('./LogViewer'));
 const SkillsPanel = lazy(() => import('./SkillsPanel'));
+const UsagePanel = lazy(() => import('./UsagePanel'));
 
 interface UsageSummary {
   provider: string;
@@ -94,7 +95,7 @@ function FloatingBrowser({ onClose }: { onClose: () => void }) {
 }
 
 export default function Dashboard({ user }: { user: any }) {
-  const [viewMode, setViewMode] = useState<'tasks' | 'sessions' | 'terminal' | 'docs' | 'projects' | 'pipelines' | 'skills' | 'logs'>('terminal');
+  const [viewMode, setViewMode] = useState<'tasks' | 'sessions' | 'terminal' | 'docs' | 'projects' | 'pipelines' | 'skills' | 'logs' | 'usage'>('terminal');
   const [browserMode, setBrowserMode] = useState<'none' | 'float' | 'right' | 'left'>('none');
   const [showBrowserMenu, setShowBrowserMenu] = useState(false);
   const [browserWidth, setBrowserWidth] = useState(600);
@@ -409,6 +410,14 @@ export default function Dashboard({ user }: { user: any }) {
               </>
             )}
           </div>
+          <button
+            onClick={() => setViewMode('usage')}
+            className={`text-[10px] px-2 py-0.5 border rounded transition-colors ${
+              viewMode === 'usage'
+                ? 'border-[var(--accent)] text-[var(--accent)]'
+                : 'border-[var(--border)] text-[var(--text-secondary)] hover:text-[var(--text-primary)] hover:border-[var(--text-secondary)]'
+            }`}
+          >Usage</button>
           <TunnelToggle />
           {onlineCount.total > 0 && (
             <span className="text-[10px] text-[var(--text-secondary)] flex items-center gap-1" title={`${onlineCount.total} online${onlineCount.remote > 0 ? `, ${onlineCount.remote} remote` : ''}`}>
@@ -708,6 +717,13 @@ export default function Dashboard({ user }: { user: any }) {
           </Suspense>
         )}
 
+        {/* Usage */}
+        {viewMode === 'usage' && (
+          <Suspense fallback={<div className="flex-1 flex items-center justify-center text-[var(--text-secondary)]">Loading...</div>}>
+            <UsagePanel />
+          </Suspense>
+        )}
+
         {/* Logs */}
         {viewMode === 'logs' && (
           <Suspense fallback={<div className="flex-1 flex items-center justify-center text-[var(--text-secondary)]">Loading...</div>}>

package/components/SkillsPanel.tsx

@@ -579,6 +579,12 @@ export default function SkillsPanel({ projectFilter }: { projectFilter?: string
                       </div>}
                     </div>
                     <p className="text-[10px] text-[var(--text-secondary)] mt-0.5">{skill?.description || ''}</p>
+                    {skill?.author && (
+                      <div className="text-[9px] text-[var(--text-secondary)] mt-1">By {skill.author}</div>
+                    )}
+                    {skill?.sourceUrl && (
+                      <a href={skill.sourceUrl} target="_blank" rel="noopener noreferrer" className="text-[9px] text-[var(--accent)] hover:underline mt-0.5 block truncate">{skill.sourceUrl.replace(/^https?:\/\//, '').slice(0, 60)}</a>
+                    )}
                     {/* Installed indicators */}
                     {skill && isInstalled && (
                       <div className="flex items-center gap-2 mt-1">

package/components/UsagePanel.tsx

@@ -0,0 +1,207 @@
+'use client';
+
+import { useState, useEffect, useCallback } from 'react';
+
+interface UsageData {
+  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 }[];
+}
+
+function formatTokens(n: number): string {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+  if (n >= 1_000) return `${(n / 1_000).toFixed(0)}K`;
+  return String(n);
+}
+
+function formatCost(n: number): string {
+  return `$${n.toFixed(2)}`;
+}
+
+// Simple bar component
+function Bar({ value, max, color }: { value: number; max: number; color: string }) {
+  const pct = max > 0 ? Math.min(100, (value / max) * 100) : 0;
+  return (
+    <div className="h-2 bg-[var(--bg-tertiary)] rounded-full overflow-hidden flex-1">
+      <div className={`h-full rounded-full ${color}`} style={{ width: `${pct}%` }} />
+    </div>
+  );
+}
+
+export default function UsagePanel() {
+  const [data, setData] = useState<UsageData | null>(null);
+  const [days, setDays] = useState(7);
+  const [scanning, setScanning] = useState(false);
+  const [loading, setLoading] = useState(true);
+
+  const fetchData = useCallback(async () => {
+    setLoading(true);
+    try {
+      const res = await fetch(`/api/usage${days ? `?days=${days}` : ''}`);
+      const d = await res.json();
+      setData(d);
+    } catch {}
+    setLoading(false);
+  }, [days]);
+
+  useEffect(() => { fetchData(); }, [fetchData]);
+
+  const triggerScan = async () => {
+    setScanning(true);
+    try {
+      await fetch('/api/usage', { method: 'POST' });
+      await fetchData();
+    } catch {}
+    setScanning(false);
+  };
+
+  if (loading && !data) {
+    return <div className="flex-1 flex items-center justify-center text-[var(--text-secondary)] text-xs">Loading usage data...</div>;
+  }
+
+  if (!data) {
+    return <div className="flex-1 flex items-center justify-center text-[var(--text-secondary)] text-xs">Failed to load usage data</div>;
+  }
+
+  const maxProjectCost = data.byProject.length > 0 ? data.byProject[0].cost : 1;
+  const maxDayCost = data.byDay.length > 0 ? Math.max(...data.byDay.map(d => d.cost)) : 1;
+
+  return (
+    <div className="flex-1 flex flex-col min-h-0 overflow-y-auto">
+      {/* Header */}
+      <div className="px-4 py-3 border-b border-[var(--border)] shrink-0 flex items-center gap-3">
+        <h2 className="text-sm font-semibold text-[var(--text-primary)]">Token Usage</h2>
+        <div className="flex items-center gap-1 ml-auto">
+          {[7, 30, 90, 0].map(d => (
+            <button
+              key={d}
+              onClick={() => setDays(d)}
+              className={`text-[10px] px-2 py-0.5 rounded ${days === d ? 'bg-[var(--accent)] text-white' : 'text-[var(--text-secondary)] hover:text-[var(--text-primary)]'}`}
+            >
+              {d === 0 ? 'All' : `${d}d`}
+            </button>
+          ))}
+        </div>
+        <button
+          onClick={triggerScan}
+          disabled={scanning}
+          className="text-[10px] px-2 py-0.5 border border-[var(--border)] rounded text-[var(--text-secondary)] hover:text-[var(--text-primary)] disabled:opacity-50"
+        >
+          {scanning ? 'Scanning...' : 'Scan Now'}
+        </button>
+      </div>
+
+      <div className="p-4 space-y-6">
+        {/* Summary cards */}
+        <div className="grid grid-cols-2 sm:grid-cols-4 gap-3">
+          <div className="bg-[var(--bg-secondary)] border border-[var(--border)] rounded-lg p-3">
+            <div className="text-[9px] text-[var(--text-secondary)] uppercase">Total Cost</div>
+            <div className="text-lg font-bold text-[var(--text-primary)]">{formatCost(data.total.cost)}</div>
+          </div>
+          <div className="bg-[var(--bg-secondary)] border border-[var(--border)] rounded-lg p-3">
+            <div className="text-[9px] text-[var(--text-secondary)] uppercase">Input Tokens</div>
+            <div className="text-lg font-bold text-[var(--text-primary)]">{formatTokens(data.total.input)}</div>
+          </div>
+          <div className="bg-[var(--bg-secondary)] border border-[var(--border)] rounded-lg p-3">
+            <div className="text-[9px] text-[var(--text-secondary)] uppercase">Output Tokens</div>
+            <div className="text-lg font-bold text-[var(--text-primary)]">{formatTokens(data.total.output)}</div>
+          </div>
+          <div className="bg-[var(--bg-secondary)] border border-[var(--border)] rounded-lg p-3">
+            <div className="text-[9px] text-[var(--text-secondary)] uppercase">Sessions</div>
+            <div className="text-lg font-bold text-[var(--text-primary)]">{data.total.sessions}</div>
+            <div className="text-[9px] text-[var(--text-secondary)]">{data.total.messages} messages</div>
+          </div>
+        </div>
+
+        {/* By Day — bar chart */}
+        {data.byDay.length > 0 && (
+          <div>
+            <h3 className="text-[11px] font-semibold text-[var(--text-secondary)] uppercase mb-2">Daily Cost</h3>
+            <div className="space-y-1">
+              {data.byDay.slice(0, 14).reverse().map(d => (
+                <div key={d.date} className="flex items-center gap-2 text-[10px]">
+                  <span className="text-[var(--text-secondary)] w-16 shrink-0">{d.date.slice(5)}</span>
+                  <Bar value={d.cost} max={maxDayCost} color="bg-[var(--accent)]" />
+                  <span className="text-[var(--text-primary)] w-16 text-right shrink-0">{formatCost(d.cost)}</span>
+                </div>
+              ))}
+            </div>
+          </div>
+        )}
+
+        {/* By Project */}
+        {data.byProject.length > 0 && (
+          <div>
+            <h3 className="text-[11px] font-semibold text-[var(--text-secondary)] uppercase mb-2">By Project</h3>
+            <div className="space-y-1.5">
+              {data.byProject.map(p => (
+                <div key={p.name} className="flex items-center gap-2 text-[10px]">
+                  <span className="text-[var(--text-primary)] w-28 truncate shrink-0" title={p.name}>{p.name}</span>
+                  <Bar value={p.cost} max={maxProjectCost} color="bg-blue-500" />
+                  <span className="text-[var(--text-primary)] w-16 text-right shrink-0">{formatCost(p.cost)}</span>
+                  <span className="text-[var(--text-secondary)] w-12 text-right shrink-0">{p.sessions}s</span>
+                </div>
+              ))}
+            </div>
+          </div>
+        )}
+
+        {/* By Model */}
+        {data.byModel.length > 0 && (
+          <div>
+            <h3 className="text-[11px] font-semibold text-[var(--text-secondary)] uppercase mb-2">By Model</h3>
+            <div className="border border-[var(--border)] rounded overflow-hidden">
+              <table className="w-full text-[10px]">
+                <thead>
+                  <tr className="bg-[var(--bg-tertiary)] text-[var(--text-secondary)]">
+                    <th className="text-left px-3 py-1.5">Model</th>
+                    <th className="text-right px-3 py-1.5">Input</th>
+                    <th className="text-right px-3 py-1.5">Output</th>
+                    <th className="text-right px-3 py-1.5">Cost</th>
+                    <th className="text-right px-3 py-1.5">Msgs</th>
+                  </tr>
+                </thead>
+                <tbody>
+                  {data.byModel.map(m => (
+                    <tr key={m.model} className="border-t border-[var(--border)]/30">
+                      <td className="px-3 py-1.5 text-[var(--text-primary)]">{m.model}</td>
+                      <td className="px-3 py-1.5 text-right text-[var(--text-secondary)]">{formatTokens(m.input)}</td>
+                      <td className="px-3 py-1.5 text-right text-[var(--text-secondary)]">{formatTokens(m.output)}</td>
+                      <td className="px-3 py-1.5 text-right text-[var(--text-primary)] font-medium">{formatCost(m.cost)}</td>
+                      <td className="px-3 py-1.5 text-right text-[var(--text-secondary)]">{m.messages}</td>
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            </div>
+          </div>
+        )}
+
+        {/* By Source */}
+        {data.bySource.length > 0 && (
+          <div>
+            <h3 className="text-[11px] font-semibold text-[var(--text-secondary)] uppercase mb-2">By Source</h3>
+            <div className="flex gap-3 flex-wrap">
+              {data.bySource.map(s => (
+                <div key={s.source} className="bg-[var(--bg-secondary)] border border-[var(--border)] rounded-lg px-3 py-2 min-w-[120px]">
+                  <div className="text-[9px] text-[var(--text-secondary)] uppercase">{s.source}</div>
+                  <div className="text-sm font-bold text-[var(--text-primary)]">{formatCost(s.cost)}</div>
+                  <div className="text-[9px] text-[var(--text-secondary)]">{s.messages} msgs</div>
+                </div>
+              ))}
+            </div>
+          </div>
+        )}
+
+        {/* Note */}
+        <div className="text-[9px] text-[var(--text-secondary)] border-t border-[var(--border)] pt-3">
+          Cost estimates based on API pricing (Opus: $15/$75 per M tokens, Sonnet: $3/$15).
+          Actual cost may differ with Claude Max/Pro subscription.
+          Daily breakdown groups by session completion date.
+        </div>
+      </div>
+    </div>
+  );
+}

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();
 

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.4.14",
+  "version": "0.4.15",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {

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/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'))
+    );
   `);
 }