@saadnvd1/agent-os 0.3.498 → 0.3.501

package/lib/db/migrations.ts

@@ -1507,6 +1507,92 @@ const migrations: Migration[] = [
         );
     },
   },
+  {
+    id: 67,
+    name: "orchestrator_event_log_suppressed",
+    up: (db) => {
+      // A capped event is logged as suppressed so a drop leaves a trace.
+      const columns = db
+        .prepare(`PRAGMA table_info(orchestrator_event_log)`)
+        .all() as { name: string }[];
+      if (!columns.some((c) => c.name === "suppressed"))
+        db.exec(
+          `ALTER TABLE orchestrator_event_log ADD COLUMN suppressed TEXT`
+        );
+    },
+  },
+  {
+    id: 68,
+    name: "usage_calls_and_rollups",
+    up: (db) => {
+      // One row per Claude response (or per one-shot run), the daily rollups
+      // computed from them, the ratchet's baseline and the limit readings.
+      db.transaction(() => {
+        db.exec(`
+          CREATE TABLE IF NOT EXISTS usage_calls (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            call_key TEXT NOT NULL UNIQUE,
+            at INTEGER NOT NULL,
+            session_id TEXT,
+            task_id TEXT,
+            workspace_id TEXT,
+            project_id TEXT,
+            session_name TEXT,
+            role TEXT,
+            kind TEXT NOT NULL,
+            agent_type TEXT,
+            model TEXT,
+            provider TEXT,
+            input_tokens INTEGER NOT NULL DEFAULT 0,
+            cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+            cache_write_5m_tokens INTEGER NOT NULL DEFAULT 0,
+            cache_write_1h_tokens INTEGER NOT NULL DEFAULT 0,
+            output_tokens INTEGER NOT NULL DEFAULT 0,
+            ctx_tokens INTEGER,
+            source TEXT NOT NULL
+          );
+          CREATE INDEX IF NOT EXISTS idx_usage_calls_at ON usage_calls(at);
+          CREATE INDEX IF NOT EXISTS idx_usage_calls_task ON usage_calls(task_id);
+          CREATE INDEX IF NOT EXISTS idx_usage_calls_session ON usage_calls(session_id);
+          CREATE TABLE IF NOT EXISTS rate_limit_readings (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            at INTEGER NOT NULL,
+            window TEXT NOT NULL,
+            utilization REAL NOT NULL,
+            raw REAL,
+            resets_at INTEGER,
+            status TEXT,
+            session_id TEXT,
+            source TEXT NOT NULL
+          );
+          CREATE INDEX IF NOT EXISTS idx_rate_limit_readings ON rate_limit_readings(window, at);
+          CREATE TABLE IF NOT EXISTS usage_rollups (
+            day TEXT PRIMARY KEY,
+            data TEXT NOT NULL,
+            final INTEGER NOT NULL DEFAULT 0,
+            computed_at INTEGER NOT NULL
+          );
+          CREATE TABLE IF NOT EXISTS usage_baseline (
+            metric TEXT PRIMARY KEY,
+            value REAL NOT NULL,
+            set_at INTEGER NOT NULL,
+            supporting TEXT
+          );
+          CREATE TABLE IF NOT EXISTS usage_alerts (
+            kind TEXT PRIMARY KEY,
+            opened_at INTEGER NOT NULL,
+            cleared_at INTEGER,
+            message TEXT NOT NULL
+          );
+          CREATE TABLE IF NOT EXISTS usage_import_offsets (
+            path TEXT PRIMARY KEY,
+            offset INTEGER NOT NULL,
+            mtime INTEGER NOT NULL
+          );
+        `);
+      })();
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/orchestrator/armed.ts

@@ -276,7 +276,8 @@ async function merge(
     return;
   }
   setArmed(task.id, false);
-  // The merged condition would say it again on the next diff.
+  // The merged condition would say it again on the next diff, so this armed
+  // line is the one merged notice. deliver.ts never caps `armed:` events.
   markTold(workspaceId, `merged:${task.id}`, task.id);
   event(
     workspaceId,

package/lib/orchestrator/deliver.ts

@@ -4,10 +4,13 @@ import {
   isAnswer,
   isAwayEvent,
   deliveriesSince,
+  type EventRow,
   lastDeliveredAt,
   logDeliveries,
+  logSuppressed,
   markDelivered,
   pendingEvents,
+  suppressedSince,
   unlogDeliveries,
 } from "./events";
 import { isPaused } from "./pause";
@@ -20,6 +23,25 @@ export const LOW_HOLD_MS = 10 * 60 * 1000;
 export const SUBJECT_CAP = 6;
 const HOUR = 60 * 60 * 1000;
 
+// Terminal and decision events are never capped: a merge, a gate refusal or
+// failure, an escalation to Saad, a drop or close, a review verdict, an
+// ask's answer. A finished task raises nothing after them, so a dropped one
+// is gone for good. The cap is for repeating noise (CI green, stack steps).
+const UNCAPPED = [
+  "merged:",
+  "blocked:",
+  "stack:merged:",
+  "stack:failed:",
+  "stack-status:",
+  "once:armed:", // merged, refused, failed, disarmed, closed
+  "once:review:",
+  "once:ask:",
+  "once:conflict:",
+  "once:plan-done:",
+];
+export const bypassesCap = (e: Pick<EventRow, "key">) =>
+  UNCAPPED.some((p) => e.key.startsWith(p));
+
 export const AGENTOS_SENDER = "agentos";
 
 export type ChatSender = (
@@ -47,7 +69,8 @@ const failing = new Map<string, { failures: number; until: number }>();
 // Rows are marked delivered before the send so a restart can't send them
 // twice. The cost: if the process dies between marking and the send
 // reaching the worker, those events are lost rather than repeated. That's
-// the cheaper failure for a paid turn, and the next change re-raises them.
+// the cheaper failure for a paid turn. (A condition that still holds is
+// re-raised by the next change; a one-off event is not.)
 export async function deliverEvents(opts: {
   workspaceId: string;
   orchestratorId: string;
@@ -62,22 +85,33 @@ export async function deliverEvents(opts: {
   if ((failing.get(workspaceId)?.until ?? 0) > now) return null;
   if (now - lastDeliveredAt(workspaceId) < BATCH_WINDOW_MS) return null;
 
-  // Over a subject's hourly cap: dropped, not sent later.
+  // Over a subject's hourly cap: dropped, not sent later, but logged as
+  // suppressed and counted into the subject's next line. Terminal events
+  // skip the cap.
   const counts = new Map<string, number>();
-  const capped: number[] = [];
+  const capped: EventRow[] = [];
   const pending = pendingEvents(workspaceId).filter((e) => {
-    if (!e.subject) return true;
+    if (!e.subject || bypassesCap(e)) return true;
     const n =
       counts.get(e.subject) ??
       deliveriesSince(workspaceId, e.subject, now - HOUR);
     if (n >= SUBJECT_CAP) {
-      capped.push(e.id);
+      capped.push(e);
       return false;
     }
     counts.set(e.subject, n + 1);
     return true;
   });
-  if (capped.length) markDelivered(capped, now);
+  if (capped.length) {
+    markDelivered(
+      capped.map((e) => e.id),
+      now
+    );
+    logSuppressed(workspaceId, capped, now);
+    console.warn(
+      `[orchestrator] ${capped.length} event(s) over the hourly cap dropped: ${capped.map((e) => e.key).join(", ")}`
+    );
+  }
   if (!pending.length) return null;
   const oldestLow = Math.min(
     ...pending.filter((e) => e.low).map((e) => Date.parse(e.created_at))
@@ -85,7 +119,15 @@ export async function deliverEvents(opts: {
   if (pending.every((e) => e.low) && now - oldestLow < LOW_HOLD_MS) return null;
 
   const ids = pending.map((e) => e.id);
-  const text = [...new Set(pending.map((e) => e.line))].join("\n");
+  const lines = [...new Set(pending.map((e) => e.line))];
+  for (const subject of new Set(pending.map((e) => e.subject))) {
+    const n = subject ? suppressedSince(workspaceId, subject, now - HOUR) : 0;
+    if (n)
+      lines.push(
+        `(+${n} capped event${n === 1 ? "" : "s"} for ${subject} in the last hour)`
+      );
+  }
+  const text = lines.join("\n");
   // Saad's answers to asks, shown in chat as his decisions.
   const decided = [...new Set(pending.filter(isAnswer).map((e) => e.line))];
   const origin: ChatOrigin = {

package/lib/orchestrator/events.ts

@@ -238,6 +238,38 @@ export function logDeliveries(
   )();
 }
 
+// Events held back by the subject cap: logged with the line, never counted
+// as deliveries.
+export function logSuppressed(
+  workspaceId: string,
+  events: Pick<EventRow, "subject" | "key">[],
+  at: number
+): void {
+  const stmt = db.prepare(
+    `INSERT INTO orchestrator_event_log (workspace_id, subject, delivered_at, suppressed) VALUES (?, ?, ?, ?)`
+  );
+  db.transaction(() => {
+    for (const e of events) stmt.run(workspaceId, e.subject, iso(at), e.key);
+  })();
+}
+
+// Events suppressed for a subject in the window.
+export function suppressedSince(
+  workspaceId: string,
+  subject: string,
+  since: number
+): number {
+  return (
+    db
+      .prepare(
+        `SELECT COUNT(*) AS n FROM orchestrator_event_log
+         WHERE workspace_id = ? AND subject = ? AND delivered_at >= ?
+           AND suppressed IS NOT NULL`
+      )
+      .get(workspaceId, subject, iso(since)) as { n: number }
+  ).n;
+}
+
 export function unlogDeliveries(ids: number[]): void {
   const stmt = db.prepare(`DELETE FROM orchestrator_event_log WHERE id = ?`);
   db.transaction(() => ids.forEach((id) => stmt.run(id)))();
@@ -246,7 +278,7 @@ export function unlogDeliveries(ids: number[]): void {
 export function lastDeliveredAt(workspaceId: string): number {
   const row = db
     .prepare(
-      `SELECT MAX(delivered_at) AS at FROM orchestrator_event_log WHERE workspace_id = ?`
+      `SELECT MAX(delivered_at) AS at FROM orchestrator_event_log WHERE workspace_id = ? AND suppressed IS NULL`
     )
     .get(workspaceId) as { at: string | null };
   return row.at ? Date.parse(row.at) : 0;
@@ -261,7 +293,8 @@ export function deliveriesSince(
     db
       .prepare(
         `SELECT COUNT(*) AS n FROM orchestrator_event_log
-         WHERE workspace_id = ? AND subject = ? AND delivered_at >= ?`
+         WHERE workspace_id = ? AND subject = ? AND delivered_at >= ?
+           AND suppressed IS NULL`
       )
       .get(workspaceId, subject, iso(since)) as { n: number }
   ).n;

package/lib/security/auth.ts

@@ -2,6 +2,11 @@
  * Who may use AgentOS once a request has passed the host/origin checks in
  * net.ts. Loopback and the tailnet are trusted as before; anything else
  * (Wi-Fi, a reverse proxy, Connect) needs a paired device's token.
+ *
+ * Connect's tunnel arrives from cloudflared on loopback, so its listener
+ * marks every socket it accepts: a marked socket is never loopback, never
+ * the tailnet and never let in by AGENTOS_AUTH=off, whatever its address,
+ * Host or headers say.
  */
 
 import type { IncomingHttpHeaders } from "http";
@@ -23,8 +28,18 @@ export interface AuthRequest {
   headers: IncomingHttpHeaders;
   remoteAddress?: string;
   localAddress?: string;
+  /** Came through Connect's tunnel listener: a paired device or nothing. */
+  tunnel?: boolean;
 }
 
+const TUNNEL_SOCKETS = new WeakSet<object>();
+/** Called by the tunnel listener for every socket, before any request. */
+export const markTunnelSocket = (socket: object) => {
+  TUNNEL_SOCKETS.add(socket);
+};
+export const isTunnelSocket = (socket: object | null | undefined) =>
+  !!socket && TUNNEL_SOCKETS.has(socket);
+
 export interface AuthPolicy {
   /** This machine's own Tailscale addresses. */
   tailnet: string[];
@@ -146,13 +161,14 @@ export function authorize(req: AuthRequest, policy: AuthPolicy): AuthResult {
 }
 
 function decide(req: AuthRequest, policy: AuthPolicy): AuthResult {
-  const trusted = networkTrust(req, policy);
+  const trusted = req.tunnel ? null : networkTrust(req, policy);
   if (trusted) return { ok: true, via: trusted };
   const token = readToken(req.headers);
   const device = token ? policy.lookup(token) : null;
   if (device) return { ok: true, via: "device", deviceId: device.id };
-  // AGENTOS_AUTH=off is for a login proxy on this side of the network. A
-  // Connect stream has no socket address and must never be let in by it.
-  if (policy.off && req.remoteAddress) return { ok: true, via: "open" };
+  // AGENTOS_AUTH=off is for a login proxy on this side of the network.
+  // Connect's tunnel must never be let in by it.
+  if (policy.off && !req.tunnel && req.remoteAddress)
+    return { ok: true, via: "open" };
   return { ok: false };
 }

package/lib/security/gate.ts

@@ -9,6 +9,7 @@ import {
   authorize,
   cookieToken,
   isPublicPath,
+  isTunnelSocket,
   plainAddress,
   DEVICE_HEADER,
   TRUST_HEADER,
@@ -44,22 +45,24 @@ export function authPolicy(env = process.env): AuthPolicy {
   };
 }
 
-// Connect streams have no address. Give them a fixed label so rate limits
-// can't be steered by headers the caller chose.
-export const sourceLabel = (remote?: string) =>
-  plainAddress(remote) || "connect";
+// Everything through Connect arrives from cloudflared on loopback. Give it
+// a fixed label so rate limits can't be steered by headers the caller chose.
+export const sourceLabel = (remote?: string, tunnel = false) =>
+  tunnel ? "connect" : plainAddress(remote) || "unknown";
 
 function decide(req: IncomingMessage, policy: AuthPolicy): AuthResult {
   // Never trust a client-supplied verdict.
   delete req.headers[DEVICE_HEADER];
   delete req.headers[TRUST_HEADER];
-  req.headers[REMOTE_HEADER] = sourceLabel(req.socket.remoteAddress);
+  const tunnel = isTunnelSocket(req.socket);
+  req.headers[REMOTE_HEADER] = sourceLabel(req.socket.remoteAddress, tunnel);
   const result = authorize(
     {
       url: req.url,
       headers: req.headers,
       remoteAddress: req.socket.remoteAddress,
       localAddress: req.socket.localAddress,
+      tunnel,
     },
     policy
   );

package/lib/security/reach.ts

@@ -44,7 +44,7 @@ export async function reachableAt(): Promise<Reach[]> {
     await tailscaleStatus(),
     lanEnabled() ? lanAddresses() : [],
     port,
-    loadConnect()?.config.hostname ?? null,
+    loadConnect()?.config.hostname || null,
     tailnetHttpsUrl()
   );
 }

package/lib/tasks/index.ts

@@ -4,6 +4,7 @@
  * drops it.
  */
 
+import { taskCosts } from "../usage/calls";
 import {
   parseOverride,
   resolveRole,
@@ -100,6 +101,8 @@ export interface TaskView {
   plan?: { planned: boolean; reason: string | null } | null;
   // A quick change: the orchestrator session that makes it (no agent).
   quickOf?: string | null;
+  // What it has cost so far in weighted tokens (lib/usage/weights).
+  weighted?: number;
 }
 
 export async function createTask(opts: {
@@ -415,6 +418,11 @@ export async function listTasks(): Promise<TaskView[]> {
     Promise.all(sessions.filter((s) => !isMirror(s)).map(taskView)),
     remoteTaskViews(sessions.filter(isMirror)),
   ]);
+  const costs = taskCosts(local.map((t) => t.id));
+  for (const t of local) {
+    const w = costs.get(t.id);
+    if (w) t.weighted = w;
+  }
   return [...local, ...remote].sort((a, b) =>
     b.createdAt.localeCompare(a.createdAt)
   );

package/lib/usage/calls.ts

@@ -0,0 +1,284 @@
+/**
+ * The per-response usage ledger (usage_calls): one row per Claude API
+ * response, keyed by its message id. Claude Code writes one assistant message
+ * per content block under the same id, with usage growing, so a row is
+ * upserted keeping the highest of each field.
+ */
+
+import { db } from "../db";
+import { ANTHROPIC, sessionRole } from "../models/roles";
+import { ctxOf, weighted, type TokenRow } from "./weights";
+
+export type CallKind = "main" | "sub" | "review" | "gate" | "helper";
+export type CallSource = "live" | "transcript" | "check_run" | "helper";
+
+export interface CallRow {
+  callKey: string;
+  at: number;
+  sessionId: string | null;
+  taskId: string | null;
+  workspaceId: string | null;
+  projectId: string | null;
+  sessionName: string | null;
+  role: string | null;
+  kind: CallKind;
+  agentType: string | null;
+  model: string | null;
+  provider: string;
+  input: number;
+  cacheRead: number;
+  cacheWrite5m: number;
+  cacheWrite1h: number;
+  output: number;
+  ctx: number | null;
+  source: CallSource;
+}
+
+// What a driver reports for one response, before it's tied to a session.
+export type CallUsage = Pick<
+  CallRow,
+  | "callKey"
+  | "at"
+  | "kind"
+  | "agentType"
+  | "model"
+  | "input"
+  | "cacheRead"
+  | "cacheWrite5m"
+  | "cacheWrite1h"
+  | "output"
+>;
+
+interface RawUsage {
+  input_tokens?: number;
+  output_tokens?: number;
+  cache_read_input_tokens?: number;
+  cache_creation_input_tokens?: number;
+  cache_creation?: {
+    ephemeral_5m_input_tokens?: number;
+    ephemeral_1h_input_tokens?: number;
+  } | null;
+}
+
+const n = (v: unknown) => (typeof v === "number" && v > 0 ? v : 0);
+
+// The usage on an assistant message, or null for a synthetic one (an error
+// the CLI wrote itself) or one with no id.
+export function callFromAssistant(
+  message: { id?: string; model?: string; usage?: RawUsage } | undefined,
+  kind: CallKind,
+  agentType: string | null,
+  at = Date.now()
+): CallUsage | null {
+  if (!message?.id || !message.usage) return null;
+  if (!message.model || message.model === "<synthetic>") return null;
+  const u = message.usage;
+  const split = u.cache_creation;
+  const w1h = n(split?.ephemeral_1h_input_tokens);
+  // Without the split, the whole write counts as the 5-minute kind.
+  const w5m = split
+    ? n(split.ephemeral_5m_input_tokens)
+    : n(u.cache_creation_input_tokens);
+  return {
+    callKey: message.id,
+    at,
+    kind,
+    agentType,
+    model: message.model,
+    input: n(u.input_tokens),
+    cacheRead: n(u.cache_read_input_tokens),
+    cacheWrite5m: w5m,
+    cacheWrite1h: w1h,
+    output: n(u.output_tokens),
+  };
+}
+
+export function upsertCall(r: CallRow): void {
+  db.prepare(
+    `INSERT INTO usage_calls (call_key, at, session_id, task_id, workspace_id, project_id,
+       session_name, role, kind, agent_type, model, provider, input_tokens, cache_read_tokens,
+       cache_write_5m_tokens, cache_write_1h_tokens, output_tokens, ctx_tokens, source)
+     VALUES (@callKey, @at, @sessionId, @taskId, @workspaceId, @projectId, @sessionName, @role,
+       @kind, @agentType, @model, @provider, @input, @cacheRead, @cacheWrite5m, @cacheWrite1h,
+       @output, @ctx, @source)
+     ON CONFLICT(call_key) DO UPDATE SET
+       input_tokens = MAX(input_tokens, excluded.input_tokens),
+       cache_read_tokens = MAX(cache_read_tokens, excluded.cache_read_tokens),
+       cache_write_5m_tokens = MAX(cache_write_5m_tokens, excluded.cache_write_5m_tokens),
+       cache_write_1h_tokens = MAX(cache_write_1h_tokens, excluded.cache_write_1h_tokens),
+       output_tokens = MAX(output_tokens, excluded.output_tokens),
+       ctx_tokens = MAX(COALESCE(ctx_tokens, 0), COALESCE(excluded.ctx_tokens, 0)),
+       session_id = COALESCE(session_id, excluded.session_id),
+       task_id = COALESCE(task_id, excluded.task_id),
+       workspace_id = COALESCE(workspace_id, excluded.workspace_id),
+       project_id = COALESCE(project_id, excluded.project_id),
+       session_name = COALESCE(session_name, excluded.session_name),
+       role = COALESCE(role, excluded.role)`
+  ).run(r);
+}
+
+export interface SessionContext {
+  sessionId: string;
+  taskId: string | null;
+  workspaceId: string | null;
+  projectId: string | null;
+  sessionName: string | null;
+  role: string | null;
+  provider: string;
+}
+
+// Who a session's calls belong to. Read per call: a plan becomes
+// implementation, and a name changes.
+export function sessionContext(sessionId: string): SessionContext {
+  const s = db
+    .prepare(
+      `SELECT name, workspace_id, project_id, model_provider, role, task_status,
+         plan_phase, started_by FROM sessions WHERE id = ?`
+    )
+    .get(sessionId) as
+    | {
+        name: string;
+        workspace_id: string | null;
+        project_id: string | null;
+        model_provider: string | null;
+        role: string | null;
+        task_status: string | null;
+        plan_phase: string | null;
+        started_by: string | null;
+      }
+    | undefined;
+  return {
+    sessionId,
+    taskId: s?.task_status ? sessionId : null,
+    workspaceId: s?.workspace_id ?? null,
+    projectId: s?.project_id ?? null,
+    sessionName: s?.name ?? null,
+    role: s ? sessionRole(s) : null,
+    provider: s?.model_provider ?? ANTHROPIC,
+  };
+}
+
+export function recordCall(
+  call: CallUsage,
+  ctx: SessionContext,
+  source: CallSource
+): void {
+  const row: CallRow = {
+    ...call,
+    sessionId: ctx.sessionId,
+    taskId: ctx.taskId,
+    workspaceId: ctx.workspaceId,
+    projectId: ctx.projectId,
+    sessionName: ctx.sessionName,
+    role: ctx.role,
+    provider: ctx.provider,
+    ctx: 0,
+    source,
+  };
+  row.ctx = ctxOf({
+    model: row.model,
+    input_tokens: row.input,
+    cache_read_tokens: row.cacheRead,
+    cache_write_5m_tokens: row.cacheWrite5m,
+    cache_write_1h_tokens: row.cacheWrite1h,
+    output_tokens: row.output,
+  });
+  upsertCall(row);
+}
+
+// A call that never goes through a conversation (a check run).
+export function recordLooseCall(
+  r: Omit<CallRow, "ctx" | "provider"> & { provider?: string }
+): void {
+  upsertCall({ ...r, provider: r.provider ?? ANTHROPIC, ctx: null });
+}
+
+// check_runs rows not yet in the ledger, as calls of their own.
+export function backfillCheckRuns(): number {
+  const rows = db
+    .prepare(
+      `SELECT c.id, c.workspace_id, c.session_id, c.label, c.kind, c.model, c.provider,
+         c.input_tokens, c.cache_write_tokens, c.cache_read_tokens, c.output_tokens, c.at,
+         s.project_id FROM check_runs c LEFT JOIN sessions s ON s.id = c.session_id
+       WHERE NOT EXISTS (SELECT 1 FROM usage_calls u WHERE u.call_key = 'check_run:' || c.id)`
+    )
+    .all() as {
+    id: number;
+    workspace_id: string;
+    session_id: string;
+    label: string;
+    kind: string;
+    model: string | null;
+    provider: string | null;
+    input_tokens: number;
+    cache_write_tokens: number;
+    cache_read_tokens: number;
+    output_tokens: number;
+    at: number;
+    project_id: string | null;
+  }[];
+  db.transaction(() => {
+    for (const c of rows) recordCheckRunCall(c.id, c);
+  })();
+  return rows.length;
+}
+
+export function recordCheckRunCall(
+  id: number,
+  c: {
+    workspace_id: string;
+    session_id: string;
+    label: string;
+    kind: string;
+    model: string | null;
+    provider: string | null;
+    input_tokens: number;
+    cache_write_tokens: number;
+    cache_read_tokens: number;
+    output_tokens: number;
+    at: number;
+    project_id?: string | null;
+  }
+): void {
+  recordLooseCall({
+    callKey: `check_run:${id}`,
+    at: c.at,
+    sessionId: c.session_id,
+    taskId: c.session_id ? sessionContext(c.session_id).taskId : null,
+    workspaceId: c.workspace_id,
+    projectId: c.project_id ?? null,
+    sessionName: c.label,
+    role: `gate-${c.kind}`,
+    kind: "gate",
+    agentType: null,
+    model: c.model,
+    provider: c.provider ?? ANTHROPIC,
+    input: c.input_tokens,
+    cacheRead: c.cache_read_tokens,
+    cacheWrite5m: c.cache_write_tokens,
+    cacheWrite1h: 0,
+    output: c.output_tokens,
+    source: "check_run",
+  });
+}
+
+// What each task cost so far in weighted tokens: its own session, its
+// subagents and its gate reviews. One grouped query for the whole list.
+export function taskCosts(ids: string[]): Map<string, number> {
+  const out = new Map<string, number>();
+  if (!ids.length) return out;
+  const marks = ids.map(() => "?").join(",");
+  const rows = db
+    .prepare(
+      `SELECT task_id, model, provider, SUM(input_tokens) AS input_tokens,
+         SUM(cache_read_tokens) AS cache_read_tokens,
+         SUM(cache_write_5m_tokens) AS cache_write_5m_tokens,
+         SUM(cache_write_1h_tokens) AS cache_write_1h_tokens,
+         SUM(output_tokens) AS output_tokens
+       FROM usage_calls WHERE task_id IN (${marks}) GROUP BY task_id, model, provider`
+    )
+    .all(...ids) as (TokenRow & { task_id: string })[];
+  for (const r of rows)
+    out.set(r.task_id, (out.get(r.task_id) ?? 0) + weighted(r));
+  return out;
+}