@ilya-lesikov/pi-pi 0.5.0 → 0.6.0

package/extensions/orchestrator/phases/review.ts

@@ -1,12 +1,18 @@
 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 {
+function isEnabled(value: { enabled?: boolean } | undefined): boolean {
+  return value?.enabled !== false;
+}
+
+export function reviewSystemPrompt(taskDir: string, pass: number, phase?: string): string {
   const reviewsDir = phase === "brainstorm" ? join(taskDir, "brainstorm-reviews") : join(taskDir, "code-reviews");
   const plansDir = join(taskDir, "plans");
 
@@ -33,25 +39,6 @@ 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");
   }
 
@@ -61,10 +48,9 @@ export function reviewSystemPrompt(taskDir: string, pass: number, manualReview =
     "Code 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.",
+    "You are a SYNTHESIZER: merge the reviewer outputs. Do NOT write your own code review from scratch.",
     "- 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.",
+    "- Do NOT call plannotator_submit_plan.",
     "",
     "# Your job (in this order):",
     `1. Read ALL reviewer outputs from ${reviewsDir}/`,
@@ -76,8 +62,6 @@ export function reviewSystemPrompt(taskDir: string, pass: number, manualReview =
     "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.",
   ].join("\n");
 }
 
@@ -88,13 +72,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 +91,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 +104,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 +141,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 +161,7 @@ export async function spawnCodeReviewers(
     : [];
 
   if (reviewFiles.length > 0) {
-    pi.sendMessage(
+    send(
       {
         customType: "pp-code-reviews-done",
         content: [
@@ -173,10 +172,10 @@ export async function spawnCodeReviewers(
         ].join("\n"),
         display: true,
       },
-      { deliverAs: "steer" },
+      "context",
     );
   } else {
-    pi.sendMessage(
+    send(
       {
         customType: "pp-code-reviews-error",
         content: [
@@ -185,7 +184,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();
+  });
+});

package/extensions/orchestrator/plannotator.ts

@@ -9,23 +9,30 @@ export function openPlannotator(
   const requestId = crypto.randomUUID();
   return new Promise((resolve) => {
     let handled = false;
+    const timer = setTimeout(() => {
+      if (!handled) resolve({ opened: false, reviewId: null });
+    }, 30000);
     pi.events.emit("plannotator:request", {
       requestId,
       action,
       payload,
       respond: (response: any) => {
         handled = true;
+        clearTimeout(timer);
         const reviewId = response?.result?.reviewId ?? null;
         resolve({ opened: response.status === "handled", reviewId });
       },
     });
-    setTimeout(() => {
-      if (!handled) resolve({ opened: false, reviewId: null });
-    }, 30000);
   });
 }
 
+const PLANNOTATOR_RESULT_TIMEOUT_MS = 30 * 60 * 1000;
+
 export function cancelPendingPlannotatorWait(orchestrator: Orchestrator): void {
+  if (orchestrator.plannotatorTimer) {
+    clearTimeout(orchestrator.plannotatorTimer);
+    orchestrator.plannotatorTimer = null;
+  }
   if (orchestrator.plannotatorUnsub) {
     orchestrator.plannotatorUnsub();
     orchestrator.plannotatorUnsub = null;
@@ -46,11 +53,22 @@ export function waitForPlannotatorResult(
     orchestrator.plannotatorReject = reject;
     const unsub = pi.events.on("plannotator:review-result", (data: any) => {
       if (reviewId && data?.reviewId && data.reviewId !== reviewId) return;
-      unsub();
-      orchestrator.plannotatorUnsub = null;
-      orchestrator.plannotatorReject = null;
+      cleanup();
       resolve({ approved: !!data?.approved, feedback: data?.feedback });
     });
     orchestrator.plannotatorUnsub = unsub;
+    function cleanup() {
+      unsub();
+      orchestrator.plannotatorUnsub = null;
+      orchestrator.plannotatorReject = null;
+      if (orchestrator.plannotatorTimer) {
+        clearTimeout(orchestrator.plannotatorTimer);
+        orchestrator.plannotatorTimer = null;
+      }
+    }
+    orchestrator.plannotatorTimer = setTimeout(() => {
+      cleanup();
+      reject(new Error("Plannotator review timed out"));
+    }, PLANNOTATOR_RESULT_TIMEOUT_MS);
   });
 }