@saadnvd1/agent-os 0.3.723 → 0.3.728

package/lib/reports/generate.ts

@@ -0,0 +1,159 @@
+// Builds, stores and serves a task's health report. Evidence first (server
+// code), words second (the analyst model), then every claim is checked and
+// the estimate is computed here. Cached on an evidence hash; one generation
+// per task at a time.
+
+import { db, type Session } from "../db";
+import type { ClaudeRunner } from "../orchestrator/claude-cli";
+import type { RunUsage } from "../usage/check-runs";
+import { isFinished } from "../tasks/state";
+import { gather, type Gathered } from "./evidence/gather";
+import { computeEstimate } from "./estimate";
+import { askModel, evidencePack } from "./model";
+import { modeOf, workspaceOf } from "./mode";
+import { hashOfLatest, insertReport, latestReport } from "./store";
+import { headlineFor, templateLines } from "./template";
+import { validateModelReport } from "./validate";
+import type { HealthReport, ReportTrigger } from "./types";
+import { notifyTopic } from "../status/hub";
+
+export const reportTopic = (sessionId: string) => `report:${sessionId}`;
+
+const inFlight = new Map<string, Promise<HealthReport>>();
+export const isGenerating = (sessionId: string) => inFlight.has(sessionId);
+
+export interface GenerateOptions {
+  analystSummary?: string | null;
+  runner?: ClaudeRunner;
+  // Build a new report even when the evidence is unchanged.
+  force?: boolean;
+}
+
+export function buildReport(
+  s: Pick<Session, "id" | "name" | "task_prompt">,
+  g: Gathered,
+  trigger: ReportTrigger,
+  raw: unknown | null,
+  usage: RunUsage | null
+): Omit<HealthReport, "id" | "createdAt" | "stale"> {
+  const v = raw === null ? null : validateModelReport(raw, g.evidence);
+  const fromModel = !!v && (v.lines.length > 0 || !!v.recommendation);
+  const tmpl = templateLines(g.state, g.evidence);
+  const estimate = computeEstimate({
+    head: g.head,
+    evidence: g.evidence,
+    items: g.items,
+    mappings: v?.mappings ?? [],
+    stages: g.stages,
+  });
+  const mode = modeOf(s.id).mode;
+  const finished = isFinished(g.state);
+  const text = mode !== "manual" && !finished ? (v?.nextPrompt ?? null) : null;
+  const draft =
+    mode === "manual" || finished
+      ? null
+      : (g.analystDraft ??
+        (text
+          ? {
+              source: "report" as const,
+              id: "",
+              text,
+              status: "pending" as const,
+            }
+          : null));
+  return {
+    sessionId: s.id,
+    workspaceId: workspaceOf(s.id),
+    head: g.head,
+    trigger,
+    headline: (fromModel && v?.headline) || headlineFor(g.state),
+    state: g.state,
+    estimate,
+    lines: fromModel ? v!.lines : tmpl.lines,
+    recommendation: fromModel ? v!.recommendation : tmpl.recommendation,
+    draft,
+    evidence: g.evidence,
+    source: fromModel ? "model" : "template",
+    dropped: v?.dropped ?? 0,
+    model: usage?.model ?? null,
+    costUsd: usage?.costUsd ?? null,
+  };
+}
+
+async function run(
+  sessionId: string,
+  trigger: ReportTrigger,
+  opts: GenerateOptions
+): Promise<HealthReport> {
+  const s = db
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
+    .get(sessionId) as Session | undefined;
+  if (!s) throw new Error("No such task");
+  const g = await gather(s, { analystSummary: opts.analystSummary });
+  const last = latestReport(sessionId, g.head);
+  // The same evidence needs no new report, and a task's end report is final.
+  if (
+    last &&
+    !opts.force &&
+    (hashOfLatest(sessionId) === g.hash ||
+      (last.trigger === "end" && isFinished(g.state)))
+  )
+    return last;
+
+  let raw: unknown = null;
+  let usage: RunUsage | null = null;
+  try {
+    raw = await askModel(
+      {
+        prompt: evidencePack(
+          { name: s.name, prompt: s.task_prompt ?? "" },
+          g.state,
+          g.evidence,
+          g.items
+        ),
+        workspaceId: workspaceOf(sessionId),
+        onUsage: (u) => (usage = u),
+      },
+      opts.runner
+    );
+  } catch (error) {
+    console.error(`Report for ${s.name}:`, error);
+  }
+  const report = buildReport(s, g, trigger, raw, usage);
+  const id = insertReport(report, g.hash);
+  notifyTopic(reportTopic(sessionId));
+  return (
+    latestReport(sessionId, g.head) ?? {
+      ...report,
+      id,
+      createdAt: "",
+      stale: false,
+    }
+  );
+}
+
+// One generation per task: a request while one runs shares its result.
+export function generateReport(
+  sessionId: string,
+  trigger: ReportTrigger,
+  opts: GenerateOptions = {}
+): Promise<HealthReport> {
+  const running = inFlight.get(sessionId);
+  if (running) return running;
+  const p = run(sessionId, trigger, opts).finally(() =>
+    inFlight.delete(sessionId)
+  );
+  inFlight.set(sessionId, p);
+  return p;
+}
+
+// The trigger entry the loop and the task hooks use: fire and forget.
+export function requestReport(
+  sessionId: string,
+  trigger: ReportTrigger,
+  opts: GenerateOptions & { cycleId?: number } = {}
+): void {
+  generateReport(sessionId, trigger, opts).catch((error) =>
+    console.error(`Report ${sessionId}:`, error)
+  );
+}

package/lib/reports/hooks.ts

@@ -0,0 +1,30 @@
+// How the developer-analyst loop meets the reports: a loop makes its task
+// Autonomous, every stop hands it back to Assisted with the instruction that
+// wasn't sent kept as a pending draft, and each settled cycle asks for a
+// report.
+
+import { setLoopHooks } from "../loops/hooks";
+import { setTaskEndHook } from "./end-hook";
+import { generateReport, requestReport } from "./generate";
+import { setTaskMode } from "./mode";
+import { setDraftText } from "./store";
+
+let installed = false;
+
+export function installReportHooks(): void {
+  if (installed) return;
+  installed = true;
+  setTaskEndHook((id) => requestReport(id, "end"));
+  setLoopHooks({
+    onCycleSettled: ({ taskId, analystSummary }) =>
+      requestReport(taskId, "cycle", { analystSummary }),
+    onStart: (loop) => setTaskMode(loop.sessionId, "autonomous"),
+    onStop: (loop, _stop, pending) => {
+      setTaskMode(loop.sessionId, "assisted");
+      if (!pending) return;
+      generateReport(loop.sessionId, "cycle", { force: true })
+        .then((r) => setDraftText(r.id, pending, "pending"))
+        .catch((error) => console.error("Keeping the loop's draft:", error));
+    },
+  });
+}

package/lib/reports/mode.ts

@@ -0,0 +1,65 @@
+// The operating mode: a workspace default and a per-task override. Manual
+// until someone says otherwise. The developer-analyst loop reads it here.
+
+import { db } from "../db";
+import { isMode, type OperatingMode } from "./types";
+
+export interface ModeOf {
+  mode: OperatingMode;
+  source: "task" | "workspace" | "default";
+}
+
+const read = (
+  scope: "task" | "workspace",
+  id: string
+): OperatingMode | null => {
+  const row = db
+    .prepare(
+      `SELECT mode FROM operating_modes WHERE scope = ? AND scope_id = ?`
+    )
+    .get(scope, id) as { mode: string } | undefined;
+  return row && isMode(row.mode) ? row.mode : null;
+};
+
+export function workspaceOf(sessionId: string): string | null {
+  const row = db
+    .prepare(`SELECT workspace_id FROM session_rows WHERE id = ?`)
+    .get(sessionId) as { workspace_id: string | null } | undefined;
+  return row?.workspace_id ?? null;
+}
+
+export function modeOf(sessionId: string): ModeOf {
+  const own = read("task", sessionId);
+  if (own) return { mode: own, source: "task" };
+  const ws = workspaceOf(sessionId);
+  const inherited = ws ? read("workspace", ws) : null;
+  return inherited
+    ? { mode: inherited, source: "workspace" }
+    : { mode: "manual", source: "default" };
+}
+
+export const workspaceMode = (workspaceId: string): OperatingMode =>
+  read("workspace", workspaceId) ?? "manual";
+
+// null clears the task's override so it follows its workspace again.
+function put(
+  scope: "task" | "workspace",
+  id: string,
+  mode: OperatingMode | null
+) {
+  if (mode === null) {
+    db.prepare(
+      `DELETE FROM operating_modes WHERE scope = ? AND scope_id = ?`
+    ).run(scope, id);
+    return;
+  }
+  db.prepare(
+    `INSERT INTO operating_modes (scope, scope_id, mode) VALUES (?, ?, ?)
+     ON CONFLICT(scope, scope_id) DO UPDATE SET mode = excluded.mode, updated_at = datetime('now')`
+  ).run(scope, id, mode);
+}
+
+export const setTaskMode = (sessionId: string, mode: OperatingMode | null) =>
+  put("task", sessionId, mode);
+export const setWorkspaceMode = (id: string, mode: OperatingMode) =>
+  put("workspace", id, mode);

package/lib/reports/model.ts

@@ -0,0 +1,115 @@
+// The model's part of a report: word what the evidence shows. It has no field
+// for an estimate, a percentage or a count of finished work; the server
+// computes those (estimate.ts) and checks every claim (validate.ts).
+
+import os from "os";
+import { runClaude, type ClaudeRunner } from "../orchestrator/claude-cli";
+import { untrusted, UNTRUSTED_RULE } from "../orchestrator/untrusted";
+import type { RunUsage } from "../usage/check-runs";
+import type { AcceptanceItem } from "./estimate";
+import type { EvidenceRef } from "./types";
+import { MAX_PROMPT } from "./validate";
+
+export const REPORT_TIMEOUT_MS = 60_000;
+const PACK_CHARS = 12_000;
+
+const SYSTEM = `You write a short plain-English progress report on one software task for someone who does not read code. You are given numbered evidence items (CI checks, test runs, the review, changed files, acceptance items). Rules:
+- Every line must cite the ids of the evidence it rests on, copied exactly. A line with no evidence is thrown away.
+- Say only what the evidence shows. Use plain words: no file paths, no jargon, no stack traces.
+- Never write a percentage, a completion estimate or a count of finished work: the system works those out. Any number you write must appear in the evidence you cite.
+- Tones: "done" for something that passed or happened, "warn" for something failing or still running, "blocked" for something waiting on a person, "next" for what should happen next. A "done" line must cite a passing item; a "warn" or "blocked" line must cite a failing, pending or waiting item.
+- "acceptance": for each numbered acceptance item that the evidence proves, give its number and the ids that prove it (a passing test, CI check or review at the latest push; a changed file alone proves nothing). Leave out items you cannot prove.
+- "recommendation": one short paragraph on the single best next step, citing evidence.
+- "nextPrompt": when work should go on, the exact message to send the coding agent, written as an instruction to it (no more than a few sentences); otherwise null.
+${UNTRUSTED_RULE}`;
+
+export const SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["headline", "lines", "recommendation", "acceptance", "nextPrompt"],
+  properties: {
+    headline: { type: "string" },
+    lines: {
+      type: "array",
+      maxItems: 10,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["tone", "text", "evidence"],
+        properties: {
+          tone: { enum: ["done", "warn", "blocked", "next"] },
+          text: { type: "string" },
+          evidence: { type: "array", items: { type: "string" } },
+        },
+      },
+    },
+    recommendation: {
+      type: ["object", "null"],
+      additionalProperties: false,
+      required: ["text", "evidence"],
+      properties: {
+        text: { type: "string" },
+        evidence: { type: "array", items: { type: "string" } },
+      },
+    },
+    acceptance: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["item", "evidence"],
+        properties: {
+          item: { type: "integer" },
+          evidence: { type: "array", items: { type: "string" } },
+        },
+      },
+    },
+    nextPrompt: { type: ["string", "null"], maxLength: MAX_PROMPT },
+  },
+} as const;
+
+export function evidencePack(
+  task: { name: string; prompt: string },
+  state: string,
+  evidence: EvidenceRef[],
+  items: AcceptanceItem[]
+): string {
+  const rows = evidence.map(
+    (e) =>
+      `${e.id} | ${e.kind} | ${e.status} | ${e.label}${
+        e.excerpt ? `\n${untrusted(`evidence ${e.id}`, e.excerpt)}` : ""
+      }`
+  );
+  const accept = items.map((it, i) => `${i + 1}. ${it.label}`);
+  const body = [
+    `Task: ${task.name}`,
+    `Brief: ${untrusted("task brief", task.prompt.slice(0, 1200))}`,
+    `State: ${state}`,
+    accept.length ? `Acceptance items:\n${accept.join("\n")}` : "",
+    `Evidence (id | kind | status | label):\n${rows.join("\n")}`,
+  ]
+    .filter(Boolean)
+    .join("\n\n");
+  return body.slice(0, PACK_CHARS);
+}
+
+export async function askModel(
+  input: {
+    prompt: string;
+    workspaceId: string | null;
+    onUsage: (u: RunUsage) => void;
+  },
+  runner: ClaudeRunner = runClaude
+): Promise<unknown> {
+  return runner({
+    cwd: os.tmpdir(),
+    system: SYSTEM,
+    prompt: input.prompt,
+    schema: SCHEMA,
+    tools: [],
+    timeoutMs: REPORT_TIMEOUT_MS,
+    role: "analyze",
+    workspaceId: input.workspaceId,
+    onUsage: input.onUsage,
+  });
+}

package/lib/reports/read.ts

@@ -0,0 +1,26 @@
+// The report a client sees: the stored one, with the current draft laid over
+// it and its staleness against the task's head.
+
+import { isFinished } from "../tasks/state";
+import { analystDraft } from "./evidence/gather";
+import { isGenerating } from "./generate";
+import { modeOf } from "./mode";
+import { latestReport } from "./store";
+import type { ReportResponse } from "./types";
+
+export function readReport(sessionId: string): ReportResponse {
+  const mode = modeOf(sessionId);
+  const report = latestReport(sessionId);
+  if (report) {
+    const live = mode.mode !== "manual" && !isFinished(report.state);
+    // The analyst's open recommendation is the draft when the task has one.
+    const own = live ? analystDraft(sessionId) : null;
+    report.draft = !live
+      ? null
+      : (own ??
+        (report.draft?.status === "pending" || report.draft?.status === "sent"
+          ? report.draft
+          : null));
+  }
+  return { report, generating: isGenerating(sessionId), mode };
+}

package/lib/reports/store.ts

@@ -0,0 +1,180 @@
+import { db } from "../db";
+import type {
+  DraftStatus,
+  HealthReport,
+  ReportSummary,
+  ReportTrigger,
+} from "./types";
+
+interface Row {
+  id: number;
+  session_id: string;
+  workspace_id: string | null;
+  head: string | null;
+  trigger: ReportTrigger;
+  evidence_hash: string;
+  data: string;
+  model: string | null;
+  cost_usd: number | null;
+  draft_text: string | null;
+  draft_status: DraftStatus | null;
+  created_at: string;
+}
+
+// What is stored in `data`: the report without what the row itself holds.
+type Stored = Omit<
+  HealthReport,
+  "id" | "sessionId" | "workspaceId" | "createdAt" | "stale" | "draft"
+> & { draft: HealthReport["draft"] };
+
+export function insertReport(
+  r: Omit<HealthReport, "id" | "createdAt" | "stale">,
+  hash: string
+): number {
+  const { id: _i, sessionId, workspaceId, ...rest } = r as HealthReport;
+  void _i;
+  const draft = r.draft?.source === "report" ? r.draft : null;
+  db.prepare(
+    `UPDATE health_reports SET draft_status = 'superseded'
+      WHERE session_id = ? AND draft_status = 'pending'`
+  ).run(sessionId);
+  const info = db
+    .prepare(
+      `INSERT INTO health_reports (session_id, workspace_id, head, trigger, evidence_hash, data, model, cost_usd, draft_text, draft_status)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    )
+    .run(
+      sessionId,
+      workspaceId,
+      r.head,
+      r.trigger,
+      hash,
+      JSON.stringify({ ...rest, draft: null } satisfies Stored),
+      r.model,
+      r.costUsd,
+      draft?.text ?? null,
+      draft ? "pending" : null
+    );
+  return Number(info.lastInsertRowid);
+}
+
+function toReport(row: Row, head: string | null | undefined): HealthReport {
+  const data = JSON.parse(row.data) as Stored;
+  return {
+    ...data,
+    id: row.id,
+    sessionId: row.session_id,
+    workspaceId: row.workspace_id,
+    createdAt: row.created_at,
+    draft: row.draft_text
+      ? {
+          source: "report",
+          id: String(row.id),
+          text: row.draft_text,
+          status: row.draft_status ?? "pending",
+        }
+      : null,
+    stale: head !== undefined && head !== row.head,
+  };
+}
+
+// `head` is the task's current head, to mark an older report stale.
+export function latestReport(
+  sessionId: string,
+  head?: string | null
+): HealthReport | null {
+  const row = db
+    .prepare(
+      `SELECT * FROM health_reports WHERE session_id = ? ORDER BY id DESC LIMIT 1`
+    )
+    .get(sessionId) as Row | undefined;
+  return row ? toReport(row, head) : null;
+}
+
+export function getReport(id: number): HealthReport | null {
+  const row = db
+    .prepare(`SELECT * FROM health_reports WHERE id = ?`)
+    .get(id) as Row | undefined;
+  return row ? toReport(row, undefined) : null;
+}
+
+export function hashOfLatest(sessionId: string): string | null {
+  const row = db
+    .prepare(
+      `SELECT evidence_hash FROM health_reports WHERE session_id = ? ORDER BY id DESC LIMIT 1`
+    )
+    .get(sessionId) as { evidence_hash: string } | undefined;
+  return row?.evidence_hash ?? null;
+}
+
+// Claimed first, so a double tap sends once.
+export function claimDraft(
+  reportId: number,
+  to: Exclude<DraftStatus, "pending">
+): boolean {
+  return (
+    db
+      .prepare(
+        `UPDATE health_reports SET draft_status = ?, draft_decided_at = datetime('now')
+          WHERE id = ? AND draft_status = 'pending'`
+      )
+      .run(to, reportId).changes === 1
+  );
+}
+
+export function reopenDraft(reportId: number): void {
+  db.prepare(
+    `UPDATE health_reports SET draft_status = 'pending', draft_decided_at = NULL
+      WHERE id = ? AND draft_status = 'sent'`
+  ).run(reportId);
+}
+
+export function setDraftText(
+  reportId: number,
+  text: string,
+  status: DraftStatus
+) {
+  db.prepare(
+    `UPDATE health_reports SET draft_text = ?, draft_status = ? WHERE id = ?`
+  ).run(text, status, reportId);
+}
+
+export function historyOf(sessionId: string, limit = 20): ReportSummary[] {
+  const rows = db
+    .prepare(
+      `SELECT * FROM health_reports WHERE session_id = ? ORDER BY id DESC LIMIT ?`
+    )
+    .all(sessionId, limit) as Row[];
+  return rows.map((r) => summaryOf(toReport(r, undefined), ""));
+}
+
+export function summaryOf(r: HealthReport, name: string): ReportSummary {
+  return {
+    sessionId: r.sessionId,
+    name,
+    headline: r.headline,
+    state: r.state,
+    estimate: {
+      done: r.estimate.done,
+      total: r.estimate.total,
+      basis: r.estimate.basis,
+    },
+    createdAt: r.createdAt,
+  };
+}
+
+// The newest report of each task in a workspace.
+export function latestByTask(
+  workspaceId: string
+): { report: HealthReport; name: string }[] {
+  const rows = db
+    .prepare(
+      `SELECT h.*, s.name AS name FROM health_reports h
+         JOIN session_rows s ON s.id = h.session_id
+        WHERE h.workspace_id = ?
+          AND h.id = (SELECT MAX(id) FROM health_reports WHERE session_id = h.session_id)
+        ORDER BY h.id DESC LIMIT 100`
+    )
+    .all(workspaceId) as (Row & { name: string })[];
+  return rows.map((r) => ({ report: toReport(r, undefined), name: r.name }));
+}

package/lib/reports/template.ts

@@ -0,0 +1,117 @@
+// The report with no model: sentences built from the same evidence. Used when
+// the model fails or every line it wrote was rejected, and for the headline.
+
+import type { TaskState } from "../tasks/state";
+import type { EvidenceRef, ReportLine } from "./types";
+
+const HEADLINES: Record<TaskState, string> = {
+  working: "The agent is working on it",
+  "needs-input": "The agent is waiting for an answer",
+  blocked: "The task is blocked and needs a decision",
+  review: "The pull request is open and waiting on review",
+  "checks-failing": "Checks are failing on the latest push",
+  "plan-ready": "The plan is written and waits for your approval",
+  exited: "The agent stopped before finishing",
+  merged: "The work is merged",
+  dropped: "The task was dropped",
+  done: "The task is finished",
+  moving: "The task is moving to another machine",
+};
+
+export const headlineFor = (state: TaskState) => HEADLINES[state];
+
+const NEXT: Partial<Record<TaskState, string>> = {
+  "checks-failing": "Next: fix the failing checks, then push again.",
+  review: "Next: wait for the review and the checks to settle, then merge.",
+  blocked: "Next: answer what the task is waiting on.",
+  "needs-input": "Next: reply to the agent so it can go on.",
+  "plan-ready": "Next: read the plan and approve it.",
+  exited: "Next: restart the agent or take the work over.",
+  working: "Next: let the agent finish its turn.",
+};
+
+export function templateLines(
+  state: TaskState,
+  evidence: EvidenceRef[]
+): {
+  lines: ReportLine[];
+  recommendation: { text: string; evidence: string[] } | null;
+} {
+  const lines: ReportLine[] = [];
+  const add = (tone: ReportLine["tone"], text: string, ev: EvidenceRef[]) =>
+    lines.push({
+      id: `l${lines.length + 1}`,
+      tone,
+      text,
+      evidence: ev.map((e) => e.id),
+    });
+  const of = (kind: EvidenceRef["kind"]) =>
+    evidence.filter((e) => e.kind === kind);
+
+  const ci = of("ci");
+  const ciPass = ci.filter((e) => e.status === "pass");
+  const ciFail = ci.filter((e) => e.status === "fail");
+  const ciWait = ci.filter((e) => e.status === "pending");
+  if (ciPass.length)
+    add(
+      "done",
+      `${ciPass.length} CI check${ciPass.length === 1 ? "" : "s"} passed.`,
+      ciPass
+    );
+  for (const e of ciFail) add("warn", `${e.label} is failing.`, [e]);
+  if (ciWait.length)
+    add(
+      "warn",
+      `${ciWait.length} CI check${ciWait.length === 1 ? " is" : "s are"} still running.`,
+      ciWait
+    );
+
+  for (const e of of("test"))
+    add(
+      e.status === "pass" ? "done" : e.status === "fail" ? "warn" : "next",
+      e.status === "pass"
+        ? `Tests passed: ${e.label}.`
+        : e.status === "fail"
+          ? `Tests failed: ${e.label}.`
+          : `Tests are running: ${e.label}.`,
+      [e]
+    );
+
+  for (const e of of("review"))
+    add(
+      e.status === "pass" ? "done" : e.status === "fail" ? "warn" : "next",
+      e.status === "pass"
+        ? "The independent review passed."
+        : e.status === "fail"
+          ? "The independent review found problems to fix."
+          : "The independent review has not finished.",
+      [e]
+    );
+
+  for (const e of of("piece"))
+    add(e.status === "pass" ? "done" : "next", `${e.label}.`, [e]);
+  for (const e of of("accept").filter((e) => e.status === "pass"))
+    add("done", `Verified: ${e.label}.`, [e]);
+  for (const e of of("ask")) add("blocked", `${e.label}.`, [e]);
+  for (const e of of("log")) add("done", `${e.label}.`, [e]);
+
+  const hasDiff = of("diff");
+  if (hasDiff.length)
+    add(
+      "done",
+      `${hasDiff.length} file${hasDiff.length === 1 ? "" : "s"} changed.`,
+      hasDiff.slice(0, 12)
+    );
+
+  const stateEv = of("state");
+  if (NEXT[state] && stateEv.length) add("next", NEXT[state]!, stateEv);
+
+  const bad = [...ciFail, ...of("test").filter((e) => e.status === "fail")];
+  const recommendation = bad.length
+    ? {
+        text: `Ask the agent to fix ${bad[0].label} first; everything else waits on it.`,
+        evidence: [bad[0].id],
+      }
+    : null;
+  return { lines, recommendation };
+}