@saadnvd1/agent-os 0.3.502 → 0.3.505

package/lib/session-logs/index.ts

@@ -0,0 +1,178 @@
+/**
+ * Session logs: when a task merges, AgentOS writes a log of it from data it
+ * already holds. It costs no model tokens, on purpose: nothing in this
+ * folder may call a model (a test holds it to that).
+ *
+ * captureMergedTask is called from every place a task becomes merged
+ * (sign-off, done, a merge seen on GitHub). It reads the plan file at once,
+ * because cleanup removes the worktree, then does the rest in the
+ * background. It runs once per task and never throws into the merge.
+ */
+
+import os from "os";
+import { db, type Session } from "../db";
+import { getProject } from "../projects";
+import { run } from "../tasks/gh";
+import { buildLogMarkdown, sqliteMs } from "./build";
+import { writeLogFile } from "./folder";
+import { gatherLogData, readPlanFile } from "./gather";
+import { hasLog, insertLog, setFilePath } from "./store";
+
+export * from "./store";
+export { buildLogMarkdown } from "./build";
+export { logFolder, setLogFolder } from "./folder";
+
+const inFlight = new Map<string, Promise<void>>();
+// Tasks known to have a log, so a poll that sees a merged PR again asks
+// nothing of the database.
+const done = new Set<string>();
+
+const sqliteNow = () => new Date().toISOString().replace("T", " ").slice(0, 19);
+
+export interface CaptureOpts {
+  // The PR's head at the merge, when the caller knows it.
+  head?: string | null;
+  // The plan, when it was read already; else the worktree is read now.
+  plan?: string | null;
+  // A log written after the worktree went (the backfill).
+  planKept?: boolean;
+  // Skip asking GitHub for the merge commit (a batch of old tasks).
+  noGh?: boolean;
+}
+
+function eligible(s: Session | undefined): s is Session {
+  return (
+    !!s &&
+    !!s.task_prompt &&
+    !s.peer_mirror &&
+    s.task_status !== "dropped" &&
+    (s.task_status === "merged" || s.pr_status === "merged")
+  );
+}
+
+async function mergeCommitOf(s: Session): Promise<string | null> {
+  const project = s.project_id ? getProject(s.project_id) : undefined;
+  if (!project || !s.pr_number || process.env.AGENTOS_SESSION_LOGS_NO_GH)
+    return null;
+  try {
+    const out = await run(
+      "gh",
+      [
+        "pr",
+        "view",
+        String(s.pr_number),
+        "--json",
+        "mergeCommit",
+        "-q",
+        ".mergeCommit.oid",
+      ],
+      project.working_directory.replace(/^~/, os.homedir()),
+      15_000
+    );
+    return out.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+export async function writeLog(
+  id: string,
+  opts: CaptureOpts & { plan?: string | null } = {}
+): Promise<boolean> {
+  const row = db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+    | Session
+    | undefined;
+  if (!eligible(row) || hasLog(id)) return false;
+  const s = { ...row, merged_at: row.merged_at ?? sqliteNow() };
+  const mergeCommit = opts.noGh ? null : await mergeCommitOf(s);
+  const data = gatherLogData(s, {
+    plan: opts.plan ?? null,
+    planKept: opts.planKept ?? true,
+    head: opts.head ?? null,
+    mergeCommit: mergeCommit ?? (opts.head ? `${opts.head} (PR head)` : null),
+  });
+  const markdown = buildLogMarkdown(data);
+  const start = sqliteMs(data.startedAt);
+  const end = sqliteMs(data.mergedAt);
+  const stored = insertLog({
+    sessionId: id,
+    projectId: s.project_id,
+    workspaceId:
+      s.workspace_id ?? getProject(s.project_id ?? "")?.workspace_id ?? null,
+    markdown,
+    header: {
+      id,
+      name: data.name,
+      workspace: data.workspace,
+      project: data.project,
+      branch: data.branch,
+      prNumber: data.prNumber,
+      prUrl: data.prUrl,
+      mergeCommit: data.mergeCommit,
+      startedAt: data.startedAt,
+      mergedAt: data.mergedAt,
+      durationMs: start !== null && end !== null ? end - start : null,
+      costUsd: data.usage.reduce((t, u) => t + u.costUsd, 0),
+      planKept: data.planKept,
+      hasPlan: data.plan !== null,
+    },
+    filePath: null,
+  });
+  if (!stored) return false;
+  try {
+    const file = writeLogFile(
+      {
+        workspace: data.workspace,
+        project: data.project,
+        projectId: s.project_id,
+        name: data.name,
+        id,
+        day: (data.mergedAt ?? sqliteNow()).slice(0, 10),
+      },
+      markdown
+    );
+    setFilePath(id, file);
+  } catch (error) {
+    // The database holds the log; the file is a copy.
+    console.error(`[session-logs] file for ${id}:`, error);
+  }
+  return true;
+}
+
+export function captureMergedTask(
+  id: string,
+  opts: CaptureOpts = {}
+): Promise<void> {
+  if (done.has(id)) return Promise.resolve();
+  const running = inFlight.get(id);
+  if (running) return running;
+  let plan: string | null | undefined = opts.plan;
+  try {
+    if (plan === undefined) {
+      const row = db
+        .prepare(`SELECT worktree_path FROM sessions WHERE id = ?`)
+        .get(id) as { worktree_path: string | null } | undefined;
+      plan = readPlanFile(row?.worktree_path ?? null);
+    }
+  } catch (error) {
+    console.error(`[session-logs] plan for ${id}:`, error);
+  }
+  const job = (async () => {
+    // After the caller's own work: the merge never waits on this.
+    await new Promise<void>((r) => setImmediate(r));
+    try {
+      await writeLog(id, { ...opts, plan });
+      if (hasLog(id)) done.add(id);
+    } catch (error) {
+      console.error(`[session-logs] ${id}:`, error);
+    }
+  })().finally(() => inFlight.delete(id));
+  inFlight.set(id, job);
+  return job;
+}
+
+// Tests start from nothing.
+export function resetSessionLogState(): void {
+  done.clear();
+  inFlight.clear();
+}

package/lib/session-logs/store.ts

@@ -0,0 +1,105 @@
+import { db } from "../db";
+
+// What the list and the orchestrator's tool show of a log without its text.
+export interface LogHeader {
+  id: string;
+  name: string;
+  workspace: string | null;
+  project: string | null;
+  branch: string | null;
+  prNumber: number | null;
+  prUrl: string | null;
+  mergeCommit: string | null;
+  startedAt: string | null;
+  mergedAt: string | null;
+  durationMs: number | null;
+  costUsd: number;
+  planKept: boolean;
+  hasPlan: boolean;
+  createdAt: string;
+  filePath: string | null;
+}
+
+export interface LogRow {
+  session_id: string;
+  project_id: string | null;
+  workspace_id: string | null;
+  created_at: string;
+  markdown: string;
+  data: string;
+  file_path: string | null;
+}
+
+export const hasLog = (sessionId: string): boolean =>
+  !!db
+    .prepare(`SELECT 1 FROM session_logs WHERE session_id = ?`)
+    .get(sessionId);
+
+export function getLog(sessionId: string): LogRow | null {
+  return (
+    (db
+      .prepare(`SELECT * FROM session_logs WHERE session_id = ?`)
+      .get(sessionId) as LogRow | undefined) ?? null
+  );
+}
+
+// True when this call stored it: a log already there is never replaced.
+export function insertLog(row: {
+  sessionId: string;
+  projectId: string | null;
+  workspaceId: string | null;
+  markdown: string;
+  header: Omit<LogHeader, "createdAt" | "filePath">;
+  filePath: string | null;
+}): boolean {
+  return (
+    db
+      .prepare(
+        `INSERT OR IGNORE INTO session_logs
+           (session_id, project_id, workspace_id, markdown, data, file_path)
+         VALUES (?, ?, ?, ?, ?, ?)`
+      )
+      .run(
+        row.sessionId,
+        row.projectId,
+        row.workspaceId,
+        row.markdown,
+        JSON.stringify(row.header),
+        row.filePath
+      ).changes > 0
+  );
+}
+
+export function setFilePath(sessionId: string, filePath: string): void {
+  db.prepare(`UPDATE session_logs SET file_path = ? WHERE session_id = ?`).run(
+    filePath,
+    sessionId
+  );
+}
+
+const toHeader = (r: LogRow): LogHeader => ({
+  ...(JSON.parse(r.data) as LogHeader),
+  createdAt: r.created_at,
+  filePath: r.file_path,
+});
+
+export const headerOf = (r: LogRow): LogHeader => toHeader(r);
+
+// Newest merge first.
+export function listLogs(
+  where: { projectId?: string; workspaceId?: string },
+  limit = 50
+): LogHeader[] {
+  const rows = db
+    .prepare(
+      `SELECT * FROM session_logs
+       WHERE (@p IS NULL OR project_id = @p) AND (@w IS NULL OR workspace_id = @w)
+       ORDER BY json_extract(data, '$.mergedAt') DESC, created_at DESC LIMIT @n`
+    )
+    .all({
+      p: where.projectId ?? null,
+      w: where.workspaceId ?? null,
+      n: Math.max(1, Math.min(limit, 500)),
+    }) as LogRow[];
+  return rows.map(toHeader);
+}

package/lib/sidebar/live-status.ts

@@ -0,0 +1,52 @@
+import {
+  PR_STAGE_BUSY,
+  PR_STAGE_SHORT,
+  type PrStage,
+  type PrStageName,
+} from "../tasks/pr-stage";
+
+export type LiveTone = "blue" | "amber" | "red" | "green" | "purple" | "muted";
+
+export interface LivePart {
+  text: string;
+  tone: LiveTone;
+  // Still moving on its own: the UI shows a spinner.
+  busy?: boolean;
+}
+
+export const PR_STAGE_TONE: Record<PrStageName, LiveTone> = {
+  merged: "purple",
+  conflicts: "amber",
+  "ci-failed": "red",
+  "ci-running": "blue",
+  "ci-settling": "blue",
+  "review-running": "blue",
+  "review-blocked": "red",
+  waiting: "amber",
+  armed: "green",
+  open: "muted",
+};
+
+// What the row's second line says about the session right now, in order:
+// "Compacting", then "PR CI". Empty when there is nothing to say.
+export function liveParts(input: {
+  compacting?: boolean;
+  prStage?: PrStage;
+}): LivePart[] {
+  const parts: LivePart[] = [];
+  if (input.compacting)
+    parts.push({ text: "Compacting", tone: "blue", busy: true });
+  const s = input.prStage;
+  if (s) {
+    const word = PR_STAGE_SHORT[s.stage];
+    parts.push({
+      text: s.stage === "open" ? "PR" : `PR ${word}`,
+      tone: PR_STAGE_TONE[s.stage],
+      busy: PR_STAGE_BUSY.has(s.stage),
+    });
+  }
+  return parts;
+}
+
+export const liveText = (parts: LivePart[]) =>
+  parts.map((p) => p.text).join(" · ");

package/lib/sidebar/shelves.ts

@@ -2,6 +2,7 @@
 // orchestrator, Pinned, Needs you, Working, then Done. Client-safe: no database.
 import type { Session } from "@/lib/db/types";
 import { fromSqliteTime } from "@/lib/session-meta";
+import type { PrStage } from "@/lib/tasks/pr-stage";
 import type { TaskState } from "@/lib/tasks/state";
 
 // Why a session is blocked on you.
@@ -33,6 +34,7 @@ export interface RowStatus {
   // A chat summarising its context (status stays "running").
   compacting?: { since: number; before?: number };
   asks?: number;
+  prStage?: PrStage;
   // A program's own message (OSC 7501): untrusted, plain text only.
   detail?: string | null;
 }
@@ -264,6 +266,9 @@ function sameStatus(a: RowStatus | undefined, b: RowStatus | undefined) {
     (a.compacting?.since ?? null) === (b.compacting?.since ?? null) &&
     (a.compacting?.before ?? null) === (b.compacting?.before ?? null) &&
     a.asks === b.asks &&
+    (a.prStage?.stage ?? null) === (b.prStage?.stage ?? null) &&
+    (a.prStage?.number ?? null) === (b.prStage?.number ?? null) &&
+    (a.prStage?.sha ?? null) === (b.prStage?.sha ?? null) &&
     (a.detail ?? null) === (b.detail ?? null)
   );
 }

package/lib/status/collect.ts

@@ -30,6 +30,8 @@ import {
   terminalStatus,
 } from "../needs-you";
 import type { SessionNeed } from "../sidebar/shelves";
+import type { PrStage } from "../tasks/pr-stage";
+import { addPrStages } from "./pr-stages";
 import type { Compacting } from "../chat/events";
 import { openAskCount } from "../orchestrator/asks";
 import { lastUserTask } from "../chat/store";
@@ -65,6 +67,8 @@ export interface SessionStatusResponse {
   stalled?: boolean;
   // A chat whose agent is summarising its context ("status" stays running).
   compacting?: Compacting;
+  // Where a task's PR is in the gates (lib/tasks/pr-stage.ts).
+  prStage?: PrStage;
   // A program's own message (OSC 7501): untrusted, plain text only.
   detail?: string | null;
   progress?: number | null;
@@ -477,6 +481,8 @@ async function collect(): Promise<StatusSnapshot> {
     };
   }
 
+  addPrStages(statusMap);
+
   // Cleanup old trackers
   statusDetector.cleanup();
 

package/lib/status/pr-stages.ts

@@ -0,0 +1,55 @@
+// A task's PR stage for the sidebar, from state AgentOS already holds: the
+// PR as the last poll saw it, the stored review and CI checks, escalations,
+// asks and the armed flag. Nothing here asks GitHub.
+import { db, type Session } from "../db";
+import { cachedPR, storedPR } from "../tasks/session";
+import { derivePrStage } from "../tasks/pr-stage";
+import { getCheck } from "../orchestrator/checks";
+import { holdingEscalations } from "../orchestrator/gates";
+import { openBySubject, workSubject } from "../orchestrator/asks";
+import { ciSettleLeft } from "../orchestrator/task-state";
+import { knownCommitTime } from "../orchestrator/facts";
+import type { SessionStatusResponse } from "./collect";
+
+type TaskRow = Session & { workspace_id: string };
+
+export function addPrStages(
+  statuses: Record<string, SessionStatusResponse>
+): void {
+  const tasks = db
+    .prepare(
+      `SELECT s.*, p.workspace_id FROM sessions s
+         JOIN projects p ON p.id = s.project_id
+        WHERE s.task_status = 'running' AND s.pr_number IS NOT NULL
+          AND s.archived_at IS NULL`
+    )
+    .all() as TaskRow[];
+  for (const t of tasks) {
+    const status = statuses[t.id];
+    if (!status) continue;
+    try {
+      const pr = cachedPR(t.id) ?? storedPR(t);
+      const head = pr?.head;
+      const stage = derivePrStage({
+        pr,
+        settleIn:
+          pr?.checks === "pass" && head
+            ? ciSettleLeft({
+                taskId: t.id,
+                sha: head,
+                checkCount: pr.checkCount ?? 0,
+                committedAt: knownCommitTime(head),
+              })
+            : 0,
+        review: head ? (getCheck(t.id, head, "review")?.status ?? null) : null,
+        held:
+          holdingEscalations(t.id).length > 0 ||
+          !!openBySubject(t.workspace_id, workSubject(t.id)),
+        armed: !!t.merge_armed_at,
+      });
+      if (stage) status.prStage = stage;
+    } catch (error) {
+      console.error(`[status] PR stage of ${t.id.slice(0, 8)}:`, error);
+    }
+  }
+}

package/lib/tasks/finish.ts

@@ -23,6 +23,7 @@ import { getProject } from "../projects";
 import { canSignOff } from "./state";
 import { forgetPR, getTaskSession, prFor, projectPathFor } from "./session";
 import { dropSessionDatabase } from "../project-config/database";
+import { captureMergedTask } from "../session-logs";
 
 // Never deleted, whatever a setting says.
 export const PROTECTED_BRANCHES = new Set(["main", "master", "HEAD"]);
@@ -154,6 +155,8 @@ export async function signOffTask(
     signingOff.delete(id);
   }
   syncTaskCardInBackground(session, "merged", pr);
+  // Reads the plan file now: cleanup below removes the worktree.
+  void captureMergedTask(id, { head: opts.head ?? pr!.head ?? null });
   const head = opts.head ?? pr!.head;
   resolveMergedTaskAsks(
     id,

package/lib/tasks/pr-stage.ts

@@ -0,0 +1,106 @@
+// Where a task's PR is in the gates, as one word for the UI. Pure: the
+// inputs are what AgentOS already tracks for the PR (tasks/state.ts,
+// orchestrator/checks.ts), so nothing here asks GitHub or a model.
+
+export const PR_STAGES = [
+  "merged",
+  "conflicts",
+  "ci-failed",
+  "ci-running",
+  "ci-settling",
+  "review-running",
+  "review-blocked",
+  "waiting",
+  "armed",
+  "open",
+] as const;
+
+export type PrStageName = (typeof PR_STAGES)[number];
+
+export interface PrStage {
+  stage: PrStageName;
+  number: number;
+  url: string;
+  // The PR's head, 7 characters.
+  sha?: string;
+}
+
+export interface PrStageInput {
+  pr: {
+    number: number;
+    url: string;
+    state: "OPEN" | "MERGED" | "CLOSED";
+    checks: "pass" | "fail" | "pending" | "none";
+    head?: string;
+    mergeable?: "MERGEABLE" | "CONFLICTING" | "UNKNOWN";
+  } | null;
+  // Seconds until CI on the head counts as settled (0 or unset: settled).
+  settleIn?: number;
+  // The newest review of the head commit.
+  review?: "running" | "pass" | "block" | "error" | null;
+  // Escalated to Saad, or an ask of his open on it.
+  held?: boolean;
+  armed?: boolean;
+}
+
+// In priority order: the first that applies wins, so a conflict hides the
+// CI behind it and a failed CI hides a review that would be moot.
+export function derivePrStage(input: PrStageInput): PrStage | null {
+  const { pr } = input;
+  if (!pr || pr.state === "CLOSED") return null;
+  const base = {
+    number: pr.number,
+    url: pr.url,
+    ...(pr.head && { sha: pr.head.slice(0, 7) }),
+  };
+  const at = (stage: PrStageName): PrStage => ({ stage, ...base });
+  if (pr.state === "MERGED") return at("merged");
+  if (pr.mergeable === "CONFLICTING") return at("conflicts");
+  if (pr.checks === "fail") return at("ci-failed");
+  if (pr.checks === "pending") return at("ci-running");
+  if (pr.checks === "pass" && (input.settleIn ?? 0) > 0)
+    return at("ci-settling");
+  if (input.review === "running") return at("review-running");
+  if (input.review === "block") return at("review-blocked");
+  if (input.held) return at("waiting");
+  if (input.armed) return at("armed");
+  return at("open");
+}
+
+// Stages still moving on their own: the badge spins for these.
+export const PR_STAGE_BUSY: ReadonlySet<PrStageName> = new Set([
+  "conflicts",
+  "ci-running",
+  "ci-settling",
+  "review-running",
+]);
+
+export const PR_STAGE_LABEL: Record<PrStageName, string> = {
+  merged: "merged",
+  conflicts: "rebasing",
+  "ci-failed": "CI failed",
+  "ci-running": "CI running",
+  "ci-settling": "CI settling",
+  "review-running": "reviewing",
+  "review-blocked": "review blocked",
+  waiting: "waiting on you",
+  armed: "armed",
+  open: "open",
+};
+
+export const prStageText = (s: Pick<PrStage, "stage" | "number">) =>
+  `PR #${s.number} · ${PR_STAGE_LABEL[s.stage]}`;
+
+// The short wording for the badge itself; the full wording is the tooltip.
+export const PR_STAGE_SHORT: Record<PrStageName, string> = {
+  merged: "Merged",
+  conflicts: "Conflicts",
+  "ci-failed": "CI failed",
+  "ci-running": "CI",
+  "ci-settling": "CI",
+  "review-running": "Review",
+  "review-blocked": "Blocked",
+  waiting: "Waiting on you",
+  armed: "Armed",
+  open: "PR",
+};

package/lib/tasks/session.ts

@@ -9,6 +9,8 @@ import { getProject } from "../projects";
 import { findPRStrict } from "./gh";
 import { currentBranch, git } from "../git-exec";
 import { lookupPR } from "./pr-poll";
+import { captureMergedTask } from "../session-logs";
+import { notifyStatusChanged } from "../status/hub";
 import type { TaskPR } from "./state";
 
 export const expandHome = (p: string) => p.replace(/^~/, os.homedir());
@@ -128,6 +130,15 @@ export const isoUTC = (t: string) =>
 
 const prCache = new Map<string, { at: number; pr: TaskPR | null }>();
 
+const prSignature = (pr: TaskPR | null | undefined) =>
+  pr
+    ? `${pr.number}|${pr.state}|${pr.checks}|${pr.head}|${pr.mergeable}|${pr.checkCount}`
+    : "";
+
+// The PR as the last poll saw it, with no gh call; undefined before one.
+export const cachedPR = (sessionId: string): TaskPR | null | undefined =>
+  prCache.get(sessionId)?.pr;
+
 // strict: a gh failure throws instead of reading as "no PR".
 export async function prFor(
   session: Session,
@@ -167,11 +178,17 @@ export async function prFor(
     }
   }
   if (renamed && !refused) moveBranch(session, renamed);
+  const before = prCache.get(session.id)?.pr;
   prCache.set(session.id, { at: Date.now(), pr });
+  // A PR whose stage inputs moved is news for the sidebar's badge.
+  if (prSignature(before) !== prSignature(pr)) notifyStatusChanged();
   if (pr) {
     db.prepare(
       `UPDATE sessions SET pr_url = ?, pr_number = ?, pr_status = ? WHERE id = ?`
     ).run(pr.url, pr.number, pr.state.toLowerCase(), session.id);
+    // Merged on GitHub rather than through AgentOS: its log is due too.
+    if (pr.state === "MERGED")
+      void captureMergedTask(session.id, { head: pr.head });
   }
   // Only an answer just read from GitHub: a cached one may predate a
   // retarget AgentOS made itself (a restack).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.502",
+  "version": "0.3.505",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"

package/scripts/backfill-session-logs.ts

@@ -0,0 +1,70 @@
+/**
+ * Writes session logs for tasks that merged before logs existed, from what
+ * the database still holds. Their plan files went with their worktrees, so
+ * each says "plan not kept". Idempotent: a task with a log is skipped.
+ *
+ *   npx tsx scripts/backfill-session-logs.ts --db <path to agent-os.db> [--no-gh] [--dry]
+ *
+ * --db is required so a run never lands on a database by accident. Files go
+ * where new logs go (~/.agent-os/session-logs, or a project's folder); run
+ * with HOME set elsewhere to keep a trial away from the real folder.
+ * --no-gh skips asking GitHub for each merge commit.
+ */
+
+const args = process.argv.slice(2);
+const flag = (name: string) => args.includes(name);
+const dbPath = args[args.indexOf("--db") + 1];
+
+if (!flag("--db") || !dbPath || dbPath.startsWith("--")) {
+  console.error(
+    "usage: backfill-session-logs.ts --db <path> [--no-gh] [--dry]"
+  );
+  process.exit(2);
+}
+process.env.DB_PATH = dbPath;
+
+async function main() {
+  const { db } = await import("../lib/db");
+  const { writeLog } = await import("../lib/session-logs");
+  const { hasLog } = await import("../lib/session-logs/store");
+  const rows = db
+    .prepare(
+      `SELECT id, name FROM sessions
+       WHERE task_prompt IS NOT NULL AND peer_mirror = 0
+         AND (task_status = 'merged' OR (pr_status = 'merged' AND task_status != 'dropped'))
+       ORDER BY COALESCE(merged_at, updated_at)`
+    )
+    .all() as { id: string; name: string }[];
+  const todo = rows.filter((r) => !hasLog(r.id));
+  console.log(
+    `${rows.length} merged tasks, ${rows.length - todo.length} already logged, ${todo.length} to write${flag("--dry") ? " (dry run)" : ""}`
+  );
+  let written = 0;
+  for (const r of todo) {
+    if (flag("--dry")) {
+      console.log(`  would log ${r.name} (${r.id.slice(0, 8)})`);
+      continue;
+    }
+    try {
+      const ok = await writeLog(r.id, {
+        planKept: false,
+        noGh: flag("--no-gh"),
+      });
+      if (ok) written++;
+      console.log(
+        `  ${ok ? "logged" : "skipped"} ${r.name} (${r.id.slice(0, 8)})`
+      );
+    } catch (error) {
+      console.error(`  FAILED ${r.name} (${r.id.slice(0, 8)}):`, error);
+    }
+  }
+  console.log(`wrote ${written} logs`);
+}
+
+main().then(
+  () => process.exit(0),
+  (error) => {
+    console.error(error);
+    process.exit(1);
+  }
+);