agent-horde 0.1.5 → 0.2.0

package/src/args.ts

@@ -1,8 +1,13 @@
 export const MAX_MEMBERS = 12;
 
+/** Hordes per swarm; `H/M` launches H hordes of M members. */
+export const MAX_HORDES = 4;
+
 export const USAGE = [
-  "usage: /agent-horde [--dashboard[=<port>]] [--no-verifier] <count> <prompt>",
-  "                                          spawn <count> members with the same prompt",
+  "usage: /agent-horde [--dashboard[=<port>]] [--no-verifier] [--until-stop] <count> <prompt>",
+  "                                          spawn <count> members with the same prompt;",
+  "                                          <count> may be H/M: H hordes of M members, the",
+  "                                          task partitioned between the hordes by a planner",
   "       /agent-horde status [target]       show the active run",
   "       /agent-horde stop-hard [target]    terminate members now (SIGTERM, then SIGKILL)",
   "       /agent-horde stop-clean [target]   let members wrap up, then reconcile their ideas",
@@ -11,21 +16,34 @@ export const USAGE = [
   "       /agent-horde pause [target]        suspend members (SIGSTOP)",
   "       /agent-horde resume [target]       resume suspended members (SIGCONT)",
   `       /agent-horde plan [--dashboard] <count> <a; b; ...>`,
-  "                                          partition members across workstreams",
+  "                                          partition members across workstreams; with H/M",
+  "                                          the layers go round-robin to the hordes",
   "       /agent-horde help                  show this text",
   "",
-  "target is 'all' (default), 'member-N', 'N', or a comma/space separated list.",
-  `count is a whole number from 1 to ${MAX_MEMBERS}`,
+  "target is 'all' (default), 'member-N', 'N', 'hN' (one horde), 'hN:member-M', 'hN:M', or a",
+  "comma/space separated list; a bare member names that member in every horde.",
+  `count is a whole number from 1 to ${MAX_MEMBERS}, or H/M with H from 1 to ${MAX_HORDES}`,
   "--dashboard serves a read-only localhost dashboard (default port 7433, or",
   "PI_HORDE_DASHBOARD_PORT); --dashboard=<port> picks the port.",
   "--no-verifier skips the default verifier role that runs of 3 or more members assign",
   "to their last member.",
+  "--until-stop keeps the whole horde working until you run stop-clean or stop-hard: a",
+  "validated solve is banked as the current answer and a member that finishes gets a fresh",
+  "session told to add new ideas.",
 ].join("\n");
 
-/** Which members a control command applies to. */
+/** One token of a control target: a horde, a member in every horde, or a member of one horde. */
+export interface TargetItem {
+  /** 1-based horde index (`h2`); absent for every horde. */
+  horde?: number;
+  /** `member-N`; absent for every member of the horde. */
+  member?: string;
+}
+
+/** Which hordes and members a control command applies to. */
 export type HordeTarget =
   | { kind: "all" }
-  | { kind: "members"; names: string[] };
+  | { kind: "selection"; items: TargetItem[] };
 
 type HordeStopMode = "hard" | "clean";
 
@@ -43,32 +61,66 @@ type HordeArgs =
   | { kind: "resume"; target: HordeTarget }
   | {
       kind: "run";
+      /** Concurrent hordes; `12` is one horde, `3/12` three. */
+      hordes: number;
+      /** Members per horde. */
       count: number;
       prompt: string;
       plan?: string[] | undefined;
       dashboard?: DashboardOption | undefined;
       /** Present (true) only when `--no-verifier` was given. */
       noVerifier?: boolean | undefined;
+      /** Present (true) only when `--until-stop` was given. */
+      untilStop?: boolean | undefined;
     };
 
 export type HordeRunArgs = Extract<HordeArgs, { kind: "run" }>;
 
+const HORDE_TOKEN = /^h(\d+)$/i;
+const MEMBER_TOKEN = /^(?:member-)?(\d+)$/i;
+
+function memberName(token: string): string | undefined {
+  const match = MEMBER_TOKEN.exec(token);
+  if (!match) return undefined;
+  const index = Number(match[1]);
+  return index >= 1 && index <= MAX_MEMBERS ? `member-${index}` : undefined;
+}
+
+function hordeIndex(token: string): number | undefined {
+  const match = HORDE_TOKEN.exec(token);
+  if (!match) return undefined;
+  const index = Number(match[1]);
+  return index >= 1 && index <= MAX_HORDES ? index : undefined;
+}
+
+/** `h2`, `h2:member-3`, `h2:3`, `member-3`, or `3`; undefined for anything else. */
+function parseTargetItem(token: string): TargetItem | undefined {
+  const colon = token.indexOf(":");
+  if (colon === -1) {
+    const horde = hordeIndex(token);
+    if (horde !== undefined) return { horde };
+    const member = memberName(token);
+    return member === undefined ? undefined : { member };
+  }
+  const horde = hordeIndex(token.slice(0, colon));
+  const member = memberName(token.slice(colon + 1));
+  return horde === undefined || member === undefined ? undefined : { horde, member };
+}
+
 function parseTargets(raw: string): HordeTarget | undefined {
   const trimmed = raw.trim();
   if (trimmed === "") return { kind: "all" };
-  const names: string[] = [];
+  const items: TargetItem[] = [];
   for (const token of trimmed.split(/[\s,]+/).filter(Boolean)) {
     if (token.toLowerCase() === "all") return { kind: "all" };
-    const match = /^(?:member-)?(\d+)$/i.exec(token);
-    if (!match) return undefined;
-    const index = Number(match[1]);
-    if (index < 1 || index > MAX_MEMBERS) return undefined;
-    names.push(`member-${index}`);
+    const item = parseTargetItem(token);
+    if (!item) return undefined;
+    items.push(item);
   }
-  return names.length > 0 ? { kind: "members", names } : { kind: "all" };
+  return items.length > 0 ? { kind: "selection", items } : { kind: "all" };
 }
 
-const TARGET_ERROR = "invalid target; use all, member-N, or N";
+const TARGET_ERROR = "invalid target; use all, member-N, N, hN, or hN:member-M";
 
 function parseStopRest(
   rest: string,
@@ -102,6 +154,7 @@ function parseStopRest(
 
 const DASHBOARD_FLAG = /^--dashboard(?:=(\S*))?(?=\s|$)/;
 const NO_VERIFIER_FLAG = /^--no-verifier(?=\s|$)/;
+const UNTIL_STOP_FLAG = /^--until-stop(?=\s|$)/;
 const DASHBOARD_ERROR = "invalid --dashboard; use --dashboard or --dashboard=<port 1-65535>";
 
 /** Launch flags found at one position of the command; `rest` is the remaining text. */
@@ -109,6 +162,7 @@ interface LaunchFlags {
   rest: string;
   dashboard?: DashboardOption | undefined;
   noVerifier?: boolean | undefined;
+  untilStop?: boolean | undefined;
   error?: string | undefined;
 }
 
@@ -120,7 +174,7 @@ function parseDashboardFlag(port: string | undefined): DashboardOption | { error
   return { port: value };
 }
 
-/** Strip leading `--dashboard[=<port>]` and `--no-verifier` tokens, in any order. */
+/** Strip leading `--dashboard[=<port>]`, `--no-verifier`, and `--until-stop` tokens, in any order. */
 function takeLaunchFlags(text: string): LaunchFlags {
   const flags: LaunchFlags = { rest: text.trim() };
   for (;;) {
@@ -138,6 +192,12 @@ function takeLaunchFlags(text: string): LaunchFlags {
       flags.rest = flags.rest.slice(noVerifier[0].length).trim();
       continue;
     }
+    const untilStop = UNTIL_STOP_FLAG.exec(flags.rest);
+    if (untilStop) {
+      flags.untilStop = true;
+      flags.rest = flags.rest.slice(untilStop[0].length).trim();
+      continue;
+    }
     return flags;
   }
 }
@@ -148,39 +208,68 @@ function mergeLaunchFlags(leading: LaunchFlags, trailing: LaunchFlags): LaunchFl
     rest: trailing.rest,
     dashboard: leading.dashboard ?? trailing.dashboard,
     noVerifier: leading.noVerifier === true || trailing.noVerifier === true ? true : undefined,
+    untilStop: leading.untilStop === true || trailing.untilStop === true ? true : undefined,
     error: leading.error ?? trailing.error,
   };
 }
 
-/** Parse `<count> [flags] <tail>`. */
-function parseCountedRun(
-  text: string,
-  leading: LaunchFlags,
-): { count: number; rest: string; flags: LaunchFlags } | { error: string } {
-  const match = /^(\d+)(?:\s+([\s\S]*))?$/.exec(text.trim());
-  if (!match) return { error: `count must be a whole number from 1 to ${MAX_MEMBERS}` };
-  const count = Number(match[1]);
-  if (count < 1 || count > MAX_MEMBERS) {
-    return { error: `count must be a whole number from 1 to ${MAX_MEMBERS}` };
-  }
-  const flags = mergeLaunchFlags(leading, takeLaunchFlags(match[2] ?? ""));
+const COUNT_ERROR =
+  `count must be a whole number from 1 to ${MAX_MEMBERS}, or H/M with H from 1 to ${MAX_HORDES} hordes`;
+
+interface CountedRun {
+  hordes: number;
+  count: number;
+  rest: string;
+  flags: LaunchFlags;
+}
+
+/** Parse `<count> [flags] <tail>`, where count is `M` or `H/M`. */
+function parseCountedRun(text: string, leading: LaunchFlags): CountedRun | { error: string } {
+  const match = /^(?:(\d+)\/)?(\d+)(?:\s+([\s\S]*))?$/.exec(text.trim());
+  if (!match) return { error: COUNT_ERROR };
+  const hordes = match[1] === undefined ? 1 : Number(match[1]);
+  const count = Number(match[2]);
+  if (count < 1 || count > MAX_MEMBERS || hordes < 1 || hordes > MAX_HORDES) return { error: COUNT_ERROR };
+  const flags = mergeLaunchFlags(leading, takeLaunchFlags(match[3] ?? ""));
   if (flags.error) return { error: flags.error };
-  return { count, rest: flags.rest, flags };
+  return { hordes, count, rest: flags.rest, flags };
 }
 
-function runArgs(count: number, prompt: string, flags: LaunchFlags, plan?: string[]): HordeRunArgs {
-  const args: HordeRunArgs = { kind: "run", count, prompt };
+function runArgs(parsed: CountedRun, prompt: string, plan?: string[]): HordeRunArgs {
+  const { hordes, count, flags } = parsed;
+  const args: HordeRunArgs = { kind: "run", hordes, count, prompt };
   if (plan) args.plan = plan;
   if (flags.dashboard) args.dashboard = flags.dashboard;
   if (flags.noVerifier) args.noVerifier = true;
+  if (flags.untilStop) args.untilStop = true;
   return args;
 }
 
+function parsePlan(rest: string, leading: LaunchFlags): HordeArgs {
+  const afterPlan = takeLaunchFlags(rest);
+  if (afterPlan.error) return { kind: "usage", error: afterPlan.error };
+  const parsed = parseCountedRun(afterPlan.rest, mergeLaunchFlags(leading, afterPlan));
+  if ("error" in parsed) {
+    return { kind: "usage", error: "plan usage: /agent-horde plan <count> <layer1; layer2; ...>" };
+  }
+  const layers = parsed.rest
+    .split(/[;\n]/)
+    .map((layer) => layer.trim())
+    .filter(Boolean);
+  if (layers.length < 2) {
+    return { kind: "usage", error: "plan needs at least 2 layers separated by ';'" };
+  }
+  if (layers.length < parsed.hordes) {
+    return { kind: "usage", error: `plan with ${parsed.hordes} hordes needs at least ${parsed.hordes} layers` };
+  }
+  return runArgs(parsed, layers.join("; "), layers);
+}
+
 export function parseHordeArgs(raw: string): HordeArgs {
   const leading = takeLaunchFlags(raw);
   if (leading.error) return { kind: "usage", error: leading.error };
   const trimmed = leading.rest;
-  const hasFlags = leading.dashboard !== undefined || leading.noVerifier === true;
+  const hasFlags = leading.dashboard !== undefined || leading.noVerifier === true || leading.untilStop === true;
   if (trimmed === "") {
     return hasFlags ? { kind: "usage", error: "count is required" } : { kind: "usage" };
   }
@@ -188,7 +277,7 @@ export function parseHordeArgs(raw: string): HordeArgs {
   const space = trimmed.search(/\s/);
   const head = (space === -1 ? trimmed : trimmed.slice(0, space)).toLowerCase();
   const rest = space === -1 ? "" : trimmed.slice(space + 1);
-  if (hasFlags && head !== "plan" && !/^\d+$/.test(head)) {
+  if (hasFlags && head !== "plan" && !/^\d+(?:\/\d+)?$/.test(head)) {
     return { kind: "usage", error: "launch flags only apply when starting a run" };
   }
 
@@ -217,22 +306,8 @@ export function parseHordeArgs(raw: string): HordeArgs {
       const target = parseTargets(rest);
       return target ? { kind: "pause", target } : { kind: "usage", error: TARGET_ERROR };
     }
-    case "plan": {
-      const afterPlan = takeLaunchFlags(rest);
-      if (afterPlan.error) return { kind: "usage", error: afterPlan.error };
-      const parsed = parseCountedRun(afterPlan.rest, mergeLaunchFlags(leading, afterPlan));
-      if ("error" in parsed) {
-        return { kind: "usage", error: "plan usage: /agent-horde plan <count> <layer1; layer2; ...>" };
-      }
-      const layers = parsed.rest
-        .split(/[;\n]/)
-        .map((layer) => layer.trim())
-        .filter(Boolean);
-      if (layers.length < 2) {
-        return { kind: "usage", error: "plan needs at least 2 layers separated by ';'" };
-      }
-      return runArgs(parsed.count, layers.join("; "), parsed.flags, layers);
-    }
+    case "plan":
+      return parsePlan(rest, leading);
     case "resume": {
       const target = parseTargets(rest);
       return target ? { kind: "resume", target } : { kind: "usage", error: TARGET_ERROR };
@@ -242,5 +317,5 @@ export function parseHordeArgs(raw: string): HordeArgs {
   const parsed = parseCountedRun(trimmed, leading);
   if ("error" in parsed) return { kind: "usage", error: parsed.error };
   if (parsed.rest === "") return { kind: "usage", error: "prompt is required" };
-  return runArgs(parsed.count, parsed.rest, parsed.flags);
+  return runArgs(parsed, parsed.rest);
 }

package/src/build-info.ts

@@ -0,0 +1,65 @@
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** What is running: the package version and, from a git checkout, the commit it is at. */
+export interface BuildInfo {
+  name: string;
+  version: string;
+  /** Short hash of HEAD, suffixed `-dirty` when the tree has uncommitted changes; absent outside a checkout. */
+  commit?: string | undefined;
+  /** The project's web repository, for linking the commit. */
+  repository?: string | undefined;
+}
+
+const GIT_TIMEOUT_MS = 2_000;
+
+/** The package directory: the parent of `src/`, which is also where `package.json` lives. */
+export function packageRoot(): string {
+  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+}
+
+function repositoryUrl(raw: unknown): string | undefined {
+  const url = typeof raw === "string" ? raw : typeof raw === "object" && raw !== null ? (raw as { url?: unknown }).url : undefined;
+  if (typeof url !== "string") return undefined;
+  const web = url.replace(/^git\+/, "").replace(/\.git$/, "");
+  return web.startsWith("https://") ? web : undefined;
+}
+
+/** The commit of the checkout rooted at `root`, or undefined when `root` is not itself a checkout (no parent repo is consulted). */
+function describeCommit(root: string): string | undefined {
+  if (!fs.existsSync(path.join(root, ".git"))) return undefined;
+  try {
+    const out = execFileSync("git", ["describe", "--always", "--dirty", "--exclude=*", "--abbrev=7"], {
+      cwd: root,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    return /^[0-9a-f]{7,40}(?:-dirty)?$/.test(out) ? out : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Reads the package at `root`; throws when its package.json is missing or malformed. */
+export function readBuildInfo(root: string): BuildInfo {
+  const file = path.join(root, "package.json");
+  let pkg: { name?: unknown; version?: unknown; repository?: unknown };
+  try {
+    pkg = JSON.parse(fs.readFileSync(file, "utf8")) as typeof pkg;
+  } catch (error) {
+    throw new Error(`cannot read ${file}: ${error instanceof Error ? error.message : String(error)}; reinstall agent-horde`);
+  }
+  if (typeof pkg.name !== "string" || typeof pkg.version !== "string") throw new Error(`${file} has no name or version; reinstall agent-horde`);
+  return { name: pkg.name, version: pkg.version, commit: describeCommit(root), repository: repositoryUrl(pkg.repository) };
+}
+
+let cached: BuildInfo | undefined;
+
+/** The running package's build, read once per process. */
+export function buildInfo(): BuildInfo {
+  cached ??= readBuildInfo(packageRoot());
+  return cached;
+}

package/src/collaboration-report.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { artifactAccepted, blockingMessages, collaborationState, openMessages } from "./ledger/collaboration.js";
+import { artifactAccepted, artifactLimits, blockingMessages, collaborationState, openMessages, partialArtifactReviews } from "./ledger/collaboration.js";
 import type { ArtifactRecord, CollaborationState, PeerMessage } from "./ledger/collaboration.js";
 import { readEvents } from "./ledger/events.js";
 import { findingReviewState, findingRevision, listFindingsForRun } from "./ledger/findings.js";
@@ -13,6 +13,8 @@ export interface CollaborationReport {
   sequence: number;
   state: CollaborationState;
   issues: string[];
+  /** Limits the accepting reviews disclosed outside each accepted artifact's criteria. */
+  limits: string[];
   acceptedArtifacts: string[];
   acceptedDocuments: string[];
   acceptedRunnableArtifacts: string[];
@@ -55,9 +57,14 @@ function artifactProblem(hordeDir: string, runId: string, state: CollaborationSt
   // "needs a review" sent them after a review that already existed.
   const blocker = blockingMessages(state).find((m) => m.target === artifact.id);
   if (blocker) return `blocked by ${blocker.id} (${blocker.state} blocking ${blocker.kind} from ${blocker.sender})`;
-  return artifactAccepted(state, artifact) ? undefined : artifact.kind === "document"
+  if (artifactAccepted(state, artifact)) return undefined;
+  // A partial review is coverage debt, not an objection: the acceptance names what it left
+  // unchecked so a full review, or one covering that scope, can settle it.
+  const partial = partialArtifactReviews(state, artifact).map((r) => `${r.id} (${r.actor}) left unchecked: ${r.unchecked.trim()}`);
+  const need = artifact.kind === "document"
     ? "needs a full independent review against document criteria"
     : "needs a full independent tested/reproduced review";
+  return partial.length ? `${need}; ${partial.join("; ")}` : need;
 }
 
 export function loadCollaborationReport(hordeDir: string, runId: string): CollaborationReport {
@@ -65,10 +72,15 @@ export function loadCollaborationReport(hordeDir: string, runId: string): Collab
   const state = collaborationState(hordeDir, runId);
   const issues = blockingMessages(state).map((m) => `${m.id} ${m.target}: ${m.state} blocking ${m.kind}`);
   const acceptedArtifacts: string[] = [];
+  const limits: string[] = [];
   for (const artifact of state.artifacts) {
     const problem = artifactProblem(hordeDir, runId, state, artifact);
-    if (problem) issues.push(`${artifact.id}@${artifact.hash}: ${problem}; exclude from recommended ${artifact.kind === "document" ? "document" : "runnable"} outputs`);
-    else acceptedArtifacts.push(artifact.id);
+    if (problem) {
+      issues.push(`${artifact.id}@${artifact.hash}: ${problem}; exclude from recommended ${artifact.kind === "document" ? "document" : "runnable"} outputs`);
+      continue;
+    }
+    acceptedArtifacts.push(artifact.id);
+    limits.push(...artifactLimits(state, artifact).map((limit) => `${artifact.id}@${artifact.hash}: accepted with limits outside its criteria; ${limit}`));
   }
   for (const f of listFindingsForRun(hordeDir, runId)) {
     if (f.supersededBy !== undefined) continue;
@@ -83,7 +95,7 @@ export function loadCollaborationReport(hordeDir: string, runId: string): Collab
   const delays = messages.flatMap((m) => Object.values(m.deliveries).slice(0, 1).map((time) => Date.parse(time) - Date.parse(m.createdAt)));
   const acceptedDocuments = state.artifacts.filter((a) => a.kind === "document" && acceptedArtifacts.includes(a.id)).map((a) => a.id);
   const acceptedRunnableArtifacts = acceptedArtifacts.filter((id) => !acceptedDocuments.includes(id));
-  return { runId, sequence: state.seq, state, issues, acceptedArtifacts, acceptedDocuments, acceptedRunnableArtifacts, metrics: {
+  return { runId, sequence: state.seq, state, issues, limits, acceptedArtifacts, acceptedDocuments, acceptedRunnableArtifacts, metrics: {
     events: events.length, rejected: events.filter((e) => e.outcome === "rejected").length,
     unresolved: openMessages(state).length, blocking: blockingMessages(state).length,
     resolvedChallenges: messages.filter((m) => m.kind === "challenge" && m.state === "resolved").length,
@@ -116,9 +128,10 @@ function collaborationMarkdown(report: CollaborationReport): string {
   return [
     `# Collaboration ${report.runId}`, `\nEvent high-water mark: ${report.sequence}. Delivery records context insertion, not comprehension.`,
     "\n## Acceptance issues", ...(report.issues.length ? report.issues.map((i) => `- ${i}`) : ["- No protocol-level issues recorded; task acceptance still requires coverage and review."]),
+    "\n## Accepted with limits", ...(report.limits.length ? report.limits.map((l) => `- ${l}`) : ["- none disclosed"]),
     "\n## Questions, challenges and handoffs", ...state.messages.map(messageMarkdown),
-    "\n## Artifact revisions", ...state.artifacts.map((a) => `- ${a.id} ${a.path}@${a.hash} owner=${a.owner} kind=${a.kind ?? "runnable"} snapshot=${a.snapshot} accepted=${report.acceptedArtifacts.includes(a.id)}\n  Criteria: ${a.criteria}\n  Dependencies: ${JSON.stringify(a.dependencies)}`),
-    "\n## Reviews", ...state.reviews.map((r) => `- ${r.id} ${r.target}@${r.revision} @${r.actor} ${r.verdict} [${r.support}] evidence=${r.evidence.join(",")}\n  Checked: ${r.checked}\n  Unchecked: ${r.unchecked || "none declared"}\n  ${r.text}`),
+    "\n## Artifact revisions", ...state.artifacts.map((a) => `- ${a.id} ${a.path}@${a.hash} owner=${a.owner} kind=${a.kind ?? "runnable"} snapshot=${a.snapshot} accepted=${report.acceptedArtifacts.includes(a.id)}\n  Criteria: ${a.criteria}\n  Dependencies: ${JSON.stringify(a.dependencies)}${a.changeNote ? `\n  Change: ${a.changeNote}` : ""}`),
+    "\n## Reviews", ...state.reviews.map((r) => `- ${r.id} ${r.target}@${r.revision} @${r.actor} ${r.verdict} [${r.support}] evidence=${r.evidence.join(",")}${r.reattests ? ` reattests=${r.reattests}` : ""}\n  Checked: ${r.checked}\n  Unchecked: ${r.unchecked || "none declared"}\n  Limits: ${r.limits || "none disclosed"}\n  ${r.text}`),
     "\n## Evidence", ...state.evidence.map((e) => `- ${e.id} ${e.target}@${e.revision} @${e.actor} ${e.relation}${e.path ? ` ${e.path}@${e.hash}` : ""}\n  ${e.text}`),
     "\n## Resources", ...state.resources.map((r) => `- ${r.target} ${r.state} generation=${r.generation} @${r.owner}/${r.attempt} ports=${r.ports.join(",")} lease=${new Date(r.leaseUntil).toISOString()}\n  Health: ${r.health}`),
     "\n## Metrics", ...Object.entries(report.metrics).map(([key, value]) => `- ${key}: ${value}`), "",
@@ -139,12 +152,13 @@ export function freezeAcceptance(hordeDir: string, runId: string, startIdeaId =
     if (check.status === "disputed") issues.push(`${check.target}: unresolved challenge or refuting review`);
   }
   const runDir = path.join(hordeDir, "runs", runId);
-  const snapshot = { report, findings, findingReviews, ideas, issues };
+  const snapshot = { report, findings, findingReviews, ideas, issues, limits: report.limits };
   const hash = hashText(JSON.stringify(snapshot));
   const status = issues.length ? "incomplete" : "reviewed";
   writeFileAtomic(path.join(runDir, "COLLABORATION.md"), collaborationMarkdown(report));
   writeFileAtomic(path.join(runDir, "ACCEPTANCE.json"), JSON.stringify({ ...snapshot, hash, status }, null, 2));
-  writeFileAtomic(path.join(runDir, "ACCEPTANCE.md"), `# Acceptance ${runId}\n\nStatus: ${status}\nSnapshot: ${hash}\nEvent sequence: ${report.sequence}\n\n${issues.map((i) => `- ${i}`).join("\n")}\n`);
+  const limitsSection = report.limits.length ? `\n\n## Accepted with limits\n\n${report.limits.map((l) => `- ${l}`).join("\n")}` : "";
+  writeFileAtomic(path.join(runDir, "ACCEPTANCE.md"), `# Acceptance ${runId}\n\nStatus: ${status}\nSnapshot: ${hash}\nEvent sequence: ${report.sequence}\n\n${issues.map((i) => `- ${i}`).join("\n")}${limitsSection}\n`);
   const dir = path.join(runDir, "snapshot");
   fs.mkdirSync(dir, { recursive: true });
   for (const name of ["BOARD", "FINDINGS", "IDEAS", "FACTS", "CLAIMS", "RESOURCES", "CONCERNS"]) {