ultimate-pi 0.6.0 → 0.7.0

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

@@ -7,6 +7,7 @@
 
 import { randomUUID } from "node:crypto";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { getRunIdFromSession } from "../lib/harness-run-context.js";
 
 type HarnessPhase = "plan" | "execute" | "evaluate" | "adversary" | "merge";
 type ObservationKind =
@@ -77,15 +78,12 @@ function nowIso(): string {
 function getRunId(ctx: {
 	sessionManager: { getEntries(): unknown[]; getSessionId(): string };
 }): string {
-	const entries = ctx.sessionManager.getEntries() as SessionEntryLike[];
-	for (let i = entries.length - 1; i >= 0; i--) {
-		const entry = entries[i];
-		if (entry.type !== "custom" || entry.customType !== "harness-trace-state")
-			continue;
-		const runId = entry.data?.run_id;
-		if (typeof runId === "string" && runId.length > 0) return runId;
-	}
-	return ctx.sessionManager.getSessionId();
+	return (
+		getRunIdFromSession(
+			ctx.sessionManager.getEntries(),
+			ctx.sessionManager.getSessionId(),
+		) ?? ctx.sessionManager.getSessionId()
+	);
 }
 
 export default function observationBus(pi: ExtensionAPI) {

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

@@ -9,6 +9,17 @@
  */
 
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import {
+	getLatestRunContext,
+	getPolicyTransitionBlock,
+	hasApprovedPlanSignalFromUserPrompt,
+	hasHarnessAbortSignal,
+	inferHarnessPhaseFromPrompt,
+	isHarnessBootstrapPrompt,
+	saveProjectActiveRun,
+	saveRunContextToDisk,
+	userVisiblePromptSlice,
+} from "../lib/harness-run-context.js";
 
 type HarnessPhase = "plan" | "execute" | "evaluate" | "adversary" | "merge";
 
@@ -70,65 +81,17 @@ function defaultState(): PolicyState {
 	};
 }
 
-function isBootstrapPrompt(prompt: string): boolean {
-	const p = prompt.toLowerCase();
-	return (
-		p.includes("/harness-setup") ||
-		p.includes("harness-setup") ||
-		p.includes("full harness bootstrap")
-	);
-}
-
-function inferPhase(prompt: string, _current: HarnessPhase): HarnessPhase {
-	const p = prompt.toLowerCase();
-	if (
-		p.includes("/harness-plan") ||
-		p.includes("harness-plan") ||
-		p.includes("/harness-auto") ||
-		p.includes("harness-auto")
-	)
-		return "plan";
-	if (p.includes("/harness-run") || p.includes("harness-run")) return "execute";
-	if (p.includes("/harness-eval") || p.includes("harness-eval"))
-		return "evaluate";
-	if (p.includes("/harness-review") || p.includes("harness-review"))
-		return "evaluate";
-	if (p.includes("/harness-critic") || p.includes("harness-critic"))
-		return "adversary";
-	if (p.includes("adversary")) return "adversary";
-	if (p.includes("merge gate") || p.includes("policy decision")) return "merge";
-	return "execute";
-}
-
-function hasApprovedPlanSignal(prompt: string): boolean {
-	const p = prompt.toLowerCase();
-	return (
-		p.includes("planpacket") ||
-		p.includes("--plan") ||
-		p.includes("approved plan") ||
-		p.includes("plan_id")
-	);
-}
-
-function hasAbortSignal(prompt: string): boolean {
-	const p = prompt.toLowerCase();
-	return p.includes("/harness-abort") || p.includes("harness-abort");
-}
-
-function isValidTransition(from: HarnessPhase, to: HarnessPhase): boolean {
-	if (from === to) return true;
-	if (to === "plan") return true;
-	if (to === "execute") return true;
-	const fromIndex = PHASE_ORDER.indexOf(from);
-	const toIndex = PHASE_ORDER.indexOf(to);
-	return toIndex === fromIndex + 1;
+function hasApprovedPlanSignal(prompt: string, entries: unknown[]): boolean {
+	const runCtx = getLatestRunContext(entries);
+	if (runCtx?.plan_ready) return true;
+	return hasApprovedPlanSignalFromUserPrompt(prompt);
 }
 
 function isMutatingBash(command: string): boolean {
 	return BASH_MUTATION_PATTERNS.some((pattern) => pattern.test(command));
 }
 
-function getLatestPolicyState(ctx: {
+function getLatestPolicyStateFull(ctx: {
 	sessionManager: { getEntries(): unknown[] };
 }): PolicyState {
 	const entries = ctx.sessionManager.getEntries() as SessionEntryLike[];
@@ -172,12 +135,14 @@ export default function policyGate(pi: ExtensionAPI) {
 	let state = defaultState();
 
 	pi.on("session_start", async (_event, ctx) => {
-		state = getLatestPolicyState(ctx);
+		state = getLatestPolicyStateFull(ctx);
 	});
 
-	pi.on("before_agent_start", async (event) => {
-		const bootstrapPrompt = isBootstrapPrompt(event.prompt);
-		const abortSignal = hasAbortSignal(event.prompt);
+	pi.on("before_agent_start", async (event, ctx) => {
+		const userPrompt = userVisiblePromptSlice(event.prompt);
+		const entries = ctx.sessionManager.getEntries();
+		const bootstrapPrompt = isHarnessBootstrapPrompt(userPrompt);
+		const abortSignal = hasHarnessAbortSignal(userPrompt);
 
 		// /harness-setup instructions mention `harness-plan` (e.g. gh label text). That
 		// substring must not force inferPhase() to "plan" or bootstrap stays blocked.
@@ -220,18 +185,17 @@ export default function policyGate(pi: ExtensionAPI) {
 			};
 		}
 
-		const nextPhase = inferPhase(event.prompt, state.phase);
-		const planSignal = hasApprovedPlanSignal(event.prompt);
+		const nextPhase = inferHarnessPhaseFromPrompt(userPrompt);
+		const planSignal = hasApprovedPlanSignal(userPrompt, entries);
 
-		if (!isValidTransition(state.phase, nextPhase)) {
+		const transitionBlock = getPolicyTransitionBlock(userPrompt, entries);
+		if (transitionBlock.blocked) {
 			return {
 				message: {
 					customType: "harness-policy-violation",
 					display: true,
-					content: [
-						`Policy gate blocked invalid phase transition: ${state.phase} -> ${nextPhase}.`,
-						"Run /harness-plan first or continue in the current phase.",
-					].join("\n"),
+					content:
+						transitionBlock.message ?? "Policy gate blocked this command.",
 				},
 			};
 		}
@@ -242,13 +206,16 @@ export default function policyGate(pi: ExtensionAPI) {
 		}
 
 		if (nextPhase === "execute" && !state.approvedPlan && !planSignal) {
-			// Softened enforcement: flow mode defaults to execute without hard plan requirement.
-			state.approvedPlan = true;
+			const runCtx = getLatestRunContext(entries);
+			if (runCtx?.plan_ready) {
+				state.approvedPlan = true;
+				state.planId = runCtx.plan_id ?? state.planId;
+			}
 		}
 
 		if (planSignal) {
 			state.approvedPlan = true;
-			const planMatch = event.prompt.match(
+			const planMatch = userPrompt.match(
 				/plan[_-]?id["'\s:=]+([A-Za-z0-9._:-]+)/i,
 			);
 			state.planId = planMatch?.[1] ?? state.planId;
@@ -318,6 +285,21 @@ export default function policyGate(pi: ExtensionAPI) {
 			state.updatedAt = state.abortedAt;
 			pi.appendEntry("harness-policy-state", state);
 
+			const runCtx = getLatestRunContext(ctx.sessionManager.getEntries());
+			if (runCtx) {
+				runCtx.status = "aborted";
+				runCtx.plan_ready = false;
+				runCtx.last_outcome = "aborted";
+				runCtx.last_completed_step = "abort";
+				runCtx.next_recommended_command = runCtx.task_summary
+					? `/harness-plan "${runCtx.task_summary}"`
+					: '/harness-plan "<task>"';
+				runCtx.updated_at = state.abortedAt ?? nowIso();
+				pi.appendEntry("harness-run-context", runCtx);
+				void saveRunContextToDisk(runCtx);
+				void saveProjectActiveRun(runCtx);
+			}
+
 			const lines = [
 				"Harness run aborted safely.",
 				"  phase: plan",
@@ -342,7 +324,7 @@ export default function policyGate(pi: ExtensionAPI) {
 	pi.registerCommand("harness-policy-status", {
 		description: "Show current harness policy gate state",
 		handler: async (_args, ctx) => {
-			const latest = getLatestPolicyState(ctx);
+			const latest = getLatestPolicyStateFull(ctx);
 			const lines = [
 				"Harness policy gate:",
 				`  phase: ${latest.phase}`,

package/.pi/extensions/trace-recorder.ts

@@ -10,10 +10,17 @@
 import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import {
+	getLatestRunContext,
+	getRunIdFromSession,
+	type HarnessPhase,
+	isHarnessSlashCommand,
+	loadRunContextFromDisk,
+	phaseTraceFileName,
+	saveRunContextToDisk,
+} from "../lib/harness-run-context.js";
 import { captureHarnessEvent } from "./lib/harness-posthog.js";
 
-type HarnessPhase = "plan" | "execute" | "evaluate" | "adversary" | "merge";
-
 interface ToolSpan {
 	tool_call_id: string;
 	tool_name: string;
@@ -52,10 +59,6 @@ function nowIso(): string {
 	return new Date().toISOString();
 }
 
-function makeRunId(sessionId: string): string {
-	return `${sessionId}-${Date.now()}`;
-}
-
 function parsePhase(ctx: {
 	sessionManager: { getEntries(): unknown[] };
 }): HarnessPhase {
@@ -165,8 +168,22 @@ async function readRunTraceSchemaVersion(): Promise<string> {
 	}
 }
 
+function resolveRunIdForAgentStart(
+	ctx: { sessionManager: { getEntries(): unknown[]; getSessionId(): string } },
+	prompt: string,
+): string {
+	const entries = ctx.sessionManager.getEntries();
+	const sessionId = ctx.sessionManager.getSessionId();
+	const fromSession = getRunIdFromSession(entries, sessionId);
+	if (fromSession && isHarnessSlashCommand(prompt)) return fromSession;
+	const runCtx = getLatestRunContext(entries);
+	if (runCtx && isHarnessSlashCommand(prompt)) return runCtx.run_id;
+	return `${sessionId}-${Date.now()}`;
+}
+
 export default function traceRecorder(pi: ExtensionAPI) {
 	let activeRun: ActiveRun | null = null;
+	let lastUserPrompt = "";
 
 	async function writeEvent(
 		runId: string,
@@ -180,14 +197,25 @@ export default function traceRecorder(pi: ExtensionAPI) {
 		);
 	}
 
+	pi.on("before_agent_start", async (event) => {
+		lastUserPrompt = event.prompt;
+	});
+
 	pi.on("agent_start", async (_event, ctx) => {
+		if (!isHarnessSlashCommand(lastUserPrompt)) {
+			activeRun = null;
+			return;
+		}
+
 		const sessionId = ctx.sessionManager.getSessionId();
-		const runId = makeRunId(sessionId);
+		const entries = ctx.sessionManager.getEntries();
+		const runId = resolveRunIdForAgentStart(ctx, lastUserPrompt);
 		const startedAt = nowIso();
+		const phase = parsePhase(ctx);
 		activeRun = {
 			runId,
 			planId: parsePlanId(ctx),
-			phase: parsePhase(ctx),
+			phase,
 			startedAt,
 			toolSpans: new Map(),
 			artifactRefs: new Set(),
@@ -198,15 +226,29 @@ export default function traceRecorder(pi: ExtensionAPI) {
 			phase: activeRun.phase,
 			started_at: startedAt,
 		});
-		captureHarnessEvent(sessionId, "harness_run_started", {
-			harness_run_id: runId,
-			harness_plan_id: activeRun.planId,
-			harness_phase: activeRun.phase,
-			pi_session_id: sessionId,
-			model: ctx.model?.id ?? "unknown",
-			thinking_level:
-				pi.getThinkingLevel() === "minimal" ? "off" : pi.getThinkingLevel(),
-		});
+
+		const runCtx = getLatestRunContext(entries);
+		const projectRoot = process.cwd();
+		const diskCtx =
+			runCtx ?? (await loadRunContextFromDisk(runId, projectRoot));
+		const shouldEmitStarted = !diskCtx?.harness_run_started_emitted;
+		if (shouldEmitStarted) {
+			captureHarnessEvent(sessionId, "harness_run_started", {
+				harness_run_id: runId,
+				harness_plan_id: activeRun.planId,
+				harness_phase: activeRun.phase,
+				pi_session_id: sessionId,
+				model: ctx.model?.id ?? "unknown",
+				thinking_level:
+					pi.getThinkingLevel() === "minimal" ? "off" : pi.getThinkingLevel(),
+			});
+			if (diskCtx) {
+				diskCtx.harness_run_started_emitted = true;
+				await saveRunContextToDisk(diskCtx);
+				pi.appendEntry("harness-run-context", diskCtx);
+			}
+		}
+
 		await writeEvent(runId, {
 			type: "run_start",
 			run_id: runId,
@@ -282,6 +324,12 @@ export default function traceRecorder(pi: ExtensionAPI) {
 			cost: usage,
 		};
 
+		const phaseFile = phaseTraceFileName(activeRun.phase);
+		await writeFile(
+			join(runDir, phaseFile),
+			`${JSON.stringify(summary, null, 2)}\n`,
+			"utf-8",
+		);
 		await writeFile(
 			join(runDir, "trace.json"),
 			`${JSON.stringify(summary, null, 2)}\n`,
@@ -313,7 +361,7 @@ export default function traceRecorder(pi: ExtensionAPI) {
 	});
 
 	pi.registerCommand("harness-trace-last", {
-		description: "Show last recorded run trace id",
+		description: "Show last harness trace phase summary (no run id)",
 		handler: async (_args, ctx) => {
 			const entries = ctx.sessionManager.getEntries();
 			for (let i = entries.length - 1; i >= 0; i--) {
@@ -322,8 +370,20 @@ export default function traceRecorder(pi: ExtensionAPI) {
 					entry.type === "custom" &&
 					entry.customType === "harness-run-trace"
 				) {
-					const data = entry.data as { run_id?: string } | undefined;
-					const msg = `Last run trace: ${data?.run_id ?? "(unknown)"}`;
+					const data = entry.data as
+						| {
+								phase?: string;
+								tool_span_count?: number;
+						  }
+						| undefined;
+					const handoff = getLatestRunContext(entries);
+					const next =
+						handoff?.next_recommended_command ?? "/harness-run-status";
+					const msg = [
+						`Last harness trace: phase ${data?.phase ?? "unknown"}`,
+						`tool spans: ${data?.tool_span_count ?? 0}`,
+						`Next: ${next}`,
+					].join("\n");
 					if (ctx.hasUI) {
 						ctx.ui.notify(msg, "info");
 					} else {

package/.pi/harness/README.md

@@ -29,6 +29,8 @@ Governance/runtime enforcement for this harness is implemented as Pi extensions
 under `.pi/extensions/` and auto-loaded through the package `pi.extensions`
 manifest (`package.json`).
 
+- `harness-run-context.ts` - active run + plan injection; short commands without run/plan args
+- `harness-live-widget.ts` - footer status (phase, plan ready, next command; no run id in UI)
 - `policy-gate.ts` - phase state machine + plan-before-mutate enforcement
 - `budget-guard.ts` - hard-stop token budget checks + budget exhausted artifacts
 - `trace-recorder.ts` - append-only run traces + HarnessRunRecord + compact index

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

@@ -1,12 +1,12 @@
 {
 	"schema_version": "1.0.0",
 	"package": "ultimate-pi",
-	"package_version": "0.3.1",
-	"generated_at": "2026-05-16T08:44:48.417Z",
+	"package_version": "0.6.1",
+	"generated_at": "2026-05-17T06:10:49.269Z",
 	"agents": {
 		"pi-pi/agent-expert": {
 			"path": ".pi/agents/pi-pi/agent-expert.md",
-			"sha256": "f52f7310adc28c3e51fc21f7e82eb3c0ec8abf33a1936518355c673b21b9a706"
+			"sha256": "86561eb092b92fa43f221bfc6305de8d5afe10d43c5f577b9bf15a71bda051c6"
 		},
 		"pi-pi/cli-expert": {
 			"path": ".pi/agents/pi-pi/cli-expert.md",

package/.pi/harness/docs/adrs/0009-sentrux-rules-lifecycle.md

@@ -15,7 +15,7 @@ Sentrux enforces architecture via [`.sentrux/rules.toml`](https://sentrux.dev/do
 4. **Re-sync command:** `node "$UP_PKG/.pi/scripts/sentrux-rules-sync.mjs" --force` or `harness-sentrux-bootstrap.mjs --force` (resolve `$UP_PKG` via [.pi/scripts/README.md](../../../scripts/README.md)).
 5. **Pi command:** `/harness-sentrux-sync` via `sentrux-rules-sync.ts` extension.
 6. **When to sync:**
-   - `/harness-setup` Step 4.3 (after sentrux CLI install in Step 2.8)
+   - `/harness-setup` Step 4.2 (after sentrux CLI install in Step 2.8)
    - After editing `architecture.manifest.json`
    - On `agent_end` when harness phase is `plan` or `merge`
    - `node "$UP_PKG/.pi/scripts/harness-verify.mjs"` fails if manifest hash ≠ last sync (`--check`)

package/.pi/harness/docs/adrs/0031-harness-run-context.md

@@ -0,0 +1,38 @@
+# ADR 0031: Harness active run context
+
+- **Status:** Accepted
+- **Date:** 2026-05-17
+
+## Context
+
+Manual harness steps required copying `run_id` and `plan-packet.json` paths between commands. `trace-recorder` minted a new `run_id` on every `agent_start`, splitting artifacts across phases. The live widget exposed raw trace ids.
+
+## Decision
+
+1. Add `.pi/lib/harness-run-context.ts` and `harness-run-context.ts` extension as the single source of truth for active runs.
+2. Persist mirrors:
+   - `.pi/harness/runs/<run_id>/run-context.json`
+   - `.pi/harness/active-run.json` (cross-session pointer for forked eval)
+3. Canonical plan path: `.pi/harness/runs/<run_id>/plan-packet.json` — injected via `[HarnessActivePlan]`; no `--plan` on the happy path.
+4. **Hook order:** `harness-run-context` `before_agent_start` allocates/reuses `run_id` before `trace-recorder` `agent_start`. Trace writes phase files `trace-<phase>.json` plus rollup `trace.json`.
+5. PostHog `harness_run_started` at most once per logical `run_id`.
+6. Short commands: `/harness-run`, `/harness-eval`, etc. without args; recovery via `/harness-run-status`, `/harness-use-run`.
+7. Review isolation unchanged: after execute, handoff says **new Pi session → `/harness-eval`**; project `active-run.json` binds forked sessions.
+8. `hasApprovedPlanSignal` uses user-visible prompt only; execute requires `plan_ready` from disk validation.
+
+## Consequences
+
+### Positive
+
+- One logical run per manual/auto pipeline; forensics and telemetry align.
+- Users never copy run ids or plan paths in normal workflows.
+
+### Negative
+
+- Extension ordering and disk reconciliation must stay correct when adding new harness commands.
+
+## References
+
+- `.pi/lib/harness-run-context.ts`
+- `.pi/extensions/harness-run-context.ts`
+- `.pi/harness/specs/harness-run-context.schema.json`

package/.pi/harness/docs/adrs/README.md

@@ -16,6 +16,7 @@ Team-shared ADRs for the ultimate-pi harness live under `.pi/harness/docs/adrs/`
 | [0008](0008-harness-posthog-telemetry.md) | Harness PostHog telemetry | Accepted |
 | [0009](0009-sentrux-rules-lifecycle.md) | Sentrux rules.toml lifecycle | Accepted |
 | [0030](0030-inhouse-vcc-compaction.md) | In-house VCC compaction (vendored pi-vcc) | Accepted |
+| [0031](0031-harness-run-context.md) | Harness active run context | Accepted |
 
 ## Template
 

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

@@ -1,30 +1,44 @@
 # ultimate-pi harness — local secrets and paths (gitignored .env)
-# Fill in values below; re-run /harness-setup to add newly introduced keys only.
+# Created by /harness-setup (harness-sync-env.mjs). Re-run setup to append newly introduced keys only.
 
-# Telemetry (set false to disable harness PostHog events)
+# --- Telemetry ---
+# Harness domain events (harness-telemetry.ts); set false to disable harness_* only
 HARNESS_TELEMETRY_ENABLED=true
 
-# harness-web (Scrapling scrape + pluggable search)
+# --- harness-web (Scrapling scrape + pluggable search) ---
 HARNESS_WEB_FETCH_MODE=stealth
 HARNESS_WEB_SEARCH_ENGINE=ddg_html
-# SearXNG (when HARNESS_WEB_SEARCH_ENGINE=searxng):
+# When HARNESS_WEB_SEARCH_ENGINE=searxng (bootstrap via harness-searxng-bootstrap.mjs):
 # HARNESS_WEB_SEARXNG_URL=http://127.0.0.1:8080
 # HARNESS_WEB_PROXY=
 # HARNESS_WEB_RATE_LIMIT_MS=2000
 # HARNESS_WEB_TIMEOUT_MS=30000
 
-# PostHog (optional)
+# --- VCC compaction (env-only; no JSON config files) ---
+# Default: VCC handles /compact and auto-compaction. Set false for Pi LLM compaction:
+# HARNESS_VCC_COMPACTION=false
+# HARNESS_VCC_DEBUG=true
+
+# --- PostHog (optional) ---
+# Project key — required for harness_* telemetry when HARNESS_TELEMETRY_ENABLED=true
 # POSTHOG_API_KEY=
+# POSTHOG_HOST=https://us.i.posthog.com
+# POSTHOG_ENABLED=true
 # POSTHOG_PROJECT_NAME=ultimate-pi
 # POSTHOG_PRIVACY_MODE=false
+# Personal API key — PostHog MCP / posthog-analyst skill only
+# POSTHOG_PERSONAL_API_KEY=
+# POSTHOG_MCP_FEATURES=llm_analytics
 
-# Graphify semantic extract (optional; `graphify update .` needs no key)
+# --- Graphify semantic extract (optional; `graphify update .` needs no key) ---
 # GEMINI_API_KEY=
 # GOOGLE_API_KEY=
 # OPENAI_API_KEY=
+# OPENAI_API_BASE=
 
-# Pi VCC compaction config path (project-relative)
-PI_VCC_CONFIG_PATH=.pi/pi-vcc-config.json
+# --- Wiki / Obsidian vault (optional) ---
+VAULT_WIKI_PATH=vault/wiki
 
-# Wiki / vault (optional — Obsidian layer)
-# VAULT_WIKI_PATH=vault/wiki
+# --- Sentrux gate (optional) ---
+# Require Sentrux stub for harness-verify (see .pi/scripts/harness-verify.mjs)
+# HARNESS_SENTRUX_REQUIRED=true

package/.pi/harness/evals/smoke/run-context.fixture.json

@@ -0,0 +1,17 @@
+{
+	"schema_version": "1.0.0",
+	"run_id": "smoke-session-1",
+	"pi_session_id": "smoke-session",
+	"project_root": "/tmp/ultimate-pi-smoke",
+	"phase": "plan",
+	"plan_id": null,
+	"plan_packet_path": "/tmp/ultimate-pi-smoke/.pi/harness/runs/smoke-session-1/plan-packet.json",
+	"plan_ready": false,
+	"task_summary": "smoke task",
+	"status": "active",
+	"last_completed_step": null,
+	"last_outcome": null,
+	"next_recommended_command": "/harness-plan \"smoke task\"",
+	"owner_pi_session_id": "smoke-session",
+	"updated_at": "2026-05-17T00:00:00.000Z"
+}

package/.pi/harness/specs/harness-run-context.schema.json

@@ -0,0 +1,80 @@
+{
+	"$schema": "https://json-schema.org/draft/2020-12/schema",
+	"$id": "https://ultimate-pi.local/.pi/harness/specs/harness-run-context.schema.json",
+	"title": "HarnessRunContext",
+	"description": "Session- and disk-backed active harness run pointer.",
+	"type": "object",
+	"additionalProperties": false,
+	"required": [
+		"schema_version",
+		"run_id",
+		"pi_session_id",
+		"project_root",
+		"phase",
+		"plan_ready",
+		"status",
+		"owner_pi_session_id",
+		"updated_at"
+	],
+	"properties": {
+		"schema_version": {
+			"type": "string",
+			"const": "1.0.0"
+		},
+		"run_id": {
+			"type": "string",
+			"minLength": 1
+		},
+		"pi_session_id": {
+			"type": "string",
+			"minLength": 1
+		},
+		"project_root": {
+			"type": "string",
+			"minLength": 1
+		},
+		"phase": {
+			"type": "string",
+			"enum": ["plan", "execute", "evaluate", "adversary", "merge"]
+		},
+		"plan_id": {
+			"type": ["string", "null"]
+		},
+		"plan_packet_path": {
+			"type": ["string", "null"]
+		},
+		"plan_ready": {
+			"type": "boolean"
+		},
+		"task_summary": {
+			"type": ["string", "null"]
+		},
+		"status": {
+			"type": "string",
+			"enum": ["active", "aborted", "completed"]
+		},
+		"last_completed_step": {
+			"type": ["string", "null"]
+		},
+		"last_outcome": {
+			"type": ["string", "null"]
+		},
+		"next_recommended_command": {
+			"type": ["string", "null"]
+		},
+		"owner_pi_session_id": {
+			"type": "string",
+			"minLength": 1
+		},
+		"updated_at": {
+			"type": "string",
+			"format": "date-time"
+		},
+		"harness_run_started_emitted": {
+			"type": "boolean"
+		},
+		"turn_override_run_id": {
+			"type": ["string", "null"]
+		}
+	}
+}