@ilya-lesikov/pi-pi 0.1.0 → 0.2.0

package/extensions/orchestrator/pp-menu.ts

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync } from "fs";
+import { existsSync, readdirSync, writeFileSync } from "fs";
 import { join, relative } from "path";
 import { askUser } from "../../3p/pi-ask-user/index.js";
 import { unregisterAgentDefinitions } from "./agents/registry.js";
@@ -8,12 +8,13 @@ import {
   loadCodeReviewOutputs,
   loadPlanReviewOutputs,
 } from "./context.js";
-import { enterReviewCycle, finalizeReviewCycle } from "./event-handlers.js";
+import { detectDefaultBranch, enterReviewCycle, finalizeReviewCycle } from "./event-handlers.js";
 import { Orchestrator, deepReviewConfig } from "./orchestrator.js";
 import { cancelPendingPlannotatorWait } from "./plannotator.js";
 import { spawnPlanners, spawnPlanReviewers } from "./phases/planning.js";
 import { spawnCodeReviewers } from "./phases/review.js";
 import { spawnBrainstormReviewers } from "./phases/brainstorm.js";
+
 import {
   listTasks,
   loadTask,
@@ -72,6 +73,38 @@ function showStatus(orchestrator: Orchestrator, ctx: any): void {
   );
 }
 
+async function abortCurrentWork(orchestrator: Orchestrator, ctx: any): Promise<void> {
+  orchestrator.abortAllSubagents();
+  ctx.abort?.();
+  await ctx.waitForIdle?.();
+  const taskStore = (globalThis as any)[Symbol.for("pi-tasks:store")];
+  taskStore?.clearAll?.();
+  taskStore?.refreshWidget?.(ctx.ui);
+}
+
+async function pauseTask(orchestrator: Orchestrator, ctx: any): Promise<string> {
+  if (!orchestrator.active) return "No active task.";
+
+  cancelPendingPlannotatorWait(orchestrator);
+  orchestrator.abortAllSubagents();
+  ctx.abort?.();
+  await ctx.waitForIdle?.();
+
+  const name = orchestrator.active.description;
+
+  saveTask(orchestrator.active.dir, orchestrator.active.state);
+  unregisterAgentDefinitions(orchestrator.pi);
+  await orchestrator.cleanupActive();
+
+  const taskStore = (globalThis as any)[Symbol.for("pi-tasks:store")];
+  taskStore?.clearAll?.();
+  taskStore?.refreshWidget?.(ctx.ui);
+
+  orchestrator.updateStatus(ctx);
+  ctx.ui.notify(`Task "${name}" paused. Use /pp → Resume to continue.`, "info");
+  return `Task "${name}" paused.`;
+}
+
 async function finishTask(orchestrator: Orchestrator, ctx: any): Promise<string> {
   if (!orchestrator.active) return "No active task.";
 
@@ -162,7 +195,12 @@ export async function resumeTask(
     description: task.state.description,
   };
 
-  const modelConfig = orchestrator.config.mainModel[task.type === "debug" ? "debug" : task.type === "brainstorm" ? "brainstorm" : "implement"];
+  const modelConfig = orchestrator.config.mainModel[
+    task.type === "debug" ? "debug"
+    : task.type === "brainstorm" ? "brainstorm"
+    : task.type === "review" ? "review"
+    : "implement"
+  ];
   const modelOk = await orchestrator.switchModel(ctx, modelConfig.model, modelConfig.thinking);
   if (!modelOk) {
     ctx.ui.notify(`Model "${modelConfig.model}" not found — using current model`, "warning");
@@ -401,6 +439,7 @@ function collectRoleAssignments(config: Partial<PiPiConfig> | null): string[] {
   add("mainModel.implement", config.mainModel?.implement?.model);
   add("mainModel.debug", config.mainModel?.debug?.model);
   add("mainModel.brainstorm", config.mainModel?.brainstorm?.model);
+  add("mainModel.review", config.mainModel?.review?.model);
 
   for (const [name, variant] of Object.entries(config.planners ?? {})) {
     if (variant.enabled) add(`planners.${name}`, variant.model);
@@ -500,7 +539,14 @@ async function showFlantInfraMenu(orchestrator: Orchestrator, ctx: any): Promise
     }
 
     if (choice.startsWith("Cache period:")) {
-      const selected = await selectOption(ctx, "Cache period", ["1 day", "3 days", "7 days", "14 days", "30 days", "Back"]);
+      const selected = await selectOption(ctx, "Cache period", [
+        { title: "1 day", description: "Refresh model metadata daily" },
+        { title: "3 days", description: "Refresh model metadata every three days" },
+        { title: "7 days", description: "Default — refresh weekly" },
+        { title: "14 days", description: "Refresh model metadata every two weeks" },
+        { title: "30 days", description: "Refresh model metadata monthly" },
+        { title: "Back", description: "Return to the previous menu" },
+      ]);
       if (!selected || selected === "Back") continue;
       const days = Number(selected.split(" ")[0]);
       if (!Number.isFinite(days) || days <= 0) continue;
@@ -520,13 +566,158 @@ async function showFlantInfraMenu(orchestrator: Orchestrator, ctx: any): Promise
   }
 }
 
-async function showSettingsMenu(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK> {
+function formatTokenCount(count: number): string {
+  if (count < 1000) return String(count);
+  if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
+  if (count < 1000000) return `${Math.round(count / 1000)}k`;
+  if (count < 10000000) return `${(count / 1000000).toFixed(1)}M`;
+  return `${Math.round(count / 1000000)}M`;
+}
+
+function formatDuration(ms: number): string {
+  const sec = Math.floor(ms / 1000);
+  if (sec < 60) return `${sec}s`;
+  const min = Math.floor(sec / 60);
+  const remSec = sec % 60;
+  if (min < 60) return remSec > 0 ? `${min}m ${remSec}s` : `${min}m`;
+  const hr = Math.floor(min / 60);
+  const remMin = min % 60;
+  return remMin > 0 ? `${hr}h ${remMin}m` : `${hr}h`;
+}
+
+function showUsage(ctx: any): void {
+  const tracker = (globalThis as any)[Symbol.for("pi-pi:usage-tracker")] as
+    | {
+        getTotalInputTokens(): number; getTotalOutputTokens(): number;
+        getTotalCacheReadTokens(): number; getTotalCacheWriteTokens(): number;
+        getTotalCost(): number; getCacheHitRate(): number;
+        getPerModelUsage(): Record<string, { inputTokens: number; outputTokens: number; cacheReadTokens: number; cacheWriteTokens: number; turns: number }>;
+        getSubagentList(): Array<{ description: string; modelId: string; inputTokens: number; outputTokens: number; cacheReadTokens: number; cacheWriteTokens: number; cost: number; durationMs: number; toolUses: number }>;
+      }
+    | undefined;
+
+  if (!tracker) {
+    ctx.ui.notify("No usage data available.", "info");
+    return;
+  }
+
+  const mainInput = tracker.getTotalInputTokens();
+  const mainOutput = tracker.getTotalOutputTokens();
+  const mainCacheRead = tracker.getTotalCacheReadTokens();
+  const mainCacheWrite = tracker.getTotalCacheWriteTokens();
+  const mainCost = tracker.getTotalCost();
+  const models = tracker.getPerModelUsage();
+  const subagents = tracker.getSubagentList();
+
+  let saInput = 0, saOutput = 0, saCacheRead = 0, saCacheWrite = 0, saCost = 0;
+  for (const sa of subagents) {
+    saInput += sa.inputTokens;
+    saOutput += sa.outputTokens;
+    saCacheRead += sa.cacheReadTokens;
+    saCacheWrite += sa.cacheWriteTokens;
+    saCost += sa.cost;
+  }
+
+  const totalInput = mainInput + saInput;
+  const totalOutput = mainOutput + saOutput;
+  const totalCacheRead = mainCacheRead + saCacheRead;
+  const totalCost = mainCost + saCost;
+  const totalCacheRate = (totalCacheRead + totalInput) > 0
+    ? totalCacheRead / (totalCacheRead + totalInput)
+    : 0;
+
+  const byModel = new Map<string, { input: number; output: number; cacheRead: number; cacheWrite: number; cost: number }>();
+  for (const [modelId, usage] of Object.entries(models)) {
+    byModel.set(modelId, {
+      input: usage.inputTokens, output: usage.outputTokens,
+      cacheRead: usage.cacheReadTokens, cacheWrite: usage.cacheWriteTokens, cost: 0,
+    });
+  }
+  if (mainCost > 0 && Object.keys(models).length === 1) {
+    const entry = byModel.values().next().value;
+    if (entry) entry.cost = mainCost;
+  }
+  for (const sa of subagents) {
+    const key = sa.modelId !== "unknown" ? sa.modelId : sa.description;
+    const existing = byModel.get(key);
+    if (existing) {
+      existing.input += sa.inputTokens;
+      existing.output += sa.outputTokens;
+      existing.cacheRead += sa.cacheReadTokens;
+      existing.cacheWrite += sa.cacheWriteTokens;
+      existing.cost += sa.cost;
+    } else {
+      byModel.set(key, {
+        input: sa.inputTokens, output: sa.outputTokens,
+        cacheRead: sa.cacheReadTokens, cacheWrite: sa.cacheWriteTokens, cost: sa.cost,
+      });
+    }
+  }
+
+  const lines: string[] = ["Session usage (total):"];
+  lines.push(`  Input: ${formatTokenCount(totalInput)} tokens`);
+  lines.push(`  Output: ${formatTokenCount(totalOutput)} tokens`);
+  if (totalCacheRead > 0) lines.push(`  Cache: ⚡${Math.round(totalCacheRate * 100)}% hit rate`);
+  if (totalCost > 0) lines.push(`  Cost: $${totalCost.toFixed(3)}`);
+
+  if (byModel.size > 0) {
+    lines.push("");
+    lines.push("By model:");
+    for (const [modelId, m] of byModel) {
+      const cr = (m.cacheRead + m.input) > 0 ? Math.round(m.cacheRead / (m.cacheRead + m.input) * 100) : 0;
+      const parts = [`↑${formatTokenCount(m.input)}`, `↓${formatTokenCount(m.output)}`];
+      if (cr > 0) parts.push(`⚡${cr}%`);
+      if (m.cost > 0) parts.push(`$${m.cost.toFixed(3)}`);
+      lines.push(`  ${modelId}: ${parts.join("  ")}`);
+    }
+  }
+
+  lines.push("");
+  lines.push("By agent:");
+  const mainModelEntries = Object.entries(models);
+  if (mainModelEntries.length > 0) {
+    const mainParts = [`↑${formatTokenCount(mainInput)}`, `↓${formatTokenCount(mainOutput)}`];
+    const mainCR = (mainCacheRead + mainInput) > 0 ? Math.round(mainCacheRead / (mainCacheRead + mainInput) * 100) : 0;
+    if (mainCR > 0) mainParts.push(`⚡${mainCR}%`);
+    if (mainCost > 0) mainParts.push(`$${mainCost.toFixed(3)}`);
+    const mainModel = mainModelEntries.map(([id]) => id).join(", ");
+    lines.push(`  Main (${mainModel}): ${mainParts.join("  ")}`);
+  }
+  for (const sa of subagents) {
+    const saCR = (sa.cacheReadTokens + sa.inputTokens) > 0
+      ? Math.round(sa.cacheReadTokens / (sa.cacheReadTokens + sa.inputTokens) * 100) : 0;
+    const parts = [`↑${formatTokenCount(sa.inputTokens)}`, `↓${formatTokenCount(sa.outputTokens)}`];
+    if (saCR > 0) parts.push(`⚡${saCR}%`);
+    if (sa.cost > 0) parts.push(`$${sa.cost.toFixed(3)}`);
+    if (sa.durationMs > 0) parts.push(formatDuration(sa.durationMs));
+    if (sa.toolUses > 0) parts.push(`${sa.toolUses} tools`);
+    lines.push(`  ${sa.description}: ${parts.join("  ")}`);
+  }
+
+  ctx.ui.notify(lines.join("\n"), "info");
+}
+
+async function showSettingsMenu(orchestrator: Orchestrator, ctx: any, showFlant = true): Promise<typeof BACK> {
   while (true) {
-    const choice = await selectOption(ctx, "Settings", [
-      { title: "Flant AI Infrastructure", description: "Configure corporate AI model provider" },
-      { title: "Back", description: "Return to the previous menu" },
-    ]);
+    const options: OptionInput[] = [
+      { title: "Usage", description: "Show session token usage and cost breakdown" },
+      { title: "LSP", description: "Language server status and controls" },
+    ];
+    if (showFlant) {
+      options.push({ title: "Flant AI Infrastructure", description: "Configure corporate AI model provider" });
+    }
+    options.push({ title: "Back", description: "Return to the previous menu" });
+
+    const choice = await selectOption(ctx, "Settings", options);
     if (!choice || choice === "Back") return BACK;
+    if (choice === "Usage") {
+      showUsage(ctx);
+      continue;
+    }
+    if (choice === "LSP") {
+      await showLspMenu(ctx);
+      continue;
+    }
     await showFlantInfraMenu(orchestrator, ctx);
   }
 }
@@ -643,6 +834,148 @@ async function showImplementMenu(orchestrator: Orchestrator, ctx: any): Promise<
   }
 }
 
+function buildPrContext(parsed: any): { prUrl: string | null; prContext: string | null } {
+  const title = typeof parsed?.title === "string" ? parsed.title.trim() : "";
+  const body = typeof parsed?.body === "string" ? parsed.body.trim() : "";
+  const commentsRaw = Array.isArray(parsed?.comments)
+    ? parsed.comments
+    : Array.isArray(parsed?.comments?.nodes)
+    ? parsed.comments.nodes
+    : [];
+  const comments: string[] = commentsRaw
+    .map((comment: any) => {
+      const text = typeof comment?.body === "string"
+        ? comment.body.trim()
+        : typeof comment?.bodyText === "string"
+        ? comment.bodyText.trim()
+        : "";
+      return text;
+    })
+    .filter((text: string): text is string => text.length > 0);
+
+  const parts: string[] = [];
+  if (title) parts.push(`Title: ${title}`);
+  if (body) parts.push(`Body:\n${body}`);
+  if (comments.length > 0) {
+    parts.push(`Comments:\n${comments.map((comment, index) => `${index + 1}. ${comment}`).join("\n\n")}`);
+  }
+
+  const prUrl = typeof parsed?.url === "string" && parsed.url.trim().length > 0 ? parsed.url.trim() : null;
+  return { prUrl, prContext: parts.length > 0 ? parts.join("\n\n") : null };
+}
+
+async function detectCurrentPrContext(orchestrator: Orchestrator): Promise<{ prUrl: string | null; prContext: string | null }> {
+  try {
+    const prResult = await orchestrator.pi.exec("gh", ["pr", "view", "--json", "url,title,body,comments"], {
+      cwd: orchestrator.cwd,
+      timeout: 10000,
+    });
+    if (prResult.code !== 0) return { prUrl: null, prContext: null };
+    const parsed = JSON.parse(prResult.stdout);
+    return buildPrContext(parsed);
+  } catch {
+    return { prUrl: null, prContext: null };
+  }
+}
+
+async function openReviewTaskInPlannotator(orchestrator: Orchestrator): Promise<string> {
+  if (!orchestrator.active) return "No active task.";
+  const payload: Record<string, unknown> = { cwd: orchestrator.cwd };
+
+  return await new Promise((resolve) => {
+    let handled = false;
+    orchestrator.pi.events.emit("plannotator:request", {
+      requestId: crypto.randomUUID(),
+      action: "code-review",
+      payload,
+      respond: (response: any) => {
+        handled = true;
+        if (response?.status !== "handled") {
+          resolve(`Plannotator is not available${response?.error ? `: ${response.error}` : "."}`);
+          return;
+        }
+        const approved = !!response?.result?.approved;
+        const feedback = typeof response?.result?.feedback === "string" && response.result.feedback.trim().length > 0
+          ? `\n\nFeedback:\n${response.result.feedback}`
+          : "";
+        resolve(approved ? "Plannotator approved the review." : `Plannotator requested changes.${feedback}`);
+      },
+    });
+    setTimeout(() => {
+      if (!handled) resolve("Plannotator is not available.");
+    }, 30000);
+  });
+}
+
+async function startReviewTask(
+  orchestrator: Orchestrator,
+  ctx: any,
+  userRequestContent: string,
+  researchContent: string | null,
+  description: string,
+): Promise<"started" | typeof BACK> {
+  await orchestrator.startTask(ctx, "review", description);
+  if (!orchestrator.active || orchestrator.active.type !== "review") return BACK;
+  writeFileSync(join(orchestrator.active.dir, "USER_REQUEST.md"), userRequestContent, "utf-8");
+  if (researchContent) {
+    writeFileSync(join(orchestrator.active.dir, "RESEARCH.md"), researchContent, "utf-8");
+  }
+  return "started";
+}
+
+async function showReviewMenu(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK | "started"> {
+  while (true) {
+    const choice = await selectOption(ctx, "Review", [
+      { title: "Current branch", description: "Review changes on current branch vs base" },
+      { title: "Uncommitted changes", description: "Review working directory changes" },
+      { title: "Describe", description: "Describe what to review and let the agent figure it out" },
+      { title: "Resume", description: "Resume a previously unfinished review" },
+      { title: "Back", description: "Return to the previous menu" },
+    ]);
+    if (!choice || choice === "Back") return BACK;
+
+    if (choice === "Resume") {
+      const result = await showResumeMenu(orchestrator, ctx, "review", "No paused review tasks found.");
+      if (result === "started") return result;
+      continue;
+    }
+
+    if (choice === "Current branch") {
+      const base = await detectDefaultBranch(orchestrator.pi, orchestrator.cwd, orchestrator.config);
+      const pr = await detectCurrentPrContext(orchestrator);
+
+      const urLines = [`# User Request\nReview current branch changes (${base}..HEAD)`];
+      if (pr.prUrl) urLines.push(`PR: ${pr.prUrl}`);
+      urLines.push("", "## Problem", "Review and identify issues in the code changes.", "", "## Constraints", "Focus on correctness, edge cases, style, missing tests, potential bugs.");
+      const urContent = urLines.join("\n") + "\n";
+
+      let resContent: string | null = null;
+      if (pr.prContext) {
+        resContent = ["## PR Context", pr.prContext, "", "## Affected Code", "(to be filled during review)", "", "## Architecture Context", "(to be filled during review)"].join("\n") + "\n";
+      }
+
+      const description = await promptDescription(ctx, "Describe the review (optional)", "review");
+      if (!description) continue;
+      return startReviewTask(orchestrator, ctx, urContent, resContent, description);
+    }
+
+    if (choice === "Uncommitted changes") {
+      const urContent = "# User Request\nReview uncommitted changes\n\n## Problem\nReview and identify issues in uncommitted working directory changes.\n\n## Constraints\nFocus on correctness, edge cases, style, missing tests, potential bugs.\n";
+      const description = await promptDescription(ctx, "Describe the review (optional)", "review");
+      if (!description) continue;
+      return startReviewTask(orchestrator, ctx, urContent, null, description);
+    }
+
+    const input = await ctx.ui.input("Describe what to review");
+    if (input === undefined || input === null) continue;
+    const trimmed = String(input).trim();
+    if (!trimmed) continue;
+
+    const urContent = `# User Request\n${trimmed}\n\n## Problem\n${trimmed}\n\n## Constraints\nFocus on correctness, edge cases, style, missing tests, potential bugs.\n`;
+    return startReviewTask(orchestrator, ctx, urContent, null, trimmed);
+  }
+}
+
 async function showTaskTypeMenu(
   orchestrator: Orchestrator,
   ctx: any,
@@ -675,13 +1008,13 @@ async function showNoActiveMenu(orchestrator: Orchestrator, ctx: any): Promise<s
       { title: "Debug", description: "Diagnose an issue. Then (optionally) fix it" },
       { title: "Brainstorm", description: "Explore and brainstorm. Then (optionally) plan and implement" },
       { title: "Implement", description: "Brainstorm, plan and implement" },
+      { title: "Review", description: "Review code changes, diffs, or pull requests" },
       { title: "Resume", description: "Resume a previously unfinished task" },
       { title: "Subagents", description: "Manage running agents" },
-      { title: "LSP", description: "Language server status and controls" },
-      { title: "Settings", description: "Configure pi-pi extension" },
-      { title: "Close", description: "Close this menu" },
+      { title: "Settings", description: "LSP, Flant AI, and other configuration" },
+      { title: "Back", description: "Close this menu" },
     ]);
-    if (!choice || choice === "Close") return undefined;
+    if (!choice || choice === "Back") return undefined;
 
     if (choice === "Debug") {
       const result = await showTaskTypeMenu(orchestrator, ctx, "debug", "Describe the task");
@@ -701,6 +1034,12 @@ async function showNoActiveMenu(orchestrator: Orchestrator, ctx: any): Promise<s
       continue;
     }
 
+    if (choice === "Review") {
+      const result = await showReviewMenu(orchestrator, ctx);
+      if (result === "started") return undefined;
+      continue;
+    }
+
     if (choice === "Resume") {
       const result = await showResumeMenu(orchestrator, ctx, undefined, "No paused tasks found.");
       if (result === "started") return undefined;
@@ -712,12 +1051,7 @@ async function showNoActiveMenu(orchestrator: Orchestrator, ctx: any): Promise<s
       continue;
     }
 
-    if (choice === "LSP") {
-      await showLspMenu(ctx);
-      continue;
-    }
-
-    await showSettingsMenu(orchestrator, ctx);
+    await showSettingsMenu(orchestrator, ctx, true);
   }
 }
 
@@ -767,32 +1101,36 @@ export async function showActiveTaskMenu(
 
     const waiting = step === "await_planners" || step === "await_reviewers";
     const { autoLabel, deepLabel } = getReviewLabels(orchestrator);
-    const hasPlannotator = phase === "plan" || phase === "implement";
-    const canFinishPhase = (phase === "brainstorm" && task.type === "brainstorm") || phase === "debug";
+    const isReviewPhase = phase === "review";
+    const hasPlannotator = phase === "plan" || phase === "implement" || isReviewPhase;
 
     const opt = (title: string, description: string): OptionInput => ({ title, description });
 
     const options: OptionInput[] = [];
+    options.push(opt("Finish", "Complete, pause, or continue to next phase"));
     if (!waiting) {
-      options.push(opt("Approve & continue", "Advance to the next phase"));
       options.push(opt(autoLabel, "Run automated review with configured reviewers"));
       options.push(opt(deepLabel, "Run automated review with higher thinking level"));
       if (hasPlannotator) {
-        options.push(opt("Review in Plannotator", "Open visual review in browser"));
-        options.push(opt("Review on my own", "Review manually, then continue"));
-      }
-      options.push(opt("Back to prompt", "Return to the prompt and keep working"));
-      if (canFinishPhase) {
-        options.push(opt("Finish", "Complete this phase and end the task"));
+        if (isReviewPhase) {
+          options.push(opt("Review in Plannotator", "Open visual diff review in browser"));
+        } else {
+          options.push(opt("Review in Plannotator", "Open visual review in browser"));
+        }
+        if (!isReviewPhase) {
+          options.push(opt("Review on my own", "Review manually, then continue"));
+        }
       }
     }
-    options.push(opt("Abort", "Stop the task without completing"));
-    options.push(opt("Status", "Show current task phase, step, and timing"));
     options.push(opt("Subagents", "Manage running agents"));
-    options.push(opt("LSP", "Language server status and controls"));
+    options.push(opt("Status", "Show current task phase, step, and timing"));
+    options.push(opt("Settings", "LSP and other configuration"));
+    options.push(opt("Back", "Return to the prompt and keep working"));
 
     const choice = await selectOption(ctx, summary, options);
-    if (!choice) return mode === "tool" ? "No action selected." : "";
+    if (!choice || choice === "Back") {
+      return "";
+    }
 
     if (choice === "Status") {
       showStatus(orchestrator, ctx);
@@ -802,18 +1140,37 @@ export async function showActiveTaskMenu(
       await showSubagentsMenu(ctx);
       continue;
     }
-    if (choice === "LSP") {
-      await showLspMenu(ctx);
+    if (choice === "Settings") {
+      await showSettingsMenu(orchestrator, ctx, false);
       continue;
     }
-    if (choice === "Abort" || choice === "Finish") {
-      const text = await finishTask(orchestrator, ctx);
-      return mode === "tool" ? text : "";
-    }
 
-    finalizeReviewCycle(task);
+    if (mode === "command") {
+      await abortCurrentWork(orchestrator, ctx);
+    }
 
-    if (choice === "Approve & continue") {
+    if (choice === "Finish") {
+      const canContinue = phase !== "implement" && !waiting;
+      const continueLabel = phase === "plan" ? "Continue to implement" : "Continue to plan & implement";
+      const finishOptions: OptionInput[] = [];
+      if (canContinue) {
+        finishOptions.push(opt(continueLabel, "Approve and advance to the next phase"));
+      }
+      finishOptions.push(opt("Complete", "Mark task as done and clean up"));
+      finishOptions.push(opt("Pause", "Suspend task to resume later"));
+      finishOptions.push(opt("Back", "Return to the previous menu"));
+
+      const finishChoice = await selectOption(ctx, "Finish", finishOptions);
+      if (!finishChoice || finishChoice === "Back") continue;
+      if (finishChoice === "Pause") {
+        const text = await pauseTask(orchestrator, ctx);
+        return mode === "tool" ? text : "";
+      }
+      if (finishChoice === "Complete") {
+        const text = await finishTask(orchestrator, ctx);
+        return mode === "tool" ? text : "";
+      }
+      finalizeReviewCycle(task);
       const result = await orchestrator.transitionToNextPhase(ctx);
       if (!result.ok) return `Transition blocked: ${result.error}`;
       if (orchestrator.phaseCompactionPending || orchestrator.taskDoneCompactionPending) return "";
@@ -822,6 +1179,14 @@ export async function showActiveTaskMenu(
       return "";
     }
 
+    if (choice === "Review in Plannotator" && isReviewPhase) {
+      const text = await openReviewTaskInPlannotator(orchestrator);
+      ctx.ui.notify(text, "info");
+      continue;
+    }
+
+    finalizeReviewCycle(task);
+
     if (choice === autoLabel || choice === deepLabel || choice === "Review in Plannotator") {
       const kind = choice === autoLabel ? "auto" as const : choice === deepLabel ? "auto-deep" as const : "plannotator" as const;
       if (kind !== "plannotator" && !hasEnabledReviewers(orchestrator, kind)) {
@@ -845,15 +1210,6 @@ export async function showActiveTaskMenu(
       }
       return continueMessage;
     }
-
-    if (choice === "Back to prompt") {
-      if (phase === "plan") {
-        setStep(orchestrator, "synthesize");
-      } else {
-        setStep(orchestrator, "llm_work");
-      }
-      return continueMessage;
-    }
   }
 }
 

package/extensions/orchestrator/state.ts

@@ -13,12 +13,13 @@ function getLockfileFs(): typeof import("fs") | undefined {
 }
 import type { TimeoutConfig } from "./config.js";
 
-export type TaskType = "implement" | "debug" | "brainstorm";
+export type TaskType = "implement" | "debug" | "brainstorm" | "review";
 
 export type ImplementPhase = "brainstorm" | "plan" | "implement" | "done";
 export type DebugPhase = "debug" | "plan" | "implement" | "done";
 export type BrainstormPhase = "brainstorm" | "plan" | "implement" | "done";
-export type Phase = ImplementPhase | DebugPhase | BrainstormPhase;
+export type ReviewPhase = "review" | "plan" | "implement" | "done";
+export type Phase = ImplementPhase | DebugPhase | BrainstormPhase | ReviewPhase;
 
 export interface TaskState {
   phase: Phase;
@@ -31,6 +32,7 @@ export interface TaskState {
   from: string | null;
   description: string;
   startedAt: string;
+
 }
 
 export interface TaskInfo {
@@ -60,7 +62,7 @@ export function createTask(cwd: string, type: TaskType, description: string): st
   mkdirSync(taskDir, { recursive: true });
 
   const state: TaskState = {
-    phase: type === "implement" ? "brainstorm" : type === "debug" ? "debug" : "brainstorm",
+    phase: type === "implement" ? "brainstorm" : type === "debug" ? "debug" : type === "review" ? "review" : "brainstorm",
     step: "llm_work",
     reviewCycle: null,
     reviewPass: 0,
@@ -77,10 +79,7 @@ export function loadTask(taskDir: string): TaskState {
   const sp = taskStatePath(taskDir);
   const raw = readFileSync(sp, "utf-8");
   try {
-    const state = JSON.parse(raw) as TaskState & { phase?: string };
-    if (state.phase === "planning") {
-      state.phase = "plan";
-    }
+    const state = JSON.parse(raw) as TaskState;
     return state;
   } catch (err: any) {
     throw new Error(`Failed to parse ${sp}: ${err.message}`);
@@ -95,7 +94,7 @@ export function listTasks(cwd: string, type?: TaskType): TaskInfo[] {
   const base = stateDir(cwd);
   if (!existsSync(base)) return [];
 
-  const types: TaskType[] = type ? [type] : ["implement", "debug", "brainstorm"];
+  const types: TaskType[] = type ? [type] : ["implement", "debug", "brainstorm", "review"];
   const results: TaskInfo[] = [];
 
   for (const t of types) {
@@ -196,7 +195,7 @@ export function taskName(taskDir: string): string {
     const state = loadTask(taskDir);
     let desc = state.description ?? "";
 
-    if (["implement", "debug", "brainstorm"].includes(desc)) {
+    if (["implement", "debug", "brainstorm", "review"].includes(desc)) {
       const urPath = join(taskDir, "USER_REQUEST.md");
       if (existsSync(urPath)) {
         const content = readFileSync(urPath, "utf-8");