ultimate-pi 0.11.0 → 0.13.0

package/.pi/lib/harness-yaml.mjs

@@ -0,0 +1,73 @@
+/**
+ * YAML read/write for harness plan artifacts (no JSON plan fallbacks).
+ */
+
+import { readFile, rename, writeFile } from "node:fs/promises";
+import { parse, stringify } from "yaml";
+
+const CODE_FENCE_RE = /^```(?:ya?ml|json)?\s*\n?([\s\S]*?)```\s*$/im;
+
+export function stripYamlFences(text) {
+	return stripCodeFences(text);
+}
+
+export function stripCodeFences(text) {
+	const trimmed = text.trim();
+	const m = CODE_FENCE_RE.exec(trimmed);
+	return m ? m[1].trim() : trimmed;
+}
+
+export function parseStructuredDocument(text, label = "document") {
+	const body = stripCodeFences(text);
+	if (!body.trim()) {
+		throw new Error(`${label}: empty document`);
+	}
+
+	try {
+		const yamlDoc = parse(body, { uniqueKeys: true });
+		if (yamlDoc !== null && yamlDoc !== undefined) {
+			return yamlDoc;
+		}
+	} catch {
+		/* try JSON below */
+	}
+
+	const trimmed = body.trim();
+	if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+		try {
+			return JSON.parse(trimmed);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			throw new Error(`${label}: JSON parse failed — ${msg}`);
+		}
+	}
+
+	throw new Error(
+		`${label}: not valid YAML or JSON (use write_harness_yaml with a schema-shaped object)`,
+	);
+}
+
+export function parseYaml(text, label = "yaml") {
+	return parseStructuredDocument(text, label);
+}
+
+export async function readYamlFile(path, label) {
+	const raw = await readFile(path, "utf-8");
+	return parseStructuredDocument(raw, label ?? path);
+}
+
+export async function writeYamlFile(path, data) {
+	const tmp = `${path}.tmp`;
+	const content = `${stringify(data, { indent: 2 })}\n`;
+	await writeFile(tmp, content, "utf-8");
+	await rename(tmp, path);
+}
+
+export function stringifyYaml(data) {
+	return `${stringify(data, { indent: 2 })}\n`;
+}
+
+export function normalizeHarnessYamlContent(text, label = "yaml") {
+	const doc = parseStructuredDocument(text, label);
+	return stringifyYaml(doc);
+}

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

@@ -0,0 +1,90 @@
+/**
+ * YAML read/write for harness plan artifacts (no JSON plan fallbacks).
+ */
+
+import { readFile, rename, writeFile } from "node:fs/promises";
+import { parse, stringify } from "yaml";
+
+const CODE_FENCE_RE = /^```(?:ya?ml|json)?\s*\n?([\s\S]*?)```\s*$/im;
+
+/** @deprecated Use stripCodeFences */
+export function stripYamlFences(text: string): string {
+	return stripCodeFences(text);
+}
+
+export function stripCodeFences(text: string): string {
+	const trimmed = text.trim();
+	const m = CODE_FENCE_RE.exec(trimmed);
+	return m ? m[1].trim() : trimmed;
+}
+
+/**
+ * Parse agent output or file body: fenced YAML/JSON, raw YAML, or raw JSON object/array.
+ */
+export function parseStructuredDocument(
+	text: string,
+	label = "document",
+): unknown {
+	const body = stripCodeFences(text);
+	if (!body.trim()) {
+		throw new Error(`${label}: empty document`);
+	}
+
+	try {
+		const yamlDoc = parse(body, { uniqueKeys: true });
+		if (yamlDoc !== null && yamlDoc !== undefined) {
+			return yamlDoc;
+		}
+	} catch {
+		/* try JSON below */
+	}
+
+	const trimmed = body.trim();
+	if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+		try {
+			return JSON.parse(trimmed) as unknown;
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			throw new Error(`${label}: JSON parse failed — ${msg}`);
+		}
+	}
+
+	throw new Error(
+		`${label}: not valid YAML or JSON (use write_harness_yaml with a schema-shaped object)`,
+	);
+}
+
+export function parseYaml(text: string, label = "yaml"): unknown {
+	return parseStructuredDocument(text, label);
+}
+
+export async function readYamlFile(
+	path: string,
+	label?: string,
+): Promise<unknown> {
+	const raw = await readFile(path, "utf-8");
+	return parseStructuredDocument(raw, label ?? path);
+}
+
+export async function writeYamlFile(
+	path: string,
+	data: unknown,
+): Promise<void> {
+	const tmp = `${path}.tmp`;
+	const content = `${stringify(data, { indent: 2 })}\n`;
+	await writeFile(tmp, content, "utf-8");
+	await rename(tmp, path);
+}
+
+export function stringifyYaml(data: unknown): string {
+	return `${stringify(data, { indent: 2 })}\n`;
+}
+
+/** Normalize arbitrary agent text to canonical YAML file bytes. */
+export function normalizeHarnessYamlContent(
+	text: string,
+	label = "yaml",
+): string {
+	const doc = parseStructuredDocument(text, label);
+	return stringifyYaml(doc);
+}

package/.pi/prompts/harness-auto.md

@@ -5,7 +5,7 @@ argument-hint: "\"<task>\" [--quick] [--risk low|med|high] [--budget <amount>]"
 
 # harness-auto
 
-Pipeline orchestrator — one session, sequential `Agent` spawns. Invoke **harness-orchestration** skill for agent IDs. Do **not** implement or review inline.
+Pipeline orchestrator — one session, sequential phase handoffs. Invoke **harness-orchestration** skill for agent IDs. Do **not** implement or review inline.
 
 ## Step 0 — Parse arguments
 
@@ -18,20 +18,22 @@ If task missing:
 
 ## Orchestration (required) — same session
 
-1. **Plan** — follow `/harness-plan` parent orchestration (parallel `harness/planning/scout-*`, `decompose`, `hypothesis`, draft PlanPacket, `ask_user` on fork, parallel `plan-adversary` + `hypothesis-eval`, parent `approve_plan` + `create_plan`). Do not spawn `harness/planner`. No second approval pass.
-2. **Execute** — spawn `harness/executor` with `HarnessSpawnContext` (`mode: execute`). Summarize handoff bullets for next spawn (do not paste full subagent log).
-3. **Eval** — spawn `harness/evaluator` (`mode: benchmark`) after parent scripts if needed.
-4. **Review** — spawn `harness/evaluator` (`mode: verdict`) OR rely on eval verdict if policy allows — prefer both when strict gates require.
-5. **Adversary** — spawn `harness/adversary` with artifact paths.
-6. **Tie-breaker** — spawn `harness/tie-breaker` only if debate unresolved.
+Follow **harness-plan** performance rules (`subagent` with parallel `tasks`, `agentScope: "both"`).
+
+1. **Plan** — follow `/harness-plan` (parallel scouts → parallel decompose/hypothesis → draft PlanPacket → debate rounds → parent `approve_plan` + `create_plan`). No second approval pass.
+2. **Execute** — `subagent({ agent: "harness/executor", task: "<HarnessSpawnContext mode execute>" })`; summarize handoff bullets only (do not paste full subprocess log).
+3. **Eval** — `subagent({ agent: "harness/evaluator", task: "<mode benchmark>" })` after parent scripts if needed.
+4. **Review** — `subagent({ agent: "harness/evaluator", task: "<mode verdict>" })` when strict gates require.
+5. **Adversary** — `subagent({ agent: "harness/adversary", ... })`. **Skip when `--quick`**.
+6. **Tie-breaker** — `subagent({ agent: "harness/tie-breaker", ... })` only if debate unresolved and **not** `--quick`.
 7. **Parent** — apply locked strict gates below; commit/PR only if all pass.
 
-No new Pi session for review — subagents use isolated context (`inherit_context: false`).
+Review agents run in isolated subprocesses via `subagent` (same parent session).
 
 ## Locked decisions (do not change)
 
 - Always produce and approve plan before mutation.
-- Adversarial review always required.
+- Adversarial review always required **except** `--quick` (evaluator-only gate).
 - Severity-policy-engine blocks merge.
 - Router tuning propose-and-approve only.
 - Plan ambiguity → parent `ask_user` (harness-decisions).
@@ -41,11 +43,11 @@ No new Pi session for review — subagents use isolated context (`inherit_contex
 
 ## Strict gates
 
-Block commit/PR if any fails: plan gate, execution in scope, evaluator pass, adversary complete, severity-policy pass/conditional_pass, benchmark deltas, rollback artifacts.
+Block commit/PR if any fails: plan gate, execution in scope, evaluator pass, adversary complete (unless `--quick`), severity-policy pass/conditional_pass, benchmark deltas, rollback artifacts.
 
 ## Notes
 
-- `--quick` reduces breadth, never safety gates.
+- `--quick` reduces breadth (skips semantic scout, post-run adversary, tie-breaker), never core safety gates on plan approval or evaluator.
 - High risk/ambiguity → stop and recommend manual `/harness-plan` with `ask_user`.
 - Interrupt: `/harness-abort [reason]` then `/harness-plan`.
 - Artifact refs under active run dir; `/harness-run-status` or `/harness-trace-last` for handoff.

package/.pi/prompts/harness-critic.md

@@ -20,10 +20,10 @@ Happy path: omit `--run`.
 2. Spawn:
 
 ```
-Agent({ subagent_type: "harness/adversary", prompt: "…" })
+subagent({ agentScope: "both", agent: "harness/adversary", task: "…" })
 ```
 
-3. `get_subagent_result` — parse `AdversaryReport` JSON; parent persists for severity policy.
+3. Parse `AdversaryReport` JSON from tool result; parent persists for severity policy.
 
 ## Parent rules
 

package/.pi/prompts/harness-eval.md

@@ -26,11 +26,11 @@ If no active run:
 4. Spawn:
 
 ```
-Agent({ subagent_type: "harness/evaluator", prompt: "…" })
+subagent({ agentScope: "both", agent: "harness/evaluator", task: "<HarnessSpawnContext + eval brief>" })
 ```
 
-5. `get_subagent_result` — parse eval JSON; parent writes structured artifacts under run dir.
-6. Do not edit `plan-packet.json`.
+5. Parse eval JSON from tool result; parent writes structured artifacts under run dir.
+6. Do not edit `plan-packet.yaml`.
 
 ## Parent rules
 

package/.pi/prompts/harness-incident.md

@@ -22,10 +22,10 @@ If `--trigger` missing:
 2. Spawn:
 
 ```
-Agent({ subagent_type: "harness/incident-recorder", prompt: "…" })
+subagent({ agentScope: "both", agent: "harness/incident-recorder", task: "…" })
 ```
 
-3. `get_subagent_result` — validate `IncidentRecord` draft; parent writes under `.pi/harness/incidents/`.
+3. Parse `IncidentRecord` JSON from tool result; parent writes under `.pi/harness/incidents/`.
 
 ## Completion
 

package/.pi/prompts/harness-plan.md

@@ -1,154 +1,145 @@
 ---
-description: Transform a vague task into a rigorous hypothesis via decomposition + DARWIN synthesis, then a strict PlanPacket.
+description: PM-grade harness plan — scouts, ExecutionPlan, DAG validation, Review Gate debate, approval.
 argument-hint: "\"<task>\" [--risk low|med|high] [--budget <amount>] [--quick]"
 ---
 
 # harness-plan
 
-Parent orchestrator — run planning in **this session**. Subagents explore, decompose, hypothesize, and review; you own `ask_user`, `approve_plan`, and `create_plan`. Never `write` or `edit` `plan-packet.json` — use **`create_plan`** only.
+You are the **planning PM** for this harness run. Produce an execution baseline (`plan-packet.yaml` + `plan-review.md`), not strategy theater. Parent owns `ask_user`, `approve_plan`, `create_plan`, debate bus commands, and YAML writes under `.pi/harness/runs/<run_id>/`.
 
-Allowed `subagent_type` values (copy exactly):
+Never `write`/`edit` the final canonical packet except via **`write_harness_yaml`** for run artifacts and **`create_plan`** after approval. Do not paste JSON into `.yaml` files — subagents emit JSON; you convert via `write_harness_yaml`.
+
+## Allowed subagents
 
 - `harness/planning/scout-graphify`
 - `harness/planning/scout-structure`
-- `harness/planning/scout-semantic`
+- `harness/planning/scout-semantic` (skip when `--quick`)
 - `harness/planning/decompose`
 - `harness/planning/hypothesis`
+- `harness/planning/stack-researcher`
+- `harness/planning/execution-plan-author`
+- `harness/planning/hypothesis-validator` (debate R1 only)
+- `harness/planning/plan-evaluator`
 - `harness/planning/plan-adversary`
-- `harness/planning/hypothesis-eval`
-
-Do **not** spawn `harness/planner` or `harness/planning/planner`.
+- `harness/planning/sprint-contract-auditor`
+- `harness/planning/review-integrator`
 
-## Step 0 — Parse arguments
+Read **harness-debate-plan** skill before Review Gate rounds.
 
-Read `$ARGUMENTS`:
+## Performance rules
 
-- task statement (required) — **THE QUESTION**
-- optional: `--risk low|med|high`, `--budget <amount>`, `--quick`
+1. Use `subagent` with `agentScope: "both"` and parallel `tasks` where lanes are independent.
+2. Each `subagent` call blocks until subprocesses finish — batch parallel scouts in one `tasks` array.
+3. Do **not** set `timeoutMs` unless the user explicitly requests a cap — subagents run until natural completion (optional backstop: `PI_SUBAGENT_TIMEOUT_MS`).
+4. Cap: **12** harness subagent invocations per parent session (extension-enforced).
+5. Compact task text: embed `HarnessSpawnContext` JSON + lane-specific instructions only.
 
-If task is missing:
+## Step 0 — Parse `$ARGUMENTS`
 
-`Usage: /harness-plan "<task>" [--risk low|med|high] [--budget <amount>] [--quick]`
+- task (required)
+- `--risk low|med|high`, `--budget`, `--quick`
 
-`--quick` skips `harness/planning/scout-semantic` only — never skip graphify, structure, decompose, hypothesis, or approval.
+`--quick` skips **scout-semantic** and post-run adversary only — **never** skip graphify, structure, decompose, hypothesis, stack research, execution plan, DAG validation, or **4-round plan debate**.
 
 ## Active plan context
 
-Use injected context only — **do not** read `.pi/harness/specs/*.schema.json` from disk.
-
-If `[HarnessActivePlan]` is present:
+Use `[HarnessActivePlan]` / `[HarnessRunContext]` only. On revise: preserve `plan_id` / `task_id`. Canonical paths: `plan-packet.yaml`, `research-brief.yaml`, `artifacts/*.yaml`.
 
-- Treat as **revise/amend** unless `/harness-new-run` was used.
-- Set `mode: revise` in `HarnessSpawnContext` from `[HarnessRunContext]`.
-- **Preserve `plan_id` and `task_id`** from the existing packet when amending.
-- Scouts focus on delta vs existing `plan_packet_path`; full re-scout only if scope changed materially.
+## Phase 0 — Semantic index (automatic)
 
-Otherwise use `HarnessSpawnContext` from `[HarnessRunContext]` with `mode: create`.
+Do **not** run `ccc index` or `ccc search --refresh`. The harness runs incremental `ccc index` before subagent spawns. Proceed directly to Phase 1 scouts.
 
-## Phase 1 — Parallel scouts (required)
+## Phase 1 — Parallel scouts
 
-1. Copy `HarnessSpawnContext` from `[HarnessRunContext]` (adjust `risk_level`, `quick`, `mode` from `$ARGUMENTS`).
-2. Spawn scouts with **`inherit_context: false`**. Prefer parallel: `run_in_background: true` on each `Agent` call, then `get_subagent_result` for all.
-
-```
-Agent({ subagent_type: "harness/planning/scout-graphify", prompt: "<task + HarnessSpawnContext + scout JSON schema>", run_in_background: true })
-Agent({ subagent_type: "harness/planning/scout-structure", prompt: "…", run_in_background: true })
+```json
+{
+  "agentScope": "both",
+  "tasks": [
+    { "agent": "harness/planning/scout-graphify", "task": "<HarnessSpawnContext + graphify lane>" },
+    { "agent": "harness/planning/scout-structure", "task": "<HarnessSpawnContext + structure lane>" }
+  ]
+}
 ```
 
-Skip `harness/planning/scout-semantic` when `--quick` or `quick: true`.
+Add `harness/planning/scout-semantic` to `tasks` unless `--quick`. Require graphify + structure success. Semantic lane uses `ccc search` only (see `scout-semantic` agent).
 
-3. Parse each scout’s fenced `json` (`lane`, `status`, `findings`, `key_paths`, `open_questions`).
-4. **Partial failure:** require successful **graphify + structure** lanes. Semantic is optional. If a required lane fails, continue with `plan_status: partial` and document gaps in `assumptions`.
-5. If JSON parse fails for a lane, summarize free-text output and add an assumption that the lane was unstructured.
+## Phase 2 & 3 — Decompose + hypothesis (parallel)
 
-## Phase 2 — Decompose (DeepMind-style)
+One `subagent` call with `tasks` for `harness/planning/decompose` and `harness/planning/hypothesis`. Parse `PlanDecompositionBrief` and `PlanHypothesisBrief` from outputs. Persist with `write_harness_yaml` → `artifacts/decomposition.yaml` and `artifacts/hypothesis.yaml`.
 
-1. Spawn once with merged scout JSON:
+## Phase 4 — Draft shell + fork
 
-```
-Agent({ subagent_type: "harness/planning/decompose", prompt: "<HarnessSpawnContext + task + all scout lane JSON>", inherit_context: false })
-```
+Build draft `PlanPacket` (`contract_version: "1.1.0"`):
 
-2. Parse `PlanDecompositionBrief` JSON (`problem_restatement`, `core_tension`, `tensions`, `prior_art`, etc.).
-3. On parse failure: one retry with “output valid JSON only”; if still failing, abort with `plan_status: needs_clarification`.
+- `scope`, `assumptions`, `acceptance_checks`, `risk_level`, `rollback_plan`
+- `execution_plan` placeholder until Phase 4b
 
-## Phase 3 — Hypothesis (DARWIN)
+`ask_user` when `dialectical_fork` is material.
 
-1. Spawn once:
+Initialize `research-brief.yaml` with decomposition + hypothesis (`write_harness_yaml`).
+
+## Phase 4a — Stack research
 
 ```
-Agent({ subagent_type: "harness/planning/hypothesis", prompt: "<HarnessSpawnContext + task + PlanDecompositionBrief + scout summaries>", inherit_context: false })
+subagent({ agentScope: "both", agent: "harness/planning/stack-researcher", task: "<HarnessSpawnContext + stack research brief>" })
 ```
 
-2. Parse `PlanHypothesisBrief` JSON (`primary`, `dialectical_fork`, `alternatives`, `recommended_next_steps`).
-3. **Revision cap:** at most **one** re-spawn of `hypothesis` if Phase 6 eval requests revision (see below).
+`write_harness_yaml` → `artifacts/stack.yaml`; merge into `research-brief.yaml` → `stack`.
 
-## Phase 4 — Draft PlanPacket + fork clarification (parent)
+## Phase 4b — Execution plan author
 
-Map hypothesis → [`PlanPacket`](.pi/harness/specs/plan-packet.schema.json):
+```
+subagent({ agentScope: "both", agent: "harness/planning/execution-plan-author", task: "<HarnessSpawnContext + execution plan brief>" })
+```
 
-| Field | Source |
-|-------|--------|
-| `scope` | `problem_restatement` (narrowed) + `primary.claim` + `primary.mechanism` (implementation-ready) |
-| `assumptions` | `core_tension`, `prior_art.dead_ends`, scout `open_questions`, chosen fork path (if any) |
-| `acceptance_checks` | Each `primary.prediction` and `primary.experiment` as verifiable checklist items (min 1) |
-| `risk_level` | From `$ARGUMENTS` or infer from fork uncertainty / blast radius |
+Merge `execution_plan` into draft `plan-packet.yaml` (`write_harness_yaml`). Save `artifacts/execution-plan-draft.yaml` the same way.
 
-Build complete draft: `plan_id`, `task_id`, `scope`, `assumptions`, `risk_level`, `acceptance_checks`, `rollback_plan` (`revert_commit_ready: true`, artifacts filled).
+## Phase 4c — DAG validation (hard gate)
 
-Call **`ask_user`** when `dialectical_fork` is material (Path A vs B materially different) **before** Phase 5 reviews.
+```bash
+node .pi/scripts/validate-plan-dag.mjs --packet .pi/harness/runs/<run_id>/plan-packet.yaml --write
+```
 
-Assemble `research_brief` for approval:
+Must **pass** before debate. On fail: fix via author or parent patches, re-run.
 
-```json
-{
-  "decomposition": { /* PlanDecompositionBrief */ },
-  "hypothesis": { /* PlanHypothesisBrief */ },
-  "eval": null
-}
-```
+## Phase 5 — Review Gate debate (4 rounds, even with `--quick`)
 
-## Phase 5 — Parallel reviews
+1. `/harness-debate-open plan-<run_id>`
+2. For rounds 1–4 (`debate_round_focus`: spec, wbs, schedule, quality):
 
-Spawn in parallel (`run_in_background: true`):
+| Round | Extra spawns (before integrator) |
+|-------|----------------------------------|
+| 1 | `hypothesis-validator` (blind: task + hypothesis only) → `plan-evaluator` → `plan-adversary` |
+| 2 | `plan-evaluator` → `plan-adversary` (optional `sprint-contract-auditor` if done_criteria thin) |
+| 3 | `plan-evaluator` → `plan-adversary` |
+| 4 | `plan-evaluator` → `plan-adversary` → **`sprint-contract-auditor` (required)** |
 
-```
-Agent({ subagent_type: "harness/planning/plan-adversary", prompt: "<HarnessSpawnContext + draft PlanPacket + scout summaries + decomposition human_summary>", inherit_context: false })
-Agent({ subagent_type: "harness/planning/hypothesis-eval", prompt: "<original task ONLY + PlanHypothesisBrief JSON — no decomposition, no PlanPacket>", inherit_context: false })
-```
+Then `review-integrator` → `write_harness_yaml` → `artifacts/review-round-r{N}.yaml` → build bus envelope → `/harness-debate-round '<json>'`.
 
-1. Parse `PlanAdversaryBrief` — merge `mitigations` into scope, assumptions, or `acceptance_checks`.
-2. Parse `PlanHypothesisEval` — set `research_brief.eval`.
-3. If `revision_recommended` or testability &lt; 70 or `relevance.passes` is false: re-spawn `hypothesis` once with eval rationale, update PlanPacket + `research_brief.hypothesis`, then re-run **hypothesis-eval** only (not adversary unless PlanPacket changed materially).
+3. `/harness-debate-consensus` after round 4.
 
-Cap: **at most 2** plan-adversary spawns and **at most 2** `approve_plan` rounds per invocation.
+**R1 blind rule:** hypothesis-validator prompt must exclude decomposition, scouts, PlanPacket, prior debate.
 
-## Phase 6 — Approval + persistence (parent)
+If R1 `revision_recommended` or `relevance.passes === false`: one `hypothesis` re-spawn, update brief, continue.
 
-1. Call **`approve_plan`** with `plan_packet`, `human_summary` (primary claim + fork if any), and `research_brief`.
-2. On **Approve** only, call **`create_plan`** with the **same** `plan_packet`.
-3. If `create_plan` fails, tell the user to fix validation errors or run `/harness-plan-commit` after approval is recorded.
-4. Confirm `[HarnessRunContext]` `plan_ready: true` before handoff.
+**Blockers:** `policy_decision: block` → do not `approve_plan`. `human_required` → `ask_user` before approval.
 
-On **Cancel** or Esc: `plan_status: needs_clarification`; do **not** call `create_plan`.
+## Phase 5b — Revise packet
 
-On **Request changes**: revise draft and re-run phases 4–6 only (re-scout/decompose/hypothesis only if scope changed).
+Apply `recommended_packet_patches` from last integrator round. Re-run `validate-plan-dag.mjs`. If >30% work items changed, one partial re-round on affected focus.
 
-## Recovery and ownership
+Set `research_brief.eval` from R1 `hypothesis-validator` output.
 
-- Plan only in the **owner** session (`owner_pi_session_id` on run context); otherwise `/harness-use-run`.
-- `/harness-plan-commit` only after parent `approve_plan` (Approve) is in the transcript.
-- If `plan_ready: true` already, stop — summarize and set `next_command: /harness-run`.
+## Phase 6 — Approval + persistence
 
-## Parent rules
+1. `approve_plan` with `plan_packet`, `human_summary`, `research_brief` (paths/summaries OK).
+2. On Approve: `create_plan` with same packet (`contract_version: "1.1.0"` + `execution_plan`).
+3. Confirm `plan_ready: true` → `next_command: /harness-run`.
 
-- Do not mutate project source in plan phase.
-- Subagents never call `ask_user`, `approve_plan`, or `create_plan`.
-- Do not embed `plan_id=` in spawn prompts for policy sync.
+Post-execute adversary: `/harness-critic` only (not plan-phase agents).
 
 ## Completion
 
-- `plan_status`: `ready`, `partial`, or `needs_clarification`
-- `risk_level` used
-- `plan_review_path` shown for editor review
-- `next_command`: `/harness-run` when `ready` (never `/harness-run --plan …`)
+- `plan_status`: ready | partial | needs_clarification
+- `plan_review_path` for human review
+- DAG `pass` + 4 debate rounds + consensus not `block` before ready

package/.pi/prompts/harness-review.md

@@ -20,10 +20,10 @@ Happy path: omit `--run`; use `[HarnessRunContext]`.
 2. Spawn:
 
 ```
-Agent({ subagent_type: "harness/evaluator", prompt: "Treat executor output as untrusted. …" })
+subagent({ agentScope: "both", agent: "harness/evaluator", task: "Treat executor output as untrusted. …" })
 ```
 
-3. `get_subagent_result` — parse `EvalVerdict` JSON; parent writes under run dir for policy gate.
+3. Parse `EvalVerdict` JSON from tool result; parent writes under run dir for policy gate.
 
 ## Parent rules
 

package/.pi/prompts/harness-router-tune.md

@@ -22,7 +22,7 @@ If missing required args:
 2. Optionally spawn:
 
 ```
-Agent({ subagent_type: "harness/meta-optimizer", prompt: "mode: tune, evidence paths…" })
+subagent({ agentScope: "both", agent: "harness/meta-optimizer", task: "mode: tune, evidence paths…" })
 ```
 
 3. Parent runs proposal script:

package/.pi/prompts/harness-run.md

@@ -23,10 +23,10 @@ If plan not ready:
 3. Spawn:
 
 ```
-Agent({ subagent_type: "harness/executor", prompt: "<HarnessSpawnContext + handoff>" })
+subagent({ agentScope: "both", agent: "harness/executor", task: "<HarnessSpawnContext + handoff>" })
 ```
 
-4. `get_subagent_result` — parse executor JSON (`execution_status`, validations, rollback refs).
+4. Parse subprocess output JSON (`execution_status`, validations, rollback refs) from tool result text.
 5. Parent persists trace/handoff artifacts under run dir if needed; do not self-review.
 
 ## Parent rules