ultimate-pi 0.24.0 → 0.25.0

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

@@ -32,6 +32,7 @@ import {
 	summarizeSearchJson,
 } from "../lib/harness-web/run-cli.js";
 
+// @ts-expect-error pi extensions run as ESM
 const MODULE_URL = import.meta.url;
 
 const WEB_SEARCH_GUIDELINES = [

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

@@ -60,6 +60,7 @@ const PHASE_ORDER: HarnessPhase[] = [
 	"merge",
 ];
 
+// @ts-expect-error pi extensions run as ESM
 const MODULE_URL = import.meta.url;
 
 const MUTATING_TOOLS = new Set(["write", "edit"]);
@@ -183,6 +184,10 @@ async function handlePolicyBeforeAgentStart(args: {
 		stateRef.current.updatedAt = stateRef.current.abortedAt;
 		stateRef.current = state;
 		pi.appendEntry("harness-policy-state", stateRef.current);
+		pi.events.emit("harness-run-aborted", {
+			reason: state.abortReason,
+			abortedAt: stateRef.current.abortedAt,
+		});
 		return {
 			message: {
 				customType: "harness-policy-aborted",
@@ -435,6 +440,10 @@ export default function policyGate(pi: ExtensionAPI) {
 			stateRef.current.abortedAt = nowIso();
 			stateRef.current.updatedAt = stateRef.current.abortedAt;
 			pi.appendEntry("harness-policy-state", stateRef.current);
+			pi.events.emit("harness-run-aborted", {
+				reason: stateRef.current.abortReason,
+				abortedAt: stateRef.current.abortedAt,
+			});
 
 			const runCtx = getLatestRunContext(ctx.sessionManager.getEntries());
 			if (runCtx) {

package/.pi/harness/agents.manifest.json

@@ -1,7 +1,7 @@
 {
 	"schema_version": "1.0.0",
 	"package": "ultimate-pi",
-	"package_version": "0.24.0",
+	"package_version": "0.25.0",
 	"generated_at": "2026-05-27T15:57:32.501Z",
 	"policy_sha256": "1a631333f1abed3b411961d3527bcae2d4fcd2f715b09a689b0b83b3ea0f54f3",
 	"agents": {

package/.pi/harness/docs/adrs/0056-agent-native-speed-wiring.md

@@ -0,0 +1,26 @@
+# ADR 0056: Agent-native speed wiring (v0.25.0)
+
+Status: Accepted  
+Date: 2026-06-06
+
+## Context
+
+ADR 0042 documented agent-native orchestration (parallel probes, synthesizer path, FSM). v0.24.0 shipped latency infrastructure but runtime wiring remained meeting-shaped: `harness_debate_open` ignored `parallel_probes`, gates fell back to threaded mode, and parents re-reasoned every turn.
+
+## Decision
+
+1. **parallel_probes end-to-end** — `review_gate_mode` includes `parallel_probes`; eligibility snapshot at `artifacts/plan-debate-eligibility.yaml`; `effectiveMinFocusRounds` caps bus checks to 1; focus coverage parses `review-round-parallel-probes.yaml`.
+2. **SSOT routing** — `planReviewGateModeForProfile`: fast→consolidated, standard→parallel_probes, light/full→threaded.
+3. **plan-synthesizer default** — low/med route via `harness_plan_route`; readiness waives separate decompose/hypothesis when all three synthesizer artifacts exist.
+4. **Auto-approve** — `HARNESS_PLAN_AUTO_APPROVE` with `canAutoApprovePlan` / audit artifact; requires non-interactive or `force`.
+5. **Plan FSM** — `derivePlanNextAction` + `harness_plan_next_action` tool.
+6. **Spawn budget enforce** — per-phase caps when `HARNESS_BUDGET_ENFORCE=1` (plan 12, execute 3, evaluate 6).
+7. **Review parallel default** — evaluator∥adversary on by default unless `HARNESS_REVIEW_PARALLEL=0`, `--quick`, or steer_attempt ≥ 2.
+8. **Auto-compact 50%** — `harness-auto-compact` extension with hysteresis; subagent compact off by default.
+9. **Phase worker spike** — `HARNESS_PHASE_WORKER=1` env only; no cross evaluator/adversary resume.
+
+## Consequences
+
+- Med-risk plans complete Review Gate in ≤4 debate spawns (validator, parallel evaluator∥adversary, integrator, submit).
+- `HARNESS_REVIEW_PARALLEL=0` remains CI escape hatch.
+- Amend ADR 0030 for 50% harness compact gate.

package/.pi/harness/env.harness.template

@@ -58,5 +58,11 @@ HARNESS_SENTRUX_REQUIRED=true
 # HARNESS_SUBAGENT_TIMEOUT_REVIEW_MS=1200000
 # HARNESS_SUBAGENT_TIMEOUT_DISABLE=0
 # HARNESS_DEBATE_WALL_CLOCK_MS=1200000
-# HARNESS_REVIEW_PARALLEL=0
+# HARNESS_REVIEW_PARALLEL=0  # unset = parallel evaluator∥adversary default on (med/high, non-quick)
+# HARNESS_PLAN_AUTO_APPROVE=1  # requires HARNESS_NON_INTERACTIVE=1 or =force
+# HARNESS_COMPACT_THRESHOLD_PERCENT=50
+# HARNESS_COMPACT_REARM_PERCENT=40
+# HARNESS_COMPACT_AUTO=true
+# HARNESS_COMPACT_SUBAGENTS=false
+# HARNESS_PHASE_WORKER=1
 # HARNESS_COCOINDEX_REFRESH_DEBOUNCE_MS=300000

package/.pi/lib/harness-auto-approve.ts

@@ -0,0 +1,140 @@
+/**
+ * Deterministic plan auto-approve when gates pass (HARNESS_PLAN_AUTO_APPROVE).
+ */
+
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { stringify as stringifyYaml } from "yaml";
+import { isHarnessNonInteractive } from "./ask-user/policy.js";
+import type { PlanApprovalReadiness } from "./plan-approval-readiness.js";
+import { loadPlanDebateEligibilitySnapshot } from "./plan-debate-eligibility-snapshot.js";
+import type { PlanDebateGateResult } from "./plan-debate-gate.js";
+import { readTaskClarificationDoc } from "./plan-task-clarification.js";
+
+function missingPlanningContextReadinessError(error: string): boolean {
+	return (
+		error.includes("planning-context.yaml") ||
+		error.includes("missing artifacts/planning-context.yaml") ||
+		error.includes("missing:planning-reconnaissance")
+	);
+}
+
+function missingPhase35ReadinessError(error: string): boolean {
+	return (
+		error.includes("implementation-research.yaml") ||
+		error.includes("stack.yaml") ||
+		error.includes("Phase 3.5")
+	);
+}
+
+export const PLAN_APPROVAL_AUDIT_ARTIFACT =
+	"artifacts/plan-approval-audit.yaml";
+
+export function isHarnessPlanAutoApproveForce(): boolean {
+	return (
+		process.env.HARNESS_PLAN_AUTO_APPROVE?.trim().toLowerCase() === "force"
+	);
+}
+
+export function isHarnessPlanAutoApproveEnabled(): boolean {
+	const raw = process.env.HARNESS_PLAN_AUTO_APPROVE?.trim().toLowerCase();
+	if (!raw || raw === "0" || raw === "false" || raw === "off") return false;
+	if (raw === "force") return true;
+	return raw === "1" || raw === "true" || raw === "on";
+}
+
+export interface AutoApprovePolicyInput {
+	projectRoot: string;
+	runId: string;
+	riskLevel: string;
+	readiness: PlanApprovalReadiness;
+	debateGate: PlanDebateGateResult;
+	dagPass?: boolean;
+}
+
+export interface AutoApprovePolicyResult {
+	allowed: boolean;
+	reasons: string[];
+}
+
+export async function canAutoApprovePlan(
+	input: AutoApprovePolicyInput,
+): Promise<AutoApprovePolicyResult> {
+	const reasons: string[] = [];
+	if (!isHarnessPlanAutoApproveEnabled()) {
+		return { allowed: false, reasons: ["HARNESS_PLAN_AUTO_APPROVE not set"] };
+	}
+	if (!isHarnessPlanAutoApproveForce() && !isHarnessNonInteractive()) {
+		reasons.push(
+			"interactive session — set HARNESS_NON_INTERACTIVE=1 or HARNESS_PLAN_AUTO_APPROVE=force",
+		);
+	}
+	const risk = String(input.riskLevel ?? "med").toLowerCase();
+	const qaSmoke =
+		process.env.HARNESS_QA_SMOKE === "1" && isHarnessNonInteractive();
+	if (risk === "high" && !qaSmoke)
+		reasons.push("high risk requires human approval");
+	if (!input.readiness.ok) {
+		for (const err of input.readiness.errors) {
+			if (
+				qaSmoke &&
+				risk === "low" &&
+				(missingPlanningContextReadinessError(err) ||
+					missingPhase35ReadinessError(err))
+			) {
+				continue;
+			}
+			reasons.push(`readiness: ${err}`);
+		}
+	}
+	if (!input.debateGate.ok) {
+		reasons.push(...input.debateGate.errors.map((e) => `debate: ${e}`));
+	}
+	if (input.debateGate.warnings.some((w) => /block/i.test(w))) {
+		reasons.push("debate gate warnings include blocker");
+	}
+	const runDir = join(input.projectRoot, ".pi", "harness", "runs", input.runId);
+	const eligibility = await loadPlanDebateEligibilitySnapshot(runDir);
+	if (eligibility?.human_required) {
+		reasons.push("eligibility human_required=true");
+	}
+	const clar = await readTaskClarificationDoc(runDir);
+	if (clar?.needs_clarification === true) {
+		reasons.push("task-clarification needs_clarification");
+	}
+	if (input.dagPass === false) {
+		reasons.push("DAG validation not passed");
+	}
+	return { allowed: reasons.length === 0, reasons };
+}
+
+export async function writePlanApprovalAudit(
+	runDir: string,
+	doc: Record<string, unknown>,
+): Promise<void> {
+	const abs = join(runDir, PLAN_APPROVAL_AUDIT_ARTIFACT);
+	await mkdir(join(runDir, "artifacts"), { recursive: true });
+	await writeFile(abs, stringifyYaml(doc), "utf-8");
+}
+
+export interface AutoApproveOutcome {
+	approved: boolean;
+	reasons: string[];
+}
+
+/** Returns whether auto-approve was applied (caller skips dialog when true). */
+export async function tryAutoApprovePlan(
+	input: AutoApprovePolicyInput,
+): Promise<AutoApproveOutcome> {
+	const policy = await canAutoApprovePlan(input);
+	const runDir = join(input.projectRoot, ".pi", "harness", "runs", input.runId);
+	await writePlanApprovalAudit(runDir, {
+		schema_version: "1.0.0",
+		source: policy.allowed ? "auto" : "blocked",
+		captured_at: new Date().toISOString(),
+		allowed: policy.allowed,
+		reasons: policy.reasons,
+		risk_level: input.riskLevel,
+	});
+	return { approved: policy.allowed, reasons: policy.reasons };
+}

package/.pi/lib/harness-auto-compact-policy.ts

@@ -0,0 +1,85 @@
+/**
+ * Harness 50% auto-compact gate policy (testable without pi runtime).
+ */
+
+import {
+	resolveCompactAuto,
+	resolveCompactRearmPercent,
+	resolveCompactSubagents,
+	resolveCompactThresholdPercent,
+} from "./harness-vcc-settings.js";
+
+export interface CompactUsage {
+	percent: number | null;
+	tokens?: number;
+	contextWindow?: number;
+}
+
+export interface CompactGateState {
+	armed: boolean;
+	inFlight: boolean;
+	cooldownTurns: number;
+	subagentSpawnPending: boolean;
+}
+
+export interface CompactGateDecision {
+	shouldCompact: boolean;
+	reason?: string;
+}
+
+export function createCompactGateState(): CompactGateState {
+	return {
+		armed: true,
+		inFlight: false,
+		cooldownTurns: 0,
+		subagentSpawnPending: false,
+	};
+}
+
+export function evaluateAutoCompactGate(
+	usage: CompactUsage,
+	state: CompactGateState,
+	opts?: { isSubagent?: boolean },
+): CompactGateDecision {
+	if (!resolveCompactAuto()) {
+		return { shouldCompact: false, reason: "HARNESS_COMPACT_AUTO=false" };
+	}
+	if (opts?.isSubagent && !resolveCompactSubagents()) {
+		return { shouldCompact: false, reason: "subagent compact disabled" };
+	}
+	if (state.subagentSpawnPending) {
+		return { shouldCompact: false, reason: "defer until subagent idle" };
+	}
+	if (state.inFlight) {
+		return { shouldCompact: false, reason: "compaction in flight" };
+	}
+	if (state.cooldownTurns > 0) {
+		return { shouldCompact: false, reason: "VCC cancel cooldown" };
+	}
+	if (!state.armed) {
+		const rearm = resolveCompactRearmPercent();
+		if (usage.percent != null && usage.percent < rearm) {
+			state.armed = true;
+		} else {
+			return { shouldCompact: false, reason: "hysteresis disarmed" };
+		}
+	}
+	const threshold = resolveCompactThresholdPercent();
+	if (usage.percent == null) {
+		return { shouldCompact: false, reason: "usage percent null" };
+	}
+	if (usage.percent < threshold) {
+		return { shouldCompact: false, reason: "below threshold" };
+	}
+	return { shouldCompact: true };
+}
+
+export function onSessionCompact(state: CompactGateState): void {
+	state.armed = false;
+	state.inFlight = false;
+}
+
+export function onCompactCancel(state: CompactGateState): void {
+	state.inFlight = false;
+	state.cooldownTurns = 2;
+}

package/.pi/lib/harness-phase-telemetry.ts

@@ -72,3 +72,10 @@ export function resetHarnessPhaseTelemetryForTests(): void {
 	phaseCompletedKeys.clear();
 	phaseSubagentCounts.clear();
 }
+
+export function getHarnessPhaseSubagentCount(
+	runId: string,
+	phase: HarnessPhase,
+): number {
+	return phaseSubagentCounts.get(phaseKey(runId, phase)) ?? 0;
+}

package/.pi/lib/harness-phase-worker.ts

@@ -0,0 +1,23 @@
+/**
+ * Phase worker resume eligibility (HARNESS_PHASE_WORKER=1 spike).
+ * Never resume across evaluator ↔ adversary — preserves generator–evaluator isolation.
+ */
+
+const DEBATE_ISOLATION_PAIRS = new Set([
+	"harness/planning/plan-evaluator",
+	"harness/planning/plan-adversary",
+]);
+
+export function isHarnessPhaseWorkerEnabled(): boolean {
+	return process.env.HARNESS_PHASE_WORKER === "1";
+}
+
+export function phaseWorkerResumeEligible(
+	priorAgent: string | null,
+	nextAgent: string,
+): boolean {
+	if (!isHarnessPhaseWorkerEnabled()) return false;
+	if (!priorAgent || priorAgent !== nextAgent) return false;
+	if (DEBATE_ISOLATION_PAIRS.has(nextAgent)) return false;
+	return true;
+}

package/.pi/lib/harness-plan-fsm.ts

@@ -0,0 +1,162 @@
+/**
+ * Plan-phase finite state machine — deterministic next action for parent orchestrator.
+ */
+
+import { join } from "node:path";
+import { canAutoApprovePlan } from "./harness-auto-approve.js";
+import { derivePlanRouteSpawns } from "./harness-plan-route.js";
+import { validatePlanApprovalReadiness } from "./plan-approval-readiness.js";
+import { loadPlanDebateEligibilitySnapshot } from "./plan-debate-eligibility-snapshot.js";
+import { validatePlanDebateGate } from "./plan-debate-gate.js";
+import { getPlanDebateRoundStatus } from "./plan-debate-round-status.js";
+import { resolvePlanHumanGateStatus } from "./plan-human-gates.js";
+import { loadMessengerState } from "./plan-messenger.js";
+import { readTaskClarificationDoc } from "./plan-task-clarification.js";
+
+export type PlanFsmActionKind = "spawn" | "tool" | "gate" | "wait_user";
+
+export interface PlanFsmNextAction {
+	phase: string;
+	action: PlanFsmActionKind;
+	agents?: string[];
+	tool?: string;
+	rationale: string[];
+	review_gate_mode?: string;
+	synthesis_route?: string;
+}
+
+export interface PlanFsmInput {
+	projectRoot: string;
+	runId: string;
+	entries: unknown[];
+	quick?: boolean;
+	taskSummary?: string;
+	lastOutcome?: string | null;
+}
+
+export async function derivePlanNextAction(
+	input: PlanFsmInput,
+): Promise<PlanFsmNextAction> {
+	const { projectRoot, runId, entries } = input;
+	const runDir = join(projectRoot, ".pi", "harness", "runs", runId);
+	const gateStatus = await resolvePlanHumanGateStatus(
+		projectRoot,
+		runId,
+		entries,
+		{
+			quick: input.quick,
+			taskSummary: input.taskSummary,
+			lastOutcome: input.lastOutcome,
+		},
+	);
+
+	if (!gateStatus.phase0Ready) {
+		return {
+			phase: "0",
+			action: gateStatus.phase0NeedsAskUser ? "wait_user" : "tool",
+			tool: gateStatus.phase0NeedsAskUser
+				? "ask_user"
+				: "write_harness_yaml + harness_artifact_ready (task-clarification)",
+			rationale: [
+				gateStatus.nextRequiredAction ?? "Complete Phase 0 task clarification",
+			],
+		};
+	}
+
+	const clarDoc = await readTaskClarificationDoc(runDir);
+	const resolvedRisk = String(clarDoc?.risk_level ?? "med");
+
+	const route = await derivePlanRouteSpawns(runDir, {
+		risk_level: resolvedRisk,
+	});
+	if (route.agents.length > 0) {
+		return {
+			phase: "2-4",
+			action: "spawn",
+			agents: route.agents,
+			synthesis_route: route.route,
+			rationale: route.rationale,
+		};
+	}
+
+	const eligibility = await loadPlanDebateEligibilitySnapshot(runDir);
+	const messenger = await loadMessengerState(runDir);
+	if (!messenger) {
+		return {
+			phase: "5",
+			action: "tool",
+			tool: "harness_plan_debate_eligibility then harness_debate_open",
+			rationale: ["Review Gate not opened — run eligibility then debate_open"],
+			review_gate_mode: eligibility?.review_gate_strategy.mode,
+		};
+	}
+
+	const roundStatus = await getPlanDebateRoundStatus(runDir, 1, runId);
+	if (!roundStatus.ready_for_integrator && roundStatus.next_tool) {
+		return {
+			phase: "5",
+			action: roundStatus.next_tool.startsWith("subagent") ? "spawn" : "tool",
+			tool: roundStatus.next_tool.startsWith("subagent")
+				? undefined
+				: roundStatus.next_tool,
+			agents: roundStatus.next_tool.includes("parallel batch")
+				? ["harness/planning/plan-evaluator", "harness/planning/plan-adversary"]
+				: roundStatus.next_tool.startsWith("subagent")
+					? [
+							roundStatus.next_tool.replace(/^subagent\s+/, "").split(" ")[0] ??
+								"",
+						]
+					: undefined,
+			review_gate_mode: messenger.review_gate_mode,
+			rationale: [
+				`Review Gate in progress (missing: ${roundStatus.missing.slice(0, 3).join(", ")})`,
+			],
+		};
+	}
+
+	if (gateStatus.debateRequired) {
+		return {
+			phase: "5",
+			action: "tool",
+			tool: "harness_debate_consensus",
+			rationale: [
+				gateStatus.debateRecoveryHint ??
+					"Complete debate consensus before approval",
+			],
+			review_gate_mode: messenger.review_gate_mode,
+		};
+	}
+
+	if (gateStatus.approvalRequired && !gateStatus.approvalRecorded) {
+		const readiness = await validatePlanApprovalReadiness(projectRoot, runId, {
+			risk_level: resolvedRisk,
+		});
+		const debateGate = await validatePlanDebateGate(
+			projectRoot,
+			runId,
+			eligibility ?? undefined,
+		);
+		const auto = await canAutoApprovePlan({
+			projectRoot,
+			runId,
+			riskLevel: resolvedRisk,
+			readiness,
+			debateGate,
+		});
+		return {
+			phase: "6",
+			action: auto.allowed ? "tool" : "gate",
+			tool: auto.allowed ? "approve_plan (auto)" : "approve_plan",
+			rationale: auto.allowed
+				? ["deterministic gates pass — auto-approve eligible"]
+				: ["plan ready — user approval required", ...auto.reasons],
+		};
+	}
+
+	return {
+		phase: "6",
+		action: "tool",
+		tool: "create_plan",
+		rationale: ["plan approved — write plan-packet.yaml via create_plan"],
+	};
+}

package/.pi/lib/harness-plan-route.ts

@@ -0,0 +1,134 @@
+/**
+ * Plan synthesis routing — sequential vs plan-synthesizer path.
+ */
+
+import { constants } from "node:fs";
+import { access, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+
+export type PlanSynthesisRoute = "sequential" | "synthesizer";
+
+export const PLAN_SYNTHESIS_ROUTE_ARTIFACT =
+	"artifacts/plan-synthesis-route.yaml";
+
+const SYNTHESIZER_ARTIFACTS = [
+	"artifacts/decomposition.yaml",
+	"artifacts/hypothesis.yaml",
+	"artifacts/execution-plan-draft.yaml",
+] as const;
+
+async function fileExists(path: string): Promise<boolean> {
+	try {
+		await access(path, constants.R_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export async function synthesizerArtifactsComplete(
+	runDir: string,
+): Promise<boolean> {
+	for (const rel of SYNTHESIZER_ARTIFACTS) {
+		if (!(await fileExists(join(runDir, rel)))) return false;
+	}
+	return true;
+}
+
+export async function synthesizerAllowsRespawn(
+	runDir: string,
+): Promise<boolean> {
+	if (!(await synthesizerArtifactsComplete(runDir))) return true;
+	for (const rel of SYNTHESIZER_ARTIFACTS) {
+		try {
+			const raw = await readFile(join(runDir, rel), "utf-8");
+			const doc = parseYaml(raw) as Record<string, unknown>;
+			const status = String(doc?.status ?? "ok").toLowerCase();
+			if (status === "partial" || status === "failed" || status === "error") {
+				return true;
+			}
+		} catch {
+			return true;
+		}
+	}
+	return false;
+}
+
+export interface PlanRouteInput {
+	risk_level?: string;
+	material_fork?: boolean;
+}
+
+export function defaultSynthesisRoute(
+	input: PlanRouteInput,
+): PlanSynthesisRoute {
+	const risk = String(input.risk_level ?? "med").toLowerCase();
+	if (input.material_fork || risk === "high") return "sequential";
+	if (risk === "low" || risk === "med") return "synthesizer";
+	return "sequential";
+}
+
+export async function planSynthesisPath(
+	runDir: string,
+	input?: PlanRouteInput,
+): Promise<PlanSynthesisRoute> {
+	const routePath = join(runDir, PLAN_SYNTHESIS_ROUTE_ARTIFACT);
+	if (await fileExists(routePath)) {
+		try {
+			const raw = await readFile(routePath, "utf-8");
+			const doc = parseYaml(raw) as Record<string, unknown>;
+			const route = String(doc.route ?? "").toLowerCase();
+			if (route === "synthesizer" || route === "sequential") return route;
+		} catch {
+			// fall through
+		}
+	}
+	if (await synthesizerArtifactsComplete(runDir)) return "synthesizer";
+	return defaultSynthesisRoute(input ?? {});
+}
+
+export interface PlanRouteNextSpawn {
+	agents: string[];
+	route: PlanSynthesisRoute;
+	rationale: string[];
+}
+
+export async function derivePlanRouteSpawns(
+	runDir: string,
+	input?: PlanRouteInput,
+): Promise<PlanRouteNextSpawn> {
+	const route = await planSynthesisPath(runDir, input);
+	const rationale: string[] = [`synthesis route: ${route}`];
+	if (route === "synthesizer") {
+		if (await synthesizerArtifactsComplete(runDir)) {
+			return {
+				route,
+				agents: ["harness/planning/execution-plan-author"],
+				rationale: [
+					...rationale,
+					"synthesizer artifacts complete — advance to execution-plan-author",
+				],
+			};
+		}
+		return {
+			route,
+			agents: ["harness/planning/plan-synthesizer"],
+			rationale: [
+				...rationale,
+				"single spawn for decomposition + hypothesis + draft",
+			],
+		};
+	}
+	const agents: string[] = [];
+	if (!(await fileExists(join(runDir, "artifacts/decomposition.yaml")))) {
+		agents.push("harness/planning/decompose");
+	} else if (!(await fileExists(join(runDir, "artifacts/hypothesis.yaml")))) {
+		agents.push("harness/planning/hypothesis");
+	} else if (
+		!(await fileExists(join(runDir, "artifacts/execution-plan-draft.yaml")))
+	) {
+		agents.push("harness/planning/execution-plan-author");
+	}
+	return { route, agents, rationale };
+}

package/.pi/lib/harness-posthog.ts

@@ -33,7 +33,10 @@ export type HarnessPostHogEventName =
 	| "harness_subagent_result_wait"
 	| "harness_subagent_setup"
 	| "harness_phase_completed"
-	| "harness_blackboard_op";
+	| "harness_blackboard_op"
+	| "harness_auto_compact"
+	| "harness_plan_fsm"
+	| "harness_plan_route";
 
 const SCHEMA_VERSION = "1.0.0";