agent-horde 0.1.5 → 0.1.6

package/README.md

@@ -88,7 +88,7 @@ pi install npm:agent-horde
 Or from the repository, pinned to a tag:
 
 ```
-pi install git:github.com/eliyastein/agent-horde@v0.1.5
+pi install git:github.com/eliyastein/agent-horde@v0.1.6
 ```
 
 To hack on it, clone and install in place. pi loads the files from the clone, so edits take effect
@@ -122,13 +122,23 @@ When you already know how the work splits, use `plan` to fix the partition at la
 Each layer becomes a seeded idea owned by one member, recorded in the run's `PLAN.md`, and that
 member works only its layer. Layers are assigned round-robin, so more layers than members gives
 some members two. Members without a layer become verifiers, and an unpartitioned run of three or
-more members makes its last member the verifier. `plan` suits "analyse each X" tasks; split design
-work by output type, such as spec, prototype, and generator, rather than by theme.
+more members makes its last member the verifier (`--no-verifier` turns that off). `plan` suits
+"analyse each X" tasks; split design work by output type, such as spec, prototype, and generator,
+rather than by theme.
+
+A run normally winds down once a validated answer exists and every idea is closed. `--until-stop`
+keeps the whole horde working until you stop it: a validated answer is banked as the current one
+and the proposal slot reopens, and a member whose session finishes gets a fresh session told to
+extend, stress-test, or deepen the work.
+
+```
+/agent-horde --dashboard --until-stop 8 find every way an unauthenticated request reaches the database
+```
 
 | command | effect |
 |---|---|
 | `/agent-horde status` | the active run and each member |
-| `/agent-horde stop-clean [postmortem]` | members wrap up, then the run finalizes |
+| `/agent-horde stop-clean [postmortem]` | members wrap up, then the run finalizes; this is how an `--until-stop` run ends |
 | `/agent-horde stop-hard` | terminate members now |
 | `/agent-horde pause`, `resume` | suspend and resume member processes |
 | `/agent-horde help` | every flag and target |
@@ -172,11 +182,13 @@ die, runs the repair phase, freezes acceptance, and writes the report.
 - Ideas, findings, facts, and resources are deduplicated on identifiers first, then wording; a
   duplicate returns the existing id and records a corroborator.
 - Every finding names a concern slug; a look-alike of an existing slug is refused.
-- A review records the revision it checked, its scope, a verdict, and evidence. Runnable
-  artifacts need a tested or reproduced review from a non-owner; documents need a sourced or
-  derived one.
+- A review records the revision it checked, its scope, a verdict, evidence, and any limits
+  outside the target's criteria. Runnable artifacts need a tested or reproduced review from a
+  non-owner; documents need a sourced or derived one. A reviewer can carry its review forward to
+  an unchanged revision instead of redoing it.
 - Solved is two-phase: one member proposes, a different member validates, and the run winds down
-  only when every idea it created is closed.
+  only when every idea it created is closed. Under `--until-stop` the answer is banked instead
+  and the horde keeps going until `stop-clean` or `stop-hard`.
 - Peer messages, reviews, and evidence enter a member's context as data. They cannot authorize
   tools or override the task.
 
@@ -194,6 +206,7 @@ linked to the page that shows it, so a run reads left to right: who claimed what
 landed under which ideas, who reviewed whom, and where actions were rejected. It is server-rendered
 SVG/HTML with no scripts. The download icon on every page exports the whole dashboard as a zip of
 static pages that opens from disk, after a warning that it may carry sensitive data from the machine.
+Every page's footer names the agent-horde version and, from a checkout, the commit it runs at.
 
 ## Benchmark: FinanceBench
 

package/docs/REFERENCE.md

@@ -7,7 +7,7 @@ at one problem beat a single linear one: research, audits, design exploration, R
 ## Usage
 
 ```
-/agent-horde [--dashboard[=<port>]] [--no-verifier] <count> <prompt>
+/agent-horde [--dashboard[=<port>]] [--no-verifier] [--until-stop] <count> <prompt>
 /agent-horde plan [--dashboard] <count> <layer; layer; ...>
 /agent-horde status [target]
 /agent-horde stop-hard [target]                      SIGTERM, SIGKILL after 5s (alias: stop)
@@ -72,7 +72,9 @@ own when the parent is gone, even after a SIGKILL or OOM kill.
 HEAD, never writes to `.horde/`, and stays up after the run until the session ends. A busy port
 refuses the run before any run directory is created. Live pages reload every three seconds
 (`?refresh=0` disables); expandable entries are URL-backed, so they stay open across refreshes.
-Every page has a JSON twin under `/api/<same path>`.
+Every page has a JSON twin under `/api/<same path>`. The footer of every page names the
+agent-horde version from its package.json and, when it runs from a git checkout, the commit it is
+at (`-dirty` when the tree has uncommitted changes), linked to the commit on GitHub.
 
 | page | shows |
 |------|-------|
@@ -154,17 +156,19 @@ from the same actor as an idempotent retry. The parent appends its own lifecycle
 | `list`, `findings`, `facts`, `claims`, `resources`, `concerns` | print a ledger |
 | `post` | append a message to BOARD.md |
 | `idea` | add an open checklist item; a near-duplicate returns the existing id |
-| `claim`, `done`, `drop`, `rule-out` | take, finish, release, or close idea #id |
+| `claim`, `done`, `drop`, `rule-out` | take, finish, release, or close idea #id; `done` with a confirmed-negative result line is refused in favour of `rule-out` |
 | `finding` | file under a claimed `idea` with a `concern` and `support`; `importance` and `confidence` are optional; `deltaOf: F#` adds distinct evidence, `supersedes: F#` corrects |
 | `verify` | record your own reproduction of F#id with the support level you reached |
-| `fact` | record a checkable fact; `deltaOf: T#` extends one |
+| `amend` | rewrite the body prose of your own F#id (`text`) with a `note` saying why; the revision changes, reviews stay pinned to what they checked, earlier verification notes are kept as history of the previous revision, and the legacy `verified=` label and corroborators are dropped |
+| `fact` | record a checkable fact; `deltaOf: T#` extends one; a fact about what an open idea or contested claim is still auditing is recorded as provisional on it |
 | `assert`, `confirm`, `contest`, `retract`, `supersede` | create or move claim C#id |
 | `resource` | claim a shared dataset, harness, corpus, or sandbox by name, with an optional `cleanup` command |
 | `solved`, `confirm-solved`, `contest-solved` | propose, validate, or refute the goal answer |
 | `message`, `inbox`, `ack`, `respond`, `resolve`, `defer` | targeted threads: question, blocker, review-request, challenge, handoff, decision |
 | `attach` | add supporting, contradicting, or extending evidence to a target |
-| `review` | record a revision-pinned check with explicit `checked` and `unchecked` scope, a verdict, and evidence refs; `evidenceText` attaches and reviews in one call |
-| `artifact` | publish a file under `artifacts/` with `artifactKind`, `criteria`, and revision-pinned `dependsOn` |
+| `review` | record a revision-pinned check with explicit `checked` and `unchecked` (in-criteria gaps) scope, `limits` outside the criteria, a verdict, and evidence refs; `evidenceText` attaches and reviews in one call |
+| `reattest` | carry your earlier review of F#/A# forward to its current revision, with evidence that what you checked is unchanged; refused across a changed artifact criteria or kind, a changed finding claim line, or a revision no `amend` started from |
+| `artifact` | publish a file under `artifacts/` with `artifactKind`, `criteria`, and revision-pinned `dependsOn`; republishing a revision other artifacts pin needs `text` naming the change |
 | `resource-state` | publish building, ready, broken, or retired state with a lease, ports, and health evidence |
 | `inspect`, `collaboration` | one record in full (`F#`, `I#`, `R#`, `A#`, `E#`, `V#`, `Q#`, `answer`), or a paged index |
 
@@ -191,18 +195,40 @@ from the same actor as an idempotent retry. The parent appends its own lifecycle
   validated and every idea this run created or its members hold is done or ruled out. With no
   other member running, or no validation within `PI_HORDE_SOLVED_CONFIRM_MS`, an uncontested
   proposal commits as `solved-unvalidated`. Findings no other member reproduced hold wind-down
-  while other members run, unless `PI_HORDE_ALLOW_UNVERIFIED=1`.
+  while other members run, unless `PI_HORDE_ALLOW_UNVERIFIED=1`. A proposal pins the revision of
+  every finding it cites. An answer that cites a superseded F# or quotes a provisional T# is
+  refused at `solved` and at `confirm-solved`; a pending proposal whose cited finding is
+  superseded or amended later is withdrawn (`solved-withdrawn`) for re-proposal. A contest that names idea ids reopens the proposal under a new revision
+  (`solved-reopened`) once every named idea is done or ruled out, with the citations it pinned;
+  if a cited finding changed or a quoted fact is still provisional by then, it is withdrawn instead. Repair serves a request about
+  the pending answer (`target=answer`) with the blockers.
 - **Reviews are revision-pinned.** A runnable artifact needs a full-scope `tested` or
   `reproduced` review from a non-owner. A `document` artifact (.md, .txt, .rst, .adoc, .pdf)
-  accepts a full-scope `sourced` or `derived` review against its criteria. Changing criteria or
-  dependencies needs changed bytes and a fresh review. Open blockers and challenges block
-  acceptance; `defer` keeps the debt visible, the recipient can still `respond` to a deferred
-  request, and the requester then resolves it. A challenger can withdraw its own blocking
-  challenge on an F# or A# before any response by recording a supporting review of the current
-  revision and resolving with evidence on it; limits that review discloses remain acceptance debt.
-  The blocking challenge a `partially-supports` review raises is cleared when a different
-  non-owner member records a full-scope `supports` review of the same revision; the resolution
-  names both reviews. Acceptance names an open blocker as `blocked by Q#`.
+  accepts a full-scope `sourced` or `derived` review against its criteria. `unchecked` names gaps
+  inside the target's stated claim or criteria and keeps acceptance open; `limits` names
+  disclosures outside the criteria and is recorded on the acceptance (`Accepted with limits` in
+  ACCEPTANCE.md and COLLABORATION.md), never as a blocker. A `partially-supports` verdict refutes
+  nothing and opens no challenge: the acceptance names the review and what it left unchecked, and
+  another member's full-scope review settles it. Only `refutes` opens a challenge. Changing
+  criteria or dependencies needs changed bytes and a fresh review; republishing a revision that
+  other artifacts pin needs `text` naming the change, and the owner of each dependent is handed a
+  repin request when a pinned dependency is superseded or re-hashed. `reattest` carries a
+  reviewer's earlier review forward to the current revision with evidence that the checked
+  behaviour is unchanged; the parent prefers prior reviewers when assigning a re-review. Open
+  blockers and challenges block acceptance; `defer` keeps the debt visible, the recipient can
+  still `respond` to a deferred request, and the requester then resolves it. A challenger can
+  withdraw its own blocking challenge on an F# or A# before any response by recording a
+  supporting review of the current revision and resolving with evidence on it; limits that
+  review discloses remain acceptance debt. Acceptance names an open blocker as `blocked by Q#`.
+- **Verifier.** The verifier's idea claims are refused while other members' findings await its
+  review at their current revision; the pending F# list follows every review, reattest and board
+  post. A verifier whose session closes with critical or high-importance findings unreviewed is
+  reset once more into a fresh session that owes them, within `PI_HORDE_RESET_CAP`. SUMMARY.md
+  derives its coverage sentence from the review records and names the unreviewed F#.
+- **Reproductions.** A finding with an independent corroborator or a full-scope review is
+  settled: a claim whose text overlaps it is told to bring a new vector as `deltaOf`, and a
+  third duplicate report is dropped. A finding that cites a runnable under `artifacts/` no R# or
+  A# covers is told to register it.
 - **Inbox.** Targeted messages are inserted at turn boundaries, for at most
   `PI_HORDE_INBOX_TURNS` extra turns per session. A recipient answers with `respond`; `ack` is an
   optional first step that signals intent. Delivery is a context insertion, not
@@ -226,6 +252,17 @@ highest-importance unchecked assertions first with `horde review`, contest or su
 not reproduce, and claim ideas only when nothing is left to review. `--no-verifier` turns this
 off.
 
+`--until-stop` keeps the whole horde working until you stop it. A validated solve does not wind
+the run down: the answer is banked in ANSWER.md (and under `answers/`) as round N and the proposal
+slot reopens, so a materially better answer can be proposed later. A member whose session finishes
+is given a fresh session that reads the board, findings, and answer and adds ideas that extend,
+stress-test, or deepen the work; these continuations count against no reset cap and are not
+resets in the report. A session that finished within `PI_HORDE_CONTINUE_COOLDOWN_MS` (default
+60000) of starting waits out the remainder first, so a member that finds nothing to do cannot spin.
+Crash and stall resets apply as usual. `stop-clean` and `stop-hard` end the run as usual and
+`stop-clean` produces the report, deliverable, and postmortem; the last banked answer stands unless
+a later proposal was validated too.
+
 ## Finding metadata
 
 `importance` (critical, high, medium, low, info), `confidence` (high, medium, low), and
@@ -253,6 +290,7 @@ carries a one-line diagnosis and, when generated, the post-mortem text.
 | variable | default | effect |
 |----------|---------|--------|
 | `PI_HORDE_DASHBOARD_PORT` | 7433 | dashboard port when `--dashboard` names none |
+| `PI_HORDE_CONTINUE_COOLDOWN_MS` | 60000 | `--until-stop`: a finished session younger than this waits out the remainder before its fresh session starts |
 | `PI_HORDE_MAX_MINUTES` | off | clean stop at a wall-clock deadline |
 | `PI_HORDE_CANARY_MS` | 60000 | time for member-1 to produce output before a retry |
 | `PI_HORDE_STALL_MS` | 1800000 | reset a member with no ledger write for this long; `0` disables |
@@ -295,6 +333,7 @@ watchdog.ts           child exits when its parent pid is gone
 widget.ts             TUI widget above the editor
 citations.ts          R#/F#/T# and file-path citation checks for findings and generated artifacts
 dashboard.ts          localhost HTTP server; dashboard-data.ts loads pages, dashboard-html.ts renders
+build-info.ts         the running package's version and checkout commit, for the dashboard footer
 collaboration-report.ts  acceptance checks, frozen snapshots, collaboration metrics
 run-graph.ts          events.jsonl projected into lanes, phases, nodes, and edges with dashboard links
 run-graph-svg.ts      the swimlane SVG and its legend; run-graph-mermaid.ts the Mermaid export and GRAPH.md

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-horde",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Run a horde of pi agents on one task: shared ledgers, peer review, an auditable event log, and a live dashboard",
   "license": "MIT",
   "type": "module",

package/src/args.ts

@@ -1,7 +1,7 @@
 export const MAX_MEMBERS = 12;
 
 export const USAGE = [
-  "usage: /agent-horde [--dashboard[=<port>]] [--no-verifier] <count> <prompt>",
+  "usage: /agent-horde [--dashboard[=<port>]] [--no-verifier] [--until-stop] <count> <prompt>",
   "                                          spawn <count> members with the same prompt",
   "       /agent-horde status [target]       show the active run",
   "       /agent-horde stop-hard [target]    terminate members now (SIGTERM, then SIGKILL)",
@@ -20,6 +20,9 @@ export const USAGE = [
   "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. */
@@ -49,6 +52,8 @@ type HordeArgs =
       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" }>;
@@ -102,6 +107,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 +115,7 @@ interface LaunchFlags {
   rest: string;
   dashboard?: DashboardOption | undefined;
   noVerifier?: boolean | undefined;
+  untilStop?: boolean | undefined;
   error?: string | undefined;
 }
 
@@ -120,7 +127,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 +145,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,6 +161,7 @@ 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,
   };
 }
@@ -173,6 +187,7 @@ function runArgs(count: number, prompt: string, flags: LaunchFlags, plan?: strin
   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;
 }
 
@@ -180,7 +195,7 @@ 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" };
   }

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"]) {

package/src/dashboard-html.ts

@@ -24,6 +24,7 @@ import type {
   TranscriptVm,
 } from "./dashboard-data.js";
 import { RUN_FILES } from "./dashboard-data.js";
+import { buildInfo } from "./build-info.js";
 import { detailKey, formatClock, formatElapsed, formatTokens, oneLine } from "./format.js";
 import { renderRunGraphMermaid } from "./run-graph-mermaid.js";
 import { GRAPH_CSS, graphLegendHtml, renderRunGraphSvg } from "./run-graph-svg.js";
@@ -54,7 +55,7 @@ const CSS =
   "th,td{border:1px solid #000;padding:2px 6px;vertical-align:top;text-align:left}" +
   "th{background:#eee}pre{white-space:pre-wrap;word-break:break-word;margin:0}" +
   "nav a{margin-right:8px}.r{text-align:right}h1,h2{font-size:13px;margin:8px 0 4px}" +
-  "details>summary{cursor:pointer}a{color:#000}" +
+  "details>summary{cursor:pointer}a{color:#000}footer{margin-top:16px;color:#666}footer a{color:#666}" +
   ".export{position:absolute;top:8px;right:8px;line-height:0}" +
   ".modal{display:none;position:fixed;inset:0;background:rgba(0,0,0,.7)}" +
   ".modal:target{display:flex;align-items:center;justify-content:center}" +
@@ -161,7 +162,7 @@ export function renderCollaboration(vm: CollaborationVm, ctx: RenderContext): st
     anchor(m.id), e(`${m.sender} -> ${m.to}`), e(`${m.state}${m.blocking ? " BLOCKING" : ""} / ${formatElapsed(Date.now() - Date.parse(m.createdAt))}`),
     e(`${m.target}@${m.revision}`), pre(messageThread(m)),
   ]));
-  const reviews = table(["review", "target revision", "verdict", "scope / evidence"], state.reviews.map((r) => [`${anchor(r.id)} @${e(r.actor)}`, e(`${r.target}@${r.revision}`), e(`${r.verdict} [${r.support}]`), pre(`Checked: ${r.checked}\nUnchecked: ${r.unchecked || "none declared"}\nEvidence: ${r.evidence.join(", ")}\n${r.text}`)]));
+  const reviews = table(["review", "target revision", "verdict", "scope / evidence"], state.reviews.map((r) => [`${anchor(r.id)} @${e(r.actor)}`, e(`${r.target}@${r.revision}`), e(`${r.verdict} [${r.support}]`), pre(`Checked: ${r.checked}\nUnchecked: ${r.unchecked || "none declared"}\nLimits: ${r.limits || "none disclosed"}\nEvidence: ${r.evidence.join(", ")}${r.reattests ? `\nReattests: ${r.reattests}` : ""}\n${r.text}`)]));
   const artifacts = table(["artifact", "hash / dependencies", "acceptance"], state.artifacts.map((a) => [`${anchor(a.id)} ${e(`${a.path} @${a.owner} (${a.kind ?? "runnable"})`)}`, pre(`${a.hash}\n${JSON.stringify(a.dependencies)}`), e(report.acceptedArtifacts.includes(a.id) ? "accepted" : "excluded / needs review")]));
   const events = vm.events.map((event) => `<div id="${e(event.eventId)}">${details(`${event.eventId} ${event.at} ${event.actor}/${event.attempt} ${event.action} ${event.outcome}`, pre(JSON.stringify(event, null, 2)), `event:${report.runId}:${event.eventId}`)}</div>`).join("");
   return page(`Collaboration ${report.runId}`, [{ text: "runs", href: "/" }, { text: report.runId, href: runHref(report.runId) }, { text: "collaboration" }],
@@ -230,13 +231,20 @@ function nativeDetails(body: string): string {
   return body.replace(/<details data-expand="[a-f0-9]+">/g, "<details>");
 }
 
+/** Which agent-horde produced the page: the package version and, from a checkout, the commit. */
+function footer(): string {
+  const { name, version, commit, repository } = buildInfo();
+  const at = commit ? ` at ${repository ? link(`${repository}/commit/${commit.replace(/-dirty$/, "")}`, commit) : e(commit)}` : "";
+  return `<footer>${e(name)} ${e(version)}${at}</footer>`;
+}
+
 export function page(title: string, crumbs: Crumb[], body: string, ctx: RenderContext, head = ""): string {
   body = ctx.export ? nativeDetails(body) : persistentDetails(body, ctx.href);
   const meta = ctx.refresh?.on ? `<meta http-equiv="refresh" content="${ctx.refresh.seconds}">` : head;
   return (
     `<!doctype html><html><head><meta charset="utf-8"><title>${e(title)}</title>${meta}` +
     `<style>${CSS}</style></head><body>${exportControl(ctx)}${nav(ctx)}${crumbLine(crumbs)}${refreshLine(ctx)}` +
-    `<h1>${e(title)}</h1>${body}</body></html>`
+    `<h1>${e(title)}</h1>${body}${footer()}</body></html>`
   );
 }
 

package/src/ledger/collaboration.ts

@@ -46,6 +46,8 @@ export interface ArtifactRecord {
   snapshot: string;
   criteria: string;
   dependencies: Array<{ target: string; revision: string }>;
+  /** The owner's statement of what a republish changed, required once other artifacts pin it. */
+  changeNote?: string;
   /** Projected from the publishing event; absent in hand-built records. */
   publishedAt?: string;
 }
@@ -57,9 +59,14 @@ export interface ReviewRecord {
   verdict: "supports" | "partially-supports" | "refutes" | "inconclusive";
   support: string;
   checked: string;
+  /** Gaps inside the target's stated claim or criteria; non-empty keeps acceptance open. */
   unchecked: string;
+  /** Disclosures outside the criteria; recorded on the acceptance as limits, never blockers. */
+  limits?: string;
   text: string;
   evidence: string[];
+  /** The reviewer's earlier review of a previous revision that this one carries forward. */
+  reattests?: string;
 }
 export interface ResourceContract {
   target: string;
@@ -153,12 +160,35 @@ export function blockingMessages(state: CollaborationState): PeerMessage[] {
   return state.messages.filter((m) => m.blocking && m.state !== "resolved");
 }
 
-export function artifactAccepted(state: CollaborationState, artifact: ArtifactRecord): boolean {
-  if (blockingMessages(state).some((m) => m.target === artifact.id)) return false;
-  const reviews = state.reviews.filter((r) => r.target === artifact.id && r.revision === artifact.hash);
+/** Each non-owner's latest review of the artifact's current revision. */
+export function latestArtifactReviews(state: CollaborationState, artifact: ArtifactRecord): ReviewRecord[] {
   const latest = new Map<string, ReviewRecord>();
-  for (const review of reviews) latest.set(review.actor, review);
-  if ([...latest.values()].some((r) => r.verdict === "refutes")) return false;
+  for (const review of state.reviews) {
+    if (review.target === artifact.id && review.revision === artifact.hash && review.actor !== artifact.owner) latest.set(review.actor, review);
+  }
+  return [...latest.values()];
+}
+
+function acceptingReview(artifact: ArtifactRecord, review: ReviewRecord): boolean {
   const methods = artifact.kind === "document" ? ["sourced", "derived", "tested", "reproduced"] : ["tested", "reproduced"];
-  return [...latest.values()].some((r) => r.actor !== artifact.owner && r.verdict === "supports" && !r.unchecked && methods.includes(r.support));
+  return review.verdict === "supports" && !review.unchecked && methods.includes(review.support);
+}
+
+export function artifactAccepted(state: CollaborationState, artifact: ArtifactRecord): boolean {
+  if (blockingMessages(state).some((m) => m.target === artifact.id)) return false;
+  const latest = latestArtifactReviews(state, artifact);
+  if (latest.some((r) => r.verdict === "refutes")) return false;
+  return latest.some((r) => acceptingReview(artifact, r));
+}
+
+/** Limits the accepting reviews disclosed outside the criteria, each named with its review. */
+export function artifactLimits(state: CollaborationState, artifact: ArtifactRecord): string[] {
+  return latestArtifactReviews(state, artifact)
+    .filter((r) => acceptingReview(artifact, r) && r.limits?.trim())
+    .map((r) => `${r.id} (${r.actor}): ${r.limits?.trim()}`);
+}
+
+/** Reviews of the current revision that left in-criteria scope unchecked: coverage debt, named. */
+export function partialArtifactReviews(state: CollaborationState, artifact: ArtifactRecord): ReviewRecord[] {
+  return latestArtifactReviews(state, artifact).filter((r) => r.verdict !== "refutes" && r.unchecked.trim());
 }