ultimate-pi 0.24.0 → 0.25.0

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

@@ -249,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,
@@ -257,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,
@@ -31,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> {
@@ -226,37 +234,70 @@ 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 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 });
@@ -324,7 +365,7 @@ export async function validatePlanDebateGate(
 	const busChecks = await collectBusAndConsensusIssues({
 		debateId,
 		debatesDir,
-		caps,
+		caps: effectiveCaps,
 		requiredFocuses,
 		coverage,
 		debateProfile,
@@ -350,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
 	);
 }
 

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

@@ -14,7 +14,9 @@ import { planDebateIdForRun } from "./plan-debate-id.js";
 import { laneArtifactPath } from "./plan-debate-lane.js";
 import {
 	lanesForConsolidatedRound,
+	lanesForParallelProbesRound,
 	lanesForRound,
+	PARALLEL_PROBES_REVIEW_ARTIFACT,
 } from "./plan-debate-lanes.js";
 import {
 	getMessengerRoundState,
@@ -53,16 +55,20 @@ export async function getPlanDebateRoundStatus(
 	opts?: { debate_round_focus?: PlanDebateRoundFocus },
 ): Promise<RoundStatusResult> {
 	const messengerState = await loadMessengerState(runDir);
+	const parallelProbes =
+		messengerState?.review_gate_mode === "parallel_probes" && roundIndex === 1;
 	const consolidated =
 		messengerState?.review_gate_mode === "consolidated" && roundIndex === 1;
 	const focus =
 		opts?.debate_round_focus ??
-		(consolidated ? ("all" as PlanDebateRoundFocus) : null) ??
+		(consolidated || parallelProbes ? ("all" as PlanDebateRoundFocus) : null) ??
 		(await readDebateRoundFocus(runDir, roundIndex));
 	const missing: string[] = [];
-	const laneList = consolidated
-		? lanesForConsolidatedRound()
-		: lanesForRound(roundIndex, focus);
+	const laneList = parallelProbes
+		? lanesForParallelProbesRound()
+		: consolidated
+			? lanesForConsolidatedRound()
+			: lanesForRound(roundIndex, focus);
 	for (const lane of laneList) {
 		const rel = laneArtifactPath(lane, roundIndex);
 		if (!(await exists(join(runDir, rel)))) {
@@ -82,13 +88,22 @@ export async function getPlanDebateRoundStatus(
 	if (!dialogue.ok) {
 		missing.push(...dialogue.errors.map((e) => `messenger: ${e}`));
 	}
-	const reviewRound = consolidated
-		? "artifacts/review-round-consolidated.yaml"
-		: `artifacts/review-round-r${roundIndex}.yaml`;
+	const reviewRound = parallelProbes
+		? PARALLEL_PROBES_REVIEW_ARTIFACT
+		: consolidated
+			? "artifacts/review-round-consolidated.yaml"
+			: `artifacts/review-round-r${roundIndex}.yaml`;
 	const reviewRoundOnDisk = await exists(join(runDir, reviewRound));
 
 	let next_tool: string | undefined;
-	if (missing.some((m) => m.includes("hypothesis-validation"))) {
+	if (
+		parallelProbes &&
+		missing.some((m) => m.includes("validation-turn")) &&
+		missing.some((m) => m.includes("adversary-brief"))
+	) {
+		next_tool =
+			"subagent parallel batch: harness/planning/plan-evaluator ∥ harness/planning/plan-adversary (parallel_probes)";
+	} else if (missing.some((m) => m.includes("hypothesis-validation"))) {
 		next_tool = "subagent harness/planning/hypothesis-validator";
 	} else if (missing.some((m) => m.includes("validation-turn"))) {
 		next_tool = "subagent harness/planning/plan-evaluator";