agent-horde 0.1.3 → 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.3
+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

package/docs/REFERENCE.md

@@ -37,9 +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.
-   The default totals follow the queue, so every queued member can afford a cold first turn; the
-   phase start records the budget and `repair-end` records each attempt's turns and first-turn
-   cost. 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
@@ -181,6 +182,9 @@ from the same actor as an idempotent retry. The parent appends its own lifecycle
   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. A recipient answers with `respond`; `ack` is an
   optional first step that signals intent. Delivery is a context insertion, not
@@ -240,8 +244,8 @@ 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` | queue-sized | total repair time: one `PI_HORDE_REPAIR_MIN_MS` per queued member (max 4) plus two recheck shares; a number here is a flat total |
-| `PI_HORDE_REPAIR_TOKENS` | queue-sized | total repair tokens: one `PI_HORDE_REPAIR_MIN_TOKENS` per queued member (max 4) plus two recheck shares; a number here is a flat total |
+| `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` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-horde",
-  "version": "0.1.3",
+  "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

@@ -73,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 {
@@ -83,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;
     }
   }
@@ -94,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 {
@@ -110,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[] {
@@ -229,13 +233,17 @@ function citedWithoutLabel(text: string, id: number): boolean {
   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: paragraphs, except that each list item and table row
+ * 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.
+ * 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]));
+  return text.split(/\n\s*\n/).flatMap((paragraph) => (/^\s*(?:[-*]|\d+\.|\|)\s/m.test(paragraph) ? paragraph.split("\n") : paragraph.split(SENTENCE_BREAK)));
 }
 
 /**

package/src/collaboration-report.ts

@@ -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";

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

@@ -100,10 +100,23 @@ 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);

package/src/ledger/event-metrics.ts

@@ -3,17 +3,18 @@ import type { HordeEvent } from "./events.js";
 export interface SolvedConfirmations {
   /** Members whose confirm-solved was the one credited for a proposal revision. */
   credited: string[];
-  /** Members whose confirm-solved arrived after the credited one and changed nothing. */
-  redundant: string[];
+  /** Members who confirmed the same proposal after the credited one; their text is in the event. */
+  additional: string[];
 }
 
-/** The report shows how many members spent a confirmation on an already validated proposal. */
+/** The report names every member that confirmed the proposal, not only the one credited. */
 export function solvedConfirmations(events: HordeEvent[]): SolvedConfirmations {
-  const out: SolvedConfirmations = { credited: [], redundant: [] };
+  const out: SolvedConfirmations = { credited: [], additional: [] };
   for (const event of events) {
-    if (event.action !== "confirm-solved") continue;
-    if (event.outcome === "applied") out.credited.push(event.actor);
-    else if (event.outcome === "noop") out.redundant.push(event.actor);
+    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;
 }

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/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"),

package/src/prompt.ts

@@ -98,7 +98,8 @@ Collaboration loop:
 - Attach evidence to anyone's work: horde attach target=F# text=observation relation=supports|contradicts|extends,
   optionally artifactPath=artifacts/file. Returned E# retains the full evidence. Ownership is unnecessary.
 - horde message target=F#/A#/I#/R# kind=challenge|review-request|question|blocker|handoff|decision text=question,
-  to=member-N (default owner), refs=[E#]. Challenges/blockers default to blocking acceptance.
+  to=member-N (default owner; a request about your own work names another member), refs=[E#].
+  Challenges/blockers default to blocking acceptance.
 - Read horde inbox. Recipient: respond target=Q# revision=hash text=result; ack target=Q# text=plan first only to signal intent.
   Respond with the challenged target's current revision, not another finding's hash. For an I# resolved by
   a finding on that idea, explicitly set responseTarget=F#. Superseded F# requests follow the correction.
@@ -530,8 +531,8 @@ export interface RunReportInput extends RunSummaryInput {
   deliverable?: string | undefined;
   /** Shared resources claimed during the run, with the non-owners whose records cite each one. */
   resources?: ReportResource[] | undefined;
-  /** Members credited with validating the proposal, and those whose confirmation came after it. */
-  solvedConfirmations?: { credited: string[]; redundant: string[] } | undefined;
+  /** Members credited with validating the proposal, and those who confirmed it after that. */
+  solvedConfirmations?: { credited: string[]; additional: string[] } | undefined;
   /** Idea creations this run made, and the ones dedup folded into an existing idea. */
   ideaCreations?: { created: number; absorbed: Array<{ id: number; count: number }> } | undefined;
   /** Set when a member reported the goal answered. */
@@ -603,9 +604,9 @@ function artifactDiagnosis(input: RunReportInput): string[] {
       `- solved: ${input.solved.member} proposed the goal answered (${how}): ${oneLine(input.solved.text, 200)}`,
     );
     if (input.solvedConfirmations) {
-      const { credited, redundant } = input.solvedConfirmations;
-      const names = (members: string[]): string => (members.length ? ` (${members.join(", ")})` : "");
-      lines.push(`- confirm-solved: ${credited.length} credited${names(credited)}, ${redundant.length} redundant${names(redundant)}`);
+      const { credited, additional } = input.solvedConfirmations;
+      const also = additional.length ? `; also confirmed by ${additional.join(", ")}` : "";
+      lines.push(`- confirm-solved: ${credited.length ? `credited ${credited.join(", ")}` : "none credited"}${also}`);
     }
     lines.push("- answer: ANSWER.md (full answer text in this run directory)");
   } else if (input.solvedContested) {
@@ -770,10 +771,13 @@ function findingLine(finding: FindingEntry, input: RunReportInput): string {
   );
 }
 
+/** A finding's title is its first line; a single-paragraph finding would otherwise print its whole body as the headline. */
+const HEADLINE_CHARS = 160;
+
 function findingsSection(input: RunReportInput, supersededBy: Map<number, number>): string[] {
   const reviewRank = (cluster: FindingCluster): number => Math.max(...cluster.findings.map((f) => ({ full: 3, limited: 2, legacy: 1, disputed: 0, unreviewed: 0, superseded: 0 })[findingReviewState(f, input.scopedReviews, input.reviewMessages).status]));
   const liveClusters = input.clusters.filter((cluster) => !supersededBy.has(cluster.representative.id)).sort((a, b) => reviewRank(b) - reviewRank(a));
-  const supersededClusters = input.clusters.filter((cluster) => supersededBy.has(cluster.representative.id));
+  const superseded = input.findings.filter((finding) => supersededBy.has(finding.id));
   const lines = [
     "",
     "## Distinct findings (ranked by review status, then legacy/support ranking, then importance, " +
@@ -785,16 +789,15 @@ function findingsSection(input: RunReportInput, supersededBy: Map<number, number
     const delta =
       cluster.deltaMembers.length > 0 ? `; deltas: ${cluster.deltaMembers.join(", ")}` : "";
     lines.push(
-      `${index + 1}. ${cluster.representative.title} ` +
+      `${index + 1}. ${oneLine(cluster.representative.title, HEADLINE_CHARS)} ` +
         `(members: ${cluster.members.join(", ") || "none"}${delta}; ${cluster.findings.length} entries)`,
     );
     for (const finding of cluster.findings) lines.push(findingLine(finding, input));
   });
-  if (supersededClusters.length > 0) {
+  if (superseded.length > 0) {
     lines.push("", "## Superseded by later findings", "");
-    for (const cluster of supersededClusters) {
-      const by = supersededBy.get(cluster.representative.id);
-      lines.push(`- F${cluster.representative.id} (superseded by F${by}): ${cluster.representative.title}`);
+    for (const finding of superseded) {
+      lines.push(`- F${finding.id} (superseded by F${supersededBy.get(finding.id)}): ${oneLine(finding.title, HEADLINE_CHARS)}`);
     }
   }
   return lines;

package/src/run/repair.ts

@@ -26,18 +26,34 @@ function queueFor(launch: RunLaunch, member: MemberState): PeerMessage[] {
     .sort((a, b) => repairPriority(a) - repairPriority(b) || a.createdAt.localeCompare(b.createdAt));
 }
 
-/** Reserve shares for the other queued members and up to two correction/recheck turns. */
-export function repairShare(remaining: number, queued: number, laterRounds: number): number {
-  return Math.max(0, Math.floor(remaining / (Math.max(1, queued) + Math.min(2, Math.max(0, laterRounds)))));
+/**
+ * What a queue costs in floors: one cold session covers the administrative threads in it, and
+ * each review request or blocking challenge is an inspect/attach/review cycle of about a floor
+ * on its own. A seven-handoff queue and a one-review queue both demand one unit; a queue holding
+ * three reviews demands three, so its share is sized to the work rather than to the member.
+ */
+export function repairDemand(queue: PeerMessage[]): number {
+  const checks = queue.filter((m) => m.blocking || (m.kind === "review-request" && /^[AF]\d+$/.test(m.target))).length;
+  return Math.max(1, checks);
+}
+
+/** The reservation a share is cut from: every pending unit plus up to two correction/recheck turns. */
+function reservedUnits(pendingUnits: number, laterRounds: number): number {
+  return Math.max(1, pendingUnits) + Math.min(2, Math.max(0, laterRounds));
+}
+
+/** This attempt's share of what remains, in proportion to its demand against every pending unit. */
+export function repairShare(remaining: number, pendingUnits: number, laterRounds: number, units = 1): number {
+  return Math.max(0, Math.floor((remaining * units) / reservedUnits(pendingUnits, laterRounds)));
 }
 
 /**
  * The clock is split only among the attempts the token budget can still pay for. Reserving time
  * for members the token floor will skip anyway shrank every attempt to a share nobody could use.
  */
-export function repairTimeShare(remainingMs: number, queued: number, laterRounds: number, fundable: number): number {
-  const reserved = Math.max(1, queued) + Math.min(2, Math.max(0, laterRounds));
-  return Math.max(0, Math.floor(remainingMs / Math.min(reserved, Math.max(1, fundable))));
+export function repairTimeShare(remainingMs: number, pendingUnits: number, laterRounds: number, fundable: number, units = 1): number {
+  const divisor = Math.min(reservedUnits(pendingUnits, laterRounds), Math.max(1, fundable));
+  return Math.max(0, Math.min(remainingMs, Math.floor((remainingMs * units) / divisor)));
 }
 
 /**
@@ -64,8 +80,8 @@ export function repairFloors(): RepairFloors {
   };
 }
 
-/** Queued members a default budget funds at the floor; the overrides name flat totals instead. */
-const FUNDED_ATTEMPTS = 4;
+/** Demand units a default budget funds at the floor; the overrides name flat totals instead. */
+const FUNDED_UNITS = 6;
 
 export interface RepairBudget {
   tokens: number;
@@ -76,18 +92,20 @@ export interface RepairBudget {
 }
 
 /**
- * Totals follow the queue: one floor per queued member up to `FUNDED_ATTEMPTS`, plus the two
- * correction/recheck shares that `repairShare` reserves for later rounds, unless
- * `PI_HORDE_REPAIR_TOKENS` or `PI_HORDE_REPAIR_MS` names a flat total. A flat 50k tokens funded
- * two attempts in an eight-member run and skipped six members with queued work.
+ * Totals follow the queues: one floor per demand unit across the queued members up to
+ * `FUNDED_UNITS`, plus the two correction/recheck shares that `repairShare` reserves for later
+ * rounds, unless `PI_HORDE_REPAIR_TOKENS` or `PI_HORDE_REPAIR_MS` names a flat total. A flat 50k
+ * tokens funded two attempts in an eight-member run and skipped six members with queued work;
+ * one floor per member gave a one-review verifier and a seven-thread owner the same 60 seconds.
  */
-export function repairBudget(queued: number, floors: RepairFloors, rounds: number): RepairBudget {
-  const funded = Math.min(Math.max(1, queued), FUNDED_ATTEMPTS) + Math.min(2, Math.max(0, rounds - 1));
+export function repairBudget(demands: number[], floors: RepairFloors, rounds: number): RepairBudget {
+  const units = demands.reduce((sum, demand) => sum + demand, 0);
+  const funded = Math.min(Math.max(1, units), FUNDED_UNITS) + Math.min(2, Math.max(0, rounds - 1));
   return {
     tokens: Math.max(0, envNumber("PI_HORDE_REPAIR_TOKENS", floors.tokens * funded)),
     ms: Math.max(0, envNumber("PI_HORDE_REPAIR_MS", floors.ms * funded)),
     turns: Math.max(1, envNumber("PI_HORDE_REPAIR_TURNS", 40)),
-    queued,
+    queued: demands.length,
   };
 }
 
@@ -155,7 +173,7 @@ async function repairMember(launch: RunLaunch, member: MemberState, deadline: nu
   const timeout = setTimeout(() => halt("time"), Math.max(1, deadline - Date.now()));
   const watchdog = setInterval(check, 100);
   try {
-    await recordEvent({ ...ctx, attempt: member.attempt }, "repair-start", { payload: { messages: queue.map((m) => m.id), prior, allowance, floors } });
+    await recordEvent({ ...ctx, attempt: member.attempt }, "repair-start", { payload: { messages: queue.map((m) => m.id), demand: repairDemand(queue), prior, allowance, floors } });
     if (stopReason(launch) || Date.now() >= deadline) {
       halt(stopReason(launch) ?? "time");
       member.status = "stopped";
@@ -209,37 +227,44 @@ async function runRepairRounds(launch: RunLaunch, begin: (budget: RepairBudget)
   if (rounds === 0 || stopReason(launch)) return;
   const floors = repairFloors();
   await scheduleCollaboration(launch, { settleMs: 0, liveOnly: false });
-  const budget = repairBudget(eligibleMembers(launch).length, floors, rounds);
+  const budget = repairBudget(eligibleMembers(launch).map((entry) => repairDemand(entry.queue)), floors, rounds);
   if (budget.queued === 0) return;
   const deadline = Date.now() + budget.ms;
   const exhausted = () => stopReason(launch) || Date.now() >= deadline || (run.repairTokens ?? 0) >= budget.tokens;
   for (let round = 0; round < rounds; round++) {
     if (exhausted()) return;
     if (round > 0) await scheduleCollaboration(launch, { settleMs: 0, liveOnly: false });
-    const eligible = eligibleMembers(launch);
-    if (!eligible.length) return;
-    // Sequential attempts preserve owner -> reviewer ordering while reserving others' shares.
-    for (let index = 0; index < eligible.length; index++) {
+    // One attempt per member per round, picked in priority order re-read before each attempt:
+    // a thread that became blocking during an attempt moves its recipient ahead of the
+    // administrative queues that were ordered first at round start.
+    const served = new Set<string>();
+    for (;;) {
       if (exhausted()) return;
-      const pending = eligible.slice(index).filter(({ member }) => queueFor(launch, member).length);
+      const pending = eligibleMembers(launch).filter((entry) => !served.has(entry.member.name));
+      if (!pending.length) break;
+      const next = pending[0]!;
+      const pendingUnits = pending.reduce((sum, entry) => sum + repairDemand(entry.queue), 0);
+      const units = repairDemand(next.queue);
+      const unserved = pending.map((entry) => entry.member);
       const remaining = budget.tokens - (run.repairTokens ?? 0);
       const laterRounds = rounds - round - 1;
-      const tokens = repairAllowance(repairShare(remaining, pending.length, laterRounds), remaining, floors.tokens);
+      const tokens = repairAllowance(repairShare(remaining, pendingUnits, laterRounds, units), remaining, floors.tokens);
       if (tokens === undefined) {
         await begin(budget);
-        await recordSkipped(launch, pending.map((entry) => entry.member), "insufficient-budget", { remaining, floor: floors.tokens });
+        await recordSkipped(launch, unserved, "insufficient-budget", { remaining, floor: floors.tokens });
         return;
       }
       const remainingMs = Math.max(0, deadline - Date.now());
       const fundable = Math.floor(remaining / Math.max(1, floors.tokens));
-      const ms = repairAllowance(repairTimeShare(remainingMs, pending.length, laterRounds, fundable), remainingMs, floors.ms);
+      const ms = repairAllowance(repairTimeShare(remainingMs, pendingUnits, laterRounds, fundable, units), remainingMs, floors.ms);
       if (ms === undefined || ms < 1) {
         await begin(budget);
-        await recordSkipped(launch, pending.map((entry) => entry.member), "insufficient-time", { remainingMs, floorMs: floors.ms });
+        await recordSkipped(launch, unserved, "insufficient-time", { remainingMs, floorMs: floors.ms });
         return;
       }
       await begin(budget);
-      await repairMember(launch, eligible[index]!.member, Date.now() + ms, { tokens, turns: budget.turns }, floors);
+      served.add(next.member.name);
+      await repairMember(launch, next.member, Date.now() + ms, { tokens, turns: budget.turns }, floors);
     }
   }
 }

package/src/run-graph.ts

@@ -284,7 +284,8 @@ function solvedHandler(label: string, tone: EdgeTone): Handler {
       draft.lastSolved = marker;
       return;
     }
-    if (draft.lastSolved) draft.edges.push({ from: marker, to: draft.lastSolved, label: event.outcome === "noop" ? `${label} (redundant)` : label, tone });
+    const additional = result.confirmation === "additional";
+    if (draft.lastSolved) draft.edges.push({ from: marker, to: draft.lastSolved, label: additional ? `${label} (additional)` : label, tone });
   };
 }
 
@@ -494,7 +495,7 @@ function addRefused(draft: Draft, event: HordeEvent): void {
   addEdge(draft, marker, refusedTarget(event.action, input), event.action, "negative");
 }
 
-/** A no-op that still names a result (a duplicate idea, a redundant confirmation) is a repeat, not a refusal. */
+/** A no-op that still names a result (a duplicate idea) is a repeat, not a refusal. */
 function isRepeat(event: HordeEvent): boolean {
   return event.outcome === "noop" && record(event.payload.result).noop === true;
 }

package/src/tool/actions.ts

@@ -13,7 +13,7 @@ import { validateFindingResourceCitations } from "../citations.js";
 import { idleHint } from "./hints.js";
 import type { HordeToolParams } from "./params.js";
 import { COLLABORATION_ACTIONS, runCollaborationAction } from "./collaboration-actions.js";
-import { recordEvent } from "../ledger/events.js";
+import { readEvents, recordEvent } from "../ledger/events.js";
 import type { EventContext } from "../ledger/events.js";
 
 const CLEAN_STOP_NOTICE =
@@ -30,8 +30,10 @@ const WORK_PLAN_POST =
 interface ActionResult {
   text: string;
   id?: number;
-  /** True when the call changed nothing: a duplicate idea, or a confirmation after the credited one. */
+  /** True when the call changed nothing, such as a duplicate idea. */
   noop?: boolean;
+  /** For confirm-solved: whether this confirmation validated the proposal or joined an earlier one. */
+  confirmation?: "credited" | "additional";
 }
 
 interface ActionContext {
@@ -52,6 +54,20 @@ function requireId(params: HordeToolParams): number {
   return params.id;
 }
 
+/** The result line of a closed idea: `text`, or `note` when a member reached for that field instead. */
+function closeNote(params: HordeToolParams): string | undefined {
+  return params.text ?? params.note;
+}
+
+/** The member whose `idea` write created #id in this run, from the event log; undefined outside a run. */
+function ideaAuthor(hordeDir: string, runId: string | undefined, id: number): string | undefined {
+  if (!runId) return undefined;
+  const created = readEvents(hordeDir, runId).find(
+    (event) => event.action === "idea" && event.outcome === "applied" && (event.payload.result as { id?: unknown } | undefined)?.id === id,
+  );
+  return created?.actor;
+}
+
 function requireRun(ctx: ActionContext): string {
   if (!ctx.runId) throw new Error(`horde: ${ctx.params.action} needs an active run`);
   return ctx.runId;
@@ -283,6 +299,7 @@ async function claimAction({ hordeDir, member, params }: ActionContext): Promise
 
 async function resourceAction(ctx: ActionContext): Promise<ActionResult> {
   const { hordeDir, member, params, runId } = ctx;
+  if ((params.text ?? "").trim() === "") throw new Error("horde: resource needs its name in text (note holds the reuse pointer)");
   const { resource, reused, ownedByCaller } = await claimResource(hordeDir, member, {
     name: params.text,
     note: params.note,
@@ -341,9 +358,15 @@ 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);
   if (!answer.ok) throw new Error(`horde: ${answer.reason}`);
-  if (answer.reason !== "validated") return { text: `The SOLVED proposal was already validated by ${answer.by}.`, noop: true };
+  if (answer.reason !== "validated") {
+    return {
+      text: `Recorded your confirmation; the proposal was already validated by ${answer.by}. Finish your claimed work.`,
+      confirmation: "additional",
+    };
+  }
   return {
     text: "Validated the SOLVED proposal. Finish your claimed work; the parent will wind down once any coverage requirement is satisfied.",
+    confirmation: "credited",
   };
 }
 
@@ -357,19 +380,20 @@ async function contestSolvedAction(ctx: ActionContext): Promise<ActionResult> {
 
 async function doneAction(ctx: ActionContext): Promise<ActionResult> {
   const { hordeDir, member, params } = ctx;
-  const idea = await finishIdea(hordeDir, member, requireId(params), params.text);
+  const idea = await finishIdea(hordeDir, member, requireId(params), closeNote(params));
   return closedIdea(ctx, idea, `Done #${idea.id}: ${idea.text}`);
 }
 
 async function dropAction(ctx: ActionContext): Promise<ActionResult> {
-  const { hordeDir, member, params } = ctx;
-  const idea = await dropIdea(hordeDir, member, requireId(params), params.text);
+  const { hordeDir, member, params, runId } = ctx;
+  const id = requireId(params);
+  const idea = await dropIdea(hordeDir, member, id, closeNote(params), { author: ideaAuthor(hordeDir, runId, id) });
   return closedIdea(ctx, idea, `Dropped #${idea.id}: ${idea.text}`);
 }
 
 async function ruleOutAction(ctx: ActionContext): Promise<ActionResult> {
   const { hordeDir, member, params } = ctx;
-  const idea = await ruleOutIdea(hordeDir, member, requireId(params), params.text);
+  const idea = await ruleOutIdea(hordeDir, member, requireId(params), closeNote(params));
   return closedIdea(ctx, idea, `Ruled out #${idea.id}: ${idea.note ?? "dead end"}`);
 }
 

package/src/tool/collaboration-actions.ts

@@ -22,12 +22,31 @@ interface CollaborationCommand {
 function evidenceRefs(state: CollaborationState, refs: string[] = []): string[] {
   for (const id of refs) {
     if (state.evidence.some((e) => e.id === id)) continue;
+    // A review is the record members most want to cite; it already names the evidence it rests on.
+    const review = state.reviews.find((r) => r.id === id);
+    if (review) throw new Error(`horde: ${id} is a review, not evidence; cite its evidence instead: ${review.evidence.join(", ") || "none recorded"}`);
+    // Evidence ids share the event counter, so the E# of the event that recorded V#, A# or Q# is
+    // the guess a member makes when it knows the record but not its evidence.
+    const recorded = recordedAtEvent(state, id);
+    if (recorded) throw new Error(`horde: ${id} is the event that recorded ${recorded.id}, not evidence; ${recorded.hint}`);
     const kind = /^[A-Z]\d+$/.test(id) && !id.startsWith("E") ? `; ${id} is not evidence, refs take E# ids (attach evidence first, or name ${id} as the target)` : "";
     throw new Error(`horde: unknown evidence ${id}${kind}`);
   }
   return refs;
 }
 
+function recordedAtEvent(state: CollaborationState, id: string): { id: string; hint: string } | undefined {
+  const seq = /^E(\d+)$/.exec(id)?.[1];
+  if (!seq) return undefined;
+  const review = state.reviews.find((r) => r.id === `V${seq}`);
+  if (review) return { id: review.id, hint: `cite ${review.id}'s evidence instead: ${review.evidence.join(", ") || "none recorded"}` };
+  const artifact = state.artifacts.find((a) => a.id === `A${seq}`);
+  if (artifact) return { id: artifact.id, hint: `attach evidence to ${artifact.id} first, or name ${artifact.id} as the target` };
+  const message = state.messages.find((m) => m.id === `Q${seq}`);
+  if (message) return { id: message.id, hint: `cite the evidence on ${message.id} instead: ${[...message.evidence, ...(message.responseEvidence ?? [])].join(", ") || "none recorded"}` };
+  return undefined;
+}
+
 /** Name the stale ref and both revisions, so a retry does not have to guess which evidence to replace. */
 function staleEvidence(state: CollaborationState, refs: string[], target: string, revision: string): string | undefined {
   const stale = refs.map((id) => state.evidence.find((e) => e.id === id)).find((e) => e && (e.target !== target || e.revision !== revision));
@@ -43,6 +62,8 @@ function newMessage(c: CollaborationCommand): EventDraft {
   const task = path.join(ctx.hordeDir, "runs", ctx.runId, "TASK.md");
   const count = fs.existsSync(task) ? Number(/^Members: (\d+)/m.exec(fs.readFileSync(task, "utf8"))?.[1]) : 0;
   if (!/^member-[1-9]\d*$/.test(to) || (count && Number(to.slice(7)) > count)) throw new Error("horde: recipient must be a member of this run");
+  // The recipient defaults to the target's owner, which is the sender itself on its own work.
+  if (to === ctx.actor) throw new Error(`horde: a message cannot be addressed to its sender; ${target} is yours, name another member with to=member-N`);
   if (p.revision && p.revision !== info.revision) throw new Error("horde: target changed; inspect current revision");
   const message: PeerMessage = {
     id: `Q${seq}`, sender: ctx.actor, to, target, revision: info.revision, kind: p.kind ?? "question",
@@ -175,7 +196,29 @@ function recordReview(c: CollaborationCommand): EventDraft {
     verdict: p.verdict, support: p.support, checked, unchecked: p.unchecked,
     text, evidence: refs },
     ...completeAssignedReview(c, target, `V${seq}`, text, refs),
-    ...(["refutes", "partially-supports"].includes(p.verdict) ? automaticChallenge(c, target, info, text, refs) : {}) }, parents: refs.filter((id) => id !== evidenceRecord?.id) };
+    ...(["refutes", "partially-supports"].includes(p.verdict) ? automaticChallenge(c, target, info, text, refs) : {}),
+    ...(p.verdict === "supports" && !p.unchecked.trim() ? coverageClearance(c, target, info, `V${seq}`, refs) : {}) }, parents: refs.filter((id) => id !== evidenceRecord?.id) };
+}
+
+/** The challenge a partially-supports review raised in its own event, as opposed to an objection a member wrote. */
+function coverageChallenge(state: CollaborationState, message: PeerMessage): boolean {
+  return state.reviews.some((r) => r.id === `V${message.id.slice(1)}` && r.actor === message.sender && r.verdict === "partially-supports");
+}
+
+/**
+ * A partial review opens a blocking challenge that only its sender may resolve. When that review
+ * contradicted nothing and another member later supports the whole revision, the unchecked scope
+ * is covered: the full review clears the challenge, and the resolution names both reviews.
+ */
+function coverageClearance(c: CollaborationCommand, target: string, info: { revision: string }, reviewId: string, refs: string[]): Record<string, unknown> {
+  const cleared = c.state.messages.filter((m) =>
+    m.target === target && m.revision === info.revision && m.blocking && m.state !== "resolved" && m.sender !== c.ctx.actor && coverageChallenge(c.state, m));
+  if (!cleared.length) return {};
+  return { clearances: cleared.map((m) => ({
+    id: m.id,
+    text: `cleared by ${reviewId}: ${c.ctx.actor}'s full-scope supporting review of ${target}@${info.revision.slice(0, 12)} covers the scope V${m.id.slice(1)} left unchecked`,
+    refs,
+  })) };
 }
 
 /** The parent's assignment closes with the review id and its evidence, so the thread shows what decided it. */

package/src/tool/collaboration-target.ts

@@ -59,7 +59,12 @@ export function retainArtifact(ctx: EventContext, file: string): { path: string;
   const runDir = path.join(ctx.hordeDir, "runs", ctx.runId);
   const root = fs.realpathSync(path.join(runDir, "artifacts"));
   const candidate = path.isAbsolute(file) ? file : path.join(runDir, file);
-  const real = fs.realpathSync(candidate);
+  let real: string;
+  try {
+    real = fs.realpathSync(candidate);
+  } catch {
+    throw new Error(`horde: artifactPath not found: ${file}; artifacts live under runs/${ctx.runId}/artifacts/`);
+  }
   if (!real.startsWith(root + path.sep) || !fs.statSync(real).isFile()) throw new Error("horde: evidence must be a file inside this run's artifacts directory");
   const bytes = fs.readFileSync(real);
   const hash = hashText(bytes);

package/src/tool/params.ts

@@ -75,7 +75,11 @@ export const HordeParams = Type.Object({
     }),
   ),
   note: Type.Optional(
-    Type.String({ description: "For a resource: a short pointer (path, command, or fact id) others should reuse" }),
+    Type.String({
+      description:
+        "For a resource: a short pointer (path, command, or fact id) others should reuse. For done/drop/rule-out: " +
+        "the result line, when text is not given",
+    }),
   ),
   cleanup: Type.Optional(
     Type.String({