ultimate-pi 0.13.1 → 0.15.0

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

@@ -0,0 +1,352 @@
+/**
+ * pi-messenger-style plan debate transport — per-agent inboxes + round threads.
+ *
+ * Layout under `.pi/harness/runs/<run_id>/debate-messenger/`:
+ *   inbox/<AgentLabel>/<seq>-<kind>.json
+ *   threads/round-<N>/transcript.jsonl
+ *   state.json
+ */
+
+import { randomUUID } from "node:crypto";
+import {
+	appendFile,
+	mkdir,
+	readdir,
+	readFile,
+	writeFile,
+} 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";
+
+export interface MessengerMessage {
+	schema_version: "1.0.0";
+	id: string;
+	ts: string;
+	from: DebateParticipant | "system";
+	to: Array<DebateParticipant | "broadcast">;
+	kind: MessengerMessageKind;
+	round_index: number;
+	in_reply_to: string[];
+	body: string;
+	claim_ids: string[];
+	evidence_refs: string[];
+	artifact_path?: string;
+}
+
+export interface MessengerRoundState {
+	round_index: number;
+	evaluator_posted: boolean;
+	adversary_posted: boolean;
+	integrator_posted: boolean;
+	claim_count: number;
+	rebuttal_count: number;
+	exchange_count: number;
+	unresolved_claim_ids: string[];
+}
+
+export interface MessengerState {
+	schema_version: "1.0.0";
+	run_id: string;
+	debate_id: string;
+	opened_at: string;
+	rounds: Record<string, MessengerRoundState>;
+	debate_profile?: DebateProfile;
+	required_focuses?: PlanDebateFocus[];
+}
+
+function messengerRoot(runDir: string): string {
+	return join(runDir, "debate-messenger");
+}
+
+function nowIso(): string {
+	return new Date().toISOString();
+}
+
+function roundKey(roundIndex: number): string {
+	return String(roundIndex);
+}
+
+export async function initPlanMessenger(
+	runDir: 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 });
+	await mkdir(join(root, "threads"), { recursive: true });
+	const state: MessengerState = {
+		schema_version: "1.0.0",
+		run_id: opts.runId,
+		debate_id: opts.debateId,
+		opened_at: nowIso(),
+		rounds: {},
+		debate_profile: opts.debate_profile,
+		required_focuses: opts.required_focuses,
+	};
+	await writeFile(
+		join(root, "state.json"),
+		`${JSON.stringify(state, null, 2)}\n`,
+		"utf-8",
+	);
+	return root;
+}
+
+export async function loadMessengerState(
+	runDir: string,
+): Promise<MessengerState | null> {
+	const path = join(messengerRoot(runDir), "state.json");
+	try {
+		const raw = await readFile(path, "utf-8");
+		return JSON.parse(raw) as MessengerState;
+	} catch {
+		return null;
+	}
+}
+
+async function saveMessengerState(
+	runDir: string,
+	state: MessengerState,
+): Promise<void> {
+	await writeFile(
+		join(messengerRoot(runDir), "state.json"),
+		`${JSON.stringify(state, null, 2)}\n`,
+		"utf-8",
+	);
+}
+
+function defaultRoundState(roundIndex: number): MessengerRoundState {
+	return {
+		round_index: roundIndex,
+		evaluator_posted: false,
+		adversary_posted: false,
+		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"> & {
+		id?: string;
+		ts?: string;
+	},
+): Promise<MessengerMessage> {
+	const root = messengerRoot(runDir);
+	const full: MessengerMessage = {
+		schema_version: "1.0.0",
+		id: msg.id ?? randomUUID(),
+		ts: msg.ts ?? nowIso(),
+		from: msg.from,
+		to: msg.to,
+		kind: msg.kind,
+		round_index: msg.round_index,
+		in_reply_to: msg.in_reply_to ?? [],
+		body: msg.body,
+		claim_ids: msg.claim_ids ?? [],
+		evidence_refs: msg.evidence_refs ?? [],
+		artifact_path: msg.artifact_path,
+	};
+
+	const inboxDir = join(root, "inbox", full.from);
+	await mkdir(inboxDir, { recursive: true });
+	const inboxName = `${full.round_index.toString().padStart(2, "0")}-${full.kind}-${full.id.slice(0, 8)}.json`;
+	await writeFile(
+		join(inboxDir, inboxName),
+		`${JSON.stringify(full, null, 2)}\n`,
+	);
+
+	const threadDir = join(root, "threads", `round-${full.round_index}`);
+	await mkdir(threadDir, { recursive: true });
+	await appendFile(
+		join(threadDir, "transcript.jsonl"),
+		`${JSON.stringify(full)}\n`,
+		"utf-8",
+	);
+
+	const state = (await loadMessengerState(runDir)) ?? {
+		schema_version: "1.0.0",
+		run_id: "",
+		debate_id: "",
+		opened_at: nowIso(),
+		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);
+	state.rounds[key] = syncRoundStateFromTranscript(round, messages);
+	await saveMessengerState(runDir, state);
+	return full;
+}
+
+export async function readRoundTranscript(
+	runDir: string,
+	roundIndex: number,
+): Promise<MessengerMessage[]> {
+	const path = join(
+		messengerRoot(runDir),
+		"threads",
+		`round-${roundIndex}`,
+		"transcript.jsonl",
+	);
+	try {
+		const raw = await readFile(path, "utf-8");
+		return raw
+			.split("\n")
+			.filter((line) => line.trim())
+			.map((line) => JSON.parse(line) as MessengerMessage);
+	} catch {
+		return [];
+	}
+}
+
+export function formatTranscriptForSpawn(
+	messages: MessengerMessage[],
+	maxChars = 12000,
+): string {
+	const lines = messages.map((m) => {
+		const reply =
+			m.in_reply_to.length > 0 ? ` (re: ${m.in_reply_to.join(", ")})` : "";
+		const claims = m.claim_ids.length > 0 ? ` [${m.claim_ids.join(", ")}]` : "";
+		return `[${m.from}/${m.kind}${claims}${reply}] ${m.body}`;
+	});
+	let text = lines.join("\n\n");
+	if (text.length > maxChars) {
+		text = `${text.slice(0, maxChars)}\n\n…(transcript truncated)`;
+	}
+	return text || "(empty thread — post evaluator claims before adversary)";
+}
+
+export async function getMessengerRoundState(
+	runDir: string,
+	roundIndex: number,
+): Promise<MessengerRoundState | null> {
+	const state = await loadMessengerState(runDir);
+	if (!state) return null;
+	const round = state.rounds[roundKey(roundIndex)];
+	if (!round) return null;
+	const transcript = await readRoundTranscript(runDir, roundIndex);
+	return syncRoundStateFromTranscript({ ...round }, transcript);
+}
+
+export interface MessengerDialogueOptions {
+	max_exchanges_per_round?: number;
+}
+
+/** Evaluator + adversary dialogue settled; safe to spawn integrator. */
+export function messengerRoundDialogueReady(
+	round: MessengerRoundState | null,
+	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");
+		return { ok: false, errors };
+	}
+	if (!round.evaluator_posted) {
+		errors.push("PlanEvaluatorAgent has not posted claims to the thread");
+	}
+	if (!round.adversary_posted) {
+		errors.push("PlanAdversaryAgent has not posted rebuttals to the thread");
+	}
+	if (round.claim_count < 1) {
+		errors.push("round thread has no claim_ids");
+	}
+	if (round.rebuttal_count < 1) {
+		errors.push("adversary must rebut at least one claim (in_reply_to)");
+	}
+	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",
+		);
+	}
+	return { ok: errors.length === 0, errors };
+}
+
+export async function listInboxAgents(runDir: string): Promise<string[]> {
+	const inbox = join(messengerRoot(runDir), "inbox");
+	try {
+		const entries = await readdir(inbox, { withFileTypes: true });
+		return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+	} catch {
+		return [];
+	}
+}

package/.pi/extensions/lib/plan-review-integrator-rules.ts

@@ -0,0 +1,119 @@
+/**
+ * P1 — integrator draft rules (disputes required when checks fail).
+ */
+
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+
+export interface IntegratorValidationResult {
+	ok: boolean;
+	review_gate_ready: boolean;
+	errors: string[];
+	warnings: string[];
+}
+
+function hasFailedChecks(doc: Record<string, unknown>): boolean {
+	const pe = doc.plan_evaluation as Record<string, unknown> | undefined;
+	if (!pe) return false;
+	for (const [key, val] of Object.entries(pe)) {
+		if (key === "source") continue;
+		const block = val as Record<string, unknown> | undefined;
+		if (block && block.passes === false) return true;
+		const checks = block?.issues as unknown[] | undefined;
+		if (Array.isArray(checks) && checks.length > 0) {
+			// issues on passing blocks are warnings only
+		}
+	}
+	const hv = doc.hypothesis_validation as Record<string, unknown> | undefined;
+	if (hv?.revision_recommended === true) return true;
+	if (
+		hv?.relevance &&
+		(hv.relevance as { passes?: boolean }).passes === false
+	) {
+		return true;
+	}
+	return false;
+}
+
+function adversarySeverityHigh(doc: Record<string, unknown>): boolean {
+	const ab = doc.adversary_brief as Record<string, unknown> | undefined;
+	const sev = String(ab?.severity ?? "").toLowerCase();
+	return sev === "high" || sev === "critical";
+}
+
+export function validateIntegratorDraft(
+	draft: Record<string, unknown>,
+	opts?: { validationTurn?: Record<string, unknown> | null },
+): IntegratorValidationResult {
+	const errors: string[] = [];
+	const warnings: string[] = [];
+	const disputes = Array.isArray(draft.disputes)
+		? (draft.disputes as string[]).filter(Boolean)
+		: [];
+	const unresolved = (
+		draft.review_integrator_summary as Record<string, unknown> | undefined
+	)?.debate_health as Record<string, unknown> | undefined;
+	const unresolvedTensions = Array.isArray(unresolved?.unresolved_tensions)
+		? (unresolved.unresolved_tensions as string[])
+		: [];
+	let review_gate_ready = draft.review_gate_ready === true;
+
+	const failedInDraft = hasFailedChecks(draft);
+	const failedInTurn =
+		opts?.validationTurn?.overall_ready === false ||
+		(Array.isArray(opts?.validationTurn?.checks) &&
+			(opts.validationTurn.checks as { status?: string }[]).some(
+				(c) => c.status === "fail",
+			));
+
+	if (failedInDraft || failedInTurn) {
+		if (disputes.length === 0) {
+			errors.push(
+				"evaluator reported failed/warn checks but disputes[] is empty — document tension",
+			);
+			review_gate_ready = false;
+		}
+		if (unresolvedTensions.length === 0 && disputes.length > 0) {
+			warnings.push(
+				"disputes present but unresolved_tensions empty — prefer listing open items",
+			);
+		}
+	}
+
+	if (adversarySeverityHigh(draft) && disputes.length === 0) {
+		errors.push("adversary severity is high but no disputes recorded");
+		review_gate_ready = false;
+	}
+
+	if (
+		review_gate_ready &&
+		(failedInDraft || failedInTurn) &&
+		disputes.length === 0
+	) {
+		errors.push(
+			"review_gate_ready cannot be true without disputes when checks fail",
+		);
+		review_gate_ready = false;
+	}
+
+	return {
+		ok: errors.length === 0,
+		review_gate_ready,
+		errors,
+		warnings,
+	};
+}
+
+export async function loadValidationTurnYaml(
+	runDir: string,
+	roundIndex: number,
+): Promise<Record<string, unknown> | null> {
+	const path = join(runDir, "artifacts", `validation-turn-r${roundIndex}.yaml`);
+	try {
+		const raw = await readFile(path, "utf-8");
+		return parseYaml(raw) as Record<string, unknown>;
+	} catch {
+		return null;
+	}
+}

package/.pi/extensions/lib/plan-scope-guard.ts

@@ -0,0 +1,89 @@
+/**
+ * P2 — detect material scope drift between task_summary and decomposition.
+ */
+
+export interface ScopeGuardResult {
+	material_drift: boolean;
+	overlap_score: number;
+	summary: string;
+	suggested_ask_user: boolean;
+}
+
+const PRODUCT_OS_MARKERS = [
+	"product os",
+	"product operating system",
+	"knowledge base",
+	"multi-source",
+	"synthesiz",
+	"papers",
+	"youtube",
+	"transcripts",
+	"news",
+	"books",
+	"decisions",
+];
+
+const INFRA_MARKERS = [
+	"cron",
+	"systemd",
+	"graphify add",
+	"graphify update",
+	"ingest",
+	"lockfile",
+	"feeds.yaml",
+	"polling",
+	"timer",
+];
+
+function tokenize(text: string): Set<string> {
+	const lower = text.toLowerCase();
+	const words = lower.match(/[a-z][a-z0-9_-]{2,}/g) ?? [];
+	return new Set(words);
+}
+
+function markerHits(text: string, markers: string[]): number {
+	const lower = text.toLowerCase();
+	return markers.filter((m) => lower.includes(m)).length;
+}
+
+export function assessPlanScopeDrift(
+	taskSummary: string,
+	decompositionText: string,
+): ScopeGuardResult {
+	const taskTokens = tokenize(taskSummary);
+	const decompTokens = tokenize(decompositionText);
+	let overlap = 0;
+	for (const t of taskTokens) {
+		if (decompTokens.has(t)) overlap += 1;
+	}
+	const overlapScore = taskTokens.size === 0 ? 1 : overlap / taskTokens.size;
+
+	const taskProduct = markerHits(taskSummary, PRODUCT_OS_MARKERS);
+	const decompProduct = markerHits(decompositionText, PRODUCT_OS_MARKERS);
+	const _taskInfra = markerHits(taskSummary, INFRA_MARKERS);
+	const decompInfra = markerHits(decompositionText, INFRA_MARKERS);
+
+	const productIntent = taskProduct >= 2;
+	const narrowedToInfra =
+		productIntent && decompInfra >= 3 && decompProduct < taskProduct;
+	const lowOverlap = productIntent && overlapScore < 0.08;
+
+	const material_drift = narrowedToInfra || lowOverlap;
+	let summary: string;
+	if (narrowedToInfra) {
+		summary =
+			"Decomposition reads as infrastructure/cron/graphify-ingest while the task asked for a broader product-OS knowledge base — confirm scope with the user.";
+	} else if (lowOverlap) {
+		summary =
+			"Decomposition shares almost no vocabulary with the task summary — verify the plan targets the right problem.";
+	} else {
+		summary = "Scope alignment looks acceptable.";
+	}
+
+	return {
+		material_drift,
+		overlap_score: overlapScore,
+		summary,
+		suggested_ask_user: material_drift,
+	};
+}

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.11.0",
-	"generated_at": "2026-05-18T09:43:44.563Z",
+	"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,39 +78,43 @@
 		},
 		"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": "685926c638ae1377361d7cafda5e400be19cb3880510d8f6d389a5876647575f"
+			"sha256": "7c14eaab65f356003ee2ff380f5d4e620170b5126daa67c3d226b12342f47bd2"
 		},
 		"harness/planning/plan-evaluator": {
 			"path": ".pi/agents/harness/planning/plan-evaluator.md",
-			"sha256": "44fd52389d7e43dd5093653cba9694900561318ee5f00e3bc05c3ecef5d43621"
+			"sha256": "846575abe9df3e7e5be812c0c474989c1a9de8074a7884d77b9d3dd423643480"
 		},
 		"harness/planning/review-integrator": {
 			"path": ".pi/agents/harness/planning/review-integrator.md",
-			"sha256": "d0e8214539d0a78b9e5add70e61dd4e4de36def64172cda18d9b70727e7600ca"
+			"sha256": "bed43f3f049c279ac50a24bcffac1bbe46a8605d89c9cc6d0c3c6a87d488b1b8"
 		},
 		"harness/planning/scout-graphify": {
 			"path": ".pi/agents/harness/planning/scout-graphify.md",
-			"sha256": "b59916a26afccfe105e29c0bd8637ac54275e8afef1c6cc88a58bd05b0325473"
+			"sha256": "7f385d5bda2fe04b9da52cb4cb9247324efd345579b483d3ad55a6abefad50d5"
 		},
 		"harness/planning/scout-semantic": {
 			"path": ".pi/agents/harness/planning/scout-semantic.md",
-			"sha256": "47b7ea3e65b20a65e6d0ff11b6d5daff59b47a9ed618b8a3b6282f2eb0460572"
+			"sha256": "36bd424ebd422bda82bd447b22f591f99f32ec897ea43f385586119da5c26caa"
 		},
 		"harness/planning/scout-structure": {
 			"path": ".pi/agents/harness/planning/scout-structure.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.