pi-plans 0.6.0 → 0.8.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}
 
@@ -161,19 +119,3 @@ Section contracts:
 - 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" | "executor";
+export type RefineOverlayRole = "reviewer" | "refs" | "auditor";
 export type RefineLaneStatus = "queued" | "running" | "complete" | "failed" | "cancelled";
 export type RefineTranscriptEntryType = "assistant-text" | "thinking" | "tool-call" | "tool-result" | "diagnostic";
 

package/src/refine-ui.ts

@@ -135,10 +135,12 @@ function previewTranscriptText(entry: RefineTranscriptEntry, width: number): { l
 	return { lines: lines.slice(-STREAMING_PREVIEW_LINES), truncated: true };
 }
 
-function footerText(laneCount: number, lang: UiLanguage): string {
+function footerText(laneCount: number, lang: UiLanguage, role: RefineOverlayRole = "reviewer"): string {
 	const chrome = refineChrome(lang);
 	const parts = [chrome.close, chrome.scroll, chrome.page];
 	if (laneCount > 1) parts.push(chrome.switchLane);
+	// Auditor overlay only: the reopen shortcut is the way back after ESC.
+	if (role === "auditor") parts.push(chrome.reopen);
 	return parts.join(" · ");
 }
 
@@ -166,7 +168,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" : role === "executor" ? "Executor" : "Criticizer";
+	const title = role === "reviewer" ? "Reviewer" : role === "auditor" ? "Execution review" : "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}`;
@@ -250,7 +252,7 @@ export class RefineOverlayComponent implements Component {
 				lines.push(...this.renderPane(this.lanes[index]!, innerWidth, paneHeight, index === this.selectedLane));
 			}
 		}
-		lines.push(renderRow(this.theme, this.theme.fg("dim", footerText(this.lanes.length, this.lang)), innerWidth));
+		lines.push(renderRow(this.theme, this.theme.fg("dim", footerText(this.lanes.length, this.lang, this.role)), innerWidth));
 		lines.push(renderBorderLine(this.theme, innerWidth, "bottom"));
 		return lines.map((line) => fitLine(line, width));
 	}
@@ -352,6 +354,20 @@ export class RefineOverlayController {
 			.catch(() => undefined);
 	}
 
+	/** Repaint without a progress event (the engine mutates lane state directly). */
+	rerender(): void {
+		if (this.closed) return;
+		this.tui?.requestRender();
+	}
+
+	/** Replace the lane with a matching id with engine-held state — used by the
+	 * execution-review reopen path so a fresh controller continues the SAME
+	 * transcript (one-shot controllers can never re-open themselves). */
+	seedLane(state: RefineLaneState): void {
+		const index = this.lanes.findIndex((lane) => lane.id === state.id);
+		if (index >= 0) this.lanes[index] = state;
+	}
+
 	update(laneId: string, event: SubagentProgressEvent): void {
 		if (this.closed) return;
 		const lane = this.lanes.find((candidate) => candidate.id === laneId);

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, 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;
@@ -105,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;
@@ -159,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
@@ -167,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);
@@ -189,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;
@@ -261,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,
@@ -327,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 {
@@ -338,14 +298,32 @@ 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.` : "";
+			// v0.8: a review-cap pause is NOT cleared by this resume — only
+			// /plans-execute (an explicit user confirmation) grants a fresh
+			// five-round budget; ordinary resumes and input keep it paused.
+			const paused = load.pausedReason
+				? load.pausedReason.startsWith("execution review exhausted") || load.pausedReason.startsWith("completion audit exhausted")
+					? `\nExecution had been paused: ${load.pausedReason} — this pause survives the resume; run /plans-execute to grant a fresh five-round review budget.`
+					: `\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." : "";
+			// v0.8: a verifying run keeps checkpoint phase "executing" but the run
+			// STATUS is verifying — surface which loop owns the run right now.
+			const verifying = run.status === "verifying";
 			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.`,
+				phaseLabel: verifying ? "verifying" : "executing",
+				text: `[PI-PLANS RESUME] ${verifying ? "Execution review of" : "Execution of"} run ${runId} continues in this session.\nPlan: ${load.planPath}${reverify}${paused}${legacy}\n${verifying ? "The task tree is terminal and the execution-review loop owns the run: when all tasks are terminal and checks are still owed, a read-only reviewer round runs automatically (status verifying → done when every check passes). If a check fails, its tasks roll back to pending — fix and re-close them with plans_update_task." : "Follow 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 execution reviewer 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;
@@ -359,69 +337,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).
@@ -512,19 +440,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

@@ -27,7 +27,7 @@ export interface ResumeCandidate {
 	updatedAt: string;
 }
 
-const RESUMABLE_RUN_STATUSES = new Set(["planning", "accepted", "executing", "stopped"]);
+const RESUMABLE_RUN_STATUSES = new Set(["planning", "accepted", "executing", "verifying", "stopped"]);
 
 /** Terminal runs are resumable only when unfinished implementation-review evidence exists (D-008). */
 function legacyDoneResumable(run: RunInfo, checkpoint: WorkflowCheckpoint | null): boolean {
@@ -52,6 +52,10 @@ function legacyDoneResumable(run: RunInfo, checkpoint: WorkflowCheckpoint | null
 }
 
 function phaseLabelOf(run: RunInfo, checkpoint: WorkflowCheckpoint | null): string {
+	// A verifying run keeps checkpoint.phase === "executing" (the execution
+	// state machine's phase is unchanged); surface the run status instead so
+	// the resume list never hides the verification loop behind "executing".
+	if (run.status === "verifying") return "verifying";
 	if (checkpoint !== null) return checkpoint.phase;
 	if (run.status === "stopped") return "executing (stopped)";
 	return run.status;