@ilya-lesikov/pi-pi 0.1.0 → 0.3.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 ||
@@ -163,7 +150,7 @@ export async function enterReviewCycle(orchestrator: Orchestrator, ctx: any, kin
       orchestrator.active.state.step = "synthesize";
       saveTask(orchestrator.active.dir, orchestrator.active.state);
       const feedback = result.feedback ? `\n\nFeedback:\n${result.feedback}` : "";
-      return `Plannotator requested changes.${feedback}\n\nUser wants to continue. Run /pp when ready to advance.`;
+      return `Plannotator requested changes.${feedback}\n\nAddress the user's feedback. If the feedback contains questions, answer them. If it requests changes, make the changes. Then call pp_phase_complete when done.`;
     }
 
     orchestrator.active.state.reviewCycle = null;
@@ -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);
@@ -411,9 +276,11 @@ function registerSpecifyReviewsTool(orchestrator: Orchestrator): void {
       let hasNeedsChanges = false;
       for (const review of params.reviews) {
         ctx.ui?.setWorkingMessage?.(`Waiting for Plannotator review: ${review.range}…`);
+        const rangeBase = review.range.includes("..") ? review.range.split("..")[0] : review.range;
         const result = await openCodeReviewDirect(pi, {
           cwd: review.cwd,
-          diffType: `range:${review.range}`,
+          diffType: "branch",
+          defaultBranch: rangeBase,
         });
         if ("error" in result) {
           results.push(`${review.cwd} (${review.range}): ${result.error}`);
@@ -434,15 +301,23 @@ function registerSpecifyReviewsTool(orchestrator: Orchestrator): void {
           saveTask(orchestrator.active.dir, orchestrator.active.state);
         }
         return {
-          content: [{ type: "text" as const, text: `Plannotator review complete.\n\n${summary}\n\nFix the issues noted above, then call pp_phase_complete when done.` }],
+          content: [{ type: "text" as const, text: `Plannotator review complete.\n\n${summary}\n\nAddress the user's feedback. If the feedback contains questions, answer them. If it requests changes, make the changes. Then call pp_phase_complete when done.` }],
           details: {},
         };
       }
 
       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) {
+          await orchestrator.waitForCompaction();
+          return { content: [{ type: "text" as const, text: "Phase transition complete." }], details: {} };
+        }
+        if (!text) {
+          return { content: [{ type: "text" as const, text: "User dismissed the menu. Wait for the user's next message. When you resume work, update USER_REQUEST.md and RESEARCH.md with any new findings before calling pp_phase_complete." }], details: {} };
+        }
+        return { content: [{ type: "text" as const, text }], details: {} };
       } finally {
         ctx.ui?.setWorkingMessage?.();
       }
@@ -476,11 +351,22 @@ function registerCommitTool(orchestrator: Orchestrator): void {
       if (!orchestrator.config.autoCommit) {
         return { content: [{ type: "text" as const, text: "autoCommit is disabled in config." }], details: {} };
       }
-      if (orchestrator.active.modifiedFiles.size === 0) {
+      const files: string[] = [];
+      try {
+        const gitResult = await pi.exec("git", ["diff", "--name-only"], { cwd: orchestrator.cwd, timeout: 5000 });
+        if (gitResult.code === 0 && gitResult.stdout.trim()) {
+          files.push(...gitResult.stdout.trim().split("\n").filter(Boolean));
+        }
+        const stagedResult = await pi.exec("git", ["diff", "--name-only", "--cached"], { cwd: orchestrator.cwd, timeout: 5000 });
+        if (stagedResult.code === 0 && stagedResult.stdout.trim()) {
+          for (const f of stagedResult.stdout.trim().split("\n").filter(Boolean)) {
+            if (!files.includes(f)) files.push(f);
+          }
+        }
+      } catch {}
+      if (files.length === 0) {
         return { content: [{ type: "text" as const, text: "No modified files to commit." }], details: {} };
       }
-
-      const files = [...orchestrator.active.modifiedFiles];
       const result = autoCommit(files, params.message, orchestrator.cwd);
       if (result.ok) {
         orchestrator.active.modifiedFiles.clear();
@@ -523,10 +409,11 @@ function registerPhaseCompleteTool(orchestrator: Orchestrator): void {
         const { showActiveTaskMenu } = await import("./pp-menu.js");
         const text = await showActiveTaskMenu(orchestrator, ctx, params.summary, "tool");
         if (orchestrator.phaseCompactionPending || orchestrator.taskDoneCompactionPending) {
-          return { content: [{ type: "text" as const, text: "Phase transition in progress." }], details: {} };
+          await orchestrator.waitForCompaction();
+          return { content: [{ type: "text" as const, text: "Phase transition complete." }], details: {} };
         }
         if (!text) {
-          return { content: [{ type: "text" as const, text: "No action selected." }], details: {} };
+          return { content: [{ type: "text" as const, text: "User dismissed the menu. Wait for the user's next message. When you resume work, update USER_REQUEST.md and RESEARCH.md with any new findings before calling pp_phase_complete." }], details: {} };
         }
         return { content: [{ type: "text" as const, text }], details: {} };
       } finally {
@@ -539,6 +426,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 +600,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 +712,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 +739,18 @@ 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",
+        agentType: data.type || "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 +819,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 +1125,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 +1161,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 +1265,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());
@@ -1331,7 +1274,9 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
     const turnWasEmpty = !hasText && !hasToolCalls && !hasToolResults;
 
     if (!turnWasEmpty) {
-      if (hasText && !hasToolCalls) {
+      const lastPart = contentParts.length > 0 ? contentParts[contentParts.length - 1] : null;
+      const endsWithText = lastPart?.type === "text" && lastPart?.text?.trim();
+      if (hasText && (!hasToolCalls || endsWithText)) {
         const step = orchestrator.active.state.step;
         if (step !== "await_planners" && step !== "await_reviewers") {
           pi.sendMessage(

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) {
@@ -450,6 +458,13 @@ export class Orchestrator {
     }
   }
 
+  waitForCompaction(): Promise<void> {
+    if (!this.phaseCompactionPending && !this.taskDoneCompactionPending) return Promise.resolve();
+    return new Promise((resolve) => {
+      this.phaseCompactionResolve = resolve;
+    });
+  }
+
   compactAndTransition(ctx: ExtensionContext, taskDir: string, phase: Phase): void {
     this.phaseCompactionPending = true;
     ctx.compact({
@@ -461,6 +476,10 @@ export class Orchestrator {
           this.phaseCompactionResolve = null;
         }
         this.phaseStartTime = Date.now();
+        if (this.active && (phase === "plan" || phase === "implement")) {
+          const modelConfig = this.config.mainModel.implement;
+          this.switchModel(ctx, modelConfig.model, modelConfig.thinking).catch(() => {});
+        }
         this.injectContextAndArtifacts(taskDir, phase);
         if (this.active?.state.phase === "plan" && this.active.state.step === "await_planners") {
           ctx.ui.notify("Entered plan phase. Waiting for planners to complete before synthesis.", "info");
@@ -476,6 +495,10 @@ export class Orchestrator {
           this.phaseCompactionResolve = null;
         }
         this.phaseStartTime = Date.now();
+        if (this.active && (phase === "plan" || phase === "implement")) {
+          const modelConfig = this.config.mainModel.implement;
+          this.switchModel(ctx, modelConfig.model, modelConfig.thinking).catch(() => {});
+        }
         this.injectContextAndArtifacts(taskDir, phase);
         if (this.active?.state.phase === "plan" && this.active.state.step === "await_planners") {
           ctx.ui.notify("Entered plan phase. Waiting for planners to complete before synthesis.", "info");

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");
+}