@ilya-lesikov/pi-pi 0.5.0 → 0.7.0

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

@@ -2,14 +2,17 @@ import { describe, expect, it } from "vitest";
 import { brainstormSystemPrompt } from "./brainstorm.js";
 
 describe("brainstormSystemPrompt", () => {
-  it("debug prompt uses pp_phase_complete", () => {
-    const prompt = brainstormSystemPrompt("debug", "fix a bug", "/tmp/task");
-    expect(prompt).toContain("pp_phase_complete");
-    expect(prompt).not.toContain("/pp:next");
+  it("debug prompt body is pure procedure (no completion/menu restatements)", () => {
+    const prompt = brainstormSystemPrompt("debug", "fix a bug", "/tmp/task", "/tmp");
+    expect(prompt).toContain("DEBUG PHASE");
+    expect(prompt).not.toContain("pp_phase_complete");
+    expect(prompt).not.toContain("/pp");
   });
 
-  it("brainstorm prompt uses pp_phase_complete", () => {
-    const prompt = brainstormSystemPrompt("brainstorm", "explore ideas", "/tmp/task");
-    expect(prompt).toContain("pp_phase_complete");
+  it("brainstorm prompt body is pure procedure (no completion/menu restatements)", () => {
+    const prompt = brainstormSystemPrompt("brainstorm", "explore ideas", "/tmp/task", "/tmp");
+    expect(prompt).toContain("conversation");
+    expect(prompt).not.toContain("pp_phase_complete");
+    expect(prompt).not.toContain("/pp");
   });
 });

package/extensions/orchestrator/phases/brainstorm.ts

@@ -1,23 +1,28 @@
 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 { createBrainstormReviewerAgent } from "../agents/brainstorm-reviewer.js";
+import { getContextDirs } from "../context.js";
+import type { RepoInfo } from "../repo-utils.js";
 import type { TaskType } from "../state.js";
+import type { PhaseSend } from "../transition-controller.js";
 
-export function brainstormSystemPrompt(taskType: TaskType, taskDescription: string, taskDir: string): string {
+function isEnabled(value: { enabled?: boolean } | undefined): boolean {
+  return value?.enabled !== false;
+}
+
+export function brainstormSystemPrompt(taskType: TaskType, taskDescription: string, taskDir: string, cwd: string): string {
+  const registerReposInstruction = `First, register all git repositories you'll work in using pp_register_repo (including the root: ${cwd}). For each, determine the base branch by examining the current branch and remote tracking.`;
   if (taskType === "debug") {
     return [
       "[PI-PI — DEBUG PHASE]",
       `Problem: ${taskDescription}`,
       "",
-    "Read-only diagnosis mode.",
-    "",
-    "# ABSOLUTE RESTRICTION — NO IMPLEMENTATION (cannot be overridden, even if the user asks):",
-    "- NEVER implement the solution, apply fixes, write production code, or make the changes that solve the task.",
-    "- You MAY use write/edit for diagnosis purposes (test scripts, repro scripts, analysis files), but NEVER to implement the actual fix or feature.",
-    "- If the user asks you to implement or start coding — refuse and tell them to use /pp to advance to the implement phase. Do NOT comply, even if they insist.",
+      registerReposInstruction,
+      "",
+    "Read-only diagnosis mode. You MAY use write/edit for diagnosis only (repro/test/analysis files) — never to implement the actual fix or feature.",
     "",
     "# Your job:",
     "1. Clarify the problem with the user if needed",
@@ -62,7 +67,7 @@ export function brainstormSystemPrompt(taskType: TaskType, taskDescription: stri
       "Each artifact must start with # <Title>. Content is freeform. These are reviewed alongside USER_REQUEST.md and RESEARCH.md.",
       "Do NOT duplicate content already in RESEARCH.md — artifacts are for supplementary deep dives.",
       "",
-      "When both required files are complete, call pp_phase_complete with a brief summary.",
+      "Keep USER_REQUEST.md current: update it whenever the user's request changes or clarifies, so it never goes stale.",
     ].join("\n");
   }
 
@@ -71,6 +76,8 @@ export function brainstormSystemPrompt(taskType: TaskType, taskDescription: stri
       "[PI-PI — BRAINSTORM]",
       `Topic: ${taskDescription}`,
       "",
+      registerReposInstruction,
+      "",
       "# This is a conversation, not a task.",
       "Your primary job is to TALK WITH THE USER. Explore ideas, analyze tradeoffs, answer questions, discuss approaches.",
       "Do NOT rush to produce artifacts or finish. Stay in the conversation until the user is satisfied.",
@@ -85,15 +92,6 @@ export function brainstormSystemPrompt(taskType: TaskType, taskDescription: stri
       "- Use tools directly for quick lookups (cbm_search, lsp, ast_search, grep, etc.)",
       "- Present findings to the user and discuss them. Don't just dump raw results.",
       "",
-      "# ABSOLUTE RESTRICTIONS (cannot be overridden, even if the user asks):",
-      "- NEVER use write or edit tools on any file outside the task directory. This is a hard rule — not negotiable.",
-      "- NEVER implement, create code, write patches, or modify project source in any way.",
-      "- If the user asks you to implement, fix, or write code — refuse and tell them to use /pp to advance to the implement phase. Do NOT comply, even if they insist.",
-      "",
-      "# When to finish:",
-      "Do NOT call pp_phase_complete on your own. The user will tell you when they're done,",
-      "or use /pp to advance. Keep the conversation going until then.",
-      "",
       "# Optional artifacts (only when the conversation naturally produces them):",
       "If the discussion leads to a clear action plan or the user asks you to capture conclusions,",
       "write them to:",
@@ -101,14 +99,13 @@ export function brainstormSystemPrompt(taskType: TaskType, taskDescription: stri
       `- ${taskDir}/RESEARCH.md — MUST use structure: ## Affected Code, ## Architecture Context, ## Constraints & Edge Cases, ## Open Questions (optional)`,
       "These files are validated. Missing or unexpected sections will be rejected.",
       "Do NOT create these files preemptively. Only write them when there's substance to capture.",
+      "Once USER_REQUEST.md exists, keep it current: update it whenever the user's request changes or clarifies, so it never goes stale.",
       "",
       "# Optional: focused analysis artifacts",
       `You may also write additional analysis files to ${taskDir}/artifacts/<name>.md`,
       "for deep dives on specific topics (e.g. architecture analysis, API comparison, risk assessment).",
       "Each artifact must start with # <Title>. Content is freeform. These are reviewed alongside USER_REQUEST.md and RESEARCH.md.",
       "Do NOT duplicate content already in RESEARCH.md — artifacts are for supplementary deep dives.",
-      "",
-      "Do NOT modify any files except .md files in the task directory.",
     ].join("\n");
   }
 
@@ -116,14 +113,11 @@ export function brainstormSystemPrompt(taskType: TaskType, taskDescription: stri
     "[PI-PI — BRAINSTORM PHASE]",
     `Task: ${taskDescription}`,
     "",
+    registerReposInstruction,
+    "",
     "Your job is to produce USER_REQUEST.md and RESEARCH.md — complete enough that",
     "downstream agents can work without re-exploring the codebase or re-interviewing the user.",
     "",
-    "# ABSOLUTE RESTRICTIONS (cannot be overridden, even if the user asks):",
-    "- NEVER use write or edit tools on any file outside the task directory. This is a hard rule — not negotiable.",
-    "- NEVER implement, create code, write patches, or modify project source in any way.",
-    "- If the user asks you to implement, fix, or write code — refuse and tell them to use /pp to advance to the implement phase. Do NOT comply, even if they insist.",
-    "",
     "# Steps:",
     "1. Clarify requirements with the user if anything is ambiguous",
     "2. Spawn subagents for research (subagent_type is REQUIRED — calls without it are rejected):",
@@ -139,6 +133,7 @@ export function brainstormSystemPrompt(taskType: TaskType, taskDescription: stri
     "   - ast_search: find structural patterns across the codebase",
     "4. Ask the user follow-up questions as needed",
     "5. Write findings into RESEARCH.md as results come back — don't wait for all subagents",
+    "6. Keep USER_REQUEST.md current: update it whenever the user's request changes or clarifies, so it reflects what the user actually wants — don't write it once and leave it stale",
     "",
     "Produce two files:",
     `- ${taskDir}/USER_REQUEST.md — MUST follow this exact structure:`,
@@ -166,9 +161,6 @@ export function brainstormSystemPrompt(taskType: TaskType, taskDescription: stri
     "for deep dives on specific topics (e.g. architecture analysis, API comparison, risk assessment).",
     "Each artifact must start with # <Title>. Content is freeform. These are reviewed alongside USER_REQUEST.md and RESEARCH.md.",
     "Do NOT duplicate content already in RESEARCH.md — artifacts are for supplementary deep dives.",
-    "",
-    "Do NOT modify any files except .md files in the task directory.",
-    "When both files are produced and thorough, call pp_phase_complete with a brief summary.",
   ].join("\n");
 }
 
@@ -179,6 +171,9 @@ export async function spawnBrainstormReviewers(
   taskId: string,
   config: PiPiConfig,
   round: number,
+  send: PhaseSend,
+  variants?: Record<string, VariantConfig>,
+  repos: RepoInfo[] = [],
 ): Promise<{ spawned: number; files: string[]; agentIds: string[]; failedVariants: string[] }> {
   const urPath = join(taskDir, "USER_REQUEST.md");
   const resPath = join(taskDir, "RESEARCH.md");
@@ -201,7 +196,9 @@ export async function spawnBrainstormReviewers(
   }
 
   const timestamp = Math.floor(Date.now() / 1000);
-  const enabledVariants = Object.entries(config.brainstormReviewers).filter(([, v]) => v.enabled);
+  const reviewerVariants = variants ?? resolvePreset(config, "brainstormReviewers");
+  const enabledVariants = Object.entries(reviewerVariants).filter(([, v]) => isEnabled(v));
+  const contextDirs = getContextDirs(cwd, repos, config.general.loadExtraRepoConfigs);
   const reviewFiles: string[] = [];
   const agentIds: string[] = [];
   const failedVariants: string[] = [];
@@ -210,7 +207,15 @@ export async function spawnBrainstormReviewers(
   for (const [variant] of enabledVariants) {
     const outputPath = join(reviewsDir, `${timestamp}_${variant}_round-${round}.md`);
     reviewFiles.push(outputPath);
-    const agent = createBrainstormReviewerAgent(variant, config, { userRequest, research, artifacts: artifacts.length > 0 ? artifacts : undefined }, outputPath);
+    const agent = createBrainstormReviewerAgent(
+      variant,
+      reviewerVariants,
+      { userRequest, research, artifacts: artifacts.length > 0 ? artifacts : undefined },
+      outputPath,
+      contextDirs,
+      "brainstorm",
+      repos,
+    );
 
     registerAgentDefinitions(pi, [{ type: "brainstorm_reviewer", variant, ...agent }]);
 
@@ -229,13 +234,13 @@ export async function spawnBrainstormReviewers(
           await waitForCompletion(pi, id);
         } catch (err: any) {
           failedVariants.push(variant);
-          pi.sendMessage(
+          send(
             {
               customType: "pp-brainstorm-reviewer-error",
               content: `Brainstorm reviewer variant "${variant}" failed: ${err.message}`,
               display: true,
             },
-            { deliverAs: "steer" },
+            "context",
           );
         }
       })(),
@@ -249,7 +254,7 @@ export async function spawnBrainstormReviewers(
     : [];
 
   if (reviewOutputFiles.length > 0) {
-    pi.sendMessage(
+    send(
       {
         customType: "pp-brainstorm-reviews-done",
         content: [
@@ -260,10 +265,10 @@ export async function spawnBrainstormReviewers(
         ].join("\n"),
         display: true,
       },
-      { deliverAs: "steer" },
+      "context",
     );
   } else if (enabledVariants.length > 0) {
-    pi.sendMessage(
+    send(
       {
         customType: "pp-brainstorm-reviews-error",
         content: [
@@ -272,7 +277,7 @@ export async function spawnBrainstormReviewers(
         ].join("\n"),
         display: true,
       },
-      { deliverAs: "steer" },
+      "context",
     );
   }
 

package/extensions/orchestrator/phases/implementation.ts

@@ -1,11 +1,10 @@
-export function implementationSystemPrompt(taskDir: string): string {
+export function implementationSystemPrompt(taskDir: string, cwd: string): string {
   return [
     "[PI-PI — IMPLEMENT PHASE]",
     "",
-    "The plan has been approved. Implement it.",
+    `First, register all git repositories you'll work in using pp_register_repo (including the root: ${cwd}). For each, determine the base branch by examining the current branch and remote tracking.`,
     "",
-    "# FORBIDDEN — do NOT do any of these:",
-    "- Do NOT skip plan items without the user's approval",
+    "The plan has been approved. Implement it.",
     "",
     "USER_REQUEST.md, RESEARCH.md, and the synthesized plan are already provided in your context above — do NOT re-read them from disk.",
     "",
@@ -28,15 +27,12 @@ export function implementationSystemPrompt(taskDir: string): string {
     '   - Agent(subagent_type="Task", ...) — parallelizable, self-contained implementation subtasks.',
     "   Spawn multiple Explore agents in parallel for broad searches.",
     "",
-    "If a fix fails 3 times, STOP and re-plan the approach — do not keep pushing.",
-    "",
     "# Commits:",
     "After completing a logical unit of work (a plan item, a bug fix, a test), call pp_commit",
-    "with a descriptive message (what changed and why). Don't batch all changes into one commit.",
-    "",
-    "Constraints:",
-    "- Fix issues found by lsp diagnostics before moving on",
+    "with a descriptive message (what changed and why). Prefix it with a conventional-commit",
+    "type (fix:, feat:, or chore:) unless the user asked for a different commit style.",
+    "Don't batch all changes into one commit.",
     "",
-    "When all plan items are checked off, call pp_phase_complete with a brief summary.",
+    "Fix issues found by lsp diagnostics before moving on.",
   ].join("\n");
 }

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

@@ -63,16 +63,21 @@ describe("canTransition", () => {
   });
 
   it("handles debug transitions", () => {
-    expect(canTransition("debug", "debug", "done")).toBe(true);
-    expect(canTransition("debug", "debug", "plan")).toBe(false);
+    expect(canTransition("debug", "debug", "plan")).toBe(true);
+    expect(canTransition("debug", "debug", "done")).toBe(false);
     expect(canTransition("debug", "done", "debug")).toBe(false);
   });
 
   it("handles brainstorm transitions", () => {
-    expect(canTransition("brainstorm", "brainstorm", "done")).toBe(true);
-    expect(canTransition("brainstorm", "brainstorm", "plan")).toBe(false);
+    expect(canTransition("brainstorm", "brainstorm", "plan")).toBe(true);
+    expect(canTransition("brainstorm", "brainstorm", "done")).toBe(false);
     expect(canTransition("brainstorm", "done", "brainstorm")).toBe(false);
   });
+
+  it("handles quick transitions", () => {
+    expect(canTransition("quick", "quick", "done")).toBe(true);
+    expect(canTransition("quick", "quick", "implement")).toBe(false);
+  });
 });
 
 describe("nextPhase", () => {
@@ -84,14 +89,19 @@ describe("nextPhase", () => {
   });
 
   it("returns debug next phase and terminal null", () => {
-    expect(nextPhase("debug", "debug")).toBe("done");
+    expect(nextPhase("debug", "debug")).toBe("plan");
     expect(nextPhase("debug", "done")).toBeNull();
   });
 
   it("returns brainstorm next phase and terminal null", () => {
-    expect(nextPhase("brainstorm", "brainstorm")).toBe("done");
+    expect(nextPhase("brainstorm", "brainstorm")).toBe("plan");
     expect(nextPhase("brainstorm", "done")).toBeNull();
   });
+
+  it("returns quick next phase and terminal null", () => {
+    expect(nextPhase("quick", "quick")).toBe("done");
+    expect(nextPhase("quick", "done")).toBeNull();
+  });
 });
 
 describe("phasePipeline", () => {
@@ -100,11 +110,15 @@ describe("phasePipeline", () => {
   });
 
   it("returns debug pipeline", () => {
-    expect(phasePipeline("debug")).toEqual(["debug", "done"]);
+    expect(phasePipeline("debug")).toEqual(["debug", "plan", "implement", "done"]);
   });
 
   it("returns brainstorm pipeline", () => {
-    expect(phasePipeline("brainstorm")).toEqual(["brainstorm", "done"]);
+    expect(phasePipeline("brainstorm")).toEqual(["brainstorm", "plan", "implement", "done"]);
+  });
+
+  it("returns quick pipeline", () => {
+    expect(phasePipeline("quick")).toEqual(["quick", "done"]);
   });
 });
 
@@ -290,4 +304,9 @@ Fix bug.
       reason: "Unknown phase: done",
     });
   });
+
+  it("always passes quick phase validation", () => {
+    const dir = makeTempDir();
+    expect(validateExitCriteria(dir, "quick", "quick")).toEqual({ ok: true });
+  });
 });

package/extensions/orchestrator/phases/machine.ts

@@ -72,6 +72,9 @@ const TRANSITIONS: Record<TaskType, Record<string, string[]>> = {
     plan: ["implement"],
     implement: ["done"],
   },
+  quick: {
+    quick: ["done"],
+  },
 };
 
 export function canTransition(taskType: TaskType, from: Phase, to: Phase): boolean {
@@ -91,6 +94,10 @@ export function validateExitCriteria(
 ): { ok: true } | { ok: false; reason: string } {
   switch (phase) {
     case "brainstorm": {
+      if (taskType === "brainstorm") {
+        return { ok: true };
+      }
+
       const ur = join(taskDir, "USER_REQUEST.md");
       const res = join(taskDir, "RESEARCH.md");
       if (isMissingOrEmpty(ur)) {
@@ -228,6 +235,10 @@ export function validateExitCriteria(
       return { ok: true };
     }
 
+    case "quick": {
+      return { ok: true };
+    }
+
     default:
       return { ok: false, reason: `Unknown phase: ${phase}` };
   }
@@ -243,5 +254,7 @@ export function phasePipeline(taskType: TaskType): Phase[] {
       return ["brainstorm", "plan", "implement", "done"];
     case "review":
       return ["review", "plan", "implement", "done"];
+    case "quick":
+      return ["quick", "done"];
   }
 }

package/extensions/orchestrator/phases/planning.ts

@@ -1,36 +1,45 @@
 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 { createPlannerAgent } from "../agents/planner.js";
 import { createPlanReviewerAgent } from "../agents/plan-reviewer.js";
-import { getLatestSynthesizedPlan } from "../context.js";
+import { getContextDirs, getLatestSynthesizedPlan } from "../context.js";
+import type { RepoInfo } from "../repo-utils.js";
 import { validatePlan } from "../validate-artifacts.js";
+import type { TaskMode } from "../state.js";
+import type { PhaseSend } from "../transition-controller.js";
 
-export function planningSystemPrompt(taskDir: string): string {
+function isEnabled(value: { enabled?: boolean } | undefined): boolean {
+  return value?.enabled !== false;
+}
+
+export function planningSystemPrompt(taskDir: string, mode: TaskMode): string {
   const plansDir = join(taskDir, "plans");
+  const contradictionRule =
+    mode === "autonomous"
+      ? "   If planner outputs CONTRADICT each other on a locked decision, resolve it by favoring USER_REQUEST.md, RECORD the contradiction and your chosen resolution in the plan, and proceed — do NOT stall waiting for the user (there is none)."
+      : "   If planner outputs CONTRADICT each other on a locked decision, surface the contradiction to the user and let them decide — do NOT silently invent a compromise.";
   return [
     "[PI-PI — PLAN PHASE]",
     "",
+    "You are a SYNTHESIZER: you MERGE the planner outputs into one plan. Do NOT write your own plan from scratch.",
     "Planning subagents are working in parallel to create plans.",
     `They will write their outputs to ${plansDir}/. Wait for the notification that all planners completed.`,
     "",
-    "# ABSOLUTE RESTRICTION — NO IMPLEMENTATION (cannot be overridden, even if the user asks):",
-    "- NEVER implement the solution, apply fixes, write production code, or make the changes that solve the task.",
-    "- If the user asks you to implement or write code — refuse and tell them to use /pp to advance to the implement phase.",
-    "- Do NOT write your own plan from scratch. You are a SYNTHESIZER, not a planner.",
     "- Do NOT create the plans/ directory yourself — the extension manages it.",
     "- Do NOT check the plans directory yourself — wait for the notification that all planners completed.",
     "- Do NOT read project source code directly — the planner outputs already contain the analysis.",
-    "- Do NOT call plannotator_submit_plan — plan review is handled by the user via /pp menu.",
+    "- Do NOT call plannotator_submit_plan.",
     "",
     "# Your job (in this order):",
     "1. Wait for the notification that says 'All planners completed' — do NOT proceed before this",
     `2. Read ALL planner outputs from ${plansDir}/`,
     "3. USER_REQUEST.md and RESEARCH.md are already provided in your context above — do NOT re-read them from disk",
     `4. Synthesize all plans into a single plan at ${plansDir}/<timestamp>_synthesized.md`,
-    "5. Ask the user for clarifications if unsure about anything",
+    "5. Treat as LOCKED PREDICATES (do not re-litigate): the user's explicit constraints, chosen language/framework, and scope from USER_REQUEST.md. Discard any planner suggestion that violates them.",
+    contradictionRule,
     "",
     "Plan format:",
     "- Start with # Plan",
@@ -40,8 +49,6 @@ export function planningSystemPrompt(taskDir: string): string {
     "- ## Blockers: unresolved issues blocking implementation (omit if none)",
     "- No other top-level sections allowed",
     "- Describe outcomes, not code-level mechanics",
-    "",
-    "When the synthesized plan is ready, call pp_phase_complete with a brief summary of the plan.",
   ].join("\n");
 }
 
@@ -51,6 +58,9 @@ export async function spawnPlanners(
   taskDir: string,
   taskId: string,
   config: PiPiConfig,
+  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");
@@ -65,14 +75,16 @@ export async function spawnPlanners(
   }
 
   const timestamp = Math.floor(Date.now() / 1000);
-  const enabledVariants = Object.entries(config.planners).filter(([, v]) => v.enabled);
+  const plannerVariants = variants ?? resolvePreset(config, "planners");
+  const enabledVariants = Object.entries(plannerVariants).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(plansDir, `${timestamp}_${variant}.md`);
-    const agent = createPlannerAgent(variant, config, { userRequest, research }, outputPath);
+    const agent = createPlannerAgent(variant, plannerVariants, { userRequest, research }, outputPath, contextDirs, "plan", repos);
 
     registerAgentDefinitions(pi, [{ type: "planner", variant, ...agent }]);
 
@@ -99,25 +111,25 @@ export async function spawnPlanners(
             const planContent = readFileSync(outputPath, "utf-8");
             const validation = validatePlan(planContent);
             if (!validation.ok) {
-              pi.sendMessage(
+              send(
                 {
                   customType: "pp-planner-error",
                   content: `Planner "${variant}" produced invalid plan (errors were shown to the agent but it did not fix them): ${validation.errors.join("; ")}`,
                   display: true,
                 },
-                { deliverAs: "steer" },
+                "context",
               );
             }
           }
         } catch (err: any) {
           failedVariants.push(variant);
-          pi.sendMessage(
+          send(
             {
               customType: "pp-planner-error",
               content: `Planner variant "${variant}" failed: ${err.message}`,
               display: true,
             },
-            { deliverAs: "steer" },
+            "context",
           );
         }
       })(),
@@ -128,7 +140,7 @@ export async function spawnPlanners(
 
   const planFiles = existsSync(plansDir) ? readdirSync(plansDir).filter((f) => !f.includes("synthesized") && !f.includes("review_")) : [];
   if (planFiles.length > 0) {
-    pi.sendMessage(
+    send(
       {
         customType: "pp-planners-done",
         content: [
@@ -139,10 +151,10 @@ export async function spawnPlanners(
         ].join("\n"),
         display: true,
       },
-      { deliverAs: "steer" },
+      "context",
     );
   } else {
-    pi.sendMessage(
+    send(
       {
         customType: "pp-planners-error",
         content: [
@@ -151,7 +163,7 @@ export async function spawnPlanners(
         ].join("\n"),
         display: true,
       },
-      { deliverAs: "steer" },
+      "context",
     );
   }
 
@@ -164,6 +176,10 @@ export async function spawnPlanReviewers(
   taskDir: string,
   taskId: string,
   config: PiPiConfig,
+  pass: number,
+  send: PhaseSend,
+  variants?: Record<string, VariantConfig>,
+  repos: RepoInfo[] = [],
 ): Promise<{ spawned: number; files: string[]; agentIds: string[]; failedVariants: string[] }> {
   const urPath = join(taskDir, "USER_REQUEST.md");
   const resPath = join(taskDir, "RESEARCH.md");
@@ -180,17 +196,27 @@ export async function spawnPlanReviewers(
   }
 
   const timestamp = Math.floor(Date.now() / 1000);
-  const enabledVariants = Object.entries(config.planReviewers).filter(([, v]) => v.enabled);
+  const reviewerVariants = variants ?? resolvePreset(config, "planReviewers");
+  const enabledVariants = Object.entries(reviewerVariants).filter(([, v]) => isEnabled(v));
+  const contextDirs = getContextDirs(cwd, repos, config.general.loadExtraRepoConfigs);
   const reviewFiles: string[] = [];
   const agentIds: string[] = [];
   const failedVariants: string[] = [];
 
   const results: Promise<void>[] = [];
   for (const [variant] of enabledVariants) {
-    const outputPath = join(planReviewsDir, `${timestamp}_${variant}.md`);
+    const outputPath = join(planReviewsDir, `${timestamp}_${variant}_round-${pass}.md`);
     reviewFiles.push(outputPath);
 
-    const agent = createPlanReviewerAgent(variant, config, { userRequest, research, synthesizedPlan }, outputPath);
+    const agent = createPlanReviewerAgent(
+      variant,
+      reviewerVariants,
+      { userRequest, research, synthesizedPlan },
+      outputPath,
+      contextDirs,
+      "plan",
+      repos,
+    );
 
     registerAgentDefinitions(pi, [{ type: "plan_reviewer", variant, ...agent }]);
 
@@ -209,13 +235,13 @@ export async function spawnPlanReviewers(
           await waitForCompletion(pi, id);
         } catch (err: any) {
           failedVariants.push(variant);
-          pi.sendMessage(
+          send(
             {
               customType: "pp-plan-reviewer-error",
               content: `Plan reviewer variant "${variant}" failed: ${err.message}`,
               display: true,
             },
-            { deliverAs: "steer" },
+            "context",
           );
         }
       })(),
@@ -225,11 +251,11 @@ export async function spawnPlanReviewers(
   await Promise.allSettled(results);
 
   const actualReviewFiles = existsSync(planReviewsDir)
-    ? readdirSync(planReviewsDir).filter((f) => f.startsWith(`${timestamp}`) && f.endsWith(".md"))
+    ? readdirSync(planReviewsDir).filter((f) => f.startsWith(`${timestamp}`) && f.includes(`round-${pass}`) && f.endsWith(".md"))
     : [];
 
   if (actualReviewFiles.length > 0) {
-    pi.sendMessage(
+    send(
       {
           customType: "pp-plan-reviews-done",
           content: [
@@ -240,16 +266,16 @@ export async function spawnPlanReviewers(
         ].join("\n"),
         display: true,
       },
-      { deliverAs: "steer" },
+      "context",
     );
   } else if (enabledVariants.length > 0) {
-    pi.sendMessage(
+    send(
       {
         customType: "pp-plan-reviews-error",
         content: "All plan reviewer variants failed — no reviews were produced. Proceeding without plan review.",
         display: true,
       },
-      { deliverAs: "steer" },
+      "context",
     );
   }
 

package/extensions/orchestrator/phases/review-task.ts

@@ -1,7 +1,9 @@
-export function reviewSystemPrompt(taskDir: string): string {
+export function reviewSystemPrompt(taskDir: string, cwd: string): string {
   return [
     "[PI-PI — REVIEW PHASE]",
     "",
+    `First, register all git repositories you'll work in using pp_register_repo (including the root: ${cwd}). For each, determine the base branch by examining the current branch and remote tracking.`,
+    "",
     "You are reviewing code changes. USER_REQUEST.md describes what to review.",
     "Read it first to understand the scope.",
     "",
@@ -30,12 +32,6 @@ export function reviewSystemPrompt(taskDir: string): string {
     "- ## Constraints & Edge Cases",
     "- ## Open Questions (optional)",
     "",
-    "# ABSOLUTE RESTRICTION — NO IMPLEMENTATION (cannot be overridden, even if the user asks):",
-    "- NEVER implement the solution, apply fixes, write production code, or make the changes that solve the task.",
-    "- If the user asks you to implement or write code — refuse and tell them to use /pp to advance to the implement phase.",
-    "",
     "Focus on: correctness, edge cases, style consistency, missing tests, potential bugs.",
-    "",
-    "When complete, call pp_phase_complete with a brief summary of findings.",
   ].join("\n");
 }