agent-horde 0.1.2 → 0.1.4

package/src/member.ts

@@ -26,7 +26,7 @@ export interface MemberUsage {
 export interface MemberState {
   attempt?: string;
   repairs?: number;
-  repairStopReason?: "tokens" | "time" | "user-stop" | "disposed" | "master-abort";
+  repairStopReason?: "tokens" | "turns" | "time" | "user-stop" | "disposed" | "master-abort";
   name: string;
   index: number;
   status: MemberStatus;

package/src/prompt.ts

@@ -11,6 +11,9 @@ import type { ResourceEntry } from "./ledger/resources.js";
 import type { SolvedSignal } from "./ledger/run-signals.js";
 import type { MemberReset, MemberState } from "./member.js";
 
+/** A resource with the non-owner members whose findings, evidence, reviews or leases cite it. */
+export type ReportResource = ResourceEntry & { citedBy?: string[] | undefined };
+
 export interface RunSummaryInput {
   id: string;
   prompt: string;
@@ -23,8 +26,16 @@ export interface RunSummaryInput {
   userStop?: boolean | undefined;
   /** Human-readable stop reason, e.g. "stopped by user" or "stopped at deadline". */
   stopLabel?: string | undefined;
-  /** Set when a member reported the goal solved; the stop cause must agree with REPORT.md. */
+  /** 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. */
+  solvedValidatedBy?: string | undefined;
+  /** True when the parent wound the run down on the validated proposal. */
+  solvedCommitted?: boolean | undefined;
+  /** Members whose queued repair work was skipped for budget. */
+  repairSkipped?: 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. */
   diagnosis?: string | undefined;
   /** Post-mortem markdown appended to the report when one was generated. */
@@ -87,14 +98,16 @@ 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.
-- Read horde inbox. Recipient: ack target=Q# text=plan, then respond target=Q# revision=hash text=result.
+  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.
   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.
   Do not repeat your existing check: inspect collaboration first and test a specific remaining gap.
-  A deferred blocking issue stays visible as acceptance debt. Never silently ignore a peer's failed test.
+  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.
 - Publish runnable outputs with horde artifact artifactKind=runnable artifactPath=artifacts/file
   criteria=positive-and-negative-tests dependsOn=[F#]. Assessment documents use artifactKind=document
   and criteria covering citation accuracy, claim scope and disclosed limits. Full independent sourced/derived
@@ -351,14 +364,38 @@ function memberSummarySection(
   return lines;
 }
 
+/**
+ * How the run ended, from what the parent recorded rather than from the solved flag alone: a
+ * proposal can be validated and still not wind the run down when coverage or review debt holds
+ * it, and the repair phase can end the run on budget instead.
+ */
+export function runEndSentence(run: RunSummaryInput): string {
+  const parts: string[] = [];
+  if (run.solved) {
+    const at = run.solved.at ? ` at ${formatClock(new Date(run.solved.at))}` : "";
+    const validated = run.solvedValidatedBy ? `validated by ${run.solvedValidatedBy}` : "not validated by another member";
+    const wound = run.solvedCommitted ? "the run wound down on it" : "the run did not wind down on it";
+    parts.push(`${run.solved.member} proposed the goal solved${at}, ${validated}; ${wound}.`);
+  }
+  parts.push(run.stopped ? `Run ${run.stopLabel ?? "was stopped by the user"}.` : "Run ended when every member exited.");
+  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 ?? [];
+  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(", ")})` : "",
+    ].filter(Boolean).join(", ");
+    parts.push(`Repair: ${attempts} attempt(s)${detail ? `, ${detail}` : ""}.`);
+  }
+  if (run.outcome) parts.push(`Outcome: ${run.outcome}.`);
+  return parts.join(" ");
+}
+
 export function summaryMarkdown(run: RunSummaryInput, now: number = Date.now()): string {
   const counts = statusCounts(run.members);
   const usage = totalUsage(run.members);
-  const end = run.solved
-    ? ` Run ended after ${run.solved.member} reported the goal solved.`
-    : run.stopped
-      ? ` Run was stopped (${run.stopLabel ?? "by the user"}).`
-      : "";
+  const end = ` ${runEndSentence(run)}`;
   const lines = [
     `# Horde run ${run.id}`,
     "",
@@ -492,14 +529,16 @@ export interface RunReportInput extends RunSummaryInput {
   facts: FactEntry[];
   /** Merged deliverable markdown when one was generated; REPORT.md points at it. */
   deliverable?: string | undefined;
-  /** Shared resources claimed during the run. */
-  resources?: ResourceEntry[] | 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 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. */
   solved?: SolvedSignal | undefined;
   /** True when a SOLVED proposal was contested and no validated answer replaced it. */
   solvedContested?: boolean | undefined;
-  /** The other member that validated the solved proposal, if any. */
-  solvedValidatedBy?: string | undefined;
   /** Resource teardown results from finalize. */
   cleanups?: Array<{ name: string; command: string; status: CleanupStatus; detail: string }> | undefined;
   /** Member board posts that landed after the last finding. */
@@ -550,8 +589,10 @@ function artifactDiagnosis(input: RunReportInput): string[] {
     lines.push("- deliverable: DELIVERABLE.md (merged task deliverable in this run directory)");
   }
   if (input.resources && input.resources.length > 0) {
-    const reused = input.resources.reduce((n, resource) => n + resource.reusers.length, 0);
-    lines.push(`- resources: ${input.resources.length} claimed, ${reused} reuse(s)`);
+    const reclaims = input.resources.reduce((n, resource) => n + resource.reusers.length, 0);
+    const citing = new Set(input.resources.flatMap((resource) => resource.citedBy ?? []));
+    const reused = input.resources.filter((resource) => resource.reusers.length > 0 || (resource.citedBy ?? []).length > 0).length;
+    lines.push(`- resources: ${input.resources.length} claimed, ${reused} reused (${reclaims} explicit reclaim(s), ${citing.size} citing member(s))`);
   }
   if (input.solved) {
     const how = input.solvedValidatedBy
@@ -562,6 +603,11 @@ function artifactDiagnosis(input: RunReportInput): string[] {
     lines.push(
       `- solved: ${input.solved.member} proposed the goal answered (${how}): ${oneLine(input.solved.text, 200)}`,
     );
+    if (input.solvedConfirmations) {
+      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) {
     lines.push("- solved: contested; no validated answer survived the run");
@@ -663,6 +709,12 @@ function ledgerDiagnosis(input: RunReportInput, supersededBy: Map<number, number
         .join(", ")}`,
     );
   }
+  if (input.ideaCreations) {
+    const { created, absorbed } = input.ideaCreations;
+    const total = absorbed.reduce((n, entry) => n + entry.count, 0);
+    const detail = absorbed.length ? ` (${absorbed.map((entry) => `#${entry.id} x${entry.count}`).join(", ")})` : "";
+    lines.push(`- ideas: ${created} created, ${total} duplicate creation(s) absorbed${detail}`);
+  }
   return lines;
 }
 
@@ -719,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, " +
@@ -734,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;
@@ -771,10 +825,14 @@ function runArtifactSections(input: RunReportInput): string[] {
   if (input.resources && input.resources.length > 0) {
     lines.push("", "## Resources", "");
     for (const resource of input.resources) {
+      const reuse = [
+        resource.reusers.length > 0 ? `reused by ${resource.reusers.join(", ")}` : "",
+        (resource.citedBy ?? []).length > 0 ? `cited by ${(resource.citedBy ?? []).join(", ")}` : "",
+      ].filter(Boolean).join("; ");
       lines.push(
         `- R${resource.id} ${resource.name} @${resource.owner}` +
           `${resource.note ? `: ${resource.note}` : ""}` +
-          `${resource.reusers.length > 0 ? ` (reused by ${resource.reusers.join(", ")})` : ""}`,
+          `${reuse ? ` (${reuse})` : ""}`,
       );
     }
   }

package/src/run/finalize.ts

@@ -5,6 +5,7 @@ import {
   ledgerCitationWarnings,
   reportConsistencyWarnings,
   resourceCitations,
+  resourceCitingMembers,
 } from "../citations.js";
 import { errorMessage, oneLine } from "../format.js";
 import { freezeAcceptance } from "../collaboration-report.js";
@@ -13,6 +14,8 @@ import { listClaims, markClaimsUnverified } from "../ledger/claims.js";
 import type { ClaimEntry } from "../ledger/claims.js";
 import { collaborationState } from "../ledger/collaboration.js";
 import { readEvents } from "../ledger/events.js";
+import type { HordeEvent } from "../ledger/events.js";
+import { absorbedIdeaCreations, ideaCreationCount, solvedConfirmations } from "../ledger/event-metrics.js";
 import { clusterFindings } from "../ledger/clusters.js";
 import { listFacts } from "../ledger/facts.js";
 import type { FactEntry } from "../ledger/facts.js";
@@ -22,14 +25,14 @@ import type { FindingEntry } from "../ledger/findings.js";
 import { countIdeas, parseIdeas, reconcileOwnedIdeas } from "../ledger/ideas.js";
 import type { Idea } from "../ledger/ideas.js";
 import { listResources, pendingCleanups, readRunResources } from "../ledger/resources.js";
-import type { PendingCleanup, ResourceEntry } from "../ledger/resources.js";
+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 { buildRunGraph } from "../run-graph.js";
 import { runGraphMarkdown } from "../run-graph-mermaid.js";
-import type { CleanupStatus, RunReportInput } from "../prompt.js";
+import type { CleanupStatus, ReportResource, RunReportInput } from "../prompt.js";
 import { buildDiagnosis } from "./diagnosis.js";
 import { recordLifecycle, recordPhase } from "./lifecycle.js";
 import { runDeliverable, runPostmortem } from "./synthesis.js";
@@ -46,8 +49,8 @@ interface RunLedgers {
   findings: FindingEntry[];
   claims: ClaimEntry[];
   facts: FactEntry[];
-  /** Resources this run claimed or reused. */
-  resources: ResourceEntry[];
+  /** Resources this run claimed or reused, with the non-owners whose records cite each one. */
+  resources: ReportResource[];
 }
 
 type CleanupResult = NonNullable<RunReportInput["cleanups"]>[number];
@@ -128,15 +131,25 @@ interface SettledAnswer {
   status: string;
 }
 
+/** Findings the proposal names that a later finding corrected; labeled, not re-versioned. */
+export function supersededCitations(text: string, findings: FindingEntry[]): string[] {
+  return findings
+    .filter((finding) => finding.supersededBy !== undefined && new RegExp(`\\bF${finding.id}\\b`).test(text))
+    .map((finding) => `F${finding.id} (now F${finding.supersededBy})`);
+}
+
 /**
- * The proposal body is the member's verbatim text and can predate later challenges. When acceptance
- * fails, the status names the blockers still open at freeze and, once synthesis wrote it, points
- * the operator at DELIVERABLE.md as the reconciled output.
+ * 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.
  */
-function annotateAnswer(run: HordeRun, answer: SettledAnswer, acceptance: { hash: string; issues: string[] }): void {
+function annotateAnswer(run: HordeRun, answer: SettledAnswer, acceptance: { hash: string; issues: string[] }, findings: FindingEntry[]): void {
   const blockers = acceptance.issues.filter((issue) => /^Q\d+ .*: \w+ blocking /.test(issue)).map((issue) => issue.replace(/:/, ""));
-  const parts = [answer.status, "acceptance incomplete"];
+  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(", ")}`);
   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 {
@@ -212,7 +225,9 @@ function readRunLedgers(run: HordeRun): RunLedgers {
     ledgers.claims = listClaims(run.hordeDir);
     ledgers.facts = listFacts(run.hordeDir);
     const touched = new Set(readRunResources(run.runDir));
-    ledgers.resources = listResources(run.hordeDir).filter((resource) => touched.has(resource.id));
+    const resources = listResources(run.hordeDir).filter((resource) => touched.has(resource.id));
+    const citing = resourceCitingMembers(resources, ledgers.findings, collaborationState(run.hordeDir, run.id));
+    ledgers.resources = resources.map((resource) => ({ ...resource, citedBy: citing.get(resource.id) ?? [] }));
   } catch {
     // FINDINGS/CLAIMS/FACTS.md was removed mid-run.
   }
@@ -322,14 +337,23 @@ function writeRunReports(
     latePosts,
   });
   const memberPosts = lastBoardPostsByMember(run.hordeDir, run.id);
+  const outcome = runOutcome(run);
+  let events: HordeEvent[] = [];
+  try {
+    events = readEvents(run.hordeDir, run.id);
+  } catch (error) {
+    safeNotify(run, `horde ${run.id}: could not read events for the report (${errorMessage(error)})`, "error");
+  }
   writeRunFile(
     run,
     "SUMMARY.md",
-    summaryMarkdown({ ...run, findings, ideas: ledgers.ideas, memberPosts, scopedReviews: reviewState.reviews, reviewMessages: reviewState.messages }, now),
+    summaryMarkdown({ ...run, outcome, findings, ideas: ledgers.ideas, memberPosts, scopedReviews: reviewState.reviews, reviewMessages: reviewState.messages }, now),
   );
   const reportInput: RunReport = {
     ...run,
-    outcome: runOutcome(run),
+    outcome,
+    solvedConfirmations: solvedConfirmations(events),
+    ideaCreations: { created: ideaCreationCount(events), absorbed: absorbedIdeaCreations(events) },
     scopedReviews: reviewState.reviews,
     reviewMessages: reviewState.messages,
     canary: run.canary,
@@ -525,15 +549,16 @@ export async function finalizeRun(state: HordeState, run: HordeRun): Promise<voi
     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;
-    if (annotate) annotateAnswer(run, answer, acceptance);
+    const annotate = answer !== undefined &&
+      (acceptance.issues.length > 0 || supersededCitations(answer.proposal.text, ledgers.findings).length > 0);
+    if (annotate) annotateAnswer(run, answer, acceptance, ledgers.findings);
     // Workers and bounded repairs have exited; only now may their labs be torn down.
     const cleanups = await runCleanups(state, run);
     const reportInput = writeRunReports(run, ledgers, releasedIdeas, cleanups, now);
     // Free the slot before the (possibly slow) synthesis so a new run can start.
     if (state.active === run) state.active = undefined;
     await synthesize(state, run, ledgers, reportInput, now);
-    if (annotate && run.deliverable) annotateAnswer(run, answer, acceptance);
+    if (annotate && run.deliverable) annotateAnswer(run, answer, acceptance, ledgers.findings);
     sendReport(state, run, ledgers, now);
     await recordLifecycle(run, "run-end", { outcome: runOutcome(run), elapsedMs: Date.now() - run.startedAt, stopLabel: run.stopLabel });
     writeRunGraph(run);

package/src/run/repair.ts

@@ -26,31 +26,117 @@ 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)));
 }
 
 /**
- * A fresh repair session pays the full system prompt, tool schemas and task on its first turn
- * (about 8k uncached tokens on deepseek). A share below that is killed before it can act, so each
- * attempt gets at least the floor and lower-priority members go unserved instead.
+ * 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.
  */
-function repairAllowance(share: number, remaining: number, floor: number): number | undefined {
+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)));
+}
+
+/**
+ * A fresh repair session pays the full system prompt, tool schemas, task and queued inbox before
+ * it can act: about 20k input+output tokens over five turns on deepseek for a queue of two to
+ * four threads, and the better part of a minute to read, inspect, attach and review. A share
+ * below either floor is killed before it acts, so each attempt gets at least the floor and
+ * lower-priority members go unserved instead.
+ */
+export function repairAllowance(share: number, remaining: number, floor: number): number | undefined {
   if (remaining < Math.max(1, floor)) return undefined;
   return Math.max(share, floor);
 }
 
-async function recordSkipped(launch: RunLaunch, pending: MemberState[], detail: Record<string, number>): Promise<void> {
+export interface RepairFloors {
+  tokens: number;
+  ms: number;
+}
+
+export function repairFloors(): RepairFloors {
+  return {
+    tokens: Math.max(0, envNumber("PI_HORDE_REPAIR_MIN_TOKENS", 40_000)),
+    ms: Math.max(0, envNumber("PI_HORDE_REPAIR_MIN_MS", 60_000)),
+  };
+}
+
+/** Demand units a default budget funds at the floor; the overrides name flat totals instead. */
+const FUNDED_UNITS = 6;
+
+export interface RepairBudget {
+  tokens: number;
+  ms: number;
+  /** Turns per attempt: one that has not finished its inbox read by then will not finish with more. */
+  turns: number;
+  queued: number;
+}
+
+/**
+ * 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(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: demands.length,
+  };
+}
+
+type SkipReason = "insufficient-budget" | "insufficient-time";
+
+async function recordSkipped(launch: RunLaunch, pending: MemberState[], reason: SkipReason, detail: Record<string, number>): Promise<void> {
   const { run } = 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) }))
     .filter((entry) => entry.messages.length);
-  if (members.length) await recordEvent(ctx, "repair-skipped", { payload: { reason: "insufficient-budget", ...detail, members } });
+  if (!members.length) return;
+  run.repairSkipped = [...new Set([...(run.repairSkipped ?? []), ...members.map((entry) => entry.member)])];
+  await recordEvent(ctx, "repair-skipped", { payload: { reason, ...detail, members } });
+}
+
+interface RepairLimits {
+  tokens: number;
+  turns: number;
+}
+
+/** What the attempt's first turn cost, so the token floor can be tuned from data. */
+interface FirstTurnCost {
+  turns: number;
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
 }
 
 /** A finished worker receives a fresh, bounded attempt with a precise evidence handoff. */
-async function repairMember(launch: RunLaunch, member: MemberState, deadline: number, tokens: number): Promise<void> {
+async function repairMember(launch: RunLaunch, member: MemberState, deadline: number, limits: RepairLimits, floors: RepairFloors): Promise<void> {
   const { run } = launch;
   const ctx = { hordeDir: run.hordeDir, runId: run.id, actor: member.name };
   const queue = queueFor(launch, member);
@@ -60,27 +146,34 @@ async function repairMember(launch: RunLaunch, member: MemberState, deadline: nu
   member.repairs = (member.repairs ?? 0) + 1;
   member.repairStopReason = undefined;
   member.attempt = randomUUID();
-  const allowance = { tokens, ms: Math.max(0, deadline - Date.now()) };
-  member.resetNote = `Repair attempt ${member.repairs}. Discovery is closed. Budget: about ${tokens} input+output tokens and ${allowance.ms}ms. ` +
+  const allowance = { ...limits, ms: Math.max(0, deadline - Date.now()) };
+  let firstTurn: FirstTurnCost | undefined;
+  member.resetNote = `Repair attempt ${member.repairs}. Discovery is closed. Budget: about ${allowance.tokens} input+output tokens, ${allowance.turns} turns and ${allowance.ms}ms. ` +
     `Read horde inbox and referenced evidence. Work in this priority order: ${queue.map((m) => `${m.id} ${m.target} (${m.state})`).join(", ")}. ` +
     "Handle blockers and artifact reviews before administrative threads. For review requests, independently check the current revision against its artifact kind and criteria and record evidence plus a scoped review. " +
-    "For corrections, acknowledge, repair, publish, and respond with the current hash. Requesters recheck and resolve or defer with evidence. Preserve unchecked limits. Do not reopen unrelated work.";
+    "For corrections, repair, publish, and respond with the current hash. Requesters recheck and resolve or defer with evidence. Preserve unchecked limits. Do not reopen unrelated work.";
+  const spent = (): number => member.usage.input + member.usage.output;
   const halt = (reason: NonNullable<MemberState["repairStopReason"]>) => {
     if (member.repairStopReason) return;
     member.repairStopReason = reason;
-    fs.appendFileSync(path.join(run.runDir, `${member.name}.log`), `[horde] repair stop: ${reason}; allowance=${JSON.stringify(allowance)}; observed tokens=${member.usage.input + member.usage.output}\n`);
+    fs.appendFileSync(path.join(run.runDir, `${member.name}.log`), `[horde] repair stop: ${reason}; allowance=${JSON.stringify(allowance)}; observed tokens=${spent()} turns=${member.turns}\n`);
     hardStopMembers(run, [member.name]);
   };
   const check = () => {
+    if (firstTurn === undefined && member.turns > 0) {
+      const { input, output, cacheRead, cacheWrite } = member.usage;
+      firstTurn = { turns: member.turns, input, output, cacheRead, cacheWrite };
+    }
     const reason = stopReason(launch);
     if (reason) halt(reason);
-    else if (member.usage.input + member.usage.output >= tokens) halt("tokens");
+    else if (spent() >= allowance.tokens) halt("tokens");
+    else if (member.turns >= allowance.turns) halt("turns");
     else if (Date.now() >= deadline) halt("time");
   };
   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 } });
+    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";
@@ -91,12 +184,13 @@ async function repairMember(launch: RunLaunch, member: MemberState, deadline: nu
       await spawnOne(launch, member, undefined, check);
     }
     await recordEvent({ ...ctx, attempt: member.attempt }, "repair-end", { payload: {
-      cause: member.endCause, stopReason: member.repairStopReason, allowance, usage: member.usage, messages: queue.map((m) => m.id),
+      cause: member.endCause, stopReason: member.repairStopReason, allowance, usage: member.usage, turns: member.turns, firstTurn,
+      messages: queue.map((m) => m.id),
     } });
   } finally {
     clearTimeout(timeout);
     clearInterval(watchdog);
-    run.repairTokens = (run.repairTokens ?? 0) + member.usage.input + member.usage.output;
+    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];
@@ -109,10 +203,10 @@ export async function drainRepairs(launch: RunLaunch): Promise<void> {
   const { run } = launch;
   let started = false;
   // The repair phase is recorded only once an attempt or a budget refusal actually happens.
-  const begin = async (): Promise<void> => {
+  const begin = async (budget: RepairBudget): Promise<void> => {
     if (started) return;
     started = true;
-    await recordPhase(run, "repair", "start");
+    await recordPhase(run, "repair", "start", { budget });
   };
   try {
     await runRepairRounds(launch, begin);
@@ -121,35 +215,56 @@ export async function drainRepairs(launch: RunLaunch): Promise<void> {
   }
 }
 
-async function runRepairRounds(launch: RunLaunch, begin: () => Promise<void>): 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)
+    .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));
+}
+
+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)));
-  const deadline = Date.now() + Math.max(0, envNumber("PI_HORDE_REPAIR_MS", 120_000));
-  const tokenLimit = Math.max(0, envNumber("PI_HORDE_REPAIR_TOKENS", 50_000));
-  const tokenFloor = Math.max(0, envNumber("PI_HORDE_REPAIR_MIN_TOKENS", 20_000));
-  const exhausted = () => stopReason(launch) || Date.now() >= deadline || (run.repairTokens ?? 0) >= tokenLimit;
+  if (rounds === 0 || stopReason(launch)) return;
+  const floors = repairFloors();
+  await scheduleCollaboration(launch, { settleMs: 0, liveOnly: false });
+  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;
-    await scheduleCollaboration(launch, { settleMs: 0, liveOnly: false });
-    const eligible = run.members.map((member) => ({ member, queue: queueFor(launch, 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));
-    if (!eligible.length) return;
-    // Sequential attempts preserve owner -> reviewer ordering while reserving others' shares.
-    for (let index = 0; index < eligible.length; index++) {
+    if (round > 0) await scheduleCollaboration(launch, { settleMs: 0, liveOnly: false });
+    // 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 remaining = tokenLimit - (run.repairTokens ?? 0);
-      const tokens = repairAllowance(repairShare(remaining, pending.length, rounds - round - 1), remaining, tokenFloor);
-      const ms = repairShare(deadline - Date.now(), pending.length, rounds - round - 1);
+      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, pendingUnits, laterRounds, units), remaining, floors.tokens);
       if (tokens === undefined) {
-        await begin();
-        await recordSkipped(launch, pending.map((entry) => entry.member), { remaining, floor: tokenFloor });
+        await begin(budget);
+        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, pendingUnits, laterRounds, fundable, units), remainingMs, floors.ms);
+      if (ms === undefined || ms < 1) {
+        await begin(budget);
+        await recordSkipped(launch, unserved, "insufficient-time", { remainingMs, floorMs: floors.ms });
         return;
       }
-      if (ms < 1) break;
-      await begin();
-      await repairMember(launch, eligible[index]!.member, Date.now() + ms, tokens);
+      await begin(budget);
+      served.add(next.member.name);
+      await repairMember(launch, next.member, Date.now() + ms, { tokens, turns: budget.turns }, floors);
     }
   }
 }