agent-horde 0.1.5 → 0.1.6

package/src/run/schedule.ts

@@ -1,7 +1,7 @@
 import { collaborationState, openMessages } from "../ledger/collaboration.js";
 import type { ArtifactRecord, CollaborationState } from "../ledger/collaboration.js";
 import { runCollaborationAction } from "../tool/collaboration-actions.js";
-import { currentTarget } from "../tool/collaboration-target.js";
+import { currentTarget, targetInfo } from "../tool/collaboration-target.js";
 import type { MemberState } from "../member.js";
 import type { RunLaunch } from "./supervise.js";
 import { safeNotify } from "./ui.js";
@@ -24,12 +24,17 @@ interface ScheduleOptions {
   liveOnly: boolean;
 }
 
-/** The non-owner with the fewest open review requests; ties go to the verifier, then roster order. */
-function pickReviewer(launch: RunLaunch, load: Map<string, number>, owner: string, liveOnly: boolean): MemberState | undefined {
+/**
+ * A member that reviewed an earlier revision can reattest a behaviour-neutral change cheaply, so
+ * it goes first; otherwise the non-owner with the fewest open review requests, ties to the
+ * verifier, then roster order.
+ */
+function pickReviewer(launch: RunLaunch, load: Map<string, number>, owner: string, liveOnly: boolean, prior: Set<string>): MemberState | undefined {
   const { run } = launch;
   const count = (member: MemberState) => load.get(member.name) ?? 0;
   const candidates = run.members.filter((m) => m.name !== owner && (!liveOnly || m.status === "running"));
-  return candidates.sort((a, b) => count(a) - count(b) || Number(b.name === run.verifier) - Number(a.name === run.verifier))[0];
+  return candidates.sort((a, b) =>
+    Number(prior.has(b.name)) - Number(prior.has(a.name)) || count(a) - count(b) || Number(b.name === run.verifier) - Number(a.name === run.verifier))[0];
 }
 
 function reviewLoad(state: CollaborationState): Map<string, number> {
@@ -53,12 +58,17 @@ async function assignArtifactReviews(launch: RunLaunch, options: ScheduleOptions
     if (!settled(artifact, options.settleMs)) continue;
     if (state.reviews.some((r) => r.target === artifact.id && r.revision === artifact.hash)) continue;
     if (state.messages.some((m) => m.target === artifact.id && m.revision === artifact.hash && m.kind === "review-request")) continue;
-    const reviewer = pickReviewer(launch, load, artifact.owner, options.liveOnly);
+    const prior = new Set(state.reviews.filter((r) => r.target === artifact.id && r.actor !== artifact.owner).map((r) => r.actor));
+    const reviewer = pickReviewer(launch, load, artifact.owner, options.liveOnly, prior);
     if (!reviewer) continue;
+    const carry = prior.has(reviewer.name)
+      ? ` You reviewed an earlier revision${artifact.changeNote ? ` (owner's change note: ${artifact.changeNote})` : ""}: if what you checked is unchanged, reattest with evidence instead of repeating the review.`
+      : "";
     await runCollaborationAction(ctx, { action: "message", kind: "review-request", target: artifact.id, to: reviewer.name,
       text: `Independently check ${artifact.path}@${artifact.hash} (${artifact.kind ?? "runnable"}) against: ${artifact.criteria}. ` +
         `${artifact.kind === "document" ? "Full-scope sourced/derived review may establish document acceptance; this does not establish runtime reproduction." : "Runnable acceptance requires full independent tested/reproduced support."} ` +
-        "Attach evidence and record a revision-scoped review. The review closes this parent assignment; a failed/partial check opens a challenge to the owner.",
+        "Attach evidence and record a revision-scoped review: unchecked names in-criteria gaps, limits names what lies outside the criteria. " +
+        `The review closes this parent assignment; a refuting check opens a challenge to the owner.${carry}`,
       requestId: `review:${artifact.id}:${artifact.hash}` });
     load.set(reviewer.name, (load.get(reviewer.name) ?? 0) + 1);
   }
@@ -74,10 +84,23 @@ function successorOf(ctx: { hordeDir: string; runId: string; actor: string }, ta
   }
 }
 
+/** A pinned dependency whose current revision moved on, with the owner's change note when it is an artifact. */
+function revisionDrift(ctx: { hordeDir: string; runId: string; actor: string }, state: CollaborationState, dependency: ArtifactRecord["dependencies"][number]): string | undefined {
+  try {
+    const current = targetInfo(ctx, state, dependency.target).revision;
+    if (current === dependency.revision) return undefined;
+    const note = state.artifacts.find((a) => a.id === dependency.target)?.changeNote;
+    return `${dependency.target}@${dependency.revision.slice(0, 12)} -> @${current.slice(0, 12)}${note ? ` (${note})` : ""}`;
+  } catch {
+    return undefined;
+  }
+}
+
 /**
- * A superseded dependency excludes the artifact from acceptance. Repointing it automatically would
- * carry acceptance to content nobody reviewed against this artifact, so the owner is asked to
- * republish against the successor instead.
+ * A superseded or re-hashed dependency excludes the artifact from acceptance. Repointing it
+ * automatically would carry acceptance to content nobody reviewed against this artifact, so the
+ * owner is asked to republish against the successor or the new revision; reviewers of the old
+ * revision can then reattest when the change was behaviour-neutral.
  */
 async function assignDependencyRepins(launch: RunLaunch): Promise<void> {
   const { run } = launch;
@@ -89,12 +112,19 @@ async function assignDependencyRepins(launch: RunLaunch): Promise<void> {
       const successor = successorOf(ctx, target);
       return successor === undefined ? [] : [`${target} -> ${successor}`];
     });
-    if (!moved.length) continue;
+    const drifted = artifact.dependencies.flatMap((dependency) => {
+      const drift = successorOf(ctx, dependency.target) === undefined ? revisionDrift(ctx, state, dependency) : undefined;
+      return drift === undefined ? [] : [drift];
+    });
+    if (!moved.length && !drifted.length) continue;
     if (state.messages.some((m) => m.sender === "parent" && m.kind === "handoff" && m.target === artifact.id && m.revision === artifact.hash)) continue;
+    const parts = [
+      moved.length ? `Dependencies of ${artifact.id} were superseded (${moved.join(", ")}). Check the corrected findings, update ${artifact.path} where the correction changes it, and republish with dependsOn naming the successors.` : "",
+      drifted.length ? `Dependencies of ${artifact.id} changed revision (${drifted.join(", ")}). Check whether the change affects ${artifact.path}, then republish with dependsOn pinning the current revisions.` : "",
+      "Acceptance needs a review of the new revision; reviewers of the earlier one can reattest when the behaviour they checked is unchanged.",
+    ].filter(Boolean);
     await runCollaborationAction(ctx, { action: "message", kind: "handoff", target: artifact.id, to: artifact.owner,
-      text: `Dependencies of ${artifact.id} were superseded (${moved.join(", ")}). Check the corrected findings, update ${artifact.path} ` +
-        "where the correction changes it, and republish with dependsOn naming the successors. Acceptance needs a fresh review of the new revision.",
-      requestId: `repin:${artifact.id}:${artifact.hash}` });
+      text: parts.join(" "), requestId: `repin:${artifact.id}:${artifact.hash}` });
   }
 }
 

package/src/run/setup.ts

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

package/src/run/solved.ts

@@ -3,9 +3,10 @@ import { oneLine } from "../format.js";
 import { loadCollaborationReport } from "../collaboration-report.js";
 import { openMessages } from "../ledger/collaboration.js";
 import { postBoard } from "../ledger/board.js";
-import { unverifiedFindings } from "../ledger/findings.js";
+import { unsettledFactCitations } from "../ledger/facts.js";
+import { listFindingsForRun, staleAnswerCitations, unverifiedFindings } from "../ledger/findings.js";
 import { listIdeas } from "../ledger/ideas.js";
-import { archiveSolved, clearCleanStop, clearSolved, readSolvedState, resolveSolvedState } from "../ledger/run-signals.js";
+import { archiveSolved, clearCleanStop, clearSolved, readSolvedState, reopenSolved, resolveSolvedState, writeAnswer } from "../ledger/run-signals.js";
 import type { SolvedSignal } from "../ledger/run-signals.js";
 import { requestCleanStop } from "./controls.js";
 import { recordLifecycle } from "./lifecycle.js";
@@ -46,14 +47,12 @@ function adoptProposal(run: HordeRun, proposal: SolvedSignal): void {
   refreshRun(run);
 }
 
-function dropContested(run: HordeRun, contest: SolvedSignal): void {
-  safeNotify(run, `horde ${run.id}: solved proposal contested by ${contest.member}`, "warning");
-  void recordLifecycle(run, "solved-contested", { member: contest.member, text: oneLine(contest.text, 200) });
-  void postBoard(
-    run.hordeDir,
-    "parent",
-    `SOLVED proposal contested by ${contest.member}: ${contest.text}. Work continues.`,
-  );
+/** Idea ids a contest names as what is still missing; the proposal reopens once they close. */
+export function contestBlockers(text: string): number[] {
+  return [...new Set([...text.matchAll(/(?:^|[\s(,;])#(\d{1,6})\b/g)].map((m) => Number(m[1])))];
+}
+
+function clearProposal(run: HordeRun): void {
   archiveSolved(run.runDir);
   clearSolved(run.runDir);
   if (!run.stopped) clearCleanStop(run.runDir);
@@ -62,10 +61,76 @@ function dropContested(run: HordeRun, contest: SolvedSignal): void {
   run.solvedCommitted = false;
   run.solvedCoverageNotice = undefined;
   run.solvedVerificationNotice = undefined;
+}
+
+function dropContested(run: HordeRun, proposal: SolvedSignal, contest: SolvedSignal): void {
+  const blockers = contestBlockers(contest.text);
+  safeNotify(run, `horde ${run.id}: solved proposal contested by ${contest.member}`, "warning");
+  void recordLifecycle(run, "solved-contested", { member: contest.member, text: oneLine(contest.text, 200), blockers });
+  const reopens = blockers.length ? ` It reopens for validation once ${blockers.map((id) => `#${id}`).join(", ")} are done or ruled out.` : "";
+  void postBoard(
+    run.hordeDir,
+    "parent",
+    `SOLVED proposal contested by ${contest.member}: ${contest.text}. Work continues.${reopens}`,
+  );
+  clearProposal(run);
   run.solvedContested = true;
+  run.solvedContest = blockers.length ? { proposal, blockers } : undefined;
   refreshRun(run);
 }
 
+/**
+ * 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.
+ */
+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 });
+  void postBoard(
+    run.hordeDir,
+    "parent",
+    `SOLVED proposal by ${proposal.member} withdrawn: it ${reason}. ${proposal.member}: propose again citing the current findings.`,
+  );
+  clearProposal(run);
+  refreshRun(run);
+}
+
+/**
+ * A contest that named open ideas as what was missing is answered by their closing: nothing else
+ * reopens the vote, so the run ended `solved-contested` with the closed negatives unapplied.
+ */
+function reopenContested(run: HordeRun): void {
+  const contest = run.solvedContest;
+  if (!contest || run.stopped) return;
+  const closed = new Map(listIdeas(run.hordeDir).map((idea) => [idea.id, idea.mark === "x" || idea.mark === "!"]));
+  if (!contest.blockers.every((id) => closed.get(id))) return;
+  const named = contest.blockers.map((id) => `#${id}`).join(", ");
+  const reason = `contest blockers ${named} closed`;
+  // 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),
+    ...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 });
+    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;
+  }
+  const signal = reopenSolved(run.runDir, run.id, contest.proposal, `re-opened: ${reason}; awaiting validation`, contest.proposal.cites);
+  run.solvedContested = false;
+  void recordLifecycle(run, "solved-reopened", { member: signal.member, reason, revision: signal.revision });
+  void postBoard(
+    run.hordeDir,
+    "parent",
+    `SOLVED proposal by ${signal.member} re-opened: ${reason}. Another member must validate it against the closed ideas with 'horde confirm-solved' or contest it again.`,
+  );
+}
+
 /**
  * Coverage is structural: a run that created ideas must close them before a
  * solve winds it down, regardless of the prompt's wording. A run that created
@@ -124,11 +189,43 @@ function verificationPending(run: HordeRun, othersRunning: boolean): boolean {
   return true;
 }
 
+/**
+ * `--until-stop`: bank the answer as the run's current one and reopen the proposal slot, so a
+ * materially better answer can be proposed later. Nobody is stopped; the supervisor gives every
+ * member that finishes a fresh session.
+ */
+function bankSolved(run: HordeRun, proposal: SolvedSignal, validator: string | undefined): void {
+  run.solveRounds = (run.solveRounds ?? 0) + 1;
+  run.lastRound = { proposal, validator };
+  const status = validator ? `validated by ${validator}` : "committed without a separate validator";
+  try {
+    writeAnswer(run.runDir, run.id, proposal, `${status} (banked as round ${run.solveRounds}; the run continues until stopped)`);
+  } catch (error) {
+    safeNotify(run, `horde ${run.id}: could not write ANSWER.md (${oneLine(String(error), 200)})`, "error");
+  }
+  clearProposal(run);
+  run.solvedContest = undefined;
+  void recordLifecycle(run, "solved-banked", { round: run.solveRounds, member: proposal.member, validator });
+  safeNotify(run, `horde ${run.id}: solve banked as round ${run.solveRounds}; the run continues until stopped`, "info");
+  void postBoard(
+    run.hordeDir,
+    "parent",
+    `SOLVED ${status}, banked as round ${run.solveRounds}: ${oneLine(proposal.text, 200)}. ` +
+      "This run continues until the user stops it. Keep working: extend, stress-test, or deepen the work, " +
+      "add ideas for what is still unexplored, and propose SOLVED again only when a materially better answer exists.",
+  );
+  refreshRun(run);
+}
+
 function commitSolved(
   run: HordeRun,
   ctx: ExtensionCommandContext,
   validator: string | undefined,
 ): void {
+  if (run.untilStop && run.solved && !run.stopped) {
+    bankSolved(run, run.solved, validator);
+    return;
+  }
   run.solvedValidatedBy = validator;
   run.solvedCommitted = true;
   void recordLifecycle(run, "solved-validated", { validator });
@@ -150,13 +247,24 @@ function commitSolved(
 }
 
 /** One poll of the two-phase solved protocol. */
-function checkSolved(run: HordeRun, ctx: ExtensionCommandContext): void {
+export function checkSolved(run: HordeRun, ctx: ExtensionCommandContext): void {
   const state = resolveSolvedState(readSolvedState(run.runDir));
-  if (!run.solved && state.proposal) adoptProposal(run, state.proposal);
+  if (!run.solved && state.proposal) {
+    run.solvedContest = undefined;
+    adoptProposal(run, state.proposal);
+  }
   const solved = run.solved;
-  if (!solved) return;
+  if (!solved) {
+    reopenContested(run);
+    return;
+  }
   if (state.contest) {
-    dropContested(run, state.contest);
+    dropContested(run, solved, state.contest);
+    return;
+  }
+  const stale = staleAnswerCitations(listFindingsForRun(run.hordeDir, run.id), solved.text, solved.cites);
+  if (stale.length && !run.solvedCommitted) {
+    withdrawStale(run, solved, stale);
     return;
   }
   const validator =
@@ -167,7 +275,9 @@ function checkSolved(run: HordeRun, ctx: ExtensionCommandContext): void {
   if (coveragePending(run, validator)) return;
   const collaboration = loadCollaborationReport(run.hordeDir, run.id);
   if (collaboration.issues.length || openMessages(collaboration.state).length) return;
-  const othersRunning = run.members.some(
+  // Members of an `--until-stop` run are always coming back, so a lull between sessions is not
+  // the absence of a validator; the proposal waits for one or for the timeout.
+  const othersRunning = run.untilStop === true || run.members.some(
     (member) =>
       (member.status === "running" || member.status === "starting") &&
       member.name !== solved.member,

package/src/run/supervise.ts

@@ -4,6 +4,7 @@ import * as path from "node:path";
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { envNumber, errorMessage } from "../format.js";
 import { postBoard } from "../ledger/board.js";
+import { pendingReviewsForMember } from "../ledger/findings.js";
 import { reconcileOwnedIdeas } from "../ledger/ideas.js";
 import { cleanStopRequestedFor, clearHeartbeat, readHeartbeat } from "../ledger/run-signals.js";
 import { resetMemberState, spawnMember } from "../member.js";
@@ -22,6 +23,17 @@ const RESET_CAP = envNumber("PI_HORDE_RESET_CAP", 2);
 /** Member exits that a fresh session may recover from; a user stop is never one. */
 const RESETTABLE_CAUSES = new Set(["model_error", "no_output", "exit_nonzero"]);
 
+/**
+ * An `--until-stop` session that finished sooner than this is held back until it has been this
+ * long since it started, so a member that keeps finding nothing to do cannot spin through
+ * sessions, each paying the full prompt for nothing.
+ */
+const CONTINUE_COOLDOWN_MS = envNumber("PI_HORDE_CONTINUE_COOLDOWN_MS", 60_000);
+
+const CONTINUE_REASON = "until-stop: earlier session finished";
+
+const sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms).unref?.());
+
 /** What spawning and supervising a run's members needs beyond the run itself. */
 export interface RunLaunch {
   state: HordeState;
@@ -80,16 +92,34 @@ export async function spawnOne(
  * stop all mean the run is ending; the cap keeps a broken provider from being
  * retried forever.
  */
-function resetReasonForExit(launch: RunLaunch, member: MemberState): string | undefined {
-  const { state, run } = launch;
-  if (state.disposed || run.stopped || run.userStop || run.solved || run.canary !== "ok") {
+/**
+ * A verifier that closes its session with high-importance findings by other members unreviewed
+ * has not done its job, whatever its summary says. Its exit is answered with a fresh session
+ * that is told which F# it owes, within the same reset cap as a crash.
+ */
+export function verificationBacklog(run: HordeRun, member: MemberState): string | undefined {
+  if (member.name !== run.verifier || member.endCause !== "completed") return undefined;
+  try {
+    const owed = pendingReviewsForMember(run.hordeDir, run.id, member.name)
+      .filter((finding) => ["critical", "high"].includes((finding.importance ?? "").toLowerCase()));
+    if (!owed.length) return undefined;
+    return `verification backlog: ${owed.map((finding) => `F${finding.id}`).join(", ")} unreviewed at close`;
+  } catch {
     return undefined;
   }
+}
+
+function resetReasonForExit(launch: RunLaunch, member: MemberState): string | undefined {
+  const { state, run } = launch;
+  if (state.disposed || run.stopped || run.userStop || run.canary !== "ok") return undefined;
+  // A pending proposal means the run is about to end, unless it runs until stopped.
+  if (run.solved && !run.untilStop) return undefined;
   if (cleanStopRequestedFor(run.hordeDir, run.id, member.name)) return undefined;
   const reason =
     member.resetPending ??
-    (RESETTABLE_CAUSES.has(member.endCause ?? "") ? member.endCause : undefined);
-  if (!reason) return undefined;
+    (RESETTABLE_CAUSES.has(member.endCause ?? "") ? member.endCause : undefined) ??
+    verificationBacklog(run, member);
+  if (!reason) return run.untilStop && member.endCause === "completed" ? CONTINUE_REASON : undefined;
   if ((member.resets ?? 0) >= RESET_CAP) {
     fs.appendFileSync(
       path.join(run.runDir, `${member.name}.log`),
@@ -115,10 +145,13 @@ async function releaseForReset(
     const releasedText = released.map((id) => `#${id}`).join(", ") || "none";
     const closedText =
       result.closed.map((item) => `#${item.id} (F${item.findingId})`).join(", ") || "none";
+    const head = reason === CONTINUE_REASON
+      ? `${member.name} finished and continues in a fresh session (${run.id} runs until stopped)`
+      : `reset ${member.name} (${reason})`;
     await postBoard(
       run.hordeDir,
       "parent",
-      `reset ${member.name} (${reason}): released ${releasedText}; closed ${closedText}. ` +
+      `${head}: released ${releasedText}; closed ${closedText}. ` +
         `A fresh session of ${member.name} starts now; earlier claims by ${member.name} ` +
         "are void.",
     );
@@ -157,13 +190,41 @@ async function performReset(run: HordeRun, member: MemberState, reason: string):
   await recordLifecycle(run, "member-reset", { member: member.name, reason, released, closed, resets: member.resets });
   member.resetNote =
     `You replace an earlier session of ${member.name} that was reset for ${reason}; ` +
-    "its ideas were released. Read BOARD.md and FINDINGS.md before claiming.";
+    "its ideas were released. Read BOARD.md and FINDINGS.md before claiming." +
+    (reason.startsWith("verification backlog") ? " Review the findings named above, with any verdict and an honest unchecked scope, before anything else." : "");
   clearHeartbeat(run.runDir, member.name);
   resetMemberState(member);
   safeNotify(run, `horde ${run.id}: reset ${member.name} (${reason})`, "warning");
   refreshRun(run);
 }
 
+/**
+ * `--until-stop`: a member that finished its session gets a fresh one. Not a recovery, so it
+ * counts against no cap and is not a reset in the report; the cooldown keeps a member that
+ * finds nothing to do from spinning.
+ */
+async function performContinue(run: HordeRun, member: MemberState): Promise<boolean> {
+  const elapsed = Date.now() - member.startedAt;
+  if (elapsed < CONTINUE_COOLDOWN_MS) await sleep(CONTINUE_COOLDOWN_MS - elapsed);
+  // A stop during the cooldown leaves the member as it ended: finished, not killed.
+  if (run.stopped) return false;
+  member.continuations = (member.continuations ?? 0) + 1;
+  fs.appendFileSync(
+    path.join(run.runDir, `${member.name}.log`),
+    `[horde] continue ${member.continuations}: ${CONTINUE_REASON}\n`,
+  );
+  const { released, closed } = await releaseForReset(run, member, CONTINUE_REASON);
+  await recordLifecycle(run, "member-continue", { member: member.name, released, closed, continuations: member.continuations });
+  member.resetNote =
+    `You are a fresh session of ${member.name}; its earlier session finished and its claims were released. ` +
+    "Read BOARD.md, FINDINGS.md and ANSWER.md if present, then add ideas that extend, stress-test, or deepen the work, claim them, and pursue them.";
+  clearHeartbeat(run.runDir, member.name);
+  resetMemberState(member);
+  safeNotify(run, `horde ${run.id}: ${member.name} finished; continuing in a fresh session`, "info");
+  refreshRun(run);
+  return true;
+}
+
 /**
  * Resolves only when the member is down for good, so the fan-out's
  * Promise.all cannot finalize the run while a replacement is running.
@@ -179,7 +240,11 @@ export async function superviseMember(
     await exited;
     const reason = resetReasonForExit(launch, member);
     if (!reason || state.disposed) return;
-    await performReset(run, member, reason);
+    if (reason === CONTINUE_REASON) {
+      if (!(await performContinue(run, member))) return;
+    } else {
+      await performReset(run, member, reason);
+    }
     if (run.stopped || state.disposed) {
       // A stop landed during the reset: leave the member down, not "starting".
       member.status = "stopped";
@@ -196,7 +261,7 @@ export async function superviseMember(
  * hung. Mark it and kill it; the supervise loop turns the kill into a reset.
  */
 function checkStalls(run: HordeRun): void {
-  if (run.stopped || run.solved) return;
+  if (run.stopped || (run.solved && !run.untilStop)) return;
   const now = Date.now();
   for (const member of run.members) {
     if (member.status !== "running" || member.paused || member.resetPending) continue;

package/src/run/types.ts

@@ -67,8 +67,14 @@ export interface HordeRun extends MemberRunInfo {
   solvedCommitted?: boolean | undefined;
   /** True when the last SOLVED proposal was contested and no validated answer replaced it. */
   solvedContested?: boolean | undefined;
+  /** The contested proposal and the idea ids its contest named; it reopens once they all close. */
+  solvedContest?: { proposal: SolvedSignal; blockers: number[] } | undefined;
   /** True once the parent has warned that a validated solve still has unverified findings. */
   solvedVerificationNotice?: boolean | undefined;
+  /** Solves banked so far in an `--until-stop` run. */
+  solveRounds?: number | undefined;
+  /** The latest banked solve of an `--until-stop` run: the answer unless a later proposal is validated. */
+  lastRound?: { proposal: SolvedSignal; validator: string | undefined } | undefined;
   solvedTimer?: ReturnType<typeof setInterval> | undefined;
   solvedCoverageNotice?: boolean | undefined;
   postmortemAbort?: AbortController | undefined;

package/src/run-graph.ts

@@ -360,10 +360,13 @@ function addReview(draft: Draft, event: HordeEvent, review: Payload): void {
   if (!id) return;
   const verdict = str(review.verdict) ?? "review";
   const support = str(review.support) ?? "";
-  const scope = `checked: ${str(review.checked) ?? ""}; unchecked: ${str(review.unchecked) || "none declared"}`;
+  const limits = str(review.limits) ? `; limits: ${str(review.limits)}` : "";
+  const scope = `checked: ${str(review.checked) ?? ""}; unchecked: ${str(review.unchecked) || "none declared"}${limits}`;
   const title = oneLine(`[${support}] ${scope}. ${str(review.text) ?? ""}`, TITLE_MAX);
   if (!addEntity(draft, event, { id, kind: "review", label: `${id} ${verdict}`, title })) return;
   addEdge(draft, id, str(review.target), verdict, relationTone(verdict));
+  const reattests = str(review.reattests);
+  if (reattests && draft.nodes.has(reattests)) draft.edges.push({ from: reattests, to: id, label: "reattested", tone: "collaboration" });
   for (const ref of strings(review.evidence)) {
     if (draft.nodes.has(ref)) draft.edges.push({ from: ref, to: id, label: "cited", tone: "collaboration" });
   }
@@ -427,7 +430,7 @@ const COLLABORATION: Record<string, Handler> = {
 function lifecycleText(action: string, p: Payload): [string, string] {
   const members = strings(p.members).join(", ");
   switch (action) {
-    case "run-start": return ["run start", `${num(p.count) ?? "?"} members${str(p.model) ? `, model ${str(p.model)}` : ""}`];
+    case "run-start": return ["run start", `${num(p.count) ?? "?"} members${str(p.model) ? `, model ${str(p.model)}` : ""}${p.untilStop === true ? ", until stop" : ""}`];
     case "run-end": return ["run end", `outcome ${str(p.outcome) ?? "unknown"}`];
     case "member-spawn": return ["spawn", str(p.role) ? `role: ${oneLine(str(p.role) ?? "", 120)}` : "spawned"];
     case "member-exit": return [`exit ${str(p.endCause) ?? ""}`.trim(), `status ${str(p.status) ?? "?"}, ${num(p.turns) ?? 0} turns, ${num(p.tokens) ?? 0} tokens`];
@@ -436,7 +439,11 @@ function lifecycleText(action: string, p: Payload): [string, string] {
     case "stop-hard": return [`stop-hard (${str(p.by) ?? "user"})`, members || "all members"];
     case "solved-proposed": return ["solved proposed", `${str(p.member) ?? ""}: ${oneLine(str(p.text) ?? "", 120)}`];
     case "solved-contested": return ["solved contested", `by ${str(p.member) ?? ""}`];
+    case "solved-withdrawn": return ["solved withdrawn", oneLine(str(p.reason) ?? "", 120)];
+    case "solved-reopened": return ["solved reopened", oneLine(str(p.reason) ?? "", 120)];
     case "solved-validated": return ["solved validated", str(p.validator) ? `by ${str(p.validator)}` : "without a separate validator"];
+    case "solved-banked": return [`solved banked (round ${num(p.round) ?? "?"})`, str(p.validator) ? `by ${str(p.validator)}` : "without a separate validator"];
+    case "member-continue": return ["continue", `fresh session ${num(p.continuations) ?? "?"}; released ${strings(p.released).length}, closed ${strings(p.closed).length}`];
     case "acceptance": return [`acceptance ${str(p.status) ?? ""}`.trim(), `${num(p.issues) ?? 0} issues, snapshot ${(str(p.hash) ?? "").slice(0, 12)}`];
     case "repair-start": return ["repair start", `queue ${strings(p.messages).join(", ")}`];
     case "repair-end": return ["repair end", `${str(p.cause) ?? ""}${str(p.stopReason) ? ` (${str(p.stopReason)})` : ""}`];