ultimate-pi 0.14.0 → 0.15.0

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

@@ -2,10 +2,11 @@
  * P0–P3 plan debate tools — bus + pi-messenger transport.
  */
 
-import { mkdir } from "node:fs/promises";
+import { mkdir, readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
+import { parse as parseYaml } from "yaml";
 import type { DebateParticipant } from "../lib/debate-orchestrator-types.js";
 import {
 	getLatestRunContext,
@@ -14,16 +15,25 @@ import {
 import { writeYamlFile } from "../lib/harness-yaml.js";
 import {
 	acceptDebateRound,
+	capsForDebate,
 	finalizeDebateConsensus,
 	openDebateBus,
 } from "./lib/debate-bus-core.js";
 import { getDebateState } from "./lib/debate-bus-state.js";
 import { claimExtensionLoad } from "./lib/extension-load-guard.js";
 import { captureHarnessEvent } from "./lib/harness-posthog.js";
+import {
+	type DebateEligibilityInput,
+	harnessPlanDebateEligibility,
+} from "./lib/plan-debate-eligibility.js";
 import {
 	buildPlanReviewRoundEnvelope,
 	type PlanReviewRoundDraft,
 } from "./lib/plan-debate-envelope.js";
+import {
+	getPlanFocusCoverage,
+	planDebateOutcomeComplete,
+} from "./lib/plan-debate-focus.js";
 import {
 	normalizePlanDebateId,
 	planDebateIdForRun,
@@ -40,6 +50,7 @@ import {
 	formatTranscriptForSpawn,
 	getMessengerRoundState,
 	initPlanMessenger,
+	loadMessengerState,
 	messengerRoundDebateReady,
 	postMessengerMessage,
 	readRoundTranscript,
@@ -122,7 +133,7 @@ export default function harnessDebateTools(pi: ExtensionAPI) {
 		}
 		if (applied.length === 0) return;
 
-		const status = await getPlanDebateRoundStatus(rd, lastRound);
+		const status = await getPlanDebateRoundStatus(rd, lastRound, runId);
 		pi.sendMessage({
 			customType: "harness-debate-next-step",
 			content: [
@@ -138,28 +149,131 @@ export default function harnessDebateTools(pi: ExtensionAPI) {
 		});
 	});
 
+	pi.registerTool({
+		name: "harness_plan_debate_eligibility",
+		label: "Plan Debate Eligibility",
+		description:
+			"Pre-debate profile selection (full|standard|light). Call after DAG pass, before harness_debate_open. Uses risk, fork, implementation/stack briefs — not R1 hypothesis output.",
+		parameters: Type.Object({
+			risk_level: Type.Optional(
+				Type.String({ description: "low | med | high" }),
+			),
+			material_fork: Type.Optional(Type.Boolean()),
+			dag_pass: Type.Optional(Type.Boolean()),
+			dag_manually_patched: Type.Optional(Type.Boolean()),
+			implementation_brief_path: Type.Optional(
+				Type.String({
+					description:
+						"Default: artifacts/implementation-research.yaml under run dir",
+				}),
+			),
+			stack_brief_path: Type.Optional(Type.String()),
+			decomposition_path: Type.Optional(Type.String()),
+		}),
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const runId = getRunId(ctx);
+			const rd = runDir(process.cwd(), runId);
+			const p = params as {
+				risk_level?: string;
+				material_fork?: boolean;
+				dag_pass?: boolean;
+				dag_manually_patched?: boolean;
+				implementation_brief_path?: string;
+				stack_brief_path?: string;
+				decomposition_path?: string;
+			};
+			async function loadYaml(
+				rel: string,
+			): Promise<Record<string, unknown> | null> {
+				try {
+					const raw = await readFile(join(rd, rel), "utf-8");
+					return parseYaml(raw) as Record<string, unknown>;
+				} catch {
+					return null;
+				}
+			}
+			const input: DebateEligibilityInput = {
+				risk_level: p.risk_level,
+				material_fork: p.material_fork,
+				dag_pass: p.dag_pass,
+				dag_manually_patched: p.dag_manually_patched,
+				implementation_brief: await loadYaml(
+					p.implementation_brief_path ??
+						"artifacts/implementation-research.yaml",
+				),
+				stack_brief: await loadYaml(
+					p.stack_brief_path ?? "artifacts/stack.yaml",
+				),
+				decomposition: await loadYaml(
+					p.decomposition_path ?? "artifacts/decomposition.yaml",
+				),
+			};
+			const result = harnessPlanDebateEligibility(input);
+			const lines = [
+				`profile: ${result.profile}`,
+				`required_focuses: ${result.required_focuses.join(", ")}`,
+				`min_focus_rounds: ${result.min_focus_rounds}`,
+				`debate_global_cap: ${result.debate_global_cap}`,
+				`human_required: ${result.human_required}`,
+				...result.rationale.map((r) => `- ${r}`),
+			];
+			return {
+				content: [{ type: "text", text: lines.join("\n") }],
+				details: result,
+			};
+		},
+	});
+
 	pi.registerTool({
 		name: "harness_debate_open",
 		label: "Open Plan Debate",
 		description:
-			"Open plan-phase debate bus (plan-<run_id>) and initialize pi-messenger inboxes/threads. Call once before Review Gate rounds.",
+			"Open plan-phase debate bus (plan-<run_id>) and initialize pi-messenger inboxes/threads. Call once after harness_plan_debate_eligibility.",
 		parameters: Type.Object({
 			debate_id: Type.Optional(
 				Type.String({ description: "Optional; normalized to plan-<run_id>" }),
 			),
+			debate_profile: Type.Optional(
+				Type.String({ description: "full | standard | light" }),
+			),
+			required_focuses: Type.Optional(
+				Type.Array(
+					Type.String({ description: "spec | wbs | schedule | quality" }),
+				),
+			),
 		}),
 		async execute(_id, params, _signal, _onUpdate, ctx) {
 			const runId = getRunId(ctx);
 			const projectRoot = process.cwd();
-			const raw = String((params as { debate_id?: string }).debate_id ?? "");
+			const p = params as {
+				debate_id?: string;
+				debate_profile?: string;
+				required_focuses?: string[];
+			};
+			const raw = String(p.debate_id ?? "");
 			const { debateId, corrected, warning } = normalizePlanDebateId(
 				raw,
 				runId,
 			);
-			const opened = await openDebateBus(runId, debateId, debateHooks(pi));
+			const profile =
+				p.debate_profile === "full" ||
+				p.debate_profile === "standard" ||
+				p.debate_profile === "light"
+					? p.debate_profile
+					: "standard";
+			const required_focuses = (p.required_focuses ?? []).filter((f) =>
+				["spec", "wbs", "schedule", "quality"].includes(f),
+			) as Array<"spec" | "wbs" | "schedule" | "quality">;
+			const opened = await openDebateBus(runId, debateId, debateHooks(pi), {
+				debate_profile: profile,
+				required_focuses:
+					required_focuses.length > 0 ? required_focuses : undefined,
+			});
 			await initPlanMessenger(runDir(projectRoot, runId), {
 				runId,
 				debateId,
+				debate_profile: profile,
+				required_focuses: opened.required_focuses,
 			});
 			const sessionId = ctx.sessionManager.getSessionId();
 			captureHarnessEvent(sessionId, "harness_debate_round", {
@@ -171,6 +285,12 @@ export default function harnessDebateTools(pi: ExtensionAPI) {
 			});
 			const lines = [
 				`Plan debate opened: ${debateId}`,
+				`Profile: ${profile}`,
+				required_focuses.length
+					? `Required focuses: ${required_focuses.join(", ")}`
+					: opened.required_focuses?.length
+						? `Required focuses: ${opened.required_focuses.join(", ")}`
+						: "Required focuses: (default all four)",
 				`Messenger: debate-messenger/ (inbox + threads/round-N/transcript.jsonl)`,
 			];
 			if (warning) lines.push(`Note: ${warning}`);
@@ -187,13 +307,14 @@ export default function harnessDebateTools(pi: ExtensionAPI) {
 		description:
 			"Post a claim/rebuttal/integrate message to the round thread and agent inbox (pi-messenger style). Evaluator posts claims first; adversary rebuts with in_reply_to claim ids.",
 		parameters: Type.Object({
-			round_index: Type.Number({ description: "1–4" }),
+			round_index: Type.Number({ description: "1–12 (monotonic per run)" }),
 			from: Type.String({
 				description:
 					"PlanEvaluatorAgent | PlanAdversaryAgent | ReviewIntegratorAgent | HypothesisValidatorAgent | SprintContractAuditorAgent",
 			}),
 			kind: Type.String({
-				description: "claim | rebuttal | integrate | audit | system",
+				description:
+					"claim | rebuttal | clarification | counter | integrate | audit | system",
 			}),
 			body: Type.String(),
 			to: Type.Optional(Type.Array(Type.String())),
@@ -207,7 +328,14 @@ export default function harnessDebateTools(pi: ExtensionAPI) {
 			const p = params as {
 				round_index: number;
 				from: DebateParticipant;
-				kind: "claim" | "rebuttal" | "integrate" | "audit" | "system";
+				kind:
+					| "claim"
+					| "rebuttal"
+					| "clarification"
+					| "counter"
+					| "integrate"
+					| "audit"
+					| "system";
 				body: string;
 				to?: Array<DebateParticipant | "broadcast">;
 				in_reply_to?: string[];
@@ -269,7 +397,7 @@ export default function harnessDebateTools(pi: ExtensionAPI) {
 		description:
 			"Validate lane YAML + messenger thread, write review-round-rN.yaml, emit bus round envelope. Parent must not write review-round files directly.",
 		parameters: Type.Object({
-			round_index: Type.Number({ description: "1–4" }),
+			round_index: Type.Number({ description: "1–12 (monotonic per run)" }),
 			integrator_draft: Type.Record(Type.String(), Type.Unknown(), {
 				description: "ReviewIntegrator YAML object (review-round-rN fields)",
 			}),
@@ -300,8 +428,11 @@ export default function harnessDebateTools(pi: ExtensionAPI) {
 				evidence_refs: [`artifacts/review-round-r${roundIndex}.yaml`],
 			});
 
+			const caps = capsForDebate(debateId);
 			const roundState = await getMessengerRoundState(rd, roundIndex);
-			const mCheck = messengerRoundDebateReady(roundState, roundIndex === 4);
+			const mCheck = messengerRoundDebateReady(roundState, roundIndex >= 4, {
+				max_exchanges_per_round: caps.max_exchanges_per_round,
+			});
 			if (!mCheck.ok) {
 				return {
 					content: [
@@ -393,7 +524,7 @@ export default function harnessDebateTools(pi: ExtensionAPI) {
 		name: "harness_debate_consensus",
 		label: "Finalize Plan Debate Consensus",
 		description:
-			"After 4 bus rounds, emit consensus packet to .pi/harness/debates/plan-<run_id>.consensus.json",
+			"After all focus areas covered (spec|wbs|schedule|quality) and last review_gate_ready true, emit consensus packet to .pi/harness/debates/plan-<run_id>.consensus.json",
 		parameters: Type.Object({
 			rationale: Type.Optional(Type.String()),
 		}),
@@ -401,7 +532,7 @@ export default function harnessDebateTools(pi: ExtensionAPI) {
 			const runId = getRunId(ctx);
 			const rationale =
 				String((params as { rationale?: string }).rationale ?? "").trim() ||
-				"Plan Review Gate consensus after 4 messenger-backed rounds.";
+				"Plan Review Gate consensus after focus coverage and messenger-backed rounds.";
 			const decision = await finalizeDebateConsensus(
 				rationale,
 				debateHooks(pi),
@@ -468,16 +599,30 @@ export default function harnessDebateTools(pi: ExtensionAPI) {
 		description:
 			"List missing lane artifacts and messenger steps for a Review Gate round. Call when resuming after a stop.",
 		parameters: Type.Object({
-			round_index: Type.Number({ description: "1–4" }),
+			round_index: Type.Number({ description: "1–12 (monotonic per run)" }),
+			debate_round_focus: Type.Optional(
+				Type.String({ description: "spec | wbs | schedule | quality" }),
+			),
 		}),
 		async execute(_id, params, _signal, _onUpdate, ctx) {
 			const runId = getRunId(ctx);
-			const roundIndex = Number(
-				(params as { round_index: number }).round_index,
-			);
+			const p = params as {
+				round_index: number;
+				debate_round_focus?: string;
+			};
+			const roundIndex = Number(p.round_index);
+			const focus =
+				p.debate_round_focus === "spec" ||
+				p.debate_round_focus === "wbs" ||
+				p.debate_round_focus === "schedule" ||
+				p.debate_round_focus === "quality"
+					? p.debate_round_focus
+					: undefined;
 			const status = await getPlanDebateRoundStatus(
 				runDir(process.cwd(), runId),
 				roundIndex,
+				runId,
+				focus ? { debate_round_focus: focus } : undefined,
 			);
 			const lines = [
 				`Round ${roundIndex}: ready_for_integrator=${status.ready_for_integrator}`,
@@ -493,6 +638,83 @@ export default function harnessDebateTools(pi: ExtensionAPI) {
 		},
 	});
 
+	pi.registerTool({
+		name: "harness_debate_focus_coverage",
+		label: "Plan Debate Focus Coverage",
+		description:
+			"Return which Review Gate focuses (spec|wbs|schedule|quality) are covered by submitted review-round artifacts and whether debate outcome is complete.",
+		parameters: Type.Object({}),
+		async execute(_id, _params, _signal, _onUpdate, ctx) {
+			const runId = getRunId(ctx);
+			const rd = runDir(process.cwd(), runId);
+			const messenger = await loadMessengerState(rd);
+			const requiredFocuses = messenger?.required_focuses;
+			const coverage = await getPlanFocusCoverage(rd, { requiredFocuses });
+			const caps = capsForDebate(
+				planDebateIdForRun(runId),
+				messenger?.debate_profile,
+			);
+			const complete = planDebateOutcomeComplete(coverage, {
+				requiredFocuses,
+				minRoundIndex: caps.min_focus_rounds,
+			});
+			const lines = [
+				`Profile: ${messenger?.debate_profile ?? "standard"}`,
+				`Required: ${(requiredFocuses ?? ["spec", "wbs", "schedule", "quality"]).join(", ")}`,
+				`Covered: ${coverage.covered.join(", ") || "(none)"}`,
+				coverage.missing.length
+					? `Missing: ${coverage.missing.join(", ")}`
+					: "All required focuses covered.",
+				`Last round: ${coverage.last_round_index}, review_gate_ready=${coverage.last_review_gate_ready}`,
+				`Outcome complete: ${complete}`,
+				`Budget: min_focus_rounds=${caps.min_focus_rounds}, max_rounds=${caps.max_rounds}, max_exchanges_per_round=${caps.max_exchanges_per_round}`,
+			];
+			return {
+				content: [{ type: "text", text: lines.join("\n") }],
+				details: {
+					coverage,
+					caps,
+					complete,
+					profile: messenger?.debate_profile,
+				},
+			};
+		},
+	});
+
+	pi.registerTool({
+		name: "harness_debate_advance_thread",
+		label: "Advance Plan Debate Thread",
+		description:
+			"Ping-pong helper: read round transcript and return next spawn (evaluator clarification vs adversary counter) based on unresolved claim_ids and exchange_count.",
+		parameters: Type.Object({
+			round_index: Type.Number(),
+		}),
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const runId = getRunId(ctx);
+			const roundIndex = Number(
+				(params as { round_index: number }).round_index,
+			);
+			const status = await getPlanDebateRoundStatus(
+				runDir(process.cwd(), runId),
+				roundIndex,
+				runId,
+			);
+			const text = [
+				`Round ${roundIndex}: exchange_count=${status.exchange_count}`,
+				status.unresolved_claim_ids.length
+					? `Unresolved claims: ${status.unresolved_claim_ids.join(", ")}`
+					: "No unresolved claims.",
+				status.next_tool
+					? `Next: ${status.next_tool}`
+					: "Dialogue complete — spawn review-integrator.",
+			].join("\n");
+			return {
+				content: [{ type: "text", text }],
+				details: status,
+			};
+		},
+	});
+
 	pi.registerTool({
 		name: "harness_plan_scope_check",
 		label: "Plan Scope Drift Check",

package/.pi/extensions/harness-live-widget.ts

@@ -3,12 +3,14 @@ import type {
 	ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import {
+	deriveHarnessStatusHint,
+	formatHarnessPhaseLabel,
+	type HarnessStatusSeverity,
 	type HarnessUiState,
 	HarnessUiStateStore,
+	nextHarnessPhase,
 } from "../lib/harness-ui-state";
 
-type Severity = "accent" | "warning" | "error";
-
 type TuiLike = { requestRender(): void };
 type ThemeLike = {
 	fg(
@@ -164,31 +166,25 @@ function composeZones(left: string, right: string, width: number): string {
 	return fitToWidth(`${leftFit}${" ".repeat(minGap)}${rightFit}`, width);
 }
 
-type InFlightState = {
-	toolCount: number;
-	lastToolName: string | null;
-};
+function themeSeverityColor(
+	severity: HarnessStatusSeverity,
+): "accent" | "warning" | "error" | "success" | "muted" {
+	return severity;
+}
 
 class HarnessWidgetComponent {
 	private widthCache?: number;
 	private linesCache?: string[];
 	private state: HarnessUiState;
-	private inFlight: InFlightState;
 	private themeRef: ThemeLike;
 
-	constructor(
-		state: HarnessUiState,
-		inFlight: InFlightState,
-		theme: ThemeLike,
-	) {
+	constructor(state: HarnessUiState, theme: ThemeLike) {
 		this.state = state;
-		this.inFlight = inFlight;
 		this.themeRef = theme;
 	}
 
-	public setData(state: HarnessUiState, inFlight: InFlightState): void {
+	public setData(state: HarnessUiState): void {
 		this.state = state;
-		this.inFlight = inFlight;
 		this.invalidate();
 	}
 
@@ -201,109 +197,23 @@ class HarnessWidgetComponent {
 		if (this.linesCache && this.widthCache === width) return this.linesCache;
 		const theme = this.themeRef;
 		const rowWidth = Math.max(1, width - TERMINAL_WIDTH_SAFETY_MARGIN);
-		const showDebateRow =
-			this.state.phase === "adversary" || this.state.phase === "merge";
-
-		const substateColor: Severity =
-			this.state.flowSubstate === "blocked"
-				? "error"
-				: this.state.flowSubstate === "severity-policy" ||
-						this.state.flowSubstate === "human-required"
-					? "warning"
-					: "accent";
-		const policyColor =
-			this.state.policyDecision === "pass"
-				? "success"
-				: this.state.policyDecision === "conditional_pass"
-					? "warning"
-					: this.state.policyDecision === "block" ||
-							this.state.policyDecision === "human_required"
-						? "error"
-						: "muted";
-
-		const policyDisplay = this.state.policyDecision ?? "pending";
-
-		const phaseToken = `${theme.fg("dim", "phase:")}${theme.fg("accent", this.state.phase)}`;
-		const flowToken = `${theme.fg("dim", "flow:")}${theme.fg(substateColor, this.state.flowSubstate)}`;
-		const policyToken = `${theme.fg("dim", "policy:")}${theme.fg(policyColor, policyDisplay)}`;
-		const row1 = composeZones(
-			`${theme.bold("Harness")} ${phaseToken} ${flowToken}`,
-			policyToken,
-			rowWidth,
-		);
 
-		const debateProgress =
-			this.state.debateMaxRounds != null
-				? `${this.state.debateRound}/${this.state.debateMaxRounds}`
-				: String(this.state.debateRound);
-		const budgetDisplay =
-			this.state.debateBudgetUsed != null && this.state.debateBudgetCap != null
-				? `${this.state.debateBudgetUsed}/${this.state.debateBudgetCap}`
-				: this.state.debateBudgetUsed != null
-					? String(this.state.debateBudgetUsed)
-					: "n/a";
-		const consensusTrend =
-			this.state.consensusDelta == null
-				? "flat"
-				: this.state.consensusDelta > 0
-					? "up"
-					: this.state.consensusDelta < 0
-						? "down"
-						: "flat";
-		const trendColor =
-			consensusTrend === "up"
-				? "success"
-				: consensusTrend === "down"
-					? "warning"
-					: "muted";
-
-		const sev = this.state.severity;
-		const severityCompact =
-			sev.correctness == null &&
-			sev.security == null &&
-			sev.architecture == null &&
-			sev.testIntegrity == null
-				? theme.fg("muted", "sev:n/a")
-				: `${theme.fg("dim", "sev")} ${theme.fg("accent", `c:${sev.correctness ?? "-"}`)} ${theme.fg("accent", `s:${sev.security ?? "-"}`)} ${theme.fg("accent", `a:${sev.architecture ?? "-"}`)} ${theme.fg("accent", `t:${sev.testIntegrity ?? "-"}`)}`;
-
-		const planFlag = this.state.planApproved
-			? `${theme.fg("dim", "📋 Plan:")}${theme.fg("success", "OK")}`
-			: `${theme.fg("dim", "📋 Plan:")}${theme.fg("error", "NO")}`;
-		const reviewFlag = this.state.reviewIsolationOk
-			? `${theme.fg("dim", "🧪 Review:")}${theme.fg("success", "OK")}`
-			: `${theme.fg("dim", "🧪 Review:")}${theme.fg("warning", "ISO")}`;
-		const budgetFlag = this.state.budgetExhausted
-			? `${theme.fg("dim", "💰 Budget:")}${theme.fg("error", "HIT")}`
-			: `${theme.fg("dim", "💰 Budget:")}${theme.fg("success", "OK")}`;
-		const testsFlag =
-			this.state.testIntegritySeverity === "high"
-				? `${theme.fg("dim", "🛡 Tests:")}${theme.fg("error", "HIGH")}`
-				: this.state.testIntegritySeverity === "medium"
-					? `${theme.fg("dim", "🛡 Tests:")}${theme.fg("warning", "MED")}`
-					: `${theme.fg("dim", "🛡 Tests:")}${theme.fg("success", "OK")}`;
-
-		const toolDisplay = this.inFlight.lastToolName
-			? `${this.inFlight.toolCount}:${this.inFlight.lastToolName}`
-			: String(this.inFlight.toolCount);
-		const nextDisplay =
-			this.state.nextRecommendedCommand != null
-				? this.state.nextRecommendedCommand.length > 36
-					? `${this.state.nextRecommendedCommand.slice(0, 33)}...`
-					: this.state.nextRecommendedCommand
-				: null;
-		const row3Left = `${planFlag} ${reviewFlag} ${budgetFlag} ${testsFlag}`;
-		const row3Right = nextDisplay
-			? `${theme.fg("dim", "inFlight:")}${theme.fg("accent", toolDisplay)} ${theme.fg("dim", "next:")}${theme.fg("accent", nextDisplay)}`
-			: `${theme.fg("dim", "inFlight:")}${theme.fg("accent", toolDisplay)}`;
-		const row3 = composeZones(row3Left, row3Right, rowWidth);
-
-		const lines: string[] = [truncateToWidth(row1, rowWidth)];
-		if (showDebateRow) {
-			const debateLeft = `${theme.fg("dim", "Debate")} ${theme.fg("accent", `rounds:${debateProgress}`)} ${theme.fg("dim", "trend:")}${theme.fg(trendColor, consensusTrend)} ${theme.fg("dim", "budget:")}${theme.fg("accent", budgetDisplay)}`;
-			const row2 = composeZones(debateLeft, severityCompact, rowWidth);
-			lines.push(truncateToWidth(row2, rowWidth));
-		}
-		lines.push(truncateToWidth(row3, rowWidth));
+		const currentLabel = formatHarnessPhaseLabel(this.state.phase);
+		const nextPhase = nextHarnessPhase(this.state.phase);
+		const nowToken = `${theme.fg("dim", "now:")}${theme.fg("accent", currentLabel)}`;
+		const phaseToken =
+			nextPhase != null
+				? `${nowToken} ${theme.fg("dim", "→")} ${theme.fg("accent", formatHarnessPhaseLabel(nextPhase))}`
+				: nowToken;
+
+		const status = deriveHarnessStatusHint(this.state);
+		const statusColor = themeSeverityColor(status.severity);
+		const statusToken = theme.fg(statusColor, status.text);
+
+		const left = `${theme.bold("Harness")} ${phaseToken}`;
+		const row = composeZones(left, statusToken, rowWidth);
+
+		const lines = [truncateToWidth(row, rowWidth)];
 		this.widthCache = width;
 		this.linesCache = lines;
 		return lines;
@@ -316,14 +226,16 @@ class HarnessWidgetComponent {
 }
 
 function statusToken(state: HarnessUiState): string {
-	const decision = state.policyDecision ?? "pending";
-	return `h:${state.phase}/${state.flowSubstate}/${decision}`;
+	const current = formatHarnessPhaseLabel(state.phase);
+	const next = nextHarnessPhase(state.phase);
+	const phasePart =
+		next != null ? `${current}→${formatHarnessPhaseLabel(next)}` : current;
+	const hint = deriveHarnessStatusHint(state).text;
+	return `h:${phasePart}|${hint}`;
 }
 
 export default function harnessLiveWidget(pi: ExtensionAPI) {
 	const stateStore = new HarnessUiStateStore();
-	const inFlightCalls = new Set<string>();
-	let lastToolName: string | null = null;
 	let widgetMounted = false;
 	let tuiHandle: TuiLike | null = null;
 	let component: HarnessWidgetComponent | null = null;
@@ -334,19 +246,14 @@ export default function harnessLiveWidget(pi: ExtensionAPI) {
 	function mountHarnessWidget(ctx: ExtensionContext): void {
 		if (!ctx.hasUI) return;
 		const state = stateStore.refresh(ctx);
-		const inFlight: InFlightState = { toolCount: 0, lastToolName: null };
-		lastRenderHash = computeRenderHash(state, inFlight);
+		lastRenderHash = computeRenderHash(state);
 
 		ctx.ui.setWidget(
 			"harness-live",
 			(tui, theme) => {
 				widgetMounted = true;
 				tuiHandle = tui;
-				component = new HarnessWidgetComponent(
-					stateStore.snapshot(),
-					inFlight,
-					theme,
-				);
+				component = new HarnessWidgetComponent(stateStore.snapshot(), theme);
 				return {
 					render(width: number): string[] {
 						component?.setTheme(theme);
@@ -388,26 +295,15 @@ export default function harnessLiveWidget(pi: ExtensionAPI) {
 		ctx.ui.setStatus("harness-mode", undefined);
 	}
 
-	function computeRenderHash(
-		state: HarnessUiState,
-		inFlight: InFlightState,
-	): string {
+	function computeRenderHash(state: HarnessUiState): string {
 		return JSON.stringify({
 			phase: state.phase,
-			flowSubstate: state.flowSubstate,
 			planApproved: state.planApproved,
-			reviewIsolationOk: state.reviewIsolationOk,
 			budgetExhausted: state.budgetExhausted,
 			testIntegritySeverity: state.testIntegritySeverity,
-			debateRound: state.debateRound,
-			debateMaxRounds: state.debateMaxRounds,
-			debateBudgetUsed: state.debateBudgetUsed,
-			debateBudgetCap: state.debateBudgetCap,
 			policyDecision: state.policyDecision,
-			consensusDelta: state.consensusDelta,
-			severity: state.severity,
+			flowSubstate: state.flowSubstate,
 			nextRecommendedCommand: state.nextRecommendedCommand,
-			inFlight,
 		});
 	}
 
@@ -417,15 +313,11 @@ export default function harnessLiveWidget(pi: ExtensionAPI) {
 		queueMicrotask(() => {
 			refreshQueued = false;
 			const state = stateStore.refresh(ctx);
-			const inFlight: InFlightState = {
-				toolCount: inFlightCalls.size,
-				lastToolName,
-			};
-			const hash = computeRenderHash(state, inFlight);
+			const hash = computeRenderHash(state);
 			updateStatusFallback(ctx, state);
 			if (hash === lastRenderHash) return;
 			lastRenderHash = hash;
-			if (component) component.setData(state, inFlight);
+			if (component) component.setData(state);
 			tuiHandle?.requestRender();
 		});
 	}
@@ -450,16 +342,4 @@ export default function harnessLiveWidget(pi: ExtensionAPI) {
 	pi.on("agent_end", (_event, ctx) => {
 		scheduleRefresh(ctx);
 	});
-
-	pi.on("tool_execution_start", (event, ctx) => {
-		inFlightCalls.add(event.toolCallId);
-		lastToolName = event.toolName;
-		scheduleRefresh(ctx);
-	});
-
-	pi.on("tool_result", (event, ctx) => {
-		inFlightCalls.delete(event.toolCallId);
-		if (inFlightCalls.size === 0) lastToolName = null;
-		scheduleRefresh(ctx);
-	});
 }