@flame0510/project-aether 1.9.0 → 1.10.0

package/README.md

@@ -18,9 +18,9 @@
 - **Live event stream** — Real-time session lineage, agent spawning, cost reporting
 - **Workspace browser** — Browse and edit agent files live from the dashboard
 - **Provider proxy** — OpenAI-compatible chat completions proxy that routes through a shared key vault
-- **System health** — runtime sessions, daemon heartbeat and errors, cron jobs and usage cost, with recommendations
+- **System health** — runtime sessions, daemon heartbeat and errors, cron jobs and what the agents spent today, with recommendations
 - **System** — the host machine's CPU, memory, swap and storage, now and over 1h / 24h / 7d / 30d (sampled every 30 s, kept 30 days)
-- **Cost tracking** — Per-session, per-model, per-time-range usage and cost reporting
+- **Costs** — what each agent spent, priced by its own OpenClaw with the prices Rev4a syncs (cache rates included, DeepSeek off-peak applied): by day, agent, model and session, with the calls that could not be priced
 - **PWA-ready** — Install on phone for mobile monitoring
 
 ---

package/app/agents/CostSection.tsx

@@ -0,0 +1,100 @@
+'use client';
+
+/**
+ * Costs section of the agent detail panel: what this agent spent, as its own OpenClaw
+ * priced it (GET /api/costs/agent, from costs.db). The Costs page has the whole fleet.
+ */
+import Link from 'next/link';
+import { useEffect, useRef, useState } from 'react';
+import { apiFetch } from '@/lib/apiFetch';
+import { formatCost } from '@/lib/utils/format';
+
+interface AgentCosts {
+  available: boolean;
+  intervalS: number;
+  today?: number;
+  week?: number;
+  month?: number;
+  tokensMonth?: number;
+  topModel?: { model: string; cost: number } | null;
+  unpricedMonth?: number;
+  collectedAt?: number | null;
+  error?: string | null;
+}
+
+
+function formatAge(ms: number): string {
+  const min = Math.round(ms / 60_000);
+  if (min < 1) return 'just now';
+  if (min < 60) return `${min} min ago`;
+  const h = Math.round(min / 60);
+  return h < 48 ? `${h} h ago` : `${Math.round(h / 24)} d ago`;
+}
+
+const ROW = { display: 'flex', justifyContent: 'space-between', padding: '7px 14px', borderBottom: '1px solid var(--border)', fontSize: 12 } as const;
+
+export default function CostSection({ container }: { container: string }) {
+  const [data, setData] = useState<AgentCosts | null>(null);
+  const [error, setError] = useState('');
+  const abortRef = useRef<AbortController | null>(null);
+
+  useEffect(() => {
+    const load = async () => {
+      abortRef.current?.abort();
+      const controller = new AbortController();
+      abortRef.current = controller;
+      try {
+        const res = await apiFetch(`/api/costs/agent?container=${encodeURIComponent(container)}`, { signal: controller.signal });
+        const body = await res.json();
+        if (!res.ok) throw new Error(body?.error || `Error ${res.status}`);
+        setData(body as AgentCosts);
+        setError('');
+      } catch (e: any) {
+        if (e?.name !== 'AbortError') setError(e?.message || 'Could not load the costs');
+      }
+    };
+    setData(null);
+    setError('');
+    load();
+    const timer = setInterval(load, 60_000);
+    return () => {
+      clearInterval(timer);
+      abortRef.current?.abort();
+    };
+  }, [container]);
+
+  if (error) return <div style={{ padding: '12px 14px', fontSize: 12, color: 'var(--red)' }}>{error}</div>;
+  if (!data) return <div style={{ padding: '12px 14px', fontSize: 12, color: '#888' }}>Loading…</div>;
+  if (!data.available) {
+    return <div style={{ padding: '12px 14px', fontSize: 12, color: '#888' }}>No figures yet: the Rev4a daemon reads the agents every {Math.round(data.intervalS / 60)} min.</div>;
+  }
+
+  const stale = !data.collectedAt || Date.now() - data.collectedAt > data.intervalS * 3 * 1000;
+  const rows: [string, string][] = [
+    ['Today (UTC)', formatCost(data.today)],
+    ['Last 7 days', formatCost(data.week)],
+    ['Last 30 days', `${formatCost(data.month)} · ${Math.round((data.tokensMonth ?? 0) / 1000)}k tokens`],
+    ['Top model (30 days)', data.topModel ? `${data.topModel.model} · ${formatCost(data.topModel.cost)}` : '-'],
+  ];
+  if (data.unpricedMonth) rows.push(['Calls without a price (30 days)', String(data.unpricedMonth)]);
+  rows.push(['Last read', data.collectedAt ? formatAge(Date.now() - data.collectedAt) : 'never']);
+
+  return (
+    <div>
+      {rows.map(([label, value]) => (
+        <div key={label} style={ROW}>
+          <span style={{ color: '#888' }}>{label}</span>
+          <span style={{ color: 'var(--text)', textAlign: 'right', maxWidth: '60%', wordBreak: 'break-word' }}>{value}</span>
+        </div>
+      ))}
+      {(stale || data.error) && (
+        <div style={{ padding: '8px 14px', fontSize: 11, color: 'var(--yellow)', borderBottom: '1px solid var(--border)' }}>
+          {data.error ?? 'Not read recently: a stopped agent keeps the figures of its last read.'}
+        </div>
+      )}
+      <div style={{ padding: '8px 14px', fontSize: 11 }}>
+        <Link href="/costs" className="ui-link">All agents on the Costs page →</Link>
+      </div>
+    </div>
+  );
+}

package/app/agents/PageClient.tsx

@@ -8,6 +8,7 @@ import PasswordInput from '../components/PasswordInput';
 import ImageDownloadBanner from './ImageDownloadBanner';
 import ChannelManager from './ChannelManager';
 import ModelSection from './ModelSection';
+import CostSection from './CostSection';
 import BrowserAccessSection, { OpenControlUiButton } from './BrowserAccessSection';
 import UpdateSection from './UpdateSection';
 import { validatePortInput } from '@/lib/agent-ports';
@@ -1194,6 +1195,12 @@ function DetailPanel({ agent, busy, onDeleted, onChanged, onModelSaved, onAccess
         <ModelSection agentId={agent.agentId} onSaved={onModelSaved} agentBusy={busy} />
       </div>
 
+      {/* Costs - what this agent spent, as its own OpenClaw priced it */}
+      <div style={{ border: '1px solid var(--border)', borderRadius: 0, background: 'var(--bg)', overflow: 'hidden' }}>
+        <SectionHeader icon={<BracesIcon size={12} />} label="COSTS" />
+        <CostSection container={agent.name} />
+      </div>
+
       {/* Config - View openclaw.json */}
       <div style={{ border: '1px solid var(--border)', borderRadius: 0, background: 'var(--bg)', overflow: 'hidden' }}>
         <SectionHeader icon={<BracesIcon size={12} />} label="CONFIG" />

package/app/api/agents/create/route.ts

@@ -221,7 +221,13 @@ export async function POST(request: NextRequest): Promise<NextResponse> {
     // this is intentional (e.g. BOOTSTRAP.md only exists in custom/).
     const templateFiles = ['AGENTS.md', 'SOUL.md', 'IDENTITY.md', 'MEMORY.md', 'TOOLS.md', 'HEARTBEAT.md', 'BOOTSTRAP.md'];
 
+    // --init: Docker's tini runs as PID 1 and collects orphaned processes. Without it
+    // openclaw-gateway is PID 1 and never does, so every process a tool leaves behind
+    // (Chrome, builds, scripts) stays a zombie and counts against the container's pids
+    // limit until the container can no longer start anything. Same flag in
+    // lib/agent-recreate.ts.
     const cmd = `docker run -d \
+      --init \
       --name "${containerName}" \
       --network "${network}" \
       --restart unless-stopped \

package/app/api/assistant/route.ts

@@ -19,7 +19,7 @@ const PAGE_CONTEXT: Record<string, PageContext> = {
   '/': {
     title: 'Dashboard',
     description: 'Main overview with live session list, cost summary by model, health cards for Rev4a\'s own runtime, cron and lineage, and a real-time event feed. The Machine card shows the server\'s CPU, RAM and fullest disk right now, coloured past a threshold, with a link to the System page.',
-    actions: ['Click any session row to open the Session Drawer for full details and tool call history', 'View cost breakdown by model and time period', 'See live events as they happen', 'Take a screenshot of the dashboard (mobile)'],
+    actions: ['Click any session row to open the Session Drawer for full details and tool call history', 'See what the agents spent today, by model (the Costs page has 7 and 30 days)', 'See live events as they happen', 'Take a screenshot of the dashboard (mobile)'],
     hints: 'The Session Drawer shows you the complete tool call history for any session — just click a row.',
   },
   '/agents': {
@@ -46,6 +46,12 @@ const PAGE_CONTEXT: Record<string, PageContext> = {
     actions: ['See all scheduled cron jobs at a glance', 'Check when each cron last ran and when it will run next', 'View job status (scheduled, running, completed, error)'],
     hints: 'Cron jobs use standard cron syntax. If a job shows "error" status, it means the last execution failed.',
   },
+  '/costs': {
+    title: 'Costs',
+    description: 'What each agent spent, as its own OpenClaw priced it with the prices Rev4a writes into every agent (input, output and cached input, DeepSeek at half price off-peak). Today, 7 days or 30 days in UTC days: the total, the split by input, output and cache, tokens and the share of input served from cache, the spend per day, by agent, by model, and the most expensive sessions. Read from the agents by the Rev4a daemon every 5 minutes.',
+    actions: ['Switch between Today, 7 days and 30 days', 'See which agent and which model cost the most', 'Find the most expensive sessions', 'Check which calls could not be priced, by model', 'See whether DeepSeek is billing peak or off-peak right now'],
+    hints: '"Against the bill" compares the agents\' figures with what DeepSeek and OpenRouter actually charged (balance or usage, read hourly); a small gap is normal because the same key also pays for this assistant. One agent\'s spend is also in its panel on the Agents page (COSTS). A model listed under "Calls without a price" has no price in Rev4a (it left the catalogue or has none yet): its calls are counted but not in the totals. "Not current" means the daemon could not read that agent recently; the reason is shown next to it.',
+  },
   '/system': {
     title: 'System',
     description: 'The machine Rev4a runs on: CPU (percent, cores, load average 1/5/15 min), memory (used, available, swap) and storage (each disk with used and free space, and whether it is the system disk, Docker\'s data or Rev4a\'s data), now and over 1h, 24h, 7d or 30d. Sampled by the Rev4a daemon every 30 seconds, kept 30 days.',
@@ -123,6 +129,7 @@ Navigation links inside Rev4a:
 - Gateway → /gateway
 - Cron Jobs → /crons
 - Containers → /containers
+- Costs (what each agent spent) → /costs
 - System (CPU, RAM, disk of the server) → /system
 - Config → /config
 - Lineage → /lineage?period=7d

package/app/api/costs/agent/route.ts

@@ -0,0 +1,56 @@
+import { NextResponse, type NextRequest } from 'next/server';
+import { openCostsDb } from '@/lib/costs-db';
+import { COLLECT_INTERVAL_S, lastDays, readCostSummary } from '@/lib/agent-costs';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+export const dynamic = 'force-dynamic';
+
+const CONTAINER_RE = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/;
+
+/**
+ * GET /api/costs/agent?container=<name> — one agent's spend for its panel: today, the
+ * last 7 and 30 UTC days, its top model and unpriced calls over 30 days, and when it
+ * was last read. From costs.db, like the Costs page.
+ */
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request);
+  if (denied) return denied as NextResponse;
+
+  const container = request.nextUrl.searchParams.get('container') ?? '';
+  if (!CONTAINER_RE.test(container)) return NextResponse.json({ error: 'Invalid container name' }, { status: 400 });
+
+  let db;
+  try {
+    db = openCostsDb();
+  } catch (e) {
+    return NextResponse.json({ error: `costs.db could not be read: ${(e as Error).message}` }, { status: 500 });
+  }
+  if (!db) return NextResponse.json({ available: false, intervalS: COLLECT_INTERVAL_S });
+
+  try {
+    const dates = lastDays(30);
+    const s = readCostSummary(db, dates, { container, topSessions: 0 });
+    const sum = (n: number) => s.daily.slice(-n).reduce((acc, d) => acc + d.cost, 0);
+    // Straight from the sources table: an agent with no use in 30 days is still read.
+    const source = db.prepare('SELECT collected_at AS collectedAt, error FROM agent_cost_sources WHERE container = ?')
+      .get(container) as { collectedAt: number | null; error: string | null } | undefined;
+    const top = s.byModel[0] ?? null;
+    const unpriced = s.unpriced.reduce((acc, u) => acc + u.calls, 0);
+    return NextResponse.json({
+      available: true,
+      intervalS: COLLECT_INTERVAL_S,
+      today: sum(1),
+      week: sum(7),
+      month: s.totals.cost,
+      tokensMonth: s.totals.tokens,
+      topModel: top && top.cost > 0 ? { model: top.model, cost: top.cost } : null,
+      unpricedMonth: unpriced,
+      collectedAt: source?.collectedAt ?? null,
+      error: source?.error ?? null,
+    });
+  } catch (e) {
+    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
+  } finally {
+    db.close();
+  }
+}

package/app/api/costs/route.ts

@@ -1,84 +1,26 @@
 import { NextResponse, type NextRequest } from 'next/server';
-import { openDb } from '@/lib/db';
-import { isBillableDollarModel } from '@/lib/billing';
+import { dashboardCosts } from '@/lib/agent-costs';
 import { requireAuthJWT } from '@/lib/rev4a-auth';
 
 export const dynamic = 'force-dynamic';
 
-// In-memory cache: 30 second TTL for cost aggregation
-let costsCache: { data: unknown; ts: number } | null = null;
-const CACHE_TTL_MS = 30_000;
-
-interface ModelCostRow {
-  model: string | null;
-  cost_usd: number;
-  tokens_in: number;
-  tokens_out: number;
-}
-
-function sumBillableCosts(rows: ModelCostRow[]): number {
-  return rows.reduce(
-    (sum, row) => (isBillableDollarModel(row.model) ? sum + Number(row.cost_usd ?? 0) : sum),
-    0,
-  );
-}
-
-function getStartOfDaySeconds(): number {
-  const now = new Date();
-  now.setHours(0, 0, 0, 0);
-  return Math.floor(now.getTime() / 1000);
-}
-
+/**
+ * GET /api/costs — the dashboard's cost card and the Lineage cost panel: today's spend
+ * (UTC day), all-time spend and today's spend by model, as the agents' own OpenClaw
+ * priced it (costs.db, see lib/agent-costs.ts). The Costs page has the full picture.
+ */
 export async function GET(request: NextRequest): Promise<NextResponse> {
-  const denied = await requireAuthJWT(request); if (denied) return denied as any;
-  // Return cached result if fresh
-  if (costsCache && Date.now() - costsCache.ts < CACHE_TTL_MS) {
-    return NextResponse.json(costsCache.data);
-  }
-
-  try {
-    const db = openDb();
-    const startOfDay = getStartOfDaySeconds();
-
-    const todayRows = db
-      .prepare(
-        `SELECT model,
-          COALESCE(SUM(cost_usd), 0) AS cost_usd,
-          COALESCE(SUM(tokens_in), 0) AS tokens_in,
-          COALESCE(SUM(tokens_out), 0) AS tokens_out
-         FROM sessions WHERE started_at >= ?
-         GROUP BY model ORDER BY cost_usd DESC`,
-      )
-      .all(startOfDay) as ModelCostRow[];
-
-    const allTimeRows = db
-      .prepare(
-        `SELECT model,
-          COALESCE(SUM(cost_usd), 0) AS cost_usd,
-          COALESCE(SUM(tokens_in), 0) AS tokens_in,
-          COALESCE(SUM(tokens_out), 0) AS tokens_out
-         FROM sessions
-         GROUP BY model ORDER BY cost_usd DESC`,
-      )
-      .all() as ModelCostRow[];
-
-    const today = sumBillableCosts(todayRows);
-    const sessionsAllTime = sumBillableCosts(allTimeRows);
-
-    const byModel = todayRows.filter((row) => isBillableDollarModel(row.model));
-
-    db.close();
-
-    const result = {
-      today,
-      allTime: sessionsAllTime,
-      allTimeSource: 'sessions_billable',
-      byModel,
-    };
-    costsCache = { data: result, ts: Date.now() };
-
-    return NextResponse.json(result);
-  } catch (e: unknown) {
-    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
-  }
+  const denied = await requireAuthJWT(request);
+  if (denied) return denied as NextResponse;
+
+  const costs = dashboardCosts();
+  if (costs?.error) return NextResponse.json({ error: `costs.db could not be read: ${costs.error}` }, { status: 500 });
+  return NextResponse.json({
+    today: costs?.today ?? 0,
+    allTime: costs?.allTime ?? 0,
+    allTimeSource: 'agents_openclaw',
+    missingToday: costs?.missingToday ?? 0,
+    // Models that cost something today; the Costs page lists the free and unpriced ones.
+    byModel: (costs?.byModelToday ?? []).filter((m) => m.cost > 0).map((m) => ({ model: m.model, cost_usd: m.cost, tokens: m.tokens, calls: m.calls })),
+  });
 }

package/app/api/costs/usage/route.ts

@@ -0,0 +1,65 @@
+import { NextResponse, type NextRequest } from 'next/server';
+import { openCostsDb } from '@/lib/costs-db';
+import { COLLECT_INTERVAL_S, EMPTY_TOTALS, lastDays, readCostSummary } from '@/lib/agent-costs';
+import { readReconciliation } from '@/lib/cost-reconciliation';
+import { loadOfferedModels } from '@/lib/model-catalogue';
+import { nextPriceChange, priceBandAt, priceScheduleFor } from '@/lib/model-pricing';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+export const dynamic = 'force-dynamic';
+
+/** Ranges in UTC days, today included. */
+const RANGES = { today: 1, '7d': 7, '30d': 30 } as const;
+type Range = keyof typeof RANGES;
+
+/**
+ * GET /api/costs/usage?range=today|7d|30d — what the agents spent, as each agent's own
+ * OpenClaw priced it (collected by daemon.js into costs.db), and how that compares with
+ * what the vendors billed. Nothing here computes a cost.
+ */
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  const denied = await requireAuthJWT(request);
+  if (denied) return denied as NextResponse;
+
+  const param = request.nextUrl.searchParams.get('range') ?? '7d';
+  if (!Object.hasOwn(RANGES, param)) {
+    return NextResponse.json({ error: `range must be one of ${Object.keys(RANGES).join(', ')}` }, { status: 400 });
+  }
+  const range = param as Range;
+  const dates = lastDays(RANGES[range]);
+  const startDate = dates[0];
+  const endDate = dates[dates.length - 1];
+
+  // The band DeepSeek bills at right now, when a DeepSeek model is on offer.
+  const scheduled = loadOfferedModels().map((m) => m.id).filter((id) => priceScheduleFor(id));
+  const next = scheduled.length ? nextPriceChange(scheduled) : null;
+  const pricing = scheduled.length
+    ? { vendor: 'DeepSeek', band: priceBandAt(scheduled[0]), nextChange: next ? next.getTime() : null, source: priceScheduleFor(scheduled[0])!.source }
+    : null;
+
+  let db;
+  try {
+    db = openCostsDb();
+  } catch (e) {
+    return NextResponse.json({ error: `costs.db could not be read: ${(e as Error).message}` }, { status: 500 });
+  }
+  if (!db) {
+    return NextResponse.json({
+      available: false, range, startDate, endDate, intervalS: COLLECT_INTERVAL_S, pricing,
+      totals: EMPTY_TOTALS, daily: dates.map((date) => ({ date, cost: 0, tokens: 0, missing: 0 })),
+      byAgent: [], byModel: [], sessions: [], unpriced: [], reconciliation: [],
+    });
+  }
+
+  try {
+    const summary = readCostSummary(db, dates);
+    const reconciliation = readReconciliation(db, startDate, endDate);
+    return NextResponse.json({
+      available: true, range, startDate, endDate, intervalS: COLLECT_INTERVAL_S, pricing, ...summary, reconciliation,
+    });
+  } catch (e) {
+    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
+  } finally {
+    db.close();
+  }
+}

package/app/api/gateway/sync.ts

@@ -24,6 +24,7 @@ import { activeUpdateAgentIds } from '@/lib/agent-update-state';
 import { activeRecreateAgentIds } from '@/lib/agent-recreate-state';
 import { activeRestoreAgentIds } from '@/lib/agent-restore-state';
 import { activeEditAgentIds } from '@/lib/agent-edit-state';
+import { priceAt, type ModelCost } from '@/lib/model-pricing';
 
 const PROVIDER_GATEWAY_BASE_URL = detectProviderGatewayUrl();
 
@@ -83,11 +84,24 @@ function containerVersionSync(name: string): string | null {
   return null;
 }
 
-function getActiveRev4aModels(version?: string | null): { id: string; name: string; input?: string[] }[] {
+/** One model of the `rev4a` block, as OpenClaw's `models.providers.*.models[]` takes it. */
+export interface Rev4aModelEntry { id: string; name: string; input?: string[]; cost?: ModelCost }
+
+/**
+ * `cost` is what makes OpenClaw price every call itself (per call, session and day, the
+ * cache split out): the rates in force now, from model-pricing.json. A model without a
+ * price gets none, and OpenClaw counts its calls as "missing cost" instead of $0. A
+ * vendor priced by time of day is re-synced at each change of rate
+ * (lib/price-schedule-sync.ts); OpenClaw keeps the cost it recorded at call time.
+ */
+function getActiveRev4aModels(version?: string | null): Rev4aModelEntry[] {
+  const now = new Date();
   return loadOfferedModels()
     .map((m) => {
-      const entry: { id: string; name: string; input?: string[] } = { id: m.id, name: m.name };
+      const entry: Rev4aModelEntry = { id: m.id, name: m.name };
       if (m.modality) entry.input = modalityToInput(m.modality, version);
+      const cost = priceAt(m.id, now);
+      if (cost) entry.cost = cost;
       return entry;
     });
 }
@@ -244,7 +258,7 @@ function writeContainerJson(container: AgentContainer, remotePath: string, data:
  * Shared between the create route and syncAllAgents — single source of truth
  * for the provider block injected into every agent container.
  */
-export function buildRev4aProviderConfig(version?: string | null): { baseUrl: string; apiKey: string; api: string; models: { id: string; name: string; input?: string[] }[] } {
+export function buildRev4aProviderConfig(version?: string | null): { baseUrl: string; apiKey: string; api: string; models: Rev4aModelEntry[] } {
   const providerKeys = readProviderKeys();
   const rev4aApiKey = providerKeys['rev4a'] || '';
   const activeModels = getActiveRev4aModels(version);
@@ -404,7 +418,7 @@ export function syncAllAgents(): SyncOutcome {
  */
 function syncContainer(
   container: AgentContainer,
-  rev4aProviderConfig: { baseUrl: string; apiKey: string; api: string; models: { id: string; name: string }[] },
+  rev4aProviderConfig: { baseUrl: string; apiKey: string; api: string; models: Rev4aModelEntry[] },
 ): string {
   const remotePath = '/root/.openclaw/openclaw.json';
   // Read first. If this throws, the container is reported as failed and nothing

package/app/api/stats/route.ts

@@ -9,9 +9,8 @@ export async function GET(request: NextRequest): Promise<NextResponse> {
   try {
     const db = openDb();
     const now = new Date();
-    const startOfMonth = Math.floor(
-      new Date(now.getFullYear(), now.getMonth(), 1).getTime() / 1000,
-    );
+    // sessions.started_at is in milliseconds (daemon.js).
+    const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1).getTime();
     const total = db
       .prepare(
         `SELECT COALESCE(SUM(cost_usd),0) as total, COALESCE(SUM(tokens_in),0) as total_in,

package/app/api/stats-since/route.ts

@@ -11,7 +11,7 @@ export async function GET(request: NextRequest): Promise<NextResponse> {
     const db = openDb();
     const row = db
       .prepare('SELECT COALESCE(SUM(cost_usd),0) as total FROM sessions WHERE started_at >= ?')
-      .get(Math.floor(ts / 1000)) as { total: number } | undefined;
+      .get(ts) as { total: number } | undefined; // both in milliseconds
     db.close();
     return NextResponse.json({ total: row?.total ?? 0 });
   } catch (e: unknown) {

package/app/api/stream/route.ts

@@ -2,6 +2,7 @@ import { type NextRequest } from 'next/server';
 import { DB_PATH } from '@/lib/db';
 import Database from 'better-sqlite3';
 import { requireAuthJWT } from '@/lib/rev4a-auth';
+import { dashboardCosts } from '@/lib/agent-costs';
 
 export const dynamic = 'force-dynamic';
 
@@ -32,12 +33,9 @@ export async function GET(request: NextRequest): Promise<Response> {
                       LEFT JOIN lineage l ON s.session_id = l.child_id
                       ORDER BY s.started_at DESC LIMIT 100`)
             .all();
-          const costs = db
-            .prepare('SELECT SUM(cost_usd) AS today FROM sessions WHERE started_at >= ?')
-            .get(Math.floor(new Date().setHours(0, 0, 0, 0) / 1000)) as
-            | { today: number | null }
-            | undefined;
           db.close();
+          // What the agents' OpenClaw priced today (UTC day), like GET /api/costs.
+          const costs = dashboardCosts();
 
           if (newEvents.length > 0) {
             lastEventId = newEvents[newEvents.length - 1].id;

package/app/api/system-health/route.ts

@@ -2,13 +2,15 @@ import { NextResponse, type NextRequest } from 'next/server';
 import { openDb } from '@/lib/db';
 import { latestMetricSample } from '@/lib/metrics-db';
 import { maybeSendAlert } from '@/lib/alerts';
-import { summarizeBilling } from '@/lib/billing';
+import { dashboardCosts } from '@/lib/agent-costs';
 import { listOpenClawCronJobs } from '@/lib/openclaw-cron';
-import type { ModelCost } from '@/lib/types';
 import { requireAuthJWT } from '@/lib/rev4a-auth';
 
 export const dynamic = 'force-dynamic';
 
+/** A day above this (US dollars, UTC day) raises the cost check to a warning. */
+const HIGH_DAILY_SPEND_USD = 10;
+
 type Health = 'ok' | 'warning' | 'error';
 type Severity = 'info' | 'warning' | 'critical';
 
@@ -146,7 +148,7 @@ export async function GET(request: NextRequest): Promise<NextResponse> {
       ? [columnExists(db, 'events', 'type') ? 'type' : null, columnExists(db, 'events', 'event') ? 'event' : null].filter(Boolean).join(", ''), COALESCE(")
       : '';
     const eventErrorCount = eventExpr
-      ? (db.prepare(`SELECT COUNT(*) AS total FROM events WHERE LOWER(COALESCE(${eventExpr}, '')) LIKE '%error%' AND ts >= ?`).get(Math.floor(Date.now() / 1000) - 86400) as { total: number }).total
+      ? (db.prepare(`SELECT COUNT(*) AS total FROM events WHERE LOWER(COALESCE(${eventExpr}, '')) LIKE '%error%' AND ts >= ?`).get(Date.now() - 86_400_000) as { total: number }).total // events.ts is in milliseconds
       : 0;
     checks.push({
       id: 'runtime.errors24h',
@@ -168,54 +170,53 @@ export async function GET(request: NextRequest): Promise<NextResponse> {
       });
     }
 
-    const startOfDay = new Date();
-    startOfDay.setHours(0, 0, 0, 0);
-    const todayModels = db.prepare(
-      `SELECT model,
-        COALESCE(SUM(cost_usd), 0) AS cost_usd,
-        COALESCE(SUM(tokens_in), 0) AS tokens_in,
-        COALESCE(SUM(tokens_out), 0) AS tokens_out,
-        COUNT(*) AS sessions
-       FROM sessions WHERE started_at >= ?
-       GROUP BY model ORDER BY cost_usd DESC`,
-    ).all(Math.floor(startOfDay.getTime() / 1000)) as ModelCost[];
-    const billing = summarizeBilling(todayModels);
+    db.close();
+  } catch (error) {
+    checks.push({ id: 'runtime.db', label: 'Rev4a DB', health: 'error', value: 'error', details: (error as Error).message, source: 'runtime' });
+    recommendations.push({ id: 'runtime.db-error', severity: 'critical', source: 'runtime', title: 'Rev4a DB unreadable', details: (error as Error).message, dismissible: false, createdAt });
+  }
+
+  // What the agents spent today (UTC day), as their own OpenClaw priced it (costs.db).
+  const spend = dashboardCosts();
+  if (spend?.error) {
+    checks.push({ id: 'cost.usageBasedToday', label: 'Spent today', health: 'warning', value: 'error', details: `costs.db unreadable: ${spend.error}`, source: 'cost' });
+  } else {
+    const today = spend?.today ?? 0;
+    const missing = spend?.missingToday ?? 0;
     checks.push({
       id: 'cost.usageBasedToday',
-      label: 'Usage-based cost today',
-      health: billing.usageBasedCost > 10 ? 'warning' : 'ok',
-      value: `$${billing.usageBasedCost.toFixed(2)}`,
-      details: `DB estimate $${billing.dbEstimatedCost.toFixed(2)}; fixed ${billing.buckets.fixed.sessions} sessions; credits ${billing.buckets.credits.sessions} sessions`,
+      label: 'Spent today',
+      health: today > HIGH_DAILY_SPEND_USD || missing > 0 ? 'warning' : 'ok',
+      value: `$${today.toFixed(2)}`,
+      details: spend
+        ? `Priced by the agents' OpenClaw, UTC day${missing ? `; ${missing} call(s) without a price` : ''}`
+        : 'No figures yet: the daemon reads the agents every 5 min',
       source: 'cost',
     });
-    if (billing.usageBasedCost > 10) {
+    if (today > HIGH_DAILY_SPEND_USD) {
       recommendations.push({
         id: 'cost.review-usage-based',
         severity: 'warning',
         source: 'cost',
-        title: 'High usage-based cost',
-        details: `Provider usage-based today: $${billing.usageBasedCost.toFixed(2)}. Counts OpenRouter and the other pay-per-use providers, not the fixed plans.`,
-        actionHref: '/gateway',
+        title: 'High spend today',
+        details: `The agents have spent $${today.toFixed(2)} today (UTC).`,
+        actionHref: '/costs',
         dismissible: true,
         createdAt,
       });
     }
-    if (billing.unknownModels.length > 0 && billing.buckets.unknown.cost_usd > 1) {
+    if (missing > 0) {
       recommendations.push({
-        id: 'cost.classify-unknown-models',
+        id: 'cost.unpriced-calls',
         severity: 'warning',
         source: 'cost',
-        title: 'Unclassified models in billing',
-        details: `${billing.unknownModels.length} unclassified models have DB estimate $${billing.buckets.unknown.cost_usd.toFixed(2)}.`,
-        actionHref: '/gateway',
+        title: 'Calls without a price',
+        details: `${missing} model call(s) today could not be priced: their model has no price in Rev4a, or a dynamic one (OpenRouter Auto).`,
+        actionHref: '/costs',
         dismissible: true,
         createdAt,
       });
     }
-    db.close();
-  } catch (error) {
-    checks.push({ id: 'runtime.db', label: 'Rev4a DB', health: 'error', value: 'error', details: (error as Error).message, source: 'runtime' });
-    recommendations.push({ id: 'runtime.db-error', severity: 'critical', source: 'runtime', title: 'Rev4a DB unreadable', details: (error as Error).message, dismissible: false, createdAt });
   }
 
   try {

package/app/components/CostBreakdown.tsx

@@ -12,7 +12,7 @@ interface CostBreakdownProps {
 export default function CostBreakdown({ byModel, loading = false }: CostBreakdownProps) {
   return (
     <article className="panel cost-panel">
-      <h2>Costs by Model (Today)</h2>
+      <h2>Spent by Model (Today, UTC)</h2>
       <div>
         {loading ? (
           <div style={{ padding: 12 }}>

package/app/components/Sidebar.tsx

@@ -59,6 +59,16 @@ const NAV: NavItem[] = [
       </svg>
     ),
   },
+  {
+    href: '/costs',
+    label: 'Costs',
+    icon: (
+      <svg width="16" height="16" viewBox="0 0 16 16" fill="none">
+        <circle cx="8" cy="8" r="6.5" stroke="currentColor" strokeWidth="1.3" />
+        <path d="M10 5.8C9.6 5.3 8.9 5 8 5c-1.2 0-2 .6-2 1.5S6.8 7.8 8 8s2 .6 2 1.5S9.2 11 8 11c-.9 0-1.6-.3-2-.8M8 3.8V5M8 11v1.2" stroke="currentColor" strokeWidth="1.2" strokeLinecap="round" />
+      </svg>
+    ),
+  },
   {
     href: '/system',
     label: 'System',