@ilya-lesikov/pi-pi 0.1.0 → 0.3.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,183 @@ 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; agentType: 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 }>();
+  const mainModelEntries = Object.entries(models);
+  const mainTotalTokens = mainModelEntries.reduce((s, [, u]) => s + u.inputTokens + u.outputTokens, 0);
+  for (const [modelId, usage] of mainModelEntries) {
+    const modelTokens = usage.inputTokens + usage.outputTokens;
+    const modelCostShare = mainTotalTokens > 0 ? mainCost * (modelTokens / mainTotalTokens) : 0;
+    byModel.set(modelId, {
+      input: usage.inputTokens, output: usage.outputTokens,
+      cacheRead: usage.cacheReadTokens, cacheWrite: usage.cacheWriteTokens, cost: modelCostShare,
+    });
+  }
+  for (const sa of subagents) {
+    const key = sa.modelId !== "unknown" ? sa.modelId : `subagent:${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(2)}`);
+
+  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(2)}`);
+      lines.push(`  ${modelId}: ${parts.join("  ")}`);
+    }
+  }
+
+  lines.push("");
+  lines.push("By agent:");
+  const agentModelNames = Object.keys(models);
+  if (agentModelNames.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(2)}`);
+    lines.push(`  Main (${agentModelNames.join(", ")}): ${mainParts.join("  ")}`);
+  }
+  const byAgentType = new Map<string, { input: number; output: number; cacheRead: number; cost: number; durationMs: number; toolUses: number; count: number }>();
+  for (const sa of subagents) {
+    const key = sa.agentType || sa.description;
+    const existing = byAgentType.get(key);
+    if (existing) {
+      existing.input += sa.inputTokens;
+      existing.output += sa.outputTokens;
+      existing.cacheRead += sa.cacheReadTokens;
+      existing.cost += sa.cost;
+      existing.durationMs += sa.durationMs;
+      existing.toolUses += sa.toolUses;
+      existing.count += 1;
+    } else {
+      byAgentType.set(key, {
+        input: sa.inputTokens, output: sa.outputTokens, cacheRead: sa.cacheReadTokens,
+        cost: sa.cost, durationMs: sa.durationMs, toolUses: sa.toolUses, count: 1,
+      });
+    }
+  }
+  for (const [agentType, agg] of byAgentType) {
+    const saCR = (agg.cacheRead + agg.input) > 0
+      ? Math.round(agg.cacheRead / (agg.cacheRead + agg.input) * 100) : 0;
+    const parts = [`↑${formatTokenCount(agg.input)}`, `↓${formatTokenCount(agg.output)}`];
+    if (saCR > 0) parts.push(`⚡${saCR}%`);
+    if (agg.cost > 0) parts.push(`$${agg.cost.toFixed(2)}`);
+    if (agg.durationMs > 0) parts.push(formatDuration(agg.durationMs));
+    if (agg.toolUses > 0) parts.push(`${agg.toolUses} tools`);
+    const countSuffix = agg.count > 1 ? ` (×${agg.count})` : "";
+    lines.push(`  ${agentType}${countSuffix}: ${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[] = [];
+    if (orchestrator.active) {
+      options.push({ title: "Task status", description: "Show current task phase, step, and timing" });
+    }
+    options.push({ title: "Usage", description: "Show session token usage and cost breakdown" });
+    options.push({ 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 === "Task status") {
+      showStatus(orchestrator, ctx);
+      continue;
+    }
+    if (choice === "Usage") {
+      showUsage(ctx);
+      continue;
+    }
+    if (choice === "LSP") {
+      await showLspMenu(ctx);
+      continue;
+    }
     await showFlantInfraMenu(orchestrator, ctx);
   }
 }
@@ -643,6 +859,149 @@ 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 openCodeReviewInPlannotator(orchestrator: Orchestrator, diffType?: string, defaultBranch?: string): Promise<string> {
+  const payload: Record<string, unknown> = { cwd: orchestrator.cwd };
+  if (diffType) payload.diffType = diffType;
+  if (defaultBranch) payload.defaultBranch = defaultBranch;
+
+  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 +1034,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 +1060,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 +1077,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,53 +1127,63 @@ 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"));
-      }
+      options.push(opt("Review", "Auto review, Plannotator, or manual review"));
     }
-    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"));
-
-    const choice = await selectOption(ctx, summary, options);
-    if (!choice) return mode === "tool" ? "No action selected." : "";
-
-    if (choice === "Status") {
-      showStatus(orchestrator, ctx);
-      continue;
+    options.push(opt("Settings", "Task status, usage, and LSP"));
+    options.push(opt("Back", "Return to the prompt and keep working"));
+
+    const headerLines = [`/pp\n\nTask: ${task.type}\nPhase: ${phase}`];
+    if (summary !== "/pp") headerLines.push(`\n${summary}`);
+    const menuTitle = headerLines.join("");
+    const choice = await selectOption(ctx, menuTitle, options);
+    if (!choice || choice === "Back") {
+      return "";
     }
+
     if (choice === "Subagents") {
       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,9 +1192,95 @@ export async function showActiveTaskMenu(
       return "";
     }
 
-    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)) {
+    if (choice === "Review") {
+      const reviewOptions: OptionInput[] = [
+        opt(autoLabel, "Run automated review with configured reviewers"),
+        opt(deepLabel, "Run automated review with higher thinking level"),
+      ];
+      if (hasPlannotator) {
+        reviewOptions.push(opt("Review in Plannotator", phase === "plan" ? "Open plan review in browser" : "Open code diff review in browser"));
+      }
+      reviewOptions.push(opt("Review on my own", "Review manually, then continue"));
+      reviewOptions.push(opt("Back", "Return to the previous menu"));
+
+      const reviewChoice = await selectOption(ctx, "Review", reviewOptions);
+      if (!reviewChoice || reviewChoice === "Back") continue;
+
+      if (reviewChoice === "Review in Plannotator") {
+        if (phase === "plan") {
+          finalizeReviewCycle(task);
+          const text = await enterReviewCycle(orchestrator, ctx, "plannotator");
+          const curStep = orchestrator.active?.state.step;
+          if (curStep === "await_reviewers") return "";
+          const handled = handleReviewResult(ctx, text);
+          if (handled.continueLoop) continue;
+          return handled.text ?? text;
+        }
+        const diffChoice = await selectOption(ctx, "Review in Plannotator", [
+          opt("All branch changes", "Committed changes vs base branch"),
+          opt("Last commit", "Changes in the most recent commit"),
+          opt("Recent commits", "Choose how many recent commits to review"),
+          opt("Uncommitted changes", "Working directory changes"),
+          opt("Back", "Return to the previous menu"),
+        ]);
+        if (!diffChoice || diffChoice === "Back") continue;
+
+        let diffType: string | undefined;
+        let defaultBranch: string | undefined;
+        if (diffChoice === "All branch changes") {
+          diffType = "branch";
+        } else if (diffChoice === "Last commit") {
+          diffType = "last-commit";
+        } else if (diffChoice === "Recent commits") {
+          let commits: Array<{ hash: string; message: string; age: string }> = [];
+          try {
+            const logResult = await orchestrator.pi.exec(
+              "git", ["log", "--oneline", "--format=%h\t%s\t%cr", "-15"],
+              { cwd: orchestrator.cwd, timeout: 5000 },
+            );
+            if (logResult.code === 0 && logResult.stdout.trim()) {
+              commits = logResult.stdout.trim().split("\n").map((line) => {
+                const [hash, message, age] = line.split("\t");
+                return { hash: hash || "", message: message || "", age: age || "" };
+              }).filter((c) => c.hash);
+            }
+          } catch {}
+          if (commits.length === 0) {
+            ctx.ui.notify("No commits found.", "info");
+            continue;
+          }
+          const commitOptions: OptionInput[] = commits.map((c) => ({
+            title: `${c.hash} ${c.message}`,
+            description: c.age,
+          }));
+          commitOptions.push(opt("Back", "Return to the previous menu"));
+          const picked = await selectOption(ctx, "Review changes since:", commitOptions);
+          if (!picked || picked === "Back") continue;
+          const pickedHash = picked.split(" ")[0];
+          if (!pickedHash) continue;
+          diffType = "branch";
+          defaultBranch = pickedHash;
+        } else {
+          diffType = "uncommitted";
+        }
+
+        const text = await openCodeReviewInPlannotator(orchestrator, diffType, defaultBranch);
+        ctx.ui.notify(text, "info");
+        continue;
+      }
+
+      if (reviewChoice === "Review on my own") {
+        if (phase === "plan") {
+          setStep(orchestrator, "synthesize");
+        } else {
+          setStep(orchestrator, "llm_work");
+        }
+        return continueMessage;
+      }
+
+      finalizeReviewCycle(task);
+      const kind = reviewChoice === autoLabel ? "auto" as const : "auto-deep" as const;
+      if (!hasEnabledReviewers(orchestrator, kind)) {
         const label = phase === "brainstorm" ? "brainstorm" : phase === "plan" ? "plan" : "code";
         ctx.ui.notify(`No ${label} reviewers enabled.`, "info");
         continue;
@@ -836,24 +1292,6 @@ export async function showActiveTaskMenu(
       if (handled.continueLoop) continue;
       return handled.text ?? text;
     }
-
-    if (choice === "Review on my own") {
-      if (phase === "plan") {
-        setStep(orchestrator, "synthesize");
-      } else {
-        setStep(orchestrator, "llm_work");
-      }
-      return continueMessage;
-    }
-
-    if (choice === "Back to prompt") {
-      if (phase === "plan") {
-        setStep(orchestrator, "synthesize");
-      } else {
-        setStep(orchestrator, "llm_work");
-      }
-      return continueMessage;
-    }
   }
 }
 
@@ -861,6 +1299,6 @@ export async function showPpMenu(orchestrator: Orchestrator, ctx: any, mode: Men
   if (!orchestrator.active) {
     return showNoActiveMenu(orchestrator, ctx);
   }
-  const text = await showActiveTaskMenu(orchestrator, ctx, "Choose next action", mode);
+  const text = await showActiveTaskMenu(orchestrator, ctx, "/pp", mode);
   return text || undefined;
 }