agent-horde 0.1.3 → 0.1.5

package/src/dashboard.ts

@@ -29,6 +29,7 @@ import {
   renderClaims,
   renderCollaboration,
   renderError,
+  renderExportStart,
   renderFacts,
   renderFile,
   renderFindings,
@@ -45,8 +46,12 @@ import {
   renderTranscriptEntry,
 } from "./dashboard-html.js";
 import type { RenderContext } from "./dashboard-html.js";
+import { collect, exportDashboard } from "./dashboard-export.js";
+import type { ExportPage } from "./dashboard-export.js";
 
 const DEFAULT_PORT = 7433;
+const EXPORT_PAGE = "/export";
+const EXPORT_PATH = "/export.zip";
 const REFRESH_SECONDS = 3;
 const MAX_URL_LENGTH = 4096;
 const CLOSE_GUARD_MS = 2_000;
@@ -57,6 +62,8 @@ interface DashboardResponse {
   contentType: string;
   body: string;
   headers: Record<string, string>;
+  /** Written after the headers in place of `body`, as it is produced. */
+  stream?: AsyncIterable<Buffer> | undefined;
 }
 
 interface Route {
@@ -282,6 +289,12 @@ function respond(status: number, contentType: string, body: string, extra: Recor
   return { status, contentType, body, headers: { ...baseHeaders(), ...extra } };
 }
 
+/** A same-origin dashboard path, else `/`; the export page returns here. */
+function backPath(query: URLSearchParams): string {
+  const back = query.get("back") ?? "/";
+  return /^\/(?![/\\])[^\s]{0,2000}$/.test(back) ? back : "/";
+}
+
 function parentPath(pathname: string): string {
   const trimmed = pathname.replace(/\/+$/, "");
   const parent = trimmed.slice(0, trimmed.lastIndexOf("/"));
@@ -316,24 +329,33 @@ function routeMatch(pathname: string): { route: Route; params: string[] } | unde
   return undefined;
 }
 
-function handleRoute(src: DashboardSource, url: URL, json: boolean, ctx: RenderContext): DashboardResponse {
+/** The run this page belongs to, and the run the nav's collaboration and graph links target. */
+function runContext(src: DashboardSource, url: URL, params: string[]): Pick<RenderContext, "runId" | "navRun"> {
+  const runId = RUN_ID_RE.test(params[0] ?? "") ? params[0] : undefined;
+  const filterRun = url.searchParams.get("run");
+  const navRun = runId ?? (filterRun && RUN_ID_RE.test(filterRun) ? filterRun : undefined) ?? latestRunId(src);
+  return { runId, navRun };
+}
+
+/** The export costs seconds of work per request, so pages from other sites may not start one. */
+function handleRoute(src: DashboardSource, url: URL, json: boolean, ctx: RenderContext, crossSite: boolean): DashboardResponse {
   const pathname = json ? url.pathname.slice("/api".length) || "/" : url.pathname;
+  if (!json && (pathname === EXPORT_PATH || pathname === EXPORT_PAGE)) {
+    if (crossSite) return errorResponse(403, "the export can only be started from the dashboard itself", url, json, ctx);
+    if (pathname === EXPORT_PATH) return exportResponse(src, url, ctx);
+    return respond(200, "text/html; charset=utf-8", renderExportStart(EXPORT_PATH, backPath(url.searchParams), ctx));
+  }
   const matched = routeMatch(pathname);
   if (!matched) throw new DashboardError(404, `no such page: ${pathname}`);
   const { route, params } = matched;
   const refreshParam = queryEnum(url.searchParams, "refresh", ["0", String(REFRESH_SECONDS)] as const, String(REFRESH_SECONDS));
   const vm = route.load(src, params, url.searchParams);
   if (json) return respond(200, "application/json; charset=utf-8", JSON.stringify(vm));
-  const runId = RUN_ID_RE.test(params[0] ?? "") ? params[0] : undefined;
-  const filterRun = url.searchParams.get("run");
-  const navRun = runId ?? (filterRun && RUN_ID_RE.test(filterRun) ? filterRun : undefined) ?? latestRunId(src);
   const live = route.live(vm, src, params, url.searchParams);
   const on = live && refreshParam !== "0";
   const pageCtx: RenderContext = {
     ...ctx,
-    runId,
-    navRun,
-    href: url.pathname + url.search,
+    ...runContext(src, url, params),
     refresh: live ? { on, toggleHref: refreshToggle(url, on), seconds: REFRESH_SECONDS } : undefined,
   };
   const body = route.render(vm as never, pageCtx);
@@ -341,17 +363,68 @@ function handleRoute(src: DashboardSource, url: URL, json: boolean, ctx: RenderC
   return respond(200, "text/html; charset=utf-8", body);
 }
 
-/** Pure request handler: validates method and host, dispatches, maps errors to responses. */
-export function routeRequest(src: DashboardSource, method: string, url: URL, host: string | undefined): DashboardResponse {
+/** One page of the static export; errors become pages so no exported link dangles. */
+function exportPage(src: DashboardSource, url: URL): ExportPage {
+  const ctx: RenderContext = { activeId: src.getActive()?.id, href: url.pathname + url.search, export: true };
+  try {
+    const matched = routeMatch(url.pathname);
+    if (!matched) throw new DashboardError(404, `no such page: ${url.pathname}`);
+    const { route, params } = matched;
+    const vm = route.load(src, params, url.searchParams);
+    return { body: route.render(vm as never, { ...ctx, ...runContext(src, url, params) }), text: route.text };
+  } catch (error) {
+    const status = error instanceof DashboardError ? error.status : 500;
+    const message = error instanceof DashboardError ? error.message : `dashboard error: ${error instanceof Error ? error.message : String(error)}`;
+    return { body: renderError(status, message, parentPath(url.pathname), ctx) };
+  }
+}
+
+/** The whole dashboard as a zip of static pages, streamed as it is built, named for the moment it was taken. */
+export function exportDashboardArchive(src: DashboardSource, now = new Date()): { filename: string; zip: AsyncGenerator<Buffer> } {
+  const folder = `horde-dashboard-${now.toISOString().slice(0, 19).replace(/[T:]/g, "-")}`;
+  return { filename: `${folder}.zip`, zip: exportDashboard((url) => exportPage(src, url), folder, now) };
+}
+
+/** The finished archive in one buffer. */
+export async function exportDashboardBuffer(src: DashboardSource, now = new Date()): Promise<{ filename: string; zip: Buffer }> {
+  const { filename, zip } = exportDashboardArchive(src, now);
+  return { filename, zip: await collect(zip) };
+}
+
+let exporting = false;
+
+/** Marks the export busy from its first chunk until the stream ends or its reader goes away. */
+async function* exclusive(stream: AsyncIterable<Buffer>): AsyncGenerator<Buffer> {
+  exporting = true;
+  try {
+    yield* stream;
+  } finally {
+    exporting = false;
+  }
+}
+
+/** Headers go out at once so the browser shows the download while the pages are still being packed; one at a time. */
+function exportResponse(src: DashboardSource, url: URL, ctx: RenderContext): DashboardResponse {
+  if (exporting) return errorResponse(503, "an export is already in progress; wait for it to finish", url, false, ctx);
+  const { filename, zip } = exportDashboardArchive(src);
+  return { ...respond(200, "application/zip", "", { "Content-Disposition": `attachment; filename="${filename}"` }), stream: exclusive(zip) };
+}
+
+/** Pure request handler: validates method and host, dispatches, maps errors to responses. `fetchSite` is the Sec-Fetch-Site header. */
+export function routeRequest(src: DashboardSource, method: string, url: URL, host: string | undefined, fetchSite?: string): DashboardResponse {
   const json = url.pathname === "/api" || url.pathname.startsWith("/api/");
-  const ctx: RenderContext = { activeId: src.getActive()?.id, origin: host ? `http://${host}` : undefined };
+  const ctx: RenderContext = {
+    activeId: src.getActive()?.id,
+    origin: host ? `http://${host}` : undefined,
+    href: url.pathname + url.search,
+  };
   try {
     if (method !== "GET" && method !== "HEAD") {
       return { ...errorResponse(405, `method ${method} not allowed`, url, json, ctx), headers: { ...baseHeaders(), Allow: "GET, HEAD" } };
     }
     if (!host || !HOST_RE.test(host)) return errorResponse(403, "host must be 127.0.0.1 or localhost", url, json, ctx);
     if (url.href.length > MAX_URL_LENGTH) return errorResponse(414, "url too long", url, json, ctx);
-    return handleRoute(src, url, json, ctx);
+    return handleRoute(src, url, json, ctx, fetchSite === "cross-site");
   } catch (error) {
     if (error instanceof DashboardError) return errorResponse(error.status, error.message, url, json, ctx);
     const message = error instanceof Error ? error.message : String(error);
@@ -383,12 +456,41 @@ function listenError(error: NodeJS.ErrnoException, port: number): Error {
   return new Error(`dashboard could not listen on ${port}: ${error.message}`);
 }
 
+const drained = (res: http.ServerResponse): Promise<void> =>
+  new Promise((resolve) => {
+    const done = (): void => {
+      res.off("drain", done);
+      res.off("close", done);
+      resolve();
+    };
+    res.once("drain", done);
+    res.once("close", done);
+  });
+
+/** Writes the chunks as they come, pausing for the client; a failure mid-stream cuts the connection. */
+async function streamBody(res: http.ServerResponse, stream: AsyncIterable<Buffer>): Promise<void> {
+  try {
+    for await (const chunk of stream) {
+      if (res.destroyed) return;
+      if (!res.write(chunk)) await drained(res);
+    }
+    res.end();
+  } catch (error) {
+    res.destroy(error instanceof Error ? error : new Error(String(error)));
+  }
+}
+
 function serve(src: DashboardSource, req: http.IncomingMessage, res: http.ServerResponse): void {
   req.resume();
   res.on("error", () => {});
   const url = new URL(req.url ?? "/", "http://127.0.0.1");
-  const response = routeRequest(src, req.method ?? "GET", url, req.headers.host);
+  const fetchSite = req.headers["sec-fetch-site"];
+  const response = routeRequest(src, req.method ?? "GET", url, req.headers.host, Array.isArray(fetchSite) ? fetchSite[0] : fetchSite);
   res.writeHead(response.status, { ...response.headers, "Content-Type": response.contentType });
+  if (response.stream && req.method !== "HEAD") {
+    void streamBody(res, response.stream);
+    return;
+  }
   res.end(response.body);
 }
 

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"}`);
 }