@overdeck/desktop 0.45.6 → 0.45.8

package/server/{review-agent-C-A6IgXc.js → review-agent-phzqNqIs.js}

@@ -1,18 +1,18 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Ft as resolveProjectForIssue, Nt as readIssueRecordSync, Ot as init_record, Ur as packageRoot, Vr as init_paths, X as resolveModel, f as loadConfigSync, t as init_config_yaml, yr as AGENTS_DIR } from "./config-yaml-DbdN9Fuq.js";
-import { a as init_activity_logger, n as emitActivityEntrySync } from "./activity-logger-Dm95Ua07.js";
-import { C as isPaneDead, O as listSessionNames, w as killSession, x as init_tmux } from "./tmux-CBYZ5lKF.js";
-import { c as init_review_status, y as setReviewStatusSync } from "./review-status-DWAsTqfJ.js";
-import { d as init_agents, f as listAgentIdsByPrefixSync, m as removeAgentSync } from "./briefing-freshness-B3YxHQ-L.js";
-import { Pn as getAgentStateSync, t as init_agents$1 } from "./agents-D_x5BSZM.js";
+import { Ft as resolveProjectForIssue, Gr as sessionFilePath, Nt as readIssueRecordSync, Ot as init_record, Ur as packageRoot, Vr as init_paths, X as resolveModel, f as loadConfigSync, t as init_config_yaml, yr as AGENTS_DIR } from "./config-yaml-DPAieL_G.js";
+import { a as init_activity_logger, n as emitActivityEntrySync } from "./activity-logger-pcbf-e30.js";
+import { C as isPaneDead, O as listSessionNames, w as killSession, x as init_tmux } from "./tmux-ePNhMIMU.js";
+import { c as init_review_status, s as getReviewStatusSync, y as setReviewStatusSync } from "./review-status-BQjqQXZG.js";
+import { d as init_agents, f as listAgentIdsByPrefixSync, m as removeAgentSync } from "./briefing-freshness-CXhZdnB8.js";
+import { Pn as getAgentStateSync, t as init_agents$1 } from "./agents-DHvsjsuP.js";
 import { a as PAN_DIRNAME, p as init_types } from "./types-CE1m_daD.js";
-import { n as init_review_monitor, t as REVIEW_SUB_ROLES } from "./review-monitor-BNV3kjLq.js";
-import { n as shouldSkipDispatchAsMerged, t as init_merge_verification } from "./merge-verification-Kvh4WViS.js";
-import { n as formatTier1Summary, o as init_review_context, t as buildReviewContext } from "./review-context-De14xPtc.js";
-import { a as resolveConflictGate, i as init_conflict_gate, r as getCachedConflictGateMergeability, t as buildRealConflictGateDeps } from "./conflict-gate-CgOtMo8i.js";
+import { n as init_review_monitor, t as REVIEW_SUB_ROLES } from "./review-monitor-BKG2ubt5.js";
+import { n as shouldSkipDispatchAsMerged, t as init_merge_verification } from "./merge-verification-DA9rvqsE.js";
+import { n as formatTier1Summary, o as init_review_context, t as buildReviewContext } from "./review-context-CCq56O_Y.js";
+import { a as resolveConflictGate, i as init_conflict_gate, r as getCachedConflictGateMergeability, t as buildRealConflictGateDeps } from "./conflict-gate-BhKvrPxn.js";
 import { Effect } from "effect";
 import { dirname, join } from "path";
-import { mkdir, readFile, rm } from "fs/promises";
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
 import { exec } from "child_process";
 import { promisify } from "util";
 //#region ../../lib/cloister/review-resume-decision.ts
@@ -34,43 +34,56 @@ function reviewResumeDecision(params) {
 }
 var init_review_resume_decision = __esmMin((() => {}));
 //#endregion
-//#region ../../lib/cloister/review-agent.ts
+//#region ../../lib/cloister/review-rerun-scope.ts
+function domainTouched(subRole, changedFiles) {
+	if (changedFiles.length === 0) return false;
+	switch (subRole) {
+		case "correctness":
+		case "requirements": return true;
+		case "security": return changedFiles.some((f) => SECURITY_SENSITIVE.test(f));
+		case "performance": return changedFiles.some((f) => PERFORMANCE_SENSITIVE.test(f));
+		default: return true;
+	}
+}
+function reviewersToRerun(input) {
+	const all = [...REVIEW_SUB_ROLES];
+	if (input.scope === "all") return all;
+	const verdicts = input.priorVerdicts ?? {};
+	const unproven = all.filter((r) => !verdicts[r] || !verdicts[r].atCommit);
+	const blocked = all.filter((r) => verdicts[r]?.status === "blocked");
+	if (input.scope === "blockers") return dedupe([...blocked, ...unproven]);
+	if (input.changedFiles === void 0) return all;
+	const touched = all.filter((r) => verdicts[r]?.status === "passed" && verdicts[r].atCommit && domainTouched(r, input.changedFiles));
+	return dedupe([
+		...blocked,
+		...unproven,
+		...touched
+	]);
+}
+function dedupe(roles) {
+	const set = new Set(roles);
+	return REVIEW_SUB_ROLES.filter((r) => set.has(r));
+}
+var SECURITY_SENSITIVE, PERFORMANCE_SENSITIVE;
+var init_review_rerun_scope = __esmMin((() => {
+	init_review_monitor();
+	SECURITY_SENSITIVE = /auth|crypt|token|secret|credential|password|session|login|permission|sandbox|escape|inject|input|parse|network|http|request|fetch|socket|proxy|exec|spawn|shell|env|\.env|package(-lock)?\.json|bun\.lock|yarn\.lock|Dockerfile|docker-compose/i;
+	PERFORMANCE_SENSITIVE = /query|sql|db|database|cache|index|loop|batch|stream|worker|pool|queue|schedul|poll|interval|timer|migration|perf|bench|concurren|parallel/i;
+}));
+//#endregion
+//#region ../../lib/cloister/review-convoy.ts
 /**
-* Review role entry point.
+* PAN-1862: the review CONVOY — sub-reviewer prompts and spawning, selective
+* re-review scope, warm-parent fork, and the discovery-ready orchestration.
 *
-* PAN-1048 review feedback 007: every legacy convoy helper has been retired.
-* The bash/tmux coordinator path (dispatchParallelReview /
-* spawnReviewCoordinatorSession / runParallelReview) was deleted in R6, and
-* the round-7 cleanup additionally removed the supporting cast that the
-* coordinator used to drive — spawnSingleReviewer, waitForReviewer,
-* archiveReviewerRound, parseReviewSynthesis, parseAgentOutput,
-* selectCompletedReviewers, getReviewAgents, getFilesChangedFromPR,
-* buildReviewFeedbackBody, parseReviewerTemplate, resolvePromptTemplatePath
-* (and the resolveTemplatePath alias), resolveReviewerModel,
-* reviewResultToReviewStatus, reviewerRetryBackoffMs,
-* isRetryableReviewerFailure, the ReviewContext / ReviewResult /
-* ReviewerTemplate / ReviewerRoundArtifact / ReviewerOutcome /
-* ReviewerWaitResult / ReviewerFailureReason / ReviewHistoryEntry types,
-* and DEFAULT_REVIEW_AGENTS / REVIEW_TIMEOUT_MS / MAX_REVIEWER_TIMEOUT_RETRIES
-* / REVIEWER_TIMEOUT_RETRY_BACKOFF_MS / REVIEW_HISTORY_DIR / REVIEW_HISTORY_FILE
-* / SPECIALISTS_DIR constants. None of these had any production caller after R6;
-* their tests went with them.
-*
-* Every active review surface — POST /api/review/:issueId/trigger, the
-* reactive scheduler review branch, and the dashboard kanban "Review again"
-* button — flows through
-* spawnReviewRoleForIssue → spawnRun(issueId, 'review'). The review role
-* launches four isolated review sub-role sessions via `pan review spawn-reviewer`,
-* then writes the report and signals the verdict via Overdeck's CLI inside
-* the role itself (see roles/review.md).
+* Split out of review-agent.ts (which keeps the review entry point, the
+* synthesis/self-review prompts, mode resolution, and session teardown).
+* This module must NEVER import review-agent.ts — review-agent imports (and
+* re-exports) from here, and a reverse edge would close a cycle.
 *
-* Surface area kept:
-*   - spawnReviewRoleForIssue       — the only review entry point
-*   - killAllReviewerSessions       — kill the canonical reviewer sessions
-*                                     for one issue (merge-agent +
-*                                     dashboard cancel/abort routes)
-*   - killAllReviewSessions         — kill ALL review sessions on shutdown
-*                                     (pan down)
+* The four convoy sub-roles are security, correctness, performance, and
+* requirements (REVIEW_SUB_ROLES, review-monitor.ts); the synthesis parent is
+* the fifth review role. See docs/REVIEW-AGENT-ARCHITECTURE.md.
 */
 /**
 * Read a convoy sub-role prompt template from the overdeck install.
@@ -135,116 +148,9 @@ async function buildConvoyPromptPromise(opts) {
 	console.log(`[review-agent] Convoy prompt for ${opts.issueId}/${opts.subRole}: ${sizeBytes} bytes`);
 	return prompt;
 }
-function buildReviewRolePrompt(opts) {
-	const subRoleFiles = REVIEW_SUB_ROLES.map((r) => `  ${join(opts.reviewDir, `${r}.md`)}`).join("\n");
-	const expectedSignals = REVIEW_SUB_ROLES.map((r) => `  REVIEWER_READY ${r} <outputPath> or REVIEWER_FAILED ${r} <reason> or REVIEWER_TIMEOUT ${r} <reason>`).join("\n");
-	const synthesisPath = join(opts.reviewDir, "synthesis.md");
-	const prompt = [
-		`STANDBY — REVIEW SYNTHESIS for ${opts.issueId}`,
-		"",
-		"Do NOT do anything yet. The Overdeck server has already spawned the four",
-		"convoy reviewers (security, correctness, performance, requirements) and they",
-		"are running in parallel right now. Your work begins only once they finish.",
-		"",
-		"You will receive exactly one `pan tell` signal per sub-role as each reviewer",
-		"finishes — these are delivered to you as user messages:",
-		expectedSignals,
-		"",
-		"Until all four terminal signals have arrived: do nothing. Do not read the",
-		"reviewer output files, do not run git, do not inspect tmux sessions, do not",
-		"poll anything. Just wait — the reviewers notify you when they finish, and",
-		"Deacon is the failsafe if one never starts or never completes. Acting early",
-		"wastes tokens reviewing nothing.",
-		"",
-		"Once you have all four terminal signals, follow roles/review.md exactly to",
-		"read the reports, synthesize the verdict, write the synthesis report, and",
-		"signal the status.",
-		"",
-		"── Review context ──",
-		`Issue: ${opts.issueId}`,
-		`Branch: ${opts.branch}`,
-		`Workspace: ${opts.workspace}`,
-		opts.prUrl ? `PR: ${opts.prUrl}` : `PR: (resolve via: gh pr view ${opts.branch})`,
-		`Run ID: ${opts.runId}`,
-		`Review directory: ${opts.reviewDir}`,
-		`Synthesis output file: ${synthesisPath}`,
-		"",
-		opts.tier1Summary ? [
-			"Shared review context:",
-			"─────────────────────────────────────────────────────────────",
-			opts.tier1Summary,
-			"─────────────────────────────────────────────────────────────",
-			"",
-			opts.contextManifestPath ? `Full manifest: ${opts.contextManifestPath}` : ""
-		].join("\n") : opts.contextManifestPath ? `Context manifest: ${opts.contextManifestPath}` : "Context manifest: (missing — block review per roles/review.md)",
-		"",
-		"Convoy reviewer output files (read each one ONLY after its REVIEWER_READY signal):",
-		subRoleFiles,
-		"",
-		"After writing the synthesis report, signal the verdict with Overdeck CLI:",
-		`  pan admin specialists done review ${opts.issueId} --status passed --notes "<one-line summary>"`,
-		`  pan admin specialists done review ${opts.issueId} --status blocked --notes "<one-line top blocker>"`,
-		"",
-		"After running the signal command above, STOP and wait — do not exit, do not run",
-		"any further commands. The session stays open for the next review cycle.",
-		"",
-		"Reactive Cloister dispatches the test role after review passes. Never queue tests yourself and never edit code."
-	].filter(Boolean).join("\n");
-	const sizeBytes = Buffer.byteLength(prompt, "utf-8");
-	console.log(`[review-agent] Synthesis prompt for ${opts.issueId}: ${sizeBytes} bytes`);
-	return prompt;
-}
-function buildSelfReviewPrompt(opts) {
-	const reviewReportPath = join(opts.reviewDir, "review.md");
-	const prompt = [
-		`CODE REVIEW for ${opts.issueId} — you are the sole reviewer; review the change yourself.`,
-		"",
-		"Review the diff for this branch yourself, across ALL dimensions in one pass:",
-		"correctness/logic, security, requirements/acceptance-criteria, and performance.",
-		"Do NOT spawn or wait for any sub-reviewers — there is no convoy; you do the",
-		"whole review yourself and emit the verdict.",
-		"",
-		"── Review context ──",
-		`Issue: ${opts.issueId}`,
-		`Branch: ${opts.branch}`,
-		`Workspace: ${opts.workspace}`,
-		opts.prUrl ? `PR: ${opts.prUrl}` : `PR: (resolve via: gh pr view ${opts.branch})`,
-		`Run ID: ${opts.runId}`,
-		`Review directory: ${opts.reviewDir}`,
-		`Review output file: ${reviewReportPath}`,
-		"",
-		opts.tier1Summary ? [
-			"Shared review context (risk-ranked changed files + acceptance criteria):",
-			"─────────────────────────────────────────────────────────────",
-			opts.tier1Summary,
-			"─────────────────────────────────────────────────────────────",
-			"",
-			opts.contextManifestPath ? `Full manifest: ${opts.contextManifestPath}` : ""
-		].join("\n") : opts.contextManifestPath ? `Context manifest: ${opts.contextManifestPath}` : "Context manifest: (missing — inspect the diff directly: git diff origin/main...HEAD)",
-		"",
-		"How to review:",
-		"1. Read the diff — use the manifest risk ranking, `git diff` the high-risk files,",
-		"   and read the surrounding code as needed.",
-		"2. Evaluate correctness, security, requirements/AC, and performance. Use the",
-		"   severity + verdict vocabulary in roles/review.md.",
-		`3. Write your findings to ${reviewReportPath}.`,
-		"",
-		"Then signal the verdict with the Overdeck CLI (exactly one):",
-		`  pan admin specialists done review ${opts.issueId} --status passed --notes "<one-line summary>"`,
-		`  pan admin specialists done review ${opts.issueId} --status blocked --notes "<one-line top blocker>"`,
-		"",
-		"After running the signal command above, STOP and wait — do not exit, do not run",
-		"any further commands. The session stays open for the next review cycle.",
-		"",
-		"Reactive Cloister dispatches the test role after review passes. Never queue tests yourself and never edit code."
-	].filter(Boolean).join("\n");
-	const sizeBytes = Buffer.byteLength(prompt, "utf-8");
-	console.log(`[review-agent] Self-review prompt for ${opts.issueId}: ${sizeBytes} bytes`);
-	return prompt;
-}
 async function spawnReviewSubRoleForIssuePromise(opts) {
 	try {
-		const { saveAgentState, spawnRun, getAgentStateSync, getLatestSessionIdSync, resumeAgent } = await import("./agents-KaEsWZ8D.js");
+		const { saveAgentState, spawnRun, getAgentStateSync, getLatestSessionIdSync, resumeAgent } = await import("./agents-BIggLvi_.js");
 		const cfg = loadConfigSync().config;
 		const outputPath = opts.outputPath ?? reviewerAgentOutputPath(opts.workspace, opts.runId, opts.subRole);
 		const synthesisAgentId = opts.synthesisAgentId ?? `agent-${opts.issueId.toLowerCase()}-review`;
@@ -270,8 +176,8 @@ async function spawnReviewSubRoleForIssuePromise(opts) {
 			tier1Summary
 		}));
 		const reviewerAgent = reviewerAgentId(opts.issueId, opts.subRole);
-		const savedReviewer = getAgentStateSync(reviewerAgent);
-		if (reviewResumeDecision({
+		const savedReviewer = opts.forkedSessionId ? null : getAgentStateSync(reviewerAgent);
+		if (!opts.forkedSessionId && reviewResumeDecision({
 			requestedModel: opts.model ?? model,
 			requestedHarness: opts.harness,
 			savedModel: savedReviewer?.model,
@@ -301,12 +207,24 @@ async function spawnReviewSubRoleForIssuePromise(opts) {
 			}
 			console.warn(`[review-agent] Convoy sub-reviewer ${opts.subRole} resume failed; falling back to a fresh session: ${resumeResult.error}`);
 		}
+		const forkedPreface = opts.forkedSessionId ? [
+			"SHARED DISCOVERY CONTEXT (PAN-1862): this session was forked from the review",
+			"parent AFTER it completed a shared discovery pass — the diff, the high-risk",
+			"changed files, and their surrounding code are already in your history above.",
+			"That pass exists for cost (forked reviewers reuse the warm prompt cache instead",
+			"of four full-price re-reads) and for consistency (every reviewer sees the same",
+			"curated context). BUILD ON IT: do not re-run a broad git diff and do not",
+			"re-read the files already shown above; read further code only where your",
+			"sub-role needs deeper detail.",
+			""
+		].join("\n") : "";
 		const run = await spawnRun(opts.issueId, "review", {
 			workspace: opts.workspace,
 			subRole: opts.subRole,
-			prompt,
+			prompt: forkedPreface + prompt,
 			model,
 			harness: opts.harness,
+			...opts.forkedSessionId ? { resumeSessionId: opts.forkedSessionId } : {},
 			reviewSynthesisAgentId: synthesisAgentId,
 			reviewOutputPath: outputPath,
 			allowHost: opts.allowHost ?? false
@@ -316,9 +234,10 @@ async function spawnReviewSubRoleForIssuePromise(opts) {
 		run.reviewOutputPath = outputPath;
 		run.reviewSynthesisAgentId = synthesisAgentId;
 		run.reviewDeadlineAt = new Date(Date.now() + REVIEWER_TIMEOUT_MS).toISOString();
+		if (opts.forkedSessionId) run.reviewForkedFromParent = true;
 		await Effect.runPromise(saveAgentState(run));
 		try {
-			const { notifyPipelineSync } = await import("./pipeline-notifier-DQsOtdjZ.js");
+			const { notifyPipelineSync } = await import("./pipeline-notifier-lwMa--Gz.js");
 			notifyPipelineSync({
 				type: "reviewer_started",
 				issueId: opts.issueId,
@@ -339,6 +258,442 @@ async function spawnReviewSubRoleForIssuePromise(opts) {
 		};
 	}
 }
+/**
+* PAN-1862: selective re-review scope for one dispatch — which convoy reviewers
+* run this cycle and which carry their prior passed verdict forward. Shared by
+* the inline dispatch path and the discovery-ready fork handler.
+*/
+async function computeConvoyScope(issueId, workspace) {
+	let inScope = [...REVIEW_SUB_ROLES];
+	let carried = [];
+	let scope = "changed";
+	try {
+		const { getReviewStatusSync } = await import("./review-status-bBkqUj5i.js");
+		scope = resolveReReviewScope(issueId);
+		const priorVerdicts = getReviewStatusSync(issueId)?.reviewerVerdicts;
+		let changedFiles;
+		const anchors = new Set(Object.values(priorVerdicts ?? {}).map((v) => v?.atCommit).filter((c) => !!c));
+		if (anchors.size === 1) try {
+			const { stdout } = await execAsync$1(`git diff --name-only ${[...anchors][0]}..HEAD`, {
+				cwd: workspace,
+				encoding: "utf-8",
+				timeout: 15e3
+			});
+			changedFiles = stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+		} catch {}
+		inScope = reviewersToRerun({
+			scope,
+			priorVerdicts,
+			changedFiles
+		});
+		carried = REVIEW_SUB_ROLES.filter((r) => !inScope.includes(r)).map((r) => ({
+			subRole: r,
+			atCommit: priorVerdicts?.[r]?.atCommit
+		}));
+		if (carried.length > 0) console.log(`[review-agent] Selective re-review for ${issueId} (scope=${scope}): re-running [${inScope.join(", ")}], carrying forward [${carried.map((c) => c.subRole).join(", ")}]`);
+	} catch (scopeErr) {
+		console.warn(`[review-agent] Selective re-review scope resolution failed for ${issueId} — running the full convoy:`, scopeErr);
+		inScope = [...REVIEW_SUB_ROLES];
+		carried = [];
+	}
+	return {
+		inScope,
+		carried,
+		scope
+	};
+}
+/**
+* PAN-1862 Phase A: fork the synthesis parent's Claude session JSONL to a fresh
+* session id so a convoy reviewer can `--resume` it and inherit the discovery
+* context (and its warm, content-addressed prompt cache). Returns null when the
+* fork is not possible — caller degrades to a fresh independent spawn (NFR-2).
+* The source JSONL is copied, never modified.
+*/
+async function forkParentSessionForReviewer(parentAgentId, workspace) {
+	try {
+		const { getLatestSessionIdSync } = await import("./agents-BIggLvi_.js");
+		const parentSessionId = getLatestSessionIdSync(parentAgentId);
+		if (!parentSessionId) return null;
+		const src = sessionFilePath(workspace, parentSessionId);
+		const { existsSync } = await import("fs");
+		if (!existsSync(src)) return null;
+		const { reserveForkSession, copySessionForFork } = await import("./session-fork-DDSDVoIK.js");
+		const reserved = await reserveForkSession(workspace);
+		await copySessionForFork(src, reserved.sessionFile, { fullHistory: true });
+		return reserved.sessionId;
+	} catch (err) {
+		console.warn(`[review-agent] Fork from ${parentAgentId} failed (degrading to independent spawn): ${err instanceof Error ? err.message : String(err)}`);
+		return null;
+	}
+}
+/**
+* Launch the review convoy for one run: write carried-forward stub reports, then
+* spawn (or fork-resume) each in-scope sub-reviewer. Shared by the inline
+* dispatch path (no fork) and the discovery-ready handler (fork).
+*/
+async function launchConvoyReviewersPromise(params) {
+	const reviewDir = join(params.workspace, PAN_DIRNAME, "review", params.runId);
+	if (params.carried.length > 0) {
+		await mkdir(reviewDir, { recursive: true });
+		for (const c of params.carried) {
+			const stubPath = reviewerAgentOutputPath(params.workspace, params.runId, c.subRole);
+			const anchorNote = c.atCommit ? ` at commit ${c.atCommit.slice(0, 8)}` : "";
+			await writeFile(stubPath, [
+				`# ${c.subRole} review — VERDICT CARRIED FORWARD`,
+				"",
+				"## Verdict: APPROVED (carried forward — reviewer not re-run this cycle)",
+				"",
+				`This reviewer passed the prior cycle${anchorNote} and no files in its domain`,
+				`changed since (reReviewScope=${params.scope}, PAN-1862 selective re-review).`,
+				"Its prior findings report remains the report of record for that verdict.",
+				"",
+				"## Findings",
+				"",
+				"None.",
+				""
+			].join("\n"), "utf-8");
+		}
+	}
+	const cfg = loadConfigSync().config;
+	const { getAgentStateSync } = await import("./agents-BIggLvi_.js");
+	const parentState = getAgentStateSync(params.synthesisAgentId);
+	const reviewerResults = await Promise.all(params.inScope.map(async (subRole) => {
+		const outputPath = reviewerAgentOutputPath(params.workspace, params.runId, subRole);
+		let forkedSessionId;
+		if (params.forkFromParent && parentState?.harness === "claude-code" && !params.harness) try {
+			const { getLatestSessionIdSync } = await import("./agents-BIggLvi_.js");
+			const reviewerModel = params.model ?? resolveModel("review", subRole, cfg);
+			if (!!!getLatestSessionIdSync(reviewerAgentId(params.issueId, subRole)) && reviewerModel === parentState.model) {
+				forkedSessionId = await forkParentSessionForReviewer(params.synthesisAgentId, params.workspace) ?? void 0;
+				if (forkedSessionId) console.log(`[review-agent] Forked ${subRole} reviewer for ${params.issueId} from ${params.synthesisAgentId}'s discovery session (PAN-1862)`);
+			}
+		} catch {}
+		const result = await Effect.runPromise(spawnReviewSubRoleForIssue({
+			issueId: params.issueId,
+			workspace: params.workspace,
+			subRole,
+			runId: params.runId,
+			outputPath,
+			contextManifestPath: params.contextManifestPath,
+			synthesisAgentId: params.synthesisAgentId,
+			...params.model ? { model: params.model } : {},
+			...params.harness ? { harness: params.harness } : {},
+			...forkedSessionId ? { forkedSessionId } : {},
+			allowHost: params.allowHost ?? false
+		}));
+		if (!result.success) try {
+			const { messageAgent } = await import("./agents-BIggLvi_.js");
+			await messageAgent(params.synthesisAgentId, `REVIEWER_FAILED ${subRole} ${result.error ?? result.message}`);
+		} catch (signalErr) {
+			console.warn(`[review-agent] Failed to signal ${subRole} spawn failure to ${params.synthesisAgentId}:`, signalErr);
+		}
+		return result;
+	}));
+	const failedReviewers = reviewerResults.filter((r) => !r.success);
+	if (failedReviewers.length > 0) console.warn(`[review-agent] Convoy launched for ${params.issueId}, but ${failedReviewers.length} reviewer(s) failed to spawn`);
+	return reviewerResults;
+}
+/**
+* Effect variant of {@link spawnReviewRoleForIssue}. The Promise version
+* returns a structured result instead of throwing, so the Effect form lifts
+* via `Effect.promise`.
+*/
+/**
+* PAN-1862 Phase A (FR-2/FR-3/FR-4, NFR-5): handle the parent's discovery-ready
+* signal — fork the parent's session into the convoy reviewers and launch them.
+* Idempotent: a repeat signal (or a signal after the convoy already launched)
+* is a no-op. The parent survives unmodified and resumes its synthesis role;
+* the CLI (`pan admin specialists discovery-ready review <id>`) and the deacon
+* stalled-discovery backstop both land here.
+*/
+async function handleReviewDiscoveryReady(issueId, opts = {}) {
+	const normalized = issueId.toUpperCase();
+	const parentId = `agent-${normalized.toLowerCase()}-review`;
+	const { saveAgentState, getAgentStateSync } = await import("./agents-BIggLvi_.js");
+	const parent = getAgentStateSync(parentId);
+	if (!parent) return {
+		success: false,
+		message: `No review parent state for ${normalized} — nothing to fork`
+	};
+	const workspace = parent.workspace;
+	const runId = parent.reviewRunId;
+	if (!workspace || !runId) return {
+		success: false,
+		message: `Review parent for ${normalized} is missing workspace/runId state — cannot launch the convoy`
+	};
+	try {
+		const sessions = await Effect.runPromise(listSessionNames());
+		const reviewerPrefix = `agent-${normalized.toLowerCase()}-review-`;
+		if (sessions.some((name) => name.startsWith(reviewerPrefix))) {
+			parent.reviewDiscoveryPending = false;
+			await Effect.runPromise(saveAgentState(parent));
+			return {
+				success: true,
+				message: `Convoy already launched for ${normalized} — no-op`
+			};
+		}
+	} catch {}
+	try {
+		const { existsSync } = await import("node:fs");
+		if (REVIEW_SUB_ROLES.some((subRole) => existsSync(reviewerAgentOutputPath(workspace, runId, subRole)))) {
+			parent.reviewDiscoveryPending = false;
+			await Effect.runPromise(saveAgentState(parent));
+			return {
+				success: true,
+				message: `Convoy for ${normalized} run ${runId} already produced reviewer output — no-op`
+			};
+		}
+	} catch {}
+	parent.reviewDiscoveryPending = false;
+	parent.reviewDiscoveryReadyAt = (/* @__PURE__ */ new Date()).toISOString();
+	await Effect.runPromise(saveAgentState(parent));
+	const { inScope, carried, scope } = await computeConvoyScope(normalized, workspace);
+	const results = await launchConvoyReviewersPromise({
+		issueId: normalized,
+		workspace,
+		runId,
+		synthesisAgentId: parentId,
+		inScope,
+		carried,
+		scope,
+		contextManifestPath: parent.reviewContextManifestPath,
+		allowHost: parent.hostOverride ?? false,
+		forkFromParent: true
+	});
+	const refreshed = getAgentStateSync(parentId);
+	if (refreshed) {
+		refreshed.reviewConvoyForkedAt = (/* @__PURE__ */ new Date()).toISOString();
+		await Effect.runPromise(saveAgentState(refreshed));
+	}
+	const launched = results.filter((r) => r.success).length;
+	const message = `Discovery-ready for ${normalized}${opts.source ? ` (${opts.source})` : ""}: launched ${launched}/${inScope.length} convoy reviewer(s)${carried.length ? `, carried [${carried.map((c) => c.subRole).join(", ")}]` : ""}`;
+	console.log(`[review-agent] ${message}`);
+	emitActivityEntrySync({
+		source: "review",
+		level: "info",
+		message,
+		issueId: normalized
+	});
+	return {
+		success: launched > 0 || inScope.length === 0,
+		message,
+		launched
+	};
+}
+/** PAN-1862 (FR-7): resolved re-review scope — merged config, default 'changed'. */
+function resolveReReviewScope(issueId) {
+	if (issueId) try {
+		const project = resolveProjectForIssue(issueId);
+		const issueScope = project ? readIssueRecordSync(project, issueId)?.reReviewScope : void 0;
+		if (issueScope === "all" || issueScope === "changed" || issueScope === "blockers") return issueScope;
+	} catch {}
+	const scope = loadConfigSync().config.roles?.review?.reReviewScope;
+	return scope === "all" || scope === "blockers" ? scope : "changed";
+}
+var execAsync$1, REVIEWER_TIMEOUT_MS, buildConvoyPrompt, spawnReviewSubRoleForIssue;
+var init_review_convoy = __esmMin((() => {
+	init_tmux();
+	init_activity_logger();
+	init_config_yaml();
+	init_review_context();
+	init_review_monitor();
+	init_review_resume_decision();
+	init_review_rerun_scope();
+	init_record();
+	init_types();
+	init_paths();
+	execAsync$1 = promisify(exec);
+	REVIEWER_TIMEOUT_MS = 1200 * 1e3;
+	buildConvoyPrompt = (opts) => Effect.promise(() => buildConvoyPromptPromise(opts));
+	spawnReviewSubRoleForIssue = (opts) => Effect.promise(() => spawnReviewSubRoleForIssuePromise(opts));
+}));
+//#endregion
+//#region ../../lib/cloister/review-agent.ts
+/**
+* Review role entry point.
+*
+* PAN-1048 review feedback 007: every legacy convoy helper has been retired.
+* The bash/tmux coordinator path (dispatchParallelReview /
+* spawnReviewCoordinatorSession / runParallelReview) was deleted in R6, and
+* the round-7 cleanup additionally removed the supporting cast that the
+* coordinator used to drive — spawnSingleReviewer, waitForReviewer,
+* archiveReviewerRound, parseReviewSynthesis, parseAgentOutput,
+* selectCompletedReviewers, getReviewAgents, getFilesChangedFromPR,
+* buildReviewFeedbackBody, parseReviewerTemplate, resolvePromptTemplatePath
+* (and the resolveTemplatePath alias), resolveReviewerModel,
+* reviewResultToReviewStatus, reviewerRetryBackoffMs,
+* isRetryableReviewerFailure, the ReviewContext / ReviewResult /
+* ReviewerTemplate / ReviewerRoundArtifact / ReviewerOutcome /
+* ReviewerWaitResult / ReviewerFailureReason / ReviewHistoryEntry types,
+* and DEFAULT_REVIEW_AGENTS / REVIEW_TIMEOUT_MS / MAX_REVIEWER_TIMEOUT_RETRIES
+* / REVIEWER_TIMEOUT_RETRY_BACKOFF_MS / REVIEW_HISTORY_DIR / REVIEW_HISTORY_FILE
+* / SPECIALISTS_DIR constants. None of these had any production caller after R6;
+* their tests went with them.
+*
+* Every active review surface — POST /api/review/:issueId/trigger, the
+* reactive scheduler review branch, and the dashboard kanban "Review again"
+* button — flows through
+* spawnReviewRoleForIssue → spawnRun(issueId, 'review'). The review role
+* launches four isolated review sub-role sessions via `pan review spawn-reviewer`,
+* then writes the report and signals the verdict via Overdeck's CLI inside
+* the role itself (see roles/review.md).
+*
+* Surface area kept:
+*   - spawnReviewRoleForIssue       — the only review entry point
+*   - killAllReviewerSessions       — kill the canonical reviewer sessions
+*                                     for one issue (merge-agent +
+*                                     dashboard cancel/abort routes)
+*   - killAllReviewSessions         — kill ALL review sessions on shutdown
+*                                     (pan down)
+*/
+function buildReviewRolePrompt(opts) {
+	const inScope = opts.inScopeSubRoles && opts.inScopeSubRoles.length > 0 ? opts.inScopeSubRoles : [...REVIEW_SUB_ROLES];
+	const carried = opts.carriedSubRoles ?? [];
+	const subRoleFiles = REVIEW_SUB_ROLES.map((r) => `  ${join(opts.reviewDir, `${r}.md`)}`).join("\n");
+	const expectedSignals = inScope.map((r) => `  REVIEWER_READY ${r} <outputPath> or REVIEWER_FAILED ${r} <reason> or REVIEWER_TIMEOUT ${r} <reason>`).join("\n");
+	const synthesisPath = join(opts.reviewDir, "synthesis.md");
+	const runningDesc = inScope.length === REVIEW_SUB_ROLES.length ? "the four convoy reviewers (security, correctness, performance, requirements)" : `${inScope.length} convoy reviewer(s) this cycle (${inScope.join(", ")})`;
+	const carriedSection = carried.length > 0 ? [
+		"",
+		`CARRIED-FORWARD VERDICTS (PAN-1862 selective re-review): ${carried.map((c) => c.subRole).join(", ")}.`,
+		"These reviewers PASSED the prior cycle and none of their domain files changed",
+		"since, so they were NOT re-run. Their stub reports are already written in the",
+		"review directory — treat each as a passed verdict. Do NOT wait for signals",
+		"from them; they will never arrive."
+	].join("\n") : "";
+	const prompt = [
+		...opts.discovery ? [
+			`DISCOVERY + SYNTHESIS — REVIEW for ${opts.issueId}`,
+			"",
+			"PHASE 1 — SHARED DISCOVERY (do this FIRST):",
+			"Read the code the whole review convoy will need so it lives in THIS",
+			"session's history. WHY: after you signal readiness the server FORKS this",
+			"session into the convoy reviewers, and because the prompt cache is",
+			"content-addressed, everything you read here becomes a ~90%-discounted",
+			"cache read for every forked reviewer instead of four independent",
+			"full-price re-reads. Reviewers also review better when they all see the",
+			"same curated context and understand the change as a whole.",
+			"",
+			"1. Read the context manifest (path below): risk ranking + acceptance criteria.",
+			"2. Read the committed diff for the branch (git diff against the merge base).",
+			"3. Read the FULL contents of the HIGH-risk changed files and the immediately",
+			"   surrounding code they depend on. Stay within the manifest scope — this is",
+			"   curation for the convoy, not an open-ended crawl.",
+			"",
+			"Then signal readiness EXACTLY ONCE (repeat signals are a server-side no-op):",
+			`  pan admin specialists discovery-ready review ${opts.issueId}`,
+			"",
+			"PHASE 2 — STANDBY (after the signal):",
+			`The server forks this session into ${runningDesc}.`,
+			"Your work resumes only once they finish.",
+			""
+		] : [
+			`STANDBY — REVIEW SYNTHESIS for ${opts.issueId}`,
+			"",
+			`Do NOT do anything yet. The Overdeck server has already spawned ${runningDesc}`,
+			"and they are running in parallel right now. Your work begins only once they finish.",
+			""
+		],
+		`You will receive exactly one \`pan tell\` signal per RUNNING sub-role as each`,
+		"reviewer finishes — these are delivered to you as user messages:",
+		expectedSignals,
+		carriedSection,
+		"",
+		`Until all ${inScope.length} terminal signal(s) have arrived: do nothing. Do not read the`,
+		"reviewer output files, do not run git, do not inspect tmux sessions, do not",
+		"poll anything. Just wait — the reviewers notify you when they finish, and",
+		"Deacon is the failsafe if one never starts or never completes. Acting early",
+		"wastes tokens reviewing nothing.",
+		"",
+		`Once you have all ${inScope.length} terminal signal(s), follow roles/review.md exactly to`,
+		"read the reports (including any carried-forward stubs), synthesize the verdict,",
+		"write the synthesis report, and signal the status.",
+		"",
+		"── Review context ──",
+		`Issue: ${opts.issueId}`,
+		`Branch: ${opts.branch}`,
+		`Workspace: ${opts.workspace}`,
+		opts.prUrl ? `PR: ${opts.prUrl}` : `PR: (resolve via: gh pr view ${opts.branch})`,
+		`Run ID: ${opts.runId}`,
+		`Review directory: ${opts.reviewDir}`,
+		`Synthesis output file: ${synthesisPath}`,
+		"",
+		opts.tier1Summary ? [
+			"Shared review context:",
+			"─────────────────────────────────────────────────────────────",
+			opts.tier1Summary,
+			"─────────────────────────────────────────────────────────────",
+			"",
+			opts.contextManifestPath ? `Full manifest: ${opts.contextManifestPath}` : ""
+		].join("\n") : opts.contextManifestPath ? `Context manifest: ${opts.contextManifestPath}` : "Context manifest: (missing — block review per roles/review.md)",
+		"",
+		"Convoy reviewer output files (read each one ONLY after its REVIEWER_READY signal):",
+		subRoleFiles,
+		"",
+		"After writing the synthesis report, signal the verdict with Overdeck CLI,",
+		"including a per-reviewer verdict for each sub-role that RAN this cycle",
+		"(PAN-1862 — this is what lets the next re-review skip provably-clean reviewers;",
+		"do NOT list carried-forward sub-roles, their verdicts are already recorded):",
+		`  pan admin specialists done review ${opts.issueId} --status passed --notes "<one-line summary>" --reviewers "${inScope.map((r) => `${r}=passed`).join(",")}"`,
+		`  pan admin specialists done review ${opts.issueId} --status blocked --notes "<one-line top blocker>" --reviewers "<subRole>=passed|blocked for each of: ${inScope.join(", ")}>"`,
+		"",
+		"After running the signal command above, STOP and wait — do not exit, do not run",
+		"any further commands. The session stays open for the next review cycle.",
+		"",
+		"Reactive Cloister dispatches the test role after review passes. Never queue tests yourself and never edit code."
+	].filter(Boolean).join("\n");
+	const sizeBytes = Buffer.byteLength(prompt, "utf-8");
+	console.log(`[review-agent] Synthesis prompt for ${opts.issueId}: ${sizeBytes} bytes`);
+	return prompt;
+}
+function buildSelfReviewPrompt(opts) {
+	const reviewReportPath = join(opts.reviewDir, "review.md");
+	const prompt = [
+		`CODE REVIEW for ${opts.issueId} — you are the sole reviewer; review the change yourself.`,
+		"",
+		"Review the diff for this branch yourself, across ALL dimensions in one pass:",
+		"correctness/logic, security, requirements/acceptance-criteria, and performance.",
+		"Do NOT spawn or wait for any sub-reviewers — there is no convoy; you do the",
+		"whole review yourself and emit the verdict.",
+		"",
+		"── Review context ──",
+		`Issue: ${opts.issueId}`,
+		`Branch: ${opts.branch}`,
+		`Workspace: ${opts.workspace}`,
+		opts.prUrl ? `PR: ${opts.prUrl}` : `PR: (resolve via: gh pr view ${opts.branch})`,
+		`Run ID: ${opts.runId}`,
+		`Review directory: ${opts.reviewDir}`,
+		`Review output file: ${reviewReportPath}`,
+		"",
+		opts.tier1Summary ? [
+			"Shared review context (risk-ranked changed files + acceptance criteria):",
+			"─────────────────────────────────────────────────────────────",
+			opts.tier1Summary,
+			"─────────────────────────────────────────────────────────────",
+			"",
+			opts.contextManifestPath ? `Full manifest: ${opts.contextManifestPath}` : ""
+		].join("\n") : opts.contextManifestPath ? `Context manifest: ${opts.contextManifestPath}` : "Context manifest: (missing — inspect the diff directly: git diff origin/main...HEAD)",
+		"",
+		"How to review:",
+		"1. Read the diff — use the manifest risk ranking, `git diff` the high-risk files,",
+		"   and read the surrounding code as needed.",
+		"2. Evaluate correctness, security, requirements/AC, and performance. Use the",
+		"   severity + verdict vocabulary in roles/review.md.",
+		`3. Write your findings to ${reviewReportPath}.`,
+		"",
+		"Then signal the verdict with the Overdeck CLI (exactly one):",
+		`  pan admin specialists done review ${opts.issueId} --status passed --notes "<one-line summary>"`,
+		`  pan admin specialists done review ${opts.issueId} --status blocked --notes "<one-line top blocker>"`,
+		"",
+		"After running the signal command above, STOP and wait — do not exit, do not run",
+		"any further commands. The session stays open for the next review cycle.",
+		"",
+		"Reactive Cloister dispatches the test role after review passes. Never queue tests yourself and never edit code."
+	].filter(Boolean).join("\n");
+	const sizeBytes = Buffer.byteLength(prompt, "utf-8");
+	console.log(`[review-agent] Self-review prompt for ${opts.issueId}: ${sizeBytes} bytes`);
+	return prompt;
+}
 async function spawnReviewRoleForIssuePromise(opts) {
 	const reviewSessionName = `agent-${opts.issueId.toLowerCase()}-review`;
 	const mergedGuard = await shouldSkipDispatchAsMerged(opts.issueId);
@@ -356,6 +711,25 @@ async function spawnReviewRoleForIssuePromise(opts) {
 			message
 		};
 	}
+	if (resolveReviewMode(opts.issueId) === "none") {
+		setReviewStatusSync(opts.issueId, {
+			reviewStatus: "skipped",
+			reviewNotes: "Review mode: none — AI review skipped by configuration; verification gate still enforced",
+			reviewSpawnedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		const message = `Review skipped for ${opts.issueId} (mode=none) — advancing to test`;
+		console.log(`[review-agent] ${message}`);
+		emitActivityEntrySync({
+			source: "review",
+			level: "info",
+			message,
+			issueId: opts.issueId
+		});
+		return {
+			success: true,
+			message
+		};
+	}
 	try {
 		if ((await Effect.runPromise(listSessionNames())).includes(reviewSessionName)) {
 			const paneDead = await Effect.runPromise(isPaneDead(reviewSessionName));
@@ -375,14 +749,25 @@ async function spawnReviewRoleForIssuePromise(opts) {
 			} catch (probeErr) {
 				console.warn(`[review-agent] Could not probe ${reviewSessionName} runId, falling back to pane-alive idempotency:`, probeErr);
 			}
-			if (!paneDead && !opts.force && !staleRunId) {
+			let finishedIdle = false;
+			if (!paneDead && !opts.force && !staleRunId) try {
+				const status = getReviewStatusSync(opts.issueId);
+				const terminal = status?.reviewStatus === "passed" || status?.reviewStatus === "blocked" || status?.reviewStatus === "failed";
+				const newerRequest = !!status?.reviewRequestedAt && (!status.reviewSpawnedAt || status.reviewRequestedAt > status.reviewSpawnedAt);
+				finishedIdle = terminal && newerRequest;
+				if (finishedIdle) console.log(`[review-agent] ${reviewSessionName} is finished-idle (verdict ${status?.reviewStatus}, newer request pending) — warm-reusing for the new review cycle`);
+				else if (terminal) console.log(`[review-agent] ${reviewSessionName} has a terminal verdict (${status?.reviewStatus}) and no newer request — treating this dispatch as a stale duplicate; leaving the verdict intact`);
+			} catch (statusErr) {
+				console.warn(`[review-agent] Could not probe review status for finished-idle check on ${opts.issueId}:`, statusErr);
+			}
+			if (!paneDead && !opts.force && !staleRunId && !finishedIdle) {
 				console.log(`[review-agent] Idempotency guard: ${reviewSessionName} already running for ${opts.issueId} — skipping spawn`);
 				return {
 					success: true,
 					message: `Review already in progress: ${reviewSessionName}`
 				};
 			}
-			const reason = opts.force ? "force-killed for re-review" : paneDead ? "pane is dead" : "stale runId";
+			const reason = opts.force ? "force-killed for re-review" : paneDead ? "pane is dead" : staleRunId ? "stale runId" : "finished-idle (warm reuse for new cycle)";
 			console.log(`[review-agent] ${reviewSessionName} ${reason} — respawning convoy`);
 			await Effect.runPromise(killAllReviewerSessions(void 0, opts.issueId).pipe(Effect.catch(() => Effect.succeed({
 				killed: [],
@@ -420,7 +805,7 @@ async function spawnReviewRoleForIssuePromise(opts) {
 		};
 	}
 	try {
-		const { archiveFeedbackFiles } = await import("./feedback-writer-BvHE1I-3.js");
+		const { archiveFeedbackFiles } = await import("./feedback-writer-thrdxYpK.js");
 		await Effect.runPromise(archiveFeedbackFiles(opts.workspace));
 	} catch {}
 	try {
@@ -437,7 +822,7 @@ async function spawnReviewRoleForIssuePromise(opts) {
 		};
 	}
 	try {
-		const { notifyPipelineSync } = await import("./pipeline-notifier-DQsOtdjZ.js");
+		const { notifyPipelineSync } = await import("./pipeline-notifier-lwMa--Gz.js");
 		notifyPipelineSync({
 			type: "task_queued",
 			specialist: "review-agent",
@@ -445,7 +830,7 @@ async function spawnReviewRoleForIssuePromise(opts) {
 		});
 	} catch {}
 	try {
-		const { spawnRun, saveAgentState, getAgentState, getAgentStateSync, getLatestSessionIdSync, resumeAgent, wipeAgentStateDirs } = await import("./agents-KaEsWZ8D.js");
+		const { spawnRun, saveAgentState, getAgentState, getAgentStateSync, getLatestSessionIdSync, resumeAgent, wipeAgentStateDirs } = await import("./agents-BIggLvi_.js");
 		const workAgentState = await Effect.runPromise(getAgentState(`agent-${opts.issueId.toLowerCase()}`));
 		const allowHost = opts.allowHost === true || workAgentState?.hostOverride === true;
 		let headSha = "unknown";
@@ -475,12 +860,23 @@ async function spawnReviewRoleForIssuePromise(opts) {
 			console.warn(`[review-agent] Context manifest build failed for ${opts.issueId} — reviewers will block on missing shared context:`, ctxErr);
 		}
 		const fullReview = isExtendedReviewEnabled(opts.issueId);
+		const { inScope: inScopeSubRoles, carried: carriedSubRoles, scope: reReviewScope } = fullReview ? await computeConvoyScope(opts.issueId, opts.workspace) : {
+			inScope: [...REVIEW_SUB_ROLES],
+			carried: [],
+			scope: "changed"
+		};
+		const cfgReviewHarness = loadConfigSync().config.roles?.review?.harness;
+		const savedReviewHarness = getAgentStateSync(`agent-${opts.issueId.toLowerCase()}-review`)?.harness;
+		const discoveryForkMode = fullReview && (opts.harness ?? savedReviewHarness ?? cfgReviewHarness ?? "claude-code") === "claude-code";
 		const prompt = fullReview ? buildReviewRolePrompt({
 			...opts,
 			runId,
 			reviewDir,
 			contextManifestPath,
-			tier1Summary
+			tier1Summary,
+			inScopeSubRoles,
+			carriedSubRoles,
+			discovery: discoveryForkMode
 		}) : buildSelfReviewPrompt({
 			...opts,
 			runId,
@@ -488,32 +884,40 @@ async function spawnReviewRoleForIssuePromise(opts) {
 			contextManifestPath,
 			tier1Summary
 		});
-		const spawnConvoyReviewers = async (synthesisAgentId) => {
-			const reviewerResults = await Promise.all(REVIEW_SUB_ROLES.map(async (subRole) => {
-				const outputPath = reviewerAgentOutputPath(opts.workspace, runId, subRole);
-				const result = await Effect.runPromise(spawnReviewSubRoleForIssue({
-					issueId: opts.issueId,
-					workspace: opts.workspace,
-					subRole,
-					runId,
-					outputPath,
-					contextManifestPath,
-					synthesisAgentId,
-					...opts.model ? { model: opts.model } : {},
-					...opts.harness ? { harness: opts.harness } : {},
-					allowHost
-				}));
-				if (!result.success) try {
-					const { messageAgent } = await import("./agents-KaEsWZ8D.js");
-					await messageAgent(synthesisAgentId, `REVIEWER_FAILED ${subRole} ${result.error ?? result.message}`);
-				} catch (signalErr) {
-					console.warn(`[review-agent] Failed to signal ${subRole} spawn failure to ${synthesisAgentId}:`, signalErr);
+		const markDiscoveryPending = async (synthesisAgentId) => {
+			try {
+				const parent = getAgentStateSync(synthesisAgentId);
+				if (parent) {
+					parent.reviewDiscoveryPending = true;
+					parent.reviewContextManifestPath = contextManifestPath;
+					parent.reviewDiscoveryReadyAt = void 0;
+					parent.reviewConvoyForkedAt = void 0;
+					parent.reviewForkCacheChecked = void 0;
+					await Effect.runPromise(saveAgentState(parent));
 				}
-				return result;
-			}));
-			const failedReviewers = reviewerResults.filter((r) => !r.success);
-			if (failedReviewers.length > 0) console.warn(`[review-agent] Review role spawned for ${opts.issueId}, but ${failedReviewers.length} reviewer(s) failed to spawn`);
-			return reviewerResults;
+			} catch (stateErr) {
+				console.warn(`[review-agent] Could not mark discovery pending on ${synthesisAgentId}:`, stateErr);
+			}
+		};
+		const spawnConvoyReviewers = async (synthesisAgentId) => {
+			if (discoveryForkMode) {
+				await markDiscoveryPending(synthesisAgentId);
+				console.log(`[review-agent] ${opts.issueId}: parent spawned in discovery mode — convoy defers to the discovery-ready signal (PAN-1862)`);
+				return [];
+			}
+			return launchConvoyReviewersPromise({
+				issueId: opts.issueId,
+				workspace: opts.workspace,
+				runId,
+				synthesisAgentId,
+				inScope: inScopeSubRoles,
+				carried: carriedSubRoles,
+				scope: reReviewScope,
+				contextManifestPath,
+				...opts.model ? { model: opts.model } : {},
+				...opts.harness ? { harness: opts.harness } : {},
+				allowHost
+			});
 		};
 		const reviewAgentId = `agent-${opts.issueId.toLowerCase()}-review`;
 		const savedReview = getAgentStateSync(reviewAgentId);
@@ -715,9 +1119,10 @@ function resolveReviewMode(issueId) {
 	if (issueId) {
 		const project = resolveProjectForIssue(issueId);
 		const issueMode = project ? readIssueRecordSync(project, issueId)?.reviewMode : void 0;
-		if (issueMode === "quick" || issueMode === "full") return issueMode;
+		if (issueMode === "quick" || issueMode === "full" || issueMode === "none") return issueMode;
 	}
-	return loadConfigSync().config.roles?.review?.mode === "full" ? "full" : "quick";
+	const configMode = loadConfigSync().config.roles?.review?.mode;
+	return configMode === "full" || configMode === "none" ? configMode : "quick";
 }
 /**
 * Is EXTENDED (convoy) review enabled for this issue?
@@ -747,7 +1152,7 @@ async function purgeReviewAgentsForIssue(projectKey, issueId) {
 		removed
 	};
 }
-var execAsync, REVIEWER_TIMEOUT_MS, buildConvoyPrompt, spawnReviewSubRoleForIssue, spawnReviewRoleForIssue, killAllReviewerSessions, killAllReviewSessions;
+var execAsync, spawnReviewRoleForIssue, killAllReviewerSessions, killAllReviewSessions;
 var init_review_agent = __esmMin((() => {
 	init_tmux();
 	init_activity_logger();
@@ -758,20 +1163,17 @@ var init_review_agent = __esmMin((() => {
 	init_conflict_gate();
 	init_review_monitor();
 	init_review_resume_decision();
+	init_review_convoy();
 	init_merge_verification();
 	init_record();
 	init_types();
-	init_paths();
 	init_agents$1();
 	execAsync = promisify(exec);
-	REVIEWER_TIMEOUT_MS = 1200 * 1e3;
-	buildConvoyPrompt = (opts) => Effect.promise(() => buildConvoyPromptPromise(opts));
-	spawnReviewSubRoleForIssue = (opts) => Effect.promise(() => spawnReviewSubRoleForIssuePromise(opts));
 	spawnReviewRoleForIssue = (opts) => Effect.promise(() => spawnReviewRoleForIssuePromise(opts));
 	killAllReviewerSessions = (projectKey, issueId) => Effect.promise(() => killAllReviewerSessionsPromise(projectKey, issueId));
 	killAllReviewSessions = () => Effect.promise(() => killAllReviewSessionsPromise());
 }));
 //#endregion
-export { isReviewStaleSync as a, purgeReviewAgentsForIssue as c, spawnReviewSubRoleForIssue as d, reviewResumeDecision as f, isReviewSessionForIssue as i, resolveReviewMode as l, init_review_agent as n, killAllReviewSessions as o, isExtendedReviewEnabled as r, killAllReviewerSessions as s, buildConvoyPrompt as t, spawnReviewRoleForIssue as u };
+export { killAllReviewSessions as a, resolveReviewMode as c, handleReviewDiscoveryReady as d, resolveReReviewScope as f, isReviewStaleSync as i, spawnReviewRoleForIssue as l, reviewResumeDecision as m, isExtendedReviewEnabled as n, killAllReviewerSessions as o, spawnReviewSubRoleForIssue as p, isReviewSessionForIssue as r, purgeReviewAgentsForIssue as s, init_review_agent as t, buildConvoyPrompt as u };
 
-//# sourceMappingURL=review-agent-C-A6IgXc.js.map
+//# sourceMappingURL=review-agent-phzqNqIs.js.map