ultimate-pi 0.13.1 → 0.14.0

package/.agents/skills/harness-debate-plan/SKILL.md

@@ -1,44 +1,84 @@
 ---
 name: harness-debate-plan
-description: Plan-phase Review Gate debate — assemble rounds, token caps, bus envelopes for parent orchestrator.
+description: Plan-phase Review Gate debate — pi-messenger threads, lane YAML, bus tools for parent orchestrator.
 ---
 
 # harness-debate-plan
 
-Use when running **Phase 5** of `/harness-plan` — four Review Gate rounds on the plan debate bus.
+Use when running **Phase 5** of `/harness-plan` — four Review Gate rounds with **pi-messenger-style** turn-taking (claims → rebuttals → integrate), then bus submission.
 
 ## Open
 
 ```
-/harness-debate-open plan-<run_id>
+harness_debate_open({})
 ```
 
+- Debate id is always `plan-<run_id>` (tool normalizes wrong ids).
+- Creates `.pi/harness/runs/<run_id>/debate-messenger/` (`inbox/<Agent>/`, `threads/round-N/transcript.jsonl`).
+
 Budget profile **plan**: `max_rounds=4`, `round_token_cap=2000`, `debate_global_cap=12000`.
 
-## Per-round spawn order
+## Per-round spawn order (P1 sequential lanes)
+
+1. Round-specific lane spawns (write lane YAML with `write_harness_yaml`)
+2. `plan-evaluator` → lane artifact + `harness_messenger_post` (claims)
+3. `harness_messenger_read_round` → spawn `plan-adversary` with transcript
+4. `plan-adversary` → lane artifact + `harness_messenger_post` (rebuttals with `in_reply_to`)
+5. R1: `hypothesis-validator` first (blind — no decomposition/PlanPacket in prompt)
+6. R4: `sprint-contract-auditor` required before integrator
+7. `review-integrator` → integrator draft + `harness_messenger_post` (`integrate`)
+8. `harness_debate_submit_round({ round_index, integrator_draft })` — **only** path for `review-round-r{N}.yaml`
+
+| Round | Extra lane artifacts |
+|-------|----------------------|
+| 1 | `hypothesis-validation-r1.yaml` |
+| 4 | `sprint-audit-r4.yaml` (required) |
 
-1. Round-specific extras (R1: `hypothesis-validator` first, blind)
-2. `plan-evaluator`
-3. `plan-adversary`
-4. R4: `sprint-contract-auditor` (required)
-5. `review-integrator`
+## Lane artifacts (auto-applied on subagent complete)
 
-## Artifacts (YAML)
+When a debate lane subagent finishes, the harness **automatically** writes lane YAML and posts messenger messages (evaluator claims, adversary rebuttals). Look for `harness-debate-next-step` in the transcript.
 
-| Agent | Output path |
-|-------|-------------|
-| hypothesis-validator | `artifacts/hypothesis-validation-r{N}.yaml` |
-| plan-evaluator | `artifacts/validation-turn-r{N}.yaml` |
-| plan-adversary | `artifacts/adversary-brief-r{N}.yaml` |
-| sprint-contract-auditor | `artifacts/sprint-audit-r{N}.yaml` |
-| review-integrator | `artifacts/review-round-r{N}.yaml` |
+| Agent | Output path | Messenger |
+|-------|-------------|-----------|
+| hypothesis-validator | `artifacts/hypothesis-validation-r{N}.yaml` | — |
+| plan-evaluator | `artifacts/validation-turn-r{N}.yaml` | `claim` |
+| plan-adversary | `artifacts/adversary-brief-r{N}.yaml` | `rebuttal` |
+| sprint-contract-auditor | `artifacts/sprint-audit-r{N}.yaml` (R4) | optional |
+| review-integrator | *(integrator draft → `harness_debate_submit_round` only)* | `integrate` (on submit) |
 
-## Bus envelope
+Fallback: `harness_debate_apply_lane({ lane, content, round_index? })` if auto-apply missed fenced YAML.
 
-Load `review-round-r{N}.yaml`, validate, then `buildPlanReviewRoundEnvelope` (`.pi/extensions/lib/plan-debate-envelope.ts`) → `/harness-debate-round '<json>'`.
+Resume after stop: `harness_debate_round_status({ round_index: N })` then run the listed `next_tool`.
 
-Plan participants only. `StackResearchAgent` uses `artifacts/stack.yaml` claims — no spawn.
+## Messenger tools
+
+```typescript
+harness_messenger_post({
+  round_index: 1,
+  from: "PlanEvaluatorAgent",
+  kind: "claim",
+  body: "...",
+  claim_ids: ["c1", "c2"],
+  to: ["broadcast"],
+})
+harness_messenger_post({
+  round_index: 1,
+  from: "PlanAdversaryAgent",
+  kind: "rebuttal",
+  in_reply_to: ["c1"],
+  body: "...",
+})
+harness_messenger_read_round({ round_index: 1 }) // for next spawn prompt
+```
+
+## Integrator + bus
+
+`harness_debate_submit_round` validates messenger thread + integrator rules (`review_gate_ready` false when checks fail without `disputes[]`), writes `review-round-r{N}.yaml`, emits bus `kind: round`.
+
+`StackResearchAgent` uses `artifacts/stack.yaml` claims — no spawn.
 
 ## Close
 
-After round 4: `/harness-debate-consensus`. Do not `approve_plan` on `policy_decision: block`.
+After round 4: `harness_debate_consensus`. `approve_plan` is **hard-gated** on lane files, messenger, 4 bus rounds, and consensus not `block`.
+
+Do not `approve_plan` on `policy_decision: block`. On `human_required` → `ask_user` first.

package/.agents/skills/harness-orchestration/SKILL.md

@@ -36,7 +36,7 @@ LIMIT 30
 1. **Parallel `tasks`** — one `subagent({ tasks: [...] })` for scouts, decompose+hypothesis, or review fan-in; subprocesses run in parallel upstream.
 2. **Blocking calls** — each `subagent` returns when the subprocess exits; no `get_subagent_result` polling.
 3. **Compact handoffs** — pass scout/decompose JSON only; never paste full subprocess message logs into the next spawn.
-4. **Spawn caps** — bridge enforces **8** active + **12** total harness spawns per session. Do **not** pass `timeoutMs` unless the user wants a cap — subprocesses wait for natural exit (`PI_SUBAGENT_TIMEOUT_MS` optional env backstop only).
+4. **No spawn cap** — harness subagent spawns are unlimited per session (active count is telemetry only). Do **not** pass `timeoutMs` unless the user wants a cap — subprocesses wait for natural exit (`PI_SUBAGENT_TIMEOUT_MS` optional env backstop only).
 
 ## Command → agent
 

package/.pi/agents/harness/planning/plan-adversary.md

@@ -9,10 +9,10 @@ max_turns: 12
 
 You are **plan-adversary** — break the plan with reproducible counterexamples.
 
-Engage failed/warn checks from the same round's `plan-evaluator` first, then independent attacks. Cite `work_item_id` / `phase_id`.
+Engage failed/warn checks from the same round's `plan-evaluator` first (parent provides evaluator YAML + messenger **claims**). Rebut specific `claim_ids` from the thread — parent posts your `rebuttal` with `in_reply_to`.
 
 ## Output
 
 Valid **YAML only** — `PlanAdversaryBrief` (`.pi/harness/specs/plan-adversary-brief.schema.json`).
 
-Bus label: `PlanAdversarysubagent`.
+Bus label: `PlanAdversaryAgent`.

package/.pi/agents/harness/planning/plan-evaluator.md

@@ -15,4 +15,6 @@ Parent passes `debate_round_focus`: `spec` | `wbs` | `schedule` | `quality`.
 
 Valid **YAML only** — `PlanValidationTurn` (`.pi/harness/specs/plan-validation-turn.schema.json`). Fail if `dag_validation.status === "fail"`.
 
-Bus label: `PlanEvaluatorsubagent`.
+Include `claim_ids[]` in your summary for parent to post as messenger **claims** before spawning adversary.
+
+Bus label: `PlanEvaluatorAgent`.

package/.pi/agents/harness/planning/review-integrator.md

@@ -18,6 +18,8 @@ Valid **YAML only** — `PlanReviewRoundDraft` (`.pi/harness/specs/plan-review-r
 - `review_gate_ready` boolean
 - `participants`, `claims`, `rebuttals`, `evidence_refs`, `token_usage`, `severity_scores`
 
-Parent runs `buildPlanReviewRoundEnvelope` → `/harness-debate-round`.
+Parent passes `harness_messenger_read_round` transcript + lane YAML. After your YAML draft, parent calls `harness_messenger_post` (`kind: integrate`) then `harness_debate_submit_round` — you do not write `review-round-r*.yaml`.
 
-Bus label: `ReviewIntegratorsubagent`.
+Set `review_gate_ready: false` when evaluator checks fail unless `disputes[]` documents open tension.
+
+Bus label: `ReviewIntegratorAgent`.

package/.pi/extensions/debate-orchestrator.ts

@@ -1,103 +1,24 @@
 /**
  * debate-orchestrator — headless debate bus (pi-messenger-inspired semantics).
  *
- * No additional UI surface:
- * - transport is extension custom entries + debate artifacts on disk
- * - command interface is machine-friendly (`/harness-debate-*`)
- *
- * Protocol envelope:
- * {
- *   protocol: "pi-debate-bus/v1",
- *   kind: "open" | "round" | "consensus" | "budget_exhausted",
- *   correlation: { run_id, debate_id, round_index?, sender },
- *   payload: { ... }
- * }
+ * Commands mirror harness_debate_* tools; shared state lives in debate-bus-core.
  */
 
-import { appendFile, mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import {
-	type DebateParticipant,
-	debatePhaseFromId,
-	isPlanDebateId,
-	PLAN_DEBATE_PARTICIPANTS,
-	POST_EXECUTE_DEBATE_PARTICIPANTS,
-} from "../lib/debate-orchestrator-types.js";
 import { getRunIdFromSession } from "../lib/harness-run-context.js";
-
-type PolicyDecision = "pass" | "conditional_pass" | "block" | "human_required";
-type DebatePhase = "plan" | "post_execute";
-
-interface RoundPayload {
-	participants: DebateParticipant[];
-	claims: string[];
-	rebuttals: string[];
-	evidence_refs: string[];
-	token_usage: {
-		per_agent: Record<string, number>;
-		round_total: number;
-	};
-	consensus_delta: number;
-	severity_scores?: {
-		correctness: number;
-		security: number;
-		architecture: number;
-		test_integrity: number;
-	};
-}
-
-interface DebateState {
-	run_id: string;
-	debate_id: string;
-	debate_phase: DebatePhase;
-	round_count: number;
-	budget_used: number;
-	max_rounds: number;
-	round_token_cap: number;
-	debate_global_cap: number;
-	last_review_gate_ready?: boolean;
-}
-
-interface BusEnvelope<T = unknown> {
-	protocol: "pi-debate-bus/v1";
-	kind: "open" | "round" | "consensus" | "budget_exhausted";
-	correlation: {
-		run_id: string;
-		debate_id: string;
-		round_index?: number;
-		sender: DebateParticipant | "system";
-	};
-	payload: T;
-}
-
-const DEBATES_DIR = join(process.cwd(), ".pi", "harness", "debates");
-const WEIGHTS = {
-	claim_quality: 0.2,
-	reproducibility: 0.4,
-	agreement: 0.4,
-};
-const THRESHOLDS = {
-	correctness: 0.7,
-	security: 0.7,
-	architecture: 0.8,
-	test_integrity: 0.8,
-};
-const HARD_STOP_DEBATE_CAPS = process.env.HARNESS_DEBATE_HARD_STOP === "true";
-
-function nowIso(): string {
-	return new Date().toISOString();
-}
-
-function toSafeFloat(value: unknown): number {
-	const n = Number(value);
-	if (Number.isNaN(n) || !Number.isFinite(n)) return 0;
-	return Math.max(0, Math.min(1, n));
-}
-
-async function ensureDebatesDir(): Promise<void> {
-	await mkdir(DEBATES_DIR, { recursive: true });
-}
+import {
+	acceptDebateRound,
+	finalizeDebateConsensus,
+	openDebateBus,
+	parseRoundEnvelope,
+} from "./lib/debate-bus-core.js";
+import {
+	getDebateState,
+	restoreDebateStateFromEntry,
+} from "./lib/debate-bus-state.js";
+import { normalizePlanDebateId } from "./lib/plan-debate-id.js";
+import { initPlanMessenger } from "./lib/plan-messenger.js";
 
 function getRunId(ctx: {
 	sessionManager: { getEntries(): unknown[]; getSessionId(): string };
@@ -110,339 +31,11 @@ function getRunId(ctx: {
 	);
 }
 
-const PLAN_BUDGET = {
-	max_rounds: 4,
-	round_token_cap: 2000,
-	debate_global_cap: 12000,
-} as const;
-
-const AGGRESSIVE_BUDGET = {
-	max_rounds: 6,
-	round_token_cap: 2500,
-	debate_global_cap: 35000,
-} as const;
-
-function capsForDebate(debateId: string): {
-	name: "plan" | "aggressive";
-	max_rounds: number;
-	round_token_cap: number;
-	debate_global_cap: number;
-} {
-	if (isPlanDebateId(debateId)) {
-		return { name: "plan", ...PLAN_BUDGET };
-	}
-	return { name: "aggressive", ...AGGRESSIVE_BUDGET };
-}
-
-function participantAllowed(participant: string, phase: DebatePhase): boolean {
-	if (phase === "plan") {
-		return (PLAN_DEBATE_PARTICIPANTS as readonly string[]).includes(
-			participant,
-		);
-	}
-	return (POST_EXECUTE_DEBATE_PARTICIPANTS as readonly string[]).includes(
-		participant,
-	);
-}
-
-async function writeDebateEvent(
-	debateId: string,
-	event: unknown,
-): Promise<void> {
-	await ensureDebatesDir();
-	const path = join(DEBATES_DIR, `${debateId}.jsonl`);
-	await appendFile(path, `${JSON.stringify(event)}\n`, "utf-8");
-}
-
-function defaultSeverity(): {
-	correctness: number;
-	security: number;
-	architecture: number;
-	test_integrity: number;
-} {
-	return { correctness: 0, security: 0, architecture: 0, test_integrity: 0 };
-}
-
-function decidePolicy(
-	severity: ReturnType<typeof defaultSeverity>,
-	minEvidenceConfidence: number,
-): PolicyDecision {
-	if (
-		severity.security >= THRESHOLDS.security ||
-		severity.correctness >= THRESHOLDS.correctness ||
-		severity.architecture >= THRESHOLDS.architecture ||
-		severity.test_integrity >= THRESHOLDS.test_integrity
-	) {
-		return "block";
-	}
-	if (minEvidenceConfidence < 0.55) return "human_required";
-	if (minEvidenceConfidence < 0.75) return "conditional_pass";
-	return "pass";
-}
-
-function parseEnvelope(raw: string): BusEnvelope<RoundPayload> | null {
-	try {
-		const parsed = JSON.parse(raw) as BusEnvelope<RoundPayload>;
-		if (parsed?.protocol !== "pi-debate-bus/v1") return null;
-		if (parsed?.kind !== "round") return null;
-		return parsed;
-	} catch {
-		return null;
-	}
-}
-
 export default function debateOrchestrator(pi: ExtensionAPI) {
-	let state: DebateState | null = null;
-	let lastSeverity = defaultSeverity();
-
-	async function openDebate(runId: string, debateId: string): Promise<void> {
-		const caps = capsForDebate(debateId);
-		const debate_phase = debatePhaseFromId(debateId);
-		state = {
-			run_id: runId,
-			debate_id: debateId,
-			debate_phase,
-			round_count: 0,
-			budget_used: 0,
-			max_rounds: caps.max_rounds,
-			round_token_cap: caps.round_token_cap,
-			debate_global_cap: caps.debate_global_cap,
-			last_review_gate_ready: false,
-		};
-		pi.appendEntry("harness-debate-state", state);
-		const envelope: BusEnvelope = {
-			protocol: "pi-debate-bus/v1",
-			kind: "open",
-			correlation: {
-				run_id: runId,
-				debate_id: debateId,
-				sender: "system",
-			},
-			payload: {
-				opened_at: nowIso(),
-				debate_phase,
-				budget_profile: caps.name,
-			},
-		};
-		pi.appendEntry("harness-debate-envelope", envelope);
-		await writeDebateEvent(debateId, envelope);
-	}
-
-	async function emitBudgetExhausted(reason: string): Promise<void> {
-		if (!state) return;
-		const envelope: BusEnvelope = {
-			protocol: "pi-debate-bus/v1",
-			kind: "budget_exhausted",
-			correlation: {
-				run_id: state.run_id,
-				debate_id: state.debate_id,
-				round_index: state.round_count,
-				sender: "system",
-			},
-			payload: {
-				schema_version: "1.0.0",
-				contract_version: "1.0.0",
-				event_type: "budget_exhausted",
-				run_id: state.run_id,
-				debate_id: state.debate_id,
-				round_count: state.round_count,
-				budget_used: state.budget_used,
-				exhaustion_reason: reason,
-				caps: {
-					max_rounds: state.max_rounds,
-					round_token_cap: state.round_token_cap,
-					debate_global_cap: state.debate_global_cap,
-				},
-				minimum_evidence_confidence: 0.6,
-				default_policy_outcome: "block",
-				human_override_allowed: true,
-			},
-		};
-		pi.appendEntry("harness-debate-envelope", envelope);
-		pi.appendEntry("harness-budget-exhausted", envelope.payload);
-		await writeDebateEvent(state.debate_id, envelope);
-	}
-
-	async function acceptRound(envelope: BusEnvelope<RoundPayload>): Promise<{
-		ok: boolean;
-		reason?: string;
-	}> {
-		if (!state) return { ok: false, reason: "no active debate" };
-		if (state.debate_id !== envelope.correlation.debate_id) {
-			return { ok: false, reason: "debate id mismatch" };
-		}
-
-		for (const p of envelope.payload.participants ?? []) {
-			if (!participantAllowed(p, state.debate_phase)) {
-				return {
-					ok: false,
-					reason: `participant ${p} invalid for debate_phase=${state.debate_phase}`,
-				};
-			}
-		}
-
-		const nextRound = state.round_count + 1;
-		if (nextRound > state.max_rounds) {
-			await emitBudgetExhausted("max_rounds_reached");
-			if (HARD_STOP_DEBATE_CAPS) {
-				return { ok: false, reason: "max rounds reached" };
-			}
-		}
-
-		const perAgent = envelope.payload.token_usage?.per_agent ?? {};
-		for (const [agent, tokens] of Object.entries(perAgent)) {
-			if (Number(tokens) > state.round_token_cap) {
-				await emitBudgetExhausted("round_token_cap_exceeded");
-				if (HARD_STOP_DEBATE_CAPS) {
-					return { ok: false, reason: `round cap exceeded by ${agent}` };
-				}
-			}
-		}
-
-		const roundTotal = Number(envelope.payload.token_usage?.round_total ?? 0);
-		if (state.budget_used + roundTotal > state.debate_global_cap) {
-			await emitBudgetExhausted("debate_global_cap_exceeded");
-			if (HARD_STOP_DEBATE_CAPS) {
-				return { ok: false, reason: "global cap exceeded" };
-			}
-		}
-
-		state.round_count = nextRound;
-		state.budget_used += roundTotal;
-		pi.appendEntry("harness-debate-state", state);
-
-		if (envelope.payload.severity_scores) {
-			lastSeverity = {
-				correctness: toSafeFloat(envelope.payload.severity_scores.correctness),
-				security: toSafeFloat(envelope.payload.severity_scores.security),
-				architecture: toSafeFloat(
-					envelope.payload.severity_scores.architecture,
-				),
-				test_integrity: toSafeFloat(
-					envelope.payload.severity_scores.test_integrity,
-				),
-			};
-		}
-
-		const profileName =
-			state.debate_phase === "plan"
-				? ("plan" as const)
-				: ("aggressive" as const);
-
-		const roundRecord = {
-			schema_version: "1.0.0",
-			contract_version: "1.0.0",
-			run_id: state.run_id,
-			debate_id: state.debate_id,
-			round_index: state.round_count,
-			participants: envelope.payload.participants,
-			claims: envelope.payload.claims,
-			rebuttals: envelope.payload.rebuttals,
-			evidence_refs: envelope.payload.evidence_refs,
-			token_usage: envelope.payload.token_usage,
-			budget_profile: {
-				name: profileName,
-				max_rounds: state.max_rounds,
-				round_token_cap: state.round_token_cap,
-				debate_global_cap: state.debate_global_cap,
-			},
-			consensus_delta: Number(envelope.payload.consensus_delta ?? 0),
-		};
-		pi.appendEntry("harness-round-result", roundRecord);
-		pi.appendEntry("harness-debate-envelope", envelope);
-		await writeDebateEvent(state.debate_id, envelope);
-		return { ok: true };
-	}
-
-	async function finalizeConsensus(
-		rationale: string,
-	): Promise<PolicyDecision | null> {
-		if (!state) return null;
-		const evidenceScore = Math.max(
-			0,
-			Math.min(
-				1,
-				lastSeverity.correctness * WEIGHTS.claim_quality +
-					(1 - Math.max(lastSeverity.security, lastSeverity.test_integrity)) *
-						WEIGHTS.reproducibility +
-					Math.max(
-						0,
-						1 - Math.abs(lastSeverity.architecture - lastSeverity.correctness),
-					) *
-						WEIGHTS.agreement,
-			),
-		);
-		const decision = decidePolicy(lastSeverity, evidenceScore);
-		const planPhase = state.debate_phase === "plan";
-		const evaluatorPassed = planPhase
-			? Boolean(state.last_review_gate_ready)
-			: true;
-		const debateComplete = planPhase
-			? state.round_count >= state.max_rounds
-			: state.round_count > 0;
-
-		const consensus = {
-			schema_version: "1.0.0",
-			contract_version: "1.0.0",
-			run_id: state.run_id,
-			debate_id: state.debate_id,
-			debate_phase: state.debate_phase,
-			round_count: state.round_count,
-			budget_used: state.budget_used,
-			severity_scores: lastSeverity,
-			severity_thresholds: {
-				correctness_block_at: THRESHOLDS.correctness,
-				security_block_at: THRESHOLDS.security,
-				architecture_block_at: THRESHOLDS.architecture,
-				test_integrity_block_at: THRESHOLDS.test_integrity,
-			},
-			confidence_weights: WEIGHTS,
-			evidence_refs: [],
-			strict_gate_prerequisites: planPhase
-				? {
-						plan_gate_passed: false,
-						execution_completed: false,
-						evaluator_passed: evaluatorPassed,
-						adversarial_debate_completed: debateComplete,
-						severity_policy_ok: decision !== "block",
-						benchmark_delta_checks_passed: false,
-						rollback_artifacts_generated: false,
-					}
-				: {
-						plan_gate_passed: true,
-						execution_completed: true,
-						evaluator_passed: true,
-						adversarial_debate_completed: debateComplete,
-						severity_policy_ok: decision !== "block",
-						benchmark_delta_checks_passed: false,
-						rollback_artifacts_generated: false,
-					},
-			policy_decision: decision,
-			rationale,
-		};
-
-		const envelope: BusEnvelope = {
-			protocol: "pi-debate-bus/v1",
-			kind: "consensus",
-			correlation: {
-				run_id: state.run_id,
-				debate_id: state.debate_id,
-				round_index: state.round_count,
-				sender: "system",
-			},
-			payload: consensus,
-		};
-
-		await writeFile(
-			join(DEBATES_DIR, `${state.debate_id}.consensus.json`),
-			`${JSON.stringify(consensus, null, 2)}\n`,
-			"utf-8",
-		);
-		pi.appendEntry("harness-consensus-packet", consensus);
-		pi.appendEntry("harness-debate-envelope", envelope);
-		await writeDebateEvent(state.debate_id, envelope);
-		return decision;
-	}
+	const hooks = {
+		appendEntry: (customType: string, data: unknown) =>
+			pi.appendEntry(customType, data),
+	};
 
 	pi.on("session_start", async (_event, ctx) => {
 		const entries = ctx.sessionManager.getEntries();
@@ -452,7 +45,7 @@ export default function debateOrchestrator(pi: ExtensionAPI) {
 				entry.type === "custom" &&
 				entry.customType === "harness-debate-state"
 			) {
-				state = entry.data as DebateState;
+				restoreDebateStateFromEntry(entry.data);
 				break;
 			}
 		}
@@ -461,13 +54,21 @@ export default function debateOrchestrator(pi: ExtensionAPI) {
 	pi.registerCommand("harness-debate-open", {
 		description: "Open a headless debate session",
 		handler: async (args, ctx) => {
+			const runId = getRunId(ctx);
 			const trimmed = args.trim();
-			let debateId = trimmed;
-			if (!debateId) debateId = `debate-${Date.now()}`;
-			await openDebate(getRunId(ctx), debateId);
+			const { debateId, warning } = normalizePlanDebateId(trimmed, runId);
+			await openDebateBus(runId, debateId, hooks);
+			if (debateId.startsWith("plan-")) {
+				await initPlanMessenger(
+					join(process.cwd(), ".pi", "harness", "runs", runId),
+					{ runId, debateId },
+				);
+			}
 			pi.sendMessage({
 				customType: "harness-debate-opened",
-				content: `Debate opened: ${debateId}`,
+				content: warning
+					? `Debate opened: ${debateId} (${warning})`
+					: `Debate opened: ${debateId}`,
 				display: false,
 			});
 		},
@@ -476,10 +77,12 @@ export default function debateOrchestrator(pi: ExtensionAPI) {
 	pi.registerCommand("harness-debate-round", {
 		description: "Submit a debate round envelope JSON",
 		handler: async (args, ctx) => {
-			if (!state) {
-				await openDebate(getRunId(ctx), `debate-${Date.now()}`);
+			if (!getDebateState()) {
+				const runId = getRunId(ctx);
+				const { debateId } = normalizePlanDebateId("", runId);
+				await openDebateBus(runId, debateId, hooks);
 			}
-			const envelope = parseEnvelope(args.trim());
+			const envelope = parseRoundEnvelope(args.trim());
 			if (!envelope) {
 				pi.sendMessage({
 					customType: "harness-debate-round-error",
@@ -489,7 +92,7 @@ export default function debateOrchestrator(pi: ExtensionAPI) {
 				});
 				return;
 			}
-			const result = await acceptRound(envelope);
+			const result = await acceptDebateRound(envelope, hooks);
 			if (!result.ok) {
 				pi.sendMessage({
 					customType: "harness-debate-round-rejected",
@@ -503,7 +106,7 @@ export default function debateOrchestrator(pi: ExtensionAPI) {
 	pi.registerCommand("harness-debate-consensus", {
 		description: "Finalize debate and emit consensus packet",
 		handler: async (args) => {
-			if (!state) {
+			if (!getDebateState()) {
 				pi.sendMessage({
 					customType: "harness-debate-consensus-error",
 					content: "No active debate to finalize.",
@@ -511,8 +114,9 @@ export default function debateOrchestrator(pi: ExtensionAPI) {
 				});
 				return;
 			}
-			const decision = await finalizeConsensus(
+			const decision = await finalizeDebateConsensus(
 				args.trim() || "Consensus generated by debate-orchestrator.",
+				hooks,
 			);
 			pi.sendMessage({
 				customType: "harness-debate-consensus",