taskplane 0.30.5 → 0.30.6

package/extensions/taskplane/agent-bridge-extension.ts

@@ -23,13 +23,22 @@
 
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Type } from "@mariozechner/pi-ai";
-import { writeFileSync, readFileSync, existsSync, mkdirSync, renameSync, unlinkSync } from "fs";
+import {
+	writeFileSync,
+	readFileSync,
+	readdirSync,
+	existsSync,
+	mkdirSync,
+	renameSync,
+	unlinkSync,
+} from "fs";
 import { join, dirname } from "path";
 import { spawn as nodeSpawn } from "child_process";
 import { resolvePiCliPath, resolveTaskplaneAgentTemplate } from "./path-resolver.ts";
 import { loadPiSettingsPackages, filterExcludedExtensions } from "./settings-loader.ts";
 import { randomBytes } from "crypto";
 import { buildExpansionRequestId, type SegmentExpansionRequest } from "./types.ts";
+import { latestReviewFilesPerGate, parseReviewVerdict } from "./review-analysis.ts";
 
 /**
  * Resolve the outbox directory from environment variables.
@@ -174,6 +183,28 @@ function writeSegmentExpansionRequest(request: SegmentExpansionRequest): string
  * @param stepNum the step number being reviewed
  * @returns true iff the step is marked Complete in STATUS.md
  */
+/**
+ * #629: does the LATEST review file for `{type}-step{N}` read REVISE/RETHINK?
+ * Used to exempt a remediation re-review from the TP-186 complete-step guard.
+ * Fail-closed: unreadable dir/file → false (guard stays in force).
+ */
+export function hasOutstandingNonApproveReview(
+	reviewsDir: string,
+	reviewType: string,
+	stepNum: number,
+): boolean {
+	try {
+		if (!existsSync(reviewsDir)) return false;
+		const latest = latestReviewFilesPerGate(readdirSync(reviewsDir));
+		const filename = latest.get(`${reviewType.toLowerCase()}-step${stepNum}`);
+		if (!filename) return false;
+		const verdict = parseReviewVerdict(readFileSync(join(reviewsDir, filename), "utf-8"));
+		return verdict === "REVISE" || verdict === "RETHINK";
+	} catch {
+		return false;
+	}
+}
+
 export function isStepMarkedComplete(statusPath: string, stepNum: number): boolean {
 	let content: string;
 	try {
@@ -822,7 +853,18 @@ export default function (pi: ExtensionAPI) {
 			// violated the Order of Operations contract; the only safe path
 			// is to revert STATUS first, then re-call review_step. Plan
 			// reviews are exempt because they fire BEFORE implementation.
-			if (reviewType !== "plan" && isStepMarkedComplete(statusPath, stepNum)) {
+			//
+			// #629 exemption: when the step is Complete but the LATEST review for
+			// this gate is REVISE/RETHINK, the runtime's finalize gate has refused
+			// (or will refuse) the task and spawned a remediation iteration whose
+			// whole purpose is to re-run this review. That state IS the anomaly
+			// being repaired — a re-review is the correct action, not an order
+			// violation. Refusing here would make the documented remedy unreachable.
+			if (
+				reviewType !== "plan" &&
+				isStepMarkedComplete(statusPath, stepNum) &&
+				!hasOutstandingNonApproveReview(reviewsDir, reviewType, stepNum)
+			) {
 				const taskIdMatch = statusPath.match(/[\\/]([A-Z]{2,}-\d+)[^\\/]*[\\/]STATUS\.md$/);
 				const taskId = taskIdMatch ? taskIdMatch[1] : "<TASK-ID>";
 				const refusal = [
@@ -944,13 +986,23 @@ export default function (pi: ExtensionAPI) {
 				// Read review output and extract verdict
 				if (existsSync(outputPath)) {
 					const reviewContent = readFileSync(outputPath, "utf-8");
-					const verdictMatch = reviewContent.match(/###?\s*Verdict[:\s]*(APPROVE|REVISE|RETHINK)/i);
-					let verdict = verdictMatch ? verdictMatch[1].toUpperCase() : "UNKNOWN";
+					// #624 (severity upgrade): robust, FAIL-CLOSED verdict extraction. The
+					// old regex ('###?\s*Verdict[:\s]*…') missed common reviewer format
+					// variants, and its fallback checked the substring "approve" FIRST — so
+					// a REVISE review whose body merely contained "approve" (e.g. "cannot
+					// approve") was returned to the worker as APPROVE. Workers then marked
+					// steps complete and advanced past unaddressed findings. The review
+					// gate must NEVER fail open: APPROVE is only ever taken from an
+					// explicit Verdict line (parseReviewVerdict handles heading/bold/plain/
+					// dash/bracket variants and skips the template placeholder). The body
+					// fallback below may only produce fail-closed guesses (REVISE/RETHINK).
+					const parsedVerdict = parseReviewVerdict(reviewContent);
+					let verdict: string = parsedVerdict ?? "UNKNOWN";
 					if (verdict === "UNKNOWN") {
 						const lower = reviewContent.toLowerCase();
-						if (lower.includes("approve") && !lower.includes("do not approve")) verdict = "APPROVE";
-						else if (lower.includes("revise") || lower.includes("changes requested")) verdict = "REVISE";
-						else if (lower.includes("rethink")) verdict = "RETHINK";
+						if (/\brevise\b/.test(lower) || lower.includes("changes requested")) verdict = "REVISE";
+						else if (/\brethink\b/.test(lower)) verdict = "RETHINK";
+						// NO approve fallback — an approval must be explicit.
 					}
 
 					// Log review in STATUS.md execution log
@@ -986,7 +1038,13 @@ export default function (pi: ExtensionAPI) {
 					} else {
 						return {
 							content: [
-								{ type: "text" as const, text: `Review complete (verdict unclear). See ${reviewFile}` },
+								{
+									type: "text" as const,
+									text:
+										`Review complete (verdict unclear). Read ${reviewFile} and follow its ` +
+										`Verdict line — do NOT treat this as an approval or mark the step complete ` +
+										`without an explicit APPROVE.`,
+								},
 							],
 							details: undefined,
 						};

package/extensions/taskplane/agent-host.ts

@@ -40,6 +40,7 @@ import type {
 	RuntimeAgentEventType,
 	RuntimeAgentManifest,
 	PacketPaths,
+	ReviewDisposition,
 } from "./types.ts";
 
 import {
@@ -144,6 +145,65 @@ export function buildWorkerToolsAllowlist(userTools: string | undefined | null):
 	return Array.from(merged).join(",");
 }
 
+/**
+ * Normalize the freeform text a `review_step` tool call returns into a
+ * {@link ReviewDisposition}. The tool returns clean leading tokens
+ * (`APPROVE`, `REVISE: …`, `RETHINK — …`, `UNAVAILABLE — …`, `REFUSED: …`),
+ * but this parser is defensive: it matches a leading verdict token
+ * case-insensitively and falls back to a substring scan, returning `UNKNOWN`
+ * when nothing recognizable is present.
+ *
+ * Pure and side-effect-free so it can be unit-tested directly.
+ *
+ * @since review-boundary notifications
+ */
+/**
+ * Extract the review file path from a review_step tool return. The tool appends
+ * "Full review: .reviews/R{NNN}-{type}-step{N}.md" (REVISE) or
+ * "See .reviews/R{NNN}-{type}-step{N}.md" (RETHINK). Returns undefined when no
+ * such reference is present (e.g. APPROVE returns just "APPROVE").
+ */
+export function extractReviewPath(resultText: string | undefined | null): string | undefined {
+	if (!resultText || typeof resultText !== "string") return undefined;
+	const m = resultText.match(/(?:Full review:|See)\s+(\S*R\d+-[a-z]+-step\d+\.md)\b/i);
+	if (m) return m[1];
+	const m2 = resultText.match(/(\S*R\d+-[a-z]+-step\d+\.md)\b/i);
+	return m2 ? m2[1] : undefined;
+}
+
+export function normalizeReviewDisposition(
+	resultText: string | undefined | null,
+): ReviewDisposition {
+	if (!resultText || typeof resultText !== "string") return "UNKNOWN";
+	const text = resultText.trim();
+	if (text.length === 0) return "UNKNOWN";
+	// Leading-token match (the tool's canonical output shape).
+	const lead = text.toUpperCase();
+	if (/^APPROVE\b/.test(lead)) return "APPROVE";
+	if (/^REVISE\b/.test(lead)) return "REVISE";
+	if (/^RETHINK\b/.test(lead)) return "RETHINK";
+	if (/^REFUSED\b/.test(lead)) return "REFUSED";
+	if (/^UNAVAILABLE\b/.test(lead)) return "UNAVAILABLE";
+	// Defensive fallback: scan for the token anywhere, most-specific first, using
+	// word boundaries so substrings inside other words don't false-match.
+	// REFUSED and UNAVAILABLE are checked before REVISE/RETHINK because their
+	// bodies may quote a verdict word.
+	if (/\bREFUSED\b/.test(lead)) return "REFUSED";
+	if (/\bUNAVAILABLE\b/.test(lead)) return "UNAVAILABLE";
+	if (/\bRETHINK\b/.test(lead)) return "RETHINK";
+	if (/\bREVISE\b/.test(lead) || /\bCHANGES REQUESTED\b/.test(lead)) return "REVISE";
+	// Approve only on a clean, non-negated APPROVE token. Reject explicit
+	// negations ("do not approve", "not approved", "disapprove", "unapproved").
+	if (
+		/\bAPPROVE\b/.test(lead) &&
+		!/\bDO NOT APPROVE\b/.test(lead) &&
+		!/\bNOT APPROVE\b/.test(lead)
+	) {
+		return "APPROVE";
+	}
+	return "UNKNOWN";
+}
+
 // ── Conversation Payload Helpers (TP-111) ───────────────────────────────
 
 /** Maximum characters for conversation event text payloads. */
@@ -181,6 +241,37 @@ function extractAssistantText(message: Record<string, unknown>): string {
 	return "";
 }
 
+/**
+ * Extract text from a Pi RPC `tool_execution_end` result, which — like message
+ * content — may be a plain string, an array of `{type:"text",text}` blocks, or
+ * an object with a `content` field (the shape tool handlers return). The old
+ * `typeof event.result === "string" ? ... : String(event.output)` extraction
+ * silently produced an empty/garbage string for structured results, which made
+ * review_step verdicts unparseable and mis-fired "Reviewer unavailable" (#624).
+ */
+export function extractToolResultText(event: { result?: unknown; output?: unknown }): string {
+	const fromValue = (val: unknown): string | null => {
+		if (typeof val === "string") return val;
+		if (Array.isArray(val)) {
+			const texts = val
+				.filter(
+					(b: unknown): b is { type: string; text: string } =>
+						typeof b === "object" &&
+						b !== null &&
+						(b as { type?: unknown }).type === "text" &&
+						typeof (b as { text?: unknown }).text === "string",
+				)
+				.map((b) => b.text);
+			if (texts.length > 0) return texts.join("\n");
+		}
+		if (val && typeof val === "object" && "content" in val) {
+			return extractAssistantText(val as Record<string, unknown>);
+		}
+		return null;
+	};
+	return fromValue(event.result) ?? fromValue(event.output) ?? "";
+}
+
 // ── Types ────────────────────────────────────────────────────────────
 
 /**
@@ -250,6 +341,11 @@ export interface AgentHostOptions {
 	 * @since TP-172
 	 */
 	maxExitInterceptions?: number;
+	/**
+	 * Upper bound (ms) for one onPrematureExit intercept before the host stops
+	 * waiting. Must exceed the lane's supervisor-reply window; default 120s.
+	 */
+	exitInterceptSafetyMs?: number;
 }
 
 /**
@@ -396,6 +492,14 @@ export function spawnAgent(
 	let lastTool = "",
 		error: string | null = null;
 	let contextUsage: AgentHostResult["contextUsage"] = null;
+	/**
+	 * In-flight review_step boundary state (review-boundary notifications). Set at
+	 * tool_execution_start so the end event and any crash-abort can carry the
+	 * step/reviewType identity (tool_execution_end does not include the original
+	 * args). review_step calls are sequential within a worker (the worker blocks
+	 * on the verdict), so a single pending slot is sufficient.
+	 */
+	let pendingReview: { step?: number; reviewType?: string } | null = null;
 	let stderrBuffer = "";
 	const STDERR_MAX = 2048;
 	/** Last assistant message text captured from message_end events (TP-172) */
@@ -589,7 +693,10 @@ export function spawnAgent(
 						try {
 							appendFileSync(
 								opts.steeringPendingPath,
-								JSON.stringify({ ts: msg.timestamp, content: msg.content, id: msg.id }) + "\n",
+								// #630: `type` lets the lane-runner tell an acknowledgement (info)
+								// from a ruling/instruction (steer) for hold bookkeeping.
+								JSON.stringify({ ts: msg.timestamp, content: msg.content, id: msg.id, type: msg.type }) +
+									"\n",
 								"utf-8",
 							);
 						} catch {
@@ -671,6 +778,19 @@ export function spawnAgent(
 					: exitCode === 0 && agentEnded
 						? "agent_exited"
 						: "agent_crashed";
+			// Review-boundary: if the worker died mid-review, close the dangling
+			// review_started so the supervisor doesn't see an orphaned "review
+			// starting" with no end. Emitted as review_failed (aborted) before the
+			// terminal exit event.
+			if (pendingReview) {
+				emitEvent("review_failed", {
+					step: pendingReview.step,
+					reviewType: pendingReview.reviewType,
+					disposition: "UNKNOWN",
+					summary: `review aborted (${exitEventType})`,
+				});
+				pendingReview = null;
+			}
 			emitEvent(exitEventType, { exitCode, signal, durationMs: result.durationMs, timedOut });
 
 			// Registry integration: update manifest to terminal status
@@ -781,17 +901,58 @@ export function spawnAgent(
 						// TP-111: Bounded payload only — no raw args in durable event log
 						const toolPath = event.args?.path ? String(event.args.path).slice(0, 200) : "";
 						emitEvent("tool_call", { tool: toolName, path: toolPath, argsPreview: argPreview });
+						// Review-boundary notification: the review START. review_step spawns a
+						// reviewer; surfacing this lets the supervisor track review activity
+						// live (see lane-runner onEvent bridge + supervisor tailer).
+						if (toolName === "review_step") {
+							const reviewStep =
+								event.args && typeof event.args === "object"
+									? (event.args as { step?: unknown }).step
+									: undefined;
+							const reviewType =
+								event.args && typeof event.args === "object"
+									? (event.args as { type?: unknown }).type
+									: undefined;
+							const stepNum = typeof reviewStep === "number" ? reviewStep : undefined;
+							const rType = typeof reviewType === "string" ? reviewType : undefined;
+							// Remember identity so the end/abort events can carry step+reviewType
+							// (tool_execution_end omits args).
+							pendingReview = { step: stepNum, reviewType: rType };
+							emitEvent("review_requested", { step: stepNum, reviewType: rType });
+						}
 						break;
 					}
 					case "tool_execution_end": {
-						// TP-111: Include bounded result summary for dashboard display
-						const toolResultSummary =
-							typeof event.result === "string"
-								? event.result.slice(0, 200)
-								: event.output
-									? String(event.output).slice(0, 200)
-									: "";
+						// #624: extract robustly — tool results are often structured content
+						// arrays, not plain strings; the old extraction produced "" for those.
+						const fullResult = extractToolResultText(event);
+						const toolResultSummary = fullResult.slice(0, 200);
 						emitEvent("tool_result", { tool: event.toolName, summary: toolResultSummary });
+						// Review-boundary notification: the review END. Normalize the reviewer
+						// verdict and emit review_completed (APPROVE/REVISE/RETHINK/REFUSED) or
+						// review_failed. Only a GENUINE UNAVAILABLE (reviewer subprocess failed
+						// / produced no output) is the "broken reviewer" signal. A parse miss
+						// (UNKNOWN) must NOT masquerade as a broken reviewer (#624) — emit it as
+						// review_completed; lane-runner authoritatively resolves the verdict from
+						// the review file on disk.
+						if (event.toolName === "review_step") {
+							const disposition = normalizeReviewDisposition(fullResult);
+							const reviewFields = {
+								step: pendingReview?.step,
+								reviewType: pendingReview?.reviewType,
+								disposition,
+								summary: toolResultSummary,
+								// review_step embeds the review file path in its REVISE/RETHINK
+								// return; surfacing it lets lane-runner read the EXACT review file.
+								reviewPath: extractReviewPath(fullResult),
+							};
+							if (disposition === "UNAVAILABLE") {
+								emitEvent("review_failed", reviewFields);
+							} else {
+								emitEvent("review_completed", reviewFields);
+							}
+							pendingReview = null;
+						}
 						break;
 					}
 					case "auto_retry_start": {
@@ -841,7 +1002,7 @@ export function spawnAgent(
 						const shouldIntercept = opts.onPrematureExit && exitInterceptionCount < maxExitInterceptions;
 						if (shouldIntercept) {
 							exitInterceptionCount++;
-							const INTERCEPTION_TIMEOUT_MS = 120_000; // 2 minute safety timeout
+							const INTERCEPTION_TIMEOUT_MS = opts.exitInterceptSafetyMs ?? 120_000; // safety timeout (> lane window)
 							// Wrap in Promise.resolve().then() to catch synchronous throws
 							const interceptPromise = Promise.resolve().then(() =>
 								opts.onPrematureExit!(lastAssistantMessage),

package/extensions/taskplane/config-loader.ts

@@ -1268,6 +1268,9 @@ export function toTaskRunnerConfig(config: TaskplaneConfig): import("./types.ts"
 			thinking: config.taskRunner.worker.thinking,
 			tools: config.taskRunner.worker.tools,
 			excludeExtensions: [...(config.taskRunner.worker.excludeExtensions ?? [])],
+			...(typeof config.taskRunner.worker.exitInterceptTimeoutSec === "number"
+				? { exitInterceptTimeoutSec: config.taskRunner.worker.exitInterceptTimeoutSec }
+				: {}),
 		},
 		model_fallback: config.taskRunner.modelFallback ?? "inherit",
 		reviewer: {
@@ -1275,6 +1278,12 @@ export function toTaskRunnerConfig(config: TaskplaneConfig): import("./types.ts"
 			thinking: config.taskRunner.reviewer.thinking,
 			tools: config.taskRunner.reviewer.tools,
 			excludeExtensions: [...(config.taskRunner.reviewer.excludeExtensions ?? [])],
+			...(config.taskRunner.reviewer.severityLabels
+				? { severityLabels: [...config.taskRunner.reviewer.severityLabels] }
+				: {}),
+			...(config.taskRunner.reviewer.spiral
+				? { spiral: { ...config.taskRunner.reviewer.spiral } }
+				: {}),
 		},
 		workerExcludeExtensions: [...(config.taskRunner.worker.excludeExtensions ?? [])],
 	};

package/extensions/taskplane/config-schema.ts

@@ -118,9 +118,34 @@ export interface WorkerConfig {
 	spawnMode?: "subprocess";
 	/** Package specifiers to exclude from extension forwarding for worker agents (exact match). @since TP-180 */
 	excludeExtensions?: string[];
+	/**
+	 * How long (seconds) the lane waits for a supervisor reply when it intercepts a
+	 * worker's premature exit, before letting the session close. Default 60. Raise
+	 * it when the supervisor is often inside long tool calls (a blocking
+	 * `--wait` mid-tool-call cannot answer in 60s — penster feedback #3, item 5).
+	 * Bounded to 15..1800.
+	 */
+	exitInterceptTimeoutSec?: number;
 }
 
 /** Reviewer agent configuration */
+/**
+ * Revision-spiral detection tuning (review-boundary supervisor notifications).
+ * When a step is reviewed repeatedly without converging, the supervisor is
+ * escalated so it can adjudicate / steer the worker. Detection is notify-based,
+ * not a hard cap on revisions.
+ */
+export interface ReviewSpiralConfig {
+	/** Master switch for spiral escalation (per-boundary notifications are always on). */
+	enabled: boolean;
+	/** Consecutive non-APPROVE reviews on the SAME step before the first escalation. */
+	threshold: number;
+	/** Minimum further non-APPROVE reviews between re-escalations (anti-spam spacing). */
+	cooldownReviews: number;
+	/** Whether UNAVAILABLE reviews count toward the spiral (default false: broken-reviewer signal, not a spiral). */
+	treatUnavailableAsNonApprove: boolean;
+}
+
 export interface ReviewerConfig {
 	/** Reviewer model (empty = inherit session model) */
 	model: string;
@@ -130,6 +155,15 @@ export interface ReviewerConfig {
 	thinking: string;
 	/** Package specifiers to exclude from extension forwarding for reviewer agents (exact match). @since TP-180 */
 	excludeExtensions?: string[];
+	/**
+	 * Ordered severity vocabulary (highest severity first) used to bucket review
+	 * findings for spiral-vs-converging analysis. Core default is generic
+	 * (critical/important/minor); projects whose reviewer emits a different scheme
+	 * (e.g. P0/P1/P2) override this. Never hardcode a project vocabulary in core.
+	 */
+	severityLabels: string[];
+	/** Revision-spiral detection tuning. */
+	spiral: ReviewSpiralConfig;
 }
 
 /** Context/resource limits for task execution */
@@ -598,7 +632,19 @@ export const DEFAULT_TASK_RUNNER_SECTION: TaskRunnerSection = {
 	// bridge tools are appended at the lane-runner spawn site by
 	// `buildWorkerToolsAllowlist()`, not here.
 	worker: { model: "", tools: DEFAULT_WORKER_USER_TOOLS, thinking: "", excludeExtensions: [] },
-	reviewer: { model: "", tools: "read,bash,grep,find,ls", thinking: "on", excludeExtensions: [] },
+	reviewer: {
+		model: "",
+		tools: "read,bash,grep,find,ls",
+		thinking: "on",
+		excludeExtensions: [],
+		severityLabels: ["critical", "important", "minor"],
+		spiral: {
+			enabled: true,
+			threshold: 3,
+			cooldownReviews: 2,
+			treatUnavailableAsNonApprove: false,
+		},
+	},
 	context: {
 		workerContextWindow: 0,
 		warnPercent: 85,

package/extensions/taskplane/diagnostic-reports.ts

@@ -10,7 +10,7 @@
  *
  * @module orch/diagnostic-reports
  */
-import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 
 import { execLog } from "./execution.ts";
@@ -92,6 +92,12 @@ export interface DiagnosticReportInput {
 	totalTasks: number;
 	/** State root path where `.pi/` lives */
 	stateRoot: string;
+	/**
+	 * #629: per-task cost (USD) from outcome telemetry for the CURRENT pass.
+	 * `diagnostics.taskExits` is not populated by the v2 runtime, so without
+	 * this every report read $0.00. Optional for backward compatibility.
+	 */
+	taskCostUsd?: Record<string, number>;
 }
 
 // ── Diagnostics Directory ────────────────────────────────────────────
@@ -140,8 +146,8 @@ export function buildDiagnosticEvents(input: DiagnosticReportInput): DiagnosticE
 			classification = task.exitDiagnostic.classification;
 		}
 
-		// Cost: from taskExits, else 0
-		const cost = exitSummary?.cost ?? 0;
+		// Cost: from taskExits, else this pass's outcome telemetry, else 0
+		const cost = exitSummary?.cost ?? input.taskCostUsd?.[task.taskId] ?? 0;
 
 		// Duration: from taskExits, else compute from timestamps, else 0
 		let durationSec = 0;
@@ -177,6 +183,79 @@ export function buildDiagnosticEvents(input: DiagnosticReportInput): DiagnosticE
 
 // ── JSONL Generation ─────────────────────────────────────────────────
 
+// ── Cross-pass evidence preservation (#629 side-effect 2) ──
+
+/**
+ * Does this event carry any execution evidence? A task that was not executed
+ * in the current pass (e.g. a no-op resume) produces an evidence-empty event
+ * that would otherwise CLOBBER the prior pass's record when the report is
+ * rewritten (observed: a $55 / 1h42m run reported as $0 / 0s after two
+ * no-op resumes).
+ */
+export function hasExecutionEvidence(evt: DiagnosticEvent): boolean {
+	return (
+		(evt.classification !== "unknown" && evt.classification !== "") ||
+		evt.cost > 0 ||
+		evt.durationSec > 0 ||
+		evt.retries > 0 ||
+		evt.startedAt !== null ||
+		evt.endedAt !== null
+	);
+}
+
+/**
+ * Merge the previous report's events into the current pass's events.
+ *
+ * Rule: CURRENT STATE always comes from the new pass (`status`, `phase`,
+ * `mode`, `batchId`) — a legitimate retry or skip must be reflected. Execution
+ * EVIDENCE is merged FIELD-WISE: each evidence field takes the new pass's
+ * value when it is present/non-zero, else the previous value. This matters
+ * because resume's reconciliation synthesizes outcomes for tasks it did NOT
+ * execute that still carry the persisted classification and a fresh
+ * `endTime` — an all-or-nothing rule would treat those as "evidence" and
+ * erase the prior cost. Cost is never summed across passes (each pass's
+ * telemetry is that attempt's cost; no double counting). Tasks present only
+ * in the previous report are dropped (the new wave plan is authoritative for
+ * membership). Pure; deterministic order follows `next`.
+ */
+export function mergeDiagnosticEvents(
+	previous: DiagnosticEvent[],
+	next: DiagnosticEvent[],
+): DiagnosticEvent[] {
+	const prevByTask = new Map<string, DiagnosticEvent>();
+	for (const p of previous) prevByTask.set(p.taskId, p);
+	return next.map((n) => {
+		const p = prevByTask.get(n.taskId);
+		if (!p) return n;
+		const knownClass = n.classification && n.classification !== "unknown";
+		return {
+			...n,
+			classification: knownClass ? n.classification : p.classification,
+			cost: n.cost > 0 ? n.cost : p.cost,
+			durationSec: n.durationSec > 0 ? n.durationSec : p.durationSec,
+			retries: n.retries > 0 ? n.retries : p.retries,
+			exitReason: n.exitReason || p.exitReason,
+			startedAt: n.startedAt ?? p.startedAt,
+			endedAt: n.endedAt ?? p.endedAt,
+		};
+	});
+}
+
+/** Parse a previously written events JSONL file (tolerant: bad lines skipped). */
+export function parseEventsJsonl(content: string): DiagnosticEvent[] {
+	const out: DiagnosticEvent[] = [];
+	for (const line of content.split(/\r?\n/)) {
+		if (!line.trim()) continue;
+		try {
+			const obj = JSON.parse(line) as Partial<DiagnosticEvent>;
+			if (typeof obj.taskId === "string") out.push(obj as DiagnosticEvent);
+		} catch {
+			/* skip malformed */
+		}
+	}
+	return out;
+}
+
 /**
  * Serialize diagnostic events to JSONL format (one JSON object per line).
  */
@@ -222,7 +301,12 @@ export function buildMarkdownReport(
 	const { succeededTasks, failedTasks, skippedTasks, blockedTasks, totalTasks } = input;
 
 	const batchDurationSec = endedAt ? Math.round((endedAt - startedAt) / 1000) : 0;
-	const batchCost = diagnostics.batchCost ?? 0;
+	// #629: header cost from batch diagnostics when populated, else the sum of
+	// per-task evidence (which survives no-op passes via mergeDiagnosticEvents).
+	const batchCost =
+		diagnostics.batchCost && diagnostics.batchCost > 0
+			? diagnostics.batchCost
+			: events.reduce((sum, e) => sum + (Number.isFinite(e.cost) ? e.cost : 0), 0);
 
 	const lines: string[] = [];
 
@@ -337,10 +421,21 @@ export function emitDiagnosticReports(input: DiagnosticReportInput): void {
 		const opId = resolveOperatorId(input.orchConfig);
 		const dir = ensureDiagnosticsDir(input.stateRoot);
 
-		const events = buildDiagnosticEvents(input);
+		const jsonlPath = join(dir, `${opId}-${input.batchId}-events.jsonl`);
+
+		// #629: preserve prior-pass execution evidence for tasks this pass did
+		// not execute (state fields still come from this pass).
+		let events = buildDiagnosticEvents(input);
+		if (existsSync(jsonlPath)) {
+			try {
+				const previous = parseEventsJsonl(readFileSync(jsonlPath, "utf-8"));
+				events = mergeDiagnosticEvents(previous, events);
+			} catch {
+				/* unreadable prior report — proceed with this pass's events */
+			}
+		}
 
 		// ── JSONL event log ──
-		const jsonlPath = join(dir, `${opId}-${input.batchId}-events.jsonl`);
 		const jsonlContent = eventsToJsonl(events);
 		writeFileSync(jsonlPath, jsonlContent, "utf-8");
 
@@ -471,5 +566,13 @@ export function assembleDiagnosticInput(
 		blockedTasks: batchState.blockedTasks,
 		totalTasks: batchState.totalTasks,
 		stateRoot,
+		taskCostUsd: (() => {
+			const costs: Record<string, number> = {};
+			for (const [taskId, outcome] of outcomeByTaskId) {
+				const c = outcome.telemetry?.costUsd;
+				if (typeof c === "number" && Number.isFinite(c) && c > 0) costs[taskId] = c;
+			}
+			return costs;
+		})(),
 	};
 }

package/extensions/taskplane/diagnostics.ts

@@ -53,6 +53,7 @@ export interface SessionTokenCounts {
  * | `stall_timeout`      | No STATUS.md progress for stall_timeout minutes      |
  * | `user_killed`        | User manually killed the session (e.g., forced process kill) |
  * | `spawn_failure`      | Worker process never spawned (e.g., Pi CLI not findable, worktree provisioning) |
+ * | `review_gate_refusal`| Governance refusal: finalize blocked by an outstanding REVISE/RETHINK review verdict (#626/#629). The worker exited cleanly — NOT a crash, never auto-retried (the review file must change first) |
  * | `unknown`            | Could not determine cause                            |
  *
  * Note: `spawn_failure` (TP-190, #561) is set BEFORE any agent process exists —
@@ -72,6 +73,7 @@ export type ExitClassification =
 	| "stall_timeout"
 	| "user_killed"
 	| "spawn_failure"
+	| "review_gate_refusal"
 	| "unknown";
 
 /**
@@ -88,6 +90,7 @@ export const EXIT_CLASSIFICATIONS: readonly ExitClassification[] = [
 	"stall_timeout",
 	"user_killed",
 	"spawn_failure",
+	"review_gate_refusal",
 	"unknown",
 ] as const;