@flame0510/project-aether 1.9.1 → 1.11.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** — 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
+- **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); what each agent and container consumes (CPU, memory, storage, processes — charts per container) and what Docker holds on disk; the machine's recent alerts
+- **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,94 @@
+'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';
+import { PanelRow } from './PanelRow';
+
+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`;
+}
+
+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]) => <PanelRow key={label} label={label} value={value} />)}
+      {(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,8 @@ import PasswordInput from '../components/PasswordInput';
 import ImageDownloadBanner from './ImageDownloadBanner';
 import ChannelManager from './ChannelManager';
 import ModelSection from './ModelSection';
+import CostSection from './CostSection';
+import ResourceSection from './ResourceSection';
 import BrowserAccessSection, { OpenControlUiButton } from './BrowserAccessSection';
 import UpdateSection from './UpdateSection';
 import { validatePortInput } from '@/lib/agent-ports';
@@ -1194,6 +1196,18 @@ 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>
+
+      {/* Resources - what this agent's container consumes (history on the System page) */}
+      <div style={{ border: '1px solid var(--border)', borderRadius: 0, background: 'var(--bg)', overflow: 'hidden' }}>
+        <SectionHeader icon={<BracesIcon size={12} />} label="RESOURCES" />
+        <ResourceSection 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/agents/PanelRow.tsx

@@ -0,0 +1,9 @@
+/** One label/value row of an agent-panel section (COSTS and RESOURCES): the label dim on the left, the value right. */
+export function PanelRow({ label, value }: { label: string; value: string }) {
+  return (
+    <div style={{ display: 'flex', justifyContent: 'space-between', padding: '7px 14px', borderBottom: '1px solid var(--border)', fontSize: 12 }}>
+      <span style={{ color: '#888' }}>{label}</span>
+      <span style={{ color: 'var(--text)', textAlign: 'right', maxWidth: '60%', wordBreak: 'break-word' }}>{value}</span>
+    </div>
+  );
+}

package/app/agents/ResourceSection.tsx

@@ -0,0 +1,105 @@
+'use client';
+
+/**
+ * Resources section of the agent detail panel: what this agent's container consumes now and
+ * over the last 24 h (GET /api/metrics/containers, from metrics.db). The history charts are
+ * on the System page — one place, linked from here.
+ */
+import Link from 'next/link';
+import { useEffect, useRef, useState } from 'react';
+import { apiFetch } from '@/lib/apiFetch';
+import { formatMb, formatRate, formatSharePercent } from '@/lib/utils/format';
+import { PanelRow } from './PanelRow';
+
+interface Overview {
+  available: boolean;
+  interval_s: number;
+  age_s?: number | null;
+  containers?: {
+    container: string;
+    running: boolean;
+    now: { cpu_cores: number | null; cpu_percent: number | null; mem_mb: number | null; mem_percent: number | null; pids: number | null; net_rx_bps: number | null; net_tx_bps: number | null } | null;
+    range: { cpu_avg_percent: number | null; cpu_max_percent: number | null; mem_avg_mb: number | null; mem_max_mb: number | null };
+    storage: { volume_mb: number | null; layer_mb: number | null; total_mb: number | null };
+  }[];
+}
+
+const note = (text: string) => <div style={{ padding: '12px 14px', fontSize: 12, color: '#888' }}>{text}</div>;
+
+export default function ResourceSection({ container }: { container: string }) {
+  const [data, setData] = useState<Overview | 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/metrics/containers?range=24h', { signal: controller.signal });
+        const body = await res.json();
+        if (!res.ok) throw new Error(body?.error || `Error ${res.status}`);
+        setData(body as Overview);
+        setError('');
+      } catch (e: any) {
+        if (e?.name !== 'AbortError') setError(e?.message || 'Could not load the resources');
+      }
+    };
+    setData(null);
+    setError('');
+    load();
+    const timer = setInterval(load, 60_000);
+    return () => {
+      clearInterval(timer);
+      abortRef.current?.abort();
+    };
+  }, [container]);
+
+  if (error && !data) return <div style={{ padding: '12px 14px', fontSize: 12, color: 'var(--red)' }}>{error}</div>;
+  if (!data) return note('Loading…');
+  if (!data.available) return note(`No samples yet: the Rev4a daemon samples the containers every ${data.interval_s} s.`);
+
+  const row = data.containers?.find((c) => c.container === container);
+  if (!row) return note('Not sampled in the last 24 h: the agent was not running.');
+  // The same three-intervals rule as the System page: a daemon that stopped must not present
+  // hours-old figures as "now".
+  const stale = data.age_s != null && data.age_s > data.interval_s * 3;
+  const r = row.range;
+  const n = row.now;
+
+  return (
+    <div>
+      {error && (
+        <div style={{ padding: '8px 14px', fontSize: 11, color: 'var(--yellow)', borderBottom: '1px solid var(--border)' }}>
+          Could not refresh ({error}): showing the last answer.
+        </div>
+      )}
+      {stale ? (
+        <div style={{ padding: '8px 14px', fontSize: 11, color: 'var(--yellow)', borderBottom: '1px solid var(--border)' }}>
+          Not collecting: the latest sample is {Math.round((data.age_s ?? 0) / 60)} min old. Check that the Rev4a daemon is running; the figures below are from when it last answered.
+        </div>
+      ) : row.running && n ? (
+        <>
+          <PanelRow label="CPU now" value={`${formatSharePercent(n.cpu_percent)} of Docker's cores${n.cpu_cores !== null ? ` · ${n.cpu_cores.toFixed(3)} cores` : ''}`} />
+          <PanelRow label="Memory now" value={`${formatMb(n.mem_mb)}${n.mem_percent !== null ? ` · ${n.mem_percent}% of Docker's memory` : ''}`} />
+          <PanelRow label="Processes" value={String(n.pids ?? '—')} />
+          <PanelRow label="Network" value={`↓ ${formatRate(n.net_rx_bps)} ↑ ${formatRate(n.net_tx_bps)}`} />
+        </>
+      ) : (
+        <div style={{ padding: '8px 14px', fontSize: 11, color: 'var(--yellow)', borderBottom: '1px solid var(--border)' }}>
+          Stopped: the figures below are from when it last ran.
+        </div>
+      )}
+      <PanelRow label="CPU · last 24 h" value={`avg ${formatSharePercent(r.cpu_avg_percent)} · peak ${formatSharePercent(r.cpu_max_percent)}`} />
+      <PanelRow label="Memory · last 24 h" value={`avg ${formatMb(r.mem_avg_mb)} · peak ${formatMb(r.mem_max_mb)}`} />
+      <PanelRow
+        label="Storage"
+        value={`${formatMb(row.storage.total_mb)}${row.storage.volume_mb !== null ? ` · volume ${formatMb(row.storage.volume_mb)}` : ''}${row.storage.layer_mb !== null ? ` · layer ${formatMb(row.storage.layer_mb)}` : ''}`}
+      />
+      <div style={{ padding: '8px 14px', fontSize: 11 }}>
+        <Link href={`/system?agent=${encodeURIComponent(container)}`} className="ui-link">Charts on the System page →</Link>
+      </div>
+    </div>
+  );
+}

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,16 +46,22 @@ 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.',
     actions: ['Read the current CPU, memory, swap and disk usage', 'Switch the charts between 1h, 24h, 7d and 30d', 'Hover a chart (or focus it and use the arrow keys) to read the average and peak at a point', 'Open a chart\'s Table view for the numbers'],
-    hints: 'Bars turn yellow then red past their thresholds: CPU and memory at 85% and 95%, disks at 80% and 90%. If the page says "Not collecting", the Rev4a daemon is not sampling: check that rev4a serve is running.',
+    hints: 'Below the charts, "Agents and containers" shows what Docker holds on disk and one row per container (sorted by CPU) with its CPU share, memory, storage and processes; open a row for its own CPU, Memory and Storage charts, which follow the same range. "Recent alerts" lists what crossed its limit and when. Bars turn yellow then red past their thresholds: CPU and memory at 85% and 95%, disks at 80% and 90%. If the page says "Not collecting", the Rev4a daemon is not sampling: check that rev4a serve is running.',
   },
   '/containers': {
     title: 'Containers',
     description: 'List of all Docker containers on the server, running or stopped (not just agents). Shows container ID, name, image, status, state, ports, and IP address.',
-    actions: ['View every container, running or stopped, with its details', 'Click "Terminal" on any container to open an interactive shell', 'Check each container\'s status, image, IP and ports (no CPU or memory figures are shown)'],
+    actions: ['View every container, running or stopped, with its details', 'Click "Terminal" on any container to open an interactive shell', 'Check each container\'s status, image, IP and ports, and what a running one consumes now (CPU share, memory, processes), with a link to its charts on the System page'],
     hints: 'Containers marked with an agentId belong to OpenClaw agents. Others are infrastructure containers like databases or reverse proxies.',
   },
   '/containers/terminal/[id]': {
@@ -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/containers/route.ts

@@ -2,6 +2,7 @@ import { type NextRequest } from "next/server";
 import { NextResponse } from 'next/server';
 import { requireAuthJWT } from '@/lib/rev4a-auth';
 import { dockerAvailable, dockerFetch } from '@/lib/docker-socket';
+import { primaryName } from '@/lib/docker-stats';
 
 export const dynamic = 'force-dynamic';
 
@@ -22,7 +23,9 @@ export async function GET(request: NextRequest) {
         const ip = Object.values(networks)[0]?.IPAddress || null;
         return {
           id: c.Id?.slice(0, 12),
-          name: (c.Names?.[0] || '').replace(/^\//, ''),
+          // The daemon's rule (the name with one leading slash), so the usage row and the
+          // /system?agent= link key on the same name the metrics store uses.
+          name: primaryName(c?.Names),
           image: c.Image,
           status: c.Status,
           state: c.State,
@@ -33,7 +36,20 @@ export async function GET(request: NextRequest) {
           created: c.Labels?.created || null,
         };
       } catch {
-        return { id: c.Id?.slice(0, 12), name: (c.Names?.[0] || '').replace(/^\//, ''), status: c.Status, error: 'inspect failed' };
+        // Identity comes from the list: a failed inspect must neither drop the container nor
+        // give it a name the metrics store does not key on. Only the inspect-only fields are lost.
+        return {
+          id: c.Id?.slice(0, 12),
+          name: primaryName(c?.Names),
+          image: c.Image,
+          status: c.Status,
+          state: c.State,
+          ports: c.Ports?.map((p: any) => `${p.PublicPort || '?'}:${p.PrivatePort || '?'}`).join(', ') || '',
+          ip: null,
+          agentId: c.Labels?.AGENT_ID || null,
+          displayName: null,
+          created: c.Labels?.created || null,
+        };
       }
     }));
 

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

@@ -0,0 +1,55 @@
+import { NextResponse, type NextRequest } from 'next/server';
+import { openCostsDb } from '@/lib/costs-db';
+import { COLLECT_INTERVAL_S, lastDays, readCostSummary } from '@/lib/agent-costs';
+import { CONTAINER_NAME_RE } from '@/lib/docker-stats';
+import { requireAuthJWT } from '@/lib/rev4a-auth';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * 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_NAME_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