agent-horde 0.1.5 → 0.2.0

package/src/run-graph.ts

@@ -117,14 +117,14 @@ export function entityHref(runId: string, id: string): string | undefined {
   if (!match) return undefined;
   const letter = match[1] ?? "";
   const number = match[2] ?? "";
-  const run = encodeURIComponent(runId);
+  const base = `/runs/${encodeURIComponent(runId)}`;
   switch (letter) {
-    case "I": return `/ideas#idea-${number}`;
-    case "F": return `/findings?run=${run}#F${number}`;
-    case "T": return `/facts?run=${run}#T${number}`;
-    case "C": return `/claims#C${number}`;
-    case "R": return `/resources#R${number}`;
-    case "A": case "V": case "Q": return `/runs/${run}/collaboration#${id}`;
+    case "I": return `${base}/ideas#idea-${number}`;
+    case "F": return `${base}/findings#F${number}`;
+    case "T": return `${base}/facts#T${number}`;
+    case "C": return `${base}/claims#C${number}`;
+    case "R": return `${base}/resources#R${number}`;
+    case "A": case "V": case "Q": return `${base}/collaboration#${id}`;
     case "E": return eventHref(runId, Number(number));
     default: return undefined;
   }
@@ -360,10 +360,13 @@ function addReview(draft: Draft, event: HordeEvent, review: Payload): void {
   if (!id) return;
   const verdict = str(review.verdict) ?? "review";
   const support = str(review.support) ?? "";
-  const scope = `checked: ${str(review.checked) ?? ""}; unchecked: ${str(review.unchecked) || "none declared"}`;
+  const limits = str(review.limits) ? `; limits: ${str(review.limits)}` : "";
+  const scope = `checked: ${str(review.checked) ?? ""}; unchecked: ${str(review.unchecked) || "none declared"}${limits}`;
   const title = oneLine(`[${support}] ${scope}. ${str(review.text) ?? ""}`, TITLE_MAX);
   if (!addEntity(draft, event, { id, kind: "review", label: `${id} ${verdict}`, title })) return;
   addEdge(draft, id, str(review.target), verdict, relationTone(verdict));
+  const reattests = str(review.reattests);
+  if (reattests && draft.nodes.has(reattests)) draft.edges.push({ from: reattests, to: id, label: "reattested", tone: "collaboration" });
   for (const ref of strings(review.evidence)) {
     if (draft.nodes.has(ref)) draft.edges.push({ from: ref, to: id, label: "cited", tone: "collaboration" });
   }
@@ -427,7 +430,7 @@ const COLLABORATION: Record<string, Handler> = {
 function lifecycleText(action: string, p: Payload): [string, string] {
   const members = strings(p.members).join(", ");
   switch (action) {
-    case "run-start": return ["run start", `${num(p.count) ?? "?"} members${str(p.model) ? `, model ${str(p.model)}` : ""}`];
+    case "run-start": return ["run start", `${num(p.count) ?? "?"} members${str(p.model) ? `, model ${str(p.model)}` : ""}${p.untilStop === true ? ", until stop" : ""}`];
     case "run-end": return ["run end", `outcome ${str(p.outcome) ?? "unknown"}`];
     case "member-spawn": return ["spawn", str(p.role) ? `role: ${oneLine(str(p.role) ?? "", 120)}` : "spawned"];
     case "member-exit": return [`exit ${str(p.endCause) ?? ""}`.trim(), `status ${str(p.status) ?? "?"}, ${num(p.turns) ?? 0} turns, ${num(p.tokens) ?? 0} tokens`];
@@ -436,7 +439,11 @@ function lifecycleText(action: string, p: Payload): [string, string] {
     case "stop-hard": return [`stop-hard (${str(p.by) ?? "user"})`, members || "all members"];
     case "solved-proposed": return ["solved proposed", `${str(p.member) ?? ""}: ${oneLine(str(p.text) ?? "", 120)}`];
     case "solved-contested": return ["solved contested", `by ${str(p.member) ?? ""}`];
+    case "solved-withdrawn": return ["solved withdrawn", oneLine(str(p.reason) ?? "", 120)];
+    case "solved-reopened": return ["solved reopened", oneLine(str(p.reason) ?? "", 120)];
     case "solved-validated": return ["solved validated", str(p.validator) ? `by ${str(p.validator)}` : "without a separate validator"];
+    case "solved-banked": return [`solved banked (round ${num(p.round) ?? "?"})`, str(p.validator) ? `by ${str(p.validator)}` : "without a separate validator"];
+    case "member-continue": return ["continue", `fresh session ${num(p.continuations) ?? "?"}; released ${strings(p.released).length}, closed ${strings(p.closed).length}`];
     case "acceptance": return [`acceptance ${str(p.status) ?? ""}`.trim(), `${num(p.issues) ?? 0} issues, snapshot ${(str(p.hash) ?? "").slice(0, 12)}`];
     case "repair-start": return ["repair start", `queue ${strings(p.messages).join(", ")}`];
     case "repair-end": return ["repair end", `${str(p.cause) ?? ""}${str(p.stopReason) ? ` (${str(p.stopReason)})` : ""}`];

package/src/swarm-graph.ts

@@ -0,0 +1,127 @@
+import { oneLine } from "./format.js";
+import type { HordeEvent } from "./ledger/events.js";
+import { LIFECYCLE_ATTEMPT, eventHref } from "./run-graph.js";
+import type { GraphEdge, GraphLane, GraphNode, RunGraph } from "./run-graph.js";
+
+/** One horde's events and where its run page is. */
+export interface SwarmGraphHorde {
+  label: string;
+  runId: string;
+  events: HordeEvent[];
+  status?: string | undefined;
+}
+
+export interface SwarmGraphInput {
+  swarmId: string;
+  startedAt: number;
+  hordes: SwarmGraphHorde[];
+  /** The swarm's merge step, once it started. */
+  merge?: { startedAt: number; endedAt?: number | undefined; written?: boolean | undefined } | undefined;
+  /** Graph end for a live swarm (epoch ms); a finished swarm ends at its last event. */
+  now?: number | undefined;
+}
+
+const SWARM_LANE = "swarm";
+
+/** The parent lifecycle actions that mark a horde's progress; member-level churn stays on the run graph. */
+const PHASE_ACTIONS = new Set([
+  "run-start", "phase-start", "phase-end", "stop-clean", "stop-hard", "solved-validated", "solved-banked",
+  "solved-contested", "acceptance", "run-end",
+]);
+
+function str(value: unknown): string | undefined {
+  return typeof value === "string" ? value : undefined;
+}
+
+function labelOf(event: HordeEvent): [string, string] {
+  const p = event.payload;
+  switch (event.action) {
+    case "run-start": return ["start", `${String(p.count ?? "?")} members${str(p.slice) ? `; workstream: ${oneLine(str(p.slice) ?? "", 160)}` : ""}`];
+    case "phase-start": return [`${str(p.phase) ?? "phase"} start`, `${str(p.phase) ?? "phase"} started`];
+    case "phase-end": return [`${str(p.phase) ?? "phase"} end`, `${str(p.phase) ?? "phase"} ended`];
+    case "stop-clean": return [`stop-clean (${str(p.label) ?? "stop-clean"})`, "clean stop requested"];
+    case "stop-hard": return [`stop-hard (${str(p.by) ?? "user"})`, "members terminated"];
+    case "solved-validated": return ["solved validated", str(p.validator) ? `by ${str(p.validator)}` : "without a separate validator"];
+    case "solved-banked": return [`solved banked (round ${String(p.round ?? "?")})`, "the run continues until stopped"];
+    case "solved-contested": return ["solved contested", `by ${str(p.member) ?? ""}`];
+    case "acceptance": return [`acceptance ${str(p.status) ?? ""}`.trim(), `${String(p.issues ?? 0)} issues`];
+    case "run-end": return ["end", `outcome ${str(p.outcome) ?? "unknown"}`];
+    default: return [event.action, ""];
+  }
+}
+
+function hordeNodes(horde: SwarmGraphHorde): GraphNode[] {
+  return horde.events
+    .filter((event) => event.attempt === LIFECYCLE_ATTEMPT && event.outcome === "applied" && PHASE_ACTIONS.has(event.action))
+    .map((event) => {
+      const [label, title] = labelOf(event);
+      const at = Date.parse(event.at);
+      return {
+        id: `${horde.label}:${event.eventId}`,
+        kind: "lifecycle" as const,
+        action: event.action,
+        label,
+        title: `${horde.label} ${event.eventId} ${title}`.trim(),
+        lane: horde.label,
+        at: Number.isFinite(at) ? at : 0,
+        eventId: event.eventId,
+        href: eventHref(horde.runId, event.seq),
+        outcome: "applied" as const,
+        marker: true,
+        placeholder: false,
+      };
+    })
+    .filter((node) => node.at > 0);
+}
+
+function mergeNodes(input: SwarmGraphInput): GraphNode[] {
+  const merge = input.merge;
+  if (!merge) return [];
+  const node = (id: string, label: string, title: string, at: number): GraphNode => ({
+    id, kind: "lifecycle", action: id, label, title, lane: SWARM_LANE, at, eventId: "",
+    href: `/swarms/${encodeURIComponent(input.swarmId)}`, outcome: "applied", marker: true, placeholder: false,
+  });
+  const nodes = [node("merge-start", "merge start", "merging the hordes' deliverables", merge.startedAt)];
+  if (merge.endedAt !== undefined) {
+    nodes.push(node("merge-end", `merge end${merge.written === false ? " (no deliverable)" : ""}`,
+      merge.written === false ? "the swarm deliverable was not written" : "DELIVERABLE.md written", merge.endedAt));
+  }
+  return nodes;
+}
+
+/** One lane per horde plus the swarm lane, so the hordes' phases line up against the merge step. */
+export function buildSwarmGraph(input: SwarmGraphInput): RunGraph {
+  const perHorde = input.hordes.map((horde) => hordeNodes(horde));
+  const nodes = [...perHorde.flat(), ...mergeNodes(input)].sort((a, b) => a.at - b.at);
+  const edges: GraphEdge[] = [];
+  if (input.merge) {
+    for (const horde of perHorde) {
+      const end = horde.find((node) => node.action === "run-end");
+      if (end) edges.push({ from: end.id, to: "merge-start", label: "merged", tone: "lifecycle" });
+    }
+  }
+  const lanes: GraphLane[] = [
+    { id: SWARM_LANE, label: SWARM_LANE },
+    ...input.hordes.map((horde) => ({
+      id: horde.label,
+      label: `${horde.label} ${horde.runId}`,
+      href: `/runs/${encodeURIComponent(horde.runId)}`,
+      status: horde.status,
+    })),
+  ];
+  const start = input.startedAt;
+  const latest = Math.max(input.now ?? 0, input.merge?.endedAt ?? 0, ...nodes.map((node) => node.at));
+  const end = latest > start ? latest : start + 1_000;
+  const hordeTimes = perHorde.flat().map((node) => node.at);
+  const live = input.now !== undefined && !input.hordes.every((horde) => horde.events.some((event) => event.action === "run-end"));
+  return {
+    runId: input.swarmId,
+    start,
+    end,
+    membersEnd: live || hordeTimes.length === 0 ? end : Math.min(end, Math.max(start, ...hordeTimes)),
+    lanes,
+    phases: [],
+    nodes,
+    edges,
+  };
+}

package/src/tool/actions.ts

@@ -2,13 +2,19 @@ import { postBoard } from "../ledger/board.js";
 import { assertClaim, confirmClaim, contestClaim, listClaims, retractClaim, supersedeClaim } from "../ledger/claims.js";
 import type { ClaimEntry } from "../ledger/claims.js";
 import { listConcerns } from "../ledger/concerns.js";
-import { addFact, listFacts } from "../ledger/facts.js";
-import { addFinding, findingSummaries, verifyFinding } from "../ledger/findings.js";
+import { addFact, factUnsettled, listFacts, unsettledFactCitations } from "../ledger/facts.js";
+import type { FactEntry } from "../ledger/facts.js";
+import * as path from "node:path";
+import { CLUSTER_THRESHOLD } from "../ledger/clusters.js";
+import { collaborationState } from "../ledger/collaboration.js";
+import { addFinding, amendFinding, answerCitations, findingReviewState, findingRevision, findingSummaries, listFindingsForRun, pendingReviewsForMember, staleAnswerCitations, verifyFinding } from "../ledger/findings.js";
+import { textOverlap } from "../ledger/text-match.js";
 import { addIdea, claimIdea, dropIdea, finishIdea, listIdeas, ruleOutIdea } from "../ledger/ideas.js";
 import type { Idea } from "../ledger/ideas.js";
 import { claimResource, listResources } from "../ledger/resources.js";
-import { cleanStopRequestedFor, confirmSolved, contestSolved, markSolved } from "../ledger/run-signals.js";
+import { cleanStopRequestedFor, confirmSolved, contestSolved, markSolved, readSolved } from "../ledger/run-signals.js";
 import { oneLine } from "../format.js";
+import type { SiblingHorde } from "../member.js";
 import { validateFindingResourceCitations } from "../citations.js";
 import { idleHint } from "./hints.js";
 import type { HordeToolParams } from "./params.js";
@@ -34,6 +40,10 @@ interface ActionResult {
   noop?: boolean;
   /** For confirm-solved: whether this confirmation validated the proposal or joined an earlier one. */
   confirmation?: "credited" | "additional";
+  /** For amend: the revisions the edit moved between, and whether the claim line changed; reattest reads them. */
+  previousRevision?: string;
+  revision?: string;
+  titleChanged?: boolean;
 }
 
 interface ActionContext {
@@ -43,6 +53,35 @@ interface ActionContext {
   runId: string | undefined;
   /** True when a clean stop is pending for this member. */
   cleanStop: boolean;
+  /** The member's role instruction, when one was assigned. */
+  role: string | undefined;
+  /** Other hordes of the swarm whose ledgers the read actions include, tagged by label. */
+  siblings: SiblingHorde[];
+}
+
+/**
+ * Shared read, local write: the read actions append each sibling horde's entries, tagged `[hN]`,
+ * so a fact, a rule-out or a resource another horde recorded is not re-derived here. A sibling
+ * whose ledger cannot be read is reported, not fatal.
+ */
+function siblingSections(siblings: SiblingHorde[], what: string, lines: (hordeDir: string) => string[]): string {
+  return siblings
+    .map((sibling) => {
+      const tag = `[${sibling.label}]`;
+      let entries: string[];
+      try {
+        entries = lines(sibling.hordeDir).map((line) => `${tag} ${line}`);
+      } catch (error) {
+        entries = [`${tag} unreadable: ${oneLine(error instanceof Error ? error.message : String(error), 120)}`];
+      }
+      const head = `${tag} ${what} of horde ${sibling.label} (read-only; ${sibling.hordeDir}):`;
+      return `\n\n${head}\n${entries.length > 0 ? entries.join("\n") : `${tag} none`}`;
+    })
+    .join("");
+}
+
+export function isVerifierRole(role: string | undefined): boolean {
+  return /verifier/i.test(role ?? "");
 }
 
 type ActionHandler = (ctx: ActionContext) => ActionResult | Promise<ActionResult>;
@@ -93,18 +132,19 @@ function closedIdea(ctx: ActionContext, idea: Idea, text: string): ActionResult
   return { text: `${text}${hint}`, id: idea.id };
 }
 
-function listAction({ hordeDir }: ActionContext): ActionResult {
+function ideaLine(idea: Idea): string {
+  const owner = idea.owner ? ` @${idea.owner}` : "";
+  const note = idea.note ? `: ${idea.note}` : "";
+  return `#${idea.id} [${idea.mark}]${owner} ${idea.text}${note}`;
+}
+
+function listAction({ hordeDir, siblings }: ActionContext): ActionResult {
   const ideas = listIdeas(hordeDir);
-  if (ideas.length === 0) return { text: "IDEAS.md has no ideas yet" };
-  return {
-    text: ideas
-      .map((idea) => {
-        const owner = idea.owner ? ` @${idea.owner}` : "";
-        const note = idea.note ? `: ${idea.note}` : "";
-        return `#${idea.id} [${idea.mark}]${owner} ${idea.text}${note}`;
-      })
-      .join("\n"),
-  };
+  const own = ideas.length === 0 ? "IDEAS.md has no ideas yet" : ideas.map(ideaLine).join("\n");
+  // Only closed ideas cross hordes: results prevent re-derivation, open ones would invite claims.
+  const shared = siblingSections(siblings, "done and ruled-out ideas", (dir) =>
+    listIdeas(dir).filter((idea) => idea.mark === "x" || idea.mark === "!").map(ideaLine));
+  return { text: `${own}${shared}` };
 }
 
 async function postAction({ hordeDir, member, params }: ActionContext): Promise<ActionResult> {
@@ -177,7 +217,23 @@ async function findingAction(ctx: ActionContext): Promise<ActionResult> {
     };
   }
   const advisory = concernAdvisory ? `\nNote: ${concernAdvisory}` : "";
-  return { text: `Recorded finding F${finding.id} [${concern}]: ${finding.title}${advisory}`, id: finding.id };
+  return { text: `Recorded finding F${finding.id} [${concern}]: ${finding.title}${advisory}${unregisteredHarness(ctx, text)}`, id: finding.id };
+}
+
+const HARNESS_PATH = /\bartifacts\/[\w./-]+\.(?:py|js|mjs|cjs|ts|sh|go|rs|rb|pl)\b/g;
+
+/**
+ * A driver or harness every member rewrote because nobody registered it: a runnable under
+ * artifacts/ that no resource note and no published artifact names is pointed at `resource`.
+ */
+function unregisteredHarness(ctx: ActionContext, text: string): string {
+  const paths = [...new Set(text.match(HARNESS_PATH) ?? [])];
+  if (!paths.length) return "";
+  const known = listResources(ctx.hordeDir).map((resource) => `${resource.name} ${resource.note ?? ""}`).join("\n");
+  const published = ctx.runId ? collaborationState(ctx.hordeDir, ctx.runId).artifacts.map((artifact) => artifact.path) : [];
+  const unregistered = paths.filter((file) => !known.includes(file) && !published.some((artifact) => file.endsWith(artifact)));
+  if (!unregistered.length) return "";
+  return `\nNote: ${unregistered.join(", ")} looks like a harness no R# covers. Claim it with 'horde resource' (name in text, path in note) so other members reuse it instead of writing their own.`;
 }
 
 function concernsAction({ hordeDir }: ActionContext): ActionResult {
@@ -209,6 +265,26 @@ async function verifyAction(ctx: ActionContext): Promise<ActionResult> {
   };
 }
 
+async function amendAction(ctx: ActionContext): Promise<ActionResult> {
+  const { hordeDir, member, params, runId } = ctx;
+  validateFindingResourceCitations(hordeDir, runId, params.text ?? "");
+  const { finding, previous, titleChanged } = await amendFinding(hordeDir, requireRun(ctx), member, {
+    id: requireId(params),
+    text: params.text,
+    note: params.note,
+  });
+  return {
+    text:
+      `Amended F${finding.id}: ${finding.title}. Revision ${previous.slice(0, 12)} is superseded by the new text; ` +
+      "reviews stay pinned to the revision they checked. " +
+      (titleChanged ? "The claim line changed, so reviewers must review again." : "Ask reviewers to reattest if what they checked is unchanged, or to review again."),
+    id: finding.id,
+    previousRevision: previous,
+    revision: findingRevision(finding),
+    titleChanged,
+  };
+}
+
 async function factAction({ hordeDir, member, params }: ActionContext): Promise<ActionResult> {
   const { fact, duplicateOf, corroborationFull } = await addFact(
     hordeDir,
@@ -225,13 +301,30 @@ async function factAction({ hordeDir, member, params }: ActionContext): Promise<
       id: fact.id,
     };
   }
-  return { text: `Recorded fact T${fact.id}: ${fact.text}`, id: fact.id };
+  const provisional = fact.provisionalOn
+    ? `\nT${fact.id} is provisional: ${fact.provisionalOn} is still auditing its subject. The answer may not quote it as settled until ${fact.provisionalOn} is closed or resolved; cite that closure with it.`
+    : "";
+  return { text: `Recorded fact T${fact.id}: ${fact.text}${provisional}`, id: fact.id };
 }
 
-function factsAction({ hordeDir }: ActionContext): ActionResult {
-  const facts = listFacts(hordeDir);
-  if (facts.length === 0) return { text: "FACTS.md has no facts yet" };
-  return { text: facts.map((fact) => `T${fact.id} ${fact.text} @${fact.author}`).join("\n") };
+function factLines(hordeDir: string): string[] {
+  const status = (fact: FactEntry): string => {
+    if (!fact.provisionalOn) return "";
+    return factUnsettled(hordeDir, fact) ? ` [provisional: ${fact.provisionalOn} open]` : ` [was provisional on ${fact.provisionalOn}, now closed]`;
+  };
+  return listFacts(hordeDir).map((fact) => `T${fact.id} ${fact.text} @${fact.author}${status(fact)}`);
+}
+
+function factsAction({ hordeDir, siblings }: ActionContext): ActionResult {
+  const own = factLines(hordeDir);
+  const shared = siblingSections(siblings, "facts", factLines);
+  return { text: `${own.length === 0 ? "FACTS.md has no facts yet" : own.join("\n")}${shared}` };
+}
+
+/** An answer that quotes a provisional fact as settled asserts what an open idea is still auditing. */
+function unsettledAnswerFacts(ctx: ActionContext, text: string): string | undefined {
+  const unsettled = unsettledFactCitations(ctx.hordeDir, text);
+  return unsettled.length ? `quotes provisional ${unsettled.join(", ")}` : undefined;
 }
 
 async function assertAction({ hordeDir, member, params }: ActionContext): Promise<ActionResult> {
@@ -288,13 +381,44 @@ async function ideaAction({ hordeDir, member, params }: ActionContext): Promise<
   return { text: `Added idea #${idea.id}: ${idea.text}`, id: idea.id };
 }
 
-async function claimAction({ hordeDir, member, params }: ActionContext): Promise<ActionResult> {
+/**
+ * The verifier reviews before it investigates: a verifier that claimed ideas and filed the
+ * run's main findings left its first session with zero scoped reviews while its summary
+ * reported verification complete. Any verdict counts; a finding it cannot reproduce gets a
+ * refuting or inconclusive review, not silence.
+ */
+function checkVerifierClaim(ctx: ActionContext): void {
+  if (!ctx.runId || !isVerifierRole(ctx.role)) return;
+  const pending = pendingReviewsForMember(ctx.hordeDir, ctx.runId, ctx.member);
+  if (!pending.length) return;
+  throw new Error(
+    `horde: you are the verifier and ${pending.length} finding(s) by other members await your review: ` +
+      `${pending.map((f) => `F${f.id}`).join(", ")}. Review each (any verdict, with its unchecked scope) before claiming an idea`,
+  );
+}
+
+/** Findings of this run that already have an independent corroborator or a full review and overlap the idea. */
+function reproducedOverlap(ctx: ActionContext, idea: Idea): string {
+  if (!ctx.runId) return "";
+  const state = collaborationState(ctx.hordeDir, ctx.runId);
+  const settled = listFindingsForRun(ctx.hordeDir, ctx.runId).filter((f) =>
+    f.supersededBy === undefined && (f.corroborators.length > 0 || findingReviewState(f, state.reviews, state.messages).status === "full"));
+  const match = textOverlap(settled.map((f) => f.title), idea.text);
+  if (!match || Math.max(match.jaccard, match.overlap) < CLUSTER_THRESHOLD) return "";
+  const finding = settled[match.index];
+  if (!finding) return "";
+  return `\nNote: F${finding.id} ("${finding.title}") is already independently reproduced; a further reproduction adds nothing. Attach a new vector or distinct evidence with deltaOf: ${finding.id}, or take a different slice.`;
+}
+
+async function claimAction(ctx: ActionContext): Promise<ActionResult> {
+  const { hordeDir, member, params } = ctx;
+  checkVerifierClaim(ctx);
   const { idea, overlap } = await claimIdea(hordeDir, member, requireId(params));
   const warning = overlap
     ? `\nWarning: #${overlap.id} held by ${overlap.owner} covers a similar slice ("${overlap.text}"). ` +
       `Coordinate: take a distinct angle, or attach evidence to #${overlap.id} with a finding or contest.`
     : "";
-  return { text: `Claimed #${idea.id}: ${idea.text}${warning}`, id: idea.id };
+  return { text: `Claimed #${idea.id}: ${idea.text}${warning}${reproducedOverlap(ctx, idea)}`, id: idea.id };
 }
 
 async function resourceAction(ctx: ActionContext): Promise<ActionResult> {
@@ -326,27 +450,46 @@ async function resourceAction(ctx: ActionContext): Promise<ActionResult> {
   };
 }
 
-function resourcesAction({ hordeDir }: ActionContext): ActionResult {
-  const resources = listResources(hordeDir);
-  if (resources.length === 0) return { text: "RESOURCES.md has no resources yet" };
-  return {
-    text: resources
-      .map(
-        (resource) =>
-          `R${resource.id} ${resource.name} @${resource.owner}` +
-          `${resource.note ? `: ${resource.note}` : ""}` +
-          `${resource.reusers.length > 0 ? ` reuse=${resource.reusers.join(",")}` : ""}`,
-      )
-      .join("\n"),
-  };
+function resourceLines(hordeDir: string): string[] {
+  return listResources(hordeDir).map(
+    (resource) =>
+      `R${resource.id} ${resource.name} @${resource.owner}` +
+      `${resource.note ? `: ${resource.note}` : ""}` +
+      `${resource.reusers.length > 0 ? ` reuse=${resource.reusers.join(",")}` : ""}`,
+  );
+}
+
+function resourcesAction({ hordeDir, siblings }: ActionContext): ActionResult {
+  const own = resourceLines(hordeDir);
+  const shared = siblingSections(siblings, "resources (reuse by path; cite the path, not the R#)", resourceLines);
+  return { text: `${own.length === 0 ? "RESOURCES.md has no resources yet" : own.join("\n")}${shared}` };
+}
+
+/**
+ * An answer that cites a superseded finding, or one amended since the proposal pinned it, ships a
+ * stale reading as the run's result. The proposer cites the current text instead; a validator is
+ * refused until the proposer re-proposes.
+ */
+function staleAnswer(ctx: ActionContext, text: string, cites?: Record<string, string>): string | undefined {
+  const runId = requireRun(ctx);
+  const stale = staleAnswerCitations(listFindingsForRun(ctx.hordeDir, runId), text, cites);
+  if (!stale.length) return undefined;
+  return `cites ${stale.join(", ")}`;
 }
 
 async function solvedAction(ctx: ActionContext): Promise<ActionResult> {
+  const runId = requireRun(ctx);
+  const text = ctx.params.text ?? "";
+  const stale = staleAnswer(ctx, text);
+  if (stale) throw new Error(`horde: the answer ${stale}; cite the current findings and propose again`);
+  const unsettled = unsettledAnswerFacts(ctx, text);
+  if (unsettled) throw new Error(`horde: the answer ${unsettled}; close the idea or resolve the claim first, or leave the fact out`);
   const { signal, alreadySolved } = await markSolved(
     ctx.hordeDir,
-    requireRun(ctx),
+    runId,
     ctx.member,
     ctx.params.text,
+    answerCitations(listFindingsForRun(ctx.hordeDir, runId), text),
   );
   return {
     text: alreadySolved
@@ -356,7 +499,13 @@ async function solvedAction(ctx: ActionContext): Promise<ActionResult> {
 }
 
 async function confirmSolvedAction(ctx: ActionContext): Promise<ActionResult> {
-  const answer = await confirmSolved(ctx.hordeDir, requireRun(ctx), ctx.member, ctx.params.text, ctx.params.revision);
+  const runId = requireRun(ctx);
+  const proposal = readSolved(path.join(ctx.hordeDir, "runs", runId));
+  const stale = proposal ? staleAnswer(ctx, proposal.text, proposal.cites) : undefined;
+  if (stale) throw new Error(`horde: the pending answer ${stale}; it cannot be validated until ${proposal?.member} re-proposes against the current findings`);
+  const unsettled = proposal ? unsettledAnswerFacts(ctx, proposal.text) : undefined;
+  if (unsettled) throw new Error(`horde: the pending answer ${unsettled}; close the idea or resolve the claim before validating it`);
+  const answer = await confirmSolved(ctx.hordeDir, runId, ctx.member, ctx.params.text, ctx.params.revision);
   if (!answer.ok) throw new Error(`horde: ${answer.reason}`);
   if (answer.reason !== "validated") {
     return {
@@ -378,9 +527,23 @@ async function contestSolvedAction(ctx: ActionContext): Promise<ActionResult> {
   };
 }
 
+/** A result line that reports a confirmed negative: the lead is dead, not merely finished. */
+const NEGATIVE_RESULT =
+  /\b(?:not (?:exploitable|vulnerable|reachable|reproducible|affected)|does not reproduce|could not reproduce|cannot be reproduced|confirmed negative|negative result|dead end|ruled? out|no (?:vulnerability|exploit|issue|bug|weakness) (?:found|present|exists))\b/i;
+
 async function doneAction(ctx: ActionContext): Promise<ActionResult> {
   const { hordeDir, member, params } = ctx;
-  const idea = await finishIdea(hordeDir, member, requireId(params), closeNote(params));
+  const note = closeNote(params) ?? "";
+  // Four confirmed negatives were recorded only as done notes and prose, so the next run on the
+  // same target re-walked them. A negative closes with rule-out, which later runs can read.
+  const negative = NEGATIVE_RESULT.exec(note);
+  if (negative) {
+    throw new Error(
+      `horde: "${negative[0]}" reads as a confirmed negative; close #${requireId(params)} with 'horde rule-out' and the same note so later runs do not retry it. ` +
+        "Use done only for work that produced a result.",
+    );
+  }
+  const idea = await finishIdea(hordeDir, member, requireId(params), note || undefined);
   return closedIdea(ctx, idea, `Done #${idea.id}: ${idea.text}`);
 }
 
@@ -422,6 +585,7 @@ const HANDLERS: Partial<Record<HordeToolParams["action"], ActionHandler>> = {
   "contest-solved": contestSolvedAction,
   concerns: concernsAction,
   verify: verifyAction,
+  amend: amendAction,
 };
 
 export async function runHordeAction(
@@ -429,10 +593,11 @@ export async function runHordeAction(
   member: string,
   params: HordeToolParams,
   runId: string | undefined = process.env.PI_HORDE_RUN,
-  tracking: { attempt?: string; requestId?: string } = {},
+  tracking: { attempt?: string; requestId?: string; role?: string | undefined; siblings?: SiblingHorde[] | undefined } = {},
 ): Promise<ActionResult> {
   const cleanStop = Boolean(runId && cleanStopRequestedFor(hordeDir, runId, member));
-  const ctx: EventContext = { hordeDir, runId: runId ?? "", actor: member, ...tracking, requestId: params.requestId ?? tracking.requestId };
+  const { role, siblings = [], ...eventTracking } = tracking;
+  const ctx: EventContext = { hordeDir, runId: runId ?? "", actor: member, ...eventTracking, requestId: params.requestId ?? tracking.requestId };
   if (COLLABORATION_ACTIONS.has(params.action)) {
     if (!runId) throw new Error("horde: collaboration needs an active run");
     return runCollaborationAction(ctx, params);
@@ -444,7 +609,7 @@ export async function runHordeAction(
   const intent = audit ? await recordEvent({ ...ctx, requestId: ctx.requestId ? `${ctx.requestId}:intent` : undefined }, params.action, { outcome: "intent", payload: { input: params } }) : undefined;
   try {
     const refused = cleanStop && NEW_WORK_ACTIONS.has(params.action);
-    const result = refused ? { text: CLEAN_STOP_NOTICE } : await handler({ hordeDir, member, params, runId, cleanStop });
+    const result = refused ? { text: CLEAN_STOP_NOTICE } : await handler({ hordeDir, member, params, runId, cleanStop, role, siblings });
     // A refusal and a no-op both record `noop`; the no-op keeps `result.noop` so the graph and the
     // report can tell an absorbed duplicate from refused work.
     if (audit) await recordEvent(ctx, params.action, { outcome: refused || result.noop ? "noop" : "applied", payload: { input: params, result }, parents: intent ? [intent.eventId] : [] });