agent-horde 0.2.0 → 0.3.0

package/src/prompt.ts

@@ -1,4 +1,4 @@
-import { formatClock, formatDateTime, formatElapsed, formatTokens, oneLine, taskHash } from "./format.js";
+import { formatClock, formatDateTime, formatElapsed, formatTokens, formatUsd, oneLine, taskHash } from "./format.js";
 import type { BoardEntry } from "./ledger/board.js";
 import type { ClaimEntry } from "./ledger/claims.js";
 import type { FindingCluster } from "./ledger/clusters.js";
@@ -26,6 +26,8 @@ export interface RunSummaryInput {
   userStop?: boolean | undefined;
   /** Human-readable stop reason, e.g. "stopped by user" or "stopped at deadline". */
   stopLabel?: string | undefined;
+  /** The `--budget` in dollars the run (or its swarm) clean-stops at. */
+  budget?: number | undefined;
   /** Set when a member reported the goal solved; the end sentence states whether the run wound down on it. */
   solved?: SolvedSignal | undefined;
   /** The other member that validated the proposal, if any. */
@@ -34,6 +36,8 @@ export interface RunSummaryInput {
   solvedCommitted?: boolean | undefined;
   /** Members whose queued repair work was skipped for budget. */
   repairSkipped?: string[] | undefined;
+  /** Members held back from later rounds because their attempt left every thread unchanged. */
+  repairStalled?: string[] | undefined;
   /** The REPORT.md outcome, so SUMMARY.md states the same end cause. */
   outcome?: string | undefined;
   /** One-line run diagnosis shown in the report message. */
@@ -126,6 +130,8 @@ Collaboration loop:
   a finding on that idea, explicitly set responseTarget=F#. Superseded F# requests follow the correction.
   Requester: attach/review evidence on the current response target, then resolve target=Q# refs=[E#]
   revision=current-hash text=decision, or defer with a reason. Disclosed finding limitations remain debt.
+  A blocking request about your own work resolves on the recipient's full supporting review of the
+  current revision, since you cannot review it yourself.
   Do not repeat your existing check: inspect collaboration first and test a specific remaining gap.
   A deferred blocking issue stays visible as acceptance debt; its recipient can still respond to it and
   the requester then resolves it. Never silently ignore a peer's failed test.
@@ -273,7 +279,8 @@ Protocol:
     proposal reopens for validation once every idea it named is done or ruled out. Pass the revision
     from ANSWER.md or 'horde inspect' target=answer to either action, so stale reviews cannot approve
     a newer proposal. An answer that cites a superseded F# or quotes a provisional T# is refused, and a
-    pending proposal is withdrawn for re-proposal when a finding it cites is superseded. A request to
+    pending proposal is withdrawn for re-proposal when a finding it cites is superseded or amended,
+    or an artifact it cites is republished. A request to
     the proposer or a validator about the pending answer (target=answer) is served with the blockers.
     The parent enforces coverage before wind-down.
 
@@ -294,10 +301,16 @@ export function taskMarkdown(input: {
   startedAt: number;
   verifier?: string | undefined;
   untilStop?: boolean | undefined;
+  /** `--budget` in dollars; a swarm's budget covers every horde. */
+  budget?: number | undefined;
   /** Set for a horde of a larger swarm: which horde this is and its workstream. */
   swarm?: { id: string; horde: number; hordes: number; slice?: string | undefined } | undefined;
 }): string {
   const swarm = input.swarm;
+  const budget =
+    input.budget === undefined
+      ? "none"
+      : `${formatUsd(input.budget)} (the run clean-stops when member spend${swarm ? " across the swarm" : ""} reaches it)`;
   return [
     `# Horde run ${input.id}`,
     "",
@@ -307,6 +320,7 @@ export function taskMarkdown(input: {
     `Thinking: ${input.thinkingLevel ?? "parent default"}`,
     `Verifier: ${input.verifier ?? "none"}`,
     `Until stop: ${input.untilStop ? "yes (the run continues until stop-clean or stop-hard)" : "no"}`,
+    `Budget: ${budget}`,
     ...(swarm ? [`Swarm: ${swarm.id} (horde h${swarm.horde} of ${swarm.hordes})`] : []),
     ...(swarm?.slice ? [`Workstream: ${swarm.slice}`] : []),
     `Task-SHA256: ${taskHash(input.prompt)}`,
@@ -326,6 +340,8 @@ interface TaskInfo {
   model?: string | undefined;
   thinking?: string | undefined;
   hash?: string | undefined;
+  /** The `--budget` in dollars, when the run was started with one. */
+  budget?: number | undefined;
   prompt: string;
 }
 
@@ -337,13 +353,17 @@ export function parseTaskMarkdown(content: string): TaskInfo {
   for (const line of lines.slice(0, promptAt === -1 ? lines.length : promptAt)) {
     const title = /^# Horde run (\S+)$/.exec(line);
     if (title) info.id = title[1];
-    const field = /^(Started|Members|Model|Thinking|Task-SHA256): (.*)$/.exec(line);
+    const field = /^(Started|Members|Model|Thinking|Budget|Task-SHA256): (.*)$/.exec(line);
     if (!field) continue;
     const value = field[2] ?? "";
     if (field[1] === "Started") info.started = value;
     else if (field[1] === "Members") info.count = Number(/^\d+/.exec(value)?.[0] ?? NaN) || undefined;
     else if (field[1] === "Model") info.model = value;
     else if (field[1] === "Thinking") info.thinking = value;
+    else if (field[1] === "Budget") {
+      const amount = Number(/^\$(\d+(?:\.\d+)?)/.exec(value)?.[1] ?? NaN);
+      if (amount > 0) info.budget = amount;
+    }
     else if (field[1] === "Task-SHA256") info.hash = value;
   }
   return info;
@@ -369,13 +389,14 @@ export interface UsageTotals {
   cost: number;
 }
 
+/** Run totals over every session each member has had; turns count the current sessions only. */
 export function totalUsage(members: MemberState[]): UsageTotals {
   return members.reduce(
     (acc, m) => ({
       turns: acc.turns + m.turns,
-      input: acc.input + m.usage.input,
-      output: acc.output + m.usage.output,
-      cost: acc.cost + m.usage.cost,
+      input: acc.input + m.lifetime.input,
+      output: acc.output + m.lifetime.output,
+      cost: acc.cost + m.lifetime.cost,
     }),
     { turns: 0, input: 0, output: 0, cost: 0 },
   );
@@ -462,10 +483,12 @@ export function runEndSentence(run: RunSummaryInput): string {
   const attempts = run.members.reduce((n, m) => n + (m.repairs ?? 0), 0);
   const killed = run.members.filter((m) => ["tokens", "turns", "time"].includes(m.repairStopReason ?? ""));
   const skipped = run.repairSkipped ?? [];
+  const stalled = run.repairStalled ?? [];
   if (attempts > 0 || skipped.length > 0) {
     const detail = [
       killed.length ? `${killed.length} killed on budget (${killed.map((m) => `${m.name}: ${m.repairStopReason}`).join(", ")})` : "",
       skipped.length ? `${skipped.length} skipped for budget (${skipped.join(", ")})` : "",
+      stalled.length ? `${stalled.length} held after no progress (${stalled.join(", ")})` : "",
     ].filter(Boolean).join(", ");
     parts.push(`Repair: ${attempts} attempt(s)${detail ? `, ${detail}` : ""}.`);
   }
@@ -579,6 +602,9 @@ export function formatStatusReport(run: RunSummaryInput, now: number = Date.now(
     const left = Math.max(0, Math.ceil((run.cleanStopUntil - now) / 1000));
     lines.push(`clean stop requested: members wrap up now, hard stop in ${left}s`);
   }
+  if (run.budget !== undefined) {
+    lines.push(`budget: ${formatUsd(totalUsage(run.members).cost)} of ${formatUsd(run.budget)} spent`);
+  }
   for (const m of run.members) {
     lines.push(
       `${m.name.padEnd(10)} ${m.status.padEnd(8)} ${memberActivity(m)}  ` +
@@ -646,7 +672,8 @@ function reportHeader(input: RunReportInput, now: number): string[] {
   if (input.model) lines.push(`Model: ${input.model}`);
   lines.push(
     `Usage: ${usage.turns} turns, ${formatTokens(usage.input)} in / ` +
-      `${formatTokens(usage.output)} out, $${usage.cost.toFixed(4)} cost`,
+      `${formatTokens(usage.output)} out, $${usage.cost.toFixed(4)} cost` +
+      (input.budget === undefined ? "" : ` (budget ${formatUsd(input.budget)})`),
   );
   return lines;
 }

package/src/run/budget.ts

@@ -0,0 +1,30 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { formatUsd } from "../format.js";
+import { totalUsage } from "../prompt.js";
+import { requestCleanStop } from "./controls.js";
+import type { HordeState, Swarm } from "./types.js";
+
+/** Dollars the swarm's members have spent over every session, replaced ones included. */
+export function swarmSpend(swarm: Pick<Swarm, "runs">): number {
+  return swarm.runs.reduce((sum, run) => sum + totalUsage(run.members).cost, 0);
+}
+
+/**
+ * `--budget`: once the members' combined spend reaches the threshold, clean-stop every horde
+ * still working. Called on every child event, so it fires on the usage update that crosses the
+ * line. The flag is set before the first await so a burst of events requests the stop once.
+ * Hordes that already reported are skipped: a clean stop on one would re-arm a timer that
+ * `stopRunTimers` cleared and record a stop-hard on a finished run.
+ */
+export function checkBudget(launch: { state: HordeState; swarm: Swarm; ctx: ExtensionCommandContext }): void {
+  const { state, swarm, ctx } = launch;
+  if (swarm.budget === undefined || swarm.budgetHit || state.disposed) return;
+  const spent = swarmSpend(swarm);
+  if (spent < swarm.budget) return;
+  swarm.budgetHit = true;
+  ctx.ui.notify(`horde ${swarm.id}: budget reached (${formatUsd(spent)} of ${formatUsd(swarm.budget)}); stopping`, "warning");
+  for (const run of swarm.runs) {
+    if (run.stopped || run.reported || run.finalized) continue;
+    void requestCleanStop(run, { kind: "all" }, ctx, { postmortem: false, label: "budget" });
+  }
+}

package/src/run/completions.ts

@@ -31,7 +31,12 @@ const UNTIL_STOP_COMPLETION = {
   description: "keep the whole horde working until stop-clean or stop-hard; validated solves are banked",
 };
 
-const LAUNCH_FLAG_COMPLETIONS = [DASHBOARD_COMPLETION, NO_VERIFIER_COMPLETION, UNTIL_STOP_COMPLETION];
+const BUDGET_COMPLETION = {
+  value: "--budget=5 ",
+  description: "clean-stop the run once the members' combined spend reaches this many dollars; edit the number",
+};
+
+const LAUNCH_FLAG_COMPLETIONS = [DASHBOARD_COMPLETION, NO_VERIFIER_COMPLETION, UNTIL_STOP_COMPLETION, BUDGET_COMPLETION];
 
 /** Argument completions that are not member targets. */
 const EXTRA_COMPLETIONS: Record<string, Array<{ value: string; description: string }>> = {

package/src/run/controls.ts

@@ -19,7 +19,7 @@ const CLEAN_STOP_ACTIVE_GRACE_MS = Number(process.env.PI_HORDE_ACTIVE_GRACE_MS)
 const SOLVED_STOP_MS = Number(process.env.PI_HORDE_SOLVED_STOP_MS) || 30_000;
 
 /** Why a clean stop was requested; selects the report's stop label. */
-type CleanStopLabel = "stop-clean" | "deadline" | "solved";
+type CleanStopLabel = "stop-clean" | "deadline" | "solved" | "budget";
 
 interface CleanStopOptions {
   graceMs?: number | undefined;
@@ -168,6 +168,7 @@ export function setPaused(
 
 function stopLabelFor(label: CleanStopLabel): string {
   if (label === "deadline") return "stopped at deadline";
+  if (label === "budget") return "stopped at budget";
   if (label === "solved") return "stopped during solved wind-down";
   return "stopped by user";
 }

package/src/run/finalize.ts

@@ -20,7 +20,7 @@ import { clusterFindings } from "../ledger/clusters.js";
 import { listFacts } from "../ledger/facts.js";
 import type { FactEntry } from "../ledger/facts.js";
 import { readHordeFile } from "../ledger/files.js";
-import { listFindingsForRun, parseFindings, supersededCitations } from "../ledger/findings.js";
+import { listFindingsForRun, parseFindings, staleAnswerFor } from "../ledger/findings.js";
 import type { FindingEntry } from "../ledger/findings.js";
 import { countIdeas, parseIdeas, reconcileOwnedIdeas } from "../ledger/ideas.js";
 import type { Idea } from "../ledger/ideas.js";
@@ -29,7 +29,7 @@ import type { PendingCleanup } from "../ledger/resources.js";
 import { archiveSolved, clearCleanStop, clearSolved, readSolvedState, resolveSolvedState, writeAnswer } from "../ledger/run-signals.js";
 import type { SolvedSignal } from "../ledger/run-signals.js";
 import { childEnv, execPi } from "../member.js";
-import { reportText, runReportMarkdown, summaryMarkdown } from "../prompt.js";
+import { reportText, runReportMarkdown, summaryMarkdown, totalUsage } from "../prompt.js";
 import { buildRunGraph } from "../run-graph.js";
 import { runGraphMarkdown } from "../run-graph-mermaid.js";
 import type { CleanupStatus, ReportResource, RunReportInput } from "../prompt.js";
@@ -137,19 +137,18 @@ interface SettledAnswer {
   status: string;
 }
 
-/** Findings the proposal names that a later finding corrected; labeled, not re-versioned. */
 /**
  * The proposal body is the member's verbatim text and can predate later challenges and corrections.
- * The status names the blockers still open at freeze and the findings a later finding superseded,
- * and, once synthesis wrote it, points the operator at DELIVERABLE.md as the reconciled output.
+ * The status names the blockers still open at freeze and the citations that changed after the
+ * proposal pinned them (superseded or amended findings, republished artifacts), and, once
+ * synthesis wrote it, points the operator at DELIVERABLE.md as the reconciled output.
  */
-function annotateAnswer(run: HordeRun, answer: SettledAnswer, acceptance: { hash: string; issues: string[] }, findings: FindingEntry[]): void {
+function annotateAnswer(run: HordeRun, answer: SettledAnswer, acceptance: { hash: string; issues: string[] }, stale: string[]): void {
   const blockers = acceptance.issues.filter((issue) => /^Q\d+ .*: \w+ blocking /.test(issue)).map((issue) => issue.replace(/:/, ""));
   const parts = [answer.status];
   if (acceptance.issues.length) parts.push("acceptance incomplete");
   if (blockers.length) parts.push(`open blocking at freeze: ${blockers.join(", ")}`);
-  const superseded = supersededCitations(answer.proposal.text, findings);
-  if (superseded.length) parts.push(`cites superseded ${superseded.join(", ")}`);
+  if (stale.length) parts.push(`cites ${stale.join(", ")}`);
   parts.push(`see ACCEPTANCE.md (snapshot ${acceptance.hash})`);
   if (run.deliverable) parts.push("reconciled operator output: DELIVERABLE.md; the proposal text below is verbatim and may be superseded there");
   try {
@@ -559,18 +558,21 @@ export async function finalizeRun(state: HordeState, swarm: Swarm, run: HordeRun
     run.acceptance = acceptance.status;
     run.snapshotHash = acceptance.hash;
     await recordLifecycle(run, "acceptance", { status: acceptance.status, hash: acceptance.hash, issues: acceptance.issues.length });
-    const annotate = answer !== undefined &&
-      (acceptance.issues.length > 0 || supersededCitations(answer.proposal.text, ledgers.findings).length > 0);
-    if (annotate) annotateAnswer(run, answer, acceptance, ledgers.findings);
+    const stale = answer ? staleAnswerFor(run.hordeDir, run.id, answer.proposal.text, answer.proposal.cites) : [];
+    const annotate = answer !== undefined && (acceptance.issues.length > 0 || stale.length > 0);
+    if (annotate) annotateAnswer(run, answer, acceptance, stale);
     // Workers and bounded repairs have exited; only now may their labs be torn down.
     const cleanups = await runCleanups(run);
     const reportInput = writeRunReports(run, ledgers, releasedIdeas, cleanups, now);
     // Free the slot before the (possibly slow) synthesis so a new run can start.
     noteRunReported(state, swarm, run);
     await synthesize(state, run, ledgers, reportInput, now);
-    if (annotate && run.deliverable) annotateAnswer(run, answer, acceptance, ledgers.findings);
+    if (annotate && run.deliverable) annotateAnswer(run, answer, acceptance, stale);
     sendReport(state, swarm, run, ledgers, now);
-    await recordLifecycle(run, "run-end", { outcome: runOutcome(run), elapsedMs: Date.now() - run.startedAt, stopLabel: run.stopLabel });
+    await recordLifecycle(run, "run-end", {
+      outcome: runOutcome(run), elapsedMs: Date.now() - run.startedAt, stopLabel: run.stopLabel,
+      spent: totalUsage(run.members).cost, budget: run.budget,
+    });
     writeRunGraph(run);
   } catch (error) {
     safeNotify(run, `horde ${run.id} failed to finalize: ${errorMessage(error)}`, "error");

package/src/run/launch.ts

@@ -277,6 +277,7 @@ function buildSwarm(
     plan: parsed.plan,
     partition: partition.slices,
     untilStop: parsed.untilStop === true ? true : undefined,
+    budget: parsed.budget,
     dashboardUrl,
   };
   return { swarm, launches };
@@ -287,7 +288,7 @@ async function seedHorde(swarm: Swarm, run: HordeRun, roles: string[]): Promise<
   await seedRun(run);
   await recordLifecycle(run, "run-start", {
     count: run.count, model: run.model, verifier: run.verifier, plan: run.plan, untilStop: run.untilStop,
-    roles: roles.map((role) => oneLine(role, 120)), dashboardUrl: run.dashboardUrl,
+    budget: run.budget, roles: roles.map((role) => oneLine(role, 120)), dashboardUrl: run.dashboardUrl,
     ...(swarm.hordes > 1 ? { swarm: swarm.id, horde: run.horde, hordes: swarm.hordes, slice: run.slice } : {}),
   });
   await recordPhase(run, "discovery", "start");

package/src/run/repair.ts

@@ -4,9 +4,10 @@ import { randomUUID } from "node:crypto";
 import { inboxFor } from "../tool/inbox.js";
 import type { PeerMessage } from "../ledger/collaboration.js";
 import { recordEvent } from "../ledger/events.js";
+import type { EventContext } from "../ledger/events.js";
 import { recordPhase } from "./lifecycle.js";
 import { envNumber } from "../format.js";
-import { resetMemberState } from "../member.js";
+import { resetMemberState, USAGE_KEYS } from "../member.js";
 import type { MemberState } from "../member.js";
 import { hardStopMembers } from "./controls.js";
 import { scheduleCollaboration, stopReason } from "./schedule.js";
@@ -24,11 +25,94 @@ function repairPriority(message: PeerMessage): number {
   return 3;
 }
 
-function queueFor(launch: RunLaunch, member: MemberState): PeerMessage[] {
-  return inboxFor({ hordeDir: launch.run.hordeDir, runId: launch.run.id, actor: member.name })
+/** The repair phase's scheduling state, shared by every round. */
+interface RepairPhase {
+  launch: RunLaunch;
+  floors: RepairFloors;
+  /**
+   * Threads a member's completed attempts left exactly as they found them, by member then
+   * message id: the signature the thread was stuck at and how many consecutive attempts left it
+   * there. The thread is held back from that member once the count reaches `UNMOVED_ATTEMPTS`,
+   * until its signature changes, which only another member's action or a new response can cause.
+   */
+  stalled: Map<string, Map<string, UnmovedThread>>;
+}
+
+interface UnmovedThread {
+  signature: string;
+  attempts: number;
+}
+
+/**
+ * Completed attempts that may leave a thread untouched before it is held. One miss is routine: a
+ * member that answered the rest of its queue, or re-answered the task, often clears the thread on
+ * its next attempt within seconds. Two misses on the same signature are the loop this guards.
+ */
+const UNMOVED_ATTEMPTS = 2;
+
+function memberContext(phase: RepairPhase, member: MemberState): EventContext {
+  return { hordeDir: phase.launch.run.hordeDir, runId: phase.launch.run.id, actor: member.name };
+}
+
+/**
+ * What an attempt can change on a thread: its state and the revision it was answered with.
+ * Delivery receipts and a re-worded response on the same revision are not progress, so neither
+ * the inbox read of a fresh attempt nor a recipient repeating itself re-qualifies a thread.
+ */
+function threadSignature(m: PeerMessage): string {
+  return `${m.state}:${m.responseRevision ?? ""}:${m.responseTarget ?? ""}`;
+}
+
+function isStalled(phase: RepairPhase, member: MemberState, m: PeerMessage): boolean {
+  const unmoved = phase.stalled.get(member.name)?.get(m.id);
+  return unmoved !== undefined && unmoved.signature === threadSignature(m) && unmoved.attempts >= UNMOVED_ATTEMPTS;
+}
+
+/** The threads currently held back from the member, in inbox order. */
+function heldThreads(phase: RepairPhase, member: MemberState): string[] {
+  return inboxFor(memberContext(phase, member)).filter((m) => isStalled(phase, member, m)).map((m) => m.id);
+}
+
+/** The threads an attempt for the member would be handed: its inbox minus the threads held back. */
+function queueFor(phase: RepairPhase, member: MemberState): PeerMessage[] {
+  return inboxFor(memberContext(phase, member)).filter((m) => !isStalled(phase, member, m))
     .sort((a, b) => repairPriority(a) - repairPriority(b) || a.createdAt.localeCompare(b.createdAt));
 }
 
+/**
+ * Counts, per thread, the consecutive completed attempts that left it as they found it; a thread
+ * the attempt moved starts over. A killed attempt counts nothing: it may have been about to act.
+ * Returns the ids this attempt left unchanged.
+ */
+function noteUnchanged(phase: RepairPhase, member: MemberState, queue: PeerMessage[]): string[] {
+  if (member.endCause !== "completed") return [];
+  const after = new Map(inboxFor(memberContext(phase, member)).map((m) => [m.id, threadSignature(m)]));
+  const unmoved = phase.stalled.get(member.name) ?? new Map<string, UnmovedThread>();
+  const unchanged: string[] = [];
+  for (const m of queue) {
+    const signature = threadSignature(m);
+    if (after.get(m.id) !== signature) { unmoved.delete(m.id); continue; }
+    const previous = unmoved.get(m.id);
+    unmoved.set(m.id, { signature, attempts: previous?.signature === signature ? previous.attempts + 1 : 1 });
+    unchanged.push(m.id);
+  }
+  phase.stalled.set(member.name, unmoved);
+  return unchanged;
+}
+
+/**
+ * Once every thread in the member's inbox is one its own completed attempt could not move, later
+ * rounds skip the member and its threads drop out of the demand that sizes the shares, until
+ * another member changes one. Recorded so the post-mortem sees why the member stopped appearing.
+ */
+async function recordStalled(phase: RepairPhase, member: MemberState): Promise<void> {
+  const held = heldThreads(phase, member);
+  if (!held.length || queueFor(phase, member).length) return;
+  const { run } = phase.launch;
+  run.repairStalled = [...new Set([...(run.repairStalled ?? []), member.name])];
+  await recordEvent({ ...memberContext(phase, member), actor: "parent", attempt: "scheduler" }, "repair-skipped", { payload: { reason: "no-progress", members: [{ member: member.name, messages: held }] } });
+}
+
 /**
  * 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
@@ -114,10 +198,10 @@ export function repairBudget(demands: number[], floors: RepairFloors, rounds: nu
 
 type SkipReason = "insufficient-budget" | "insufficient-time";
 
-async function recordSkipped(launch: RunLaunch, pending: MemberState[], reason: SkipReason, detail: Record<string, number>): Promise<void> {
-  const { run } = launch;
+async function recordSkipped(phase: RepairPhase, pending: MemberState[], reason: SkipReason, detail: Record<string, number>): Promise<void> {
+  const { run } = phase.launch;
   const ctx = { hordeDir: run.hordeDir, runId: run.id, actor: "parent", attempt: "scheduler" };
-  const members = pending.map((member) => ({ member: member.name, messages: queueFor(launch, member).map((m) => m.id) }))
+  const members = pending.map((member) => ({ member: member.name, messages: queueFor(phase, member).map((m) => m.id) }))
     .filter((entry) => entry.messages.length);
   if (!members.length) return;
   run.repairSkipped = [...new Set([...(run.repairSkipped ?? []), ...members.map((entry) => entry.member)])];
@@ -143,10 +227,11 @@ interface FirstTurnCost {
  * share is the allowance recorded and the deadline is derived from it once, so the record cannot
  * read a millisecond under the floor the share was raised to.
  */
-async function repairMember(launch: RunLaunch, member: MemberState, ms: number, limits: RepairLimits, floors: RepairFloors): Promise<void> {
+async function repairMember(phase: RepairPhase, member: MemberState, ms: number, limits: RepairLimits): Promise<void> {
+  const { launch, floors } = phase;
   const { run } = launch;
-  const ctx = { hordeDir: run.hordeDir, runId: run.id, actor: member.name };
-  const queue = queueFor(launch, member);
+  const ctx = memberContext(phase, member);
+  const queue = queueFor(phase, member);
   if (!queue.length || stopReason(launch)) return;
   const prior = { turns: member.turns, toolCalls: member.toolCalls, usage: { ...member.usage }, startedAt: member.startedAt };
   resetMemberState(member);
@@ -181,7 +266,8 @@ async function repairMember(launch: RunLaunch, member: MemberState, ms: number,
   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), demand: repairDemand(queue), prior, allowance, floors } });
+    const held = heldThreads(phase, member);
+    await recordEvent({ ...ctx, attempt: member.attempt }, "repair-start", { payload: { messages: queue.map((m) => m.id), demand: repairDemand(queue), prior, allowance, floors, ...(held.length ? { held } : {}) } });
     if (stopReason(launch) || Date.now() >= deadline) {
       halt(stopReason(launch) ?? "time");
       member.status = "stopped";
@@ -191,17 +277,19 @@ async function repairMember(launch: RunLaunch, member: MemberState, ms: number,
       // Enforce a share on every usage update, rather than waiting for the next poll.
       await spawnOne(launch, member, undefined, check);
     }
+    const unchanged = noteUnchanged(phase, member, queue);
     await recordEvent({ ...ctx, attempt: member.attempt }, "repair-end", { payload: {
       cause: member.endCause, stopReason: member.repairStopReason, allowance, usage: member.usage, turns: member.turns, firstTurn,
-      messages: queue.map((m) => m.id),
+      messages: queue.map((m) => m.id), unchanged,
     } });
+    if (unchanged.length) await recordStalled(phase, member);
   } finally {
     clearTimeout(timeout);
     clearInterval(watchdog);
     run.repairTokens = (run.repairTokens ?? 0) + spent();
     member.turns += prior.turns;
     member.toolCalls += prior.toolCalls;
-    for (const key of ["input", "output", "cacheRead", "cacheWrite", "cost"] as const) member.usage[key] += prior.usage[key];
+    for (const key of USAGE_KEYS) member.usage[key] += prior.usage[key];
     member.startedAt = prior.startedAt;
   }
 }
@@ -223,19 +311,42 @@ export async function drainRepairs(launch: RunLaunch): Promise<void> {
   }
 }
 
-function eligibleMembers(launch: RunLaunch): Array<{ member: MemberState; queue: PeerMessage[] }> {
-  return launch.run.members.map((member) => ({ member, queue: queueFor(launch, member) })).filter((entry) => entry.queue.length)
+function eligibleMembers(phase: RepairPhase): Array<{ member: MemberState; queue: PeerMessage[] }> {
+  return phase.launch.run.members.map((member) => ({ member, queue: queueFor(phase, member) })).filter((entry) => entry.queue.length)
     .sort((a, b) => repairPriority(a.queue[0]!) - repairPriority(b.queue[0]!) ||
       (a.member.repairs ?? 0) - (b.member.repairs ?? 0) || a.queue[0]!.createdAt.localeCompare(b.queue[0]!.createdAt));
 }
 
+/** The queue a member was handed this round, by message id, at the signature it was handed. */
+type HandedQueues = Map<string, Map<string, string>>;
+
+/**
+ * True when every blocking thread left belongs to a member already served this round, and one of
+ * them is new or moved since that member was handed its queue. A correction answered mid-round
+ * leaves its requester to recheck it; finishing the round on administrative rechecks first spent
+ * the clock that recheck needed, so when a later round exists it starts now. A blocker the member
+ * left as it was handed is no reason to serve it again early; the last round serves everyone.
+ */
+export function blockedOnServed(eligible: Array<{ member: MemberState; queue: PeerMessage[] }>, handed: HandedQueues): boolean {
+  let moved = false;
+  for (const { member, queue } of eligible) {
+    const seen = handed.get(member.name);
+    for (const m of queue) {
+      if (repairPriority(m) !== 0) continue;
+      if (!seen) return false;
+      if (seen.get(m.id) !== threadSignature(m)) moved = true;
+    }
+  }
+  return moved;
+}
+
 async function runRepairRounds(launch: RunLaunch, begin: (budget: RepairBudget) => Promise<void>): Promise<void> {
   const { run } = launch;
   const rounds = Math.max(0, Math.min(6, envNumber("PI_HORDE_REPAIR_ROUNDS", 4)));
   if (rounds === 0 || stopReason(launch)) return;
-  const floors = repairFloors();
+  const phase: RepairPhase = { launch, floors: repairFloors(), stalled: new Map() };
   await scheduleCollaboration(launch, { settleMs: 0, liveOnly: false });
-  const budget = repairBudget(eligibleMembers(launch).map((entry) => repairDemand(entry.queue)), floors, rounds);
+  const budget = repairBudget(eligibleMembers(phase).map((entry) => repairDemand(entry.queue)), phase.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;
@@ -245,34 +356,35 @@ async function runRepairRounds(launch: RunLaunch, begin: (budget: RepairBudget)
     // 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>();
+    const handed: HandedQueues = new Map();
     for (;;) {
       if (exhausted()) return;
-      const pending = eligibleMembers(launch).filter((entry) => !served.has(entry.member.name));
-      if (!pending.length) break;
+      const eligible = eligibleMembers(phase);
+      const pending = eligible.filter((entry) => !handed.has(entry.member.name));
+      if (!pending.length || (round < rounds - 1 && blockedOnServed(eligible, handed))) 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, pendingUnits, laterRounds, units), remaining, floors.tokens);
+      const tokens = repairAllowance(repairShare(remaining, pendingUnits, laterRounds, units), remaining, phase.floors.tokens);
       if (tokens === undefined) {
         await begin(budget);
-        await recordSkipped(launch, unserved, "insufficient-budget", { remaining, floor: floors.tokens });
+        await recordSkipped(phase, unserved, "insufficient-budget", { remaining, floor: phase.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, pendingUnits, laterRounds, fundable, units), remainingMs, floors.ms);
+      const fundable = Math.floor(remaining / Math.max(1, phase.floors.tokens));
+      const ms = repairAllowance(repairTimeShare(remainingMs, pendingUnits, laterRounds, fundable, units), remainingMs, phase.floors.ms);
       if (ms === undefined || ms < 1) {
         await begin(budget);
-        await recordSkipped(launch, unserved, "insufficient-time", { remainingMs, floorMs: floors.ms });
+        await recordSkipped(phase, unserved, "insufficient-time", { remainingMs, floorMs: phase.floors.ms });
         return;
       }
       await begin(budget);
-      served.add(next.member.name);
-      await repairMember(launch, next.member, ms, { tokens, turns: budget.turns }, floors);
+      handed.set(next.member.name, new Map(next.queue.map((m) => [m.id, threadSignature(m)])));
+      await repairMember(phase, next.member, ms, { tokens, turns: budget.turns });
     }
   }
 }

package/src/run/setup.ts

@@ -93,7 +93,8 @@ export function createRun(
   fs.writeFileSync(
     path.join(runDir, "TASK.md"),
     taskMarkdown({
-      id, prompt, count, model, thinkingLevel: ctx.thinkingLevel, startedAt, verifier, untilStop: parsed.untilStop, swarm,
+      id, prompt, count, model, thinkingLevel: ctx.thinkingLevel, startedAt, verifier, untilStop: parsed.untilStop,
+      budget: parsed.budget, swarm,
     }),
     "utf-8",
   );
@@ -123,6 +124,7 @@ export function createRun(
     plan,
     verifier,
     untilStop: parsed.untilStop === true ? true : undefined,
+    budget: parsed.budget,
     resets: [],
     dashboardUrl,
   };

package/src/run/solved.ts

@@ -4,7 +4,7 @@ import { loadCollaborationReport } from "../collaboration-report.js";
 import { openMessages } from "../ledger/collaboration.js";
 import { postBoard } from "../ledger/board.js";
 import { unsettledFactCitations } from "../ledger/facts.js";
-import { listFindingsForRun, staleAnswerCitations, unverifiedFindings } from "../ledger/findings.js";
+import { staleAnswerFor, unverifiedFindings } from "../ledger/findings.js";
 import { listIdeas } from "../ledger/ideas.js";
 import { archiveSolved, clearCleanStop, clearSolved, readSolvedState, reopenSolved, resolveSolvedState, writeAnswer } from "../ledger/run-signals.js";
 import type { SolvedSignal } from "../ledger/run-signals.js";
@@ -80,14 +80,27 @@ function dropContested(run: HordeRun, proposal: SolvedSignal, contest: SolvedSig
 }
 
 /**
- * A proposal that cites a finding superseded or amended after it was made would ship the stale
- * reading as the answer. It is withdrawn for re-proposal rather than validated; the board names
- * the successor or the amendment.
+ * ANSWER.md keeps the withdrawn text for the record, but its status must stop naming the
+ * validation it held, or the run reads as validated after the proposal is gone.
+ */
+function recordWithdrawn(run: HordeRun, proposal: SolvedSignal, reason: string): void {
+  void recordLifecycle(run, "solved-withdrawn", { member: proposal.member, reason });
+  try {
+    writeAnswer(run.runDir, run.id, proposal, `withdrawn: it ${reason}; no validation carries over and no proposal is pending`);
+  } catch (error) {
+    safeNotify(run, `horde ${run.id}: could not write ANSWER.md (${oneLine(String(error), 200)})`, "error");
+  }
+}
+
+/**
+ * A proposal that cites a finding superseded or amended, or an artifact republished, after it was
+ * made would ship the stale reading as the answer. It is withdrawn for re-proposal rather than
+ * validated; the board names the successor, the amendment, or the republish.
  */
 function withdrawStale(run: HordeRun, proposal: SolvedSignal, stale: string[]): void {
   const reason = `cites ${stale.join(", ")}`;
   safeNotify(run, `horde ${run.id}: solved proposal withdrawn; it ${reason}`, "warning");
-  void recordLifecycle(run, "solved-withdrawn", { member: proposal.member, reason });
+  recordWithdrawn(run, proposal, reason);
   void postBoard(
     run.hordeDir,
     "parent",
@@ -111,13 +124,13 @@ function reopenContested(run: HordeRun): void {
   // The proposal returns with the citations it pinned when it was made; what went stale or
   // unsettled meanwhile makes it a re-proposal for its author, not a reopening.
   const stale = [
-    ...staleAnswerCitations(listFindingsForRun(run.hordeDir, run.id), contest.proposal.text, contest.proposal.cites),
+    ...staleAnswerFor(run.hordeDir, run.id, contest.proposal.text, contest.proposal.cites),
     ...unsettledFactCitations(run.hordeDir, contest.proposal.text).map((citation) => `provisional ${citation}`),
   ];
   run.solvedContest = undefined;
   if (stale.length) {
     const why = `cites ${stale.join(", ")}`;
-    void recordLifecycle(run, "solved-withdrawn", { member: contest.proposal.member, reason: why });
+    recordWithdrawn(run, contest.proposal, why);
     void postBoard(run.hordeDir, "parent", `SOLVED proposal by ${contest.proposal.member} is not re-opened after ${reason}: it ${why}. ${contest.proposal.member}: propose again citing the current findings.`);
     return;
   }
@@ -262,7 +275,7 @@ export function checkSolved(run: HordeRun, ctx: ExtensionCommandContext): void {
     dropContested(run, solved, state.contest);
     return;
   }
-  const stale = staleAnswerCitations(listFindingsForRun(run.hordeDir, run.id), solved.text, solved.cites);
+  const stale = staleAnswerFor(run.hordeDir, run.id, solved.text, solved.cites);
   if (stale.length && !run.solvedCommitted) {
     withdrawStale(run, solved, stale);
     return;