ultimate-pi 0.6.1 → 0.8.0

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

@@ -8,7 +8,25 @@
  * - command surface via pi.registerCommand()
  */
 
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+	extractWritePathFromToolInput,
+	getLatestRunContext,
+	getPolicyTransitionBlock,
+	hasApprovedPlanSignalFromUserPrompt,
+	hasHarnessAbortSignal,
+	inferHarnessPhaseFromPrompt,
+	isHarnessAutoSession,
+	isHarnessBootstrapPrompt,
+	isPlanPhaseAllowedMutation,
+	isPlanPhaseScopedWrite,
+	normalizeHarnessPath,
+	readPlanPacketFromPath,
+	saveProjectActiveRun,
+	saveRunContextToDisk,
+	userVisiblePromptSlice,
+	validatePlanPacket,
+} from "../lib/harness-run-context.js";
 
 type HarnessPhase = "plan" | "execute" | "evaluate" | "adversary" | "merge";
 
@@ -70,65 +88,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[];
@@ -171,13 +141,21 @@ function getLatestPolicyState(ctx: {
 export default function policyGate(pi: ExtensionAPI) {
 	let state = defaultState();
 
+	const appendPolicyState = (next: PolicyState): void => {
+		state = next;
+		pi.appendEntry("harness-policy-state", state);
+	};
+
 	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();
+		state = getLatestPolicyStateFull(ctx);
+		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 +198,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 +219,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;
@@ -261,26 +241,41 @@ export default function policyGate(pi: ExtensionAPI) {
 		state.updatedAt = nowIso();
 		pi.appendEntry("harness-policy-state", state);
 
+		const planPhaseHint =
+			state.phase === "plan"
+				? "\nPlan phase: present the full PlanPacket in chat, call ask_user (Approve / Request changes / Cancel), then write only the canonical plan-packet.json after Approve."
+				: "";
+
 		return {
-			systemPrompt: `${event.systemPrompt}\n\n[PolicyGate]\nPhase=${state.phase}; ApprovedPlan=${state.approvedPlan}; PlanId=${state.planId ?? "none"}; Aborted=${state.aborted}.`,
+			systemPrompt: `${event.systemPrompt}\n\n[PolicyGate]\nPhase=${state.phase}; ApprovedPlan=${state.approvedPlan}; PlanId=${state.planId ?? "none"}; Aborted=${state.aborted}.${planPhaseHint}`,
 		};
 	});
 
-	pi.on("tool_call", async (event) => {
-		if (state.aborted && MUTATING_TOOLS.has(event.toolName)) {
-			return {
-				block: true,
-				reason:
-					"policy-gate: mutating tool blocked because harness-abort lock is active. Attach a new approved plan first.",
-			};
-		}
+	pi.on("tool_call", async (event, ctx) => {
+		state = getLatestPolicyStateFull(ctx);
+		const entries = ctx.sessionManager.getEntries();
+		const projectRoot = process.cwd();
+		const sessionId = ctx.sessionManager.getSessionId();
+		const runCtx = getLatestRunContext(entries);
+
 		if (MUTATING_TOOLS.has(event.toolName)) {
-			if (state.phase !== "execute") {
-				return {
-					block: true,
-					reason: `policy-gate: ${event.toolName} blocked in phase '${state.phase}'. Allowed only in execute phase.`,
-				};
+			const decision = await isPlanPhaseAllowedMutation(
+				event.toolName,
+				event.input as Record<string, unknown>,
+				state.phase,
+				runCtx,
+				projectRoot,
+				{
+					aborted: state.aborted,
+					entries,
+					ownerSessionId: runCtx?.owner_pi_session_id,
+					currentSessionId: sessionId,
+				},
+			);
+			if (!decision.allowed) {
+				return { block: true, reason: decision.reason };
 			}
+			return undefined;
 		}
 
 		if (event.toolName === "bash") {
@@ -293,7 +288,7 @@ export default function policyGate(pi: ExtensionAPI) {
 						"policy-gate: mutating bash command blocked because harness-abort lock is active. Attach a new approved plan first.",
 				};
 			}
-			if (state.phase !== "execute") {
+			if (state.phase !== "execute" && state.phase !== "merge") {
 				return {
 					block: true,
 					reason: `policy-gate: mutating bash command blocked in phase '${state.phase}'.`,
@@ -304,6 +299,48 @@ export default function policyGate(pi: ExtensionAPI) {
 		return undefined;
 	});
 
+	pi.on("tool_result", async (event, ctx) => {
+		if (event.isError) return;
+		if (event.toolName !== "write" && event.toolName !== "edit") return;
+
+		const entries = ctx.sessionManager.getEntries();
+		state = getLatestPolicyStateFull(ctx);
+		const projectRoot = process.cwd();
+		const runCtx = getLatestRunContext(entries);
+		if (!runCtx) return;
+
+		const target = extractWritePathFromToolInput(
+			event.input as Record<string, unknown>,
+		);
+		if (!target) return;
+		const scoped = await isPlanPhaseScopedWrite(target, runCtx, projectRoot);
+		if (!scoped) return;
+
+		const planPath = normalizeHarnessPath(target, projectRoot);
+		const packet = await readPlanPacketFromPath(planPath);
+		const validation = validatePlanPacket(packet);
+		if (!validation.valid || !packet?.plan_id) return;
+
+		if (isHarnessAutoSession(entries)) {
+			state.phase = "execute";
+			state.approvedPlan = true;
+			state.planId = packet.plan_id;
+			state.aborted = false;
+			state.abortReason = null;
+			state.abortedAt = null;
+			state.updatedAt = nowIso();
+			appendPolicyState(state);
+
+			runCtx.plan_ready = true;
+			runCtx.plan_id = packet.plan_id;
+			runCtx.phase = "execute";
+			runCtx.updated_at = nowIso();
+			pi.appendEntry("harness-run-context", runCtx);
+			void saveRunContextToDisk(runCtx);
+			void saveProjectActiveRun(runCtx);
+		}
+	});
+
 	pi.registerCommand("harness-abort", {
 		description: "Safely abort current harness run and reset to plan phase",
 		handler: async (args, ctx) => {
@@ -318,6 +355,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 +394,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/provider-payload-sanitize.ts

@@ -9,7 +9,7 @@
 import type {
 	BeforeProviderRequestEvent,
 	ExtensionAPI,
-} from "@mariozechner/pi-coding-agent";
+} from "@earendil-works/pi-coding-agent";
 
 const CHAT_MESSAGE_EXTRA_KEYS = [
 	"reasoning",

package/.pi/extensions/review-integrity.ts

@@ -1,19 +1,34 @@
 /**
  * review-integrity — enforce evaluator/adversary isolation from executor session.
  *
- * If review phases (`evaluate`/`adversary`) run in the same session as execution,
- * tool calls are blocked until the review is isolated (fork/switch session).
+ * Parent orchestrators spawn review agents in isolated subagent sessions.
+ * Direct review tools in the executor session are blocked; Agent/get_subagent_result
+ * for harness review agents remain allowed.
  */
 
 import { appendFile, mkdir } from "node:fs/promises";
 import { join } from "node:path";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 type HarnessPhase = "plan" | "execute" | "evaluate" | "adversary" | "merge";
 
 const INCIDENTS_DIR = join(process.cwd(), ".pi", "harness", "incidents");
 const INCIDENT_FILE = join(INCIDENTS_DIR, "review-integrity.jsonl");
 
+const ORCHESTRATION_TOOLS = new Set([
+	"Agent",
+	"get_subagent_result",
+	"steer_subagent",
+]);
+
+const REVIEW_SUBAGENT_TYPES = new Set([
+	"harness/evaluator",
+	"harness/adversary",
+	"harness/tie-breaker",
+]);
+
+const EXECUTOR_SUBAGENT_TYPE = "harness/executor";
+
 interface IsolationState {
 	executorSessionId: string | null;
 	violationActive: boolean;
@@ -89,6 +104,17 @@ function restoreState(ctx: {
 	};
 }
 
+function subagentTypeFromInput(
+	input: Record<string, unknown> | undefined,
+): string {
+	if (!input) return "";
+	const direct = input.subagent_type;
+	if (typeof direct === "string") return direct;
+	const nested = input as { subagentType?: string };
+	if (typeof nested.subagentType === "string") return nested.subagentType;
+	return "";
+}
+
 async function appendIncident(payload: Record<string, unknown>): Promise<void> {
 	await mkdir(INCIDENTS_DIR, { recursive: true });
 	await appendFile(
@@ -105,6 +131,10 @@ export default function reviewIntegrity(pi: ExtensionAPI) {
 		updatedAt: nowIso(),
 	};
 
+	const persist = (): void => {
+		pi.appendEntry("harness-review-integrity", state);
+	};
+
 	pi.on("session_start", async (_event, ctx) => {
 		state = restoreState(ctx);
 	});
@@ -115,7 +145,7 @@ export default function reviewIntegrity(pi: ExtensionAPI) {
 		state.executorSessionId = ctx.sessionManager.getSessionId();
 		state.violationActive = false;
 		state.updatedAt = nowIso();
-		pi.appendEntry("harness-review-integrity", state);
+		persist();
 	});
 
 	pi.on("before_agent_start", async (_event, ctx) => {
@@ -125,7 +155,7 @@ export default function reviewIntegrity(pi: ExtensionAPI) {
 		if (!inReview) {
 			state.violationActive = false;
 			state.updatedAt = nowIso();
-			pi.appendEntry("harness-review-integrity", state);
+			persist();
 			return undefined;
 		}
 
@@ -135,42 +165,66 @@ export default function reviewIntegrity(pi: ExtensionAPI) {
 		) {
 			state.violationActive = false;
 			state.updatedAt = nowIso();
-			pi.appendEntry("harness-review-integrity", state);
+			persist();
 			return undefined;
 		}
 
 		state.violationActive = true;
 		state.updatedAt = nowIso();
-		pi.appendEntry("harness-review-integrity", state);
-
-		await appendIncident({
-			type: "review_integrity_violation",
-			session_id: currentSessionId,
-			phase,
-			reason:
-				"evaluator/adversary session is not isolated from executor session",
-			mitigation:
-				"fork or switch to a clean review session before running review tools",
-		});
+		persist();
 
 		return {
 			message: {
-				customType: "harness-review-integrity-block",
+				customType: "harness-review-integrity-hint",
 				display: true,
 				content: [
-					"Review integrity violation: evaluator/adversary is sharing executor session context.",
-					"Fork/switch session, then rerun review to maintain independent evaluation guarantees.",
+					"Review phase in executor session: spawn harness/evaluator or harness/adversary via Agent (isolated subagent context).",
+					"Do not run review checks directly in this session — use get_subagent_result after spawn.",
 				].join("\n"),
 			},
 		};
 	});
 
-	pi.on("tool_call", async (_event) => {
+	pi.on("tool_call", async (event, ctx) => {
+		if (event.toolName === "Agent") {
+			const subagentType = subagentTypeFromInput(
+				event.input as Record<string, unknown> | undefined,
+			);
+			if (subagentType === EXECUTOR_SUBAGENT_TYPE) {
+				state.executorSessionId = ctx.sessionManager.getSessionId();
+				state.violationActive = false;
+				state.updatedAt = nowIso();
+				persist();
+				return undefined;
+			}
+			if (REVIEW_SUBAGENT_TYPES.has(subagentType)) {
+				state.violationActive = false;
+				state.updatedAt = nowIso();
+				persist();
+				return undefined;
+			}
+		}
+
 		if (!state.violationActive) return undefined;
+
+		if (ORCHESTRATION_TOOLS.has(event.toolName)) {
+			return undefined;
+		}
+
+		await appendIncident({
+			type: "review_integrity_violation",
+			session_id: ctx.sessionManager.getSessionId(),
+			tool: event.toolName,
+			reason:
+				"direct tool use in review phase while sharing executor session context",
+			mitigation:
+				"spawn harness/evaluator or harness/adversary via Agent instead",
+		});
+
 		return {
 			block: true,
 			reason:
-				"review-integrity: tool call blocked because review session is not isolated from executor context.",
+				"review-integrity: tool blocked in review phase — spawn an isolated review subagent via Agent.",
 		};
 	});
 

package/.pi/extensions/sentrux-rules-sync.ts

@@ -3,7 +3,7 @@
  */
 
 import { spawn } from "node:child_process";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { resolveHarnessScript } from "./lib/harness-paths.js";
 
 function resolveSyncScript(): string {

package/.pi/extensions/soundboard.ts

@@ -31,7 +31,7 @@ import {
 import type {
 	ExtensionAPI,
 	ExtensionCommandContext,
-} from "@mariozechner/pi-coding-agent";
+} from "@earendil-works/pi-coding-agent";
 
 // ── Constants ──────────────────────────────────────────────────────
 

package/.pi/extensions/test-diff-integrity.ts

@@ -12,7 +12,7 @@
 
 import { appendFile, mkdir } from "node:fs/promises";
 import { join } from "node:path";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 const INCIDENTS_DIR = join(process.cwd(), ".pi", "harness", "incidents");
 const INCIDENT_FILE = join(INCIDENTS_DIR, "test-diff-integrity.jsonl");

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

@@ -9,11 +9,18 @@
 
 import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/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 {