agent-horde 0.1.5 → 0.2.0

package/src/tool/collaboration-actions.ts

@@ -3,15 +3,15 @@ import * as path from "node:path";
 import { listFindingsForRun } from "../ledger/findings.js";
 import { requireParam, requireText } from "../ledger/files.js";
 import { collaborationState, openMessages, projectCollaboration } from "../ledger/collaboration.js";
-import type { CollaborationState, PeerMessage } from "../ledger/collaboration.js";
-import { transactEvent } from "../ledger/events.js";
+import type { ArtifactRecord, CollaborationState, PeerMessage } from "../ledger/collaboration.js";
+import { readEvents, transactEvent } from "../ledger/events.js";
 import type { EventContext, EventDraft } from "../ledger/events.js";
 import { currentTarget, targetInfo, retainArtifact, hashText } from "./collaboration-target.js";
 import { collaborationView, inspectRecord } from "./collaboration-view.js";
 import { resourceTransition } from "./resource-contract.js";
 import type { HordeToolParams } from "./params.js";
 
-export const COLLABORATION_ACTIONS = new Set(["inbox", "message", "ack", "respond", "resolve", "defer", "attach", "review", "artifact", "resource-state", "collaboration", "inspect"]);
+export const COLLABORATION_ACTIONS = new Set(["inbox", "message", "ack", "respond", "resolve", "defer", "attach", "review", "reattest", "artifact", "resource-state", "collaboration", "inspect"]);
 interface CollaborationCommand {
   ctx: EventContext;
   state: CollaborationState;
@@ -144,9 +144,13 @@ function attachEvidence(c: CollaborationCommand): EventDraft {
   if (p.revision && p.revision !== info.revision) throw new Error("horde: target revision changed");
   const file = p.artifactPath ? retainArtifact(ctx, p.artifactPath) : {};
   const text = requireText(p.text, "attach");
+  // Contradicting evidence on an idea is how a lead dies; the record that outlives the run is a rule-out.
+  const ruleOutHint = p.relation === "contradicts" && /^I\d+$/.test(target)
+    ? { note: `${target} has contradicting evidence: a rule-out candidate. If this closes the lead, its owner (${info.owner}) should 'horde rule-out' it with this evidence as the reason so later runs do not retry it.` }
+    : {};
   return { payload: { evidenceRecord: { id: `E${seq}`, actor: ctx.actor, target, revision: info.revision,
     relation: p.relation ?? "extends", text, ...file },
-    ...(p.relation === "contradicts" ? automaticChallenge(c, target, info, text, [`E${seq}`]) : {}) } };
+    ...(p.relation === "contradicts" ? automaticChallenge(c, target, info, text, [`E${seq}`]) : {}), ...ruleOutHint } };
 }
 
 function publishArtifact(c: CollaborationCommand): EventDraft {
@@ -167,8 +171,15 @@ function publishArtifact(c: CollaborationCommand): EventDraft {
   if (existing && existing.hash === retained.hash && (existing.criteria !== criteria || JSON.stringify(existing.dependencies) !== JSON.stringify(dependencies))) {
     throw new Error("horde: changing criteria or dependencies requires a new file revision so prior reviews cannot transfer to a different contract");
   }
+  // A revision other artifacts pin is a frozen contract: re-hashing it goes stale for every
+  // dependent, so the change is announced, and reviewers can reattest when behaviour is unchanged.
+  const dependents = existing ? state.artifacts.filter((a) => a.id !== existing.id && a.dependencies.some((d) => d.target === existing.id)).map((a) => a.id) : [];
+  if (existing && existing.hash !== retained.hash && dependents.length && !p.text?.trim()) {
+    throw new Error(`horde: ${existing.id}@${existing.hash.slice(0, 12)} is pinned by ${dependents.join(", ")}; prefer a follow-up finding or artifact, or republish with text= naming the change and whether behaviour is unchanged so dependents can reattest`);
+  }
+  const changeNote = existing && existing.hash !== retained.hash && p.text?.trim() ? { changeNote: p.text.trim() } : {};
   return { payload: { artifact: { id: existing?.id ?? `A${seq}`, kind, owner: ctx.actor, ...retained,
-    criteria, dependencies } }, parents: evidenceRefs(state, p.refs) };
+    criteria, dependencies, ...changeNote }, ...(dependents.length ? { dependents } : {}) }, parents: evidenceRefs(state, p.refs) };
 }
 
 function recordReview(c: CollaborationCommand): EventDraft {
@@ -192,33 +203,71 @@ function recordReview(c: CollaborationCommand): EventDraft {
     text: requireParam(p.evidenceText, "evidenceText", p.action), ...(p.artifactPath ? retainArtifact(ctx, p.artifactPath) : {}),
   };
   if (evidenceRecord) refs.push(evidenceRecord.id);
+  const limits = p.limits?.trim();
+  // A partial verdict refutes nothing: its unchecked scope is coverage debt that the acceptance
+  // names and a full review settles. Only a refutation is an objection the owner must answer.
   return { payload: { ...(evidenceRecord ? { evidenceRecord } : {}), review: { id: `V${seq}`, actor: ctx.actor, target, revision: info.revision,
-    verdict: p.verdict, support: p.support, checked, unchecked: p.unchecked,
+    verdict: p.verdict, support: p.support, checked, unchecked: p.unchecked, ...(limits ? { limits } : {}),
     text, evidence: refs },
     ...completeAssignedReview(c, target, `V${seq}`, text, refs),
-    ...(["refutes", "partially-supports"].includes(p.verdict) ? automaticChallenge(c, target, info, text, refs) : {}),
-    ...(p.verdict === "supports" && !p.unchecked.trim() ? coverageClearance(c, target, info, `V${seq}`, refs) : {}) }, parents: refs.filter((id) => id !== evidenceRecord?.id) };
-}
-
-/** The challenge a partially-supports review raised in its own event, as opposed to an objection a member wrote. */
-function coverageChallenge(state: CollaborationState, message: PeerMessage): boolean {
-  return state.reviews.some((r) => r.id === `V${message.id.slice(1)}` && r.actor === message.sender && r.verdict === "partially-supports");
+    ...(p.verdict === "refutes" ? automaticChallenge(c, target, info, text, refs) : {}) }, parents: refs.filter((id) => id !== evidenceRecord?.id) };
 }
 
 /**
- * A partial review opens a blocking challenge that only its sender may resolve. When that review
- * contradicted nothing and another member later supports the whole revision, the unchecked scope
- * is covered: the full review clears the challenge, and the resolution names both reviews.
+ * A behaviour-neutral re-hash (a republish against a corrected dependency, an amended finding
+ * body, a spec clarification) would otherwise drop every review of the earlier revision. The
+ * reviewer carries its own latest review forward with evidence that what it checked is unchanged.
+ */
+/**
+ * What changed between the reviewed revision and the current one, as the ledger recorded it. A
+ * review carries forward only across prose: a new acceptance contract or a new claim line is a
+ * different subject and needs a fresh review.
  */
-function coverageClearance(c: CollaborationCommand, target: string, info: { revision: string }, reviewId: string, refs: string[]): Record<string, unknown> {
-  const cleared = c.state.messages.filter((m) =>
-    m.target === target && m.revision === info.revision && m.blocking && m.state !== "resolved" && m.sender !== c.ctx.actor && coverageChallenge(c.state, m));
-  if (!cleared.length) return {};
-  return { clearances: cleared.map((m) => ({
-    id: m.id,
-    text: `cleared by ${reviewId}: ${c.ctx.actor}'s full-scope supporting review of ${target}@${info.revision.slice(0, 12)} covers the scope V${m.id.slice(1)} left unchecked`,
-    refs,
-  })) };
+function reattestBlocker(ctx: EventContext, state: CollaborationState, target: string, previousRevision: string): string | undefined {
+  const events = readEvents(ctx.hordeDir, ctx.runId).filter((e) => e.outcome === "applied");
+  if (target.startsWith("A")) {
+    const current = state.artifacts.find((a) => a.id === target);
+    const earlier = events.map((e) => e.payload.artifact as ArtifactRecord | undefined).find((a) => a?.id === target && a.hash === previousRevision);
+    if (!current || !earlier) return `the reviewed revision ${previousRevision.slice(0, 12)} of ${target} is not on record`;
+    if (earlier.criteria !== current.criteria) return `${target}'s criteria changed since the reviewed revision; review the new contract`;
+    if ((earlier.kind ?? "runnable") !== (current.kind ?? "runnable")) return `${target}'s kind changed since the reviewed revision`;
+    return undefined;
+  }
+  const amends = events.filter((e) => e.action === "amend").map((e) => e.payload.result as { id?: number; previousRevision?: string; titleChanged?: boolean } | undefined);
+  const start = amends.findIndex((a) => a?.id === Number(target.slice(1)) && a.previousRevision === previousRevision);
+  if (start === -1) return `the reviewed revision ${previousRevision.slice(0, 12)} of ${target} is not the revision an amend started from; review the current text`;
+  if (amends.slice(start).some((a) => a?.id === Number(target.slice(1)) && a.titleChanged)) return `${target}'s claim line changed since the reviewed revision; review the new claim`;
+  return undefined;
+}
+
+function reattestReview(c: CollaborationCommand): EventDraft {
+  const { ctx, state, params: p, seq } = c;
+  const target = requireParam(p.target, "target", p.action);
+  if (!/^[FA]\d+$/.test(target)) throw new Error("horde: reattest targets an F# or A#");
+  const info = targetInfo(ctx, state, target);
+  if (info.owner === ctx.actor) throw new Error("horde: an independent review needs another member");
+  if (p.revision !== info.revision) throw new Error("horde: reattest must name the current revision from inspect");
+  const previous = state.reviews.findLast((r) => r.target === target && r.actor === ctx.actor && r.revision !== info.revision);
+  if (!previous) throw new Error(`horde: no earlier review of ${target} by ${ctx.actor} to carry forward; record a review instead`);
+  const blocker = reattestBlocker(ctx, state, target, previous.revision);
+  if (blocker) throw new Error(`horde: cannot reattest: ${blocker}`);
+  if (state.reviews.some((r) => r.target === target && r.actor === ctx.actor && r.revision === info.revision)) {
+    throw new Error(`horde: ${ctx.actor} already reviewed ${target}@${info.revision.slice(0, 12)}`);
+  }
+  const refs = [...evidenceRefs(state, p.refs)];
+  if (!refs.length && !p.evidenceText) throw new Error("horde: reattest needs evidence that the checked behaviour is unchanged: refs or evidenceText");
+  const stale = staleEvidence(state, refs, target, info.revision);
+  if (stale) throw new Error(`horde: reattest evidence must address the current revision: ${stale}`);
+  const text = requireText(p.text, "reattest");
+  const evidenceRecord = p.evidenceText === undefined ? undefined : {
+    id: `E${seq}`, actor: ctx.actor, target, revision: info.revision, relation: "extends" as const,
+    text: p.evidenceText, ...(p.artifactPath ? retainArtifact(ctx, p.artifactPath) : {}),
+  };
+  if (evidenceRecord) refs.push(evidenceRecord.id);
+  const review = { ...previous, id: `V${seq}`, revision: info.revision, text, evidence: refs, reattests: previous.id };
+  return { payload: { ...(evidenceRecord ? { evidenceRecord } : {}), review,
+    ...completeAssignedReview(c, target, `V${seq}`, text, refs),
+    ...(review.verdict === "refutes" ? automaticChallenge(c, target, info, text, refs) : {}) }, parents: [previous.id, ...refs.filter((id) => id !== evidenceRecord?.id)] };
 }
 
 /** The parent's assignment closes with the review id and its evidence, so the thread shows what decided it. */
@@ -239,6 +288,7 @@ function decide(c: CollaborationCommand): EventDraft {
     case "message": return newMessage(c);
     case "attach": return attachEvidence(c);
     case "review": return recordReview(c);
+    case "reattest": return reattestReview(c);
     case "artifact": return publishArtifact(c);
     case "resource-state": return resourceTransition(c);
     default: return transition(c);

package/src/tool/params.ts

@@ -28,19 +28,20 @@ export const HordeParams = Type.Object({
       "confirm-solved",
       "contest-solved",
       "concerns",
-      "verify", "inbox", "message", "ack", "respond", "resolve", "defer",
-      "attach", "review", "artifact", "resource-state", "collaboration", "inspect",
+      "verify", "amend", "inbox", "message", "ack", "respond", "resolve", "defer",
+      "attach", "review", "reattest", "artifact", "resource-state", "collaboration", "inspect",
     ] as const,
     {
       description:
         "list/findings/facts/claims/resources/concerns: read shared state; post: BOARD.md; " +
         "idea/claim/done/drop/rule-out: checklist (rule-out is a terminal negative); " +
         "finding: FINDINGS.md with a claimed idea, a concern slug, and optional importance/" +
-        "confidence/support; " +
+        "confidence/support; amend: rewrite the body prose of your own F#id at its current revision; " +
         "verify: record your independent reproduction of finding F#id with the support level you reached; " +
         "fact: FACTS.md; assert/confirm/contest/retract/supersede: change claim C#id state; " +
         "resource: claim a shared dataset, harness, corpus, or sandbox (with cleanup) before building it; " +
-        "solved: propose the goal answered; confirm-solved/contest-solved: validate or refute it",
+        "solved: propose the goal answered; confirm-solved/contest-solved: validate or refute it; " +
+        "reattest: carry your earlier review of F#/A# forward to its current revision with evidence that the checked behaviour is unchanged",
     },
   ),
   detail: Type.Optional(StringEnum(["summary", "full"] as const, { description: "Collaboration reads default to summaries; full returns complete page bodies, inspected subjects or write receipts. inspect E#/V#/Q# always returns the full record." })),
@@ -57,7 +58,8 @@ export const HordeParams = Type.Object({
   relation: Type.Optional(StringEnum(["supports", "contradicts", "extends"] as const)),
   verdict: Type.Optional(StringEnum(["supports", "partially-supports", "refutes", "inconclusive"] as const)),
   checked: Type.Optional(Type.String({ description: "Exact assertions checked and method; required for review." })),
-  unchecked: Type.Optional(Type.String({ description: "Assertions left unchecked or limitations; empty only for full coverage." })),
+  unchecked: Type.Optional(Type.String({ description: "Assertions inside the target's stated claim or criteria that you did not check; empty only for full coverage of that scope. Disclosures outside the criteria go in limits." })),
+  limits: Type.Optional(Type.String({ description: "For review: limits outside the target's declared claim or criteria (one engine, no hardened deployment). Recorded on the acceptance as limits, never as blockers." })),
   artifactKind: Type.Optional(StringEnum(["runnable", "document"] as const, { description: "Artifact classification, immutable after publication. Default runnable requires tested/reproduced review. document permits full-scope sourced/derived review of its stated criteria, not runtime acceptance." })),
   artifactPath: Type.Optional(Type.String({ description: "File path relative to this run, under artifacts/, retained by content hash." })),
   criteria: Type.Optional(Type.String({ description: "Artifact acceptance criteria, including positive/negative tests." })),
@@ -168,8 +170,8 @@ export type HordeToolParams = {
     | "confirm-solved"
     | "contest-solved"
     | "concerns"
-    | "verify" | "inbox" | "message" | "ack" | "respond" | "resolve" | "defer"
-    | "attach" | "review" | "artifact" | "resource-state" | "collaboration" | "inspect";
+    | "verify" | "amend" | "inbox" | "message" | "ack" | "respond" | "resolve" | "defer"
+    | "attach" | "review" | "reattest" | "artifact" | "resource-state" | "collaboration" | "inspect";
   detail?: "summary" | "full";
   offset?: number;
   limit?: number;
@@ -185,6 +187,7 @@ export type HordeToolParams = {
   verdict?: "supports" | "partially-supports" | "refutes" | "inconclusive";
   checked?: string;
   unchecked?: string;
+  limits?: string;
   artifactPath?: string;
   artifactKind?: "runnable" | "document";
   criteria?: string;

package/src/tool/register.ts

@@ -2,8 +2,9 @@ import * as path from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { cleanStopRequestedFor, writeHeartbeat } from "../ledger/run-signals.js";
 import { envNumber } from "../format.js";
+import { parseSiblings } from "../member.js";
 import { ReminderGate, goalReminder } from "../reminder.js";
-import { runHordeAction } from "./actions.js";
+import { isVerifierRole, runHordeAction } from "./actions.js";
 import { pendingVerificationHint, solvedHint } from "./hints.js";
 import { HordeParams } from "./params.js";
 import { compactReceipt } from "./collaboration-view.js";
@@ -18,9 +19,12 @@ const REMIND_MS = envNumber("PI_HORDE_REMIND_MS", 600_000);
 const MUTATING_ACTIONS = new Set([
   "post", "idea", "claim", "done", "drop", "rule-out", "finding", "fact", "assert", "confirm",
   "contest", "retract", "supersede", "resource", "solved", "confirm-solved", "contest-solved",
-  "verify", "message", "ack", "respond", "resolve", "defer", "attach", "review", "artifact", "resource-state",
+  "verify", "amend", "message", "ack", "respond", "resolve", "defer", "attach", "review", "reattest", "artifact", "resource-state",
 ]);
 
+/** After these, a verifier is shown what it still has to review. */
+const VERIFIER_QUEUE_ACTIONS = new Set(["verify", "review", "reattest", "post", "findings"]);
+
 export function registerMemberTool(pi: ExtensionAPI): void {
   const hordeDir = process.env.PI_HORDE_DIR;
   const member = process.env.PI_HORDE_NAME;
@@ -28,6 +32,7 @@ export function registerMemberTool(pi: ExtensionAPI): void {
     throw new Error("agent-horde: PI_HORDE_DIR and PI_HORDE_NAME must be set for a horde member");
   }
   const attempt = process.env.PI_HORDE_ATTEMPT ?? `pid-${process.pid}`;
+  const siblings = parseSiblings(process.env.PI_HORDE_SIBLINGS);
   const activeRun = process.env.PI_HORDE_RUN;
   if (activeRun) registerInbox(pi, { hordeDir, runId: activeRun, actor: member, attempt });
   // One member per process, so one gate is the per-member reminder counter.
@@ -60,13 +65,15 @@ export function registerMemberTool(pi: ExtensionAPI): void {
     parameters: HordeParams,
     async execute(toolCallId, params) {
       const runId = process.env.PI_HORDE_RUN;
-      const result = await runHordeAction(hordeDir, member, params, runId, { attempt, requestId: toolCallId });
+      const role = process.env.PI_HORDE_ROLE;
+      const result = await runHordeAction(hordeDir, member, params, runId, { attempt, requestId: toolCallId, role, siblings });
       const runDir = runId ? path.join(hordeDir, "runs", runId) : undefined;
       if (runDir && MUTATING_ACTIONS.has(params.action)) touchHeartbeat(runDir, member);
       let text = compactReceipt(result.text, params) + solvedHint(hordeDir, runId, member, params.action);
-      // A verifier's coverage claim is only a snapshot. Append the live pending queue
-      // after every verify so a finding filed later cannot read as already checked.
-      if (runId && params.action === "verify" && /verifier/i.test(process.env.PI_HORDE_ROLE ?? "")) {
+      // A verifier's coverage claim is only a snapshot. Append the live pending queue after every
+      // review and every board update, so the unreviewed F# are named before wind-down and a
+      // finding filed later cannot read as already checked.
+      if (runId && VERIFIER_QUEUE_ACTIONS.has(params.action) && isVerifierRole(role)) {
         text += pendingVerificationHint(hordeDir, runId, member);
       }
       const winding = Boolean(runId && cleanStopRequestedFor(hordeDir, runId, member));

package/src/widget.ts

@@ -1,17 +1,30 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth } from "@earendil-works/pi-tui";
-import { formatElapsed } from "./format.js";
+import { formatElapsed, formatTokens } from "./format.js";
 import type { MemberState } from "./member.js";
-import { memberActivity, statusCounts } from "./prompt.js";
+import { memberActivity, statusCounts, totalUsage } from "./prompt.js";
 
 interface WidgetRun {
   id: string;
+  horde: number;
   members: MemberState[];
   startedAt: number;
   cleanStopUntil?: number | undefined;
   dashboardUrl?: string | undefined;
   /** Steps still running after members finished, e.g. ["deliverable", "post-mortem"]. */
   finalizing?: string[] | undefined;
+  reported?: boolean | undefined;
+  finalized?: boolean | undefined;
+  outcome?: string | undefined;
+}
+
+interface WidgetSwarm {
+  id: string;
+  runs: WidgetRun[];
+  startedAt: number;
+  dashboardUrl?: string | undefined;
+  /** The swarm step still running after every horde finalized, e.g. ["merge"]. */
+  finalizing?: string[] | undefined;
 }
 
 const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
@@ -65,8 +78,8 @@ function memberLine(m: MemberState, now: number, frame: number, theme: Theme): s
   );
 }
 
-export function widgetLines(run: WidgetRun, now: number, width: number, theme: Theme): string[] {
-  const frame = Math.floor(now / 100) % SPINNER.length;
+/** The widget for one horde: a header, then a line per member (a glyph strip past eight). */
+function runLines(run: WidgetRun, now: number, frame: number, theme: Theme): string[] {
   const lines = [headerLine(run, now, theme)];
   if (run.members.length > COLLAPSE_ABOVE) {
     lines.push(` ${run.members.map((m) => statusGlyph(m, frame, theme)).join(" ")}`);
@@ -77,22 +90,81 @@ export function widgetLines(run: WidgetRun, now: number, width: number, theme: T
   } else {
     for (const m of run.members) lines.push(memberLine(m, now, frame, theme));
   }
+  return lines;
+}
+
+/** What one horde of a swarm is doing, in a word. */
+function hordeActivity(run: WidgetRun, c: ReturnType<typeof statusCounts>): string {
+  if (run.finalized) return run.outcome ?? "finished";
+  if (run.finalizing && run.finalizing.length > 0) return `synthesizing ${run.finalizing.join(", ")}`;
+  if (run.reported) return "finalizing";
+  if (run.cleanStopUntil !== undefined) return "stopping";
+  return c.running + c.starting > 0 ? "running" : "finishing";
+}
+
+/** One line per horde: `h2  11/12 running  1 done  t120  45.2k tok  $1.20  running`. */
+export function hordeLine(run: WidgetRun, now: number, frame: number, theme: Theme): string {
+  const c = statusCounts(run.members);
+  const usage = totalUsage(run.members);
+  const live = run.members.find((m) => m.status === "running");
+  const glyph = run.finalized
+    ? theme.fg("success", "✓")
+    : live
+      ? theme.fg("accent", SPINNER[frame % SPINNER.length] ?? "⠋")
+      : theme.fg("dim", "·");
+  const parts = [
+    `${c.running + c.starting}/${run.members.length} running`,
+    `${c.done} done`,
+  ];
+  if (c.failed) parts.push(theme.fg("error", `${c.failed} failed`));
+  if (c.stopped) parts.push(theme.fg("warning", `${c.stopped} stopped`));
+  parts.push(theme.fg("dim", `t${usage.turns}  ${formatTokens(usage.input + usage.output)} tok  $${usage.cost.toFixed(2)}`));
+  parts.push(theme.fg("muted", hordeActivity(run, c)));
+  return ` ${glyph} ${`h${run.horde}`.padEnd(3)} ${parts.join("  ")}`;
+}
+
+function swarmHeader(swarm: WidgetSwarm, now: number, theme: Theme): string {
+  const members = swarm.runs.flatMap((run) => run.members);
+  const c = statusCounts(members);
+  const parts = [
+    theme.bold(theme.fg("accent", `swarm ${swarm.id}`)),
+    `${swarm.runs.length} hordes`,
+    `${c.running + c.starting} running`,
+    `${c.done} done`,
+  ];
+  if (c.failed) parts.push(theme.fg("error", `${c.failed} failed`));
+  if (c.stopped) parts.push(theme.fg("warning", `${c.stopped} stopped`));
+  parts.push(formatElapsed(now - swarm.startedAt));
+  if (swarm.finalizing && swarm.finalizing.length > 0) {
+    parts.push(theme.fg("warning", `synthesizing ${swarm.finalizing.join(", ")}`));
+  }
+  if (swarm.dashboardUrl) parts.push(`${swarm.dashboardUrl}swarms/${swarm.id}`);
+  return `${parts.join("  ")}  ${theme.fg("dim", "/agent-horde status | stop-hard | stop-clean [hN]")}`;
+}
+
+/** A swarm of one shows its run as before; a larger swarm shows one line per horde. */
+export function widgetLines(swarm: WidgetSwarm, now: number, width: number, theme: Theme): string[] {
+  const frame = Math.floor(now / 100) % SPINNER.length;
+  const single = swarm.runs.length === 1 ? swarm.runs[0] : undefined;
+  const lines = single
+    ? runLines(single, now, frame, theme)
+    : [swarmHeader(swarm, now, theme), ...swarm.runs.map((run) => hordeLine(run, now, frame, theme))];
   return lines.map((line) => truncateToWidth(line, width));
 }
 
 export class HordeWidget {
-  private readonly run: WidgetRun;
+  private readonly swarm: WidgetSwarm;
   private readonly theme: Theme;
   private readonly now: () => number;
 
-  constructor(run: WidgetRun, theme: Theme, now: () => number = Date.now) {
-    this.run = run;
+  constructor(swarm: WidgetSwarm, theme: Theme, now: () => number = Date.now) {
+    this.swarm = swarm;
     this.theme = theme;
     this.now = now;
   }
 
   render(width: number): string[] {
-    return widgetLines(this.run, this.now(), width, this.theme);
+    return widgetLines(this.swarm, this.now(), width, this.theme);
   }
 
   invalidate(): void {}