ultimate-pi 0.17.0 → 0.18.0

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

@@ -0,0 +1,241 @@
+/**
+ * Pre-approve_plan readiness checks (artifacts, scouts, phase status).
+ */
+
+import { constants } from "node:fs";
+import { access, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+
+export interface PlanApprovalReadiness {
+	ok: boolean;
+	errors: string[];
+	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 = [
+	"artifacts/implementation-research.yaml",
+	"artifacts/stack.yaml",
+] as const;
+
+async function fileExists(path: string): Promise<boolean> {
+	try {
+		await access(path, constants.R_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function readYamlObject(
+	path: string,
+): Promise<Record<string, unknown> | null> {
+	try {
+		const raw = await readFile(path, "utf-8");
+		const doc = parseYaml(raw) as unknown;
+		return doc && typeof doc === "object" && !Array.isArray(doc)
+			? (doc as Record<string, unknown>)
+			: null;
+	} catch {
+		return null;
+	}
+}
+
+async function hasPhaseWaiver(
+	runDir: string,
+	reason: string,
+): Promise<boolean> {
+	const path = join(runDir, "artifacts", "plan-phase-waiver.yaml");
+	const doc = await readYamlObject(path);
+	if (!doc) return false;
+	const waived = doc.waived as unknown;
+	if (!Array.isArray(waived)) return false;
+	return waived.some((w) => {
+		if (!w || typeof w !== "object") return false;
+		const entry = w as Record<string, unknown>;
+		return String(entry.reason ?? "") === reason;
+	});
+}
+
+function artifactStatusBad(
+	doc: Record<string, unknown> | null,
+	label: string,
+): string | null {
+	const status = String(doc?.status ?? "ok").toLowerCase();
+	if (status === "partial" || status === "failed" || status === "error") {
+		return `${label}: status "${status}" without waiver`;
+	}
+	return null;
+}
+
+function coverageLaneStatus(
+	doc: Record<string, unknown> | null,
+	lane: string,
+): string {
+	const coverage = doc?.coverage as Record<string, unknown> | undefined;
+	if (!coverage || typeof coverage !== "object") return "";
+	const laneDoc = coverage[lane] as Record<string, unknown> | undefined;
+	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,
+	errors: string[],
+): Promise<boolean> {
+	const rel = PLANNING_CONTEXT_ARTIFACT;
+	const abs = join(runDir, rel);
+	if (!(await fileExists(abs))) {
+		return false;
+	}
+	const doc = await readYamlObject(abs);
+	const bad = artifactStatusBad(doc, rel);
+	if (bad) {
+		const waived = await hasPhaseWaiver(
+			runDir,
+			`planning-context:${String(doc?.status ?? "")}`,
+		);
+		if (!waived) {
+			errors.push(bad);
+		}
+	}
+	const arch = coverageLaneStatus(doc, "architecture");
+	const structure = coverageLaneStatus(doc, "structure");
+	if (arch !== "ok" && arch !== "partial") {
+		errors.push(
+			`${rel}: coverage.architecture.status must be ok or partial (got "${arch || "missing"}")`,
+		);
+	}
+	if (structure !== "ok" && structure !== "partial") {
+		errors.push(
+			`${rel}: coverage.structure.status must be ok or partial (got "${structure || "missing"}")`,
+		);
+	}
+	if (!quick) {
+		const semantic = coverageLaneStatus(doc, "semantic");
+		if (
+			semantic &&
+			semantic !== "ok" &&
+			semantic !== "partial" &&
+			semantic !== "skipped"
+		) {
+			errors.push(
+				`${rel}: coverage.semantic.status must be ok, partial, or skipped (got "${semantic}")`,
+			);
+		}
+	}
+	return true;
+}
+
+export async function validatePlanApprovalReadiness(
+	projectRoot: string,
+	runId: string,
+	opts?: { risk_level?: string; quick?: boolean },
+): Promise<PlanApprovalReadiness> {
+	const runDir = join(projectRoot, ".pi", "harness", "runs", runId);
+	const errors: string[] = [];
+	const warnings: string[] = [];
+	const risk = String(opts?.risk_level ?? "med").toLowerCase();
+	const quick = opts?.quick === true;
+
+	const statusPath = join(runDir, "artifacts", "plan-phase-status.yaml");
+	const statusDoc = await readYamlObject(statusPath);
+	if (statusDoc) {
+		const planStatus = String(statusDoc.plan_status ?? "").toLowerCase();
+		if (planStatus === "partial" || planStatus === "needs_clarification") {
+			const waived = await hasPhaseWaiver(runDir, `plan_status:${planStatus}`);
+			if (!waived) {
+				errors.push(
+					`plan phase status is "${planStatus}" — resolve gaps, set plan_status ready, or write artifacts/plan-phase-waiver.yaml`,
+				);
+			}
+		}
+	}
+
+	const hasPlanningContext = await validatePlanningContext(
+		runDir,
+		quick,
+		errors,
+	);
+	const hasLegacyScouts = hasPlanningContext
+		? false
+		: await validateLegacyScouts(runDir, quick, errors, warnings);
+
+	if (!hasPlanningContext && !hasLegacyScouts) {
+		const waived = await hasPhaseWaiver(
+			runDir,
+			"missing:planning-reconnaissance",
+		);
+		if (!waived) {
+			errors.push(
+				`missing ${PLANNING_CONTEXT_ARTIFACT} (or legacy scout-graphify/structure/semantic trio)`,
+			);
+		}
+	}
+
+	for (const rel of PHASE35_ARTIFACTS) {
+		const abs = join(runDir, rel);
+		if (!(await fileExists(abs))) {
+			if (risk === "high" || risk === "med") {
+				errors.push(`missing ${rel} (Phase 3.5 required for risk ${risk})`);
+			} else {
+				warnings.push(`missing ${rel} (recommended for risk ${risk})`);
+			}
+		}
+	}
+
+	if (!(await fileExists(join(runDir, "artifacts/decomposition.yaml")))) {
+		errors.push("missing artifacts/decomposition.yaml");
+	}
+	if (!(await fileExists(join(runDir, "artifacts/hypothesis.yaml")))) {
+		errors.push("missing artifacts/hypothesis.yaml");
+	}
+
+	return { ok: errors.length === 0, errors, warnings };
+}

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

@@ -126,7 +126,7 @@ export const PLAN_BUDGET_FAST = {
 } as const;
 
 export interface PlanReviewGateStrategy {
-	mode: "consolidated" | "threaded";
+	mode: "consolidated" | "threaded" | "parallel_probes";
 	profile: DebateProfile;
 	required_focuses: PlanDebateFocus[];
 	min_focus_rounds: number;
@@ -232,9 +232,9 @@ export function harnessPlanDebateEligibility(
 		confidenceAllowsLight(impl) &&
 		stackHasClearPrimary(stack)
 	) {
-		profile = "fast";
+		profile = "light";
 		rationale.push(
-			"fast: low risk, clear stack, high-confidence implementation approach",
+			"light: low risk, clear stack, high-confidence implementation (threaded spec+quality)",
 		);
 	} else if (risk === "med") {
 		profile = "standard";
@@ -242,7 +242,9 @@ export function harnessPlanDebateEligibility(
 	}
 
 	const required_focuses: PlanDebateFocus[] =
-		profile === "fast" ? [...LIGHT_FOCUS] : [...PLAN_FOCUS_AREAS];
+		profile === "fast" || profile === "light"
+			? [...LIGHT_FOCUS]
+			: [...PLAN_FOCUS_AREAS];
 
 	const caps = capsForProfile(profile);
 
@@ -253,7 +255,12 @@ export function harnessPlanDebateEligibility(
 		human_required,
 		rationale,
 		review_gate_strategy: {
-			mode: profile === "fast" ? "consolidated" : "threaded",
+			mode:
+				profile === "fast"
+					? "consolidated"
+					: profile === "standard"
+						? "parallel_probes"
+						: "threaded",
 			profile,
 			required_focuses: [...required_focuses],
 			min_focus_rounds: caps.min_focus_rounds,

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

@@ -16,6 +16,7 @@ import {
 import { planDebateIdForRun } from "./plan-debate-id.js";
 import {
 	laneArtifactPathsForConsolidatedRound,
+	laneArtifactPathsForParallelProbesRound,
 	laneArtifactPathsForRound,
 } from "./plan-debate-lanes.js";
 import {
@@ -26,6 +27,7 @@ import {
 import {
 	CONSOLIDATED_REVIEW_ARTIFACT,
 	isConsolidatedReviewStrategy,
+	isParallelProbesReviewStrategy,
 	planReviewGateStrategyFromEligibility,
 } from "./plan-review-gate.js";
 
@@ -114,6 +116,7 @@ export async function validatePlanDebateGate(
 						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,
@@ -126,7 +129,25 @@ export async function validatePlanDebateGate(
 		errors.push("last submitted review round has review_gate_ready !== true");
 	}
 
-	if (consolidated) {
+	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}`);

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

@@ -43,9 +43,39 @@ export function laneArtifactPathsForRound(
 	return paths;
 }
 
-/** Lanes for consolidated Review Gate (single round, parallel-friendly). */
+/** Lanes for consolidated Review Gate (single round; blind verifier first). */
 export function lanesForConsolidatedRound(): DebateLaneKind[] {
-	return ["validation-turn", "adversary-brief", "sprint-audit"];
+	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[] {

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

@@ -38,6 +38,14 @@ export function isConsolidatedReviewStrategy(
 	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",

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/harness/agents.manifest.json

@@ -1,8 +1,8 @@
 {
 	"schema_version": "1.0.0",
 	"package": "ultimate-pi",
-	"package_version": "0.15.0",
-	"generated_at": "2026-05-19T12:56:13.369Z",
+	"package_version": "0.17.0",
+	"generated_at": "2026-05-23T10:14:51.637Z",
 	"agents": {
 		"pi-pi/agent-expert": {
 			"path": ".pi/agents/pi-pi/agent-expert.md",
@@ -46,15 +46,15 @@
 		},
 		"harness/adversary": {
 			"path": ".pi/agents/harness/adversary.md",
-			"sha256": "560c7571ab91478bde1271e9ae6c3a112c3e1d28e1a261c5450fd1d00f9f89af"
+			"sha256": "697ee7c784e8eb30ce96f4f16e9bb5f9cdcaae76a4a7083ace2fe4272e6d732f"
 		},
 		"harness/evaluator": {
 			"path": ".pi/agents/harness/evaluator.md",
-			"sha256": "a4667d3efb305ba2fe79118e3d7d2b0de5e0369637af040d1238161d75cd28ac"
+			"sha256": "587ae14d6e91fd8af2b2842f568b9a1fa0b1d84fa6e18b4bc21c0ba2a9e62218"
 		},
 		"harness/executor": {
 			"path": ".pi/agents/harness/executor.md",
-			"sha256": "6baffcc3d89954494ce3ae439175686a39928b6a543a0a451da27475094b1712"
+			"sha256": "e222a5c54c74329cdcfa92918d9191fa603d8945b81ca94484db258cda012783"
 		},
 		"harness/incident-recorder": {
 			"path": ".pi/agents/harness/incident-recorder.md",
@@ -68,6 +68,10 @@
 			"path": ".pi/agents/harness/sentrux-bootstrap.md",
 			"sha256": "3a0b43b94386a7c541b8a806a37524a5e53f1c8049270db7a420680df5799eeb"
 		},
+		"harness/sentrux-steward": {
+			"path": ".pi/agents/harness/sentrux-steward.md",
+			"sha256": "0e63175d817adc0d65876f5c24fb54e4882081caf939ff9c658afee51fc6889c"
+		},
 		"harness/tie-breaker": {
 			"path": ".pi/agents/harness/tie-breaker.md",
 			"sha256": "1c54c1c3274291dea1ea8826563a7ad4fe1d9c4302984e907bfcd22cfc4f5eba"
@@ -78,7 +82,7 @@
 		},
 		"harness/planning/decompose": {
 			"path": ".pi/agents/harness/planning/decompose.md",
-			"sha256": "0919dafa1d1cd008d513c28524c1e7218867586a138982dccf01db5270c42c73"
+			"sha256": "c9dd890d45cf4548e28d03aedb86d5fc4ed81022e920ad0005faf404994c6e96"
 		},
 		"harness/planning/execution-plan-author": {
 			"path": ".pi/agents/harness/planning/execution-plan-author.md",
@@ -86,43 +90,47 @@
 		},
 		"harness/planning/hypothesis-validator": {
 			"path": ".pi/agents/harness/planning/hypothesis-validator.md",
-			"sha256": "36f0baa7796229f21bd02faf5e70402c7bf054289eab557a25bfbe3cb7781de7"
+			"sha256": "20411e5d734b14b05ae11153133089e044f46784e5b4741712f608665bbf4376"
 		},
 		"harness/planning/hypothesis": {
 			"path": ".pi/agents/harness/planning/hypothesis.md",
-			"sha256": "e83d5c4faaee8d32af4a5f22c9917b70a173f3e22d7c0f182b361706f2309171"
+			"sha256": "bbb91ac0de39c9de4bf388f0cf926151b6b6a7771d2a0d01d1009a1860daef77"
 		},
 		"harness/planning/implementation-researcher": {
 			"path": ".pi/agents/harness/planning/implementation-researcher.md",
-			"sha256": "653f320b5d51bb331774246687f24a75347b406bba4e6dfd2968d6e5d4cc8bb3"
+			"sha256": "d1bbaaf1e67ad98350319f973062f01a25ca70874c99cb335c99bec866da1f6d"
 		},
 		"harness/planning/plan-adversary": {
 			"path": ".pi/agents/harness/planning/plan-adversary.md",
-			"sha256": "3241d7ec939dc29e0af64690b99e9f74b209f40b0daa4a2a1f9ff86f99f94a8d"
+			"sha256": "d9a953c0f8f900dc9a95816ada401955dafade7bf5907406cbe3bf3ba760c469"
 		},
 		"harness/planning/plan-evaluator": {
 			"path": ".pi/agents/harness/planning/plan-evaluator.md",
-			"sha256": "71660ab58bfcfdfae56c873140d4ea5946ae30cd5719c96afeabfd02b1d1f81d"
+			"sha256": "825f296c487d6aeacad5d320e155a3f23d0db6dea822fccc99a1305941a43da2"
+		},
+		"harness/planning/planning-context": {
+			"path": ".pi/agents/harness/planning/planning-context.md",
+			"sha256": "96a51d1f2daafc9eaa8869a06ede9d04fc9e19076d58a81041e346e4c81c8b08"
 		},
 		"harness/planning/review-integrator": {
 			"path": ".pi/agents/harness/planning/review-integrator.md",
-			"sha256": "cf3f0dbe81274ec9ef0ff2e0c170e8dc929b20be65492d0ee9a80d985acf6d71"
+			"sha256": "bba385463ca8833654cd0dc80f666344332293fe86d7420d2c36755a3f9e743a"
 		},
 		"harness/planning/scout-graphify": {
 			"path": ".pi/agents/harness/planning/scout-graphify.md",
-			"sha256": "6e2bda8ad38311810c9916d9dab311873bc776e4b8832bb0e574136e45e1255e"
+			"sha256": "edc117245476859d3bea93d6e1247cf9f580719bb3aabb91d885cc196c102f68"
 		},
 		"harness/planning/scout-semantic": {
 			"path": ".pi/agents/harness/planning/scout-semantic.md",
-			"sha256": "416e518d8204a55b26dc53da1f750865c6f09ee2c7f343b41e7c08da3230c089"
+			"sha256": "060ad9251068c68cc20418a45a5a5747b708895b946c8153d9e5034b28c59ad5"
 		},
 		"harness/planning/scout-structure": {
 			"path": ".pi/agents/harness/planning/scout-structure.md",
-			"sha256": "76c42a15cc74cf1de2cf861cb0146c865c205f69cce7b9605d41893b19600029"
+			"sha256": "111d055b82f0e1dde4cddc61d53474d8ad650dba2fd988061fd40fa638ed8bc7"
 		},
 		"harness/planning/sprint-contract-auditor": {
 			"path": ".pi/agents/harness/planning/sprint-contract-auditor.md",
-			"sha256": "12cb5e6b53dcc19ace62e8e4c152d96440717df53a182e76216dd2327410df4d"
+			"sha256": "2321298529f70d03798d23346231c4c43ad4b7490a43f291430ca65b3ef93757"
 		},
 		"harness/planning/stack-researcher": {
 			"path": ".pi/agents/harness/planning/stack-researcher.md",

package/.pi/harness/corpus/cron.example

@@ -0,0 +1,8 @@
+# Cron alternative (systemd timer is the tested path). Bounded, locked, explicit env, no overlap.
+# Edit UP_ROOT before installing with `crontab -e`.
+SHELL=/bin/sh
+PATH=/usr/local/bin:/usr/bin:/bin
+UP_ROOT=/home/USER/ai-projects/ultimate-pi
+HARNESS_GRAPHIFY_KB_LOG=/home/USER/.local/state/ultimate-pi/graphify-kb-updater.log
+
+30 8 * * * cd "$UP_ROOT" && /usr/bin/flock -n /tmp/graphify-kb-updater.lock /usr/bin/timeout 45m /usr/bin/env node .pi/scripts/graphify-kb-updater.mjs --apply --refresh-graph --pilot-report --max-promotions 25 >> "$HARNESS_GRAPHIFY_KB_LOG" 2>&1