@quickchatai/quickreview 0.0.0-stage → 1.1.0

package/src/slack/api.ts

@@ -0,0 +1,303 @@
+// Slack Web API poster — plain global fetch, no SDK.
+//
+// Two hard properties:
+//   1. ONE serialized post queue with a minimum interval between message posts,
+//      so we never trip Slack's per-channel rate limit.
+//   2. Slack delivery NEVER blocks a verdict, a label or a round: a failing
+//      post is retried twice, then logged and dropped. Nothing throws into
+//      callers — failures come back as `{ ok: false, error }`. A NEW message
+//      is retried only after a definite refusal: when Slack may have taken it
+//      (a timeout, a reset, a server error, an unreadable 2xx answer) a resend could post it
+//      twice, so it is returned as ambiguous — the caller keeps its reservation
+//      until an operator can reconcile the unknown delivery.
+//
+// This class reads no config and no files: tokens and intervals arrive as
+// plain options (the caller owns config).
+import {
+  SLACK_API_BASE,
+  type SlackFetchFn,
+  type SlackIdentity,
+  type SlackPostResult,
+  type SlackUserInfo,
+  type SlackWebApi,
+} from "./types.js";
+
+export interface SlackApiOptions {
+  /** Bot token (`xoxb-…`) — Bearer on every call. */
+  botToken: string;
+  /** Injected fetch (default: global fetch). */
+  fetchFn?: SlackFetchFn;
+  /** Minimum spacing between outbound message posts, ms. */
+  postMinIntervalMs?: number;
+  /** users.info memo TTL, seconds. */
+  userCacheTtlSec?: number;
+  /** Web API base (override in tests). */
+  apiBase?: string;
+  /** Clock seam. */
+  now?: () => number;
+  /** Deadline for ONE HTTP attempt (headers and body), ms. A stalled
+   * attempt is aborted and handled like any other failure, so it can never
+   * hold the serialized post queue for longer than this. */
+  requestTimeoutMs?: number;
+  /** Timer seam for the waits between posts and retries. The per-attempt
+   * deadline (`requestTimeoutMs`) runs on the global timer. */
+  setTimeoutFn?: (fn: () => void, ms: number) => unknown;
+  /** Structured log sink. */
+  log?: (message: string, meta?: Record<string, unknown>) => void;
+}
+
+const DEFAULT_POST_MIN_INTERVAL_MS = 1100;
+const DEFAULT_USER_CACHE_TTL_SEC = 86_400;
+/** One initial attempt + this many retries. */
+const RETRIES = 2;
+/** Cap on an honored Retry-After, so a hostile header cannot wedge the queue. */
+const MAX_RETRY_AFTER_MS = 60_000;
+const DEFAULT_REQUEST_TIMEOUT_MS = 15_000;
+
+/** Methods that create something: resending one Slack may already have
+ * taken would create it twice. */
+const CREATES = new Set(["chat.postMessage"]);
+
+/** Transport failures that happen before the request leaves this host. */
+const NEVER_SENT_CODES = new Set([
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "UND_ERR_CONNECT_TIMEOUT",
+]);
+
+function neverSent(err: unknown): boolean {
+  const e = err as { code?: unknown; cause?: { code?: unknown } } | null;
+  const code = e?.cause?.code ?? e?.code;
+  return typeof code === "string" && NEVER_SENT_CODES.has(code);
+}
+
+interface SlackApiResponse {
+  ok?: boolean;
+  error?: string;
+  ts?: string;
+  [k: string]: unknown;
+}
+
+export class SlackApiClient implements SlackWebApi {
+  private readonly botToken: string;
+  private readonly fetchFn: SlackFetchFn;
+  private readonly postMinIntervalMs: number;
+  private readonly requestTimeoutMs: number;
+  private readonly userCacheTtlMs: number;
+  private readonly apiBase: string;
+  private readonly now: () => number;
+  private readonly setTimeoutFn: (fn: () => void, ms: number) => unknown;
+  private readonly log: (message: string, meta?: Record<string, unknown>) => void;
+
+  /** The single serialized post chain. */
+  private queue: Promise<unknown> = Promise.resolve();
+  private lastPostAt = Number.NEGATIVE_INFINITY;
+  private readonly userCache = new Map<string, { at: number; info: SlackUserInfo }>();
+
+  constructor(opts: SlackApiOptions) {
+    this.botToken = opts.botToken;
+    this.fetchFn = opts.fetchFn ?? fetch;
+    this.postMinIntervalMs = opts.postMinIntervalMs ?? DEFAULT_POST_MIN_INTERVAL_MS;
+    this.requestTimeoutMs = opts.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    this.userCacheTtlMs = (opts.userCacheTtlSec ?? DEFAULT_USER_CACHE_TTL_SEC) * 1000;
+    this.apiBase = opts.apiBase ?? SLACK_API_BASE;
+    this.now = opts.now ?? Date.now;
+    this.setTimeoutFn = opts.setTimeoutFn ?? ((fn, ms) => setTimeout(fn, ms));
+    this.log = opts.log ?? (() => {});
+  }
+
+  postMessage(args: {
+    channel: string;
+    text: string;
+    thread_ts?: string;
+  }): Promise<SlackPostResult> {
+    const body: Record<string, unknown> = { channel: args.channel, text: args.text };
+    if (args.thread_ts) body["thread_ts"] = args.thread_ts;
+    return this.enqueuePost("chat.postMessage", body);
+  }
+
+  updateMessage(args: { channel: string; ts: string; text: string }): Promise<SlackPostResult> {
+    return this.enqueuePost("chat.update", { channel: args.channel, ts: args.ts, text: args.text });
+  }
+
+  /** Best-effort: not queued, failures are expected (`no_permission`). */
+  async pinsAdd(args: { channel: string; ts: string }): Promise<SlackPostResult> {
+    const out = await this.callOnce("pins.add", { channel: args.channel, timestamp: args.ts });
+    if (!out.ok) this.log("slack.api.pin_failed", { error: out.error });
+    return out.ok ? { ok: true } : { ok: false, error: out.error ?? "unknown" };
+  }
+
+  async authTest(): Promise<SlackIdentity | undefined> {
+    const res = await this.callOnce("auth.test", {});
+    if (!res.ok || !res.raw) {
+      this.log("slack.api.auth_test_failed", { error: res.error });
+      return undefined;
+    }
+    const raw = res.raw;
+    const userId = typeof raw["user_id"] === "string" ? raw["user_id"] : "";
+    if (!userId) return undefined;
+    return {
+      user_id: userId,
+      ...(typeof raw["bot_id"] === "string" ? { bot_id: raw["bot_id"] } : {}),
+      ...(typeof raw["team_id"] === "string" ? { team_id: raw["team_id"] } : {}),
+    };
+  }
+
+  async usersInfo(userId: string): Promise<SlackUserInfo | undefined> {
+    const hit = this.userCache.get(userId);
+    if (hit && this.now() - hit.at < this.userCacheTtlMs) return hit.info;
+
+    const res = await this.callOnce("users.info", { user: userId });
+    if (!res.ok || !res.raw) return undefined;
+    const user = res.raw["user"] as
+      | {
+          id?: string;
+          name?: string;
+          real_name?: string;
+          is_bot?: boolean;
+          profile?: { display_name?: string; real_name?: string };
+        }
+      | undefined;
+    if (!user) return undefined;
+    const info: SlackUserInfo = {
+      id: user.id ?? userId,
+      display_name:
+        user.profile?.display_name?.trim() ||
+        user.profile?.real_name?.trim() ||
+        user.real_name?.trim() ||
+        user.name?.trim() ||
+        userId,
+      is_bot: user.is_bot === true,
+    };
+    this.userCache.set(userId, { at: this.now(), info });
+    return info;
+  }
+
+  // ---- the serialized post queue -------------------------------------------
+
+  private enqueuePost(method: string, body: Record<string, unknown>): Promise<SlackPostResult> {
+    const run = this.queue.then(async () => {
+      await this.spaceOut();
+      const result = await this.callWithRetries(method, body);
+      this.lastPostAt = this.now();
+      return result;
+    });
+    // Keep the chain alive even if a link somehow rejects.
+    this.queue = run.then(
+      () => undefined,
+      () => undefined,
+    );
+    return run;
+  }
+
+  private async spaceOut(): Promise<void> {
+    const wait = this.lastPostAt + this.postMinIntervalMs - this.now();
+    if (wait > 0) await this.sleep(wait);
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise<void>((resolve) => {
+      this.setTimeoutFn(() => resolve(), ms);
+    });
+  }
+
+  /** Initial attempt + 2 retries, then log and drop. Never throws. */
+  private async callWithRetries(
+    method: string,
+    body: Record<string, unknown>,
+  ): Promise<SlackPostResult> {
+    let last: CallOutcome = { ok: false, error: "unknown" };
+    for (let attempt = 0; attempt <= RETRIES; attempt += 1) {
+      last = await this.callOnce(method, body);
+      if (last.ok) return { ok: true, ...(last.ts ? { ts: last.ts } : {}) };
+      if (attempt === RETRIES) break;
+      if (last.ambiguous && CREATES.has(method)) {
+        this.log("slack.api.not_retried", { method, error: last.error });
+        break;
+      }
+      const wait = last.retryAfterMs ?? this.postMinIntervalMs;
+      this.log("slack.api.retry", {
+        method,
+        attempt: attempt + 1,
+        wait_ms: wait,
+        error: last.error,
+      });
+      await this.sleep(wait);
+    }
+    // Dropped, deliberately: Slack must never block a verdict, label or round.
+    this.log("slack.api.dropped", { method, error: last.error });
+    return {
+      ok: false,
+      error: last.error ?? "unknown",
+      ...(last.ambiguous ? { ambiguous: true } : {}),
+    };
+  }
+
+  /** One HTTP call, bounded by `requestTimeoutMs` end to end (the abort
+   * signal covers the body read too). Swallows everything; returns an outcome. */
+  private async callOnce(method: string, body: Record<string, unknown>): Promise<CallOutcome> {
+    const abort = new AbortController();
+    const timer = setTimeout(
+      () => abort.abort(new Error(`timeout after ${this.requestTimeoutMs}ms`)),
+      this.requestTimeoutMs,
+    );
+    timer.unref?.();
+    try {
+      const res = await this.fetchFn(`${this.apiBase}/${method}`, {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${this.botToken}`,
+          "content-type": "application/json; charset=utf-8",
+        },
+        body: JSON.stringify(body),
+        signal: abort.signal,
+      });
+      if (res.status === 429) {
+        return { ok: false, error: "rate_limited", retryAfterMs: this.retryAfterMs(res) };
+      }
+      let payload: SlackApiResponse;
+      try {
+        payload = (await res.json()) as SlackApiResponse;
+      } catch {
+        // A 2xx Slack answered but we cannot read: it may have done the work.
+        return {
+          ok: false,
+          error: `bad_json_${res.status}`,
+          ambiguous: res.ok || res.status >= 500,
+        };
+      }
+      if (!res.ok || payload?.ok !== true) {
+        return {
+          ok: false,
+          error: payload?.error ?? `http_${res.status}`,
+          ...(res.status >= 500 ? { ambiguous: true } : {}),
+        };
+      }
+      // ts is a string, always — never coerce it to a number.
+      const ts = typeof payload.ts === "string" ? payload.ts : undefined;
+      return { ok: true, ...(ts ? { ts } : {}), raw: payload };
+    } catch (err) {
+      return { ok: false, error: String(err), ambiguous: !neverSent(err) };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  private retryAfterMs(res: Response): number {
+    const raw = res.headers?.get?.("retry-after");
+    const secs = Number(raw);
+    if (!Number.isFinite(secs) || secs <= 0) return this.postMinIntervalMs;
+    return Math.min(secs * 1000, MAX_RETRY_AFTER_MS);
+  }
+}
+
+interface CallOutcome {
+  ok: boolean;
+  ts?: string;
+  error?: string;
+  /** The request may have reached Slack and been acted on. */
+  ambiguous?: boolean;
+  retryAfterMs?: number;
+  raw?: SlackApiResponse;
+}

package/src/slack/messages.ts

@@ -0,0 +1,288 @@
+// The Slack message templates. The wording is fixed, not model-written.
+//
+// Pure functions, zero I/O: every announcement the daemon can make is rendered
+// here from data the daemon already has, so the wording is testable byte for
+// byte and can never drift into a model's hands. House style, non-negotiable:
+// one line of status, one short paragraph at most, one link. Plain mrkdwn in
+// `text` — NO Block Kit anywhere.
+//
+// Two invariants live in this file:
+//   * every interpolated user-derived string (titles, summaries, reasons,
+//     author replies) goes through `escapeMrkdwn` — Slack's `&`/`<`/`>` are the
+//     only three characters that can turn text into markup;
+//   * `{author_ref}` is a real `<@U…>` mention ONLY when [slack.users] maps the
+//     GitHub login. Otherwise it is the bare login as PLAIN TEXT — a fabricated
+//     mention pings a stranger, so it is never constructed.
+//
+// AGENTS.md invariant 2 shows up here as a WORDING rule: nothing the daemon
+// says may claim a review was dismissed. Superseding is "read the newest one".
+import type { Config } from "../config.js";
+import type { RoundType, Verdict } from "@quickchatai/pi-quickreview/src/types.js";
+
+/** Slack mrkdwn escaping — `&` first, or the other two double-escape. */
+export function escapeMrkdwn(text: string): string {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+/** Hard character budget, with an ellipsis when it bites. */
+export function truncate(text: string, max: number): string {
+  return text.length <= max ? text : `${text.slice(0, Math.max(0, max - 1))}…`;
+}
+
+/** The 7-char sha every GitHub UI shows. */
+export function shortSha(sha: string): string {
+  return (sha ?? "").slice(0, 7);
+}
+
+/** `<@U…>` for a known Slack id. Never call this with an unmapped login. */
+export function mention(slackUserId: string): string {
+  return `<@${slackUserId}>`;
+}
+
+/**
+ * A GitHub login rendered for Slack: a mention when [slack.users] maps it,
+ * otherwise the escaped bare login. NEVER a guessed id.
+ */
+export function userRef(cfg: Config, githubLogin: string): string {
+  const login = (githubLogin ?? "").trim();
+  if (!login) return "the author";
+  for (const [slackId, gh] of Object.entries(cfg.slack.users)) {
+    if (gh.toLowerCase() === login.toLowerCase()) return mention(slackId);
+  }
+  return escapeMrkdwn(login);
+}
+
+/** The owner — by mention when their Slack id is configured, by configured
+ * name otherwise, and by the neutral role when neither is set. */
+export function ownerRef(cfg: Config): string {
+  const id = cfg.owner.slack_id.trim();
+  if (id) return mention(id);
+  const name = cfg.owner.name.trim();
+  return name ? escapeMrkdwn(name) : "the owner";
+}
+
+export function prUrl(cfg: Config, pr: number): string {
+  return `https://github.com/${cfg.github.repo}/pull/${pr}`;
+}
+
+/** Round type as a human says it. */
+export const ROUND_TYPE_LABEL: Record<RoundType, string> = {
+  first: "first review",
+  "re-review": "re-review",
+  staleness: "staleness recheck",
+};
+
+/** A downtime gap, honestly: minutes under an hour, `h`+`min` above it. */
+export function formatGap(ms: number): string {
+  const totalMin = Math.max(0, Math.round(ms / 60_000));
+  if (totalMin < 60) return `${totalMin} min`;
+  const h = Math.floor(totalMin / 60);
+  const m = totalMin % 60;
+  return m === 0 ? `${h} h` : `${h} h ${m} min`;
+}
+
+/** ISO instant trimmed to seconds — timestamps we quote, not decorate. */
+export function isoSeconds(iso: string): string {
+  return iso.replace(/\.\d{3}(Z|[+-]\d\d:\d\d)$/, "$1");
+}
+
+// ---- thread lifecycle -----------------------------------------------------
+
+export interface PickupMessageInput {
+  pr: number;
+  title: string;
+  author: string;
+  round_no: number;
+  round_type: RoundType;
+  changed_files: number;
+  additions: number;
+  deletions: number;
+  lenses: string[];
+}
+
+/** The thread ROOT: one line of status, one italic line of facts. */
+export function pickupMessage(cfg: Config, m: PickupMessageInput): string {
+  return (
+    `👀 *<${prUrl(cfg, m.pr)}|#${m.pr} ${escapeMrkdwn(m.title)}>* — review started for ${userRef(cfg, m.author)}\n` +
+    `_round ${m.round_no} · ${ROUND_TYPE_LABEL[m.round_type]} · ${m.changed_files} files, ` +
+    `+${m.additions}/−${m.deletions} · lenses: ${m.lenses.join(", ")}_`
+  );
+}
+
+export type VerdictName = Verdict;
+
+const VERDICT_RENDER: Record<VerdictName, { glyph: string; label: string }> = {
+  APPROVE: { glyph: "✅", label: "APPROVED" },
+  REQUEST_CHANGES: { glyph: "🔧", label: "CHANGES REQUESTED" },
+  // Legacy verdict: older prompts still emit it; the daemon lands it
+  // as `tracked` — review posted, no approval, the AI keeps driving. The label
+  // must not claim a person is needed, because nothing waits on one.
+  NEEDS_HUMAN: { glyph: "🚨", label: "UNDECIDED (legacy verdict)" },
+};
+
+/** An APPROVE whose approval CI withheld: the review posted as a COMMENT,
+ * and the approval follows only once CI is green at the head. */
+const APPROVAL_WITHHELD_RENDER = { glyph: "⏳", label: "APPROVAL WITHHELD (CI not green)" };
+
+export interface VerdictMessageInput {
+  pr: number;
+  author: string;
+  round_no: number;
+  verdict: VerdictName;
+  /** The verdict was APPROVE, but CI was not green at the head, so the review
+   * posted as a COMMENT and no approval exists yet. */
+  approval_withheld?: boolean;
+  /** `rounds.summary`, VERBATIM. Null ⇒ the line is dropped, never filled in. */
+  summary: string | null;
+  duration_min: number;
+  /** Link target; the daemon has no per-review URL, so this is the PR. */
+  review_url?: string;
+}
+
+export function verdictMessage(cfg: Config, m: VerdictMessageInput): string {
+  const { glyph, label } =
+    m.verdict === "APPROVE" && m.approval_withheld
+      ? APPROVAL_WITHHELD_RENDER
+      : VERDICT_RENDER[m.verdict];
+  const lines = [
+    `${userRef(cfg, m.author)} ${glyph} *${label}* — round ${m.round_no}, ${m.duration_min} min`,
+  ];
+  // A missing summary drops the line entirely: filler ("no summary provided")
+  // is noise, and an invented one would be a lie about what the round found.
+  if (m.summary !== null && m.summary.trim() !== "") lines.push(escapeMrkdwn(m.summary));
+  lines.push(`<${m.review_url ?? prUrl(cfg, m.pr)}|review on GitHub>`);
+  if (m.verdict === "NEEDS_HUMAN") {
+    // No owner ping: there is no park and no decision waiting on a person.
+    lines.push(
+      "legacy undecided verdict — landed as tracked: review posted, no approval, the automated review continues",
+    );
+  }
+  return lines.join("\n");
+}
+
+/** Why a later round started. The `re-run by` variant carries the operator. */
+export type ReRoundReason =
+  | { kind: "pushed" }
+  | { kind: "base_moved" }
+  | { kind: "re_requested" }
+  | { kind: "rerun"; requested_by: string };
+
+export function reRoundReasonText(reason: ReRoundReason): string {
+  switch (reason.kind) {
+    case "pushed":
+      return "you pushed new commits";
+    case "base_moved":
+      return "base moved, rechecking";
+    case "re_requested":
+      return "re-requested review";
+    case "rerun":
+      return `re-run by ${escapeMrkdwn(reason.requested_by)}`;
+  }
+}
+
+/** A later round, in-thread. No lens/diffstat line — the root carries those. */
+export function reRoundMessage(m: {
+  round_no: number;
+  reason: ReRoundReason;
+  head_sha: string;
+}): string {
+  return `🔄 round ${m.round_no} started — ${reRoundReasonText(m.reason)} (\`${shortSha(m.head_sha)}\`)`;
+}
+
+/**
+ * A newer round replaced an older one. WORDING IS LOAD-BEARING: no approval and
+ * no other identity's review is ever dismissed (AGENTS.md invariant 2) — the
+ * older review stays exactly where it is, this line only points at the newest.
+ */
+export function supersededMessage(m: {
+  old_round_no: number;
+  new_round_no: number;
+  head_sha: string;
+}): string {
+  return (
+    `♻️ the round-${m.old_round_no} review is superseded by round ${m.new_round_no} ` +
+    `(\`${shortSha(m.head_sha)}\`) — read the newest one`
+  );
+}
+
+// ---- unprompted causes ----------------------------------------------------
+
+/** Every cause the announcer has a message for. The first six ship ON; the
+ * rest are config-disabled and templated only — nothing in the daemon raises
+ * them yet, so turning their flag on announces nothing until a producer
+ * calls the announcer for them. */
+export type CauseMessageInput =
+  | { cause: "round.overdue"; pr: number; round_no: number; deadline_min: number }
+  | { cause: "round.malformed_verdict"; pr: number; round_no: number }
+  | {
+      cause: "pr.not_picked_up";
+      pr: number;
+      age_min: number;
+      queue_depth: number;
+      running: number;
+      max_concurrent: number;
+    }
+  | { cause: "daemon.up"; version: string; gap: string; last_heartbeat: string }
+  | { cause: "daemon.stopping"; reason: string }
+  | { cause: "slack.cap_reached"; cap: number }
+  | { cause: "reconcile.storm"; corrections: number; window_min: number }
+  | { cause: "digest.eod"; headline: string; url?: string }
+  | { cause: "pr.awaiting_author_stale"; pr: number; hours: number };
+
+export type Cause = CauseMessageInput["cause"];
+
+export function causeMessage(cfg: Config, m: CauseMessageInput): string {
+  switch (m.cause) {
+    case "round.overdue":
+      return (
+        `⏱ #${m.pr} round ${m.round_no} blew its ${m.deadline_min}-min deadline — ` +
+        `no verdict was posted, and no approval was implied. ${ownerRef(cfg)}`
+      );
+    case "round.malformed_verdict":
+      return `⚠️ #${m.pr} round ${m.round_no} ended without a usable verdict — nothing was posted and no approval was implied.`;
+    case "pr.not_picked_up":
+      return (
+        `🐢 #${m.pr} has been waiting ${m.age_min} min for a review slot ` +
+        `(${m.queue_depth} queued, ${m.running}/${m.max_concurrent} running).`
+      );
+    case "daemon.up":
+      return (
+        `🟢 review daemon up (${escapeMrkdwn(m.version)}) — was down ${m.gap} (since ${m.last_heartbeat}); ` +
+        `events in that window may have been missed, reconcile is catching up.`
+      );
+    case "daemon.stopping":
+      return `🟡 review daemon stopping (${escapeMrkdwn(m.reason)}) — back shortly.`;
+    case "slack.cap_reached":
+      return (
+        `🔇 I've hit today's answer budget (${m.cap} turns). Verdicts and alerts keep posting; ` +
+        `questions resume at midnight (or ask ${ownerRef(cfg)}).`
+      );
+    // ---- OFF in v1 (config-disabled), templated only; a producer must also raise them --
+    case "reconcile.storm":
+      return `🌀 reconcile corrected ${m.corrections} PRs in the last ${m.window_min} min — something upstream is flapping, I'm re-deriving from GitHub.`;
+    case "digest.eod":
+      return m.url
+        ? `📋 end of day — ${escapeMrkdwn(m.headline)}\n<${m.url}|the full digest>`
+        : `📋 end of day — ${escapeMrkdwn(m.headline)}`;
+    case "pr.awaiting_author_stale":
+      return `😴 #${m.pr} has been waiting on its author for ${m.hours} h — no action from me until a new push lands.`;
+  }
+}
+
+/** The pinned liveness message. Its staleness IS the signal, so it carries the
+ * instant it was last refreshed. */
+export function heartbeatMessage(m: {
+  refreshed_at: string;
+  running: number;
+  max_concurrent: number;
+  queued: number;
+  dry_run: boolean;
+  failed_loud?: number;
+  recovered_incident?: string;
+}): string {
+  return (
+    `💓 review daemon alive — ${isoSeconds(m.refreshed_at)} · ${m.running}/${m.max_concurrent} rounds running · ` +
+    `${m.queued} queued${m.failed_loud ? ` · ⛔ PIPELINE FAILED · ${m.failed_loud} review${m.failed_loud === 1 ? "" : "s"} needs u` : ""}` +
+    `${m.recovered_incident ? ` · ✓ recovered ${m.recovered_incident}` : ""}${m.dry_run ? " · DRY-RUN" : ""}`
+  );
+}