pi-plans 0.5.7 → 0.7.0

package/src/refine-prompts.ts

@@ -17,11 +17,11 @@ export const REVIEWER_LENSES: readonly ReviewerLane[] = [
 	{ id: "verification", lens: "verification rigor, risks, and evidence gaps" },
 ] as const;
 
-function buildSharedHeader(role: "reviewer" | "criticizer", opts: RefinePromptInput): string {
-	const lensLine = role === "reviewer" && opts.lens ? `\nReview lens: ${opts.lens}.` : "";
+function buildSharedHeader(opts: RefinePromptInput): string {
+	const lensLine = opts.lens ? `\nReview lens: ${opts.lens}.` : "";
 	const focusLine = opts.focus ? `\n\nSpecific concerns from the main agent: ${opts.focus}` : "";
 	const contextLine = opts.context ? `\n\nContext: ${opts.context}` : "";
-	return `Goal: ${role === "reviewer" ? "review the plan against the repository" : "stress-test the plan's assumptions"}.
+	return `Goal: review the plan against the repository and surface what needs the user's judgment.
 
 Target: ${opts.planPath}
 
@@ -30,23 +30,6 @@ Authority boundary: read-only analysis only. Do not edit, write, delete, commit,
 Evidence: inspect the repository with read, grep, find, and ls before judging the plan.${lensLine}${focusLine}${contextLine}`;
 }
 
-/** Shared header for the post-execution implementation review: the
- * accepted plan is the contract, the IMPLEMENTATION in the worktree is
- * under review. Findings must anchor to the plan's goals/acceptance
- * criteria and explicitly assess delivery maturity. */
-function buildImplementationSharedHeader(role: "reviewer" | "criticizer", opts: RefinePromptInput): string {
-	const lensLine = role === "reviewer" && opts.lens ? `\nReview lens: ${opts.lens}.` : "";
-	const focusLine = opts.focus ? `\n\nSpecific concerns from the main agent: ${opts.focus}` : "";
-	const contextLine = opts.context ? `\n\nContext: ${opts.context}` : "";
-	return `Goal: ${role === "reviewer" ? "review the implemented result in the worktree against the plan" : "stress-test the implemented result's assumptions"}.
-
-Target: ${opts.planPath} (the accepted plan; the IMPLEMENTATION in the worktree is under review)
-
-Authority boundary: read-only analysis only. Do not edit, write, delete, commit, push, or spawn subagents.
-
-Evidence: inspect the repository with read, grep, find, and ls before judging the implementation. Judge the implementation against the plan's goals, verifier checklist, and acceptance criteria. Explicitly assess delivery maturity: did the executor ship a minimal MVP only, or refine for long-term growth (no stopgaps, long-term architectural decisions, missing tests, technical debt, production readiness)? Calibrate severity accordingly. Out-of-scope improvement ideas are low severity by default and must not be forced into findings.${lensLine}${focusLine}${contextLine}`;
-}
-
 export function reviewerLanes(count: number): ReviewerLane[] {
 	if (count === 3) return [...REVIEWER_LENSES];
 	if (count === 2) return [...REVIEWER_LENSES.slice(0, 2)];
@@ -54,47 +37,22 @@ export function reviewerLanes(count: number): ReviewerLane[] {
 }
 
 export function buildReviewerTask(opts: RefinePromptInput): string {
-	return `${buildSharedHeader("reviewer", opts)}
-
-Success criteria: return evidence-backed findings or explicitly say the plan holds up.
-
-Output: Markdown, highest severity first. For each finding use this shape:
-- \`F-###\` — severity: high | medium | low; affected plan IDs (e.g. R-001, I-003); evidence: repo path/command or external source that proves it; impact; recommended fix; suggested disposition (accept | reject | needs-discussion).
-
-Surface at most five high-priority findings; list lower-severity findings after them. If the plan holds up, say so explicitly and list what you checked.
-
-Plan file: ${opts.planPath}
-
----8<--- PLAN CONTENT ---8<---
-${opts.planText}
----8<--- END PLAN CONTENT ---8<---`;
-}
+	return `${buildSharedHeader(opts)}
 
-export function buildCriticizerTask(opts: RefinePromptInput): string {
-	return `${buildSharedHeader("criticizer", opts)}
+Success criteria: return evidence-backed findings, plus the questions only the user can settle. If the plan holds up, say so explicitly and list what you checked.
 
-Success criteria: return concrete, answerable questions only; never rewrite the plan.
+Output: Markdown with exactly two top-level parts, in this order.
 
-Output: Markdown in exactly this shape:
-1. A summary of your core criticism in at most three sentences, highlighting the single most important point.
-2. Then at most five adaptive questions, numbered, each with one line of why it matters. Questions must be answerable by a user with repo access — never rhetorical. Stop earlier if the plan genuinely holds.
+## Findings
 
-Plan file: ${opts.planPath}
-
----8<--- PLAN CONTENT ---8<---
-${opts.planText}
----8<--- END PLAN CONTENT ---8<---`;
-}
-
-export function buildImplementationReviewerTask(opts: RefinePromptInput): string {
-	return `${buildImplementationSharedHeader("reviewer", opts)}
+Highest severity first. For each finding use this shape:
+- \`F-###\` — severity: high | medium | low; affected plan IDs (e.g. R-001, I-003); evidence: repo path/command or external source that proves it; impact; recommended fix; suggested disposition (accept | reject | needs-discussion).
 
-Success criteria: return evidence-backed findings or explicitly say the implementation holds up.
+Surface at most five high-priority findings; list lower-severity findings after them. Write "None." when there are none.
 
-Output: Markdown, highest severity first. For each finding use this shape:
-- \`F-###\` — severity: high | medium | low; affected plan IDs (e.g. R-001, I-003) or files; evidence: repo path/command that proves it; impact; recommended fix; suggested disposition (accept | reject | needs-discussion).
+## Questions
 
-Surface at most five high-priority findings; list lower-severity findings after them. If the implementation holds up, say so explicitly and list what you checked.
+At most five numbered questions (\`Q-1\`, \`Q-2\`, …) covering everything that needs the user's decision before the plan can be safely revised — hidden trade-offs, undetermined semantics, accept/reject calls on findings marked needs-discussion. Each question gets one line of why it matters, phrased so a user with repo access can answer it concretely. Never rhetorical; never questions the repository itself already answers. Stop earlier if nothing genuinely needs the user.
 
 Plan file: ${opts.planPath}
 
@@ -144,7 +102,7 @@ Local path (your working directory): ${opts.localPath}
 
 Authority boundary: read-only analysis only. Do not edit, write, delete, commit, push, or spawn subagents. Stay inside the reference directory.
 
-Evidence: inspect the reference with read, grep, find, and ls before judging it. Cite files as <relative-path>:<line> for every claim; quote only what you verified.${contextLine}${languageLine}
+Evidence: inspect the reference with read, grep, find, and ls before judging it. Cite evidence for every claim in the medium's format — code: <relative-path>:<line>; papers: section/theorem/table numbers with a short quote; blogs/docs: the heading or quoted passage. Quote only what you verified. Medium-aware deep-read: repos go through entry points, core modules, tests, and configuration; papers through claims, method, limitations, and experiments; blogs/docs through technique, measurements, and caveats. Theoretical grounding counts — an algorithm, a formal property, or a measured tradeoff is as adoptable as an implementation pattern.${contextLine}${languageLine}
 
 Success criteria: a structured analysis the main agent can paste into REF_ANALYSIS.md and turn into adoption questions.
 
@@ -157,23 +115,7 @@ Section contracts:
 - Key Mechanisms And Design Tradeoffs: the mechanisms that make it work and the tradeoffs they embody.
 - Adoptable Ideas For The Target Repo: concrete, portable ideas ranked by expected value; name the target-repo surface each would touch.
 - Pitfalls And Anti-Patterns: what to avoid when borrowing; failure modes the reference itself documents or exhibits.
-- Evidence Citations: the file:line references backing the claims above.
+- Evidence Citations: the evidence references backing the claims above (file:line for code; section/theorem/table + quote for papers; heading/quote for blogs and docs).
 - Coverage: which parts of the reference you actually read versus skipped.
 - Evidence Gaps: what you could not determine from the reference alone.`;
 }
-
-export function buildImplementationCriticizerTask(opts: RefinePromptInput): string {
-	return `${buildImplementationSharedHeader("criticizer", opts)}
-
-Success criteria: return concrete, answerable questions only; never rewrite the plan or the implementation.
-
-Output: Markdown in exactly this shape:
-1. A summary of your core criticism in at most three sentences, highlighting the single most important point.
-2. Then at most five adaptive questions, numbered, each with one line of why it matters. Questions must be answerable by a user with repo access — never rhetorical. Stop earlier if the implementation genuinely holds.
-
-Plan file: ${opts.planPath}
-
----8<--- PLAN CONTENT ---8<---
-${opts.planText}
----8<--- END PLAN CONTENT ---8<---`;
-}

package/src/refine-ui-helpers.ts

@@ -10,11 +10,30 @@
 const ELLIPSIS = "…";
 
 /**
- * ECMA-48 CSI sequence: ESC [ parameter bytes (0x30-0x3F), intermediate bytes
- * (0x20-0x2F), final byte (0x40-0x7E). Matched atomically so styling payloads
- * never leak into width math and are never split mid-sequence.
+ * ECMA-48 escape sequences. ALL of them render at zero width, so styling and
+ * control payloads must never leak into width math nor be split mid-sequence.
+ *
+ * Three families are recognised:
+ *  - CSI: `ESC [ params intermediates final`           (SGR colours, cursor moves)
+ *  - String-terminated: `ESC ] _ P X ^` … `BEL`|`ST`  (OSC, APC, DCS, SOS, PM)
+ *  - Simple: `ESC` intermediates `final`               (`ESC c`, `ESC (B`, `ESC 7`)
+ *
+ * The string family matters beyond colour: pi's `CURSOR_MARKER` is an APC
+ * sequence (`ESC _ pi:c BEL`). Counting its payload as visible text made every
+ * row carrying the marker — e.g. a focused search Input — measure several
+ * columns too wide, which pushed that row's right-hand border out of
+ * alignment. The terminator is required: a well-formed sequence always has
+ * one, and refusing malformed ones keeps the fallback (the simple family)
+ * from swallowing real text.
  */
-const CSI_PATTERN = /\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/g;
+const ESCAPE_PATTERN = new RegExp(
+	[
+		"\\x1b\\[[\\x30-\\x3f]*[\\x20-\\x2f]*[\\x40-\\x7e]", // CSI
+		"\\x1b[\\]PX^_][^\\x07\\x1b]*(?:\\x07|\\x1b\\\\)", // OSC / APC / DCS / SOS / PM
+		"\\x1b[\\x20-\\x2f]*[\\x30-\\x7e]", // simple escapes
+	].join("|"),
+	"g",
+);
 
 interface AnsiPart {
 	kind: "csi" | "text";
@@ -24,7 +43,7 @@ interface AnsiPart {
 function splitAnsi(text: string): AnsiPart[] {
 	const parts: AnsiPart[] = [];
 	let last = 0;
-	for (const match of text.matchAll(CSI_PATTERN)) {
+	for (const match of text.matchAll(ESCAPE_PATTERN)) {
 		const start = match.index ?? 0;
 		if (start > last) parts.push({ kind: "text", value: text.slice(last, start) });
 		parts.push({ kind: "csi", value: match[0] });

package/src/refine-ui-state.ts

@@ -1,6 +1,6 @@
 import type { SubagentProgressEvent, SubagentResult } from "./subagent.ts";
 
-export type RefineOverlayRole = "reviewer" | "criticizer" | "refs";
+export type RefineOverlayRole = "reviewer" | "refs";
 export type RefineLaneStatus = "queued" | "running" | "complete" | "failed" | "cancelled";
 export type RefineTranscriptEntryType = "assistant-text" | "thinking" | "tool-call" | "tool-result" | "diagnostic";
 

package/src/refine-ui.ts

@@ -166,7 +166,7 @@ function summaryFor(role: RefineOverlayRole, lanes: RefineLaneState[], modelLabe
 	const complete = lanes.filter((lane) => lane.status === "complete").length;
 	const terminal = lanes.filter((lane) => ["complete", "failed", "cancelled"].includes(lane.status)).length;
 	const running = lanes.filter((lane) => lane.status === "running").length;
-	const title = role === "reviewer" ? "Reviewer" : role === "refs" ? "Refs" : "Criticizer";
+	const title = role === "reviewer" ? "Reviewer" : "Refs";
 	const visibleTitle = modelLabel ? `${title} (${modelLabel})` : title;
 	const state = terminal === lanes.length ? "done" : running > 0 ? `${running} running` : "queued";
 	return `${visibleTitle} · ${complete}/${lanes.length} done · ${state}`;

package/src/resume-command.ts

@@ -12,14 +12,14 @@
  * - R-007: after every dialog the world is re-checked; one kickoff max.
  */
 
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import * as fs from "node:fs";
 import { existsSync } from "node:fs";
 import * as path from "node:path";
 import { loadExecutionFromCheckpoint } from "./exec.ts";
-import { bindRun } from "./run-context.ts";
+import { bindRun, boundRunId } from "./run-context.ts";
 import { acquireOwnership, OwnershipError, releaseOwnership } from "./run-ownership.ts";
-import { loadConfig, resolveStateRootOrNull, setRunStatus, updateRunWorkdir } from "./state.ts";
+import { loadConfig, resolveArtifactRoot, resolveStateRootOrNull, setRunStatus, updateRunWorkdir } from "./state.ts";
 import {
 	applyMigration,
 	mutateCheckpoint,
@@ -35,12 +35,12 @@ import {
 	reconcileCheckpointWithLedger,
 	type ResumeCandidate,
 } from "./resume.ts";
+import { messaging } from "./messaging.ts";
 
 /** One kickoff per invocation; repeat invocations are blocked by the idle check. */
 let inFlight = false;
 
 export async function resumePlansCommand(
-	pi: ExtensionAPI,
 	ctx: ExtensionContext,
 	baseDir: string,
 ): Promise<void> {
@@ -50,13 +50,13 @@ export async function resumePlansCommand(
 	}
 	inFlight = true;
 	try {
-		await run(pi, ctx, baseDir);
+		await run(ctx, baseDir);
 	} finally {
 		inFlight = false;
 	}
 }
 
-async function run(pi: ExtensionAPI, ctx: ExtensionContext, baseDir: string): Promise<void> {
+async function run(ctx: ExtensionContext, baseDir: string): Promise<void> {
 	if (!ctx.hasUI) {
 		ctx.ui.notify?.("/resume-plans needs an interactive session (TUI/RPC); print/json cannot resume.", "warning");
 		return;
@@ -73,7 +73,11 @@ async function run(pi: ExtensionAPI, ctx: ExtensionContext, baseDir: string): Pr
 		return;
 	}
 
-	let candidate = pickDefaultCandidate(ctx.cwd, candidates);
+	// v0.6.0 (D-1): a session-bound resumable run resumes directly; the
+	// active-pointer auto-win is gone — ambiguity opens the descriptive form.
+	const bound = boundRunId(ctx.sessionManager, ctx.cwd);
+	const boundCandidate = bound ? candidates.find((candidate) => candidate.runId === bound) ?? null : null;
+	let candidate = boundCandidate ?? pickDefaultCandidate(ctx.cwd, candidates);
 	if (candidate === null) {
 		const labels = candidates.map((entry, index) => {
 			const cross = entry.crossWorktree ? " · cross-worktree" : "";
@@ -101,7 +105,7 @@ async function run(pi: ExtensionAPI, ctx: ExtensionContext, baseDir: string): Pr
 	}
 	if (candidate.checkpointStatus === "corrupt") {
 		ctx.ui.notify(
-			`Checkpoint for ${candidate.runId} is corrupt (${candidate.checkpointError ?? "unknown"}). Repair or remove .git/pi_plans/runs/${candidate.runId}/checkpoint.json explicitly; nothing was changed.`,
+			`Checkpoint for ${candidate.runId} is corrupt (${candidate.checkpointError ?? "unknown"}). Repair or remove .git/pi-plans/runs/${candidate.runId}/checkpoint.json explicitly; nothing was changed.`,
 			"error",
 		);
 		return;
@@ -155,7 +159,7 @@ async function run(pi: ExtensionAPI, ctx: ExtensionContext, baseDir: string): Pr
 			}
 		}
 
-		const brief = await buildBrief(pi, ctx, baseDir, candidate);
+		const brief = await buildBrief(ctx, baseDir, candidate);
 		if (brief === null) {
 			releaseOwnership(ctx.cwd, candidate.runId, ownerToken);
 			return; // buildBrief reported the specific problem
@@ -163,7 +167,7 @@ async function run(pi: ExtensionAPI, ctx: ExtensionContext, baseDir: string): Pr
 
 		// Exactly one kickoff (R-007). The idle re-check happens above and in
 		// buildBrief's dialogs; the message itself starts the continuation.
-		await pi.sendUserMessage(brief.text);
+		await messaging().sendUserMessage(brief.text);
 		ctx.ui.notify(`Resumed ${candidate.runId} (${brief.phaseLabel}).`, "info");
 	} catch (error) {
 		releaseOwnership(ctx.cwd, candidate.runId, ownerToken);
@@ -185,13 +189,12 @@ export function migrateRunIntoCurrentWorktree(workdir: string, candidate: Resume
 	const stateRoot = loadConfigShared(workdir);
 	if (stateRoot === null) return null;
 	const config = loadConfig(stateRoot);
-	let artifactRoot = config.artifact_root;
-	if (!path.isAbsolute(artifactRoot)) artifactRoot = path.resolve(workdir, artifactRoot);
+	const artifactRoot = resolveArtifactRoot(workdir, config.artifact_root);
 	const sourceDir = candidate.run.artifact_dir;
 	if (!existsSync(sourceDir)) return null;
 	// Artifacts already in a shared location stay put.
 	const gitRoot = findGitCommonDir(workdir);
-	if (gitRoot !== null && isInside(sourceDir, path.join(gitRoot, "pi_plans"))) return sourceDir;
+	if (gitRoot !== null && isInside(sourceDir, path.join(gitRoot, "pi-plans"))) return sourceDir;
 	const targetDir = path.join(artifactRoot, path.basename(sourceDir));
 	for (const entry of fs.readdirSync(sourceDir, { withFileTypes: true })) {
 		if (!entry.isFile()) continue;
@@ -257,46 +260,7 @@ export interface ResumeBrief {
 	text: string;
 }
 
-/** D-5 crash-window recovery: rebuild the implementation-review loop
- * configuration from the checkpoint plus the decisions ledger. Answers land
- * in the ledger first (stable questionIds), the combined record-checkpoint
- * second; between the two, this resolver reconstructs what is known and
- * reports which questions are still missing. Exported for tests. */
-export function resolveImplReviewConfig(
-	review: { terminationCondition?: string; reviewerCount?: number; completedRounds: number } | undefined,
-	ledger: { questionId?: string; answer?: string }[],
-): {
-	condition: string | undefined;
-	conditionFromLedger: boolean;
-	reviewerCount: number | undefined;
-	reviewerCountFromLedger: boolean;
-	missing: Array<"termination-condition" | "impl-review-reviewer-count">;
-} {
-	const latest = (id: string): string | undefined =>
-		[...ledger].reverse().find((entry) => entry.questionId === id)?.answer;
-	const ledgerCondition = latest("termination-condition");
-	const ledgerCountRaw = latest("impl-review-reviewer-count");
-	const ledgerCount = ledgerCountRaw === undefined ? undefined : Number.parseInt(ledgerCountRaw, 10);
-	const ledgerCountValid = ledgerCount !== undefined && Number.isInteger(ledgerCount) && ledgerCount >= 1 && ledgerCount <= 3;
-	const condition = review?.terminationCondition ?? ledgerCondition;
-	const reviewerCount = review?.reviewerCount ?? (ledgerCountValid ? ledgerCount : undefined);
-	// Both questions are per-run configuration: a count is missing whenever it
-	// is unknown (including legacy checkpoints persisted before 0.5.4),
-	// independent of where the condition came from.
-	const missing: Array<"termination-condition" | "impl-review-reviewer-count"> = [];
-	if (condition === undefined) missing.push("termination-condition");
-	if (reviewerCount === undefined) missing.push("impl-review-reviewer-count");
-	return {
-		condition,
-		conditionFromLedger: review?.terminationCondition === undefined && ledgerCondition !== undefined,
-		reviewerCount,
-		reviewerCountFromLedger: review?.reviewerCount === undefined && ledgerCountValid,
-		missing,
-	};
-}
-
 async function buildBrief(
-	pi: ExtensionAPI,
 	ctx: ExtensionContext,
 	baseDir: string,
 	candidate: ResumeCandidate,
@@ -323,7 +287,7 @@ async function buildBrief(
 	bindRun(ctx.sessionManager, ctx.cwd, runId);
 
 	if (cp.phase === "executing") {
-		const load = loadExecutionFromCheckpoint(pi, ctx, runId);
+		const load = loadExecutionFromCheckpoint(ctx, runId);
 		if (load.status === "loaded") {
 			if (run.status === "stopped" || run.status === "accepted") {
 				try {
@@ -334,14 +298,22 @@ async function buildBrief(
 			}
 			const doneList = (load.doneVcIds ?? []).join(", ") || "none";
 			const reverify = load.reverifyAll
-				? `\nThe code state (HEAD) changed since approval: the authorization is KEPT, but every previously verified VC must be re-verified before new work counts. Historically verified (evidence only): ${doneList}.`
+				? `\nThe code state (HEAD) changed since approval: the authorization is KEPT, but every previously closed task was re-opened and must be re-done. Historically verified checks (evidence only): ${doneList}.`
 				: `\nPreviously verified and still valid: ${doneList}.`;
-			const paused = load.pausedReason ? `\nExecution was paused: ${load.pausedReason}. Continue from where it stopped.` : "";
+			const paused = load.pausedReason ? `\nExecution had been paused: ${load.pausedReason} — the pause is cleared by this resume; continue from where it stopped.` : "";
+			const legacy = load.legacyPlan ? "\nThis plan parses through the legacy I-### compatibility mapping; upgrade it to the ## Tasks format at the next revision." : "";
 			return {
 				phaseLabel: "executing",
-				text: `[PI-PLANS RESUME] Execution of run ${runId} continues in this session.\nPlan: ${load.planPath}${reverify}${paused}\nFollow the execution-loop contract: implement in dependency order, verify each VC, and mark completions with [DONE:VC-xxx]. The remaining checklist is injected each turn.`,
+				text: `[PI-PLANS RESUME] Execution of run ${runId} continues in this session.\nPlan: ${load.planPath}${reverify}${paused}${legacy}\nFollow the execution-loop contract: work through tasks in wave order, report every task with the plans_update_task tool (status + evidence / skipReason), and let the completion auditor verify the checks. The current wave and remaining tasks are injected each turn.`,
 			};
 		}
+		if (load.legacyDelegate) {
+			ctx.ui.notify(
+				`Cannot resume ${runId} directly: it was mid-flight under a v0.6.0 delegated executor (removed in v0.6.1). Run /plans-execute to re-approve the handoff; execution restarts from the first task (0.6.0 progress cannot map onto the task tree).`,
+				"warning",
+			);
+			return null;
+		}
 		if (load.status === "plan-missing" || load.status === "plan-mismatch") {
 			ctx.ui.notify(`Cannot resume ${runId}: ${load.error ?? "plan file missing"}.`, "error");
 			return null;
@@ -355,69 +327,19 @@ async function buildBrief(
 	}
 
 	if (cp.phase === "implementation-review") {
-		const review = cp.implementationReview;
-		const condition = review?.terminationCondition;
-		const lines: string[] = [
-			`[PI-PLANS RESUME] Implementation review of run ${runId} continues in this session.`,
-			`Plan: ${cp.plan?.path ?? "(unknown)"}`,
-		];
-		// D-5 crash-window recovery: both config answers live in the decisions
-		// ledger under stable questionIds. Rebuild from the ledger, ask ONLY the
-		// missing question(s), then persist BOTH in one combined write. The
-		// re-ask guard on the checkpoint (termination condition already
-		// configured) rejects duplicate writes, so the combined write happens
-		// only while the field is genuinely absent.
-		const ledger = readDecisionLedger(ctx.cwd, runId);
-		const resolved = resolveImplReviewConfig(review, ledger);
-		const effectiveCondition = resolved.condition;
-		const effectiveCount = resolved.reviewerCount;
-		if (effectiveCondition === undefined) {
-			lines.push(
-				`The termination condition was never chosen. Ask it now via ask_choice (autoComplete: false, questionId: "termination-condition"): "How should the implementation-review loop terminate?" Options: goal wait (recommended) / until no high-severity finding (hard cap 5 rounds) / 1 / 2 / 3 rounds.`,
-			);
-		} else {
-			lines.push(`Termination condition: ${effectiveCondition}${resolved.conditionFromLedger ? " (recovered from the decisions ledger)" : ""}`);
-		}
-		if (review?.reviewerCount === undefined) {
-			if (effectiveCount !== undefined && Number.isInteger(effectiveCount) && effectiveCount >= 1 && effectiveCount <= 3) {
-				lines.push(`Reviewer count: ${effectiveCount} (recovered from the decisions ledger; not yet persisted).`);
-			} else {
-				lines.push(
-					`The reviewer count was never chosen. Ask it via ask_choice (autoComplete: false, allowOther: false, questionId: "impl-review-reviewer-count", digit labels "1"/"2"/"3"): "How many concurrent reviewers should each implementation-review round use?" — recommended default follows this run's skill: plan-big / plan-with-refs → 3, others → 1.`,
-				);
-			}
-		} else {
-			lines.push(`Reviewers per round: ${review.reviewerCount}`);
-		}
-		if (condition === undefined) {
-			// Only when the checkpoint is still unconfigured: the combined write
-			// (both answers) is one transaction. When only terminationCondition is
-			// missing but a ledger answer exists for both, write both; when a
-			// question is genuinely unanswered, ask first, then write.
-			lines.push(
-				`After both answers exist (asked now or recovered from the ledger), persist them in ONE call: plans record-checkpoint (checkpoint: { transition: "implementation-review-configured", terminationCondition: "<answer>", reviewerCount: <integer> }).`,
-			);
-		} else {
-			lines.push(`Completed rounds in this worktree: ${review?.completedRounds ?? 0} (hard cap 5).`);
-		}
-		const currentRound = review?.currentRoundId
-			? cp.reviewRounds.find((round) => round.roundId === review.currentRoundId)
-			: undefined;
-		if (currentRound) {
-			const done = currentRound.lanes.filter((lane) => lane.status === "complete").map((lane) => lane.laneId);
-			const pending = currentRound.lanes.filter((lane) => lane.status !== "complete").map((lane) => lane.laneId);
-			lines.push(
-				`Round ${currentRound.roundId} is in flight — complete lanes: ${done.join(", ") || "none"}; pending/failed lanes: ${pending.join(", ") || "none"}. Resume it with refine (role: "reviewer", target: "implementation", resumeRoundId: "${currentRound.roundId}") so completed lanes are reused, never re-run.`,
-			);
-		} else {
-			lines.push(
-				`Start the next round with refine (role: "reviewer", target: "implementation", reviewers: ${review?.reviewerCount ?? effectiveCount ?? "<configured count>"}) — do NOT pass a resumeRoundId unless resuming an interrupted round; an omitted reviewers argument falls back to the run's configured reviewerCount.`,
-			);
+		// v0.6.1 (D-018/D-020): the implementation-review loop is gone; a
+		// legacy 0.6.0 checkpoint in this phase maps to execution completed.
+		// The run flips to done so the status line and run registry agree.
+		try {
+			setRunStatus(ctx.cwd, runId, "done");
+		} catch {
+			/* best-effort */
 		}
-		lines.push(
-			`Record boundaries with plans record-checkpoint: review-consolidated → implementation-round-finished per round; completed (with evidence) when the termination condition is met.`,
+		ctx.ui.notify(
+			`${runId} finished under the removed v0.6.0 implementation-review loop; mapped to done. Its historical acceptance stands; no review loop to resume.`,
+			"info",
 		);
-		return { phaseLabel: "implementation-review", text: lines.join("\n") };
+		return null;
 	}
 
 	// planning / reviewing: rebuild the workflow context (R-002/R-003).
@@ -508,19 +430,7 @@ async function buildLegacyBrief(
 			`This run predates durable checkpoints: treat every VC as unverified and re-run the execution handoff (execute_plan or /plans-execute) for explicit approval before writing any code.`,
 		);
 	}
-	if (candidate.run.status === "done") {
-		const ok = await ctx.ui.confirm(
-			"Finished run with review artifacts",
-			`${candidate.runId} is marked done and has review records, but completion of the implementation-review loop cannot be proven for legacy runs. Resume the review loop anyway?`,
-		);
-		if (!ok) {
-			ctx.ui.notify("Cancelled; nothing was changed.", "info");
-			return null;
-		}
-		lines.push(
-			`Resume the implementation-review loop: ask the termination condition (questionId: "termination-condition") if unknown, then run rounds with refine (target: "implementation").`,
-		);
-	}
 	lines.push(`Continue only the missing work; never restart the interview from scratch.`);
 	return { phaseLabel: candidate.phaseLabel, text: lines.join("\n") };
 }
+

package/src/resume.ts

@@ -9,7 +9,7 @@
 import * as fs from "node:fs";
 import { existsSync, readFileSync } from "node:fs";
 import * as path from "node:path";
-import { getRun, readActive, resolveStateRootOrNull, runDirPath, type RunInfo } from "./state.ts";
+import { getRun, listRuns, readActive, resolveStateRootOrNull, runDirPath, type RunInfo } from "./state.ts";
 import { loadCheckpoint, mutateCheckpoint, type WorkflowCheckpoint } from "./workflow-state.ts";
 
 export interface ResumeCandidate {
@@ -81,22 +81,17 @@ function planVersionOf(checkpoint: WorkflowCheckpoint | null, run: RunInfo): num
 /**
  * Enumerate resumable runs for the repo containing `workdir`. Corrupt
  * checkpoints are surfaced (not hidden) so the command can report them;
- * read errors never abort discovery of other runs.
+ * read errors never abort discovery of other runs. v0.6.0: enumeration is
+ * driven by the filesystem-derived registry (`listRuns`) so ordering and
+ * corrupt-run tolerance match every other multi-run surface.
  */
 export function listResumeCandidates(workdir: string): ResumeCandidate[] {
 	const stateRoot = resolveStateRootOrNull(workdir);
 	if (stateRoot === null) return [];
-	const runsDir = path.join(stateRoot, "runs");
-	if (!existsSync(runsDir)) return [];
 	const active = readActive(workdir);
 	const candidates: ResumeCandidate[] = [];
-	let entries: string[] = [];
-	try {
-		entries = fs.readdirSync(runsDir);
-	} catch {
-		return [];
-	}
-	for (const runId of entries) {
+	for (const summary of listRuns(workdir)) {
+		const runId = summary.run_id;
 		const run = getRun(workdir, runId);
 		if (!run) continue;
 		const runDir = runDirPath(workdir, runId);
@@ -130,7 +125,7 @@ export function listResumeCandidates(workdir: string): ResumeCandidate[] {
 			updatedAt: checkpoint?.updatedAt ?? run.updated_at,
 		});
 	}
-	// Active pointer first (priority, not exclusivity), then newest updated.
+	// Newest updated first; the active run (registry hint) gets priority.
 	candidates.sort((a, b) => {
 		const aActive = active?.run_id === a.runId ? 1 : 0;
 		const bActive = active?.run_id === b.runId ? 1 : 0;
@@ -140,14 +135,17 @@ export function listResumeCandidates(workdir: string): ResumeCandidate[] {
 	return candidates;
 }
 
-/** Pick the default candidate: active-unfinished first, else unique candidate (D-001). */
+/**
+ * Pick the default candidate (v0.6.0 D-1): the SESSION BINDING is resolved by
+ * the command (it owns the SessionManager); here a unique candidate goes
+ * direct and everything else is ambiguous — the active-pointer auto-win is
+ * gone (multi-run workdirs must not silently pick the registry hint).
+ */
 export function pickDefaultCandidate(workdir: string, candidates: ResumeCandidate[]): ResumeCandidate | null {
+	void workdir;
 	if (candidates.length === 0) return null;
-	const active = readActive(workdir);
-	const activeCandidate = active ? candidates.find((candidate) => candidate.runId === active.run_id) ?? null : null;
-	if (activeCandidate !== null) return activeCandidate;
 	if (candidates.length === 1) return candidates[0]!;
-	return null; // ambiguous: the command must ask
+	return null; // ambiguous: the command must ask (binding first, then form)
 }
 
 export interface DecisionLedgerEntry {