@saadnvd1/agent-os 0.3.460 → 0.3.462

package/data/away/index.ts

@@ -0,0 +1,73 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { AwayView } from "@/lib/away/view";
+import { post } from "../orchestrators";
+import { usePollWhenOffline } from "../push/connection";
+
+export const awayKeys = {
+  all: ["away"] as const,
+};
+
+export function useAwayQuery() {
+  return useQuery({
+    queryKey: awayKeys.all,
+    queryFn: async () => {
+      const res = await fetch("/api/away");
+      if (!res.ok) throw new Error(`Request failed (${res.status})`);
+      return (await res.json()) as AwayView;
+    },
+    staleTime: 10_000,
+    // Pushed when it changes (away_periods); a minute catches it running
+    // out while the stream is down.
+    refetchInterval: usePollWhenOffline(60_000),
+  });
+}
+
+// expiresAt null: until he's back. `false` turns it off.
+export function useSetAway() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (on: false | { expiresAt: Date | null }) =>
+      post(
+        "/api/away",
+        on
+          ? { on: true, expiresAt: on.expiresAt?.toISOString() ?? null }
+          : { on: false }
+      ) as Promise<AwayView>,
+    onSuccess: (view) => queryClient.setQueryData(awayKeys.all, view),
+    onSettled: () => queryClient.invalidateQueries({ queryKey: awayKeys.all }),
+  });
+}
+
+export function useDismissAwayReport() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (id: number) => post("/api/away/seen", { id }),
+    onMutate: () =>
+      queryClient.setQueryData<AwayView>(awayKeys.all, (prev) =>
+        prev ? { ...prev, report: null } : prev
+      ),
+    onSettled: () => queryClient.invalidateQueries({ queryKey: awayKeys.all }),
+  });
+}
+
+// The choices the toggle offers, as when each ends.
+export const AWAY_DURATIONS = [
+  { id: "1h", label: "For 1 hour" },
+  { id: "4h", label: "For 4 hours" },
+  { id: "morning", label: "Until morning" },
+  { id: "back", label: "Until I'm back" },
+] as const;
+
+export type AwayDuration = (typeof AWAY_DURATIONS)[number]["id"];
+
+// "Until morning" is 8 AM, local: today's if it's still before 5 AM,
+// else tomorrow's.
+export function awayEnds(d: AwayDuration, now = new Date()): Date | null {
+  if (d === "1h") return new Date(now.getTime() + 60 * 60 * 1000);
+  if (d === "4h") return new Date(now.getTime() + 4 * 60 * 60 * 1000);
+  if (d === "back") return null;
+  const morning = new Date(now);
+  morning.setHours(8, 0, 0, 0);
+  if (now.getHours() >= 5) morning.setDate(morning.getDate() + 1);
+  return morning;
+}

package/data/push/topics.ts

@@ -12,6 +12,7 @@ import { ruleKeys } from "../orchestrators/rules";
 import { workspaceKeys } from "../workspaces";
 import { scheduleKeys } from "../schedules";
 import { archivedKeys } from "../done";
+import { awayKeys } from "../away";
 
 // What each pushed topic (a table that changed, lib/db/changes.ts, or a
 // pushed view) means the browser should refetch. Only queries on screen
@@ -56,6 +57,8 @@ function keysFor(topic: string): QueryKey[] {
       return [orchestratorKeys.all];
     case "orchestrator_rules":
       return [ruleKeys.all];
+    case "away_periods":
+      return [awayKeys.all];
     case "dev_servers":
       return [devServerKeys.all];
     default:
@@ -96,6 +99,7 @@ export const ALL_TOPICS = [
   "schedules",
   "orchestrator_asks",
   "orchestrator_rules",
+  "away_periods",
   "dev_servers",
 ];
 

package/lib/away/brief.ts

@@ -0,0 +1,23 @@
+/**
+ * What an orchestrator is told while Saad is away: the event that turns
+ * Away on, and the line leading its brief's digest on a fresh start.
+ */
+
+import {
+  activeAway,
+  clockTime,
+  fromSql,
+  untilText,
+  type AwayRow,
+} from "./state";
+import { SWEEP_EVERY_MS } from "./sweep";
+
+export function awayOnLine(row: AwayRow, now = Date.now()): string {
+  return `Saad is away (Away mode, since ${clockTime(fromSql(row.started_at), now)}, ${untilText(row, now)}). Follow work through rather than only reacting to events: keep each task moving to merged and deployed, sign off what passes its gates, and pick up what stalled. Every ${SWEEP_EVERY_MS / 60000} minutes AgentOS sweeps: it nudges stalled tasks, asks idle ones with uncommitted work to commit and open a PR, runs lost reviews again and checks the deploy after each merge; what needs you comes as events, and each step is in your log. Interactive sessions (not tasks) are Saad's: in Away mode only ask them to wrap up, never drive them further. Hard lines still go to ask_saad; while he's away his asks reach his phone in one batch per sweep, so raise them as usual. \`aos notify\` is held for that batch too, so don't send one per item.`;
+}
+
+// For the digest: the same line while Away is on, else nothing.
+export function awayDigestLine(now = Date.now()): string | null {
+  const row = activeAway();
+  return row ? awayOnLine(row, now) : null;
+}

package/lib/away/deploy.ts

@@ -0,0 +1,173 @@
+/**
+ * After a merge, did the deploy land and the server come back healthy? Read
+ * from the project's `deploy` config (agentos.json): the file its deploy
+ * writes the deployed commit to (scripts/autodeploy's `deployed`), the file
+ * it writes a commit whose deploy failed to (`alerted`), and a health URL.
+ * A project without one isn't checked; a missing `deployed` file means no
+ * deploy runs on this machine, which isn't a failure either.
+ */
+
+import fs from "fs";
+import type { ProjectConfig } from "../project-config";
+import { run } from "../tasks/gh";
+import { expandHome } from "../tasks/session";
+import { selfUrl } from "../agents/self-env";
+import { commitTime } from "../orchestrator/repo";
+
+export type DeployConfig = NonNullable<ProjectConfig["deploy"]>;
+
+export type DeployVerdict =
+  | { state: "ok"; detail: string }
+  | { state: "failed"; detail: string }
+  | { state: "pending" }
+  | { state: "unchecked"; detail: string };
+
+export const DEPLOY_WITHIN_MIN = 30;
+// After the deploy lands, the server gets this long to answer healthy.
+export const HEALTH_GRACE_MS = 3 * 60 * 1000;
+
+export interface DeployDeps {
+  // The commit a state file names, or null when there's no such file.
+  readSha: (file: string) => { sha: string; at: number } | null;
+  // Whether `sha` is in the history of `tip` (fetching it if need be);
+  // throws when that can't be told.
+  contains: (repo: string, tip: string, sha: string) => Promise<boolean>;
+  // startedAt, when the server says when it started (AgentOS's
+  // /api/health does), so a deploy that never restarted it is caught.
+  health: (
+    url: string
+  ) => Promise<{ ok: boolean; why?: string; startedAt?: number }>;
+  // When GitHub made the merge commit, in ms (0 when unknown): the time a
+  // restart has to come after. Not when AgentOS noticed the merge, which
+  // can be after a restart that already took it.
+  committedAt: (repo: string, sha: string) => Promise<number>;
+}
+
+const SHA = /^[0-9a-f]{40}$/;
+
+function readSha(file: string): { sha: string; at: number } | null {
+  try {
+    const full = expandHome(file);
+    const sha = fs.readFileSync(full, "utf-8").slice(0, 80).trim();
+    return SHA.test(sha) ? { sha, at: fs.statSync(full).mtimeMs } : null;
+  } catch {
+    return null;
+  }
+}
+
+async function contains(
+  repo: string,
+  tip: string,
+  sha: string
+): Promise<boolean> {
+  if (tip === sha) return true;
+  const ancestor = () =>
+    run("git", ["merge-base", "--is-ancestor", sha, tip], repo).then(
+      () => true,
+      () => false
+    );
+  if (await ancestor()) return true;
+  // The deployed commit may be newer than this checkout knows. A fetch that
+  // fails throws, so stale refs never read as "not deployed".
+  await run("git", ["fetch", "--quiet", "origin"], repo);
+  return ancestor();
+}
+
+async function health(
+  url: string
+): Promise<{ ok: boolean; why?: string; startedAt?: number }> {
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(5000) });
+    if (!res.ok) return { ok: false, why: `HTTP ${res.status}` };
+    const body = (await res.json().catch(() => null)) as {
+      startedAt?: unknown;
+    } | null;
+    const startedAt =
+      typeof body?.startedAt === "string" ? Date.parse(body.startedAt) : NaN;
+    return Number.isFinite(startedAt) ? { ok: true, startedAt } : { ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      why: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+export const DEFAULT_DEPS: DeployDeps = {
+  readSha,
+  contains,
+  health,
+  committedAt: async (repo, sha) =>
+    (await commitTime(repo, sha).catch(() => 0)) * 1000,
+};
+
+// A path alone is this AgentOS server's own.
+export const healthUrl = (health: string) =>
+  health.startsWith("/") ? `${selfUrl()}${health}` : health;
+
+// Pending when it can't be told yet (git couldn't fetch): the next sweep
+// asks again, rather than a blip reading as a failed deploy.
+export async function checkDeploy(
+  input: Parameters<typeof judge>[0],
+  deps: DeployDeps = DEFAULT_DEPS
+): Promise<DeployVerdict> {
+  try {
+    return await judge(input, deps);
+  } catch {
+    return { state: "pending" };
+  }
+}
+
+async function judge(
+  input: {
+    repo: string;
+    config: DeployConfig | undefined;
+    mergeSha: string | null;
+    mergedAt: number;
+    now: number;
+  },
+  deps: DeployDeps = DEFAULT_DEPS
+): Promise<DeployVerdict> {
+  const { config, mergeSha } = input;
+  if (!config)
+    return { state: "unchecked", detail: "no deploy check configured" };
+  if (!mergeSha) return { state: "pending" };
+  const short = mergeSha.slice(0, 7);
+  const deployed = deps.readSha(config.deployed);
+  if (!deployed)
+    return { state: "unchecked", detail: "no deploy runs on this machine" };
+
+  if (await deps.contains(input.repo, deployed.sha, mergeSha)) {
+    if (!config.health) return { state: "ok", detail: `${short} deployed` };
+    const url = healthUrl(config.health);
+    const answer = await deps.health(url);
+    const merged =
+      answer.ok && answer.startedAt !== undefined
+        ? await deps.committedAt(input.repo, mergeSha)
+        : 0;
+    const stale = !!merged && answer.startedAt! < merged;
+    if (answer.ok && !stale)
+      return { state: "ok", detail: `${short} deployed, server healthy` };
+    if (input.now - deployed.at < HEALTH_GRACE_MS) return { state: "pending" };
+    return {
+      state: "failed",
+      detail: stale
+        ? `${short} deployed, but the server answering ${config.health} hasn't restarted since the merge`
+        : `${short} deployed, but ${config.health} didn't answer healthy: ${answer.why ?? "no answer"}`,
+    };
+  }
+
+  const failed = config.failed ? deps.readSha(config.failed) : null;
+  if (failed && (await deps.contains(input.repo, failed.sha, mergeSha)))
+    return {
+      state: "failed",
+      detail: `the deploy of ${failed.sha.slice(0, 7)} (which has ${short}) failed; see the deploy's log`,
+    };
+  const within = (config.within_minutes ?? DEPLOY_WITHIN_MIN) * 60 * 1000;
+  if (input.now - input.mergedAt >= within)
+    return {
+      state: "failed",
+      detail: `${short} not deployed ${Math.round(within / 60000)} minutes after the merge`,
+    };
+  return { state: "pending" };
+}

package/lib/away/report.ts

@@ -0,0 +1,398 @@
+/**
+ * "While you were away": what happened in every workspace between Away on
+ * and off, read straight from the database, no model involved. Built once
+ * as Away ends and kept with the period, so it reads the same later.
+ */
+
+import { db } from "../db";
+import { listWorkspaces } from "../workspaces";
+import { HARD_LINES, openAsks } from "../orchestrator/asks";
+import {
+  checksBySession,
+  clip,
+  failuresBySession,
+  type CheckRow,
+  type FailureRow,
+} from "../orchestrator/digest";
+import type { AskKind } from "../orchestrator/ask-view";
+import { clockTime, fromSql, type AwayRow } from "./state";
+
+export type DeployState = "deployed" | "failed" | "pending" | "unchecked";
+
+export interface MergedItem {
+  task: string;
+  project: string;
+  pr: number | null;
+  url: string | null;
+  deploy: DeployState;
+  deployDetail: string | null;
+}
+
+export interface InFlightItem {
+  task: string;
+  project: string;
+  pr: number | null;
+  url: string | null;
+  why: string;
+}
+
+export interface FailedItem {
+  what: string;
+  url: string | null;
+}
+
+export interface WaitingItem {
+  askId: number;
+  kind: AskKind;
+  title: string;
+  hardLine: boolean;
+  url: string | null;
+}
+
+export interface WorkspaceReport {
+  id: string;
+  name: string;
+  merged: MergedItem[];
+  inFlight: InFlightItem[];
+  failed: FailedItem[];
+  waiting: WaitingItem[];
+}
+
+export interface AwayReport {
+  awayId: number;
+  startedAt: string;
+  endedAt: string;
+  endedBy: string | null;
+  setBy: string;
+  // Workspaces with anything to say, in sidebar order.
+  workspaces: WorkspaceReport[];
+  totals: {
+    merged: number;
+    deployed: number;
+    deployFailed: number;
+    inFlight: number;
+    failed: number;
+    waiting: number;
+    hardLines: number;
+  };
+}
+
+const sha7 = (sha: string) => sha.slice(0, 7);
+
+// Why a running task hasn't merged yet, in the order that matters to Saad:
+// his, then broken, then waiting on the pipeline.
+export function inFlightWhy(t: {
+  prNumber: number | null;
+  armed: boolean;
+  checks: CheckRow[];
+  failures: FailureRow[];
+  askKinds: string[];
+  nudges: number;
+}): string {
+  const escalated = t.failures.filter((f) => f.escalated_at);
+  if (escalated.length)
+    return `with you: the ${escalated.map((f) => f.gate).join(" and ")} gate failed twice`;
+  if (t.askKinds.length) return `waiting on your answer (${t.askKinds[0]})`;
+  const nudged = t.nudges ? `; nudged ${t.nudges}x while you were away` : "";
+  if (!t.prNumber) return `no PR yet${nudged}`;
+  const of = (kind: string) => t.checks.find((c) => c.kind === kind);
+  const review = of("review");
+  const ci = of("ci");
+  if (ci && ci.status !== "pass" && ci.status !== "running")
+    return `CI failing at ${sha7(ci.sha)}${nudged}`;
+  if (review?.status === "block")
+    return `review found blocking issues at ${sha7(review.sha)}`;
+  const failed = t.failures.filter((f) => f.count > 0);
+  if (failed.length)
+    return `the ${failed.map((f) => f.gate).join(" and ")} gate failed once; retrying`;
+  if (review?.status === "running")
+    return `review of ${sha7(review.sha)} running`;
+  if (!review || review.status === "error")
+    return "PR open, waiting on its review";
+  if (t.armed) return "armed to merge, waiting on its gates";
+  return "PR open and reviewed, waiting on sign-off";
+}
+
+interface TaskRow {
+  id: string;
+  name: string;
+  project: string;
+  pr_number: number | null;
+  pr_url: string | null;
+  armed_at: string | null;
+}
+
+function merged(
+  workspaceId: string,
+  away: AwayRow,
+  end: string,
+  deployConfigured: (projectId: string) => boolean
+): MergedItem[] {
+  const rows = db
+    .prepare(
+      `SELECT s.id, s.name, p.name AS project, p.id AS project_id, s.pr_number, s.pr_url
+       FROM sessions s JOIN projects p ON p.id = s.project_id
+       WHERE p.workspace_id = ? AND s.task_status = 'merged'
+         AND s.merged_at >= ? AND s.merged_at <= ?
+       ORDER BY s.merged_at, s.id`
+    )
+    .all(workspaceId, away.started_at, end) as (TaskRow & {
+    project_id: string;
+  })[];
+  const action = db.prepare(
+    `SELECT kind, detail FROM away_actions WHERE away_id = ? AND key = ?`
+  );
+  return rows.map((r) => {
+    const done = action.get(away.id, `deploy:${r.id}`) as
+      | { kind: string; detail: string | null }
+      | undefined;
+    const deploy: DeployState =
+      done?.kind === "deploy_ok"
+        ? "deployed"
+        : done?.kind === "deploy_failed"
+          ? "failed"
+          : done?.kind === "deploy_unchecked" || !deployConfigured(r.project_id)
+            ? "unchecked"
+            : "pending";
+    return {
+      task: r.name,
+      project: r.project,
+      pr: r.pr_number,
+      url: r.pr_url,
+      deploy,
+      deployDetail: done?.detail ?? null,
+    };
+  });
+}
+
+function inFlight(workspaceId: string, awayId: number): InFlightItem[] {
+  const tasks = db
+    .prepare(
+      `SELECT s.id, s.name, p.name AS project, s.pr_number, s.pr_url,
+         s.merge_armed_at AS armed_at
+       FROM sessions s JOIN projects p ON p.id = s.project_id
+       WHERE p.workspace_id = ? AND s.role IS NULL AND s.archived_at IS NULL
+         AND s.task_status = 'running'
+       ORDER BY s.created_at, s.id`
+    )
+    .all(workspaceId) as TaskRow[];
+  if (!tasks.length) return [];
+  const checks = checksBySession(workspaceId);
+  const failures = failuresBySession(workspaceId);
+  const asks = openAsks(workspaceId);
+  const nudges = db.prepare(
+    `SELECT COUNT(*) AS n FROM away_actions
+     WHERE away_id = ? AND subject = ? AND kind = 'nudge'`
+  );
+  return tasks.map((t) => ({
+    task: t.name,
+    project: t.project,
+    pr: t.pr_number,
+    url: t.pr_url,
+    why: inFlightWhy({
+      prNumber: t.pr_number,
+      armed: !!t.armed_at,
+      checks: checks.get(t.id) ?? [],
+      failures: failures.get(t.id) ?? [],
+      askKinds: asks
+        .filter((a) => a.subject === `task:${t.id}`)
+        .map((a) => a.kind),
+      nudges: (nudges.get(awayId, t.id) as { n: number }).n,
+    }),
+  }));
+}
+
+function failed(workspaceId: string, away: AwayRow, end: string) {
+  const escalations = db
+    .prepare(
+      `SELECT text FROM orchestrator_notes
+       WHERE workspace_id = ? AND kind = 'escalation'
+         AND created_at >= ? AND created_at <= ?
+       ORDER BY id`
+    )
+    .all(workspaceId, away.started_at, end) as { text: string }[];
+  const deploys = db
+    .prepare(
+      `SELECT a.detail, s.name, s.pr_number, s.pr_url FROM away_actions a
+       LEFT JOIN sessions s ON s.id = a.subject
+       WHERE a.away_id = ? AND a.workspace_id = ? AND a.kind = 'deploy_failed'
+       ORDER BY a.id`
+    )
+    .all(away.id, workspaceId) as {
+    detail: string | null;
+    name: string | null;
+    pr_number: number | null;
+    pr_url: string | null;
+  }[];
+  const ended = db
+    .prepare(
+      `SELECT s.name, s.task_status, s.pr_number, s.pr_url FROM sessions s
+       JOIN projects p ON p.id = s.project_id
+       WHERE p.workspace_id = ? AND s.task_status IN ('dropped', 'done')
+         AND s.task_ended_at >= ? AND s.task_ended_at <= ?
+       ORDER BY s.task_ended_at, s.id`
+    )
+    .all(workspaceId, away.started_at, end) as {
+    name: string;
+    task_status: string;
+    pr_number: number | null;
+    pr_url: string | null;
+  }[];
+  return [
+    ...ended.map((t) => ({
+      what: `${t.name} ${t.task_status === "dropped" ? "was dropped" : "ended without a merge"}${t.pr_number ? ` (PR #${t.pr_number})` : ""}`,
+      url: t.pr_url,
+    })),
+    ...deploys.map((d) => ({
+      what: `Deploy failed after ${d.name ?? "a task"}${d.pr_number ? ` (PR #${d.pr_number})` : ""} merged: ${d.detail ?? "no detail"}`,
+      url: d.pr_url,
+    })),
+    ...escalations.map((e) => ({ what: clip(e.text), url: null })),
+  ];
+}
+
+function waiting(workspaceId: string): WaitingItem[] {
+  return openAsks(workspaceId).map((a) => ({
+    askId: a.id,
+    kind: a.kind,
+    title: clip(a.title, 160),
+    hardLine: HARD_LINES.includes(a.kind),
+    url: a.link,
+  }));
+}
+
+export function buildAwayReport(
+  away: AwayRow,
+  deployConfigured: (projectId: string) => boolean
+): AwayReport {
+  const end = away.ended_at ?? away.started_at;
+  const workspaces = listWorkspaces()
+    .map((w) => ({
+      id: w.id,
+      name: w.name,
+      merged: merged(w.id, away, end, deployConfigured),
+      inFlight: inFlight(w.id, away.id),
+      failed: failed(w.id, away, end),
+      waiting: waiting(w.id),
+    }))
+    .filter(
+      (w) =>
+        w.merged.length ||
+        w.inFlight.length ||
+        w.failed.length ||
+        w.waiting.length
+    );
+  const all = <T>(pick: (w: WorkspaceReport) => T[]) =>
+    workspaces.flatMap(pick);
+  const mergedAll = all((w) => w.merged);
+  const waitingAll = all((w) => w.waiting);
+  return {
+    awayId: away.id,
+    startedAt: away.started_at,
+    endedAt: end,
+    endedBy: away.ended_by,
+    setBy: away.set_by,
+    workspaces,
+    totals: {
+      merged: mergedAll.length,
+      deployed: mergedAll.filter((m) => m.deploy === "deployed").length,
+      deployFailed: mergedAll.filter((m) => m.deploy === "failed").length,
+      inFlight: all((w) => w.inFlight).length,
+      failed: all((w) => w.failed).length,
+      waiting: waitingAll.length,
+      hardLines: waitingAll.filter((a) => a.hardLine).length,
+    },
+  };
+}
+
+const plural = (n: number, one: string, many = `${one}s`) =>
+  `${n} ${n === 1 ? one : many}`;
+
+// The phone's version: counts, and whether anything waits on him.
+export function phoneSummary(r: AwayReport): string {
+  const t = r.totals;
+  const deploy = t.merged
+    ? ` (${t.deployed} deployed${t.deployFailed ? `, ${t.deployFailed} deploy failed` : ""})`
+    : "";
+  const waiting = t.waiting
+    ? `${plural(t.waiting, "ask")} waiting on you${t.hardLines ? `, ${t.hardLines} a hard line` : ""}.`
+    : "Nothing waiting on you.";
+  return [
+    `While you were away: ${t.merged} merged${deploy}, ${t.inFlight} in flight, ${t.failed} failed or escalated.`,
+    waiting,
+    "The full report is in AgentOS.",
+  ].join(" ");
+}
+
+const DEPLOY_WORD: Record<DeployState, string> = {
+  deployed: "deployed",
+  failed: "deploy failed",
+  pending: "deploy not confirmed yet",
+  unchecked: "no deploy check",
+};
+
+// Task names, ask titles and log lines are text agents wrote: no markup.
+const esc = (text: string) => text.replace(/[[\]<>`*_]/g, "\\$&");
+const safeUrl = (url: string | null) =>
+  url && /^https:\/\/[^\s()<>]+$/.test(url) ? url : null;
+const link = (label: string, url: string | null) =>
+  safeUrl(url) ? `[${label}](${url})` : label;
+
+// For Settings > Audits: a markdown file with the same content.
+export function reportMarkdown(r: AwayReport): string {
+  const from = clockTime(fromSql(r.startedAt), fromSql(r.endedAt));
+  const to = clockTime(fromSql(r.endedAt), fromSql(r.endedAt));
+  const out = [
+    `---\naudited: ${new Date(fromSql(r.endedAt)).toISOString()}\n---`,
+    `# While you were away (${from} to ${to})`,
+    "",
+    phoneSummary(r).replace(" The full report is in AgentOS.", ""),
+  ];
+  const section = (title: string, lines: string[], empty: string) => {
+    out.push("", `## ${title}`, "");
+    out.push(...(lines.length ? lines : [empty]));
+  };
+  const each = <T>(
+    pick: (w: WorkspaceReport) => T[],
+    line: (item: T) => string
+  ) =>
+    r.workspaces.flatMap((w) =>
+      pick(w).map((item) => `- **${esc(w.name)}**: ${line(item)}`)
+    );
+  section(
+    "Merged",
+    each(
+      (w) => w.merged,
+      (m) =>
+        `${m.pr ? `${link(`PR #${m.pr}`, m.url)} ` : ""}${esc(m.task)} (${esc(m.project)}): ${DEPLOY_WORD[m.deploy]}${m.deployDetail ? `, ${esc(m.deployDetail)}` : ""}`
+    ),
+    "- None."
+  );
+  section(
+    "Still in flight",
+    each(
+      (w) => w.inFlight,
+      (t) =>
+        `${t.pr ? `${link(`PR #${t.pr}`, t.url)} ` : ""}${esc(t.task)} (${esc(t.project)}): ${t.why}`
+    ),
+    "- None."
+  );
+  section(
+    "Failed or escalated",
+    each(
+      (w) => w.failed,
+      (f) => `${esc(f.what)}${safeUrl(f.url) ? ` (${f.url})` : ""}`
+    ),
+    "- None."
+  );
+  section(
+    "Waiting on you",
+    each(
+      (w) => w.waiting,
+      (a) =>
+        `${a.hardLine ? "**hard line** " : ""}${a.kind}: ${esc(a.title)}${safeUrl(a.url) ? ` (${a.url})` : ""}`
+    ),
+    "- None."
+  );
+  return out.join("\n") + "\n";
+}