ultimate-pi 0.18.0 → 0.18.1

package/.pi/extensions/harness-run-context.ts

@@ -5,8 +5,15 @@
  * in before_agent_start so trace-recorder reuses it on agent_start.
  */
 
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import {
+	mkdir,
+	readdir,
+	readFile,
+	rename,
+	stat,
+	writeFile,
+} from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
 import {
@@ -65,7 +72,7 @@ import {
 	parseStructuredDocument,
 	writeYamlFile,
 } from "../lib/harness-yaml.js";
-import { claimExtensionLoad } from "./lib/extension-load-guard.js";
+import { claimHarnessGovernanceLoad } from "./lib/extension-load-guard.js";
 import {
 	evaluateHarnessSubagentToolCall,
 	isSubmitToolName,
@@ -96,6 +103,136 @@ function persistContext(pi: ExtensionAPI, ctx: HarnessRunContext): void {
 	pi.events.emit("harness-run-context:updated", { run_id: ctx.run_id });
 }
 
+const PLAN_REVISION_ARTIFACT_FILES = new Set([
+	"planning-context.yaml",
+	"decomposition.yaml",
+	"hypothesis.yaml",
+	"implementation-research.yaml",
+	"stack.yaml",
+	"execution-plan-draft.yaml",
+	"plan-phase-status.yaml",
+	"plan-phase-waiver.yaml",
+	"sentrux-manifest-proposal.yaml",
+]);
+
+const PLAN_REVISION_ARTIFACT_PREFIXES = [
+	"hypothesis-validation-r",
+	"review-round-r",
+	"plan-evaluator-r",
+	"plan-adversary-r",
+	"sprint-contract-audit-r",
+	"adversary-brief-r",
+] as const;
+
+async function moveIfExists(from: string, to: string): Promise<boolean> {
+	try {
+		await stat(from);
+	} catch {
+		return false;
+	}
+	await mkdir(dirname(to), { recursive: true });
+	await rename(from, to);
+	return true;
+}
+
+function isPlanRevisionArtifactFile(name: string): boolean {
+	if (PLAN_REVISION_ARTIFACT_FILES.has(name)) return true;
+	if (name === "review-round-consolidated.yaml") return true;
+	return PLAN_REVISION_ARTIFACT_PREFIXES.some((prefix) =>
+		name.startsWith(prefix),
+	);
+}
+
+export async function archivePlanRevisionArtifacts(input: {
+	projectRoot: string;
+	runId: string;
+	reason: string;
+	recordedAt?: string;
+}): Promise<{ archiveDir: string; moved: string[] }> {
+	const recordedAt = input.recordedAt ?? nowIso();
+	const revisionId = recordedAt.replace(/[:.]/g, "-");
+	const runDir = join(input.projectRoot, ".pi", "harness", "runs", input.runId);
+	const artifactsDir = join(runDir, "artifacts");
+	const archiveDir = join(artifactsDir, "revisions", revisionId);
+	const moved: string[] = [];
+
+	async function archiveRel(rel: string): Promise<void> {
+		const ok = await moveIfExists(join(runDir, rel), join(archiveDir, rel));
+		if (ok) moved.push(rel);
+	}
+
+	await archiveRel("plan-packet.yaml");
+	await archiveRel("plan-review.md");
+	await archiveRel("research-brief.yaml");
+	await archiveRel("debate-messenger");
+
+	try {
+		const names = await readdir(artifactsDir);
+		for (const name of names) {
+			if (!isPlanRevisionArtifactFile(name)) continue;
+			await archiveRel(join("artifacts", name));
+		}
+	} catch {
+		// No artifacts yet.
+	}
+
+	const debateRel = join(
+		".pi",
+		"harness",
+		"debates",
+		`plan-${input.runId}.jsonl`,
+	);
+	const debateArchived = await moveIfExists(
+		join(input.projectRoot, debateRel),
+		join(archiveDir, "debates", basename(debateRel)),
+	);
+	if (debateArchived) moved.push(debateRel);
+
+	if (moved.length > 0) {
+		await mkdir(archiveDir, { recursive: true });
+		await writeFile(
+			join(archiveDir, "revision-reset.json"),
+			`${JSON.stringify(
+				{
+					schema_version: "1.0.0",
+					run_id: input.runId,
+					reason: input.reason,
+					recorded_at: recordedAt,
+					moved,
+				},
+				null,
+				2,
+			)}\n`,
+			"utf-8",
+		);
+	}
+
+	return { archiveDir, moved };
+}
+
+function shouldArchiveForPlanRevise(input: {
+	command: string;
+	mode: "create" | "revise" | null;
+	runCtx: HarnessRunContext;
+	reviewOutcome: Awaited<ReturnType<typeof readReviewOutcomeFromRun>>;
+	userPrompt: string;
+}): boolean {
+	if (input.command !== "harness-plan" && input.command !== "harness-auto") {
+		return false;
+	}
+	if (input.mode !== "revise") return false;
+	const next = (input.runCtx.next_recommended_command ?? "").toLowerCase();
+	const prompt = input.userPrompt.toLowerCase();
+	return (
+		input.reviewOutcome?.remediation_class === "plan_gap" ||
+		next.includes("/harness-plan") ||
+		next.includes("revise") ||
+		prompt.includes("--mode revise") ||
+		prompt.includes("--mode=revise") ||
+		prompt.includes("mode: revise")
+	);
+}
+
 function syncPolicyFromRunContext(
 	pi: ExtensionAPI,
 	entries: unknown[],
@@ -236,10 +373,7 @@ async function offerCrossSessionResume(
 		hasUI: boolean;
 		sessionManager: { getEntries(): unknown[] };
 		ui: {
-			notify(
-				message: string,
-				type?: "info" | "warning" | "error",
-			): void;
+			notify(message: string, type?: "info" | "warning" | "error"): void;
 		};
 	},
 ): Promise<void> {
@@ -272,7 +406,7 @@ async function offerCrossSessionResume(
 }
 
 export default function harnessRunContext(pi: ExtensionAPI) {
-	if (!claimExtensionLoad("harness-run-context", MODULE_URL)) return;
+	if (!claimHarnessGovernanceLoad("harness-run-context", MODULE_URL)) return;
 	let activeCtx: HarnessRunContext | null = null;
 
 	pi.on("session_start", async (_event, ctx) => {
@@ -658,12 +792,15 @@ export default function harnessRunContext(pi: ExtensionAPI) {
 		}
 
 		let activePlanBlock = "";
+		let planMode: "create" | "revise" | null = null;
 		if (command === "harness-plan" || command === "harness-auto") {
-			const mode =
-				activeCtx.plan_ready || activeCtx.status === "aborted"
+			planMode =
+				activeCtx.plan_id ||
+				activeCtx.plan_packet_path ||
+				activeCtx.status === "aborted"
 					? "revise"
 					: "create";
-			activePlanBlock = formatActivePlanBlock(activeCtx, mode, planSummary);
+			activePlanBlock = formatActivePlanBlock(activeCtx, planMode, planSummary);
 		} else if (command === "harness-run") {
 			activePlanBlock = formatActivePlanBlock(
 				activeCtx,
@@ -688,6 +825,37 @@ export default function harnessRunContext(pi: ExtensionAPI) {
 			activePlanBlock = formatActivePlanBlock(activeCtx, "read", planSummary);
 		}
 
+		if (command === "harness-plan" || command === "harness-auto") {
+			const reviewOutcome = await readReviewOutcomeFromRun(
+				activeCtx.run_id,
+				projectRoot,
+			);
+			if (
+				shouldArchiveForPlanRevise({
+					command,
+					mode: planMode,
+					runCtx: activeCtx,
+					reviewOutcome,
+					userPrompt,
+				})
+			) {
+				const reset = await archivePlanRevisionArtifacts({
+					projectRoot,
+					runId: activeCtx.run_id,
+					reason: "review_plan_gap_revise",
+				});
+				if (reset.moved.length > 0) {
+					pi.appendEntry("harness-plan-revision-reset", {
+						run_id: activeCtx.run_id,
+						archive_dir: reset.archiveDir,
+						moved: reset.moved,
+						reason: "review_plan_gap_revise",
+						recorded_at: nowIso(),
+					});
+				}
+			}
+		}
+
 		persistContext(pi, activeCtx);
 
 		return {
@@ -1211,7 +1379,7 @@ export default function harnessRunContext(pi: ExtensionAPI) {
 					content: [
 						{
 							type: "text",
-							text: `Path not allowed: ${pathArg}. Post-run verdicts must be written via submit_* in harness/evaluator or harness/adversary subagents; parent gates with harness_artifact_ready only.`,
+							text: `Path not allowed: ${pathArg}. Post-run verdicts must be written via submit_* in harness/reviewing/evaluator or harness/reviewing/adversary subagents; parent gates with harness_artifact_ready only.`,
 						},
 					],
 					details: { path: pathArg },

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

@@ -7,7 +7,7 @@ import { join } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
 import { resolveGuardedRunDir } from "../lib/harness-subagent-submit-path.js";
-import { claimExtensionLoad } from "./lib/extension-load-guard.js";
+import { claimHarnessGovernanceLoad } from "./lib/extension-load-guard.js";
 import { getHarnessPackageRoot } from "./lib/harness-paths.js";
 import { evaluateHarnessSubagentToolCall } from "./lib/harness-subagent-policy.js";
 import {
@@ -60,7 +60,8 @@ function isSubprocessHarness(): boolean {
 }
 
 export default function harnessSubagentSubmit(pi: ExtensionAPI) {
-	if (!claimExtensionLoad("harness-subagent-submit", MODULE_URL)) return;
+	if (!claimHarnessGovernanceLoad("harness-subagent-submit", MODULE_URL))
+		return;
 	// Option A: only load submit tools in subprocess (`-e` bundle), not parent discovery.
 	if (process.env.PI_HARNESS_SUBPROCESS !== "1") {
 		return;

package/.pi/extensions/harness-subagents.ts

@@ -6,13 +6,13 @@
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { claimExtensionLoad } from "./lib/extension-load-guard.js";
+import { claimHarnessGovernanceLoad } from "./lib/extension-load-guard.js";
 
 // @ts-expect-error pi extensions run as ESM
 const MODULE_URL = import.meta.url;
 
 async function loadHarnessSubagents(): Promise<(pi: ExtensionAPI) => void> {
-	if (!claimExtensionLoad("harness-subagents", MODULE_URL)) {
+	if (!claimHarnessGovernanceLoad("harness-subagents", MODULE_URL)) {
 		return () => {};
 	}
 	const { getHarnessPackageRoot } = await import("./lib/harness-paths.js");

package/.pi/extensions/harness-telemetry.ts

@@ -9,6 +9,7 @@
 
 import { createHash } from "node:crypto";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { isHarnessProjectEnabled } from "../lib/harness-project-config.js";
 import {
 	captureHarnessEvent,
 	type HarnessPostHogEventName,
@@ -338,6 +339,7 @@ function mapCustomEntry(
 }
 
 export default function harnessTelemetry(pi: ExtensionAPI) {
+	if (!isHarnessProjectEnabled()) return;
 	const flushedHashes = new Set<string>();
 	let lastPolicyPhase: HarnessPhase | null = null;
 

package/.pi/extensions/harness-web-tools.ts

@@ -4,7 +4,7 @@
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import { claimExtensionLoad } from "./lib/extension-load-guard.js";
+import { claimHarnessGovernanceLoad } from "./lib/extension-load-guard.js";
 import {
 	harnessWebContextLine,
 	readTextExcerpt,
@@ -98,7 +98,7 @@ function sessionCwd(ctx: { cwd?: string }): string {
 }
 
 export default function harnessWebTools(pi: ExtensionAPI) {
-	if (!claimExtensionLoad("harness-web-tools", MODULE_URL)) return;
+	if (!claimHarnessGovernanceLoad("harness-web-tools", MODULE_URL)) return;
 	pi.on("before_agent_start", async (event) => {
 		return {
 			systemPrompt: `${event.systemPrompt}\n\n${harnessWebContextLine()}`,

package/.pi/extensions/lib/extension-load-guard.ts

@@ -1,6 +1,7 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { isHarnessProjectEnabled } from "../../lib/harness-project-config.js";
 
 const LOAD_GUARD_KEY = Symbol.for("ultimate-pi.extension-load-guard");
 
@@ -37,3 +38,12 @@ export function claimExtensionLoad(key: string, moduleUrl: string): boolean {
 	registry.add(key);
 	return true;
 }
+
+/** Skip duplicate loads and skip all governance extensions when harness is disabled. */
+export function claimHarnessGovernanceLoad(
+	key: string,
+	moduleUrl: string,
+): boolean {
+	if (!isHarnessProjectEnabled()) return false;
+	return claimExtensionLoad(key, moduleUrl);
+}

package/.pi/extensions/lib/harness-artifact-gate.ts

@@ -20,9 +20,6 @@ const ARTIFACT_SCHEMA: Record<string, string> = {
 		"plan-implementation-research-brief.schema.json",
 	"artifacts/stack.yaml": "plan-stack-brief.schema.json",
 	"artifacts/planning-context.yaml": "plan-planning-context.schema.json",
-	"artifacts/scout-graphify.yaml": "plan-scout-findings.schema.json",
-	"artifacts/scout-structure.yaml": "plan-scout-findings.schema.json",
-	"artifacts/scout-semantic.yaml": "plan-scout-findings.schema.json",
 	"artifacts/eval-verdict.yaml": "eval-verdict.schema.json",
 	"artifacts/adversary-report.yaml": "adversary-report.schema.json",
 };
@@ -48,10 +45,10 @@ async function fileExists(path: string): Promise<boolean> {
 	}
 }
 
-function scoutStatusBad(doc: Record<string, unknown>): string | null {
+function artifactStatusBad(doc: Record<string, unknown>): string | null {
 	const status = String(doc.status ?? "ok").toLowerCase();
 	if (status === "partial" || status === "failed" || status === "error") {
-		return `scout status is "${status}"`;
+		return `artifact status is "${status}"`;
 	}
 	return null;
 }
@@ -105,17 +102,10 @@ export async function validateHarnessArtifactFile(
 		}
 	}
 
-	if (doc && normalized.startsWith("artifacts/scout-")) {
-		const scoutErr = scoutStatusBad(doc);
-		if (scoutErr) {
-			errors.push(`${normalized}: ${scoutErr}`);
-		}
-	}
-
 	if (doc && normalized === "artifacts/planning-context.yaml") {
-		const scoutErr = scoutStatusBad(doc);
-		if (scoutErr) {
-			errors.push(`${normalized}: ${scoutErr}`);
+		const statusErr = artifactStatusBad(doc);
+		if (statusErr) {
+			errors.push(`${normalized}: ${statusErr}`);
 		}
 		const coverage = doc.coverage as Record<string, unknown> | undefined;
 		if (coverage && typeof coverage === "object") {

package/.pi/extensions/lib/harness-spawn-topology.ts

@@ -23,13 +23,6 @@ const DEBATE_LANE_AGENTS = new Set([
 	"harness/planning/review-integrator",
 ]);
 
-/** @deprecated Legacy tool-tied scouts — prefer parent tools + planning-context.yaml (ADR 0041). */
-const LEGACY_SCOUT_AGENTS = new Set([
-	"harness/planning/scout-graphify",
-	"harness/planning/scout-structure",
-	"harness/planning/scout-semantic",
-]);
-
 const PLANNING_CONTEXT_AGENT = "harness/planning/planning-context";
 
 const PARALLEL_RESEARCH_AGENTS = new Set([
@@ -42,7 +35,7 @@ function countInSet(names: string[], allowed: Set<string>): number {
 }
 
 function isReconnaissanceAgent(name: string): boolean {
-	return LEGACY_SCOUT_AGENTS.has(name) || name === PLANNING_CONTEXT_AGENT;
+	return name === PLANNING_CONTEXT_AGENT;
 }
 
 async function decompositionReady(
@@ -103,28 +96,12 @@ export async function validateHarnessSpawnTopology(
 			};
 		}
 
-		const legacyScouts = countInSet(names, LEGACY_SCOUT_AGENTS);
 		const planningContext = names.filter(
 			(n) => n === PLANNING_CONTEXT_AGENT,
 		).length;
 		const research = countInSet(names, PARALLEL_RESEARCH_AGENTS);
-		const recon = legacyScouts + planningContext;
+		const recon = planningContext;
 
-		if (legacyScouts > 0 && planningContext > 0) {
-			return {
-				ok: false,
-				message:
-					"Do not mix legacy scout-* subagents with planning-context in one batch. " +
-					"Prefer parent tool use + planning-context.yaml, or a single planning-context subagent.",
-			};
-		}
-		if (legacyScouts > 3) {
-			return {
-				ok: false,
-				message:
-					"At most 3 legacy planning scouts per parallel batch (deprecated — use planning-context).",
-			};
-		}
 		if (planningContext > 1) {
 			return {
 				ok: false,
@@ -149,7 +126,7 @@ export async function validateHarnessSpawnTopology(
 				ok: false,
 				message:
 					"Parallel batches may include only one independent group: " +
-					"research (≤2 lanes), optional legacy scouts (≤3), optional single planning-context, " +
+					"research (≤2 lanes), optional single planning-context, " +
 					"or a single sequential lane agent.",
 			};
 		}
@@ -175,7 +152,7 @@ export async function validateHarnessSpawnTopology(
 	}
 
 	if (phase === "plan") {
-		const mutating = names.filter((n) => n.startsWith("harness/executor"));
+		const mutating = names.filter((n) => n.startsWith("harness/running/"));
 		if (mutating.length > 0) {
 			return {
 				ok: false,

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

@@ -52,8 +52,6 @@ const ROUTINE_PLANNING_AGENT_PATHS = new Set([
 	"harness/planning/hypothesis-validator",
 	"harness/planning/sprint-contract-auditor",
 	"harness/planning/planning-context",
-	"harness/planning/scout-structure",
-	"harness/planning/scout-semantic",
 	"harness/planning/decompose",
 	"harness/planning/hypothesis",
 	"harness/planning/stack-research",

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

@@ -66,13 +66,13 @@ export function classifyHarnessAgent(agentType: string): HarnessAgentKind {
 		return "planner";
 	}
 	switch (id) {
-		case "executor":
+		case "running/executor":
 			return "executor";
-		case "evaluator":
+		case "reviewing/evaluator":
 			return "evaluator";
-		case "adversary":
+		case "reviewing/adversary":
 			return "adversary";
-		case "tie-breaker":
+		case "reviewing/tie-breaker":
 			return "tie_breaker";
 		case "meta-optimizer":
 			return "meta";
@@ -127,7 +127,7 @@ export function evaluateHarnessSubagentToolCall(
 				return {
 					action: "block",
 					reason:
-						"submit_human_required is not available for harness/executor.",
+						"submit_human_required is not available for harness/running/executor.",
 				};
 			}
 			return { action: "allow" };

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

@@ -64,7 +64,7 @@ export async function precheckHarnessSubagentSpawn(
 		const cfg = resolveAgent(agents, n);
 		return cfg
 			? agentAllowsMutatingTools(cfg)
-			: n.startsWith("harness/executor");
+			: n.startsWith("harness/running/");
 	});
 
 	if (phase === "plan" && mutating.length > 0) {
@@ -78,8 +78,8 @@ export async function precheckHarnessSubagentSpawn(
 
 	const parallelEvalAdversary =
 		(params.tasks?.length ?? 0) === 2 &&
-		params.tasks?.some((t) => t.agent === "harness/evaluator") &&
-		params.tasks?.some((t) => t.agent === "harness/adversary") &&
+		params.tasks?.some((t) => t.agent === "harness/reviewing/evaluator") &&
+		params.tasks?.some((t) => t.agent === "harness/reviewing/adversary") &&
 		phase === "evaluate";
 
 	if (

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

@@ -28,24 +28,6 @@ export const SUBMIT_TOOL_SPECS: readonly SubmitToolSpec[] = [
 		schemaFile: "plan-planning-context.schema.json",
 		artifactPath: "artifacts/planning-context.yaml",
 	},
-	{
-		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", "harness/planning/plan-synthesizer"],
@@ -118,19 +100,19 @@ export const SUBMIT_TOOL_SPECS: readonly SubmitToolSpec[] = [
 	},
 	{
 		toolName: "submit_executor_handoff",
-		agents: ["harness/executor"],
+		agents: ["harness/running/executor"],
 		schemaFile: "harness-executor-handoff.schema.json",
 		artifactPath: "handoff/executor-summary.yaml",
 	},
 	{
 		toolName: "submit_eval_verdict",
-		agents: ["harness/evaluator"],
+		agents: ["harness/reviewing/evaluator"],
 		schemaFile: "eval-verdict.schema.json",
 		artifactPath: "artifacts/eval-verdict.yaml",
 	},
 	{
 		toolName: "submit_adversary_report",
-		agents: ["harness/adversary"],
+		agents: ["harness/reviewing/adversary"],
 		schemaFile: "adversary-report.schema.json",
 		artifactPath: "artifacts/adversary-report.yaml",
 	},

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

@@ -1,5 +1,5 @@
 /**
- * Pre-approve_plan readiness checks (artifacts, scouts, phase status).
+ * Pre-approve_plan readiness checks (planning context, research, phase status).
  */
 
 import { constants } from "node:fs";
@@ -13,12 +13,6 @@ export interface PlanApprovalReadiness {
 	warnings: string[];
 }
 
-const LEGACY_SCOUT_ARTIFACTS = [
-	"artifacts/scout-graphify.yaml",
-	"artifacts/scout-structure.yaml",
-	"artifacts/scout-semantic.yaml",
-] as const;
-
 const PLANNING_CONTEXT_ARTIFACT = "artifacts/planning-context.yaml";
 
 const PHASE35_ARTIFACTS = [
@@ -86,44 +80,6 @@ function coverageLaneStatus(
 	return String(laneDoc?.status ?? "").toLowerCase();
 }
 
-async function validateLegacyScouts(
-	runDir: string,
-	quick: boolean,
-	errors: string[],
-	warnings: string[],
-): Promise<boolean> {
-	let anyPresent = false;
-	for (const rel of LEGACY_SCOUT_ARTIFACTS) {
-		if (rel === "artifacts/scout-semantic.yaml" && quick) continue;
-		const abs = join(runDir, rel);
-		if (!(await fileExists(abs))) {
-			const waived = await hasPhaseWaiver(runDir, `missing:${rel}`);
-			if (!waived) {
-				errors.push(`missing ${rel}`);
-			}
-			continue;
-		}
-		anyPresent = true;
-		const doc = await readYamlObject(abs);
-		const bad = artifactStatusBad(doc, rel);
-		if (bad) {
-			const waived = await hasPhaseWaiver(
-				runDir,
-				`scout:${rel}:${String(doc?.status ?? "")}`,
-			);
-			if (!waived) {
-				errors.push(bad);
-			}
-		}
-	}
-	if (anyPresent) {
-		warnings.push(
-			"legacy scout YAML artifacts detected — prefer artifacts/planning-context.yaml (see ADR 0041)",
-		);
-	}
-	return anyPresent;
-}
-
 async function validatePlanningContext(
 	runDir: string,
 	quick: boolean,
@@ -203,19 +159,14 @@ export async function validatePlanApprovalReadiness(
 		quick,
 		errors,
 	);
-	const hasLegacyScouts = hasPlanningContext
-		? false
-		: await validateLegacyScouts(runDir, quick, errors, warnings);
 
-	if (!hasPlanningContext && !hasLegacyScouts) {
+	if (!hasPlanningContext) {
 		const waived = await hasPhaseWaiver(
 			runDir,
 			"missing:planning-reconnaissance",
 		);
 		if (!waived) {
-			errors.push(
-				`missing ${PLANNING_CONTEXT_ARTIFACT} (or legacy scout-graphify/structure/semantic trio)`,
-			);
+			errors.push(`missing ${PLANNING_CONTEXT_ARTIFACT}`);
 		}
 	}
 

package/.pi/extensions/lib/spawn-policy.ts

@@ -11,9 +11,9 @@ export const SUBAGENT_BLOCKED_TOOLS = new Set([
 ]);
 
 const ASK_USER_ALLOWED_AGENT_TYPES = new Set([
-	"harness/evaluator",
-	"harness/adversary",
-	"harness/tie-breaker",
+	"harness/reviewing/evaluator",
+	"harness/reviewing/adversary",
+	"harness/reviewing/tie-breaker",
 ]);
 
 export interface ToolCallDecision {

package/.pi/extensions/observation-bus.ts

@@ -7,6 +7,7 @@
 
 import { randomUUID } from "node:crypto";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { isHarnessProjectEnabled } from "../lib/harness-project-config.js";
 import { getRunIdFromSession } from "../lib/harness-run-context.js";
 
 type HarnessPhase = "plan" | "execute" | "evaluate" | "adversary" | "merge";
@@ -87,6 +88,7 @@ function getRunId(ctx: {
 }
 
 export default function observationBus(pi: ExtensionAPI) {
+	if (!isHarnessProjectEnabled()) return;
 	const seen = new Set<string>();
 
 	pi.on("agent_end", async (_event, ctx) => {