ultimate-pi 0.16.0 → 0.18.0

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,29 @@ 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,
+	laneArtifactPathsForParallelProbesRound,
+	laneArtifactPathsForRound,
+} from "./plan-debate-lanes.js";
 import {
 	getMessengerRoundState,
 	loadMessengerState,
 	messengerRoundDebateReady,
 } from "./plan-messenger.js";
+import {
+	CONSOLIDATED_REVIEW_ARTIFACT,
+	isConsolidatedReviewStrategy,
+	isParallelProbesReviewStrategy,
+	planReviewGateStrategyFromEligibility,
+} from "./plan-review-gate.js";
 
 async function fileExists(path: string): Promise<boolean> {
 	try {
@@ -64,6 +75,7 @@ export interface PlanDebateGateResult {
 export async function validatePlanDebateGate(
 	projectRoot: string,
 	runId: string,
+	eligibility?: DebateEligibilityResult,
 ): Promise<PlanDebateGateResult> {
 	const errors: string[] = [];
 	const warnings: string[] = [];
@@ -77,6 +89,34 @@ 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 parallelProbes = isParallelProbesReviewStrategy(reviewStrategy);
 	const coverage = await getPlanFocusCoverage(runDir, { requiredFocuses });
 	const dialogueOpts = {
 		max_exchanges_per_round: caps.max_exchanges_per_round,
@@ -89,31 +129,73 @@ 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 (parallelProbes) {
+		for (const rel of laneArtifactPathsForParallelProbesRound()) {
+			const abs = join(runDir, rel);
+			if (!(await fileExists(abs))) {
+				errors.push(`missing ${rel}`);
+			}
+		}
+		const roundState = await getMessengerRoundState(runDir, 1);
+		const messengerCheck = messengerRoundDebateReady(
+			roundState,
+			false,
+			dialogueOpts,
+		);
+		if (!messengerCheck.ok) {
+			for (const e of messengerCheck.errors) {
+				errors.push(`parallel_probes round messenger: ${e}`);
+			}
+		}
+	} else 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 +285,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,57 @@ export function laneArtifactPathsForRound(
 	paths.push(`artifacts/review-round-r${roundIndex}.yaml`);
 	return paths;
 }
+
+/** Lanes for consolidated Review Gate (single round; blind verifier first). */
+export function lanesForConsolidatedRound(): DebateLaneKind[] {
+	return [
+		"hypothesis-validation",
+		"validation-turn",
+		"adversary-brief",
+		"sprint-audit",
+	];
+}
+
+export const PARALLEL_PROBES_REVIEW_ARTIFACT =
+	"artifacts/review-round-parallel-probes.yaml";
+
+/** Parallel plan-verify: inspector ∥ adversary (round 1), then integrator. */
+export function lanesForParallelProbesRound(): DebateLaneKind[] {
+	return ["hypothesis-validation", "validation-turn", "adversary-brief"];
+}
+
+export function laneArtifactPathsForParallelProbesRound(): string[] {
+	const roundIndex = 1;
+	return [
+		...lanesForParallelProbesRound().map((lane) => {
+			switch (lane) {
+				case "validation-turn":
+					return `artifacts/validation-turn-r${roundIndex}.yaml`;
+				case "adversary-brief":
+					return `artifacts/adversary-brief-r${roundIndex}.yaml`;
+				default:
+					return `artifacts/${lane}-r${roundIndex}.yaml`;
+			}
+		}),
+		PARALLEL_PROBES_REVIEW_ARTIFACT,
+	];
+}
+
+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,59 @@
+/**
+ * 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";
+}
+
+export { PARALLEL_PROBES_REVIEW_ARTIFACT } from "./plan-debate-lanes.js";
+
+export function isParallelProbesReviewStrategy(
+	strategy: PlanReviewGateStrategy,
+): boolean {
+	return strategy.mode === "parallel_probes";
+}
+
+/** 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/lib/posthog-client.ts

@@ -0,0 +1,76 @@
+/**
+ * PostHog client helpers — IPv4-first fetch for WSL2 / broken dual-stack DNS.
+ *
+ * Node's default fetch can ETIMEDOUT against *.posthog.com while curl succeeds.
+ * Use createPostHogFetch() (undici, family 4) for all posthog-node clients.
+ */
+
+import { Agent, fetch as undiciFetch } from "undici";
+
+const POSTHOG_HOST_RE = /(^https?:\/\/)?([^.]+\.)*posthog\.com(\/|$)/i;
+
+const ipv4Agent = new Agent({ connect: { family: 4 } });
+
+let fetchPatchInstalled = false;
+
+export function isPostHogHostUrl(url: string): boolean {
+	return POSTHOG_HOST_RE.test(url);
+}
+
+export function resolvePostHogHost(): string {
+	return process.env.POSTHOG_HOST?.trim() || "https://us.i.posthog.com";
+}
+
+/** Fetch that prefers IPv4 — fixes WSL2 ETIMEDOUT on us.i.posthog.com. */
+export function createPostHogFetch(): typeof fetch {
+	return ((input: Parameters<typeof fetch>[0], init?: RequestInit) =>
+		undiciFetch(
+			input as Parameters<typeof undiciFetch>[0],
+			{
+				...init,
+				dispatcher: ipv4Agent,
+			} as Parameters<typeof undiciFetch>[1],
+		)) as typeof fetch;
+}
+
+export function getPostHogClientOptions(): {
+	host: string;
+	fetch: typeof fetch;
+	requestTimeout: number;
+} {
+	return {
+		host: resolvePostHogHost(),
+		fetch: createPostHogFetch(),
+		requestTimeout: 30_000,
+	};
+}
+
+/**
+ * Patch global fetch so @posthog/pi (which uses default fetch) reaches PostHog on WSL2.
+ * Only PostHog hostnames are routed through the IPv4 agent.
+ */
+export function installPostHogFetchPatch(): void {
+	if (fetchPatchInstalled) return;
+	fetchPatchInstalled = true;
+
+	const nativeFetch = globalThis.fetch.bind(globalThis);
+	const posthogFetch = createPostHogFetch();
+
+	globalThis.fetch = ((
+		input: Parameters<typeof fetch>[0],
+		init?: RequestInit,
+	) => {
+		const url =
+			typeof input === "string"
+				? input
+				: input instanceof URL
+					? input.href
+					: typeof input === "object" && input !== null && "url" in input
+						? String((input as { url: string }).url)
+						: "";
+		if (url && isPostHogHostUrl(url)) {
+			return posthogFetch(input, init);
+		}
+		return nativeFetch(input, init);
+	}) as typeof fetch;
+}

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

@@ -9,6 +9,10 @@
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+	evaluateContextModeMutation,
+	isMutatingBash,
+} from "../lib/harness-context-mode-policy.js";
 import {
 	extractWritePathFromToolInput,
 	getLatestRunContext,
@@ -27,6 +31,7 @@ import {
 	userVisiblePromptSlice,
 	validatePlanPacket,
 } from "../lib/harness-run-context.js";
+import { bootstrapHarnessSubprocessFromEnv } from "./lib/harness-subprocess-bootstrap.js";
 
 type HarnessPhase = "plan" | "execute" | "evaluate" | "adversary" | "merge";
 
@@ -56,20 +61,6 @@ const PHASE_ORDER: HarnessPhase[] = [
 ];
 
 const MUTATING_TOOLS = new Set(["write", "edit"]);
-const BASH_MUTATION_PATTERNS = [
-	/\bgit\s+commit\b/i,
-	/\bgit\s+push\b/i,
-	/\bgit\s+merge\b/i,
-	/\bgit\s+rebase\b/i,
-	/\brm\s+(-rf?|--recursive)\b/i,
-	/\bmv\b/i,
-	/\bcp\b/i,
-	/\bmkdir\b/i,
-	/\bchmod\b/i,
-	/\bchown\b/i,
-	/\bsed\s+-i\b/i,
-	/\bperl\s+-i\b/i,
-];
 
 function nowIso(): string {
 	return new Date().toISOString();
@@ -94,10 +85,6 @@ function hasApprovedPlanSignal(prompt: string, entries: unknown[]): boolean {
 	return hasApprovedPlanSignalFromUserPrompt(prompt);
 }
 
-function isMutatingBash(command: string): boolean {
-	return BASH_MUTATION_PATTERNS.some((pattern) => pattern.test(command));
-}
-
 function getLatestPolicyStateFull(ctx: {
 	sessionManager: { getEntries(): unknown[] };
 }): PolicyState {
@@ -148,10 +135,15 @@ export default function policyGate(pi: ExtensionAPI) {
 
 	pi.on("session_start", async (_event, ctx) => {
 		state = getLatestPolicyStateFull(ctx);
+		const booted = await bootstrapHarnessSubprocessFromEnv(pi, ctx);
+		if (booted) {
+			state = getLatestPolicyStateFull(ctx);
+		}
 	});
 
 	pi.on("before_agent_start", async (event, ctx) => {
 		const userPrompt = userVisiblePromptSlice(event.prompt);
+		await bootstrapHarnessSubprocessFromEnv(pi, ctx);
 		const entries = ctx.sessionManager.getEntries();
 		state = getLatestPolicyStateFull(ctx);
 		const bootstrapPrompt = isHarnessBootstrapPrompt(userPrompt);
@@ -243,7 +235,7 @@ export default function policyGate(pi: ExtensionAPI) {
 
 		const planPhaseHint =
 			state.phase === "plan"
-				? "\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."
+				? "\nPlan phase: scouts (parallel) → decompose → hypothesis (sequential) → implementation-researcher + stack-researcher (parallel) → execution-plan-author → validate-plan-dag → debate eligibility + Review Gate → approve_plan → create_plan (YAML plan-packet.yaml). Post-execute: /harness-review."
 				: "";
 
 		return {
@@ -296,6 +288,19 @@ export default function policyGate(pi: ExtensionAPI) {
 			}
 		}
 
+		const ctxDecision = evaluateContextModeMutation(
+			event.toolName,
+			event.input as Record<string, unknown>,
+			state.phase,
+			{
+				aborted: state.aborted,
+				budgetBypass: state.budgetBypass,
+			},
+		);
+		if (ctxDecision.blocked) {
+			return { block: true, reason: ctxDecision.reason };
+		}
+
 		return undefined;
 	});
 

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,