@ilya-lesikov/pi-pi 0.1.0 → 0.2.0

package/extensions/orchestrator/event-handlers.ts

@@ -24,9 +24,13 @@ import { spawnCodeReviewers } from "./phases/review.js";
 import { spawnBrainstormReviewers } from "./phases/brainstorm.js";
 import { openPlannotator, waitForPlannotatorResult, cancelPendingPlannotatorWait } from "./plannotator.js";
 import { Orchestrator, deepReviewConfig, type ActiveTask } from "./orchestrator.js";
+import { createCustomFooter, setFooterContext, setFooterTracker } from "./custom-footer.js";
+import { createUsageTracker, dumpUsageSummary, loadUsageSummary, type UsageTracker } from "./usage-tracker.js";
 import { askUser } from "../../3p/pi-ask-user/index.js";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
+const USAGE_TRACKER_KEY = Symbol.for("pi-pi:usage-tracker");
+
 export async function detectDefaultBranch(pi: ExtensionAPI, cwd: string, config?: { diffBaseBranch?: string }): Promise<string> {
   if (config?.diffBaseBranch) return config.diffBaseBranch;
   try {
@@ -46,17 +50,6 @@ export async function detectDefaultBranch(pi: ExtensionAPI, cwd: string, config?
   return "main";
 }
 
-export async function detectRepoCwd(pi: ExtensionAPI, modifiedFiles: Set<string>, fallbackCwd: string): Promise<string> {
-  if (modifiedFiles.size === 0) return fallbackCwd;
-  const firstFile = [...modifiedFiles][0];
-  const dir = resolve(firstFile, "..");
-  try {
-    const result = await pi.exec("git", ["rev-parse", "--show-toplevel"], { cwd: dir, timeout: 5000 });
-    if (result.code === 0 && result.stdout.trim()) return result.stdout.trim();
-  } catch {}
-  return fallbackCwd;
-}
-
 export async function selectOption(ctx: any, question: string, options: string[]): Promise<string | undefined> {
   const result = await askUser(ctx, {
     question,
@@ -69,12 +62,6 @@ export async function selectOption(ctx: any, question: string, options: string[]
   return result.selections[0];
 }
 
-function setStep(orchestrator: Orchestrator, step: string): void {
-  if (!orchestrator.active) return;
-  orchestrator.active.state.step = step;
-  saveTask(orchestrator.active.dir, orchestrator.active.state);
-}
-
 function tryCompleteReviewCycle(orchestrator: Orchestrator): void {
   if (
     !orchestrator.active?.state.reviewCycle ||
@@ -214,13 +201,13 @@ export async function enterReviewCycle(orchestrator: Orchestrator, ctx: any, kin
   return `Started review cycle pass ${pass} (${kind}). Awaiting reviewers.`;
 }
 
-export function stopTask(orchestrator: Orchestrator): string {
+export async function stopTask(orchestrator: Orchestrator): Promise<string> {
   if (!orchestrator.active) return "No active task.";
   orchestrator.abortAllSubagents();
   orchestrator.active.state.phase = "done";
   saveTask(orchestrator.active.dir, orchestrator.active.state);
   const desc = orchestrator.active.description;
-  orchestrator.cleanupActive();
+  await orchestrator.cleanupActive();
   const taskStore = (globalThis as any)[Symbol.for("pi-tasks:store")];
   taskStore?.clearAll?.();
   return `Task "${desc}" stopped.`;
@@ -238,128 +225,6 @@ export function finalizeReviewCycle(task: ActiveTask): void {
   saveTask(task.dir, task.state);
 }
 
-export async function runUserGateDialog(orchestrator: Orchestrator, ctx: any, summary: string): Promise<string> {
-  if (!orchestrator.active) return "No active task.";
-  if (orchestrator.userGatePending) return "A user-gate dialog is already in progress.";
-  orchestrator.userGatePending = true;
-
-  try {
-    return await runUserGateDialogInner(orchestrator, ctx, summary);
-  } finally {
-    orchestrator.userGatePending = false;
-  }
-}
-
-async function runUserGateDialogInner(orchestrator: Orchestrator, ctx: any, summary: string): Promise<string> {
-  if (!orchestrator.active) return "No active task.";
-  const pi = orchestrator.pi;
-  const phase = orchestrator.active.state.phase;
-  const task = orchestrator.active;
-
-  if (orchestrator.spawnedAgentIds.size > 0 || orchestrator.pendingSubagentSpawns > 0) {
-    const count = orchestrator.spawnedAgentIds.size + orchestrator.pendingSubagentSpawns;
-    return `${count} subagent(s) still running or spawning.`;
-  }
-
-    const byKind = task.state.reviewPassByKind ?? {};
-    const autoCount = byKind["auto"] ?? 0;
-    const deepCount = byKind["auto-deep"] ?? 0;
-    const autoLabel = autoCount > 0 ? `Review (pass ${autoCount + 1})` : "Review";
-    const deepLabel = deepCount > 0 ? `Deep review (pass ${deepCount + 1})` : "Deep review";
-
-  const continueMessage = "User wants to continue. Run /pp when ready to advance.";
-
-  if (phase === "brainstorm" && task.type === "implement") {
-    const choice = await selectOption(ctx, summary, ["Approve brainstorm", autoLabel, deepLabel, "Continue brainstorming", "Stop task"]);
-    finalizeReviewCycle(task);
-    if (choice === "Approve brainstorm") {
-      const result = await orchestrator.transitionToNextPhase(ctx);
-      return result.ok ? "Brainstorm approved. Transitioned to plan." : `Transition blocked: ${result.error}`;
-    }
-    if (choice === autoLabel) return enterReviewCycle(orchestrator, ctx, "auto");
-    if (choice === deepLabel) return enterReviewCycle(orchestrator, ctx, "auto-deep");
-    if (choice === "Stop task") return stopTask(orchestrator);
-    setStep(orchestrator, "llm_work");
-    return continueMessage;
-  }
-
-  if (phase === "brainstorm" && task.type === "brainstorm") {
-    const choice = await selectOption(ctx, summary, ["Approve brainstorm", autoLabel, deepLabel, "Continue brainstorming", "Finish brainstorming", "Stop task"]);
-    finalizeReviewCycle(task);
-    if (choice === "Approve brainstorm") {
-      const result = await orchestrator.transitionToNextPhase(ctx);
-      return result.ok ? "Brainstorm approved. Transitioned to plan." : `Transition blocked: ${result.error}`;
-    }
-    if (choice === autoLabel) return enterReviewCycle(orchestrator, ctx, "auto");
-    if (choice === deepLabel) return enterReviewCycle(orchestrator, ctx, "auto-deep");
-    if (choice === "Finish brainstorming" || choice === "Stop task") return stopTask(orchestrator);
-    setStep(orchestrator, "llm_work");
-    return continueMessage;
-  }
-
-  if (phase === "debug") {
-    const choice = await selectOption(ctx, summary, ["Approve debug", autoLabel, deepLabel, "Continue debugging", "Finish debugging", "Stop task"]);
-    finalizeReviewCycle(task);
-    if (choice === "Approve debug") {
-      const result = await orchestrator.transitionToNextPhase(ctx);
-      return result.ok ? "Debug approved. Transitioned to plan." : `Transition blocked: ${result.error}`;
-    }
-    if (choice === autoLabel) return enterReviewCycle(orchestrator, ctx, "auto");
-    if (choice === deepLabel) return enterReviewCycle(orchestrator, ctx, "auto-deep");
-    if (choice === "Finish debugging" || choice === "Stop task") return stopTask(orchestrator);
-    setStep(orchestrator, "llm_work");
-    return continueMessage;
-  }
-
-  if (phase === "plan") {
-    const choice = await selectOption(ctx, summary, [
-      "Approve plan",
-      autoLabel,
-      deepLabel,
-      "Review in Plannotator",
-      "Review on my own",
-      "Continue planning",
-      "Stop task",
-    ]);
-    finalizeReviewCycle(task);
-    if (choice === "Approve plan") {
-      const result = await orchestrator.transitionToNextPhase(ctx);
-      return result.ok ? "Plan approved. Transitioned to implement." : `Transition blocked: ${result.error}`;
-    }
-    if (choice === autoLabel) return enterReviewCycle(orchestrator, ctx, "auto");
-    if (choice === deepLabel) return enterReviewCycle(orchestrator, ctx, "auto-deep");
-    if (choice === "Review in Plannotator") return enterReviewCycle(orchestrator, ctx, "plannotator");
-    if (choice === "Stop task") return stopTask(orchestrator);
-    setStep(orchestrator, "synthesize");
-    return continueMessage;
-  }
-
-  if (phase === "implement") {
-    const choice = await selectOption(ctx, summary, [
-      "Approve implementation",
-      autoLabel,
-      deepLabel,
-      "Review in Plannotator",
-      "Review on my own",
-      "Continue implementation",
-      "Stop task",
-    ]);
-    finalizeReviewCycle(task);
-    if (choice === "Approve implementation") {
-      const result = await orchestrator.transitionToNextPhase(ctx);
-      return result.ok ? "Implementation approved. Task completed." : `Transition blocked: ${result.error}`;
-    }
-    if (choice === autoLabel) return enterReviewCycle(orchestrator, ctx, "auto");
-    if (choice === deepLabel) return enterReviewCycle(orchestrator, ctx, "auto-deep");
-    if (choice === "Review in Plannotator") return enterReviewCycle(orchestrator, ctx, "plannotator");
-    if (choice === "Stop task") return stopTask(orchestrator);
-    setStep(orchestrator, "llm_work");
-    return continueMessage;
-  }
-
-  return "No dialog available for this phase.";
-}
-
 function registerOrchestratorTools(orchestrator: Orchestrator): void {
   registerPhaseCompleteTool(orchestrator);
   registerCommitTool(orchestrator);
@@ -441,8 +306,15 @@ function registerSpecifyReviewsTool(orchestrator: Orchestrator): void {
 
       ctx.ui?.setWorkingMessage?.("Waiting for user input…");
       try {
-        const gateResult = await runUserGateDialog(orchestrator, ctx, `Plannotator review complete.\n\n${summary}`);
-        return { content: [{ type: "text" as const, text: gateResult }], details: {} };
+        const { showActiveTaskMenu } = await import("./pp-menu.js");
+        const text = await showActiveTaskMenu(orchestrator, ctx, `Plannotator review complete.\n\n${summary}`, "tool");
+        if (orchestrator.phaseCompactionPending || orchestrator.taskDoneCompactionPending) {
+          return { content: [{ type: "text" as const, text: "Phase transition in progress." }], details: {} };
+        }
+        if (!text) {
+          return { content: [{ type: "text" as const, text: "No action selected." }], details: {} };
+        }
+        return { content: [{ type: "text" as const, text }], details: {} };
       } finally {
         ctx.ui?.setWorkingMessage?.();
       }
@@ -539,6 +411,10 @@ function registerPhaseCompleteTool(orchestrator: Orchestrator): void {
 export function registerEventHandlers(orchestrator: Orchestrator): void {
   const pi = orchestrator.pi;
 
+  function getUsageTracker(): UsageTracker | undefined {
+    return (globalThis as any)[USAGE_TRACKER_KEY] as UsageTracker | undefined;
+  }
+
   function trackSubagentEvent(data: any, event: "created" | "started" | "first_tool" | "first_turn" | "completed" | "failed"): void {
     if (!orchestrator.active || !data?.id) return;
     const now = Date.now();
@@ -709,7 +585,7 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
           }
 
           if (choice === "Stop task") {
-            pi.sendUserMessage(`[PI-PI] ${stopTask(orchestrator)}`, { deliverAs: "followUp" });
+            pi.sendUserMessage(`[PI-PI] ${await stopTask(orchestrator)}`, { deliverAs: "followUp" });
             return;
           }
 
@@ -821,7 +697,7 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
           }
 
           if (choice === "Stop task") {
-            pi.sendUserMessage(`[PI-PI] ${stopTask(orchestrator)}`, { deliverAs: "followUp" });
+            pi.sendUserMessage(`[PI-PI] ${await stopTask(orchestrator)}`, { deliverAs: "followUp" });
             return;
           }
 
@@ -848,6 +724,17 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
   }
 
   pi.events.on("subagents:completed", (data: any) => {
+    const usageTracker = getUsageTracker();
+    if (usageTracker && data?.tokens) {
+      usageTracker.recordSubagentCompletion(data.tokens, undefined, {
+        description: data.description || data.type || data.id || "unknown",
+        modelId: data.modelId || "unknown",
+        durationMs: data.durationMs,
+        toolUses: data.toolUses,
+      });
+      (orchestrator.lastCtx?.ui as any)?.requestRender?.();
+    }
+
     if (!orchestrator.active || !data?.id) return;
     trackSubagentEvent(data, "completed");
     orchestrator.spawnedAgentIds.delete(data.id);
@@ -916,10 +803,36 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
     await orchestrator.cleanupActive();
   });
 
+  pi.on("session_shutdown", async (_event, ctx) => {
+    if ((globalThis as any)[SUBAGENT_SESSION_KEY]) return;
+    const tracker = getUsageTracker();
+    if (!tracker) return;
+    const sessionId = ctx.sessionManager?.getSessionId?.() || `session-${Date.now()}`;
+    try {
+      dumpUsageSummary(tracker, sessionId);
+    } catch (err: any) {
+      console.error(`[pi-pi] Failed to dump usage summary: ${err.message}`);
+    }
+    delete (globalThis as any)[USAGE_TRACKER_KEY];
+  });
+
   pi.on("session_start", async (_event, ctx) => {
     orchestrator.lastCtx = ctx;
     orchestrator.cwd = ctx.cwd;
 
+    if (!(globalThis as any)[SUBAGENT_SESSION_KEY]) {
+      const tracker = createUsageTracker();
+      const sessionId = ctx.sessionManager?.getSessionId?.() || "";
+      if (sessionId) {
+        const previous = loadUsageSummary(sessionId);
+        if (previous) tracker.loadFromSummary(previous);
+      }
+      (globalThis as any)[USAGE_TRACKER_KEY] = tracker;
+      setFooterContext(ctx);
+      setFooterTracker(tracker);
+      ctx.ui.setFooter(createCustomFooter);
+    }
+
     const subagentsMgr = (globalThis as any)[Symbol.for("pi-subagents:manager")];
     subagentsMgr?.refreshWidget?.(ctx.ui);
     const taskStore = (globalThis as any)[Symbol.for("pi-tasks:store")];
@@ -1196,6 +1109,20 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
   });
 
   pi.on("turn_end", async (event, ctx) => {
+    const msg = event.message as any;
+    const usageTracker = getUsageTracker();
+    if (usageTracker && msg?.usage) {
+      const input = typeof msg.usage.input === "number" ? msg.usage.input : 0;
+      const output = typeof msg.usage.output === "number" ? msg.usage.output : 0;
+      const cacheRead = typeof msg.usage.cacheRead === "number" ? msg.usage.cacheRead : 0;
+      const cacheWrite = typeof msg.usage.cacheWrite === "number" ? msg.usage.cacheWrite : 0;
+      const cost = typeof msg.usage.cost?.total === "number" ? msg.usage.cost.total : 0;
+      const modelId = (typeof msg.model === "string" && msg.model) || ctx.model?.id || "unknown-model";
+      const provider = (typeof msg.provider === "string" && msg.provider) || ctx.model?.provider || "unknown";
+      usageTracker.recordTurn(modelId, provider, input, output, cacheRead, cacheWrite, cost);
+      (ctx.ui as any)?.requestRender?.();
+    }
+
     if (!orchestrator.active || orchestrator.active.state.phase === "done") return;
     orchestrator.updateStatus(ctx);
 
@@ -1218,7 +1145,6 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
 
     const phase = orchestrator.active.state.phase;
 
-    const msg = event.message as any;
     if (msg?.stopReason === "aborted") return;
     if (msg?.stopReason === "error") {
       const errorMsg = msg.errorMessage || "unknown error";
@@ -1323,6 +1249,7 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
     }
 
     if (orchestrator.active.type === "brainstorm" && phase === "brainstorm") return;
+    if (orchestrator.active.type === "review" && phase === "review") return;
 
     const contentParts = Array.isArray(msg?.content) ? msg.content : [];
     const hasText = contentParts.some((c: any) => c.type === "text" && c.text?.trim());

package/extensions/orchestrator/flant-infra.ts

@@ -11,6 +11,8 @@ export interface OpenRouterModelData {
   pricing: {
     prompt: number;
     completion: number;
+    cacheRead: number;
+    cacheWrite: number;
   };
   modality: string;
 }
@@ -241,6 +243,8 @@ export async function fetchOpenRouterMetadata(modelIds: string[]): Promise<Recor
       pricing: {
         prompt: toNumber(pricing.prompt, 0),
         completion: toNumber(pricing.completion, 0),
+        cacheRead: toNumber(pricing.input_cache_read, 0),
+        cacheWrite: toNumber(pricing.input_cache_write, 0),
       },
       modality: typeof architecture.modality === "string" ? architecture.modality : "text",
     };
@@ -267,8 +271,8 @@ function buildProviderModelConfig(
     cost: {
       input: toNumber(modelMeta?.pricing.prompt, 0) * 1_000_000,
       output: toNumber(modelMeta?.pricing.completion, 0) * 1_000_000,
-      cacheRead: 0,
-      cacheWrite: 0,
+      cacheRead: toNumber(modelMeta?.pricing.cacheRead, 0) * 1_000_000,
+      cacheWrite: toNumber(modelMeta?.pricing.cacheWrite, 0) * 1_000_000,
     },
     contextWindow: toNumber(modelMeta?.context_length, 200000),
     maxTokens: toNumber(modelMeta?.max_completion_tokens, 32000),
@@ -358,6 +362,7 @@ export function generateFlantConfig(models: string[]): Partial<PiPiConfig> {
       implement: { model: modelSpec(implementModel), thinking: "high" },
       debug: { model: modelSpec(debugModel), thinking: "high" },
       brainstorm: { model: modelSpec(brainstormModel), thinking: "high" },
+      review: { model: modelSpec(implementModel), thinking: "high" },
     },
     planners: {
       opus: makeVariant(latestOpus, fallback),

package/extensions/orchestrator/integration.test.ts

@@ -4,7 +4,7 @@ import { join } from "path";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { Orchestrator } from "./orchestrator.js";
 import { registerCommandHandlers } from "./command-handlers.js";
-import { registerEventHandlers, runUserGateDialog } from "./event-handlers.js";
+import { registerEventHandlers } from "./event-handlers.js";
 import { createTask, loadTask, saveTask } from "./state.js";
 
 vi.mock("./cbm.js", () => ({ registerCbmTools: vi.fn() }));
@@ -25,6 +25,7 @@ vi.mock("./config.js", async (importOriginal) => {
       implement: { model: "test/model", thinking: "high" },
       debug: { model: "test/model", thinking: "high" },
       brainstorm: { model: "test/model", thinking: "high" },
+      review: { model: "test/model", thinking: "high" },
     },
     planners: { test: { enabled: true, model: "test/planner", thinking: "low" } },
     planReviewers: {},
@@ -142,6 +143,7 @@ function makeConfig() {
       implement: { model: "test/model", thinking: "high" },
       debug: { model: "test/model", thinking: "high" },
       brainstorm: { model: "test/model", thinking: "high" },
+      review: { model: "test/model", thinking: "high" },
     },
     planners: {
       test: { enabled: true, model: "test/planner", thinking: "low" },

package/extensions/orchestrator/orchestrator.test.ts

@@ -98,6 +98,7 @@ describe("deepReviewConfig", () => {
         implement: { model: "a/impl", thinking: "high" },
         debug: { model: "a/debug", thinking: "high" },
         brainstorm: { model: "a/brain", thinking: "high" },
+        review: { model: "a/review", thinking: "high" },
       },
       planners: {},
       planReviewers: {

package/extensions/orchestrator/orchestrator.ts

@@ -16,7 +16,8 @@ import { loadContextFiles, getPhaseArtifacts, getLatestSynthesizedPlan } from ".
 import { brainstormSystemPrompt } from "./phases/brainstorm.js";
 import { planningSystemPrompt, spawnPlanners } from "./phases/planning.js";
 import { implementationSystemPrompt } from "./phases/implementation.js";
-import { reviewSystemPrompt } from "./phases/review.js";
+import { reviewSystemPrompt as reviewCycleSystemPrompt } from "./phases/review.js";
+import { reviewSystemPrompt as reviewTaskSystemPrompt } from "./phases/review-task.js";
 import { registerAgentDefinitions, unregisterAgentDefinitions } from "./agents/registry.js";
 import { createExploreAgent } from "./agents/explore.js";
 import { createLibrarianAgent } from "./agents/librarian.js";
@@ -207,7 +208,7 @@ export class Orchestrator {
     if (this.active.state.reviewCycle?.step === "apply_feedback") {
       const pass = this.active.state.reviewCycle.pass;
       const manualReview = this.active.state.reviewCycle.kind === "manual";
-      return reviewSystemPrompt(this.active.dir, pass, manualReview, this.active.state.phase);
+      return reviewCycleSystemPrompt(this.active.dir, pass, manualReview, this.active.state.phase);
     }
 
     switch (this.active.state.phase) {
@@ -219,6 +220,8 @@ export class Orchestrator {
         return planningSystemPrompt(this.active.dir);
       case "implement":
         return implementationSystemPrompt(this.active.dir);
+      case "review":
+        return reviewTaskSystemPrompt(this.active.dir);
       default:
         return "";
     }
@@ -314,7 +317,12 @@ export class Orchestrator {
       description: state.description,
     };
 
-    const modelConfig = this.config.mainModel[type === "debug" ? "debug" : type === "brainstorm" ? "brainstorm" : "implement"];
+    const modelConfig = this.config.mainModel[
+      type === "debug" ? "debug"
+      : type === "brainstorm" ? "brainstorm"
+      : type === "review" ? "review"
+      : "implement"
+    ];
     const modelOk = await this.switchModel(ctx, modelConfig.model, modelConfig.thinking);
     if (!modelOk) {
       ctx.ui.notify(`Model "${modelConfig.model}" not found — using current model`, "warning");
@@ -328,7 +336,7 @@ export class Orchestrator {
     this.injectContextAndArtifacts(this.active.dir, this.active.state.phase);
 
     this.phaseStartTime = Date.now();
-    const isGenericDescription = ["implement", "debug", "brainstorm"].includes(this.active.description);
+    const isGenericDescription = ["implement", "debug", "brainstorm", "review"].includes(this.active.description);
     const hasInheritedTaskContext = Boolean(fromTaskDir && type === "implement");
     const isWaitingForPlanners = this.active.state.phase === "plan" && this.active.state.step === "await_planners";
     if (isGenericDescription && !hasInheritedTaskContext) {

package/extensions/orchestrator/phases/machine.ts

@@ -67,6 +67,11 @@ const TRANSITIONS: Record<TaskType, Record<string, string[]>> = {
     plan: ["implement"],
     implement: ["done"],
   },
+  review: {
+    review: ["plan"],
+    plan: ["implement"],
+    implement: ["done"],
+  },
 };
 
 export function canTransition(taskType: TaskType, from: Phase, to: Phase): boolean {
@@ -116,6 +121,37 @@ export function validateExitCriteria(
       return { ok: true };
     }
 
+    case "review": {
+      const ur = join(taskDir, "USER_REQUEST.md");
+      const res = join(taskDir, "RESEARCH.md");
+      if (isMissingOrEmpty(ur)) {
+        return { ok: false, reason: "USER_REQUEST.md does not exist or is empty" };
+      }
+      if (isMissingOrEmpty(res)) {
+        return { ok: false, reason: "RESEARCH.md does not exist or is empty" };
+      }
+      const urContent = readFileSync(ur, "utf-8");
+      const resContent = readFileSync(res, "utf-8");
+
+      const userRequestValidation = validateUserRequest(urContent);
+      if (!userRequestValidation.ok) {
+        return {
+          ok: false,
+          reason: formatValidationErrors("USER_REQUEST.md", userRequestValidation.errors, USER_REQUEST_TEMPLATE),
+        };
+      }
+
+      const researchValidation = validateResearch(resContent);
+      if (!researchValidation.ok) {
+        return {
+          ok: false,
+          reason: formatValidationErrors("RESEARCH.md", researchValidation.errors, RESEARCH_TEMPLATE),
+        };
+      }
+
+      return { ok: true };
+    }
+
     case "plan": {
       const plan = getLatestSynthesizedPlan(taskDir);
       if (!plan) {
@@ -205,5 +241,7 @@ export function phasePipeline(taskType: TaskType): Phase[] {
       return ["debug", "plan", "implement", "done"];
     case "brainstorm":
       return ["brainstorm", "plan", "implement", "done"];
+    case "review":
+      return ["review", "plan", "implement", "done"];
   }
 }

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

@@ -0,0 +1,32 @@
+export function reviewSystemPrompt(taskDir: string): string {
+  return [
+    "[PI-PI — REVIEW PHASE]",
+    "",
+    "You are reviewing code changes. USER_REQUEST.md describes what to review.",
+    "Read it first to understand the scope.",
+    "",
+    "Use available tools to analyze the changes:",
+    "- git diff, git log, git show for examining commits and diffs",
+    "- read, lsp, grep, find for understanding the code",
+    "- gh pr view for GitHub PR context if a PR URL is mentioned",
+    "",
+    "Write your findings:",
+    `- ${taskDir}/USER_REQUEST.md — update with a clear problem statement of issues found`,
+    `- ${taskDir}/RESEARCH.md — detailed technical analysis`,
+    "",
+    "USER_REQUEST.md format:",
+    "- # User Request",
+    "- ## Problem",
+    "- ## Constraints",
+    "",
+    "RESEARCH.md format:",
+    "- ## Affected Code",
+    "- ## Architecture Context",
+    "- ## Constraints & Edge Cases",
+    "- ## Open Questions (optional)",
+    "",
+    "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");
+}