@chrysb/alphaclaw 0.3.5-beta.1 → 0.4.1-beta.0

package/lib/server/routes/system.js

@@ -50,6 +50,63 @@ const registerSystemRoutes = ({
       `${schedule} root bash "${kSystemCronScriptPath}" >> /var/log/openclaw-hourly-sync.log 2>&1`,
       "",
     ].join("\n");
+  const shellEscapeArg = (value) => {
+    const safeValue = String(value || "");
+    return `'${safeValue.replace(/'/g, `'\\''`)}'`;
+  };
+  const parseJsonFromStdout = (stdout) => {
+    const raw = String(stdout || "").trim();
+    if (!raw) return null;
+    const candidateStarts = [raw.indexOf("{"), raw.indexOf("[")].filter((idx) => idx >= 0);
+    for (const start of candidateStarts) {
+      const candidate = raw.slice(start);
+      try {
+        return JSON.parse(candidate);
+      } catch {}
+    }
+    return null;
+  };
+  const buildSessionLabel = (sessionRow = {}) => {
+    const key = String(sessionRow?.key || "");
+    if (key === "agent:main:main") return "Main agent thread";
+    const telegramMatch = key.match(/:telegram:direct:([^:]+)$/);
+    if (telegramMatch) {
+      return `Telegram ${telegramMatch[1]}`;
+    }
+    const directMatch = key.match(/:direct:([^:]+)$/);
+    if (directMatch) {
+      return `Direct ${directMatch[1]}`;
+    }
+    return key || "Session";
+  };
+  const listSendableAgentSessions = async () => {
+    const result = await clawCmd("sessions --json", { quiet: true });
+    if (!result.ok) {
+      throw new Error(result.stderr || "Could not load agent sessions");
+    }
+    const payload = parseJsonFromStdout(result.stdout);
+    const sessions = Array.isArray(payload?.sessions) ? payload.sessions : [];
+    return sessions
+      .filter((sessionRow) => {
+        const key = String(sessionRow?.key || "").toLowerCase();
+        if (!key) return false;
+        if (key.includes(":hook:") || key.includes(":cron:")) return false;
+        return true;
+      })
+      .map((sessionRow) => {
+        const key = String(sessionRow?.key || "");
+        const telegramMatch = key.match(/:telegram:direct:([^:]+)$/);
+        return {
+          key,
+          sessionId: String(sessionRow?.sessionId || ""),
+          updatedAt: Number(sessionRow?.updatedAt) || 0,
+          label: buildSessionLabel(sessionRow),
+          replyChannel: telegramMatch ? "telegram" : "",
+          replyTo: telegramMatch ? String(telegramMatch[1] || "") : "",
+        };
+      })
+      .sort((a, b) => b.updatedAt - a.updatedAt);
+  };
   const readSystemCronConfig = () => {
     try {
       const raw = fs.readFileSync(kSystemCronConfigPath, "utf8");
@@ -258,6 +315,56 @@ const registerSystemRoutes = ({
     res.json(result);
   });
 
+  app.get("/api/agent/sessions", async (req, res) => {
+    try {
+      const sessions = await listSendableAgentSessions();
+      return res.json({ ok: true, sessions });
+    } catch (err) {
+      return res.status(502).json({ ok: false, error: err.message });
+    }
+  });
+
+  app.post("/api/agent/message", async (req, res) => {
+    const rawMessage = String(req.body?.message || "");
+    const message = rawMessage.trim();
+    const sessionKey = String(req.body?.sessionKey || "").trim();
+    if (!message) {
+      return res.status(400).json({ ok: false, error: "message is required" });
+    }
+    if (message.length > 4000) {
+      return res
+        .status(400)
+        .json({ ok: false, error: "message must be 4000 characters or fewer" });
+    }
+    let command = `agent --agent main --message ${shellEscapeArg(message)}`;
+    if (sessionKey) {
+      let selectedSession = null;
+      try {
+        const sessions = await listSendableAgentSessions();
+        selectedSession = sessions.find((sessionRow) => sessionRow.key === sessionKey) || null;
+      } catch (err) {
+        return res.status(502).json({ ok: false, error: err.message });
+      }
+      if (!selectedSession) {
+        return res.status(400).json({ ok: false, error: "Selected session was not found" });
+      }
+      if (selectedSession.replyChannel && selectedSession.replyTo) {
+        command +=
+          ` --deliver --reply-channel ${shellEscapeArg(selectedSession.replyChannel)}` +
+          ` --reply-to ${shellEscapeArg(selectedSession.replyTo)}`;
+      } else if (selectedSession.sessionId) {
+        command += ` --session-id ${shellEscapeArg(selectedSession.sessionId)}`;
+      }
+    }
+    const result = await clawCmd(command, { quiet: true });
+    if (!result.ok) {
+      return res
+        .status(502)
+        .json({ ok: false, error: result.stderr || "Could not send message to agent" });
+    }
+    return res.json({ ok: true, stdout: result.stdout || "" });
+  });
+
   app.get("/api/gateway/dashboard", async (req, res) => {
     if (!isOnboarded()) return res.json({ ok: false, url: "/openclaw" });
     const result = await clawCmd("dashboard --no-open");

package/lib/server/routes/usage.js

@@ -1,6 +1,7 @@
 const topicRegistry = require("../topic-registry");
 
 const kSummaryCacheTtlMs = 60 * 1000;
+const kClientTimeZoneHeader = "x-client-timezone";
 
 const parsePositiveInt = (value, fallbackValue) => {
   const parsed = Number.parseInt(String(value ?? ""), 10);
@@ -8,6 +9,15 @@ const parsePositiveInt = (value, fallbackValue) => {
 };
 
 const createSummaryCache = () => new Map();
+const toTitleLabel = (value) => {
+  const raw = String(value || "").trim();
+  if (!raw) return "";
+  return raw.charAt(0).toUpperCase() + raw.slice(1);
+};
+const isUuidLike = (value) =>
+  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+    String(value || "").trim(),
+  );
 
 // Parse "agent:main:telegram:group:-123:topic:42" into structured labels.
 const parseSessionLabels = (sessionKey) => {
@@ -56,6 +66,20 @@ const parseSessionLabels = (sessionKey) => {
       });
     }
   }
+  const hookIndex = parts.indexOf("hook");
+  if (hookIndex !== -1) {
+    labels.push({ label: "Hook", tone: "purple" });
+    const hookName = String(parts[hookIndex + 1] || "").trim();
+    if (hookName && !isUuidLike(hookName)) {
+      labels.push({
+        label: toTitleLabel(hookName),
+        tone: "gray",
+      });
+    }
+  }
+  if (parts.includes("cron")) {
+    labels.push({ label: "Cron", tone: "blue" });
+  }
 
   return labels.length > 0 ? labels : null;
 };
@@ -78,14 +102,17 @@ const registerUsageRoutes = ({
   app.get("/api/usage/summary", requireAuth, (req, res) => {
     try {
       const days = parsePositiveInt(req.query.days, 30);
-      const cacheKey = String(days);
+      const timeZone = String(
+        req.get(kClientTimeZoneHeader) || req.query.timeZone || "",
+      ).trim();
+      const cacheKey = `${days}:${timeZone || "UTC"}`;
       const cached = summaryCache.get(cacheKey);
       const now = Date.now();
       if (cached && now - cached.cachedAt <= kSummaryCacheTtlMs) {
         res.json({ ok: true, ...cached.payload, cached: true });
         return;
       }
-      const summary = getDailySummary({ days });
+      const summary = getDailySummary({ days, timeZone });
       const payload = { summary };
       summaryCache.set(cacheKey, { payload, cachedAt: now });
       res.json({ ok: true, ...payload, cached: false });

package/lib/server/routes/webhooks.js

@@ -6,9 +6,12 @@ const {
   validateWebhookName,
 } = require("../webhooks");
 
-const isFiniteInteger = (value) => Number.isFinite(value) && Number.isInteger(value);
+const isFiniteInteger = (value) =>
+  Number.isFinite(value) && Number.isInteger(value);
 const parseBooleanFlag = (value) => {
-  const normalized = String(value == null ? "" : value).trim().toLowerCase();
+  const normalized = String(value == null ? "" : value)
+    .trim()
+    .toLowerCase();
   return ["1", "true", "yes", "on"].includes(normalized);
 };
 
@@ -40,20 +43,24 @@ const mergeWebhookAndSummary = ({ webhook, summary }) => {
 };
 
 const normalizeStatusFilter = (rawStatus) => {
-  const status = String(rawStatus || "all").trim().toLowerCase();
+  const status = String(rawStatus || "all")
+    .trim()
+    .toLowerCase();
   if (["all", "success", "error"].includes(status)) return status;
   return "all";
 };
 
 const buildWebhookUrls = ({ baseUrl, name }) => {
   const fullUrl = `${baseUrl}/hooks/${name}`;
-  const token = String(process.env.WEBHOOK_TOKEN || "").trim();
+  const token = String(
+    process.env.OPENCLAW_HOOKS_TOKEN || process.env.WEBHOOK_TOKEN || "",
+  ).trim();
   const queryStringUrl = token
     ? `${fullUrl}?token=${encodeURIComponent(token)}`
-    : `${fullUrl}?token=<WEBHOOK_TOKEN>`;
+    : `${fullUrl}?token=<OPENCLAW_HOOKS_TOKEN>`;
   const authHeaderValue = token
     ? `Authorization: Bearer ${token}`
-    : "Authorization: Bearer <WEBHOOK_TOKEN>";
+    : "Authorization: Bearer <OPENCLAW_HOOKS_TOKEN>";
   return { fullUrl, queryStringUrl, authHeaderValue, hasRuntimeToken: !!token };
 };
 
@@ -71,7 +78,8 @@ const registerWebhookRoutes = ({
     getSnapshot: async () => ({ restartRequired: false }),
   };
   const resolvedRestartState = restartRequiredState || fallbackRestartState;
-  const { markRequired: markRestartRequired, getSnapshot: getRestartSnapshot } = resolvedRestartState;
+  const { markRequired: markRestartRequired, getSnapshot: getRestartSnapshot } =
+    resolvedRestartState;
   const runWebhookGitSync = async (action, name) => {
     if (typeof shellCmd !== "function") return null;
     const safeName = String(name || "").trim();
@@ -95,7 +103,8 @@ const registerWebhookRoutes = ({
         mergeWebhookAndSummary({
           webhook,
           summary: summaryByHook.get(webhook.name),
-        }));
+        }),
+      );
       res.json({ ok: true, webhooks });
     } catch (err) {
       res.status(500).json({ ok: false, error: err.message });
@@ -106,8 +115,11 @@ const registerWebhookRoutes = ({
     try {
       const name = validateWebhookName(req.params.name);
       const detail = getWebhookDetail({ fs, constants, name });
-      if (!detail) return res.status(404).json({ ok: false, error: "Webhook not found" });
-      const summary = webhooksDb.getHookSummaries().find((item) => item.hookName === name);
+      if (!detail)
+        return res.status(404).json({ ok: false, error: "Webhook not found" });
+      const summary = webhooksDb
+        .getHookSummaries()
+        .find((item) => item.hookName === name);
       const merged = mergeWebhookAndSummary({ webhook: detail, summary });
       const baseUrl = getBaseUrl(req);
       const urls = buildWebhookUrls({ baseUrl, name });
@@ -151,7 +163,9 @@ const registerWebhookRoutes = ({
         syncWarning,
       });
     } catch (err) {
-      const status = String(err.message || "").includes("already exists") ? 409 : 400;
+      const status = String(err.message || "").includes("already exists")
+        ? 409
+        : 400;
       return res.status(status).json({ ok: false, error: err.message });
     }
   });
@@ -159,9 +173,23 @@ const registerWebhookRoutes = ({
   app.delete("/api/webhooks/:name", async (req, res) => {
     try {
       const name = validateWebhookName(req.params.name);
-      const deleteTransformDir = parseBooleanFlag(req?.body?.deleteTransformDir);
-      const deletion = deleteWebhook({ fs, constants, name, deleteTransformDir });
-      if (!deletion?.removed) return res.status(404).json({ ok: false, error: "Webhook not found" });
+      const deleteTransformDir = parseBooleanFlag(
+        req?.body?.deleteTransformDir,
+      );
+      const deletion = deleteWebhook({
+        fs,
+        constants,
+        name,
+        deleteTransformDir,
+      });
+      if (deletion?.managed) {
+        return res.status(409).json({
+          ok: false,
+          error: `Webhook "${name}" is managed by system setup and cannot be deleted`,
+        });
+      }
+      if (!deletion?.removed)
+        return res.status(404).json({ ok: false, error: "Webhook not found" });
       const deletedRequestCount = webhooksDb.deleteRequestsByHook(name);
       const syncWarning = await runWebhookGitSync("delete", name);
       markRestartRequired("webhooks");
@@ -184,9 +212,15 @@ const registerWebhookRoutes = ({
       const limit = Number.parseInt(String(req.query.limit || 50), 10);
       const offset = Number.parseInt(String(req.query.offset || 0), 10);
       const status = normalizeStatusFilter(req.query.status);
-      const hasBadPaging = !isFiniteInteger(limit) || limit <= 0 || !isFiniteInteger(offset) || offset < 0;
+      const hasBadPaging =
+        !isFiniteInteger(limit) ||
+        limit <= 0 ||
+        !isFiniteInteger(offset) ||
+        offset < 0;
       if (hasBadPaging) {
-        return res.status(400).json({ ok: false, error: "Invalid limit/offset" });
+        return res
+          .status(400)
+          .json({ ok: false, error: "Invalid limit/offset" });
       }
       const requests = webhooksDb.getRequests(name, { limit, offset, status });
       return res.json({ ok: true, requests });
@@ -203,7 +237,8 @@ const registerWebhookRoutes = ({
         return res.status(400).json({ ok: false, error: "Invalid request id" });
       }
       const request = webhooksDb.getRequestById(name, requestId);
-      if (!request) return res.status(404).json({ ok: false, error: "Request not found" });
+      if (!request)
+        return res.status(404).json({ ok: false, error: "Request not found" });
       return res.json({ ok: true, request });
     } catch (err) {
       return res.status(400).json({ ok: false, error: err.message });

package/lib/server/usage-db.js

@@ -7,7 +7,10 @@ const kMaxSessionLimit = 200;
 const kDefaultDays = 30;
 const kDefaultMaxPoints = 100;
 const kMaxMaxPoints = 1000;
+const kDayMs = 24 * 60 * 60 * 1000;
 const kTokensPerMillion = 1_000_000;
+const kUtcTimeZone = "UTC";
+const kDayKeyFormatterCache = new Map();
 const kGlobalModelPricing = {
   "claude-opus-4-6": { input: 15.0, output: 75.0 },
   "claude-sonnet-4-6": { input: 3.0, output: 15.0 },
@@ -31,6 +34,39 @@ const coerceInt = (value, fallbackValue = 0) => {
 const clampInt = (value, minValue, maxValue, fallbackValue) =>
   Math.min(maxValue, Math.max(minValue, coerceInt(value, fallbackValue)));
 
+const normalizeTimeZone = (value) => {
+  const raw = String(value || "").trim();
+  if (!raw) return kUtcTimeZone;
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: raw });
+    return raw;
+  } catch {
+    return kUtcTimeZone;
+  }
+};
+
+const getDayKeyFormatter = (timeZone) => {
+  if (kDayKeyFormatterCache.has(timeZone)) {
+    return kDayKeyFormatterCache.get(timeZone);
+  }
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  });
+  kDayKeyFormatterCache.set(timeZone, formatter);
+  return formatter;
+};
+
+const toTimeZoneDayKey = (timestampMs, timeZone) => {
+  const parts = getDayKeyFormatter(timeZone).formatToParts(new Date(timestampMs));
+  const year = parts.find((part) => part.type === "year")?.value || "0000";
+  const month = parts.find((part) => part.type === "month")?.value || "01";
+  const day = parts.find((part) => part.type === "day")?.value || "01";
+  return `${year}-${month}-${day}`;
+};
+
 const resolvePricing = (model) => {
   const normalized = String(model || "").toLowerCase();
   if (!normalized) return null;
@@ -174,11 +210,15 @@ const initUsageDb = ({ rootDir }) => {
 
 const toDayKey = (timestampMs) => new Date(timestampMs).toISOString().slice(0, 10);
 
-const getPeriodRange = (days) => {
+const getPeriodRange = (days, timeZone = kUtcTimeZone) => {
   const now = Date.now();
   const safeDays = clampInt(days, 1, 3650, kDefaultDays);
-  const startMs = now - safeDays * 24 * 60 * 60 * 1000;
-  return { now, safeDays, startDay: toDayKey(startMs) };
+  const startMs = now - safeDays * kDayMs;
+  const normalizedTimeZone = normalizeTimeZone(timeZone);
+  const startDay = normalizedTimeZone === kUtcTimeZone
+    ? toDayKey(startMs)
+    : toTimeZoneDayKey(startMs, normalizedTimeZone);
+  return { now, safeDays, startDay, timeZone: normalizedTimeZone };
 };
 
 const appendCostToRows = (rows) =>
@@ -208,27 +248,253 @@ const appendCostToRows = (rows) =>
     };
   });
 
-const getDailySummary = ({ days = kDefaultDays } = {}) => {
+const parseAgentAndSourceFromSessionRef = (sessionRef) => {
+  const raw = String(sessionRef || "").trim();
+  if (!raw) {
+    return { agent: "unknown", source: "chat" };
+  }
+  const parts = raw.split(":");
+  const agent =
+    parts[0] === "agent" && String(parts[1] || "").trim()
+      ? String(parts[1] || "").trim()
+      : "unknown";
+  const source = parts.includes("hook")
+    ? "hooks"
+    : parts.includes("cron")
+      ? "cron"
+      : "chat";
+  return { agent, source };
+};
+
+const getAgentCostDistribution = ({
+  eventsRows = [],
+  startDay = "",
+  timeZone = kUtcTimeZone,
+}) => {
+  const byAgent = new Map();
+  const ensureAgentBucket = (agent) => {
+    if (byAgent.has(agent)) return byAgent.get(agent);
+    const bucket = {
+      agent,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0,
+      totalTokens: 0,
+      totalCost: 0,
+      turnCount: 0,
+      sourceBreakdown: {
+        chat: {
+          source: "chat",
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheWriteTokens: 0,
+          totalTokens: 0,
+          totalCost: 0,
+          turnCount: 0,
+        },
+        hooks: {
+          source: "hooks",
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheWriteTokens: 0,
+          totalTokens: 0,
+          totalCost: 0,
+          turnCount: 0,
+        },
+        cron: {
+          source: "cron",
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheReadTokens: 0,
+          cacheWriteTokens: 0,
+          totalTokens: 0,
+          totalCost: 0,
+          turnCount: 0,
+        },
+      },
+    };
+    byAgent.set(agent, bucket);
+    return bucket;
+  };
+
+  for (const eventRow of eventsRows) {
+    const timestamp = coerceInt(eventRow.timestamp);
+    const dayKey = timeZone === kUtcTimeZone
+      ? toDayKey(timestamp)
+      : toTimeZoneDayKey(timestamp, timeZone);
+    if (dayKey < startDay) continue;
+
+    const inputTokens = coerceInt(eventRow.input_tokens);
+    const outputTokens = coerceInt(eventRow.output_tokens);
+    const cacheReadTokens = coerceInt(eventRow.cache_read_tokens);
+    const cacheWriteTokens = coerceInt(eventRow.cache_write_tokens);
+    const totalTokens =
+      coerceInt(eventRow.total_tokens) ||
+      inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens;
+    const { totalCost } = deriveCostBreakdown({
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      model: eventRow.model,
+    });
+    const sessionRef = String(eventRow.session_key || eventRow.session_id || "");
+    const { agent, source } = parseAgentAndSourceFromSessionRef(sessionRef);
+    const agentBucket = ensureAgentBucket(agent);
+    const sourceBucket = agentBucket.sourceBreakdown[source];
+
+    agentBucket.inputTokens += inputTokens;
+    agentBucket.outputTokens += outputTokens;
+    agentBucket.cacheReadTokens += cacheReadTokens;
+    agentBucket.cacheWriteTokens += cacheWriteTokens;
+    agentBucket.totalTokens += totalTokens;
+    agentBucket.totalCost += totalCost;
+    agentBucket.turnCount += 1;
+
+    sourceBucket.inputTokens += inputTokens;
+    sourceBucket.outputTokens += outputTokens;
+    sourceBucket.cacheReadTokens += cacheReadTokens;
+    sourceBucket.cacheWriteTokens += cacheWriteTokens;
+    sourceBucket.totalTokens += totalTokens;
+    sourceBucket.totalCost += totalCost;
+    sourceBucket.turnCount += 1;
+  }
+
+  const agents = Array.from(byAgent.values())
+    .map((bucket) => ({
+      agent: bucket.agent,
+      inputTokens: bucket.inputTokens,
+      outputTokens: bucket.outputTokens,
+      cacheReadTokens: bucket.cacheReadTokens,
+      cacheWriteTokens: bucket.cacheWriteTokens,
+      totalTokens: bucket.totalTokens,
+      totalCost: bucket.totalCost,
+      turnCount: bucket.turnCount,
+      sourceBreakdown: ["chat", "hooks", "cron"].map(
+        (source) => bucket.sourceBreakdown[source],
+      ),
+    }))
+    .sort((a, b) => b.totalCost - a.totalCost);
+
+  return {
+    agents,
+    totals: agents.reduce(
+      (acc, agentBucket) => {
+        acc.totalCost += Number(agentBucket.totalCost || 0);
+        acc.totalTokens += Number(agentBucket.totalTokens || 0);
+        acc.turnCount += Number(agentBucket.turnCount || 0);
+        return acc;
+      },
+      { totalCost: 0, totalTokens: 0, turnCount: 0 },
+    ),
+  };
+};
+
+const getDailySummary = ({ days = kDefaultDays, timeZone = kUtcTimeZone } = {}) => {
   const database = ensureDb();
-  const { safeDays, startDay } = getPeriodRange(days);
-  const rows = database
+  const { now, safeDays, startDay, timeZone: normalizedTimeZone } = getPeriodRange(
+    days,
+    timeZone,
+  );
+  let rows = [];
+  if (normalizedTimeZone === kUtcTimeZone) {
+    rows = database
+      .prepare(`
+        SELECT
+          date,
+          model,
+          provider,
+          input_tokens,
+          output_tokens,
+          cache_read_tokens,
+          cache_write_tokens,
+          total_tokens,
+          turn_count
+        FROM usage_daily
+        WHERE date >= $startDay
+        ORDER BY date ASC, total_tokens DESC
+      `)
+      .all({ $startDay: startDay });
+  } else {
+    const lookbackMs = now - (safeDays + 2) * kDayMs;
+    const eventRows = database
+      .prepare(`
+        SELECT
+          timestamp,
+          provider,
+          model,
+          input_tokens,
+          output_tokens,
+          cache_read_tokens,
+          cache_write_tokens,
+          total_tokens
+        FROM usage_events
+        WHERE timestamp >= $lookbackMs
+        ORDER BY timestamp ASC
+      `)
+      .all({ $lookbackMs: lookbackMs });
+    const byDateModel = new Map();
+    for (const eventRow of eventRows) {
+      const dayKey = toTimeZoneDayKey(coerceInt(eventRow.timestamp), normalizedTimeZone);
+      if (dayKey < startDay) continue;
+      const model = String(eventRow.model || "unknown");
+      const mapKey = `${dayKey}\u0000${model}`;
+      if (!byDateModel.has(mapKey)) {
+        byDateModel.set(mapKey, {
+          date: dayKey,
+          model,
+          provider: String(eventRow.provider || "unknown"),
+          input_tokens: 0,
+          output_tokens: 0,
+          cache_read_tokens: 0,
+          cache_write_tokens: 0,
+          total_tokens: 0,
+          turn_count: 0,
+        });
+      }
+      const aggregate = byDateModel.get(mapKey);
+      aggregate.input_tokens += coerceInt(eventRow.input_tokens);
+      aggregate.output_tokens += coerceInt(eventRow.output_tokens);
+      aggregate.cache_read_tokens += coerceInt(eventRow.cache_read_tokens);
+      aggregate.cache_write_tokens += coerceInt(eventRow.cache_write_tokens);
+      aggregate.total_tokens += coerceInt(eventRow.total_tokens);
+      aggregate.turn_count += 1;
+      if (!aggregate.provider && eventRow.provider) {
+        aggregate.provider = String(eventRow.provider || "unknown");
+      }
+    }
+    rows = Array.from(byDateModel.values()).sort((a, b) => {
+      if (a.date === b.date) return b.total_tokens - a.total_tokens;
+      return a.date.localeCompare(b.date);
+    });
+  }
+  const enriched = appendCostToRows(rows);
+  const lookbackMs = now - (safeDays + 2) * kDayMs;
+  const eventsRows = database
     .prepare(`
       SELECT
-        date,
+        timestamp,
+        session_id,
+        session_key,
         model,
-        provider,
         input_tokens,
         output_tokens,
         cache_read_tokens,
         cache_write_tokens,
-        total_tokens,
-        turn_count
-      FROM usage_daily
-      WHERE date >= $startDay
-      ORDER BY date ASC, total_tokens DESC
+        total_tokens
+      FROM usage_events
+      WHERE timestamp >= $lookbackMs
+      ORDER BY timestamp ASC
     `)
-    .all({ $startDay: startDay });
-  const enriched = appendCostToRows(rows);
+    .all({ $lookbackMs: lookbackMs });
+  const costByAgent = getAgentCostDistribution({
+    eventsRows,
+    startDay,
+    timeZone: normalizedTimeZone,
+  });
   const byDate = new Map();
   for (const row of enriched) {
     if (!byDate.has(row.date)) byDate.set(row.date, []);
@@ -294,8 +560,10 @@ const getDailySummary = ({ days = kDefaultDays } = {}) => {
   return {
     updatedAt: Date.now(),
     days: safeDays,
+    timeZone: normalizedTimeZone,
     daily,
     totals,
+    costByAgent,
   };
 };