@aion0/forge 0.4.13 → 0.4.15

package/RELEASE_NOTES.md

@@ -1,11 +1,25 @@
-# Forge v0.4.13
+# Forge v0.4.15
 
 Released: 2026-03-23
 
-## Changes since v0.4.12
+## 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 notification only triggers on claude completion, not terminal idle
+- 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.12...v0.4.13
+**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/components/WebTerminal.tsx

@@ -168,16 +168,15 @@ const pendingCommands = new Map<number, string>();
 
 const bellEnabledPanes = new Set<number>();
 const bellPaneLabels = new Map<number, string>();
-const bellLastFired = new Map<number, number>(); // paneId -> timestamp
-const BELL_COOLDOWN = 30000; // 30s cooldown between bells
+const bellLastFired = new Map<string, number>(); // tabLabel -> timestamp
+const BELL_COOLDOWN = 120000; // 2min cooldown between bells
 
 function fireBellNotification(paneId: number) {
+  const label = bellPaneLabels.get(paneId) || 'Terminal';
   const now = Date.now();
-  const last = bellLastFired.get(paneId) || 0;
+  const last = bellLastFired.get(label) || 0;
   if (now - last < BELL_COOLDOWN) return;
-  bellLastFired.set(paneId, now);
-
-  const label = bellPaneLabels.get(paneId) || 'Terminal';
+  bellLastFired.set(label, now);
 
   // Browser notification
   if (typeof Notification !== 'undefined' && Notification.permission === 'granted') {
@@ -1120,7 +1119,10 @@ const MemoTerminalPane = memo(function TerminalPane({
     if (!containerRef.current) return;
 
     let disposed = false; // guard against post-cleanup writes (React Strict Mode)
-    let bellOutputBuffer = '';
+    let bellArmed = false; // armed after user presses Enter
+    let bellNewBytes = 0;
+    let bellIdleTimer = 0;
+    let bellArmedAt = 0; // timestamp when armed
 
     // Read terminal theme from CSS variables
     const cs = getComputedStyle(document.documentElement);
@@ -1257,15 +1259,23 @@ const MemoTerminalPane = memo(function TerminalPane({
           const msg = JSON.parse(event.data);
           if (msg.type === 'output') {
             try { term.write(msg.data); } catch {};
-            // Bell: detect claude completion (cost summary or prompt after activity)
-            if (bellEnabledPanes.has(id)) {
-              bellOutputBuffer += msg.data as string;
-              // Keep only last 500 chars
-              if (bellOutputBuffer.length > 500) bellOutputBuffer = bellOutputBuffer.slice(-500);
-              // Claude outputs cost/token info when done, or returns to prompt ❯
-              if (bellOutputBuffer.includes('input tokens') || bellOutputBuffer.includes('output tokens') || bellOutputBuffer.includes('api_cost')) {
-                bellOutputBuffer = '';
-                fireBellNotification(id);
+            // Bell: detect claude completion
+            // Bell: idle detection after user submits prompt
+            if (bellEnabledPanes.has(id) && bellArmed) {
+              bellNewBytes += (msg.data as string).length;
+              clearTimeout(bellIdleTimer);
+              if (bellNewBytes > 2000) {
+                // 10s idle = claude finished
+                bellIdleTimer = window.setTimeout(() => {
+                  bellArmed = false;
+                  fireBellNotification(id);
+                }, 10000);
+                // Fallback: if 90s since armed with activity, force fire
+                if (Date.now() - bellArmedAt > 90000) {
+                  bellArmed = false;
+                  clearTimeout(bellIdleTimer);
+                  fireBellNotification(id);
+                }
               }
             }
           } else if (msg.type === 'connected') {
@@ -1358,6 +1368,13 @@ const MemoTerminalPane = memo(function TerminalPane({
 
     term.onData((data) => {
       if (ws?.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: 'input', data }));
+      // Arm bell on Enter (user submitted a new prompt)
+      if (data === '\r' || data === '\n') {
+        bellArmed = true;
+        bellNewBytes = 0;
+        bellArmedAt = Date.now();
+        clearTimeout(bellIdleTimer);
+      }
     });
 
     // ── Resize handling ──

package/forge-logo.svg

@@ -0,0 +1,106 @@
+<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN"
+ "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
+<svg version="1.0" xmlns="http://www.w3.org/2000/svg"
+ width="1050.000000pt" height="1102.000000pt" viewBox="0 0 1050.000000 1102.000000"
+ preserveAspectRatio="xMidYMid meet">
+
+<g transform="translate(0.000000,1102.000000) scale(0.100000,-0.100000)"
+fill="#000000" stroke="none">
+<path d="M0 5510 l0 -5510 5250 0 5250 0 0 5510 0 5510 -5250 0 -5250 0 0
+-5510z m2410 3369 c37 -18 164 -120 395 -319 584 -503 1025 -883 1101 -946 39
+-34 111 -96 159 -138 52 -45 96 -76 109 -76 12 0 233 45 492 99 258 55 503
+106 544 115 67 13 83 14 137 1 74 -17 147 -33 398 -85 105 -21 233 -48 285
+-60 237 -52 327 -70 350 -70 25 0 127 84 655 541 61 52 162 139 225 193 63 54
+171 147 240 207 475 410 597 512 643 536 74 38 198 44 279 13 66 -24 145 -92
+181 -153 60 -101 57 -27 57 -1656 l0 -1492 54 -217 c57 -224 150 -590 185
+-722 10 -41 38 -147 62 -235 23 -88 47 -185 54 -215 7 -30 16 -67 20 -82 6
+-25 5 -28 -19 -28 -15 0 -29 6 -32 14 -4 11 -13 12 -35 6 -16 -5 -68 -12 -114
+-15 l-84 -7 -6 29 c-4 15 -9 35 -12 43 -2 8 -29 110 -58 225 -30 116 -75 289
+-100 385 -25 96 -81 316 -125 488 l-80 313 0 1495 c0 1664 5 1554 -65 1554
+-29 0 -49 -13 -123 -77 -88 -77 -479 -412 -617 -528 -40 -33 -213 -181 -385
+-330 -173 -148 -399 -343 -504 -432 -121 -105 -197 -163 -211 -163 -21 0 -115
+19 -525 106 -204 43 -302 64 -500 105 l-155 32 -115 -23 c-63 -12 -155 -31
+-205 -42 -49 -11 -133 -28 -185 -39 -52 -11 -124 -27 -160 -34 -259 -56 -505
+-105 -526 -105 -17 0 -66 36 -162 119 -341 296 -862 743 -1486 1275 -166 142
+-194 156 -230 120 -9 -8 -17 -16 -18 -17 -2 -1 -5 -688 -8 -1527 l-5 -1525
+-53 -195 c-28 -107 -79 -298 -111 -425 -33 -126 -72 -275 -86 -330 -15 -55
+-46 -177 -70 -271 -64 -248 -50 -226 -142 -219 -129 10 -144 11 -149 3 -8 -13
+-54 -9 -54 5 0 6 5 28 11 47 6 19 17 60 24 90 11 50 115 454 165 645 12 44 56
+213 98 375 l77 295 5 1540 5 1540 33 67 c40 81 117 155 193 186 78 31 202 27
+279 -9z m560 -1324 c0 -85 0 -85 -26 -85 -36 0 -81 -29 -94 -59 -6 -14 -14
+-112 -19 -217 -9 -212 -21 -257 -83 -309 l-30 -25 40 -44 c58 -63 73 -120 78
+-301 2 -82 4 -160 4 -173 0 -37 52 -82 94 -82 l36 0 0 -85 0 -85 -47 0 c-107
+1 -190 39 -237 111 -42 63 -56 137 -56 294 0 77 -3 157 -6 177 -9 50 -43 85
+-98 100 l-46 12 0 78 c0 77 0 78 28 84 111 24 115 34 123 268 6 204 13 236 58
+307 45 72 133 113 254 118 l27 1 0 -85z m4810 42 c117 -58 150 -147 150 -406
+0 -192 17 -229 113 -246 l38 -7 -3 -76 -3 -75 -49 -17 c-84 -28 -89 -41 -97
+-254 -4 -101 -10 -199 -14 -218 -17 -79 -79 -154 -153 -185 -19 -8 -66 -15
+-106 -16 l-71 -2 0 80 0 79 45 8 c81 13 86 27 93 239 7 208 18 258 73 316 19
+20 34 37 34 38 0 1 -16 19 -35 40 -52 57 -65 109 -66 254 0 196 -10 259 -43
+287 -15 13 -45 27 -67 30 l-39 7 0 77 c0 54 4 80 13 83 32 12 126 -6 187 -36z
+m-3638 -2314 c233 -236 490 -501 596 -615 72 -77 72 -77 72 -133 l0 -57 -177
+-181 c-455 -467 -688 -697 -710 -697 -23 0 -198 181 -198 206 0 7 159 173 354
+369 195 195 353 357 350 360 -17 18 -186 194 -424 438 -154 159 -282 293 -284
+299 -3 10 197 218 210 218 3 0 98 -93 211 -207z m2473 -1633 l0 -145 -95 -6
+c-121 -9 -1077 -8 -1320 0 l-185 6 -3 134 c-2 90 1 138 9 147 10 12 136 14
+803 12 l791 -3 0 -145z m-4912 -141 c21 -35 42 -73 48 -84 22 -47 71 -129 86
+-143 14 -14 16 -14 25 1 5 9 14 17 20 17 7 0 6 -5 -2 -15 -6 -8 -9 -19 -5 -26
+4 -6 2 -15 -5 -19 -9 -5 -5 -20 13 -56 13 -27 28 -59 32 -72 4 -13 25 -55 47
+-93 38 -65 44 -106 16 -97 -11 4 -40 53 -160 278 -66 123 -173 337 -188 374
+-10 28 -10 29 12 14 13 -9 40 -44 61 -79z m7221 54 c-4 -16 -28 -68 -54 -118
+-26 -49 -80 -153 -120 -230 -40 -77 -90 -170 -112 -207 -21 -36 -38 -71 -38
+-77 0 -13 -27 -15 -34 -2 -3 5 8 41 24 79 17 39 30 78 30 87 0 9 5 13 11 9 8
+-4 9 1 4 17 -4 13 -4 21 0 17 5 -4 14 0 21 10 9 13 10 20 1 31 -10 12 -9 14 4
+9 17 -7 40 30 132 212 74 146 149 240 131 163z m-284 -35 c-7 -18 -33 -75 -57
+-126 -24 -51 -43 -99 -43 -106 0 -7 -7 -19 -15 -26 -9 -7 -13 -20 -10 -30 3
+-10 -5 -26 -21 -41 -14 -13 -46 -59 -71 -101 -30 -53 -49 -75 -59 -71 -8 3
+-14 9 -14 13 0 28 233 461 252 468 4 2 8 8 8 13 0 11 33 47 39 43 2 -2 -2 -18
+-9 -36z m-6543 -260 c99 -190 119 -235 106 -241 -18 -11 -8 -24 -87 113 -87
+148 -108 179 -124 180 -14 0 -36 49 -27 58 3 4 8 -4 12 -16 3 -12 10 -22 15
+-22 5 0 0 17 -11 38 -28 52 -51 111 -51 132 0 10 -5 20 -12 22 -7 3 -8 9 -3
+18 15 24 52 -34 182 -282z m-231 54 c-18 -18 -29 -12 -20 11 3 9 12 13 21 10
+13 -5 13 -8 -1 -21z m6779 -162 c3 -5 1 -10 -4 -10 -6 0 -11 5 -11 10 0 6 2
+10 4 10 3 0 8 -4 11 -10z m-751 -568 c-22 -19 -66 -52 -99 -75 -33 -22 -99
+-69 -146 -103 -48 -35 -89 -64 -93 -64 -3 0 -14 -7 -23 -16 -17 -14 -69 -51
+-248 -174 -36 -25 -107 -74 -158 -110 -51 -36 -100 -69 -109 -75 -8 -5 -43
+-30 -78 -55 -34 -25 -75 -53 -92 -62 -17 -9 -34 -21 -37 -25 -15 -20 -72 -53
+-82 -47 -12 7 48 63 69 64 6 0 12 4 12 8 0 5 33 31 72 58 40 27 77 53 83 57
+16 12 252 181 414 295 73 52 180 126 205 142 27 17 67 46 204 147 62 45 106
+71 121 70 22 -1 21 -4 -15 -35z m-5149 -18 c5 -5 30 -23 54 -39 25 -15 50 -32
+55 -37 6 -5 65 -47 131 -93 66 -46 125 -88 130 -92 6 -4 30 -21 55 -37 25 -16
+72 -50 105 -75 58 -45 100 -75 134 -96 9 -5 32 -22 51 -37 20 -14 71 -50 115
+-79 44 -29 97 -71 119 -93 21 -21 36 -34 32 -28 -12 20 10 13 36 -10 14 -13
+35 -30 47 -38 11 -8 21 -20 21 -28 0 -12 -27 2 -75 40 -5 5 -53 37 -105 71
+-134 89 -261 177 -285 197 -11 10 -74 54 -140 99 -66 45 -147 102 -180 126
+-70 52 -161 116 -183 130 -12 7 -140 100 -181 131 -1 1 0 7 3 13 7 11 39 -2
+61 -25z m5388 -81 c-5 -12 -3 -14 8 -8 68 39 -178 -142 -435 -320 -154 -106
+-291 -203 -384 -270 -53 -39 -135 -96 -182 -127 -102 -69 -351 -246 -383 -273
+-52 -44 -168 -104 -167 -88 1 11 75 67 195 148 96 65 153 106 288 206 34 25
+107 76 162 114 93 63 384 273 467 337 20 15 39 28 43 28 3 0 45 29 93 64 78
+57 294 206 299 206 1 0 -1 -7 -4 -17z m-5615 -47 c71 -47 139 -94 159 -111 6
+-5 49 -36 95 -68 46 -32 162 -114 258 -183 96 -69 231 -164 300 -211 122 -85
+260 -185 290 -210 8 -7 24 -19 35 -27 11 -8 17 -17 13 -21 -7 -8 -42 10 -84
+42 -16 12 -76 54 -134 93 -58 39 -143 98 -190 131 -47 33 -96 68 -110 77 -26
+17 -177 125 -195 139 -5 4 -30 21 -55 38 -25 16 -95 66 -156 111 -61 45 -122
+87 -135 94 -25 14 -113 79 -140 105 -9 8 -20 15 -26 15 -5 0 -10 7 -10 15 0
+23 13 19 85 -29z m1347 -667 c11 -17 -1 -21 -15 -4 -8 9 -8 15 -2 15 6 0 14
+-5 17 -11z m2850 1 c10 -16 -258 -206 -276 -195 -15 10 0 25 19 18 9 -3 14 -3
+10 2 -9 9 26 42 53 50 11 4 19 11 19 17 0 6 3 8 7 5 3 -4 16 5 29 18 13 14 27
+25 31 26 4 0 28 15 53 34 53 40 47 37 55 25z m-2795 -49 c-1 -15 -2 -15 -13 0
+-7 9 -19 14 -27 12 -13 -4 -13 -3 -1 5 19 13 41 4 41 -17z m178 -117 c34 -27
+37 -39 8 -28 -9 3 -14 10 -11 14 3 4 -8 10 -23 13 -15 4 -40 19 -57 34 -16 15
+-43 35 -58 43 -16 8 -24 16 -18 18 6 2 8 8 5 14 -7 11 99 -63 154 -108z m-190
+-152 c62 -43 76 -62 47 -62 -8 0 -15 3 -15 8 0 4 -15 13 -32 21 -18 8 -35 17
+-38 20 -3 3 -27 22 -55 40 -27 19 -52 37 -55 41 -3 3 -24 18 -47 33 -25 18
+-40 34 -36 43 5 13 36 -6 231 -144z m452 28 c0 -5 -15 -10 -34 -10 -19 0 -38
+5 -41 10 -4 6 10 10 34 10 23 0 41 -4 41 -10z m685 5 c-25 -8 -675 -12 -675
+-4 0 5 141 9 343 8 188 0 338 -2 332 -4z m705 -5 c-96 -3 -249 -3 -340 0 -113
+4 -58 6 175 6 246 0 291 -2 165 -6z m263 3 c-7 -2 -21 -2 -30 0 -10 3 -4 5 12
+5 17 0 24 -2 18 -5z m165 0 c-21 -2 -57 -2 -80 0 -24 2 -7 4 37 4 44 0 63 -2
+43 -4z m401 -119 c-6 -7 -15 -12 -19 -9 -5 3 -11 1 -15 -5 -4 -6 -11 -7 -17
+-4 -5 4 2 14 18 25 30 20 52 15 33 -7z m-134 -84 c3 -5 -3 -10 -15 -10 -12 0
+-18 5 -15 10 3 6 10 10 15 10 5 0 12 -4 15 -10z m-71 -39 c3 -5 -11 -7 -32 -4
+-49 7 -54 13 -9 13 20 0 38 -4 41 -9z"/>
+</g>
+</svg>

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/notifications.ts

@@ -40,7 +40,7 @@ export function getNotifications(limit = 50, offset = 0): Notification[] {
     body: r.body,
     read: !!r.read,
     taskId: r.task_id,
-    createdAt: r.created_at,
+    createdAt: r.created_at ? (r.created_at.endsWith('Z') ? r.created_at : r.created_at.replace(' ', 'T') + 'Z') : r.created_at,
   }));
 }
 

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.13",
+  "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'))
+    );
   `);
 }