ultimate-pi 0.14.0 → 0.15.0

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

@@ -5,32 +5,20 @@
 import { constants } from "node:fs";
 import { access, readFile } from "node:fs/promises";
 import { join } from "node:path";
+import { capsForDebate } from "./debate-bus-core.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 {
 	getMessengerRoundState,
 	loadMessengerState,
 	messengerRoundDebateReady,
 } from "./plan-messenger.js";
 
-const PLAN_ROUNDS = 4;
-const FOCUS_BY_ROUND = ["spec", "wbs", "schedule", "quality"] as const;
-
-function laneFilesForRound(roundIndex: number): string[] {
-	const n = roundIndex;
-	const lanes = [
-		`artifacts/validation-turn-r${n}.yaml`,
-		`artifacts/adversary-brief-r${n}.yaml`,
-	];
-	if (n === 1) {
-		lanes.unshift(`artifacts/hypothesis-validation-r${n}.yaml`);
-	}
-	if (n === 4) {
-		lanes.push(`artifacts/sprint-audit-r${n}.yaml`);
-	}
-	lanes.push(`artifacts/review-round-r${n}.yaml`);
-	return lanes;
-}
-
 async function fileExists(path: string): Promise<boolean> {
 	try {
 		await access(path, constants.R_OK);
@@ -64,6 +52,12 @@ export interface PlanDebateGateResult {
 	errors: string[];
 	warnings: string[];
 	debateId: string;
+	focus_coverage?: {
+		covered: string[];
+		missing: string[];
+		last_review_gate_ready: boolean;
+	};
+	debate_profile?: string;
 }
 
 export async function validatePlanDebateGate(
@@ -75,16 +69,47 @@ export async function validatePlanDebateGate(
 	const debateId = planDebateIdForRun(runId);
 	const runDir = join(projectRoot, ".pi", "harness", "runs", runId);
 	const debatesDir = join(projectRoot, ".pi", "harness", "debates");
+	const messenger = await loadMessengerState(runDir);
+	const debateProfile = messenger?.debate_profile ?? "standard";
+	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 coverage = await getPlanFocusCoverage(runDir, { requiredFocuses });
+	const dialogueOpts = {
+		max_exchanges_per_round: caps.max_exchanges_per_round,
+	};
 
-	for (let r = 1; r <= PLAN_ROUNDS; r++) {
-		for (const rel of laneFilesForRound(r)) {
+	for (const focus of coverage.missing) {
+		errors.push(`focus not covered in submitted rounds: ${focus}`);
+	}
+	if (!coverage.last_review_gate_ready) {
+		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)) {
 			const abs = join(runDir, rel);
 			if (!(await fileExists(abs))) {
 				errors.push(`missing ${rel}`);
 			}
 		}
 		const roundState = await getMessengerRoundState(runDir, r);
-		const messengerCheck = messengerRoundDebateReady(roundState, r === 4);
+		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}`);
@@ -92,7 +117,12 @@ export async function validatePlanDebateGate(
 		}
 	}
 
-	const messenger = await loadMessengerState(runDir);
+	if (coverage.last_round_index > caps.max_rounds) {
+		errors.push(
+			`round_count ${coverage.last_round_index} exceeds max_rounds ${caps.max_rounds}`,
+		);
+	}
+
 	if (!messenger) {
 		errors.push(
 			"debate-messenger/state.json missing — call harness_debate_open",
@@ -103,9 +133,10 @@ export async function validatePlanDebateGate(
 
 	const jsonlPath = join(debatesDir, `${debateId}.jsonl`);
 	const { rounds, hasConsensus } = await countJsonlKinds(jsonlPath);
-	if (rounds < PLAN_ROUNDS) {
+	const minRounds = caps.min_focus_rounds;
+	if (rounds < minRounds) {
 		errors.push(
-			`${debateId}.jsonl has ${rounds}/${PLAN_ROUNDS} round events — use harness_debate_submit_round each round`,
+			`${debateId}.jsonl has ${rounds}/${minRounds} minimum round events — use harness_debate_submit_round per focus`,
 		);
 	}
 	if (!hasConsensus) {
@@ -114,6 +145,17 @@ export async function validatePlanDebateGate(
 		);
 	}
 
+	if (
+		!planDebateOutcomeComplete(coverage, {
+			requiredFocuses,
+			minRoundIndex: caps.min_focus_rounds,
+		})
+	) {
+		errors.push(
+			`debate outcome incomplete: required focuses [${requiredFocuses.join(", ")}] with last review_gate_ready true (profile=${debateProfile})`,
+		);
+	}
+
 	const consensusPath = join(debatesDir, `${debateId}.consensus.json`);
 	if (!(await fileExists(consensusPath))) {
 		errors.push(`missing ${debateId}.consensus.json`);
@@ -129,15 +171,10 @@ export async function validatePlanDebateGate(
 		}
 	}
 
-	for (let r = 0; r < FOCUS_BY_ROUND.length; r++) {
-		const focus = FOCUS_BY_ROUND[r];
-		const reviewPath = join(runDir, `artifacts/review-round-r${r + 1}.yaml`);
-		if (await fileExists(reviewPath)) {
-			const raw = await readFile(reviewPath, "utf-8");
-			if (!raw.includes(focus)) {
-				warnings.push(`review-round-r${r + 1} may not match focus ${focus}`);
-			}
-		}
+	if (rounds > caps.max_rounds) {
+		warnings.push(
+			`bus round count ${rounds} exceeds soft max_rounds ${caps.max_rounds}`,
+		);
 	}
 
 	return {
@@ -145,6 +182,12 @@ export async function validatePlanDebateGate(
 		errors,
 		warnings,
 		debateId,
+		focus_coverage: {
+			covered: coverage.covered,
+			missing: coverage.missing,
+			last_review_gate_ready: coverage.last_review_gate_ready,
+		},
+		debate_profile: debateProfile,
 	};
 }
 

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

@@ -0,0 +1,44 @@
+/**
+ * Shared Review Gate lane list for a round (gate + round-status).
+ */
+
+import type { PlanDebateFocus } 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,
+): DebateLaneKind[] {
+	const lanes: DebateLaneKind[] = ["validation-turn", "adversary-brief"];
+	if (roundIndex === 1) {
+		lanes.unshift("hypothesis-validation");
+	}
+	if (roundIndex >= 4 || debateRoundFocus === "quality") {
+		lanes.push("sprint-audit");
+	}
+	return lanes;
+}
+
+/** Relative artifact paths for lane YAML + review-round. */
+export function laneArtifactPathsForRound(
+	roundIndex: number,
+	debateRoundFocus?: PlanDebateFocus | null,
+): string[] {
+	const paths = lanesForRound(roundIndex, debateRoundFocus).map((lane) => {
+		switch (lane) {
+			case "hypothesis-validation":
+				return `artifacts/hypothesis-validation-r${roundIndex}.yaml`;
+			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`;
+		}
+	});
+	paths.push(`artifacts/review-round-r${roundIndex}.yaml`);
+	return paths;
+}

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

@@ -5,10 +5,18 @@
 import { constants } from "node:fs";
 import { access } from "node:fs/promises";
 import { join } from "node:path";
-import { type DebateLaneKind, laneArtifactPath } from "./plan-debate-lane.js";
+import { capsForDebate } from "./debate-bus-core.js";
+import {
+	type PlanDebateFocus,
+	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 {
 	getMessengerRoundState,
-	messengerRoundDebateReady,
+	loadMessengerState,
+	messengerRoundDialogueReady,
 } from "./plan-messenger.js";
 
 async function exists(path: string): Promise<boolean> {
@@ -20,39 +28,50 @@ async function exists(path: string): Promise<boolean> {
 	}
 }
 
-function lanesForRound(roundIndex: number): DebateLaneKind[] {
-	const lanes: DebateLaneKind[] = ["validation-turn", "adversary-brief"];
-	if (roundIndex === 1) lanes.unshift("hypothesis-validation");
-	if (roundIndex === 4) lanes.push("sprint-audit");
-	return lanes;
-}
-
 export interface RoundStatusResult {
 	round_index: number;
-	/** Lane YAML + messenger thread complete; spawn integrator next. */
+	/** Lane YAML + messenger dialogue complete; spawn integrator next. */
 	ready_for_integrator: boolean;
 	/** review-round-rN.yaml on disk (call harness_debate_submit_round if bus not updated). */
 	review_round_on_disk: boolean;
 	missing: string[];
 	next_tool?: string;
 	messenger: { ok: boolean; errors: string[] };
+	dialogue: { ok: boolean; errors: string[] };
+	unresolved_claim_ids: string[];
+	exchange_count: number;
+	debate_round_focus?: PlanDebateFocus | null;
 }
 
 export async function getPlanDebateRoundStatus(
 	runDir: string,
 	roundIndex: number,
+	runId?: string,
+	opts?: { debate_round_focus?: PlanDebateFocus },
 ): Promise<RoundStatusResult> {
+	const focus =
+		opts?.debate_round_focus ??
+		(await readDebateRoundFocus(runDir, roundIndex));
 	const missing: string[] = [];
-	for (const lane of lanesForRound(roundIndex)) {
+	for (const lane of lanesForRound(roundIndex, focus)) {
 		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"}`,
+		profile,
+	);
 	const roundState = await getMessengerRoundState(runDir, roundIndex);
-	const messenger = messengerRoundDebateReady(roundState, roundIndex === 4);
-	if (!messenger.ok) {
-		missing.push(...messenger.errors.map((e) => `messenger: ${e}`));
+	const dialogueOpts = {
+		max_exchanges_per_round: caps.max_exchanges_per_round,
+	};
+	const dialogue = messengerRoundDialogueReady(roundState, dialogueOpts);
+	if (!dialogue.ok) {
+		missing.push(...dialogue.errors.map((e) => `messenger: ${e}`));
 	}
 	const reviewRound = `artifacts/review-round-r${roundIndex}.yaml`;
 	const reviewRoundOnDisk = await exists(join(runDir, reviewRound));
@@ -62,14 +81,35 @@ export async function getPlanDebateRoundStatus(
 		next_tool = "subagent harness/planning/hypothesis-validator";
 	} else if (missing.some((m) => m.includes("validation-turn"))) {
 		next_tool = "subagent harness/planning/plan-evaluator";
+	} else if (
+		missing.some((m) => m.includes("adversary-brief")) &&
+		!roundState?.evaluator_posted
+	) {
+		next_tool = "subagent harness/planning/plan-evaluator";
 	} else if (missing.some((m) => m.includes("adversary-brief"))) {
 		next_tool =
 			"harness_messenger_read_round then subagent harness/planning/plan-adversary";
 	} else if (missing.some((m) => m.includes("sprint-audit"))) {
 		next_tool = "subagent harness/planning/sprint-contract-auditor";
-	} else if (!messenger.ok) {
+	} else if (
+		roundState &&
+		roundState.evaluator_posted &&
+		!roundState.adversary_posted
+	) {
+		next_tool =
+			"harness_messenger_read_round then subagent harness/planning/plan-adversary";
+	} else if (
+		roundState &&
+		roundState.unresolved_claim_ids.length > 0 &&
+		roundState.exchange_count < caps.max_exchanges_per_round
+	) {
+		const spawnEvaluator = roundState.exchange_count % 2 === 1;
+		next_tool = spawnEvaluator
+			? "harness_debate_advance_thread → harness_messenger_read_round → subagent harness/planning/plan-evaluator (clarification; address unresolved claim_ids)"
+			: "harness_debate_advance_thread → harness_messenger_read_round → subagent harness/planning/plan-adversary (counter or concede)";
+	} else if (!dialogue.ok) {
 		next_tool =
-			"harness_debate_apply_lane (evaluator/adversary) or re-spawn lane agent";
+			"harness_debate_advance_thread or harness_debate_apply_lane (evaluator/adversary)";
 	} else if (!reviewRoundOnDisk) {
 		next_tool =
 			"subagent harness/planning/review-integrator then harness_debate_submit_round";
@@ -78,10 +118,9 @@ export async function getPlanDebateRoundStatus(
 			"harness_debate_submit_round with integrator draft from review-round file";
 	}
 
+	const laneMissing = missing.filter((m) => !m.startsWith("messenger"));
 	const readyForIntegrator =
-		messenger.ok &&
-		missing.filter((m) => !m.startsWith("messenger")).length === 0 &&
-		!reviewRoundOnDisk;
+		dialogue.ok && laneMissing.length === 0 && !reviewRoundOnDisk;
 
 	return {
 		round_index: roundIndex,
@@ -89,6 +128,10 @@ export async function getPlanDebateRoundStatus(
 		review_round_on_disk: reviewRoundOnDisk,
 		missing,
 		next_tool,
-		messenger,
+		messenger: dialogue,
+		dialogue,
+		unresolved_claim_ids: roundState?.unresolved_claim_ids ?? [],
+		exchange_count: roundState?.exchange_count ?? 0,
+		debate_round_focus: focus,
 	};
 }

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

@@ -17,11 +17,15 @@ import {
 } from "node:fs/promises";
 import { join } from "node:path";
 import type { DebateParticipant } from "../../lib/debate-orchestrator-types.js";
+import type { DebateProfile } from "./plan-debate-eligibility.js";
+import type { PlanDebateFocus } from "./plan-debate-focus.js";
 
 export type MessengerMessageKind =
 	| "system"
 	| "claim"
 	| "rebuttal"
+	| "clarification"
+	| "counter"
 	| "integrate"
 	| "audit";
 
@@ -47,6 +51,8 @@ export interface MessengerRoundState {
 	integrator_posted: boolean;
 	claim_count: number;
 	rebuttal_count: number;
+	exchange_count: number;
+	unresolved_claim_ids: string[];
 }
 
 export interface MessengerState {
@@ -55,6 +61,8 @@ export interface MessengerState {
 	debate_id: string;
 	opened_at: string;
 	rounds: Record<string, MessengerRoundState>;
+	debate_profile?: DebateProfile;
+	required_focuses?: PlanDebateFocus[];
 }
 
 function messengerRoot(runDir: string): string {
@@ -71,7 +79,12 @@ function roundKey(roundIndex: number): string {
 
 export async function initPlanMessenger(
 	runDir: string,
-	opts: { runId: string; debateId: string },
+	opts: {
+		runId: string;
+		debateId: string;
+		debate_profile?: DebateProfile;
+		required_focuses?: PlanDebateFocus[];
+	},
 ): Promise<string> {
 	const root = messengerRoot(runDir);
 	await mkdir(join(root, "inbox"), { recursive: true });
@@ -82,6 +95,8 @@ export async function initPlanMessenger(
 		debate_id: opts.debateId,
 		opened_at: nowIso(),
 		rounds: {},
+		debate_profile: opts.debate_profile,
+		required_focuses: opts.required_focuses,
 	};
 	await writeFile(
 		join(root, "state.json"),
@@ -122,9 +137,51 @@ function defaultRoundState(roundIndex: number): MessengerRoundState {
 		integrator_posted: false,
 		claim_count: 0,
 		rebuttal_count: 0,
+		exchange_count: 0,
+		unresolved_claim_ids: [],
 	};
 }
 
+/** Recompute exchange + unresolved claim ids from a round transcript. */
+export function syncRoundStateFromTranscript(
+	round: MessengerRoundState,
+	messages: MessengerMessage[],
+): MessengerRoundState {
+	const claimed = new Set<string>();
+	const resolved = new Set<string>();
+	let exchange_count = 0;
+
+	for (const m of messages) {
+		if (m.from === "PlanEvaluatorAgent" && m.kind === "claim") {
+			round.evaluator_posted = true;
+			round.claim_count += m.claim_ids.length || 1;
+			for (const id of m.claim_ids) claimed.add(id);
+		}
+		if (m.from === "PlanAdversaryAgent" && m.kind === "rebuttal") {
+			round.adversary_posted = true;
+			round.rebuttal_count += m.in_reply_to.length || 1;
+			exchange_count += 1;
+		}
+		if (m.from === "PlanEvaluatorAgent" && m.kind === "clarification") {
+			exchange_count += 1;
+			for (const id of m.claim_ids) resolved.add(id);
+			for (const id of m.in_reply_to) resolved.add(id);
+		}
+		if (m.from === "PlanAdversaryAgent" && m.kind === "counter") {
+			exchange_count += 1;
+			for (const id of m.claim_ids) resolved.add(id);
+			for (const id of m.in_reply_to) resolved.add(id);
+		}
+		if (m.from === "ReviewIntegratorAgent" && m.kind === "integrate") {
+			round.integrator_posted = true;
+		}
+	}
+
+	round.exchange_count = exchange_count;
+	round.unresolved_claim_ids = [...claimed].filter((id) => !resolved.has(id));
+	return round;
+}
+
 export async function postMessengerMessage(
 	runDir: string,
 	msg: Omit<MessengerMessage, "schema_version" | "id" | "ts"> & {
@@ -172,19 +229,10 @@ export async function postMessengerMessage(
 		rounds: {},
 	};
 	const key = roundKey(full.round_index);
+	const messages = await readRoundTranscript(runDir, full.round_index);
+	messages.push(full);
 	const round = state.rounds[key] ?? defaultRoundState(full.round_index);
-	if (full.from === "PlanEvaluatorAgent" && full.kind === "claim") {
-		round.evaluator_posted = true;
-		round.claim_count += full.claim_ids.length || 1;
-	}
-	if (full.from === "PlanAdversaryAgent" && full.kind === "rebuttal") {
-		round.adversary_posted = true;
-		round.rebuttal_count += full.in_reply_to.length || 1;
-	}
-	if (full.from === "ReviewIntegratorAgent" && full.kind === "integrate") {
-		round.integrator_posted = true;
-	}
-	state.rounds[key] = round;
+	state.rounds[key] = syncRoundStateFromTranscript(round, messages);
 	await saveMessengerState(runDir, state);
 	return full;
 }
@@ -233,13 +281,22 @@ export async function getMessengerRoundState(
 ): Promise<MessengerRoundState | null> {
 	const state = await loadMessengerState(runDir);
 	if (!state) return null;
-	return state.rounds[roundKey(roundIndex)] ?? null;
+	const round = state.rounds[roundKey(roundIndex)];
+	if (!round) return null;
+	const transcript = await readRoundTranscript(runDir, roundIndex);
+	return syncRoundStateFromTranscript({ ...round }, transcript);
 }
 
-export function messengerRoundDebateReady(
+export interface MessengerDialogueOptions {
+	max_exchanges_per_round?: number;
+}
+
+/** Evaluator + adversary dialogue settled; safe to spawn integrator. */
+export function messengerRoundDialogueReady(
 	round: MessengerRoundState | null,
-	_requireSprintAudit: boolean,
+	opts: MessengerDialogueOptions = {},
 ): { ok: boolean; errors: string[] } {
+	const maxExchanges = opts.max_exchanges_per_round ?? 3;
 	const errors: string[] = [];
 	if (!round) {
 		errors.push("no messenger activity for this round");
@@ -257,7 +314,26 @@ export function messengerRoundDebateReady(
 	if (round.rebuttal_count < 1) {
 		errors.push("adversary must rebut at least one claim (in_reply_to)");
 	}
-	if (!round.integrator_posted) {
+	const dialogueSettled =
+		round.unresolved_claim_ids.length === 0 ||
+		round.exchange_count >= maxExchanges;
+	if (!dialogueSettled) {
+		errors.push(
+			`unresolved claims remain (${round.unresolved_claim_ids.join(", ")}) and exchange_count ${round.exchange_count} < ${maxExchanges}`,
+		);
+	}
+	return { ok: errors.length === 0, errors };
+}
+
+/** Full round ready for harness_debate_submit_round (includes integrator). */
+export function messengerRoundDebateReady(
+	round: MessengerRoundState | null,
+	_requireSprintAudit: boolean,
+	opts: MessengerDialogueOptions = {},
+): { ok: boolean; errors: string[] } {
+	const dialogue = messengerRoundDialogueReady(round, opts);
+	const errors = [...dialogue.errors];
+	if (!round?.integrator_posted) {
 		errors.push(
 			"ReviewIntegratorAgent must post integrate message before bus submit",
 		);

package/.pi/extensions/policy-gate.ts

@@ -243,7 +243,7 @@ export default function policyGate(pi: ExtensionAPI) {
 
 		const planPhaseHint =
 			state.phase === "plan"
-				? "\nPlan phase: scouts → decompose → hypothesis → stack-researcher → execution-plan-author → validate-plan-dag → 4-round plan debate → approve_plan → create_plan (YAML plan-packet.yaml). Post-execute: /harness-critic."
+				? "\nPlan phase: scouts → decompose → hypothesis → implementation-researcher + stack-researcher → execution-plan-author → validate-plan-dag → debate eligibility + Review Gate → approve_plan → create_plan (YAML plan-packet.yaml). Post-execute: /harness-critic."
 				: "";
 
 		return {

package/.pi/harness/README.md

@@ -30,7 +30,7 @@ under `.pi/extensions/` and auto-loaded through the package `pi.extensions`
 manifest (`package.json`).
 
 - `harness-run-context.ts` - active run + plan injection; short commands without run/plan args
-- `harness-live-widget.ts` - footer status (phase, plan ready, next command; no run id in UI)
+- `harness-live-widget.ts` - footer status (current/next phase + plain-language status hint; no run id in UI)
 - `policy-gate.ts` - phase state machine + plan-before-mutate enforcement
 - `budget-guard.ts` - hard-stop token budget checks + budget exhausted artifacts
 - `trace-recorder.ts` - append-only run traces + HarnessRunRecord + compact index

package/.pi/harness/agents.manifest.json

@@ -1,8 +1,8 @@
 {
 	"schema_version": "1.0.0",
 	"package": "ultimate-pi",
-	"package_version": "0.13.1",
-	"generated_at": "2026-05-18T17:22:10.311Z",
+	"package_version": "0.14.0",
+	"generated_at": "2026-05-19T10:53:28.359Z",
 	"agents": {
 		"pi-pi/agent-expert": {
 			"path": ".pi/agents/pi-pi/agent-expert.md",
@@ -78,35 +78,39 @@
 		},
 		"harness/planning/decompose": {
 			"path": ".pi/agents/harness/planning/decompose.md",
-			"sha256": "1b3f85d956d2e203ec87045a731c47f8b40f75b63fce8916fda91cefc39244a8"
+			"sha256": "5c3b983772d013741d50f39945bc77f178aa338aecab56b93c09216d72192c69"
 		},
 		"harness/planning/execution-plan-author": {
 			"path": ".pi/agents/harness/planning/execution-plan-author.md",
-			"sha256": "a69fb2e8bda9336e71ce9536071f9c8a2f4abd9d9d88930c6a8be29bdc9c5f62"
+			"sha256": "16f8800c50bcaf1b82ed9138889c8a0e538ee6a139aeae129ccd20cec2ec25f7"
 		},
 		"harness/planning/hypothesis-validator": {
 			"path": ".pi/agents/harness/planning/hypothesis-validator.md",
-			"sha256": "f75312439c441ccee72692d41f44b6e733df08e06c89e930740fc256bed3ba02"
+			"sha256": "9e68ec5d6aef96a3666c30227c3cbddf1aaed1182fdc94dbbd21ad3d48315ff2"
 		},
 		"harness/planning/hypothesis": {
 			"path": ".pi/agents/harness/planning/hypothesis.md",
 			"sha256": "b20c527d15c2243cd5d3a8f16cea6d44bdfd16e01915d42f3b830bf9938e5f8b"
 		},
+		"harness/planning/implementation-researcher": {
+			"path": ".pi/agents/harness/planning/implementation-researcher.md",
+			"sha256": "dbd1c4fc74d538b110d406febfd4603eebea77d82e8b367df4596ac7ff6e54cc"
+		},
 		"harness/planning/plan-adversary": {
 			"path": ".pi/agents/harness/planning/plan-adversary.md",
-			"sha256": "84c7fa63d38c39e32000c90093688a45bc2b96a2c6209037342222eae0c854f9"
+			"sha256": "7c14eaab65f356003ee2ff380f5d4e620170b5126daa67c3d226b12342f47bd2"
 		},
 		"harness/planning/plan-evaluator": {
 			"path": ".pi/agents/harness/planning/plan-evaluator.md",
-			"sha256": "580d8c7a31f7a6ecd9e627460459d600650580b5df63d129278beefd3f3e347c"
+			"sha256": "846575abe9df3e7e5be812c0c474989c1a9de8074a7884d77b9d3dd423643480"
 		},
 		"harness/planning/review-integrator": {
 			"path": ".pi/agents/harness/planning/review-integrator.md",
-			"sha256": "cd1e5d10f0cb8b7a4197d2e92489023c285e90e250f1badc371470165aeb8cfd"
+			"sha256": "bed43f3f049c279ac50a24bcffac1bbe46a8605d89c9cc6d0c3c6a87d488b1b8"
 		},
 		"harness/planning/scout-graphify": {
 			"path": ".pi/agents/harness/planning/scout-graphify.md",
-			"sha256": "8a5ff68306a5eedf1a62067ac8812eac4ac1fe2016cba63337ef4e90b5136e00"
+			"sha256": "7f385d5bda2fe04b9da52cb4cb9247324efd345579b483d3ad55a6abefad50d5"
 		},
 		"harness/planning/scout-semantic": {
 			"path": ".pi/agents/harness/planning/scout-semantic.md",
@@ -118,11 +122,11 @@
 		},
 		"harness/planning/sprint-contract-auditor": {
 			"path": ".pi/agents/harness/planning/sprint-contract-auditor.md",
-			"sha256": "f613a4fa937d76936fa01155d4e7956a81878f300100f99f6a78915b0af6f7c7"
+			"sha256": "d915274dc9b5addae5499bc2390b348eddeb8f133b526a816e23d0d19a2618bf"
 		},
 		"harness/planning/stack-researcher": {
 			"path": ".pi/agents/harness/planning/stack-researcher.md",
-			"sha256": "90e2ff1348f54bebc8c0392407bf1bb4d794c942fd8d6f342d80b191c945b34e"
+			"sha256": "fa228920abe2b66d4d8921c4a5d85593e3019a24bbe9ae512ed9149f235e3536"
 		}
 	}
 }

package/.pi/harness/docs/adrs/0034-darwin-plan-research-pipeline.md

@@ -13,9 +13,7 @@
    - `harness/planning/decompose` — DeepMind-style problem decomposition (`PlanDecompositionBrief`)
    - `harness/planning/hypothesis` — DARWIN hypothesis generation (`PlanHypothesisBrief`)
 2. **Parent maps hypothesis → PlanPacket** — `plan-packet.schema.json` unchanged; execution gating stable.
-3. **Parallel pre-approval reviews:**
-   - `harness/planning/plan-adversary` — execution risk on PlanPacket
-   - `harness/planning/hypothesis-eval` — blind self-eval (task + hypothesis only)
+3. **Review Gate (ADR 0035):** outcome-based debate with `hypothesis-validator` on R1 (blind — task + hypothesis only). Retired `hypothesis-eval` as a separate pre-approval agent.
 4. **`approve_plan` optional `research_brief`** — rendered in `plan-review.md`; not written to `plan-packet.json`.
 5. **`--quick`** still skips semantic scout only; never skips decompose/hypothesis.