ultimate-pi 0.15.0 → 0.17.0

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

@@ -2,6 +2,7 @@
  * ultimate-pi harness wrapper around vendored pi-subagents.
  */
 
+import { join } from "node:path";
 import type {
 	ExtensionAPI,
 	ExtensionContext,
@@ -12,6 +13,13 @@ import {
 	type HarnessSubagentsOptions,
 	type SpawnAuthForward,
 } from "../../../vendor/pi-subagents/src/subagents.js";
+import {
+	getLatestRunContext,
+	getRunIdFromSession,
+	type HarnessPhase,
+} from "../../lib/harness-run-context.js";
+import { parseSpawnContextFromTask } from "../../lib/harness-spawn-parse.js";
+import { harnessSubagentSubmitExtensionPath } from "../harness-subagent-submit.js";
 import { refreshHarnessCocoindexIndex } from "./harness-cocoindex-refresh.js";
 import { captureHarnessEvent } from "./harness-posthog.js";
 import {
@@ -32,6 +40,51 @@ import {
 
 const spawnBudget = createSpawnBudgetState();
 let lastSessionId = "harness";
+let spawnGroupCounter = 0;
+type PendingSpawnTelemetry = {
+	harness_run_id: string;
+	run_id: string;
+	harness_plan_id: string;
+	harness_phase: HarnessPhase;
+	agent_ids: string[];
+	spawn_group_id: string;
+};
+let pendingSpawnTelemetry: PendingSpawnTelemetry | null = null;
+
+function collectHarnessAgentIds(params: Record<string, unknown>): string[] {
+	const out = new Set<string>();
+	const maybe = params as {
+		agent?: string;
+		chain?: Array<{ agent?: string }>;
+		tasks?: Array<{ agent?: string }>;
+		aggregator?: { agent?: string };
+	};
+	if (typeof maybe.agent === "string" && maybe.agent.startsWith("harness/")) {
+		out.add(maybe.agent);
+	}
+	for (const item of maybe.chain ?? []) {
+		if (typeof item?.agent === "string" && item.agent.startsWith("harness/")) {
+			out.add(item.agent);
+		}
+	}
+	for (const item of maybe.tasks ?? []) {
+		if (typeof item?.agent === "string" && item.agent.startsWith("harness/")) {
+			out.add(item.agent);
+		}
+	}
+	if (
+		typeof maybe.aggregator?.agent === "string" &&
+		maybe.aggregator.agent.startsWith("harness/")
+	) {
+		out.add(maybe.aggregator.agent);
+	}
+	return Array.from(out.values()).sort();
+}
+
+function nextSpawnGroupId(sessionId: string): string {
+	spawnGroupCounter += 1;
+	return `${sessionId}-${Date.now()}-${spawnGroupCounter}`;
+}
 
 async function resolveHarnessSpawnAuth(
 	ctx: ExtensionContext,
@@ -58,8 +111,47 @@ async function resolveHarnessSpawnAuth(
 export function createHarnessSubagentsExtension(
 	packageRoot: string,
 ): (pi: ExtensionAPI) => void {
+	const submitExtPath = harnessSubagentSubmitExtensionPath(packageRoot);
 	const options: HarnessSubagentsOptions = {
 		packageRoot,
+		harnessSubprocessExtensionPath: submitExtPath,
+		resolveSubprocessEnv: (task, agent) => {
+			if (!agent.name.startsWith("harness/")) return undefined;
+			const ctx = parseSpawnContextFromTask(task);
+			// #region agent log
+			fetch(
+				"http://127.0.0.1:7928/ingest/a5d40896-34cb-4f12-97db-df7ada0b22f0",
+				{
+					method: "POST",
+					headers: {
+						"Content-Type": "application/json",
+						"X-Debug-Session-Id": "2ca12b",
+					},
+					body: JSON.stringify({
+						sessionId: "2ca12b",
+						hypothesisId: "H1",
+						location: "harness-subagents-bridge.ts:resolveSubprocessEnv",
+						message: "parsed spawn context for subprocess env",
+						data: {
+							agent: agent.name,
+							hasCtx: Boolean(ctx?.run_id),
+							run_id: ctx?.run_id ?? null,
+							run_dir: ctx?.run_dir ?? null,
+							taskPrefix: task.slice(0, 160),
+						},
+						timestamp: Date.now(),
+					}),
+				},
+			).catch(() => {});
+			// #endregion
+			if (!ctx?.run_id) return undefined;
+			return {
+				HARNESS_RUN_ID: ctx.run_id,
+				HARNESS_RUN_DIR:
+					ctx.run_dir ??
+					join(packageRoot, ".pi", "harness", "runs", ctx.run_id),
+			};
+		},
 		defaultAgentScope: "both",
 		defaultConfirmProjectAgents: false,
 		truncateDetails: true,
@@ -69,11 +161,13 @@ export function createHarnessSubagentsExtension(
 			const { harnessCount } = countHarnessAgentsInRequest(
 				params as Parameters<typeof countHarnessAgentsInRequest>[0],
 			);
+			pendingSpawnTelemetry = null;
 			if (harnessCount > 0) {
 				const budget = checkHarnessSpawnBudget(spawnBudget, harnessCount);
 				if (!budget.ok) {
 					return { ok: false, message: budget.message };
 				}
+				const entries = ctx.sessionManager.getEntries();
 				const phase = inferPhaseForPrecheck(ctx.sessionManager.getEntries());
 				const pre = precheckHarnessSubagentSpawn(
 					params as Parameters<typeof precheckHarnessSubagentSpawn>[0],
@@ -91,6 +185,19 @@ export function createHarnessSubagentsExtension(
 						return { ok: false, message: refreshMsg };
 					}
 				}
+				const runCtx = getLatestRunContext(entries);
+				const runId =
+					runCtx?.run_id ??
+					getRunIdFromSession(entries, lastSessionId) ??
+					lastSessionId;
+				pendingSpawnTelemetry = {
+					harness_run_id: runId,
+					run_id: runId,
+					harness_plan_id: runCtx?.plan_id ?? "plan-unknown",
+					harness_phase: phase,
+					agent_ids: collectHarnessAgentIds(params as Record<string, unknown>),
+					spawn_group_id: nextSpawnGroupId(lastSessionId),
+				};
 			}
 			return { ok: true };
 		},
@@ -100,6 +207,16 @@ export function createHarnessSubagentsExtension(
 			captureHarnessEvent(lastSessionId, "harness_subagent_spawned", {
 				active_after: spawnBudget.active,
 				spawn_count: harnessCount,
+				harness_run_id: pendingSpawnTelemetry?.harness_run_id ?? lastSessionId,
+				run_id: pendingSpawnTelemetry?.run_id ?? lastSessionId,
+				harness_plan_id:
+					pendingSpawnTelemetry?.harness_plan_id ?? "plan-unknown",
+				harness_phase: pendingSpawnTelemetry?.harness_phase ?? "plan",
+				agent_ids: pendingSpawnTelemetry?.agent_ids ?? [],
+				agent_count: pendingSpawnTelemetry?.agent_ids.length ?? harnessCount,
+				spawn_group_id:
+					pendingSpawnTelemetry?.spawn_group_id ??
+					nextSpawnGroupId(lastSessionId),
 			});
 		},
 		onSpawnEnd: (harnessCount) => {
@@ -112,7 +229,17 @@ export function createHarnessSubagentsExtension(
 				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,
+				harness_plan_id:
+					pendingSpawnTelemetry?.harness_plan_id ?? "plan-unknown",
+				harness_phase: pendingSpawnTelemetry?.harness_phase ?? "plan",
+				spawn_group_id:
+					pendingSpawnTelemetry?.spawn_group_id ??
+					nextSpawnGroupId(lastSessionId),
 			});
+			pendingSpawnTelemetry = null;
 		},
 	};
 

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

@@ -4,7 +4,7 @@
 
 import { PLAN_FOCUS_AREAS, type PlanDebateFocus } from "./plan-debate-focus.js";
 
-export type DebateProfile = "full" | "standard" | "light";
+export type DebateProfile = "full" | "standard" | "light" | "fast";
 
 export interface DebateEligibilityInput {
 	risk_level?: string;
@@ -26,6 +26,7 @@ export interface DebateEligibilityResult {
 	debate_global_cap: number;
 	human_required: boolean;
 	rationale: string[];
+	review_gate_strategy: PlanReviewGateStrategy;
 }
 
 const LIGHT_FOCUS: PlanDebateFocus[] = ["spec", "quality"];
@@ -75,7 +76,7 @@ function confidenceAllowsLight(brief: Record<string, unknown> | null): boolean {
 	if (!rationale || refs.length < 2) return false;
 	if (implementationOpenQuestions(brief).length > 0) return false;
 	const patterns = Array.isArray(brief?.solution_patterns)
-		? (brief!.solution_patterns as unknown[])
+		? (brief?.solution_patterns as unknown[])
 		: [];
 	for (const p of patterns) {
 		const pat = asRecord(p);
@@ -85,7 +86,7 @@ function confidenceAllowsLight(brief: Record<string, unknown> | null): boolean {
 		}
 	}
 	const similar = Array.isArray(brief?.similar_implementations)
-		? (brief!.similar_implementations as unknown[])
+		? (brief?.similar_implementations as unknown[])
 		: [];
 	if (similar.length === 0) return false;
 	return true;
@@ -116,17 +117,46 @@ export const PLAN_BUDGET_LIGHT = {
 	debate_global_cap: 40000,
 } as const;
 
+export const PLAN_BUDGET_FAST = {
+	min_focus_rounds: 1,
+	max_rounds: 2,
+	max_exchanges_per_round: 1,
+	round_token_cap: 3500,
+	debate_global_cap: 20000,
+} as const;
+
+export interface PlanReviewGateStrategy {
+	mode: "consolidated" | "threaded";
+	profile: DebateProfile;
+	required_focuses: PlanDebateFocus[];
+	min_focus_rounds: number;
+	max_rounds: number;
+	max_exchanges_per_round: number;
+	round_token_cap: number;
+	debate_global_cap: number;
+	rationale: string[];
+}
+
 function capsForProfile(
 	profile: DebateProfile,
 ): Omit<
 	DebateEligibilityResult,
-	"profile" | "required_focuses" | "human_required" | "rationale"
+	| "profile"
+	| "required_focuses"
+	| "human_required"
+	| "rationale"
+	| "review_gate_strategy"
 > {
 	if (profile === "light") {
 		return {
 			...PLAN_BUDGET_LIGHT,
 		};
 	}
+	if (profile === "fast") {
+		return {
+			...PLAN_BUDGET_FAST,
+		};
+	}
 	return {
 		...PLAN_BUDGET_STANDARD,
 	};
@@ -161,7 +191,7 @@ export function harnessPlanDebateEligibility(
 
 	const conflictingPatterns =
 		Array.isArray(impl?.solution_patterns) &&
-		(impl!.solution_patterns as unknown[]).length >= 2 &&
+		(impl?.solution_patterns as unknown[]).length >= 2 &&
 		openQs.length > 0;
 	if (conflictingPatterns) {
 		human_required = true;
@@ -182,6 +212,18 @@ export function harnessPlanDebateEligibility(
 		rationale.push(
 			"full: high risk, material fork, open questions, DAG patch, or tensions",
 		);
+	} else if (
+		risk === "med" &&
+		!materialFork &&
+		!dagPatched &&
+		input.dag_pass !== false &&
+		openQs.length === 0 &&
+		stackHasClearPrimary(stack)
+	) {
+		profile = "fast";
+		rationale.push(
+			"fast: medium risk with clear stack and no open questions; use consolidated review with escalation on blockers",
+		);
 	} else if (
 		risk === "low" &&
 		!materialFork &&
@@ -190,9 +232,9 @@ export function harnessPlanDebateEligibility(
 		confidenceAllowsLight(impl) &&
 		stackHasClearPrimary(stack)
 	) {
-		profile = "light";
+		profile = "fast";
 		rationale.push(
-			"light: low risk, clear stack, high-confidence implementation approach",
+			"fast: low risk, clear stack, high-confidence implementation approach",
 		);
 	} else if (risk === "med") {
 		profile = "standard";
@@ -200,7 +242,7 @@ export function harnessPlanDebateEligibility(
 	}
 
 	const required_focuses: PlanDebateFocus[] =
-		profile === "light" ? [...LIGHT_FOCUS] : [...PLAN_FOCUS_AREAS];
+		profile === "fast" ? [...LIGHT_FOCUS] : [...PLAN_FOCUS_AREAS];
 
 	const caps = capsForProfile(profile);
 
@@ -210,5 +252,16 @@ export function harnessPlanDebateEligibility(
 		...caps,
 		human_required,
 		rationale,
+		review_gate_strategy: {
+			mode: profile === "fast" ? "consolidated" : "threaded",
+			profile,
+			required_focuses: [...required_focuses],
+			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: [...rationale],
+		},
 	};
 }

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

@@ -9,12 +9,13 @@ import { parse as parseYaml } from "yaml";
 
 export const PLAN_FOCUS_AREAS = ["spec", "wbs", "schedule", "quality"] as const;
 export type PlanDebateFocus = (typeof PLAN_FOCUS_AREAS)[number];
+export type PlanDebateRoundFocus = PlanDebateFocus | "all";
 
 export interface PlanFocusCoverage {
 	covered: PlanDebateFocus[];
 	missing: PlanDebateFocus[];
 	rounds_by_focus: Partial<Record<PlanDebateFocus, number>>;
-	focus_by_round: Partial<Record<number, PlanDebateFocus>>;
+	focus_by_round: Partial<Record<number, PlanDebateRoundFocus>>;
 	last_review_gate_ready: boolean;
 	last_round_index: number;
 }
@@ -34,8 +35,9 @@ async function fileExists(path: string): Promise<boolean> {
 
 function focusFromDraft(
 	draft: Record<string, unknown>,
-): PlanDebateFocus | null {
+): PlanDebateRoundFocus | null {
 	const focus = String(draft.debate_round_focus ?? "").trim();
+	if (focus === "all") return "all";
 	if ((PLAN_FOCUS_AREAS as readonly string[]).includes(focus)) {
 		return focus as PlanDebateFocus;
 	}
@@ -56,14 +58,14 @@ export async function getPlanFocusCoverage(
 	const artifactsDir = join(runDir, "artifacts");
 	const covered = new Set<PlanDebateFocus>();
 	const rounds_by_focus: Partial<Record<PlanDebateFocus, number>> = {};
-	const focus_by_round: Partial<Record<number, PlanDebateFocus>> = {};
+	const focus_by_round: Partial<Record<number, PlanDebateRoundFocus>> = {};
 	let last_review_gate_ready = false;
 	let last_round_index = 0;
 
 	let files: string[] = [];
 	try {
 		files = (await readdir(artifactsDir)).filter((f) =>
-			/^review-round-r\d+\.yaml$/i.test(f),
+			/^review-round(?:-r\d+|-consolidated)\.yaml$/i.test(f),
 		);
 	} catch {
 		return {
@@ -77,9 +79,12 @@ export async function getPlanFocusCoverage(
 	}
 
 	for (const name of files.sort()) {
-		const m = /^review-round-r(\d+)\.yaml$/i.exec(name);
+		const consolidated = /^review-round-consolidated\.yaml$/i.test(name);
+		const m = consolidated
+			? ["review-round-consolidated.yaml", "1"]
+			: /^review-round-r(\d+)\.yaml$/i.exec(name);
 		if (!m) continue;
-		const roundIndex = Number(m[1]);
+		const roundIndex = consolidated ? 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>;
@@ -90,8 +95,15 @@ export async function getPlanFocusCoverage(
 		}
 		const focus = focusFromDraft(draft);
 		if (focus) {
-			covered.add(focus);
-			rounds_by_focus[focus] = roundIndex;
+			if (focus === "all") {
+				for (const requiredFocus of required) {
+					covered.add(requiredFocus);
+					rounds_by_focus[requiredFocus] = roundIndex;
+				}
+			} else {
+				covered.add(focus);
+				rounds_by_focus[focus] = roundIndex;
+			}
 			focus_by_round[roundIndex] = focus;
 		}
 		if (roundIndex === last_round_index) {
@@ -138,7 +150,7 @@ export function planDebateOutcomeComplete(
 export async function readDebateRoundFocus(
 	runDir: string,
 	roundIndex: number,
-): Promise<PlanDebateFocus | null> {
+): Promise<PlanDebateRoundFocus | null> {
 	const path = join(runDir, "artifacts", `review-round-r${roundIndex}.yaml`);
 	if (!(await fileExists(path))) return null;
 	try {

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

@@ -5,19 +5,29 @@
 import { constants } from "node:fs";
 import { access, readFile } from "node:fs/promises";
 import { join } from "node:path";
+import { isHarnessBudgetEnforceOn } from "../../lib/harness-budget-enforce.js";
 import { capsForDebate } from "./debate-bus-core.js";
+import type { DebateEligibilityResult } from "./plan-debate-eligibility.js";
 import {
 	getPlanFocusCoverage,
 	type PlanDebateFocus,
 	planDebateOutcomeComplete,
 } from "./plan-debate-focus.js";
 import { planDebateIdForRun } from "./plan-debate-id.js";
-import { laneArtifactPathsForRound } from "./plan-debate-lanes.js";
+import {
+	laneArtifactPathsForConsolidatedRound,
+	laneArtifactPathsForRound,
+} from "./plan-debate-lanes.js";
 import {
 	getMessengerRoundState,
 	loadMessengerState,
 	messengerRoundDebateReady,
 } from "./plan-messenger.js";
+import {
+	CONSOLIDATED_REVIEW_ARTIFACT,
+	isConsolidatedReviewStrategy,
+	planReviewGateStrategyFromEligibility,
+} from "./plan-review-gate.js";
 
 async function fileExists(path: string): Promise<boolean> {
 	try {
@@ -63,6 +73,7 @@ export interface PlanDebateGateResult {
 export async function validatePlanDebateGate(
 	projectRoot: string,
 	runId: string,
+	eligibility?: DebateEligibilityResult,
 ): Promise<PlanDebateGateResult> {
 	const errors: string[] = [];
 	const warnings: string[] = [];
@@ -76,6 +87,33 @@ export async function validatePlanDebateGate(
 			? 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 coverage = await getPlanFocusCoverage(runDir, { requiredFocuses });
 	const dialogueOpts = {
 		max_exchanges_per_round: caps.max_exchanges_per_round,
@@ -88,39 +126,73 @@ export async function validatePlanDebateGate(
 		errors.push("last submitted review round has review_gate_ready !== true");
 	}
 
-	const roundIndices = [
-		...new Set(
-			Object.values(coverage.rounds_by_focus).filter(
-				(v): v is number => typeof v === "number",
-			),
-		),
-	];
-	for (const r of roundIndices) {
-		const focus = coverage.focus_by_round[r] ?? null;
-		for (const rel of laneArtifactPathsForRound(r, focus)) {
+	if (consolidated) {
+		const absConsolidated = join(runDir, CONSOLIDATED_REVIEW_ARTIFACT);
+		if (!(await fileExists(absConsolidated))) {
+			errors.push(`missing ${CONSOLIDATED_REVIEW_ARTIFACT}`);
+		}
+		for (const rel of laneArtifactPathsForConsolidatedRound()) {
 			const abs = join(runDir, rel);
 			if (!(await fileExists(abs))) {
 				errors.push(`missing ${rel}`);
 			}
 		}
-		const roundState = await getMessengerRoundState(runDir, r);
-		const requireSprint = focus === "quality" || r >= 4;
+		const roundState = await getMessengerRoundState(runDir, 1);
 		const messengerCheck = messengerRoundDebateReady(
 			roundState,
-			requireSprint,
+			true,
 			dialogueOpts,
 		);
 		if (!messengerCheck.ok) {
 			for (const e of messengerCheck.errors) {
-				errors.push(`round ${r} messenger: ${e}`);
+				errors.push(`consolidated round messenger: ${e}`);
+			}
+		}
+	} else {
+		const roundIndices = [
+			...new Set(
+				Object.values(coverage.rounds_by_focus).filter(
+					(v): v is number => typeof v === "number",
+				),
+			),
+		];
+		for (const r of roundIndices) {
+			const focus = coverage.focus_by_round[r] ?? null;
+			for (const rel of laneArtifactPathsForRound(r, focus)) {
+				const abs = join(runDir, rel);
+				if (!(await fileExists(abs))) {
+					errors.push(`missing ${rel}`);
+				}
+			}
+			const roundState = await getMessengerRoundState(runDir, r);
+			const requireSprint = focus === "quality" || r >= 4;
+			const messengerCheck = messengerRoundDebateReady(
+				roundState,
+				requireSprint,
+				dialogueOpts,
+			);
+			if (!messengerCheck.ok) {
+				for (const e of messengerCheck.errors) {
+					errors.push(`round ${r} messenger: ${e}`);
+				}
 			}
 		}
 	}
 
-	if (coverage.last_round_index > caps.max_rounds) {
+	if (
+		isHarnessBudgetEnforceOn() &&
+		coverage.last_round_index > caps.max_rounds
+	) {
 		errors.push(
 			`round_count ${coverage.last_round_index} exceeds max_rounds ${caps.max_rounds}`,
 		);
+	} else if (
+		!isHarnessBudgetEnforceOn() &&
+		coverage.last_round_index > caps.max_rounds
+	) {
+		warnings.push(
+			`round_count ${coverage.last_round_index} exceeds advisory max_rounds ${caps.max_rounds} (budget enforce off)`,
+		);
 	}
 
 	if (!messenger) {
@@ -192,7 +264,9 @@ export async function validatePlanDebateGate(
 }
 
 export function isReviewRoundArtifactPath(relPath: string): boolean {
-	return /^artifacts\/review-round-r\d+\.yaml$/i.test(
-		relPath.replace(/\\/g, "/"),
+	const norm = relPath.replace(/\\/g, "/");
+	return (
+		/^artifacts\/review-round-r\d+\.yaml$/i.test(norm) ||
+		norm === CONSOLIDATED_REVIEW_ARTIFACT
 	);
 }

package/.pi/extensions/lib/plan-debate-lane.ts

@@ -45,6 +45,21 @@ export function laneArtifactPath(
 	}
 }
 
+/** Apply messenger side effects when artifact YAML was already written via submit tool. */
+export async function applyDebateLaneFromDoc(opts: {
+	runDir: string;
+	lane: DebateLaneKind;
+	doc: Record<string, unknown>;
+	roundIndex?: number;
+}): Promise<ApplyDebateLaneResult> {
+	return applyDebateLane({
+		runDir: opts.runDir,
+		lane: opts.lane,
+		content: JSON.stringify(opts.doc),
+		roundIndex: opts.roundIndex,
+	});
+}
+
 export function extractClaimIds(doc: Record<string, unknown>): string[] {
 	const explicit = doc.messenger_claim_ids;
 	if (Array.isArray(explicit)) {

package/.pi/extensions/lib/plan-debate-lanes.ts

@@ -2,13 +2,13 @@
  * Shared Review Gate lane list for a round (gate + round-status).
  */
 
-import type { PlanDebateFocus } from "./plan-debate-focus.js";
+import type { PlanDebateRoundFocus } from "./plan-debate-focus.js";
 import type { DebateLaneKind } from "./plan-debate-lane.js";
 
 /** Lanes required before review-integrator for this round. */
 export function lanesForRound(
 	roundIndex: number,
-	debateRoundFocus?: PlanDebateFocus | null,
+	debateRoundFocus?: PlanDebateRoundFocus | null,
 ): DebateLaneKind[] {
 	const lanes: DebateLaneKind[] = ["validation-turn", "adversary-brief"];
 	if (roundIndex === 1) {
@@ -23,7 +23,7 @@ export function lanesForRound(
 /** Relative artifact paths for lane YAML + review-round. */
 export function laneArtifactPathsForRound(
 	roundIndex: number,
-	debateRoundFocus?: PlanDebateFocus | null,
+	debateRoundFocus?: PlanDebateRoundFocus | null,
 ): string[] {
 	const paths = lanesForRound(roundIndex, debateRoundFocus).map((lane) => {
 		switch (lane) {
@@ -42,3 +42,27 @@ export function laneArtifactPathsForRound(
 	paths.push(`artifacts/review-round-r${roundIndex}.yaml`);
 	return paths;
 }
+
+/** Lanes for consolidated Review Gate (single round, parallel-friendly). */
+export function lanesForConsolidatedRound(): DebateLaneKind[] {
+	return ["validation-turn", "adversary-brief", "sprint-audit"];
+}
+
+export function laneArtifactPathsForConsolidatedRound(): string[] {
+	const roundIndex = 1;
+	return [
+		...lanesForConsolidatedRound().map((lane) => {
+			switch (lane) {
+				case "validation-turn":
+					return `artifacts/validation-turn-r${roundIndex}.yaml`;
+				case "adversary-brief":
+					return `artifacts/adversary-brief-r${roundIndex}.yaml`;
+				case "sprint-audit":
+					return `artifacts/sprint-audit-r${roundIndex}.yaml`;
+				default:
+					return `artifacts/${lane}-r${roundIndex}.yaml`;
+			}
+		}),
+		"artifacts/review-round-consolidated.yaml",
+	];
+}