ultimate-pi 0.16.0 → 0.17.0

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

@@ -7,18 +7,27 @@ 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 {
@@ -64,6 +73,7 @@ export interface PlanDebateGateResult {
 export async function validatePlanDebateGate(
 	projectRoot: string,
 	runId: string,
+	eligibility?: DebateEligibilityResult,
 ): Promise<PlanDebateGateResult> {
 	const errors: string[] = [];
 	const warnings: string[] = [];
@@ -77,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,
@@ -89,31 +126,55 @@ 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}`);
+				}
 			}
 		}
 	}
@@ -203,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-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",
+	];
+}

package/.pi/extensions/lib/plan-debate-round-status.ts

@@ -7,12 +7,15 @@ import { access } from "node:fs/promises";
 import { join } from "node:path";
 import { capsForDebate } from "./debate-bus-core.js";
 import {
-	type PlanDebateFocus,
+	type PlanDebateRoundFocus,
 	readDebateRoundFocus,
 } from "./plan-debate-focus.js";
 import { planDebateIdForRun } from "./plan-debate-id.js";
 import { laneArtifactPath } from "./plan-debate-lane.js";
-import { lanesForRound } from "./plan-debate-lanes.js";
+import {
+	lanesForConsolidatedRound,
+	lanesForRound,
+} from "./plan-debate-lanes.js";
 import {
 	getMessengerRoundState,
 	loadMessengerState,
@@ -40,26 +43,32 @@ export interface RoundStatusResult {
 	dialogue: { ok: boolean; errors: string[] };
 	unresolved_claim_ids: string[];
 	exchange_count: number;
-	debate_round_focus?: PlanDebateFocus | null;
+	debate_round_focus?: PlanDebateRoundFocus | null;
 }
 
 export async function getPlanDebateRoundStatus(
 	runDir: string,
 	roundIndex: number,
 	runId?: string,
-	opts?: { debate_round_focus?: PlanDebateFocus },
+	opts?: { debate_round_focus?: PlanDebateRoundFocus },
 ): Promise<RoundStatusResult> {
+	const messengerState = await loadMessengerState(runDir);
+	const consolidated =
+		messengerState?.review_gate_mode === "consolidated" && roundIndex === 1;
 	const focus =
 		opts?.debate_round_focus ??
+		(consolidated ? ("all" as PlanDebateRoundFocus) : null) ??
 		(await readDebateRoundFocus(runDir, roundIndex));
 	const missing: string[] = [];
-	for (const lane of lanesForRound(roundIndex, focus)) {
+	const laneList = consolidated
+		? lanesForConsolidatedRound()
+		: lanesForRound(roundIndex, focus);
+	for (const lane of laneList) {
 		const rel = laneArtifactPath(lane, roundIndex);
 		if (!(await exists(join(runDir, rel)))) {
 			missing.push(rel);
 		}
 	}
-	const messengerState = await loadMessengerState(runDir);
 	const profile = messengerState?.debate_profile;
 	const caps = capsForDebate(
 		runId ? planDebateIdForRun(runId) : `plan-${runId ?? "unknown"}`,
@@ -73,7 +82,9 @@ export async function getPlanDebateRoundStatus(
 	if (!dialogue.ok) {
 		missing.push(...dialogue.errors.map((e) => `messenger: ${e}`));
 	}
-	const reviewRound = `artifacts/review-round-r${roundIndex}.yaml`;
+	const reviewRound = consolidated
+		? "artifacts/review-round-consolidated.yaml"
+		: `artifacts/review-round-r${roundIndex}.yaml`;
 	const reviewRoundOnDisk = await exists(join(runDir, reviewRound));
 
 	let next_tool: string | undefined;

package/.pi/extensions/lib/plan-messenger.ts

@@ -63,6 +63,8 @@ export interface MessengerState {
 	rounds: Record<string, MessengerRoundState>;
 	debate_profile?: DebateProfile;
 	required_focuses?: PlanDebateFocus[];
+	/** consolidated = single Review Gate round; threaded = per-focus rounds */
+	review_gate_mode?: "consolidated" | "threaded";
 }
 
 function messengerRoot(runDir: string): string {
@@ -84,6 +86,7 @@ export async function initPlanMessenger(
 		debateId: string;
 		debate_profile?: DebateProfile;
 		required_focuses?: PlanDebateFocus[];
+		review_gate_mode?: "consolidated" | "threaded";
 	},
 ): Promise<string> {
 	const root = messengerRoot(runDir);
@@ -97,6 +100,7 @@ export async function initPlanMessenger(
 		rounds: {},
 		debate_profile: opts.debate_profile,
 		required_focuses: opts.required_focuses,
+		review_gate_mode: opts.review_gate_mode,
 	};
 	await writeFile(
 		join(root, "state.json"),

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

@@ -0,0 +1,51 @@
+/**
+ * Consolidated vs threaded Review Gate strategy for plan-phase debate.
+ */
+
+import type {
+	DebateEligibilityResult,
+	PlanReviewGateStrategy,
+} from "./plan-debate-eligibility.js";
+import type { PlanDebateFocus } from "./plan-debate-focus.js";
+
+export type { PlanReviewGateStrategy };
+
+export const CONSOLIDATED_REVIEW_ROUND = 1;
+export const CONSOLIDATED_REVIEW_ARTIFACT =
+	"artifacts/review-round-consolidated.yaml";
+
+export function planReviewGateStrategyFromEligibility(
+	eligibility: DebateEligibilityResult,
+): PlanReviewGateStrategy {
+	return (
+		eligibility.review_gate_strategy ?? {
+			mode: eligibility.profile === "fast" ? "consolidated" : "threaded",
+			profile: eligibility.profile,
+			required_focuses: [...eligibility.required_focuses],
+			min_focus_rounds: eligibility.min_focus_rounds,
+			max_rounds: eligibility.max_rounds,
+			max_exchanges_per_round: eligibility.max_exchanges_per_round,
+			round_token_cap: eligibility.round_token_cap,
+			debate_global_cap: eligibility.debate_global_cap,
+			rationale: [...eligibility.rationale],
+		}
+	);
+}
+
+export function isConsolidatedReviewStrategy(
+	strategy: PlanReviewGateStrategy,
+): boolean {
+	return strategy.mode === "consolidated";
+}
+
+/** Focus areas covered in a single consolidated review round (spec + quality gate). */
+export const CONSOLIDATED_REVIEW_FOCUS_AREAS: readonly PlanDebateFocus[] = [
+	"spec",
+	"quality",
+];
+
+export function consolidatedReviewFocusesSatisfied(
+	covered: readonly string[],
+): boolean {
+	return CONSOLIDATED_REVIEW_FOCUS_AREAS.every((f) => covered.includes(f));
+}

package/.pi/extensions/trace-recorder.ts

@@ -235,6 +235,7 @@ export default function traceRecorder(pi: ExtensionAPI) {
 		if (shouldEmitStarted) {
 			captureHarnessEvent(sessionId, "harness_run_started", {
 				harness_run_id: runId,
+				run_id: runId,
 				harness_plan_id: activeRun.planId,
 				harness_phase: activeRun.phase,
 				pi_session_id: sessionId,

package/.pi/harness/evals/smoke/fixtures/plan-phase/minimal-med-fast/artifacts/implementation-research.yaml

@@ -0,0 +1,28 @@
+schema_version: "1.0.0"
+problem_framing: Validate harness plan-phase with fixture-driven smoke
+sub_problems:
+  - DAG validation
+  - Debate gate coverage
+internal_references:
+  - path: .pi/harness/evals/smoke/smoke-harness-plan.mjs
+    relevance: Existing smoke pattern
+    reuse_signal: high
+external_references: []
+solution_patterns:
+  - name: fixture-driven gate
+    provenance: in-repo smoke
+    fit: Validates plan pipeline without live agents
+    tradeoffs:
+      pros: [Deterministic CI]
+      cons: []
+    risks: []
+similar_implementations: []
+recommended_approach:
+  summary: Extend minimal-med fixture with implementation artifact
+  recommended_approach_confidence: high
+  confidence_rationale: Reuses established smoke-harness-plan pattern
+  evidence_refs:
+    - .pi/harness/evals/smoke/smoke-harness-plan.mjs
+    - .pi/scripts/validate-plan-dag.mjs
+anti_patterns: []
+open_questions: []

package/.pi/harness/evals/smoke/fixtures/plan-phase/minimal-med-fast/artifacts/review-round-consolidated.yaml

@@ -0,0 +1,25 @@
+schema_version: "1.0.0"
+round_index: 1
+debate_round_focus: all
+round_summary: Consolidated review gate for fast profile fixture
+validation_summary: Spec and quality checks pass in one round
+adversary_summary: No blockers
+disputes: []
+recommended_packet_patches: []
+review_gate_ready: true
+participants:
+  - PlanEvaluatorAgent
+  - PlanAdversaryAgent
+  - SprintContractAuditorAgent
+  - ReviewIntegratorAgent
+claims:
+  - consolidated review gate ready
+rebuttals: []
+evidence_refs: []
+token_usage:
+  per_agent:
+    PlanEvaluatorAgent: 120
+    PlanAdversaryAgent: 100
+    SprintContractAuditorAgent: 80
+  round_total: 300
+consensus_delta: 0.1