ultimate-pi 0.23.0 → 0.25.0

package/.pi/lib/harness-subagents-bridge.ts

@@ -20,6 +20,11 @@ import {
 } from "./agt/delegation.js";
 import { spawnCircuitOpen } from "./agt/sre-hooks.js";
 import { refreshHarnessCocoindexIndex } from "./harness-cocoindex-refresh.js";
+import {
+	incrementHarnessPhaseSubagentCount,
+	recordHarnessPhaseStart,
+} from "./harness-phase-telemetry.js";
+import { isHarnessPhaseWorkerEnabled } from "./harness-phase-worker.js";
 import { captureHarnessEvent } from "./harness-posthog.js";
 import {
 	getLatestRunContext,
@@ -34,6 +39,7 @@ import {
 	recordSpawnStart,
 } from "./harness-spawn-budget.js";
 import { parseSpawnContextFromTask } from "./harness-spawn-parse.js";
+import { recordDuplicateSpawnBlock } from "./harness-spawn-stall-detector.js";
 import {
 	isUsableApiKey,
 	resolveConcreteSubagentModel,
@@ -42,6 +48,13 @@ import {
 	inferPhaseForPrecheck,
 	precheckHarnessSubagentSpawn,
 } from "./harness-subagent-precheck.js";
+import {
+	clearHarnessSubagentProgress,
+	setHarnessSubagentProgress,
+	startHarnessSubagentHeartbeat,
+	stopHarnessSubagentHeartbeat,
+} from "./harness-subagent-progress.js";
+import { resolveHarnessSubagentTimeoutForAgents } from "./harness-subagent-timeout.js";
 import {
 	getRememberedSessionWebArtifactDir,
 	resolveWebArtifactScope,
@@ -59,6 +72,8 @@ type PendingSpawnTelemetry = {
 	spawn_group_id: string;
 };
 let pendingSpawnTelemetry: PendingSpawnTelemetry | null = null;
+let bridgePi: ExtensionAPI | null = null;
+let executeIndexRefreshPending = true;
 
 function subagentGovernanceExtensionPath(packageRoot: string): string {
 	return join(packageRoot, ".pi", "extensions", "subagent-governance.ts");
@@ -139,6 +154,9 @@ export function createHarnessSubagentsExtension(
 				HARNESS_PKG_ROOT: packageRoot,
 				HARNESS_PROJECT_ROOT: projectRoot,
 			};
+			if (isHarnessPhaseWorkerEnabled()) {
+				base.HARNESS_PHASE_WORKER = "1";
+			}
 			if (agent.name.startsWith("harness/web-retrieval/")) {
 				const ctx = parseSpawnContextFromTask(task);
 				const remembered = getRememberedSessionWebArtifactDir(lastSessionId);
@@ -195,6 +213,12 @@ export function createHarnessSubagentsExtension(
 		defaultConfirmProjectAgents: false,
 		truncateDetails: true,
 		resolveSpawnAuth: resolveHarnessSpawnAuth,
+		resolveDefaultTimeoutMs: (params, _agents, ctx) => {
+			const agentIds = collectHarnessAgentIds(params);
+			if (agentIds.length === 0) return undefined;
+			const phase = inferPhaseForPrecheck(ctx.sessionManager.getEntries());
+			return resolveHarnessSubagentTimeoutForAgents(phase, agentIds);
+		},
 		beforeExecute: async (params, agents, ctx) => {
 			lastSessionId = ctx.sessionManager.getSessionId();
 			const { harnessCount } = countHarnessAgentsInRequest(
@@ -202,13 +226,17 @@ export function createHarnessSubagentsExtension(
 			);
 			pendingSpawnTelemetry = null;
 			if (harnessCount > 0) {
-				const budget = checkHarnessSpawnBudget(spawnBudget, harnessCount);
+				const entries = ctx.sessionManager.getEntries();
+				const phase = inferPhaseForPrecheck(entries);
+				const budget = checkHarnessSpawnBudget(
+					spawnBudget,
+					harnessCount,
+					phase,
+				);
 				if (!budget.ok) {
 					return { ok: false, message: budget.message };
 				}
-				const entries = ctx.sessionManager.getEntries();
 				const runCtx = getLatestRunContext(entries);
-				const phase = inferPhaseForPrecheck(entries);
 				const pre = await precheckHarnessSubagentSpawn(
 					params as Parameters<typeof precheckHarnessSubagentSpawn>[0],
 					agents,
@@ -222,10 +250,26 @@ export function createHarnessSubagentsExtension(
 					},
 				);
 				if (!pre.ok) {
+					if (pre.message?.includes("Duplicate spawn blocked")) {
+						await recordDuplicateSpawnBlock({
+							message: pre.message,
+							projectRoot: ctx.cwd,
+							runId: runCtx?.run_id ?? null,
+							phase,
+							sessionId: lastSessionId,
+						});
+					}
 					return { ok: false, message: pre.message };
 				}
 				if (phase === "plan" || phase === "execute") {
-					const refreshMsg = refreshHarnessCocoindexIndex(ctx.cwd);
+					const forceExecuteRefresh =
+						phase === "execute" && executeIndexRefreshPending;
+					if (forceExecuteRefresh) {
+						executeIndexRefreshPending = false;
+					}
+					const refreshMsg = refreshHarnessCocoindexIndex(ctx.cwd, {
+						forceExecuteRefresh,
+					});
 					if (refreshMsg?.includes("continuing")) {
 						// warn-only path; do not block spawn
 					} else if (refreshMsg) {
@@ -250,6 +294,25 @@ export function createHarnessSubagentsExtension(
 		onSpawnStart: (harnessCount) => {
 			if (harnessCount <= 0) return;
 			recordSpawnStart(spawnBudget, harnessCount);
+			const phase = pendingSpawnTelemetry?.harness_phase ?? "plan";
+			const runId = pendingSpawnTelemetry?.run_id ?? lastSessionId;
+			const agentIds = pendingSpawnTelemetry?.agent_ids ?? [];
+			recordHarnessPhaseStart(runId, phase);
+			incrementHarnessPhaseSubagentCount(runId, phase, harnessCount);
+			setHarnessSubagentProgress({
+				agentIds,
+				phase,
+			});
+			captureHarnessEvent(lastSessionId, "harness_subagent_setup", {
+				harness_run_id: runId,
+				run_id: runId,
+				harness_phase: phase,
+				agent_ids: agentIds,
+				agent_count: agentIds.length,
+			});
+			startHarnessSubagentHeartbeat(() => {
+				bridgePi?.events.emit("harness-progress:updated", {});
+			});
 			captureHarnessEvent(lastSessionId, "harness_subagent_spawned", {
 				active_after: spawnBudget.active,
 				spawn_count: harnessCount,
@@ -269,27 +332,50 @@ export function createHarnessSubagentsExtension(
 			if (harnessCount <= 0) return;
 			recordSpawnEnd(spawnBudget, harnessCount);
 		},
-		onCompleted: ({ agents, mode, durationMs }) => {
+		onCompleted: ({ agents, mode, durationMs, timedOut, stop_reason }) => {
+			stopHarnessSubagentHeartbeat();
+			clearHarnessSubagentProgress();
+			bridgePi?.events.emit("harness-progress:updated", {});
+
 			if (agents.length === 0) return;
-			captureHarnessEvent(lastSessionId, "harness_subagent_completed", {
+			const runId = pendingSpawnTelemetry?.run_id ?? lastSessionId;
+			const phase = pendingSpawnTelemetry?.harness_phase ?? "plan";
+			const base = {
 				mode,
 				duration_ms: durationMs,
 				agent_count: agents.length,
 				agent_ids: agents,
 				harness_run_id: pendingSpawnTelemetry?.harness_run_id ?? lastSessionId,
-				run_id: pendingSpawnTelemetry?.run_id ?? lastSessionId,
+				run_id: runId,
 				harness_plan_id:
 					pendingSpawnTelemetry?.harness_plan_id ?? "plan-unknown",
-				harness_phase: pendingSpawnTelemetry?.harness_phase ?? "plan",
+				harness_phase: phase,
 				spawn_group_id:
 					pendingSpawnTelemetry?.spawn_group_id ??
 					nextSpawnGroupId(lastSessionId),
+				stop_reason: stop_reason ?? (timedOut ? "timeout" : "complete"),
+			};
+			captureHarnessEvent(lastSessionId, "harness_subagent_result_wait", {
+				...base,
+				wait_ms: durationMs,
 			});
+			if (timedOut) {
+				captureHarnessEvent(lastSessionId, "harness_subagent_timeout", {
+					...base,
+					incomplete_artifact_paths: agents.map((a) => `subagent:${a}:timeout`),
+					escalation: "human_required",
+				});
+			}
+			captureHarnessEvent(lastSessionId, "harness_subagent_completed", base);
 			pendingSpawnTelemetry = null;
 		},
 	};
 
 	return (pi: ExtensionAPI) => {
+		bridgePi = pi;
 		createSubagentsExtension(pi, options);
+		pi.events.on("harness-run-context:updated", () => {
+			executeIndexRefreshPending = true;
+		});
 	};
 }

package/.pi/lib/harness-ui-state.ts

@@ -5,6 +5,7 @@ import {
 	getLatestRunContext,
 	nextStepAfterOutcome,
 } from "./harness-run-context.js";
+import { buildHarnessProgressStatusLine } from "./harness-subagent-progress.js";
 
 export type HarnessPhase =
 	| "plan"
@@ -486,6 +487,10 @@ export function deriveHarnessStatusHint(state: HarnessUiState): {
 	if (state.policyDecision === "block") {
 		return { text: "Blocked — fix issues first", severity: "error" };
 	}
+	const progressLine = buildHarnessProgressStatusLine();
+	if (progressLine) {
+		return { text: progressLine, severity: "accent" };
+	}
 	if (
 		state.policyDecision === "human_required" ||
 		state.flowSubstate === "human-required"

package/.pi/lib/harness-vcc-settings.ts

@@ -10,6 +10,14 @@ export interface PiVccSettings {
 	overrideDefaultCompaction: boolean;
 	/** Write debug snapshot to /tmp/pi-vcc-debug.json on each compaction. */
 	debug: boolean;
+	/** Compact when context usage ≥ this percent (harness auto-compact extension). */
+	compactThresholdPercent: number;
+	/** Hysteresis: re-arm after usage falls below this percent. */
+	compactRearmPercent: number;
+	/** Enable harness 50% auto-compact gate. */
+	compactAuto: boolean;
+	/** Allow auto-compact in subagent subprocesses (default false). */
+	compactSubagents: boolean;
 }
 
 const FALSE_VALUES = new Set(["false", "0", "off", "no"]);
@@ -39,10 +47,38 @@ export function resolveVccDebug(): boolean {
 	return parseHarnessBool("HARNESS_VCC_DEBUG", false);
 }
 
+function parseHarnessPercent(envName: string, defaultValue: number): number {
+	const raw = process.env[envName]?.trim();
+	if (!raw) return defaultValue;
+	const n = Number.parseInt(raw, 10);
+	if (!Number.isFinite(n) || n < 1 || n > 99) return defaultValue;
+	return n;
+}
+
+export function resolveCompactThresholdPercent(): number {
+	return parseHarnessPercent("HARNESS_COMPACT_THRESHOLD_PERCENT", 50);
+}
+
+export function resolveCompactRearmPercent(): number {
+	return parseHarnessPercent("HARNESS_COMPACT_REARM_PERCENT", 40);
+}
+
+export function resolveCompactAuto(): boolean {
+	return parseHarnessBool("HARNESS_COMPACT_AUTO", true);
+}
+
+export function resolveCompactSubagents(): boolean {
+	return parseHarnessBool("HARNESS_COMPACT_SUBAGENTS", false);
+}
+
 export function loadSettings(): PiVccSettings {
 	return {
 		overrideDefaultCompaction: resolveOverrideDefaultCompaction(),
 		debug: resolveVccDebug(),
+		compactThresholdPercent: resolveCompactThresholdPercent(),
+		compactRearmPercent: resolveCompactRearmPercent(),
+		compactAuto: resolveCompactAuto(),
+		compactSubagents: resolveCompactSubagents(),
 	};
 }
 

package/.pi/lib/plan-approval-readiness.ts

@@ -6,6 +6,7 @@ import { constants } from "node:fs";
 import { access, readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { parse as parseYaml } from "yaml";
+import { synthesizerArtifactsComplete } from "./harness-plan-route.js";
 import {
 	isTaskClarificationReady,
 	TASK_CLARIFICATION_ARTIFACT,
@@ -213,11 +214,14 @@ export async function validatePlanApprovalReadiness(
 		}
 	}
 
-	if (!(await fileExists(join(runDir, "artifacts/decomposition.yaml")))) {
-		errors.push("missing artifacts/decomposition.yaml");
-	}
-	if (!(await fileExists(join(runDir, "artifacts/hypothesis.yaml")))) {
-		errors.push("missing artifacts/hypothesis.yaml");
+	const synthComplete = await synthesizerArtifactsComplete(runDir);
+	if (!synthComplete) {
+		if (!(await fileExists(join(runDir, "artifacts/decomposition.yaml")))) {
+			errors.push("missing artifacts/decomposition.yaml");
+		}
+		if (!(await fileExists(join(runDir, "artifacts/hypothesis.yaml")))) {
+			errors.push("missing artifacts/hypothesis.yaml");
+		}
 	}
 
 	return { ok: errors.length === 0, errors, warnings };

package/.pi/lib/plan-debate-eligibility-snapshot.ts

@@ -0,0 +1,90 @@
+/**
+ * Persisted plan-debate eligibility snapshot for gate pass-through.
+ */
+
+import { constants } from "node:fs";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import type { DebateEligibilityResult } from "./plan-debate-eligibility.js";
+
+export const PLAN_DEBATE_ELIGIBILITY_ARTIFACT =
+	"artifacts/plan-debate-eligibility.yaml";
+
+async function fileExists(path: string): Promise<boolean> {
+	try {
+		await access(path, constants.R_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export async function writePlanDebateEligibilitySnapshot(
+	runDir: string,
+	result: DebateEligibilityResult,
+): Promise<string> {
+	const rel = PLAN_DEBATE_ELIGIBILITY_ARTIFACT;
+	const abs = join(runDir, rel);
+	await mkdir(dirname(abs), { recursive: true });
+	const doc = {
+		schema_version: "1.0.0",
+		captured_at: new Date().toISOString(),
+		profile: result.profile,
+		required_focuses: result.required_focuses,
+		min_focus_rounds: result.review_gate_strategy.min_focus_rounds,
+		max_rounds: result.max_rounds,
+		max_exchanges_per_round: result.max_exchanges_per_round,
+		round_token_cap: result.round_token_cap,
+		debate_global_cap: result.debate_global_cap,
+		human_required: result.human_required,
+		rationale: result.rationale,
+		review_gate_strategy: result.review_gate_strategy,
+	};
+	await writeFile(abs, stringifyYaml(doc), "utf-8");
+	return rel;
+}
+
+export async function loadPlanDebateEligibilitySnapshot(
+	runDir: string,
+): Promise<DebateEligibilityResult | null> {
+	const abs = join(runDir, PLAN_DEBATE_ELIGIBILITY_ARTIFACT);
+	if (!(await fileExists(abs))) return null;
+	try {
+		const raw = await readFile(abs, "utf-8");
+		const doc = parseYaml(raw) as Record<string, unknown>;
+		if (!doc || typeof doc !== "object") return null;
+		const strategy = doc.review_gate_strategy as
+			| DebateEligibilityResult["review_gate_strategy"]
+			| undefined;
+		if (!strategy?.mode) return null;
+		return {
+			profile: String(
+				doc.profile ?? strategy.profile ?? "standard",
+			) as DebateEligibilityResult["profile"],
+			required_focuses: (doc.required_focuses ??
+				strategy.required_focuses ??
+				[]) as DebateEligibilityResult["required_focuses"],
+			min_focus_rounds: Number(
+				doc.min_focus_rounds ?? strategy.min_focus_rounds ?? 1,
+			),
+			max_rounds: Number(doc.max_rounds ?? strategy.max_rounds ?? 12),
+			max_exchanges_per_round: Number(
+				doc.max_exchanges_per_round ?? strategy.max_exchanges_per_round ?? 3,
+			),
+			round_token_cap: Number(
+				doc.round_token_cap ?? strategy.round_token_cap ?? 8000,
+			),
+			debate_global_cap: Number(
+				doc.debate_global_cap ?? strategy.debate_global_cap ?? 80000,
+			),
+			human_required: doc.human_required === true,
+			rationale: Array.isArray(doc.rationale)
+				? doc.rationale.map((r) => String(r))
+				: [],
+			review_gate_strategy: strategy,
+		};
+	} catch {
+		return null;
+	}
+}

package/.pi/lib/plan-debate-eligibility.ts

@@ -218,11 +218,13 @@ export function harnessPlanDebateEligibility(
 		!dagPatched &&
 		input.dag_pass !== false &&
 		openQs.length === 0 &&
-		stackHasClearPrimary(stack)
+		stackHasClearPrimary(stack) &&
+		impl != null &&
+		stack != null
 	) {
 		profile = "fast";
 		rationale.push(
-			"fast: medium risk with clear stack and no open questions; use consolidated review with escalation on blockers",
+			"fast: medium risk with Phase 3.5 research artifacts, clear stack, and no open questions",
 		);
 	} else if (
 		risk === "low" &&
@@ -247,6 +249,16 @@ export function harnessPlanDebateEligibility(
 			: [...PLAN_FOCUS_AREAS];
 
 	const caps = capsForProfile(profile);
+	const reviewMode =
+		profile === "fast"
+			? ("consolidated" as const)
+			: profile === "standard"
+				? ("parallel_probes" as const)
+				: ("threaded" as const);
+	const minFocusForStrategy =
+		reviewMode === "parallel_probes" || reviewMode === "consolidated"
+			? 1
+			: caps.min_focus_rounds;
 
 	return {
 		profile,
@@ -255,15 +267,10 @@ export function harnessPlanDebateEligibility(
 		human_required,
 		rationale,
 		review_gate_strategy: {
-			mode:
-				profile === "fast"
-					? "consolidated"
-					: profile === "standard"
-						? "parallel_probes"
-						: "threaded",
+			mode: reviewMode,
 			profile,
 			required_focuses: [...required_focuses],
-			min_focus_rounds: caps.min_focus_rounds,
+			min_focus_rounds: minFocusForStrategy,
 			max_rounds: caps.max_rounds,
 			max_exchanges_per_round: caps.max_exchanges_per_round,
 			round_token_cap: caps.round_token_cap,

package/.pi/lib/plan-debate-focus.ts

@@ -65,7 +65,7 @@ export async function getPlanFocusCoverage(
 	let files: string[] = [];
 	try {
 		files = (await readdir(artifactsDir)).filter((f) =>
-			/^review-round(?:-r\d+|-consolidated)\.yaml$/i.test(f),
+			/^review-round(?:-r\d+|-consolidated|-parallel-probes)\.yaml$/i.test(f),
 		);
 	} catch {
 		return {
@@ -80,11 +80,14 @@ export async function getPlanFocusCoverage(
 
 	for (const name of files.sort()) {
 		const consolidated = /^review-round-consolidated\.yaml$/i.test(name);
+		const parallelProbes = /^review-round-parallel-probes\.yaml$/i.test(name);
 		const m = consolidated
 			? ["review-round-consolidated.yaml", "1"]
-			: /^review-round-r(\d+)\.yaml$/i.exec(name);
+			: parallelProbes
+				? ["review-round-parallel-probes.yaml", "1"]
+				: /^review-round-r(\d+)\.yaml$/i.exec(name);
 		if (!m) continue;
-		const roundIndex = consolidated ? 1 : Number(m[1]);
+		const roundIndex = consolidated || parallelProbes ? 1 : Number(m[1]);
 		if (roundIndex > last_round_index) last_round_index = roundIndex;
 		const raw = await readFile(join(artifactsDir, name), "utf-8");
 		let draft: Record<string, unknown>;
@@ -151,13 +154,22 @@ export async function readDebateRoundFocus(
 	runDir: string,
 	roundIndex: number,
 ): Promise<PlanDebateRoundFocus | null> {
-	const path = join(runDir, "artifacts", `review-round-r${roundIndex}.yaml`);
-	if (!(await fileExists(path))) return null;
-	try {
-		const raw = await readFile(path, "utf-8");
-		const draft = parseYaml(raw) as Record<string, unknown>;
-		return focusFromDraft(draft);
-	} catch {
-		return null;
+	const candidates =
+		roundIndex === 1
+			? [
+					"review-round-parallel-probes.yaml",
+					"review-round-consolidated.yaml",
+					`review-round-r${roundIndex}.yaml`,
+				]
+			: [`review-round-r${roundIndex}.yaml`];
+	for (const name of candidates) {
+		const path = join(runDir, "artifacts", name);
+		if (!(await fileExists(path))) continue;
+		try {
+			const raw = await readFile(path, "utf-8");
+			const draft = parseYaml(raw) as Record<string, unknown>;
+			return focusFromDraft(draft);
+		} catch {}
 	}
+	return null;
 }

package/.pi/lib/plan-debate-gate.ts

@@ -5,9 +5,14 @@
 import { constants } from "node:fs";
 import { access, readFile } from "node:fs/promises";
 import { join } from "node:path";
+import { isHarnessNonInteractive } from "./ask-user/policy.js";
 import { capsForDebate } from "./debate-bus-core.js";
 import { isHarnessBudgetEnforceOn } from "./harness-budget-enforce.js";
-import type { DebateEligibilityResult } from "./plan-debate-eligibility.js";
+import type {
+	DebateEligibilityResult,
+	DebateProfile,
+} from "./plan-debate-eligibility.js";
+import { loadPlanDebateEligibilitySnapshot } from "./plan-debate-eligibility-snapshot.js";
 import {
 	getPlanFocusCoverage,
 	type PlanDebateFocus,
@@ -20,6 +25,10 @@ import {
 	laneArtifactPathsForRound,
 } from "./plan-debate-lanes.js";
 import { getPlanDebateRoundStatus } from "./plan-debate-round-status.js";
+import {
+	checkDebateWallClock,
+	debateWallClockRecoveryHint,
+} from "./plan-debate-wall-clock.js";
 import {
 	getMessengerRoundState,
 	loadMessengerState,
@@ -27,9 +36,12 @@ import {
 } from "./plan-messenger.js";
 import {
 	CONSOLIDATED_REVIEW_ARTIFACT,
+	effectiveMinFocusRounds,
 	isConsolidatedReviewStrategy,
 	isParallelProbesReviewStrategy,
+	PARALLEL_PROBES_REVIEW_ARTIFACT,
 	planReviewGateStrategyFromEligibility,
+	reviewStrategyFromMessenger,
 } from "./plan-review-gate.js";
 
 async function fileExists(path: string): Promise<boolean> {
@@ -222,39 +234,72 @@ export async function validatePlanDebateGate(
 	const debatesDir = join(projectRoot, ".pi", "harness", "debates");
 	const messenger = await loadMessengerState(runDir);
 	const debateProfile = messenger?.debate_profile ?? "standard";
+
+	if (process.env.HARNESS_QA_SMOKE === "1" && isHarnessNonInteractive()) {
+		const consensusPath = join(debatesDir, `${debateId}.consensus.json`);
+		if (await fileExists(consensusPath)) {
+			try {
+				const packet = JSON.parse(await readFile(consensusPath, "utf-8")) as {
+					headless_bypass?: boolean;
+					policy_decision?: string;
+				};
+				if (
+					packet.headless_bypass === true &&
+					packet.policy_decision !== "block"
+				) {
+					const coverage = await getPlanFocusCoverage(runDir);
+					return {
+						ok: true,
+						errors: [],
+						warnings: ["QA smoke: headless debate bypass consensus accepted"],
+						debateId,
+						focus_coverage: {
+							covered: coverage.covered,
+							missing: coverage.missing,
+							last_review_gate_ready: coverage.last_review_gate_ready,
+						},
+						debate_profile: debateProfile,
+					};
+				}
+			} catch {
+				// fall through to full gate
+			}
+		}
+	}
+
 	const requiredFocuses: readonly PlanDebateFocus[] =
 		messenger?.required_focuses && messenger.required_focuses.length > 0
 			? messenger.required_focuses
 			: (["spec", "wbs", "schedule", "quality"] as const);
 	const caps = capsForDebate(debateId, debateProfile);
-	const reviewStrategy =
-		eligibility != null
-			? planReviewGateStrategyFromEligibility(eligibility)
-			: messenger?.review_gate_mode === "consolidated"
-				? {
-						mode: "consolidated" as const,
-						profile: debateProfile as DebateEligibilityResult["profile"],
-						required_focuses: [...requiredFocuses],
-						min_focus_rounds: caps.min_focus_rounds,
-						max_rounds: caps.max_rounds,
-						max_exchanges_per_round: caps.max_exchanges_per_round,
-						round_token_cap: caps.round_token_cap,
-						debate_global_cap: caps.debate_global_cap,
-						rationale: ["messenger review_gate_mode=consolidated"],
-					}
-				: {
-						mode: "threaded" as const,
-						profile: debateProfile as DebateEligibilityResult["profile"],
-						required_focuses: [...requiredFocuses],
-						min_focus_rounds: caps.min_focus_rounds,
-						max_rounds: caps.max_rounds,
-						max_exchanges_per_round: caps.max_exchanges_per_round,
-						round_token_cap: caps.round_token_cap,
-						debate_global_cap: caps.debate_global_cap,
-						rationale: [],
-					};
-	const consolidated = isConsolidatedReviewStrategy(reviewStrategy);
-	const parallelProbes = isParallelProbesReviewStrategy(reviewStrategy);
+	const eligibilitySnapshot =
+		eligibility ?? (await loadPlanDebateEligibilitySnapshot(runDir));
+	const reviewStrategy = eligibilitySnapshot
+		? planReviewGateStrategyFromEligibility(eligibilitySnapshot)
+		: messenger
+			? reviewStrategyFromMessenger(
+					messenger,
+					debateProfile as DebateProfile,
+					requiredFocuses,
+					caps,
+				)
+			: {
+					mode: "threaded" as const,
+					profile: debateProfile as DebateProfile,
+					required_focuses: [...requiredFocuses],
+					min_focus_rounds: caps.min_focus_rounds,
+					max_rounds: caps.max_rounds,
+					max_exchanges_per_round: caps.max_exchanges_per_round,
+					round_token_cap: caps.round_token_cap,
+					debate_global_cap: caps.debate_global_cap,
+					rationale: [],
+				};
+	const effectiveCaps = {
+		...caps,
+		min_focus_rounds: effectiveMinFocusRounds(reviewStrategy),
+	};
+	const _consolidated = isConsolidatedReviewStrategy(reviewStrategy);
+	const _parallelProbes = isParallelProbesReviewStrategy(reviewStrategy);
 	const coverage = await getPlanFocusCoverage(runDir, { requiredFocuses });
 	const dialogueOpts = {
 		max_exchanges_per_round: caps.max_exchanges_per_round,
@@ -298,12 +343,29 @@ export async function validatePlanDebateGate(
 		);
 	} else if (messenger.debate_id !== debateId) {
 		errors.push(`messenger debate_id ${messenger.debate_id} !== ${debateId}`);
+	} else {
+		const wall = checkDebateWallClock({
+			opened_at: messenger.opened_at,
+			debate_profile: debateProfile as DebateEligibilityResult["profile"],
+		});
+		if (wall.exceeded) {
+			const hint = debateWallClockRecoveryHint(wall);
+			if (wall.non_interactive) {
+				warnings.push(
+					`debate wall-clock exceeded (${Math.round(wall.elapsed_ms / 1000)}s > ${Math.round(wall.limit_ms / 1000)}s) — ${hint}`,
+				);
+			} else {
+				errors.push(
+					`debate wall-clock exceeded (${Math.round(wall.elapsed_ms / 1000)}s) — ${hint}`,
+				);
+			}
+		}
 	}
 
 	const busChecks = await collectBusAndConsensusIssues({
 		debateId,
 		debatesDir,
-		caps,
+		caps: effectiveCaps,
 		requiredFocuses,
 		coverage,
 		debateProfile,
@@ -329,7 +391,8 @@ export function isReviewRoundArtifactPath(relPath: string): boolean {
 	const norm = relPath.replace(/\\/g, "/");
 	return (
 		/^artifacts\/review-round-r\d+\.yaml$/i.test(norm) ||
-		norm === CONSOLIDATED_REVIEW_ARTIFACT
+		norm === CONSOLIDATED_REVIEW_ARTIFACT ||
+		norm === PARALLEL_PROBES_REVIEW_ARTIFACT
 	);
 }