ultimate-pi 0.14.0 → 0.16.0

package/.pi/extensions/lib/debate-bus-core.ts

@@ -11,6 +11,10 @@ import {
 	PLAN_DEBATE_PARTICIPANTS,
 	POST_EXECUTE_DEBATE_PARTICIPANTS,
 } from "../../lib/debate-orchestrator-types.js";
+import {
+	isHarnessBudgetEnforceOn,
+	shouldEmitBlockingBudgetExhausted,
+} from "../../lib/harness-budget-enforce.js";
 import {
 	type DebateState,
 	getDebateState,
@@ -19,6 +23,17 @@ import {
 	setDebateState,
 	setLastSeverity,
 } from "./debate-bus-state.js";
+import {
+	type DebateProfile,
+	PLAN_BUDGET_LIGHT,
+	PLAN_BUDGET_STANDARD,
+} from "./plan-debate-eligibility.js";
+import {
+	getPlanFocusCoverage,
+	PLAN_FOCUS_AREAS,
+	type PlanDebateFocus,
+	planDebateOutcomeComplete,
+} from "./plan-debate-focus.js";
 
 export type PolicyDecision =
 	| "pass"
@@ -64,13 +79,10 @@ const THRESHOLDS = {
 	architecture: 0.8,
 	test_integrity: 0.8,
 };
-const HARD_STOP_DEBATE_CAPS = process.env.HARNESS_DEBATE_HARD_STOP === "true";
+const HARD_STOP_DEBATE_CAPS =
+	process.env.HARNESS_DEBATE_HARD_STOP === "true" && isHarnessBudgetEnforceOn();
 
-const PLAN_BUDGET = {
-	max_rounds: 4,
-	round_token_cap: 2000,
-	debate_global_cap: 12000,
-} as const;
+const PLAN_BUDGET = PLAN_BUDGET_STANDARD;
 
 const AGGRESSIVE_BUDGET = {
 	max_rounds: 6,
@@ -88,16 +100,48 @@ function toSafeFloat(value: unknown): number {
 	return Math.max(0, Math.min(1, n));
 }
 
-export function capsForDebate(debateId: string): {
+export function capsForDebate(
+	debateId: string,
+	profile?: DebateProfile,
+): {
 	name: "plan" | "aggressive";
+	min_focus_rounds: number;
 	max_rounds: number;
+	max_exchanges_per_round: number;
 	round_token_cap: number;
 	debate_global_cap: number;
 } {
 	if (isPlanDebateId(debateId)) {
-		return { name: "plan", ...PLAN_BUDGET };
+		const active = profile ?? getDebateState()?.debate_profile ?? "standard";
+		const budget = active === "light" ? PLAN_BUDGET_LIGHT : PLAN_BUDGET;
+		const caps = { name: "plan" as const, ...budget };
+		if (!isHarnessBudgetEnforceOn()) {
+			return {
+				...caps,
+				max_rounds: 999,
+				max_exchanges_per_round: 99,
+				round_token_cap: caps.round_token_cap * 100,
+				debate_global_cap: caps.debate_global_cap * 100,
+			};
+		}
+		return caps;
 	}
-	return { name: "aggressive", ...AGGRESSIVE_BUDGET };
+	const caps = {
+		name: "aggressive" as const,
+		min_focus_rounds: 1,
+		max_exchanges_per_round: 1,
+		...AGGRESSIVE_BUDGET,
+	};
+	if (!isHarnessBudgetEnforceOn()) {
+		return {
+			...caps,
+			max_rounds: 999,
+			max_exchanges_per_round: 99,
+			round_token_cap: caps.round_token_cap * 100,
+			debate_global_cap: caps.debate_global_cap * 100,
+		};
+	}
+	return caps;
 }
 
 function participantAllowed(
@@ -161,23 +205,40 @@ export interface DebateBusHooks {
 	appendEntry: (customType: string, data: unknown) => void;
 }
 
+export interface OpenDebateBusOptions {
+	debate_profile?: DebateProfile;
+	required_focuses?: DebateState["required_focuses"];
+}
+
 export async function openDebateBus(
 	runId: string,
 	debateId: string,
 	hooks: DebateBusHooks,
+	opts?: OpenDebateBusOptions,
 ): Promise<DebateState> {
-	const caps = capsForDebate(debateId);
+	const profile = opts?.debate_profile ?? "standard";
+	const caps = capsForDebate(debateId, profile);
 	const debate_phase = debatePhaseFromId(debateId);
+	const defaultFocuses: PlanDebateFocus[] =
+		profile === "light" ? ["spec", "quality"] : [...PLAN_FOCUS_AREAS];
+	const required_focuses =
+		opts?.required_focuses && opts.required_focuses.length > 0
+			? opts.required_focuses
+			: defaultFocuses;
 	const next: DebateState = {
 		run_id: runId,
 		debate_id: debateId,
 		debate_phase,
 		round_count: 0,
 		budget_used: 0,
+		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,
 		last_review_gate_ready: false,
+		debate_profile: profile,
+		required_focuses,
 	};
 	setDebateState(next);
 	setLastSeverity({
@@ -199,6 +260,8 @@ export async function openDebateBus(
 			opened_at: nowIso(),
 			debate_phase,
 			budget_profile: caps.name,
+			debate_profile: profile,
+			required_focuses,
 		},
 	};
 	hooks.appendEntry("harness-debate-envelope", envelope);
@@ -230,7 +293,9 @@ async function emitBudgetExhausted(
 			budget_used: state.budget_used,
 			exhaustion_reason: reason,
 			caps: {
+				min_focus_rounds: state.min_focus_rounds,
 				max_rounds: state.max_rounds,
+				max_exchanges_per_round: state.max_exchanges_per_round,
 				round_token_cap: state.round_token_cap,
 				debate_global_cap: state.debate_global_cap,
 			},
@@ -240,7 +305,19 @@ async function emitBudgetExhausted(
 		},
 	};
 	hooks.appendEntry("harness-debate-envelope", envelope);
-	hooks.appendEntry("harness-budget-exhausted", envelope.payload);
+	if (shouldEmitBlockingBudgetExhausted()) {
+		hooks.appendEntry("harness-budget-exhausted", envelope.payload);
+	} else {
+		const telemetryPayload = {
+			...(envelope.payload as Record<string, unknown>),
+			telemetry_only: true,
+		};
+		hooks.appendEntry("harness-debate-budget-telemetry", telemetryPayload);
+		hooks.appendEntry("harness-budget-telemetry", {
+			...telemetryPayload,
+			source: "debate-bus",
+		});
+	}
 	await writeDebateEvent(state.debate_id, envelope);
 }
 
@@ -327,7 +404,9 @@ export async function acceptDebateRound(
 		token_usage: envelope.payload.token_usage,
 		budget_profile: {
 			name: profileName,
+			min_focus_rounds: state.min_focus_rounds,
 			max_rounds: state.max_rounds,
+			max_exchanges_per_round: state.max_exchanges_per_round,
 			round_token_cap: state.round_token_cap,
 			debate_global_cap: state.debate_global_cap,
 		},
@@ -363,12 +442,24 @@ export async function finalizeDebateConsensus(
 	);
 	const decision = decidePolicy(lastSeverity, evidenceScore);
 	const planPhase = state.debate_phase === "plan";
-	const evaluatorPassed = planPhase
-		? Boolean(state.last_review_gate_ready)
-		: true;
-	const debateComplete = planPhase
-		? state.round_count >= state.max_rounds
-		: state.round_count > 0;
+	let evaluatorPassed = true;
+	let debateComplete = state.round_count > 0;
+	if (planPhase) {
+		const runDir = join(process.cwd(), ".pi", "harness", "runs", state.run_id);
+		const requiredFocuses =
+			state.required_focuses && state.required_focuses.length > 0
+				? state.required_focuses
+				: undefined;
+		const coverage = await getPlanFocusCoverage(runDir, {
+			requiredFocuses,
+		});
+		evaluatorPassed =
+			coverage.last_review_gate_ready || Boolean(state.last_review_gate_ready);
+		debateComplete = planDebateOutcomeComplete(coverage, {
+			requiredFocuses,
+			minRoundIndex: state.min_focus_rounds,
+		});
+	}
 
 	const consensus = {
 		schema_version: "1.0.0",

package/.pi/extensions/lib/debate-bus-state.ts

@@ -3,6 +3,8 @@
  */
 
 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 DebatePhase = "plan" | "post_execute";
 
@@ -12,10 +14,14 @@ export interface DebateState {
 	debate_phase: DebatePhase;
 	round_count: number;
 	budget_used: number;
+	min_focus_rounds: number;
 	max_rounds: number;
+	max_exchanges_per_round: number;
 	round_token_cap: number;
 	debate_global_cap: number;
 	last_review_gate_ready?: boolean;
+	debate_profile?: DebateProfile;
+	required_focuses?: PlanDebateFocus[];
 }
 
 export interface SeverityScores {

package/.pi/extensions/lib/harness-subagent-policy.ts

@@ -2,6 +2,10 @@
  * Per-agent tool policy for harness/* subagents (defense in depth with frontmatter).
  */
 
+import {
+	isSubmitToolName,
+	SUBMIT_TOOLS_BY_AGENT,
+} from "./harness-subagent-submit-registry.js";
 import {
 	evaluateSubagentToolCall,
 	type ToolCallDecision,
@@ -107,6 +111,45 @@ export function evaluateHarnessSubagentToolCall(
 	}
 
 	if (!isHarnessPackageAgent(agentType)) {
+		if (
+			isSubmitToolName(toolName) &&
+			process.env.PI_HARNESS_SUBPROCESS !== "1"
+		) {
+			return {
+				action: "block",
+				reason:
+					"harness-subagent-policy: submit_* tools are subprocess-only; parent orchestrator must use harness_artifact_ready and write_harness_yaml for merges.",
+			};
+		}
+		return { action: "allow" };
+	}
+
+	if (isSubmitToolName(toolName)) {
+		if (process.env.PI_HARNESS_SUBPROCESS !== "1") {
+			return {
+				action: "block",
+				reason:
+					"harness-subagent-policy: submit_* tools are not available in the parent harness session.",
+			};
+		}
+		if (toolName === "submit_human_required") {
+			const kind = classifyHarnessAgent(agentType);
+			if (kind === "executor") {
+				return {
+					action: "block",
+					reason:
+						"submit_human_required is not available for harness/executor.",
+				};
+			}
+			return { action: "allow" };
+		}
+		const allowed = SUBMIT_TOOLS_BY_AGENT[agentType];
+		if (!allowed?.has(toolName)) {
+			return {
+				action: "block",
+				reason: `harness-subagent-policy: ${toolName} is not allowed for ${agentType}.`,
+			};
+		}
 		return { action: "allow" };
 	}
 
@@ -153,6 +196,8 @@ export function evaluateHarnessSubagentToolCall(
 	return { action: "allow" };
 }
 
+export { isSubmitToolName } from "./harness-subagent-submit-registry.js";
+
 export function harnessSubagentPhaseHint(agentType: string): string | null {
 	if (isHarnessPlanningAgent(agentType)) {
 		return "plan";

package/.pi/extensions/lib/harness-subagent-submit-pipeline.ts

@@ -0,0 +1,82 @@
+/**
+ * Shared write pipeline for harness subagent submit tools.
+ */
+
+import { mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { validateAgainstHarnessSchema } from "../../lib/harness-schema-validate.js";
+import { resolveGuardedRunDir } from "../../lib/harness-subagent-submit-path.js";
+import { writeYamlFile } from "../../lib/harness-yaml.js";
+import {
+	resolveArtifactRelPath,
+	type SubmitToolSpec,
+} from "./harness-subagent-submit-registry.js";
+import {
+	type ApplyDebateLaneResult,
+	applyDebateLaneFromDoc,
+} from "./plan-debate-lane.js";
+
+export interface SubmitPipelineResult {
+	ok: boolean;
+	artifact_path?: string;
+	validation_errors?: string[];
+	lane_result?: ApplyDebateLaneResult;
+	human_required?: boolean;
+}
+
+export async function executeSubmitPipeline(opts: {
+	projectRoot: string;
+	specsDir: string;
+	spec: SubmitToolSpec;
+	agentId: string;
+	document: Record<string, unknown>;
+	runId: string;
+	runDirEnv?: string;
+}): Promise<SubmitPipelineResult> {
+	const runResolved = await resolveGuardedRunDir({
+		projectRoot: opts.projectRoot,
+		runId: opts.runId,
+		runDirEnv: opts.runDirEnv,
+	});
+	if (!runResolved.ok) {
+		return { ok: false, validation_errors: [runResolved.error] };
+	}
+
+	const validation = await validateAgainstHarnessSchema(
+		opts.specsDir,
+		opts.spec.schemaFile,
+		opts.document,
+	);
+	if (!validation.ok) {
+		return { ok: false, validation_errors: validation.errors };
+	}
+
+	const relPath = resolveArtifactRelPath(opts.spec, opts.document);
+	const absPath = join(runResolved.runDir, relPath);
+	await mkdir(dirname(absPath), { recursive: true });
+	await writeYamlFile(absPath, opts.document);
+
+	let laneResult: ApplyDebateLaneResult | undefined;
+	if (opts.spec.debateLane) {
+		laneResult = await applyDebateLaneFromDoc({
+			runDir: runResolved.runDir,
+			lane: opts.spec.debateLane,
+			doc: opts.document,
+		});
+		if (!laneResult.ok) {
+			return {
+				ok: false,
+				artifact_path: relPath,
+				validation_errors: laneResult.errors,
+				lane_result: laneResult,
+			};
+		}
+	}
+
+	return {
+		ok: true,
+		artifact_path: relPath,
+		lane_result: laneResult,
+		human_required: opts.spec.humanRequired === true,
+	};
+}

package/.pi/extensions/lib/harness-subagent-submit-registry.ts

@@ -0,0 +1,172 @@
+/**
+ * Registry: submit tool name → agent allowlist, schema, artifact path.
+ */
+
+import type { DebateLaneKind } from "./plan-debate-lane.js";
+
+export interface SubmitToolSpec {
+	toolName: string;
+	agents: readonly string[];
+	schemaFile: string;
+	artifactPath: string | ((doc: Record<string, unknown>) => string);
+	debateLane?: DebateLaneKind;
+	humanRequired?: boolean;
+}
+
+function roundPath(prefix: string, doc: Record<string, unknown>): string {
+	const r =
+		typeof doc.round_index === "number"
+			? doc.round_index
+			: Number(doc.round_index ?? 1);
+	return `artifacts/${prefix}-r${r}.yaml`;
+}
+
+export const SUBMIT_TOOL_SPECS: readonly SubmitToolSpec[] = [
+	{
+		toolName: "submit_scout_findings",
+		agents: [
+			"harness/planning/scout-graphify",
+			"harness/planning/scout-structure",
+			"harness/planning/scout-semantic",
+		],
+		schemaFile: "plan-scout-findings.schema.json",
+		artifactPath: (doc) => {
+			const lane =
+				typeof doc.lane === "string"
+					? doc.lane
+					: typeof doc.scout_lane === "string"
+						? doc.scout_lane
+						: "graphify";
+			return `artifacts/scout-${lane}.yaml`;
+		},
+	},
+	{
+		toolName: "submit_decomposition_brief",
+		agents: ["harness/planning/decompose"],
+		schemaFile: "plan-decomposition-brief.schema.json",
+		artifactPath: "artifacts/decomposition.yaml",
+	},
+	{
+		toolName: "submit_hypothesis_brief",
+		agents: ["harness/planning/hypothesis"],
+		schemaFile: "plan-hypothesis-brief.schema.json",
+		artifactPath: "artifacts/hypothesis.yaml",
+	},
+	{
+		toolName: "submit_implementation_research",
+		agents: ["harness/planning/implementation-researcher"],
+		schemaFile: "plan-implementation-research-brief.schema.json",
+		artifactPath: "artifacts/implementation-research.yaml",
+	},
+	{
+		toolName: "submit_stack_brief",
+		agents: ["harness/planning/stack-researcher"],
+		schemaFile: "plan-stack-brief.schema.json",
+		artifactPath: "artifacts/stack.yaml",
+	},
+	{
+		toolName: "submit_execution_plan_brief",
+		agents: ["harness/planning/execution-plan-author"],
+		schemaFile: "plan-execution-plan-brief.schema.json",
+		artifactPath: "artifacts/execution-plan-draft.yaml",
+	},
+	{
+		toolName: "submit_hypothesis_validation",
+		agents: ["harness/planning/hypothesis-validator"],
+		schemaFile: "plan-hypothesis-eval.schema.json",
+		artifactPath: (doc) => roundPath("hypothesis-validation", doc),
+		debateLane: "hypothesis-validation",
+	},
+	{
+		toolName: "submit_validation_turn",
+		agents: ["harness/planning/plan-evaluator"],
+		schemaFile: "plan-validation-turn.schema.json",
+		artifactPath: (doc) => roundPath("validation-turn", doc),
+		debateLane: "validation-turn",
+	},
+	{
+		toolName: "submit_adversary_brief",
+		agents: ["harness/planning/plan-adversary"],
+		schemaFile: "plan-adversary-brief.schema.json",
+		artifactPath: (doc) => roundPath("adversary-brief", doc),
+		debateLane: "adversary-brief",
+	},
+	{
+		toolName: "submit_sprint_audit",
+		agents: ["harness/planning/sprint-contract-auditor"],
+		schemaFile: "plan-sprint-audit-turn.schema.json",
+		artifactPath: (doc) => roundPath("sprint-audit", doc),
+		debateLane: "sprint-audit",
+	},
+	{
+		toolName: "submit_review_round_draft",
+		agents: ["harness/planning/review-integrator"],
+		schemaFile: "plan-review-round-draft.schema.json",
+		artifactPath: (doc) => roundPath("review-round-draft", doc),
+	},
+	{
+		toolName: "submit_executor_handoff",
+		agents: ["harness/executor"],
+		schemaFile: "harness-executor-handoff.schema.json",
+		artifactPath: "handoff/executor-summary.yaml",
+	},
+	{
+		toolName: "submit_eval_verdict",
+		agents: ["harness/evaluator"],
+		schemaFile: "eval-verdict.schema.json",
+		artifactPath: "artifacts/eval-verdict.yaml",
+	},
+	{
+		toolName: "submit_adversary_report",
+		agents: ["harness/adversary"],
+		schemaFile: "adversary-report.schema.json",
+		artifactPath: "artifacts/adversary-report.yaml",
+	},
+	{
+		toolName: "submit_human_required",
+		agents: ["harness/planning/decompose", "harness/planning/hypothesis"],
+		schemaFile: "harness-human-required.schema.json",
+		artifactPath: "artifacts/human-required.yaml",
+		humanRequired: true,
+	},
+] as const;
+
+export const SUBMIT_TOOLS_BY_AGENT: Readonly<
+	Record<string, ReadonlySet<string>>
+> = (() => {
+	const map = new Map<string, Set<string>>();
+	for (const spec of SUBMIT_TOOL_SPECS) {
+		for (const agent of spec.agents) {
+			if (!map.has(agent)) map.set(agent, new Set());
+			map.get(agent)?.add(spec.toolName);
+		}
+	}
+	return Object.fromEntries(map.entries());
+})();
+
+export function specForSubmitTool(
+	toolName: string,
+): SubmitToolSpec | undefined {
+	return SUBMIT_TOOL_SPECS.find((s) => s.toolName === toolName);
+}
+
+export function resolveArtifactRelPath(
+	spec: SubmitToolSpec,
+	doc: Record<string, unknown>,
+): string {
+	if (typeof spec.artifactPath === "function") {
+		return spec.artifactPath(doc);
+	}
+	return spec.artifactPath;
+}
+
+export function isSubmitToolName(toolName: string): boolean {
+	return toolName.startsWith("submit_");
+}
+
+export const DEBATE_AGENT_SUBMIT_TOOL: Readonly<Record<string, string>> = {
+	"harness/planning/hypothesis-validator": "submit_hypothesis_validation",
+	"harness/planning/plan-evaluator": "submit_validation_turn",
+	"harness/planning/plan-adversary": "submit_adversary_brief",
+	"harness/planning/sprint-contract-auditor": "submit_sprint_audit",
+};

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,8 @@ import {
 	type HarnessSubagentsOptions,
 	type SpawnAuthForward,
 } from "../../../vendor/pi-subagents/src/subagents.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 {
@@ -58,8 +61,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,

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

@@ -160,6 +160,62 @@ export function formatResearchBriefMarkdown(
 		}
 	}
 
+	const impl = asRecord(research.implementation);
+	if (impl) {
+		lines.push("## Phase 3.5 — Implementation research");
+		lines.push("");
+		const framing = str(impl.problem_framing);
+		if (framing) {
+			lines.push("**Problem framing:**");
+			lines.push("");
+			lines.push(framing);
+			lines.push("");
+		}
+		const rec = asRecord(impl.recommended_approach);
+		if (rec) {
+			const summary = str(rec.summary);
+			const conf = str(rec.recommended_approach_confidence);
+			if (summary) {
+				lines.push(
+					`**Recommended approach**${conf ? ` (${conf} confidence)` : ""}:`,
+				);
+				lines.push("");
+				lines.push(summary);
+				lines.push("");
+			}
+			const rationale = str(rec.confidence_rationale);
+			if (rationale) {
+				lines.push(`*Rationale:* ${rationale}`);
+				lines.push("");
+			}
+		}
+		const patterns = Array.isArray(impl.solution_patterns)
+			? impl.solution_patterns
+			: [];
+		if (patterns.length) {
+			lines.push("**Solution patterns:**");
+			for (const p of patterns) {
+				const pat = asRecord(p);
+				const name = pat ? str(pat.name) : null;
+				const fit = pat ? str(pat.fit) : null;
+				if (name) lines.push(`- **${name}**${fit ? `: ${fit}` : ""}`);
+			}
+			lines.push("");
+		}
+		const openQs = strList(impl.open_questions);
+		if (openQs.length) {
+			lines.push("**Open questions:**");
+			for (const q of openQs) lines.push(`- ${q}`);
+			lines.push("");
+		}
+		const anti = strList(impl.anti_patterns);
+		if (anti.length) {
+			lines.push("**Anti-patterns:**");
+			for (const a of anti) lines.push(`- ${a}`);
+			lines.push("");
+		}
+	}
+
 	if (evalBrief) {
 		lines.push("## Self-evaluation");
 		lines.push("");

package/.pi/extensions/lib/plan-approval/types.ts

@@ -13,6 +13,7 @@ export interface PlanResearchBrief {
 	hypothesis?: Record<string, unknown> | null;
 	eval?: Record<string, unknown> | null;
 	stack?: Record<string, unknown> | null;
+	implementation?: Record<string, unknown> | null;
 	debate?: {
 		rounds?: Record<string, unknown>[];
 		hypothesis_validations?: Record<string, unknown>[];