agent-horde 0.1.2 → 0.1.4

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.2
+pi install git:github.com/eliyastein/agent-horde@v0.1.4
 ```
 
 To hack on it, clone and install in place. pi loads the files from the clone, so edits take effect
@@ -109,14 +109,21 @@ Start pi in the directory the horde should work on, then:
 
 Six members start on the prompt with the session's model and thinking level. The command returns
 at once; a widget above the editor shows each member's status, current tool, turns, and resets,
-and the dashboard is at `http://127.0.0.1:7433/`. When the work is partitionable, name the parts:
+and the dashboard is at `http://127.0.0.1:7433/`. In this form members divide the work
+themselves: each reads the board, claims an idea nobody else owns, and moves on when it is done or
+ruled out.
+
+When you already know how the work splits, use `plan` to fix the partition at launch:
 
 ```
 /agent-horde plan --dashboard 4 parser; type checker; code generator
 ```
 
-Each member takes one part. Members without a part become verifiers, and an unpartitioned run of
-three or more members makes its last member the verifier.
+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.
 
 | command | effect |
 |---|---|

package/docs/REFERENCE.md

@@ -37,7 +37,10 @@ synthesize it.
    a fresh session takes its name, up to `PI_HORDE_RESET_CAP` times.
 3. **Repair.** After discovery ends normally, finished members get fresh, targeted sessions to
    answer open blockers, review requests, and responses, within the `PI_HORDE_REPAIR_*` budgets.
-   A user stop skips this phase.
+   The default totals follow the queues' demand (one floor per queue plus one per further review
+   request or blocking challenge), each attempt's share is cut in proportion to its demand, and
+   every attempt gets at least a floor; the phase start records the budget, `repair-start` the
+   attempt's demand, and `repair-end` its turns and first-turn cost. A user stop skips this phase.
 4. **Finalize.** Acceptance is frozen (`ACCEPTANCE.*`, `snapshot/`), resource cleanup commands
    run, `SUMMARY.md` and `REPORT.md` are written, then a synthesis member writes `DELIVERABLE.md`
    and a read-only reviewer writes `POSTMORTEM.md`. The widget shows `synthesizing` until both
@@ -83,7 +86,7 @@ Every page has a JSON twin under `/api/<same path>`.
 | `/runs/<id>/collaboration` | messages, review scope, artifact acceptance, resources, event audit |
 | `/runs/<id>/graph` | the run as a swimlane: one lane per member plus the parent, phase bands, every event a link to its ledger entry (`?w=<px>`, `?from=<s>&to=<s>`); the axis is real time until the last member exits, then the synthesis phases share a compressed tail |
 | `/runs/<id>/graph.mmd` | the same run as a Mermaid flowchart with absolute dashboard links (text/plain) |
-| `/ideas`, `/board`, `/findings`, `/claims`, `/facts`, `/resources` | the shared ledgers; `?run=<id>\|all`, `?view=clusters`, `?owner=<m>` filter them |
+| `/ideas`, `/board`, `/findings`, `/claims`, `/facts`, `/resources` | the shared ledgers; `?run=<id>\|all`, `?view=clusters`, `?owner=<m>` filter them; `/resources` also lists who cited each resource in the active run, as REPORT.md counts reuse |
 
 Only the active run has live member state. Historical runs are rebuilt from `member-N.log` and
 the session files, so they show end cause, turns, and usage but no activity.
@@ -175,9 +178,16 @@ from the same actor as an idempotent retry. The parent appends its own lifecycle
   `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.
+  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#`.
 - **Inbox.** Targeted messages are inserted at turn boundaries, for at most
-  `PI_HORDE_INBOX_TURNS` extra turns per session. Delivery is a context insertion, not
+  `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
   comprehension. Message and review bodies are untrusted input, not tool instructions.
 - **Reminders.** Every `PI_HORDE_REMIND_CALLS` tool calls or `PI_HORDE_REMIND_MS`, the tool
   result restates the task, role, and claimed ideas. A member that finishes its last idea while
@@ -234,9 +244,11 @@ carries a one-line diagnosis and, when generated, the post-mortem text.
 | `PI_HORDE_SOLVED_STOP_MS` | 30000 | extra wind-down window for a solve landing at the deadline |
 | `PI_HORDE_ALLOW_UNVERIFIED` | unset | `1` accepts a validated answer with unverified findings |
 | `PI_HORDE_REPAIR_ROUNDS` | 4 | post-discovery repair rounds (max 6; `0` disables) |
-| `PI_HORDE_REPAIR_MS` | 120000 | total repair time |
-| `PI_HORDE_REPAIR_TOKENS` | 50000 | total repair tokens |
-| `PI_HORDE_REPAIR_MIN_TOKENS` | 20000 | floor per attempt; below it scheduling stops with a `repair-skipped` event |
+| `PI_HORDE_REPAIR_MS` | demand-sized | total repair time: one `PI_HORDE_REPAIR_MIN_MS` per demand unit (max 6) plus two recheck shares; a number here is a flat total |
+| `PI_HORDE_REPAIR_TOKENS` | demand-sized | total repair tokens: one `PI_HORDE_REPAIR_MIN_TOKENS` per demand unit (max 6) plus two recheck shares; a number here is a flat total |
+| `PI_HORDE_REPAIR_MIN_TOKENS` | 40000 | token floor per attempt; below it scheduling stops with a `repair-skipped` event |
+| `PI_HORDE_REPAIR_MIN_MS` | 60000 | time floor per attempt; the clock is split only among attempts the token budget can fund |
+| `PI_HORDE_REPAIR_TURNS` | 40 | turn cap per attempt; an attempt still reading its inbox at the cap is stopped with `turns` |
 | `PI_HORDE_DELIVERABLE` | on | `off` skips the synthesis member |
 | `PI_HORDE_POSTMORTEM` | on | `off` skips the automatic post-mortem |
 | `PI_HORDE_POSTMORTEM_MS` | 300000 | post-mortem reviewer timeout |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-horde",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "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/citations.ts

@@ -2,7 +2,8 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { clusterFindings } from "./ledger/clusters.js";
 import { collaborationState } from "./ledger/collaboration.js";
-import { findingReviewState } from "./ledger/findings.js";
+import type { CollaborationState, ReviewRecord } from "./ledger/collaboration.js";
+import { findingReviewState, findingRevision } from "./ledger/findings.js";
 import type { FindingEntry } from "./ledger/findings.js";
 import { listResources, readRunResources } from "./ledger/resources.js";
 import type { ResourceEntry } from "./ledger/resources.js";
@@ -72,7 +73,10 @@ export function citedDataFiles(text: string): string[] {
   return [...out];
 }
 
-/** Bounded search for a file by name under a directory; artifact dirs are small. */
+/** Trees a basename search never descends into: run data, dependencies and version control. */
+const UNSEARCHED_DIRS = new Set([".horde", "node_modules", ".git"]);
+
+/** Bounded search for a file by name under a directory; artifact dirs and source trees are shallow. */
 function fileNamedUnder(dir: string, name: string, depth = 6): boolean {
   let entries: fs.Dirent[];
   try {
@@ -82,7 +86,7 @@ function fileNamedUnder(dir: string, name: string, depth = 6): boolean {
   }
   for (const entry of entries) {
     if (entry.isFile() && entry.name === name) return true;
-    if (entry.isDirectory() && depth > 0 && fileNamedUnder(path.join(dir, entry.name), name, depth - 1)) {
+    if (entry.isDirectory() && depth > 0 && !UNSEARCHED_DIRS.has(entry.name) && fileNamedUnder(path.join(dir, entry.name), name, depth - 1)) {
       return true;
     }
   }
@@ -93,7 +97,8 @@ function fileNamedUnder(dir: string, name: string, depth = 6): boolean {
  * True when a cited file cannot be resolved to an existing file on disk. Paths
  * are tried against the repo root, the run directory, its artifacts directory,
  * and the directory of the citing file. Because generated artifacts usually cite
- * retained files by a relative name, a basename match anywhere in this run's tree
+ * retained files by a relative name, and a deliverable cites the reviewed project's
+ * own files by bare name, a basename match in this run's tree or in the project tree
  * also counts, which keeps the warning precise instead of noisy.
  */
 function citedFileMissing(run: HordeRun, ref: string, baseDir?: string): boolean {
@@ -109,7 +114,7 @@ function citedFileMissing(run: HordeRun, ref: string, baseDir?: string): boolean
     }
   }
   const base = ref.replace(/^\.\//, "").split("/").pop() ?? ref;
-  return !fileNamedUnder(run.runDir, base);
+  return !fileNamedUnder(run.runDir, base) && !fileNamedUnder(run.cwd, base);
 }
 
 export function resourceCitations(text: string): number[] {
@@ -215,6 +220,61 @@ export function ledgerCitationWarnings(
   return [...new Set(warnings)];
 }
 
+/** The acceptance vocabulary for a finding nobody reviewed at its current revision. */
+const UNREVIEWED_LABEL = /unverified|unreviewed|no (?:independent|current-revision) review|not (?:independently )?reviewed/i;
+
+/**
+ * True when the text cites F<id> and no citing paragraph carries the unreviewed label. One label
+ * at the top of a document cannot cover every later citation; a label next to any citation can.
+ */
+function citedWithoutLabel(text: string, id: number): boolean {
+  const cite = new RegExp(`\\bF${id}\\b`);
+  const citing = text.split(/\n\s*\n/).filter((paragraph) => cite.test(paragraph));
+  return citing.length > 0 && !citing.some((paragraph) => UNREVIEWED_LABEL.test(paragraph));
+}
+
+/** A sentence ends at `.`, `!` or `?`, possibly inside closing emphasis or brackets, before a capitalised start. */
+const SENTENCE_BREAK = /(?<=[.!?][*_)\]"']*)\s+(?=[A-Z"'([*_`])/;
+
+/**
+ * The units a review citation is judged in: sentences, except that each list item and table row
+ * stands alone. A bullet that cites reviews as the source of a limitation does not claim them as
+ * support for a finding named two bullets up, and a sentence that cites a document's review does
+ * not claim it for the finding named in the sentence before.
+ */
+function citationUnits(text: string): string[] {
+  return text.split(/\n\s*\n/).flatMap((paragraph) => (/^\s*(?:[-*]|\d+\.|\|)\s/m.test(paragraph) ? paragraph.split("\n") : paragraph.split(SENTENCE_BREAK)));
+}
+
+/**
+ * A V# cited next to an F# must review that finding at its current revision. A review of the
+ * finding it superseded, of an artifact that merely depends on it, or of an earlier revision is
+ * not support for the claim it sits next to. A V# with no review record is left alone: "V8" in
+ * prose is an engine, not a citation.
+ */
+function reviewCitationWarnings(label: string, text: string, findings: FindingEntry[], reviews: ReviewRecord[]): string[] {
+  const warnings: string[] = [];
+  for (const paragraph of citationUnits(text)) {
+    const cited = [...new Set([...paragraph.matchAll(/\bF(\d+)\b/g)].map((match) => `F${match[1]}`))];
+    if (cited.length === 0) continue;
+    const targets = new Set([...cited, ...[...paragraph.matchAll(/\bA(\d+)\b/g)].map((match) => `A${match[1]}`)]);
+    for (const match of paragraph.matchAll(/\bV(\d+)\b/g)) {
+      const id = `V${match[1]}`;
+      const review = reviews.find((entry) => entry.id === id);
+      if (!review) continue;
+      if (!targets.has(review.target)) {
+        warnings.push(`${label} cites ${id} next to ${cited.join(", ")}, but ${id} reviews ${review.target}`);
+        continue;
+      }
+      const finding = findings.find((entry) => `F${entry.id}` === review.target);
+      if (finding && review.revision !== findingRevision(finding)) {
+        warnings.push(`${label} cites ${id} for ${review.target}, but it reviewed an earlier revision; the current revision has no such review`);
+      }
+    }
+  }
+  return warnings;
+}
+
 export function generatedArtifactWarnings(
   run: HordeRun,
   label: string,
@@ -238,14 +298,41 @@ export function generatedArtifactWarnings(
     const cited = checks.filter((f) => f.check.status === status && new RegExp(`\\bF${f.id}\\b`).test(text));
     if (cited.length) warnings.push(`${label} cites ${status === "limited" ? "scope-limited reviews" : "disputed findings"} (${cited.map((f) => `F${f.id}`).join(", ")}); consult the exact checked/unchecked scope and unresolved challenges in COLLABORATION.md`);
   }
-  const citedUnverified = unverified.filter((finding) =>
-    new RegExp(`\\bF${finding.id}\\b`).test(text),
-  );
-  if (citedUnverified.length > 0 && !/unverified/i.test(text)) {
+  const unlabeled = unverified.filter((finding) => citedWithoutLabel(text, finding.id));
+  if (unlabeled.length > 0) {
     warnings.push(
-      `${label} cites unverified findings (${citedUnverified.map((finding) => `F${finding.id}`).join(", ")}) ` +
-        "without labeling them unverified",
+      `${label} cites findings with no independent review (${unlabeled.map((finding) => `F${finding.id}`).join(", ")}) ` +
+        "without saying so in the citing paragraph",
     );
   }
+  warnings.push(...reviewCitationWarnings(label, text, findings, state.reviews));
   return [...new Set(warnings)];
 }
+
+/**
+ * Non-owner members whose findings, evidence, reviews or leases name a resource. A member that
+ * works in a shared lab rarely re-runs `horde resource`, so explicit reclaims alone undercount reuse.
+ */
+export function resourceCitingMembers(
+  resources: ResourceEntry[],
+  findings: FindingEntry[],
+  state: Pick<CollaborationState, "evidence" | "reviews" | "resources">,
+): Map<number, string[]> {
+  const texts: Array<{ member: string; text: string }> = [
+    ...findings.map((finding) => ({ member: finding.author, text: finding.body })),
+    ...state.evidence.map((record) => ({ member: record.actor, text: record.text })),
+    ...state.reviews.map((review) => ({ member: review.actor, text: `${review.checked} ${review.text}` })),
+  ];
+  const out = new Map<number, string[]>();
+  for (const resource of resources) {
+    const members = new Set<string>();
+    for (const { member, text } of texts) {
+      if (member !== resource.owner && resourceCitations(text).includes(resource.id)) members.add(member);
+    }
+    for (const contract of state.resources) {
+      if (contract.target === `R${resource.id}` && contract.owner !== resource.owner) members.add(contract.owner);
+    }
+    out.set(resource.id, [...members].sort());
+  }
+  return out;
+}

package/src/collaboration-report.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { artifactAccepted, blockingMessages, collaborationState, openMessages } from "./ledger/collaboration.js";
-import type { ArtifactRecord, CollaborationState } 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";
 import { listIdeas } from "./ledger/ideas.js";
@@ -51,6 +51,10 @@ function artifactProblem(hordeDir: string, runId: string, state: CollaborationSt
     const file = fs.realpathSync(path.join(hordeDir, "runs", runId, artifact.path));
     if (!file.startsWith(root + path.sep) || hashText(fs.readFileSync(file)) !== artifact.hash) return "file changed after publication";
   } catch { return "published file unavailable"; }
+  // A blocker is named as such: the acceptance text is read by members and the deliverable, and
+  // "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"
     ? "needs a full independent review against document criteria"
     : "needs a full independent tested/reproduced review";
@@ -84,19 +88,35 @@ export function loadCollaborationReport(hordeDir: string, runId: string): Collab
     unresolved: openMessages(state).length, blocking: blockingMessages(state).length,
     resolvedChallenges: messages.filter((m) => m.kind === "challenge" && m.state === "resolved").length,
     deferredChallenges: messages.filter((m) => m.kind === "challenge" && m.state === "deferred").length,
+    openChallenges: messages.filter((m) => m.kind === "challenge" && m.state !== "resolved" && m.state !== "deferred").length,
     meanDeliveryMs: delays.length ? Math.round(delays.reduce((a, b) => a + b, 0) / delays.length) : 0,
     acceptedArtifacts: acceptedArtifacts.length,
     acceptedDocuments: acceptedDocuments.length, acceptedRunnableArtifacts: acceptedRunnableArtifacts.length,
   } };
 }
 
+function withEvidence(text: string, evidence: string[] | undefined): string {
+  return evidence?.length ? `${text} (evidence ${evidence.join(", ")})` : text;
+}
+
+/** The response and the resolution are different actors' decisions; each shows with its own evidence. */
+function messageMarkdown(m: PeerMessage): string {
+  const lines = [
+    `- ${m.id} ${m.sender} -> ${m.to} ${m.target}@${m.revision} [${m.state}] ${m.kind}${m.blocking ? " BLOCKING" : ""}`,
+    `  ${m.text}`,
+    `  Response: ${m.response ? withEvidence(m.response, m.responseEvidence) : "pending"}`,
+  ];
+  if (m.resolution !== undefined) lines.push(`  ${m.state === "deferred" ? "Deferred" : "Resolution"}: ${withEvidence(m.resolution, m.resolutionEvidence)}`);
+  lines.push(`  Evidence: ${m.evidence.join(", ") || "none"}; created ${m.createdAt}; updated ${m.updatedAt}`);
+  return lines.join("\n");
+}
+
 function collaborationMarkdown(report: CollaborationReport): string {
   const { state } = report;
   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## Questions, challenges and handoffs", ...state.messages.map((m) =>
-      `- ${m.id} ${m.sender} -> ${m.to} ${m.target}@${m.revision} [${m.state}] ${m.kind}${m.blocking ? " BLOCKING" : ""}\n  ${m.text}\n  Response: ${m.response ?? "pending"}\n  Evidence: ${m.evidence.join(", ") || "none"}; created ${m.createdAt}; updated ${m.updatedAt}`),
+    "\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## Evidence", ...state.evidence.map((e) => `- ${e.id} ${e.target}@${e.revision} @${e.actor} ${e.relation}${e.path ? ` ${e.path}@${e.hash}` : ""}\n  ${e.text}`),

package/src/dashboard-data.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { MAX_MEMBERS } from "./args.js";
+import { resourceCitingMembers } from "./citations.js";
 import { loadCollaborationReport } from "./collaboration-report.js";
 import type { CollaborationReport } from "./collaboration-report.js";
 import { readEvents } from "./ledger/events.js";
@@ -14,7 +15,7 @@ import { listFacts } from "./ledger/facts.js";
 import type { FactEntry } from "./ledger/facts.js";
 import { hordePaths } from "./ledger/files.js";
 import { collaborationState } from "./ledger/collaboration.js";
-import { findingReviewState, parseFindings } from "./ledger/findings.js";
+import { findingReviewState, listFindingsForRun, parseFindings } from "./ledger/findings.js";
 import type { FindingEntry } from "./ledger/findings.js";
 import { listIdeas } from "./ledger/ideas.js";
 import type { Idea } from "./ledger/ideas.js";
@@ -802,13 +803,24 @@ export function loadClaims(src: DashboardSource): ClaimsVm {
 }
 
 export interface ResourcesVm {
-  resources: ResourceEntry[];
+  /** The active run whose findings, evidence, reviews and leases were scanned for citations. */
+  run?: string | undefined;
+  resources: Array<ResourceEntry & { citedBy: string[] }>;
 }
 
-/** Shared labs/harnesses/control corpora and who reused them. */
+/**
+ * Shared labs/harnesses/control corpora, who reclaimed them, and who cited them. Citations are
+ * counted the way REPORT.md counts them, from the active run's ledgers; without an active run
+ * only explicit reclaims are known.
+ */
 export function loadResources(src: DashboardSource): ResourcesVm {
   const paths = hordePaths(src.hordeDir);
-  return { resources: fs.existsSync(paths.resources) ? listResources(src.hordeDir) : [] };
+  const resources = fs.existsSync(paths.resources) ? listResources(src.hordeDir) : [];
+  const live = src.getActive();
+  const citing = live
+    ? resourceCitingMembers(resources, listFindingsForRun(src.hordeDir, live.id), collaborationState(src.hordeDir, live.id))
+    : new Map<number, string[]>();
+  return { run: live?.id, resources: resources.map((resource) => ({ ...resource, citedBy: citing.get(resource.id) ?? [] })) };
 }
 
 export interface FactsVm {

package/src/dashboard-html.ts

@@ -3,6 +3,7 @@ import type { ClaimEntry } from "./ledger/claims.js";
 import type { FactEntry } from "./ledger/facts.js";
 import type { FindingEntry } from "./ledger/findings.js";
 import type { Idea } from "./ledger/ideas.js";
+import type { PeerMessage } from "./ledger/collaboration.js";
 import type {
   BoardVm,
   CollaborationVm,
@@ -122,12 +123,24 @@ function anchor(id: string): string {
   return `<span id="${e(id)}">${e(id)}</span>`;
 }
 
+function withEvidence(text: string, evidence: string[] | undefined): string {
+  return evidence?.length ? `${text} (evidence ${evidence.join(", ")})` : text;
+}
+
+/** The request, the recipient's response and the sender's resolution, each with its own evidence. */
+function messageThread(m: PeerMessage): string {
+  const lines = [m.text, `Response: ${m.response ? withEvidence(m.response, m.responseEvidence) : "pending"}`];
+  if (m.resolution !== undefined) lines.push(`${m.state === "deferred" ? "Deferred" : "Resolution"}: ${withEvidence(m.resolution, m.resolutionEvidence)}`);
+  lines.push(`Evidence: ${m.evidence.join(", ") || "none"}`);
+  return lines.join("\n");
+}
+
 export function renderCollaboration(vm: CollaborationVm, ctx: RenderContext): string {
   const { report } = vm;
   const { state } = report;
   const messages = table(["request", "owner", "state / age", "target", "question / response"], state.messages.map((m) => [
     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(`${m.text}\nResponse: ${m.response ?? "pending"}\nEvidence: ${m.evidence.join(", ")}`),
+    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 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")]));
@@ -615,15 +628,17 @@ export function renderResources(vm: ResourcesVm, ctx: RenderContext): string {
     e(resource.name),
     authorLink(resource.owner, ctx.activeId),
     e(resource.note ?? ""),
-    resource.reusers.length > 0
-      ? resource.reusers.map((name) => authorLink(name, ctx.activeId)).join(", ")
-      : "",
+    resource.reusers.map((name) => authorLink(name, ctx.activeId)).join(", "),
+    resource.citedBy.map((name) => authorLink(name, ctx.activeId)).join(", "),
     e(resource.cleanup ?? ""),
   ]);
+  const scope = vm.run
+    ? `<p>cited by: non-owners whose findings, evidence, reviews or leases name the resource in run ${e(vm.run)}</p>`
+    : "<p>cited by: needs an active run; only explicit reclaims are shown</p>";
   return page(
     "resources",
     [{ text: "resources" }],
-    table(["id", "name", "owner", "note", "reused by", "cleanup"], rows, "no shared resources claimed"),
+    scope + table(["id", "name", "owner", "note", "reused by", "cited by", "cleanup"], rows, "no shared resources claimed"),
     ctx,
   );
 }

package/src/ledger/clusters.ts

@@ -114,9 +114,10 @@ export function clusterFindings(entries: FindingEntry[]): FindingCluster[] {
   return drafts
     .filter((draft) => draft.findings.length > 0)
     .map((draft) => {
-      // A cluster is represented by its root finding: a non-delta with the lowest id.
+      // A cluster is represented by its root finding: a current non-delta with the lowest id. A
+      // superseded root would file the whole cluster, successor included, under superseded.
       const representative = [...draft.findings].sort((a, b) => {
-        const rank = (finding: FindingEntry): number => (finding.deltaOf === undefined ? 0 : 1);
+        const rank = (finding: FindingEntry): number => (finding.supersededBy === undefined ? 0 : 2) + (finding.deltaOf === undefined ? 0 : 1);
         return rank(a) - rank(b) || a.id - b.id;
       })[0]!;
       const members: string[] = [];

package/src/ledger/collaboration.ts

@@ -19,7 +19,11 @@ export interface PeerMessage {
   response?: string;
   responseRevision?: string;
   responseTarget?: string;
+  /** Evidence the recipient attached to its response. */
+  responseEvidence?: string[];
   resolution?: string;
+  /** Evidence the sender attached when resolving or deferring. */
+  resolutionEvidence?: string[];
   deliveries: Record<string, string>;
 }
 interface EvidenceRecord {
@@ -96,14 +100,28 @@ export function projectCollaboration(events: HordeEvent[]): CollaborationState {
       state.resources = state.resources.filter((r) => r.target !== contract.target).concat(contract);
     }
     if (p.transition) applyTransition(state, event);
+    if (Array.isArray(p.clearances)) applyClearances(state, event);
   }
   return state;
 }
 
+/** A full-scope review that covers a partial review's unchecked scope resolves the challenge that review raised. */
+function applyClearances(state: CollaborationState, event: HordeEvent): void {
+  for (const clearance of event.payload.clearances as Array<{ id: string; text: string; refs: string[] }>) {
+    const message = state.messages.find((m) => m.id === clearance.id);
+    if (!message || message.state === "resolved") continue;
+    message.state = "resolved";
+    message.resolution = clearance.text;
+    message.resolutionEvidence = clearance.refs;
+    message.updatedAt = event.at;
+  }
+}
+
 function applyTransition(state: CollaborationState, event: HordeEvent): void {
   const t = event.payload.transition as { id: string; state: MessageState; text?: string; revision?: string; responseTarget?: string; attempt?: string };
   const message = state.messages.find((m) => m.id === t.id);
   if (!message) return;
+  const refs = Array.isArray(event.payload.refs) ? (event.payload.refs as string[]) : [];
   if (t.state === "delivered") {
     message.deliveries[t.attempt ?? event.attempt] = event.at;
     if (message.state === "pending") message.state = "delivered";
@@ -113,7 +131,11 @@ function applyTransition(state: CollaborationState, event: HordeEvent): void {
       message.response = t.text;
       message.responseRevision = t.revision;
       message.responseTarget = t.responseTarget;
-    } else if (t.state === "resolved" || t.state === "deferred") message.resolution = t.text;
+      message.responseEvidence = refs;
+    } else if (t.state === "resolved" || t.state === "deferred") {
+      message.resolution = t.text;
+      message.resolutionEvidence = refs;
+    }
   }
   message.updatedAt = event.at;
 }

package/src/ledger/event-metrics.ts

@@ -0,0 +1,35 @@
+import type { HordeEvent } from "./events.js";
+
+export interface SolvedConfirmations {
+  /** Members whose confirm-solved was the one credited for a proposal revision. */
+  credited: string[];
+  /** Members who confirmed the same proposal after the credited one; their text is in the event. */
+  additional: string[];
+}
+
+/** The report names every member that confirmed the proposal, not only the one credited. */
+export function solvedConfirmations(events: HordeEvent[]): SolvedConfirmations {
+  const out: SolvedConfirmations = { credited: [], additional: [] };
+  for (const event of events) {
+    if (event.action !== "confirm-solved" || event.outcome === "rejected" || event.outcome === "intent") continue;
+    const result = event.payload.result as { confirmation?: unknown } | undefined;
+    if (event.outcome === "applied" && result?.confirmation !== "additional") out.credited.push(event.actor);
+    else out.additional.push(event.actor);
+  }
+  return out;
+}
+
+export function ideaCreationCount(events: HordeEvent[]): number {
+  return events.filter((event) => event.action === "idea" && event.outcome === "applied").length;
+}
+
+/** Idea creations the dedup folded into an existing idea, by that idea's id, most absorbed first. */
+export function absorbedIdeaCreations(events: HordeEvent[]): Array<{ id: number; count: number }> {
+  const counts = new Map<number, number>();
+  for (const event of events) {
+    if (event.action !== "idea" || event.outcome !== "noop") continue;
+    const id = (event.payload.result as { id?: unknown } | undefined)?.id;
+    if (typeof id === "number") counts.set(id, (counts.get(id) ?? 0) + 1);
+  }
+  return [...counts].map(([id, count]) => ({ id, count })).sort((a, b) => b.count - a.count || a.id - b.id);
+}

package/src/ledger/ideas.ts

@@ -215,18 +215,26 @@ export async function finishIdea(
   });
 }
 
+/**
+ * Release a claimed idea back to the pool, or retire an unclaimed one you added. `author` is the
+ * member whose write created the idea, when the caller knows it; an unclaimed idea is dropped only
+ * by its author, so folding your own duplicate does not require claiming it first.
+ */
 export async function dropIdea(
   hordeDir: string,
   owner: string,
   id: number,
   reason: string | undefined,
+  options: { author?: string | undefined } = {},
 ): Promise<Idea> {
   return withHordeLock(hordeDir, owner, () => {
     const doc = readIdeasDoc(hordeDir);
     const { index, idea } = requireIdea(doc, id);
-    if (idea.owner !== owner) {
-      const holder = idea.owner ? `claimed by ${idea.owner}` : "not claimed";
-      throw new Error(`horde: idea #${id} is ${holder}; you can only drop ideas you claimed`);
+    if (idea.owner && idea.owner !== owner) {
+      throw new Error(`horde: idea #${id} is claimed by ${idea.owner}; you can only drop ideas you claimed`);
+    }
+    if (!idea.owner && options.author !== owner) {
+      throw new Error(`horde: idea #${id} is not claimed; only the member who added it or its claimant can drop it`);
     }
     const dropped: Idea = { id, mark: " ", text: idea.text };
     doc.lines[index] = formatIdea(dropped);

package/src/ledger/resources.ts

@@ -159,6 +159,27 @@ function cleanupCommandProblem(command: string, runId?: string): string | undefi
   return undefined;
 }
 
+/** The runtime object a cleanup removes, so two labs that share one container name collide. */
+function cleanupObject(command: string): string {
+  const normalized = command.trim().replace(/\s+/g, " ");
+  const container = /^(?:docker|podman)\s+(?:container\s+|image\s+)?(?:rm|rmi|stop|kill)\b(?:\s+-\S+)*\s+(\S+)/i.exec(normalized);
+  if (container) return `object:${container[1]}`;
+  const proc = /^pkill\b(?:\s+-\S+)*\s+(.+)$/i.exec(normalized);
+  if (proc) return `process:${proc[1]}`;
+  return `command:${normalized}`;
+}
+
+/** One teardown must not remove two labs: refuse a cleanup another resource of this run registered. */
+function cleanupCollision(resources: ResourceEntry[], touched: Set<number>, command: string, selfId?: number): ResourceEntry | undefined {
+  if (!command) return undefined;
+  const object = cleanupObject(command);
+  return resources.find((r) => r.id !== selfId && touched.has(r.id) && r.cleanup !== undefined && cleanupObject(r.cleanup) === object);
+}
+
+function collisionMessage(command: string, other: ResourceEntry): string {
+  return `horde: cleanup \`${command}\` is already registered by R${other.id} "${other.name}"; reuse R${other.id} or pick a distinct container name`;
+}
+
 // Filesystem paths cited in a resource note, used to detect overlapping scopes.
 // A URL, a bare filename, or a docker image ref (no slash, or a scheme) is ignored.
 function resourceNotePaths(note: string): string[] {
@@ -223,6 +244,11 @@ export async function claimResource(
     const touch = (resourceId: number): void => {
       if (runId) recordRunResource(hordeDir, runId, resourceId);
     };
+    const touched = new Set(runId ? readRunResources(path.join(hordeDir, "runs", runId)) : []);
+    const collide = (selfId?: number): void => {
+      const other = cleanupCollision(resources, touched, cleanupText, selfId);
+      if (other) throw new Error(collisionMessage(cleanupText, other));
+    };
     const normalized = resourceName.toLowerCase();
     let existing = resources.find((resource) => resource.name.toLowerCase() === normalized);
     if (!existing) existing = bestResourceMatch(resources, resourceName, noteText);
@@ -232,6 +258,7 @@ export async function claimResource(
       if (existing.owner === owner && existing.name.toLowerCase() === normalized &&
           (!runId || existing.ownerRunId === runId)) {
         if ((noteText && noteText !== existing.note) || (cleanupText && cleanupText !== existing.cleanup)) {
+          if (cleanupText && cleanupText !== existing.cleanup) collide(existing.id);
           const updated: ResourceEntry = {
             ...existing,
             note: noteText || existing.note,
@@ -248,6 +275,7 @@ export async function claimResource(
       }
       // A reuser may supply a missing teardown command, but cannot overwrite the owner's.
       const adoptCleanup = cleanupText && !existing.cleanup;
+      if (adoptCleanup) collide(existing.id);
       if (!existing.reusers.includes(owner) || adoptCleanup) {
         const updated: ResourceEntry = {
           ...existing,
@@ -272,6 +300,7 @@ export async function claimResource(
           `reuse R${overlap.id} and cite it, or claim a disjoint path`,
       );
     }
+    collide();
     const id = resources.reduce((max, resource) => Math.max(max, resource.id), 0) + 1;
     const resource: ResourceEntry = {
       id,

package/src/ledger/run-signals.ts

@@ -235,7 +235,11 @@ export async function confirmSolved(
     if (state.proposal.member === member) return { ok: false, reason: "the proposer cannot validate their own proposal" };
     if (revision && state.proposal.revision !== revision) return { ok: false, reason: "stale answer revision; inspect the current proposal" };
     if (state.contest) return { ok: false, reason: `the proposal was already contested by ${state.contest.member}` };
-    if (state.confirm) return { ok: true, reason: "already validated", by: state.confirm.member };
+    if (state.confirm) {
+      // The first confirmation credits the wind-down; later ones are still verification records.
+      appendEntry(hordePaths(hordeDir).board, boardEntry(member, `also validated SOLVED: ${requireText(note, "confirm-solved")}`));
+      return { ok: true, reason: "already validated", by: state.confirm.member };
+    }
     const signal: SolvedSignal = {
       member,
       text: requireText(note, "confirm-solved"),