taskplane 0.12.0 → 0.13.0

package/extensions/reviewer-extension.ts

@@ -0,0 +1,119 @@
+/**
+ * Persistent Reviewer Extension — TP-057
+ *
+ * Provides the `wait_for_review` tool that enables a reviewer agent to stay
+ * alive across multiple review requests within a single task. The tool blocks
+ * (via filesystem polling) until the task-runner signals a new review request
+ * or shutdown.
+ *
+ * Signal protocol:
+ *   - `.reviews/.review-signal-{NNN}` — new review request available
+ *   - `.reviews/.review-shutdown` — reviewer should exit cleanly
+ *   - `.reviews/request-R{NNN}.md` — review request content
+ *
+ * Environment:
+ *   - REVIEWER_SIGNAL_DIR — path to .reviews/ directory (required)
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "@mariozechner/pi-ai";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import {
+	REVIEWER_POLL_INTERVAL_MS,
+	REVIEWER_WAIT_TIMEOUT_MS,
+	REVIEWER_SHUTDOWN_SIGNAL,
+	REVIEWER_SIGNAL_PREFIX,
+} from "./taskplane/types.ts";
+
+// ── Extension ────────────────────────────────────────────────────────
+
+export default function reviewerExtension(pi: ExtensionAPI) {
+	const signalDir = process.env.REVIEWER_SIGNAL_DIR;
+
+	if (!signalDir) {
+		// Not running in persistent reviewer mode — skip tool registration.
+		// This allows the extension to be loaded in non-persistent contexts
+		// without error (fallback fresh-spawn mode).
+		return;
+	}
+
+	/** Counter tracking which signal number to watch for next. */
+	let nextSignalNum = 1;
+
+	pi.registerTool({
+		name: "wait_for_review",
+		label: "Wait for Review",
+		description:
+			"Block until the next review request is available, then return its content. " +
+			"Call this after completing each review to wait for the next one. " +
+			"Returns 'SHUTDOWN' when the task is complete and you should exit.",
+		promptSnippet: "wait_for_review() — block until the next review request arrives (persistent reviewer mode)",
+		promptGuidelines: [
+			"Call wait_for_review() to receive each review request.",
+			"After writing your review to the specified output file, call wait_for_review() again.",
+			"When it returns 'SHUTDOWN', exit cleanly — the task is complete.",
+			"Reference your previous reviews when relevant (e.g., 'I flagged X in Step 1 — checking if addressed').",
+		],
+		parameters: Type.Object({}),
+		async execute() {
+			const startTime = Date.now();
+			const signalNum = String(nextSignalNum).padStart(3, "0");
+			const signalPath = join(signalDir, `${REVIEWER_SIGNAL_PREFIX}${signalNum}`);
+			const shutdownPath = join(signalDir, REVIEWER_SHUTDOWN_SIGNAL);
+
+			// Poll for signal file or shutdown
+			while (true) {
+				// Check for shutdown signal first
+				if (existsSync(shutdownPath)) {
+					return {
+						content: [{ type: "text" as const, text: "SHUTDOWN — The task is complete. Exit cleanly." }],
+						details: undefined,
+					};
+				}
+
+				// Check for review signal
+				if (existsSync(signalPath)) {
+					// Signal found — read the request file path from signal content.
+					// Signal file content is the request filename (e.g., "request-R003.md").
+					const signalContent = readFileSync(signalPath, "utf-8").trim();
+					const requestPath = join(signalDir, signalContent);
+
+					if (!existsSync(requestPath)) {
+						// Signal fired but request file doesn't exist (race condition or error)
+						return {
+							content: [{
+								type: "text" as const,
+								text: `ERROR — Signal file ${REVIEWER_SIGNAL_PREFIX}${signalNum} found but ` +
+									`${signalContent} does not exist. Waiting for next signal.`,
+							}],
+							details: undefined,
+						};
+					}
+
+					const requestContent = readFileSync(requestPath, "utf-8");
+					nextSignalNum++;
+
+					return {
+						content: [{ type: "text" as const, text: requestContent }],
+						details: undefined,
+					};
+				}
+
+				// Check timeout
+				if (Date.now() - startTime > REVIEWER_WAIT_TIMEOUT_MS) {
+					return {
+						content: [{
+							type: "text" as const,
+							text: "TIMEOUT — No review request received within the timeout period. Exit cleanly.",
+						}],
+						details: undefined,
+					};
+				}
+
+				// Wait before next poll
+				await new Promise(resolve => setTimeout(resolve, REVIEWER_POLL_INTERVAL_MS));
+			}
+		},
+	});
+}

package/extensions/task-runner.ts

@@ -24,13 +24,18 @@ import { Container, Text, truncateToWidth } from "@mariozechner/pi-tui";
 import { spawn, spawnSync } from "child_process";
 import {
 	readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync, unlinkSync,
-	statSync, openSync, readSync, closeSync,
+	readdirSync, statSync, openSync, readSync, closeSync,
 } from "fs";
 import { tmpdir, userInfo } from "os";
 import { join, dirname, basename, resolve } from "path";
 import { loadProjectConfig, toTaskConfig } from "./taskplane/config-loader.ts";
 import { loadWorkspaceConfig, resolvePointer } from "./taskplane/workspace.ts";
 import type { PointerResolution } from "./taskplane/types.ts";
+import {
+	REVIEWER_SHUTDOWN_GRACE_MS,
+	REVIEWER_SIGNAL_PREFIX,
+	REVIEWER_SHUTDOWN_SIGNAL,
+} from "./taskplane/types.ts";
 import { classifyExit } from "./taskplane/diagnostics.ts";
 import type { TaskExitDiagnostic, ExitSummary } from "./taskplane/diagnostics.ts";
 import {
@@ -143,6 +148,12 @@ interface TaskState {
 	reviewerProc: any;
 	reviewerTimer: any;
 	reviewCounter: number;
+	/** TP-057: Persistent reviewer session — tracks the long-lived reviewer tmux session. */
+	persistentReviewerSession: string | null;
+	/** TP-057: Kill function for the persistent reviewer (to stop sidecar polling). */
+	persistentReviewerKill: (() => void) | null;
+	/** TP-057: Signal counter for the persistent reviewer (monotonically increasing). */
+	persistentReviewerSignalNum: number;
 	totalIterations: number;
 	stepStatuses: Map<number, StepInfo>;
 }
@@ -160,7 +171,9 @@ function freshState(): TaskState {
 		reviewerElapsed: 0, reviewerLastTool: "", reviewerToolCount: 0,
 		reviewerInputTokens: 0, reviewerOutputTokens: 0, reviewerCacheReadTokens: 0, reviewerCacheWriteTokens: 0,
 		reviewerCostUsd: 0, reviewerContextPct: 0, reviewerProc: null, reviewerTimer: null,
-		reviewCounter: 0, totalIterations: 0, stepStatuses: new Map(),
+		reviewCounter: 0,
+		persistentReviewerSession: null, persistentReviewerKill: null, persistentReviewerSignalNum: 0,
+		totalIterations: 0, stepStatuses: new Map(),
 	};
 }
 
@@ -633,6 +646,43 @@ function resolveRpcWrapperPath(): string {
 	);
 }
 
+/**
+ * Resolve the path to reviewer-extension.ts from the installed taskplane package.
+ * Mirrors resolveRpcWrapperPath() resolution strategy.
+ *
+ * @returns Absolute path to reviewer-extension.ts, or null if not found
+ * @since TP-057
+ */
+function resolveReviewerExtensionPath(): string | null {
+	const extRelPath = join("extensions", "reviewer-extension.ts");
+
+	// 1. Package root
+	const root = findPackageRoot();
+	if (root) {
+		const p = join(root, extRelPath);
+		if (existsSync(p)) return p;
+	}
+
+	// 2. Extension-file-relative (dev scenario: task-runner.ts is sibling)
+	try {
+		const args = process.argv;
+		for (let i = 0; i < args.length - 1; i++) {
+			if (args[i] === "-e" && args[i + 1]?.includes("task-runner")) {
+				const extPath = resolve(args[i + 1]);
+				const derivedRoot = resolve(extPath, "..", "..");
+				const p = join(derivedRoot, extRelPath);
+				if (existsSync(p)) return p;
+			}
+		}
+	} catch { /* ignore */ }
+
+	// 3. Development fallback: cwd
+	const cwdDev = join(process.cwd(), extRelPath);
+	if (existsSync(cwdDev)) return cwdDev;
+
+	return null;
+}
+
 /**
  * Load an agent definition with prompt inheritance.
  *
@@ -1567,6 +1617,9 @@ function spawnAgentTmux(opts: {
 	/** Optional extension paths to load in the spawned pi session (via rpc-wrapper --extensions).
 	 *  When provided, --no-extensions is NOT passed to pi (would conflict). */
 	extensions?: string[];
+	/** Optional extra environment variables to set in the spawned tmux session.
+	 *  Injected as `KEY=VALUE` prefixes in the shell command. @since TP-057 */
+	env?: Record<string, string>;
 	/** Called on each poll tick with accumulated telemetry from the sidecar JSONL.
 	 *  Enables the tmux poll loop to update TaskState (tokens, cost, context%, tools, retries)
 	 *  with the same signals that subprocess mode gets from onTokenUpdate/onContextPct/onToolCall. */
@@ -1710,7 +1763,11 @@ function spawnAgentTmux(opts: {
 	// Pi's ink/react TUI hangs with TERM=tmux-256color (tmux default), so we
 	// force xterm-256color.
 	const tmuxCwd = opts.cwd.replace(/^([A-Za-z]):\\/, (_, d: string) => `/${d.toLowerCase()}/`).replace(/\\/g, "/");
-	const wrappedCommand = `cd ${quoteArg(tmuxCwd)} && TERM=xterm-256color ${wrapperCommand}`;
+	// Build extra env var prefix (TP-057: e.g., REVIEWER_SIGNAL_DIR for persistent reviewer)
+	const extraEnv = opts.env
+		? Object.entries(opts.env).map(([k, v]) => `${k}=${quoteArg(v)}`).join(" ") + " "
+		: "";
+	const wrappedCommand = `cd ${quoteArg(tmuxCwd)} && ${extraEnv}TERM=xterm-256color ${wrapperCommand}`;
 	const createResult = spawnSync("tmux", [
 		"new-session", "-d",
 		"-s", opts.sessionName,
@@ -2017,6 +2074,80 @@ export default function (pi: ExtensionAPI) {
 		state.reviewerTimer = null;
 	}
 
+	/**
+	 * TP-057: Remove stale signal and shutdown files from .reviews/ directory.
+	 * Called before spawning a new persistent reviewer to prevent the reviewer
+	 * from consuming old signals or immediately seeing a stale shutdown marker.
+	 */
+	function cleanStaleReviewerSignals(reviewsDir: string): void {
+		try {
+			const files = readdirSync(reviewsDir);
+			for (const f of files) {
+				if (f.startsWith(REVIEWER_SIGNAL_PREFIX) || f === REVIEWER_SHUTDOWN_SIGNAL) {
+					try { unlinkSync(join(reviewsDir, f)); } catch {}
+				}
+			}
+		} catch {
+			// Directory may not exist yet — not an error
+		}
+	}
+
+	/**
+	 * TP-057: Shut down the persistent reviewer session cleanly.
+	 * Writes shutdown signal, waits for clean exit within grace period,
+	 * then force-kills the session if still alive.
+	 *
+	 * Called from all executeTask exit paths (success, pause, error, stall)
+	 * to prevent orphan tmux sessions.
+	 *
+	 * @param reason - Why the reviewer is being shut down (for logging)
+	 */
+	async function shutdownPersistentReviewer(reason: string): Promise<void> {
+		if (!state.persistentReviewerSession) return;
+
+		const sessionName = state.persistentReviewerSession;
+		console.error(`[task-runner] persistent reviewer: shutting down (${reason})`);
+
+		// Write shutdown signal so the reviewer exits cleanly
+		if (state.task) {
+			const reviewsDir = join(state.task.taskFolder, ".reviews");
+			const shutdownPath = join(reviewsDir, REVIEWER_SHUTDOWN_SIGNAL);
+			try {
+				if (!existsSync(reviewsDir)) mkdirSync(reviewsDir, { recursive: true });
+				writeFileSync(shutdownPath, "shutdown");
+			} catch (err: any) {
+				console.error(`[task-runner] persistent reviewer: failed to write shutdown signal: ${err?.message}`);
+			}
+		}
+
+		// Poll for session death within grace period
+		const graceStart = Date.now();
+		while (Date.now() - graceStart < REVIEWER_SHUTDOWN_GRACE_MS) {
+			const alive = spawnSync("tmux", ["has-session", "-t", sessionName]);
+			if (alive.status !== 0) break;
+			await new Promise(r => setTimeout(r, 1000));
+		}
+
+		// Force kill if still alive after grace period
+		const finalCheck = spawnSync("tmux", ["has-session", "-t", sessionName]);
+		if (finalCheck.status === 0) {
+			console.error(`[task-runner] persistent reviewer: killing session after grace period`);
+			spawnSync("tmux", ["kill-session", "-t", sessionName]);
+		}
+
+		// Reset state
+		state.persistentReviewerSession = null;
+		state.persistentReviewerKill = null;
+		state.persistentReviewerSignalNum = 0;
+		clearReviewerState();
+		writeLaneState(state);
+
+		if (state.task) {
+			const statusPath = join(state.task.taskFolder, "STATUS.md");
+			logExecution(statusPath, "Persistent reviewer", `Shutdown complete (${reason})`);
+		}
+	}
+
 	if (isOrchestratedMode()) {
 		pi.registerTool({
 			name: "review_step",
@@ -2080,9 +2211,6 @@ export default function (pi: ExtensionAPI) {
 				const outputPath = join(reviewsDir, `R${num}-${reviewType}-step${stepNum}.md`);
 
 				// Resolve step baseline commit for code reviews.
-				// The worker should pass the pre-step HEAD SHA as `baseline` so the
-				// reviewer sees only this step's changes (not cumulative diff).
-				// Falls back to undefined (full diff) if baseline is not provided.
 				const stepBaselineCommit: string | undefined =
 					reviewType === "code" ? (baseline || undefined) : undefined;
 
@@ -2118,12 +2246,15 @@ export default function (pi: ExtensionAPI) {
 				state.reviewerElapsed = 0;
 				state.reviewerLastTool = "";
 				state.reviewerToolCount = 0;
-				state.reviewerInputTokens = 0;
-				state.reviewerOutputTokens = 0;
-				state.reviewerCacheReadTokens = 0;
-				state.reviewerCacheWriteTokens = 0;
-				state.reviewerCostUsd = 0;
-				state.reviewerContextPct = 0;
+				// Don't reset cumulative token counts for persistent reviewer — they accumulate
+				if (!state.persistentReviewerSession) {
+					state.reviewerInputTokens = 0;
+					state.reviewerOutputTokens = 0;
+					state.reviewerCacheReadTokens = 0;
+					state.reviewerCacheWriteTokens = 0;
+					state.reviewerCostUsd = 0;
+					state.reviewerContextPct = 0;
+				}
 				updateWidgets();
 
 				const startTime = Date.now();
@@ -2132,23 +2263,54 @@ export default function (pi: ExtensionAPI) {
 					updateWidgets();
 				}, 1000);
 
-				// Read the request file content as the prompt
-				const promptContent = readFileSync(requestPath, "utf-8");
-
 				// Resolve context window for reviewer context% calculation
 				const { contextWindow } = resolveContextWindow(config, ctx);
 
-				try {
-					// Spawn reviewer via spawnAgentTmux with onTelemetry for live metrics
+				// ── TP-057: Persistent Reviewer Session ─────────────────
+				// On the first review_step call, spawn a persistent reviewer
+				// that stays alive via the wait_for_review tool. On subsequent
+				// calls, reuse the existing session by writing signal files.
+				// Fall back to fresh-spawn if the persistent session dies.
+
+				/**
+				 * Check if the persistent reviewer tmux session is still alive.
+				 */
+				function isPersistentReviewerAlive(): boolean {
+					if (!state.persistentReviewerSession) return false;
+					const result = spawnSync("tmux", ["has-session", "-t", state.persistentReviewerSession]);
+					return result.status === 0;
+				}
+
+				/**
+				 * Spawn a persistent reviewer session with the reviewer-extension
+				 * loaded, so the reviewer can use wait_for_review to receive requests.
+				 */
+				function spawnPersistentReviewer(): void {
+					const reviewerExtPath = resolveReviewerExtensionPath();
+					if (!reviewerExtPath) {
+						throw new Error("Cannot find reviewer-extension.ts. Ensure taskplane is installed correctly.");
+					}
+
+					// Clean stale signal/shutdown files before spawning
+					cleanStaleReviewerSignals(reviewsDir);
+
+					// Initial prompt tells the reviewer to call wait_for_review
+					const initialPrompt =
+						"You are a persistent reviewer for this task. " +
+						"Call the `wait_for_review` tool now to receive your first review request. " +
+						"After writing each review, call `wait_for_review` again for the next one.";
+
 					const spawned = spawnAgentTmux({
 						sessionName,
 						cwd: ctx.cwd,
 						systemPrompt,
-						prompt: promptContent,
+						prompt: initialPrompt,
 						model: reviewerModel,
 						tools: config.reviewer.tools || reviewerDef?.tools || "read,write,bash,grep,find,ls",
 						thinking: config.reviewer.thinking || "on",
 						taskId: task.taskId,
+						extensions: [reviewerExtPath],
+						env: { REVIEWER_SIGNAL_DIR: reviewsDir },
 						onTelemetry: (delta) => {
 							// Accumulate tokens and cost
 							state.reviewerInputTokens += delta.inputTokens;
@@ -2173,27 +2335,96 @@ export default function (pi: ExtensionAPI) {
 						},
 					});
 
+					// Store persistent session state
+					state.persistentReviewerSession = sessionName;
+					state.persistentReviewerKill = spawned.kill;
+					state.persistentReviewerSignalNum = 0;
 					state.reviewerProc = { kill: spawned.kill };
 
-					// Await reviewer completion
-					const result = await spawned.promise;
+					// Don't await spawned.promise — the session stays alive across reviews.
+					// Handle session death via isPersistentReviewerAlive() checks.
+					spawned.promise.then(() => {
+						// Session ended (reviewer exited or was killed)
+						console.error(`[task-runner] persistent reviewer session '${sessionName}' ended`);
+					}).catch((err: any) => {
+						console.error(`[task-runner] persistent reviewer session error: ${err?.message || err}`);
+					});
+				}
+
+				/**
+				 * Write signal file to notify the persistent reviewer of a new request.
+				 * Returns the signal number used.
+				 */
+				function signalPersistentReviewer(): number {
+					state.persistentReviewerSignalNum++;
+					const sigNum = String(state.persistentReviewerSignalNum).padStart(3, "0");
+					const signalPath = join(reviewsDir, `${REVIEWER_SIGNAL_PREFIX}${sigNum}`);
+					// Write the request filename so the reviewer can find it
+					// (signal num and review counter may diverge after respawns)
+					writeFileSync(signalPath, `request-R${num}.md`);
+					return state.persistentReviewerSignalNum;
+				}
+
+				/**
+				 * Poll for the verdict file to appear (written by the reviewer).
+				 * Same pattern as the original review_step handler.
+				 */
+				async function pollForVerdict(): Promise<string> {
+					const verdictTimeout = 30 * 60 * 1000; // 30 minutes
+					const pollStart = Date.now();
+					while (Date.now() - pollStart < verdictTimeout) {
+						if (existsSync(outputPath)) {
+							return readFileSync(outputPath, "utf-8");
+						}
+						// Also check if persistent reviewer died while we're waiting
+						if (state.persistentReviewerSession && !isPersistentReviewerAlive()) {
+							throw new Error("Persistent reviewer session died while waiting for verdict");
+						}
+						await new Promise(r => setTimeout(r, 2000));
+					}
+					throw new Error("Reviewer verdict timeout — no output file after 30 minutes");
+				}
+
+				try {
+					// ── Persistent reviewer: spawn or reuse ─────────────
+					const needsSpawn = !state.persistentReviewerSession || !isPersistentReviewerAlive();
+
+					if (needsSpawn && state.persistentReviewerSession) {
+						// Session was previously active but died — log fallback
+						console.error(`[task-runner] persistent reviewer session dead — respawning`);
+						logExecution(statusPath, `Reviewer R${num}`,
+							`persistent reviewer dead — respawning for ${reviewType} review`);
+						state.persistentReviewerSession = null;
+						state.persistentReviewerKill = null;
+						state.persistentReviewerSignalNum = 0;
+					}
+
+					if (needsSpawn) {
+						spawnPersistentReviewer();
+						// Give the reviewer a moment to start and call wait_for_review
+						await new Promise(r => setTimeout(r, 5000));
+					}
 
-					clearInterval(state.reviewerTimer);
+					// Signal the reviewer with the new request
+					signalPersistentReviewer();
+
+					// Poll for the verdict file
+					const reviewContent = await pollForVerdict();
+
+					// Stop the per-review timer
+					if (state.reviewerTimer) clearInterval(state.reviewerTimer);
 					state.reviewerElapsed = Date.now() - startTime;
-					state.reviewerStatus = result.exitCode === 0 ? "done" : "error";
-					state.reviewerProc = null;
+					state.reviewerStatus = "done";
 					writeLaneState(state);
 					updateWidgets();
 
 					// Extract verdict from review output
 					let verdict = "UNKNOWN";
 					let reviseDetails = "";
-					if (existsSync(outputPath)) {
-						const review = readFileSync(outputPath, "utf-8");
-						verdict = extractVerdict(review);
+					if (reviewContent) {
+						verdict = extractVerdict(reviewContent);
 						if (verdict === "REVISE") {
-							// Extract a brief summary from the review for the worker
-							const summaryMatch = review.match(/###?\s*Summary[:\s]*([\s\S]*?)(?=###|$)/i);
+							const summaryMatch = reviewContent.match(/###?\s*Summary[:\s]*([\s\S]*?)(?=###|$)/i);
 							reviseDetails = summaryMatch
 								? summaryMatch[1].trim().slice(0, 500)
 								: "See review file for details.";
@@ -2211,8 +2442,12 @@ export default function (pi: ExtensionAPI) {
 						`${reviewType} Step ${stepNum}: ${verdict}`);
 					updateStatusField(statusPath, "Review Counter", `${state.reviewCounter}`);
 
-					// Clear reviewer state for dashboard
-					clearReviewerState();
+					// Set reviewer to idle (NOT clear — persistent session stays alive)
+					state.reviewerStatus = "idle";
+					state.reviewerType = "";
+					state.reviewerStep = 0;
+					if (state.reviewerTimer) clearInterval(state.reviewerTimer);
+					state.reviewerTimer = null;
 					writeLaneState(state);
 					updateWidgets();
 
@@ -2233,20 +2468,116 @@ export default function (pi: ExtensionAPI) {
 						details: undefined,
 					};
 				} catch (err: any) {
-					// Reviewer crashed
-					clearInterval(state.reviewerTimer);
-					clearReviewerState();
-					state.reviewerStatus = "error";
-					writeLaneState(state);
-					updateWidgets();
-
+					// ── Fallback: kill persistent session, try fresh spawn ──
+					console.error(`[task-runner] persistent reviewer error: ${err?.message || err}`);
 					logExecution(statusPath, `Reviewer R${num}`,
-						`${reviewType} review — reviewer crashed: ${err?.message || err}`);
+						`persistent reviewer failed — falling back to fresh spawn: ${err?.message || err}`);
 
-					return {
-						content: [{ type: "text" as const, text: `UNAVAILABLE — reviewer error: ${err?.message || err}` }],
-						details: undefined,
-					};
+					// Kill the dead/broken persistent session
+					if (state.persistentReviewerKill) {
+						try { state.persistentReviewerKill(); } catch {}
+					}
+					state.persistentReviewerSession = null;
+					state.persistentReviewerKill = null;
+					state.persistentReviewerSignalNum = 0;
+
+					// ── Fresh spawn fallback (original behavior) ────────
+					try {
+						const promptContent = readFileSync(requestPath, "utf-8");
+						const spawned = spawnAgentTmux({
+							sessionName,
+							cwd: ctx.cwd,
+							systemPrompt,
+							prompt: promptContent,
+							model: reviewerModel,
+							tools: config.reviewer.tools || reviewerDef?.tools || "read,write,bash,grep,find,ls",
+							thinking: config.reviewer.thinking || "on",
+							taskId: task.taskId,
+							onTelemetry: (delta) => {
+								state.reviewerInputTokens += delta.inputTokens;
+								state.reviewerOutputTokens += delta.outputTokens;
+								state.reviewerCacheReadTokens += delta.cacheReadTokens;
+								state.reviewerCacheWriteTokens += delta.cacheWriteTokens;
+								state.reviewerCostUsd += delta.cost;
+								state.reviewerToolCount += delta.toolCalls;
+								if (delta.lastTool) state.reviewerLastTool = delta.lastTool;
+								if (delta.latestTotalTokens > 0 && contextWindow > 0) {
+									state.reviewerContextPct = (delta.latestTotalTokens / contextWindow) * 100;
+								}
+								writeLaneState(state);
+								updateWidgets();
+							},
+						});
+
+						state.reviewerProc = { kill: spawned.kill };
+						const result = await spawned.promise;
+
+						clearInterval(state.reviewerTimer);
+						state.reviewerElapsed = Date.now() - startTime;
+						state.reviewerStatus = result.exitCode === 0 ? "done" : "error";
+						state.reviewerProc = null;
+						writeLaneState(state);
+						updateWidgets();
+
+						// Extract verdict from fallback review
+						let verdict = "UNKNOWN";
+						let reviseDetails = "";
+						if (existsSync(outputPath)) {
+							const review = readFileSync(outputPath, "utf-8");
+							verdict = extractVerdict(review);
+							if (verdict === "REVISE") {
+								const summaryMatch = review.match(/###?\s*Summary[:\s]*([\s\S]*?)(?=###|$)/i);
+								reviseDetails = summaryMatch
+									? summaryMatch[1].trim().slice(0, 500)
+									: "See review file for details.";
+							}
+						} else {
+							verdict = "UNAVAILABLE";
+							logExecution(statusPath, `Reviewer R${num}`,
+								`${reviewType} review — fallback reviewer did not produce output`);
+						}
+
+						logReview(statusPath, `R${num}`, reviewType, stepNum, verdict,
+							`.reviews/R${num}-${reviewType}-step${stepNum}.md`);
+						logExecution(statusPath, `Review R${num}`,
+							`${reviewType} Step ${stepNum}: ${verdict} (fallback)`);
+						updateStatusField(statusPath, "Review Counter", `${state.reviewCounter}`);
+
+						clearReviewerState();
+						writeLaneState(state);
+						updateWidgets();
+
+						let resultText: string;
+						if (verdict === "APPROVE") {
+							resultText = "APPROVE";
+						} else if (verdict === "REVISE") {
+							resultText = `REVISE: ${reviseDetails}\n\nFull review: .reviews/R${num}-${reviewType}-step${stepNum}.md`;
+						} else if (verdict === "RETHINK") {
+							resultText = `RETHINK — reconsider your approach. See .reviews/R${num}-${reviewType}-step${stepNum}.md`;
+						} else {
+							resultText = `UNAVAILABLE — reviewer did not produce a usable verdict.`;
+						}
+
+						return {
+							content: [{ type: "text" as const, text: resultText }],
+							details: undefined,
+						};
+					} catch (fallbackErr: any) {
+						// Both persistent and fallback failed
+						clearInterval(state.reviewerTimer);
+						clearReviewerState();
+						state.reviewerStatus = "error";
+						writeLaneState(state);
+						updateWidgets();
+
+						logExecution(statusPath, `Reviewer R${num}`,
+							`${reviewType} review — both persistent and fallback failed: ${fallbackErr?.message || fallbackErr}`);
+
+						return {
+							content: [{ type: "text" as const, text: `UNAVAILABLE — reviewer error: ${fallbackErr?.message || fallbackErr}` }],
+							details: undefined,
+						};
+					}
 				}
 			},
 		});
@@ -2298,6 +2629,7 @@ export default function (pi: ExtensionAPI) {
 			if (state.phase === "paused") {
 				logExecution(statusPath, "Paused", `User paused at iteration ${iter + 1}`);
 				ctx.ui.notify(`Task paused at iteration ${iter + 1}`, "info");
+				await shutdownPersistentReviewer("task paused");
 				return;
 			}
 
@@ -2329,7 +2661,10 @@ export default function (pi: ExtensionAPI) {
 
 			await runWorker(remainingSteps, ctx);
 
-			if (state.phase === "error") return;
+			if (state.phase === "error") {
+				await shutdownPersistentReviewer("worker error");
+				return;
+			}
 
 			// ── Post-worker: determine which steps were newly completed ──
 			const afterStatus = parseStatusMd(readFileSync(statusPath, "utf-8"));
@@ -2345,6 +2680,7 @@ export default function (pi: ExtensionAPI) {
 					logExecution(statusPath, "Task blocked", `No progress after ${noProgressCount} iterations`);
 					ctx.ui.notify(`⚠️ Task blocked — no progress after ${noProgressCount} iterations`, "error");
 					state.phase = "error";
+					await shutdownPersistentReviewer("task stalled");
 					return;
 				}
 			} else {
@@ -2409,10 +2745,14 @@ export default function (pi: ExtensionAPI) {
 				logExecution(statusPath, "Task incomplete", `Max iterations (${config.context.max_worker_iterations}) reached with incomplete steps: ${incomplete}`);
 				ctx.ui.notify(`⚠️ Task incomplete — max iterations reached. Incomplete: ${incomplete}`, "error");
 				state.phase = "error";
+				await shutdownPersistentReviewer("max iterations reached");
 				return;
 			}
 		}
 
+		// ── TP-057: Shutdown persistent reviewer ────────────────────────
+		await shutdownPersistentReviewer("task complete");
+
 		// All steps done — run quality gate if enabled, then create .DONE
 		if (config.quality_gate.enabled) {
 			// ── Quality Gate Enabled ─────────────────────────────────
@@ -3545,6 +3885,11 @@ export default function (pi: ExtensionAPI) {
 		// Kill any running subprocesses
 		if (state.workerProc) try { state.workerProc.kill(); } catch {}
 		if (state.reviewerProc) try { state.reviewerProc.kill(); } catch {}
+		// TP-057: Kill persistent reviewer session if alive
+		if (state.persistentReviewerKill) try { state.persistentReviewerKill(); } catch {}
+		state.persistentReviewerSession = null;
+		state.persistentReviewerKill = null;
+		state.persistentReviewerSignalNum = 0;
 		if (state.workerTimer) clearInterval(state.workerTimer);
 		if (state.reviewerTimer) clearInterval(state.reviewerTimer);
 

package/extensions/taskplane/supervisor-primer.md

@@ -50,10 +50,12 @@ You (supervisor) ← operator talks to you
 │   └── Create .DONE file when all steps complete
 │
 ├── Reviewer Agents (LLM, cross-model)
-│   ├── Spawned by task-runner between worker iterations
-│   ├── Review plans (before implementation) and code (after)
+│   ├── Persistent: one reviewer per task, stays alive across all reviews
+│   ├── Receives review requests via wait_for_review tool (signal files)
+│   ├── Reviews plans (before implementation) and code (after)
 │   ├── Write structured verdict to .reviews/ directory
-│   └── APPROVE or REVISE (worker re-iterates on REVISE)
+│   ├── APPROVE or REVISE (worker addresses feedback inline)
+│   └── Falls back to fresh spawn if persistent session dies
 │
 └── Merge Agents (LLM)
     ├── Run in temporary merge worktrees

package/extensions/taskplane/types.ts

@@ -1306,6 +1306,41 @@ export const MERGE_HEALTH_STUCK_THRESHOLD_MS = 20 * 60 * 1000; // 20 minutes
  */
 export const MERGE_HEALTH_CAPTURE_LINES = 10;
 
+// ── Persistent Reviewer Constants (TP-057) ───────────────────────────
+
+/**
+ * Polling interval (ms) for the `wait_for_review` tool to check for signal files.
+ * Reviews take minutes; 3s latency is invisible to the user.
+ * @since TP-057
+ */
+export const REVIEWER_POLL_INTERVAL_MS = 3_000;
+
+/**
+ * Maximum time (ms) for the `wait_for_review` tool to wait for a review signal.
+ * 30 minutes — generous for long-running code reviews.
+ * @since TP-057
+ */
+export const REVIEWER_WAIT_TIMEOUT_MS = 30 * 60 * 1000;
+
+/**
+ * Grace period (ms) after writing shutdown signal before killing the reviewer session.
+ * Allows the reviewer to exit cleanly after receiving the shutdown signal.
+ * @since TP-057
+ */
+export const REVIEWER_SHUTDOWN_GRACE_MS = 10_000;
+
+/**
+ * Signal file prefix for review requests. Full name: `.review-signal-{NNN}`
+ * @since TP-057
+ */
+export const REVIEWER_SIGNAL_PREFIX = ".review-signal-";
+
+/**
+ * Shutdown signal filename written to .reviews/ when the task is complete.
+ * @since TP-057
+ */
+export const REVIEWER_SHUTDOWN_SIGNAL = ".review-shutdown";
+
 // ── Merge Health Event Types (TP-056) ────────────────────────────────
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskplane",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "AI agent orchestration for pi — parallel task execution with checkpoint discipline",
   "keywords": [
     "pi-package",
@@ -31,6 +31,7 @@
     "dashboard/",
     "extensions/task-runner.ts",
     "extensions/task-orchestrator.ts",
+    "extensions/reviewer-extension.ts",
     "extensions/taskplane/",
     "skills/",
     "templates/"

package/templates/agents/local/task-reviewer.md

@@ -16,6 +16,7 @@ name: task-reviewer
   - Verdict format (APPROVE / REVISE)
   - Review file output conventions
   - Plan granularity guidance
+  - Persistent reviewer mode (wait_for_review tool workflow)
 
   Add project-specific review criteria below. Common examples:
   - Required test coverage thresholds

package/templates/agents/task-reviewer.md

@@ -9,12 +9,38 @@ task implementations. You have full read access to the codebase and can run comm
 
 ## How You Work
 
+You operate in one of two modes depending on available tools:
+
+### Persistent Mode (when `wait_for_review` tool is available)
+
+You are a **persistent reviewer** that stays alive across all review requests for
+a task. This preserves your context — you remember what you reviewed in earlier
+steps and can reference previous findings.
+
+1. Call `wait_for_review()` to receive your first review request
+2. The request specifies an **output file path** — you MUST write your review there
+3. Use your tools to explore the codebase — read files, run `git diff`, check patterns
+4. **Use the `write` tool to create the output file with your review**
+5. Use the appropriate verdict: APPROVE, REVISE, or RETHINK
+6. Call `wait_for_review()` again to receive the next request
+7. Repeat until you receive a `SHUTDOWN` signal, then exit cleanly
+
+**Cross-step awareness:** When reviewing later steps, reference your earlier
+reviews when relevant. For example: "I flagged X in Step 2's plan review —
+checking if it was addressed in this code review."
+
+### Fresh Spawn Mode (when `wait_for_review` is NOT available)
+
+You handle a single review request and then exit.
+
 1. Read the review request provided to you carefully
 2. The request specifies an **output file path** — you MUST write your review there
 3. Use your tools to explore the codebase — read files, run `git diff`, check patterns
 4. **Use the `write` tool to create the output file with your review**
 5. Use the appropriate verdict: APPROVE, REVISE, or RETHINK
 
+### Critical Rule (Both Modes)
+
 **CRITICAL:** Your review MUST be written to disk using the `write` tool.
 Do NOT just respond with text — the orchestrator reads the OUTPUT FILE to get
 your verdict. If you don't write the file, your review is lost.