@ilya-lesikov/pi-pi 0.5.0 → 0.7.0

package/extensions/orchestrator/phases/review.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect } from "vitest";
+import { reviewSystemPrompt } from "./review.js";
+
+describe("reviewSystemPrompt apply_feedback wording", () => {
+  it("autonomous plan/implement mandates re-calling pp_phase_complete and does not tell the agent to wait for the user", () => {
+    const prompt = reviewSystemPrompt("/tmp/task", 1, "plan", "autonomous");
+    expect(prompt).toContain("pp_phase_complete");
+    expect(prompt).not.toContain("Present the synthesis to the user");
+    expect(prompt).not.toContain("A new review pass will begin");
+  });
+
+  it("guided plan/implement keeps the user-facing synthesis behavior", () => {
+    const prompt = reviewSystemPrompt("/tmp/task", 1, "plan", "guided");
+    expect(prompt).toContain("Present the synthesis to the user");
+    expect(prompt).not.toContain("Call pp_phase_complete again to finalize");
+  });
+
+  it("brainstorm prompt is unaffected by mode (never instructs pp_phase_complete)", () => {
+    const auto = reviewSystemPrompt("/tmp/task", 1, "brainstorm", "autonomous");
+    const guided = reviewSystemPrompt("/tmp/task", 1, "brainstorm", "guided");
+    expect(auto).toBe(guided);
+    expect(auto).toContain("BRAINSTORM REVIEW CYCLE");
+    expect(auto).not.toContain("pp_phase_complete");
+  });
+
+  it("autonomous plan feedback folds into a new synthesized plan, not a separate fix-plan file", () => {
+    // Re-review and the transition read only the latest `*synthesized*` plan, so
+    // plan-phase feedback must land there.
+    const plan = reviewSystemPrompt("/tmp/task", 1, "plan", "autonomous");
+    expect(plan).toContain("synthesized.md");
+    expect(plan).not.toContain("do NOT modify the original synthesized plan");
+
+    // The implement phase keeps the fix-plan/implement pattern (synthesized plan
+    // is code guidance there, not the reviewed artifact).
+    const impl = reviewSystemPrompt("/tmp/task", 1, "implement", "autonomous");
+    expect(impl).toContain("Create a fix plan");
+    expect(impl).toContain("Implement the fixes");
+  });
+
+  it("points each phase at the directory its reviewers actually write to", () => {
+    // plan reviewers write to plan-reviews (planning.ts) and outputs load from
+    // plan-reviews (context.ts); the prompt must match, not code-reviews.
+    const plan = reviewSystemPrompt("/tmp/task", 1, "plan", "autonomous");
+    expect(plan).toContain("plan-reviews/");
+    expect(plan).not.toContain("code-reviews/");
+
+    const impl = reviewSystemPrompt("/tmp/task", 1, "implement", "autonomous");
+    expect(impl).toContain("code-reviews/");
+    expect(impl).not.toContain("plan-reviews/");
+
+    const brainstorm = reviewSystemPrompt("/tmp/task", 1, "brainstorm", "guided");
+    expect(brainstorm).toContain("brainstorm-reviews/");
+  });
+});

package/extensions/orchestrator/phases/review.ts

@@ -1,13 +1,25 @@
 import { readFileSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
 import { join } from "path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { PiPiConfig } from "../config.js";
+import { resolvePreset, type PiPiConfig, type VariantConfig } from "../config.js";
 import { registerAgentDefinitions, spawnViaRpc, waitForCompletion } from "../agents/registry.js";
 import { createCodeReviewerAgent } from "../agents/code-reviewer.js";
-import { getLatestSynthesizedPlan } from "../context.js";
+import { getContextDirs, getLatestSynthesizedPlan } from "../context.js";
+import type { RepoInfo } from "../repo-utils.js";
+import type { PhaseSend } from "../transition-controller.js";
 
-export function reviewSystemPrompt(taskDir: string, pass: number, manualReview = false, phase?: string): string {
-  const reviewsDir = phase === "brainstorm" ? join(taskDir, "brainstorm-reviews") : join(taskDir, "code-reviews");
+function isEnabled(value: { enabled?: boolean } | undefined): boolean {
+  return value?.enabled !== false;
+}
+
+export function reviewSystemPrompt(taskDir: string, pass: number, phase?: string, mode?: "guided" | "autonomous"): string {
+  // Each phase writes/loads its review outputs in a distinct directory:
+  // brainstorm -> brainstorm-reviews, plan -> plan-reviews, everything else
+  // (implement/review) -> code-reviews. The apply_feedback prompt must point the
+  // agent at the SAME directory the reviewers wrote to (see planning.ts /
+  // context.ts), otherwise it synthesizes against the wrong (empty) directory.
+  const reviewsDirName = phase === "brainstorm" ? "brainstorm-reviews" : phase === "plan" ? "plan-reviews" : "code-reviews";
+  const reviewsDir = join(taskDir, reviewsDirName);
   const plansDir = join(taskDir, "plans");
 
   if (phase === "brainstorm") {
@@ -33,51 +45,65 @@ export function reviewSystemPrompt(taskDir: string, pass: number, manualReview =
       "USER_REQUEST.md MUST keep exactly: # User Request, ## Problem, ## Constraints",
       "RESEARCH.md MUST keep exactly: ## Affected Code, ## Architecture Context, ## Constraints & Edge Cases, ## Open Questions (optional)",
       "Any other sections will fail validation.",
-      "",
-      "When done (or no changes needed), call pp_phase_complete with a brief summary.",
     ].join("\n");
   }
 
-  if (manualReview) {
-    return [
-      `[PI-PI — REVIEW CYCLE (pass ${pass}, manual)]`,
-      "",
-      "Review the implementation yourself using the available tools.",
-      "",
-      `Write your review to ${reviewsDir}/<timestamp>_final_pass-${pass}.md`,
-      "",
-      "If changes are needed:",
-      `1. Create a fix plan at ${plansDir}/<timestamp>_<description>.md`,
-      "2. Implement the fixes",
-      "3. Run afterImplement commands",
-      "",
-    "When done, call pp_phase_complete with a brief summary.",
-    ].join("\n");
-  }
+  // In autonomous plan/implement the phase does NOT complete until the agent
+  // re-calls pp_phase_complete: that is what finalizes the pass and advances the
+  // phase. Telling it to "present to the user" and wait causes the plan phase to
+  // stall after applying feedback. Guided mode keeps the user-facing behavior.
+  const finalStep =
+    mode === "autonomous"
+      ? "3. Call pp_phase_complete again to finalize this review pass. The phase is NOT complete until you do — do NOT stop or wait for the user"
+      : "3. Present the synthesis to the user";
+
+  // In the plan phase the synthesized plan IS the reviewed artifact: re-review
+  // and the phase transition both read only the LATEST `*synthesized*` file (see
+  // getLatestSynthesizedPlan). So autonomous plan feedback must be folded into a
+  // new synthesized plan, NOT a separate fix-plan file (which those readers
+  // ignore). In the implement phase the synthesized plan is code guidance, so
+  // the fix-plan/implement/afterImplement pattern is correct there.
+  const tail =
+    mode === "autonomous"
+      ? phase === "plan"
+        ? [
+            "",
+            "If the reviewers require changes:",
+            `1. Fold the required changes into a NEW synthesized plan at ${plansDir}/<timestamp>_synthesized.md (re-review and the phase transition read only the latest \`*synthesized*\` plan, so the fixes MUST land there — do not write them to a separate fix-plan file)`,
+            "2. Then call pp_phase_complete again — the extension will start a new review pass or advance the phase as appropriate. Do NOT wait for the user.",
+          ]
+        : [
+            "",
+            "If changes are needed:",
+            `1. Create a fix plan at ${plansDir}/<timestamp>_<description>.md (do NOT modify the original synthesized plan)`,
+            "2. Implement the fixes",
+            "3. Run afterImplement commands",
+            "4. Then call pp_phase_complete again — the extension will start a new review pass or advance the phase as appropriate. Do NOT wait for the user.",
+          ]
+      : [
+          "",
+          "If changes are needed:",
+          `1. Create a fix plan at ${plansDir}/<timestamp>_<description>.md (do NOT modify the original synthesized plan)`,
+          "2. Implement the fixes",
+          "3. Run afterImplement commands",
+          "4. A new review pass will begin",
+        ];
 
   return [
     `[PI-PI — REVIEW CYCLE (pass ${pass})]`,
     "",
-    "Code reviewer outputs are ready.",
+    "Reviewer outputs are ready.",
     `Read them from ${reviewsDir}/, synthesize feedback, and implement fixes if needed.`,
     "",
-    "# FORBIDDEN — do NOT do any of these:",
-    "- Do NOT write your own code review from scratch. You are a SYNTHESIZER, not a reviewer.",
-    "- Do NOT create the code-reviews/ directory yourself — the extension manages it.",
-    "- Do NOT call plannotator_submit_plan — code review is handled by the user via /pp menu.",
+    "You are a SYNTHESIZER: merge the reviewer outputs. Do NOT write your own review from scratch.",
+    `- Do NOT create the ${reviewsDirName}/ directory yourself — the extension manages it.`,
+    "- Do NOT call plannotator_submit_plan.",
     "",
     "# Your job (in this order):",
     `1. Read ALL reviewer outputs from ${reviewsDir}/`,
     `2. Synthesize into ${reviewsDir}/<timestamp>_final_pass-${pass}.md`,
-    "3. Present the synthesis to the user",
-    "",
-    "If changes are needed:",
-    `1. Create a fix plan at ${plansDir}/<timestamp>_<description>.md (do NOT modify the original synthesized plan)`,
-    "2. Implement the fixes",
-    "3. Run afterImplement commands",
-    "4. A new review pass will begin",
-    "",
-    "When the synthesized review is ready, call pp_phase_complete with a brief summary.",
+    finalStep,
+    ...tail,
   ].join("\n");
 }
 
@@ -88,13 +114,17 @@ export async function spawnCodeReviewers(
   taskId: string,
   config: PiPiConfig,
   round: number,
+  phase: string,
+  send: PhaseSend,
+  variants?: Record<string, VariantConfig>,
+  repos: RepoInfo[] = [],
 ): Promise<{ spawned: number; agentIds: string[]; failedVariants: string[] }> {
   const urPath = join(taskDir, "USER_REQUEST.md");
   const resPath = join(taskDir, "RESEARCH.md");
   if (!existsSync(urPath) || !existsSync(resPath)) {
-    pi.sendMessage(
+    send(
       { customType: "pp-code-reviews-error", content: "Cannot start code review: USER_REQUEST.md or RESEARCH.md is missing.", display: true },
-      { deliverAs: "steer" },
+      "context",
     );
     return { spawned: 0, agentIds: [], failedVariants: [] };
   }
@@ -103,9 +133,9 @@ export async function spawnCodeReviewers(
   const research = readFileSync(resPath, "utf-8");
   const synthesizedPlan = getLatestSynthesizedPlan(taskDir);
   if (!synthesizedPlan) {
-    pi.sendMessage(
+    send(
       { customType: "pp-code-reviews-error", content: "Cannot start code review: no synthesized plan found.", display: true },
-      { deliverAs: "steer" },
+      "context",
     );
     return { spawned: 0, agentIds: [], failedVariants: [] };
   }
@@ -116,14 +146,25 @@ export async function spawnCodeReviewers(
   }
 
   const timestamp = Math.floor(Date.now() / 1000);
-  const enabledVariants = Object.entries(config.codeReviewers).filter(([, v]) => v.enabled);
+  const reviewerVariants = variants ?? resolvePreset(config, "codeReviewers");
+  const enabledVariants = Object.entries(reviewerVariants).filter(([, v]) => isEnabled(v));
+  const contextDirs = getContextDirs(cwd, repos, config.general.loadExtraRepoConfigs);
   const agentIds: string[] = [];
   const failedVariants: string[] = [];
   const results: Promise<void>[] = [];
 
   for (const [variant] of enabledVariants) {
     const outputPath = join(reviewsDir, `${timestamp}_${variant}_round-${round}.md`);
-    const agent = createCodeReviewerAgent(variant, config, { userRequest, research, synthesizedPlan }, outputPath);
+    const reviewerPhase = phase === "review" ? "review" : "implement";
+    const agent = createCodeReviewerAgent(
+      variant,
+      reviewerVariants,
+      { userRequest, research, synthesizedPlan },
+      outputPath,
+      contextDirs,
+      reviewerPhase,
+      repos,
+    );
 
     registerAgentDefinitions(pi, [{ type: "code_reviewer", variant, ...agent }]);
 
@@ -142,13 +183,13 @@ export async function spawnCodeReviewers(
           await waitForCompletion(pi, id);
         } catch (err: any) {
           failedVariants.push(variant);
-          pi.sendMessage(
+          send(
             {
               customType: "pp-code-reviewer-error",
               content: `Code reviewer variant "${variant}" failed: ${err.message}`,
               display: true,
             },
-            { deliverAs: "steer" },
+            "context",
           );
         }
       })(),
@@ -162,7 +203,7 @@ export async function spawnCodeReviewers(
     : [];
 
   if (reviewFiles.length > 0) {
-    pi.sendMessage(
+    send(
       {
         customType: "pp-code-reviews-done",
         content: [
@@ -173,10 +214,10 @@ export async function spawnCodeReviewers(
         ].join("\n"),
         display: true,
       },
-      { deliverAs: "steer" },
+      "context",
     );
   } else {
-    pi.sendMessage(
+    send(
       {
         customType: "pp-code-reviews-error",
         content: [
@@ -185,7 +226,7 @@ export async function spawnCodeReviewers(
         ].join("\n"),
         display: true,
       },
-      { deliverAs: "steer" },
+      "context",
     );
   }
 

package/extensions/orchestrator/phases/spawn-blocking.test.ts

@@ -0,0 +1,69 @@
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+let resolveWait: (() => void) | null = null;
+let waitStarted = false;
+
+vi.mock("../agents/registry.js", () => ({
+  registerAgentDefinitions: vi.fn(),
+  unregisterAgentDefinitions: vi.fn(),
+  spawnViaRpc: vi.fn(async () => ({ id: `agent-${Math.random().toString(36).slice(2)}` })),
+  waitForCompletion: vi.fn(
+    () =>
+      new Promise<void>((resolve) => {
+        waitStarted = true;
+        resolveWait = resolve;
+      }),
+  ),
+}));
+
+import { spawnPlanners } from "./planning.js";
+import { getDefaultConfig } from "../config.js";
+
+const tempDirs: string[] = [];
+
+function makeTaskDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "pi-pi-spawn-block-"));
+  tempDirs.push(dir);
+  writeFileSync(join(dir, "USER_REQUEST.md"), "# User Request\n\n## Problem\n\nx\n\n## Constraints\n\n- y\n");
+  writeFileSync(join(dir, "RESEARCH.md"), "## Affected Code\n\nx\n\n## Architecture Context\n\nx\n\n## Constraints & Edge Cases\n\nx\n\n## Open Questions\n\nx\n");
+  mkdirSync(join(dir, "plans"), { recursive: true });
+  return dir;
+}
+
+function makePi(): any {
+  return { sendMessage: vi.fn(), events: { emit: vi.fn(), on: vi.fn() } };
+}
+
+afterEach(() => {
+  resolveWait = null;
+  waitStarted = false;
+  for (const dir of tempDirs.splice(0)) rmSync(dir, { recursive: true, force: true });
+  vi.clearAllMocks();
+});
+
+describe("spawn blocks until completion (review-cycle invariant)", () => {
+  it("spawnPlanners does not resolve until waitForCompletion resolves", async () => {
+    const taskDir = makeTaskDir();
+    const config = getDefaultConfig();
+    const variants = { only: { model: "anthropic/claude-test", enabled: true } } as any;
+
+    const send = vi.fn();
+    const promise = spawnPlanners(makePi(), taskDir, taskDir, "1", config, send, variants);
+
+    let settled = false;
+    promise.then(() => {
+      settled = true;
+    });
+
+    await vi.waitFor(() => expect(waitStarted).toBe(true));
+    await Promise.resolve();
+    expect(settled).toBe(false);
+
+    resolveWait!();
+    await promise;
+    expect(settled).toBe(true);
+  });
+});

package/extensions/orchestrator/phases/verdict.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { parseVerdict, hasActionableFindings, reviewPassUnanimousApprove } from "./verdict.js";
+
+describe("parseVerdict", () => {
+  it("parses inline colon form", () => {
+    expect(parseVerdict("- VERDICT: APPROVE")).toBe("approve");
+  });
+
+  it("parses the header form with token on a later line (opus)", () => {
+    expect(parseVerdict("## Findings\nNone.\n\n## VERDICT\n\nAPPROVE")).toBe("approve");
+  });
+
+  it("parses bold form", () => {
+    expect(parseVerdict("**VERDICT:** APPROVE")).toBe("approve");
+  });
+
+  it("parses all negative tokens as changes", () => {
+    expect(parseVerdict("VERDICT: NEEDS_CHANGES")).toBe("changes");
+    expect(parseVerdict("VERDICT: NEEDS_WORK")).toBe("changes");
+    expect(parseVerdict("VERDICT: REJECT")).toBe("changes");
+    expect(parseVerdict("## VERDICT\nNEEDS_CHANGES")).toBe("changes");
+  });
+
+  it("is case-insensitive on the label", () => {
+    expect(parseVerdict("verdict: approve")).toBe("approve");
+  });
+
+  it("returns unknown when no verdict line", () => {
+    expect(parseVerdict("LGTM, looks fine")).toBe("unknown");
+  });
+
+  it("first-line verdict wins over a later VERDICT-like word in prose", () => {
+    const review = [
+      "VERDICT: NEEDS_CHANGES",
+      "- CRITICAL: the prose below mentions the word VERDICT: APPROVE but must not win",
+    ].join("\n");
+    expect(parseVerdict(review)).toBe("changes");
+  });
+});
+
+describe("hasActionableFindings", () => {
+  it("treats inline 'none' as no findings", () => {
+    expect(hasActionableFindings("- CRITICAL: none\n- MAJOR: (none)")).toBe(false);
+  });
+
+  it("detects a real inline CRITICAL finding", () => {
+    expect(hasActionableFindings("- CRITICAL: null deref at foo.ts:10")).toBe(true);
+  });
+
+  it("ignores MINOR findings", () => {
+    expect(hasActionableFindings("- MINOR: rename a variable")).toBe(false);
+  });
+
+  it("treats header form with 'None.' body as no findings (opus)", () => {
+    expect(hasActionableFindings("## Findings\n\n### CRITICAL\nNone.\n\n### MAJOR\nNone.\n")).toBe(false);
+  });
+
+  it("detects a real header-form CRITICAL finding", () => {
+    expect(hasActionableFindings("### CRITICAL\nnull deref at x.ts:1\n\n### MAJOR\nNone.")).toBe(true);
+  });
+});
+
+describe("reviewPassUnanimousApprove", () => {
+  let dir: string;
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), "verdict-test-"));
+  });
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("returns true when all reviewer files approve with no findings", () => {
+    const rd = join(dir, "code-reviews");
+    mkdirSync(rd, { recursive: true });
+    writeFileSync(join(rd, "1_a_round-1.md"), "- CRITICAL: none\n- VERDICT: APPROVE");
+    writeFileSync(join(rd, "1_b_round-1.md"), "- MAJOR: none\n- VERDICT: APPROVE");
+    expect(reviewPassUnanimousApprove(dir, "implement", 1, 2)).toBe(true);
+  });
+
+  it("returns true for the real opus header-form approval", () => {
+    const rd = join(dir, "code-reviews");
+    mkdirSync(rd, { recursive: true });
+    writeFileSync(
+      join(rd, "1_opus_round-1.md"),
+      "## Findings\n\n### CRITICAL\nNone.\n\n### MAJOR\nNone.\n\n## VERDICT\n\nAPPROVE\n",
+    );
+    expect(reviewPassUnanimousApprove(dir, "implement", 1, 1)).toBe(true);
+  });
+
+  it("returns false when one reviewer needs changes", () => {
+    const rd = join(dir, "code-reviews");
+    mkdirSync(rd, { recursive: true });
+    writeFileSync(join(rd, "1_a_round-1.md"), "- VERDICT: APPROVE");
+    writeFileSync(join(rd, "1_b_round-1.md"), "- VERDICT: NEEDS_CHANGES");
+    expect(reviewPassUnanimousApprove(dir, "implement", 1, 2)).toBe(false);
+  });
+
+  it("returns false when approved but with a CRITICAL finding", () => {
+    const rd = join(dir, "code-reviews");
+    mkdirSync(rd, { recursive: true });
+    writeFileSync(join(rd, "1_a_round-1.md"), "- CRITICAL: bug at x.ts:1\n- VERDICT: APPROVE");
+    expect(reviewPassUnanimousApprove(dir, "implement", 1, 1)).toBe(false);
+  });
+
+  it("returns false when fewer files than enabled reviewers (some failed)", () => {
+    const rd = join(dir, "code-reviews");
+    mkdirSync(rd, { recursive: true });
+    writeFileSync(join(rd, "1_a_round-1.md"), "- VERDICT: APPROVE");
+    expect(reviewPassUnanimousApprove(dir, "implement", 1, 3)).toBe(false);
+  });
+
+  it("returns false when a verdict is unparseable (fail-safe)", () => {
+    const rd = join(dir, "code-reviews");
+    mkdirSync(rd, { recursive: true });
+    writeFileSync(join(rd, "1_a_round-1.md"), "LGTM");
+    expect(reviewPassUnanimousApprove(dir, "implement", 1, 1)).toBe(false);
+  });
+
+  it("returns false when no reviewer files exist", () => {
+    expect(reviewPassUnanimousApprove(dir, "implement", 1, 1)).toBe(false);
+  });
+
+  it("uses brainstorm-reviews dir for brainstorm phase", () => {
+    const rd = join(dir, "brainstorm-reviews");
+    mkdirSync(rd, { recursive: true });
+    writeFileSync(join(rd, "1_a_round-1.md"), "- VERDICT: APPROVE");
+    expect(reviewPassUnanimousApprove(dir, "brainstorm", 1, 1)).toBe(true);
+  });
+
+  it("uses plan-reviews dir for plan phase", () => {
+    const rd = join(dir, "plan-reviews");
+    mkdirSync(rd, { recursive: true });
+    writeFileSync(join(rd, "1_a_round-1.md"), "- VERDICT: APPROVE");
+    expect(reviewPassUnanimousApprove(dir, "plan", 1, 1)).toBe(true);
+  });
+});

package/extensions/orchestrator/phases/verdict.ts

@@ -0,0 +1,82 @@
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { join } from "path";
+import type { Phase } from "../state.js";
+
+export type ReviewVerdict = "approve" | "changes" | "unknown";
+
+const CHANGES_TOKENS = ["NEEDS_CHANGES", "NEEDS_WORK", "REJECT"];
+
+export function parseVerdict(reviewContent: string): ReviewVerdict {
+  const match = reviewContent.match(/VERDICT\**\s*:?\**\s*\n*\s*([A-Z_]+)/i);
+  if (!match) return "unknown";
+  const token = match[1].toUpperCase();
+  if (CHANGES_TOKENS.includes(token)) return "changes";
+  if (token === "APPROVE") return "approve";
+  return "unknown";
+}
+
+function isNoneBody(text: string): boolean {
+  const cleaned = text.trim().replace(/[().*]/g, "").toLowerCase();
+  return cleaned === "" || /^none\b/.test(cleaned);
+}
+
+export function hasActionableFindings(reviewContent: string): boolean {
+  const lines = reviewContent.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i].trim();
+
+    const inline = raw.replace(/^[-*]\s*/, "").match(/^(CRITICAL|MAJOR)\b\s*:?(.*)$/i);
+    if (inline && !raw.startsWith("#")) {
+      if (!isNoneBody(inline[2])) return true;
+      continue;
+    }
+
+    const header = raw.match(/^#{1,4}\s*(CRITICAL|MAJOR)\b\s*:?(.*)$/i);
+    if (header) {
+      if (header[2].trim() !== "" && !isNoneBody(header[2])) return true;
+      let body = "";
+      for (let j = i + 1; j < lines.length; j++) {
+        if (/^#{1,4}\s/.test(lines[j].trim())) break;
+        body += lines[j] + "\n";
+      }
+      const meaningful = body
+        .split("\n")
+        .map((l) => l.trim().replace(/^[-*]\s*/, ""))
+        .filter((l) => l.length > 0);
+      if (meaningful.length > 0 && !meaningful.every((l) => isNoneBody(l))) return true;
+    }
+  }
+  return false;
+}
+
+function reviewsDirForPhase(taskDir: string, phase: Phase): string {
+  if (phase === "brainstorm") return join(taskDir, "brainstorm-reviews");
+  if (phase === "plan") return join(taskDir, "plan-reviews");
+  return join(taskDir, "code-reviews");
+}
+
+export function reviewPassUnanimousApprove(
+  taskDir: string,
+  phase: Phase,
+  round: number,
+  expectedReviewerCount: number,
+): boolean {
+  if (expectedReviewerCount <= 0) return false;
+  const dir = reviewsDirForPhase(taskDir, phase);
+  if (!existsSync(dir)) return false;
+  const files = readdirSync(dir).filter(
+    (f) => f.includes(`round-${round}`) && !f.includes("final") && f.endsWith(".md"),
+  );
+  if (files.length < expectedReviewerCount) return false;
+  for (const f of files) {
+    let content: string;
+    try {
+      content = readFileSync(join(dir, f), "utf-8");
+    } catch {
+      return false;
+    }
+    if (parseVerdict(content) !== "approve") return false;
+    if (hasActionableFindings(content)) return false;
+  }
+  return true;
+}

package/extensions/orchestrator/plannotator.test.ts

@@ -0,0 +1,85 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  cancelPendingPlannotatorWait,
+  openPlannotator,
+  waitForPlannotatorResult,
+} from "./plannotator.js";
+import type { Orchestrator } from "./orchestrator.js";
+
+type Handler = (data: any) => void;
+
+function makeEvents() {
+  const handlers = new Map<string, Set<Handler>>();
+  return {
+    handlers,
+    on(name: string, fn: Handler) {
+      if (!handlers.has(name)) handlers.set(name, new Set());
+      handlers.get(name)!.add(fn);
+      return () => handlers.get(name)!.delete(fn);
+    },
+    emit(name: string, data: any) {
+      for (const fn of handlers.get(name) ?? []) fn(data);
+    },
+  };
+}
+
+function makeOrchestrator(events: ReturnType<typeof makeEvents>): Orchestrator {
+  return {
+    pi: { events },
+    plannotatorReject: null,
+    plannotatorUnsub: null,
+    plannotatorTimer: null,
+  } as unknown as Orchestrator;
+}
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+describe("waitForPlannotatorResult", () => {
+  it("resolves when a matching review-result arrives", async () => {
+    const events = makeEvents();
+    const orch = makeOrchestrator(events);
+    const p = waitForPlannotatorResult(orch, "rev-1");
+    events.emit("plannotator:review-result", { reviewId: "rev-1", approved: true, feedback: "ok" });
+    await expect(p).resolves.toEqual({ approved: true, feedback: "ok" });
+    expect(orch.plannotatorTimer).toBeNull();
+  });
+
+  it("rejects on timeout instead of hanging forever", async () => {
+    vi.useFakeTimers();
+    const events = makeEvents();
+    const orch = makeOrchestrator(events);
+    const p = waitForPlannotatorResult(orch, "rev-1");
+    const assertion = expect(p).rejects.toThrow("timed out");
+    await vi.advanceTimersByTimeAsync(30 * 60 * 1000 + 1);
+    await assertion;
+    expect(orch.plannotatorTimer).toBeNull();
+  });
+
+  it("can be cancelled on task switch/done", async () => {
+    const events = makeEvents();
+    const orch = makeOrchestrator(events);
+    const p = waitForPlannotatorResult(orch, "rev-1");
+    const assertion = expect(p).rejects.toThrow("cancelled");
+    cancelPendingPlannotatorWait(orch);
+    await assertion;
+    expect(orch.plannotatorTimer).toBeNull();
+    expect(orch.plannotatorUnsub).toBeNull();
+  });
+});
+
+describe("openPlannotator", () => {
+  it("clears its timeout after respond so no late side effect fires", async () => {
+    vi.useFakeTimers();
+    const clearSpy = vi.spyOn(globalThis, "clearTimeout");
+    const events = makeEvents();
+    events.on("plannotator:request", (req: any) => {
+      req.respond({ status: "handled", result: { reviewId: "rev-9" } });
+    });
+    const pi = { events } as any;
+    const result = await openPlannotator(pi, "open", {});
+    expect(result).toEqual({ opened: true, reviewId: "rev-9" });
+    expect(clearSpy).toHaveBeenCalled();
+  });
+});