@ilya-lesikov/pi-pi 0.2.0 → 0.3.0

package/3p/pi-plannotator/apps/pi-extension/plannotator-browser.ts

@@ -442,12 +442,7 @@ export async function startCodeReviewBrowserSession(
 			gitRef = result.gitRef;
 			diffError = result.error;
 			initialBase = result.base;
-			if (typeof diffType === "string" && diffType.startsWith("range:") && gitCtx) {
-				const range = diffType.slice("range:".length);
-				if (!gitCtx.diffOptions.some((o: { id: string }) => o.id === diffType)) {
-					gitCtx.diffOptions.push({ id: diffType, label: `Commits ${range}` });
-				}
-			}
+
 		} else {
 			workspace = await buildLocalWorkspaceReview(cwd, {
 				requestedDiffType: options.diffType,

package/3p/pi-plannotator/packages/shared/review-core.ts

@@ -22,7 +22,6 @@ export type DiffType =
   | "branch"
   | "merge-base"
   | "all"
-  | `range:${string}`
   | `worktree:${string}`
   | "p4-default"
   | `p4-changelist:${string}`;
@@ -737,28 +736,8 @@ export async function runGitDiff(
         break;
       }
 
-      default: {
-        if (effectiveDiffType.startsWith("range:")) {
-          const range = effectiveDiffType.slice("range:".length);
-          const rangeArgs = [
-            "diff",
-            "--no-ext-diff",
-            ...wFlag,
-            "--src-prefix=a/",
-            "--dst-prefix=b/",
-            "--end-of-options",
-            range,
-          ];
-          const rangeDiff = assertGitSuccess(
-            await runtime.runGit(rangeArgs, { cwd }),
-            rangeArgs,
-          );
-          patch = rangeDiff.stdout;
-          label = `Commits ${range}`;
-          break;
-        }
+      default:
         return { patch: "", label: "Unknown diff type" };
-      }
     }
   } catch (error) {
     const raw = error instanceof Error ? error.message : String(error);

package/3p/pi-plannotator/packages/shared/vcs-core.ts

@@ -158,7 +158,7 @@ export function createGitProvider(runtime: ReviewGitRuntime): VcsProvider {
     },
 
     ownsDiffType(diffType: string): boolean {
-      return GIT_DIFF_TYPES.has(diffType) || diffType.startsWith("worktree:") || diffType.startsWith("range:");
+      return GIT_DIFF_TYPES.has(diffType) || diffType.startsWith("worktree:");
     },
 
     canStageFiles(diffType: string): boolean {

package/extensions/orchestrator/event-handlers.ts

@@ -150,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;
@@ -276,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}`);
@@ -299,7 +301,7 @@ 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: {},
         };
       }
@@ -309,10 +311,11 @@ function registerSpecifyReviewsTool(orchestrator: Orchestrator): void {
         const { showActiveTaskMenu } = await import("./pp-menu.js");
         const text = await showActiveTaskMenu(orchestrator, ctx, `Plannotator review complete.\n\n${summary}`, "tool");
         if (orchestrator.phaseCompactionPending || orchestrator.taskDoneCompactionPending) {
-          return { content: [{ type: "text" as const, text: "Phase transition in progress." }], details: {} };
+          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 {
@@ -348,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();
@@ -395,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 {
@@ -728,6 +743,7 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
     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,
@@ -1258,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/orchestrator.ts

@@ -458,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({
@@ -469,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");
@@ -484,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/pp-menu.ts

@@ -592,7 +592,7 @@ function showUsage(ctx: any): void {
         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 }>;
+        getSubagentList(): Array<{ description: string; agentType: string; modelId: string; inputTokens: number; outputTokens: number; cacheReadTokens: number; cacheWriteTokens: number; cost: number; durationMs: number; toolUses: number }>;
       }
     | undefined;
 
@@ -627,18 +627,18 @@ function showUsage(ctx: any): void {
     : 0;
 
   const byModel = new Map<string, { input: number; output: number; cacheRead: number; cacheWrite: number; cost: number }>();
-  for (const [modelId, usage] of Object.entries(models)) {
+  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: 0,
+      cacheRead: usage.cacheReadTokens, cacheWrite: usage.cacheWriteTokens, cost: modelCostShare,
     });
   }
-  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 key = sa.modelId !== "unknown" ? sa.modelId : `subagent:${sa.description}`;
     const existing = byModel.get(key);
     if (existing) {
       existing.input += sa.inputTokens;
@@ -658,7 +658,7 @@ function showUsage(ctx: any): void {
   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 (totalCost > 0) lines.push(`  Cost: $${totalCost.toFixed(2)}`);
 
   if (byModel.size > 0) {
     lines.push("");
@@ -667,31 +667,50 @@ function showUsage(ctx: any): void {
       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)}`);
+      if (m.cost > 0) parts.push(`$${m.cost.toFixed(2)}`);
       lines.push(`  ${modelId}: ${parts.join("  ")}`);
     }
   }
 
   lines.push("");
   lines.push("By agent:");
-  const mainModelEntries = Object.entries(models);
-  if (mainModelEntries.length > 0) {
+  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(3)}`);
-    const mainModel = mainModelEntries.map(([id]) => id).join(", ");
-    lines.push(`  Main (${mainModel}): ${mainParts.join("  ")}`);
+    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 saCR = (sa.cacheReadTokens + sa.inputTokens) > 0
-      ? Math.round(sa.cacheReadTokens / (sa.cacheReadTokens + sa.inputTokens) * 100) : 0;
-    const parts = [`↑${formatTokenCount(sa.inputTokens)}`, `↓${formatTokenCount(sa.outputTokens)}`];
+    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 (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("  ")}`);
+    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");
@@ -699,10 +718,12 @@ function showUsage(ctx: any): void {
 
 async function showSettingsMenu(orchestrator: Orchestrator, ctx: any, showFlant = true): Promise<typeof BACK> {
   while (true) {
-    const options: OptionInput[] = [
-      { title: "Usage", description: "Show session token usage and cost breakdown" },
-      { title: "LSP", description: "Language server status and controls" },
-    ];
+    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" });
     }
@@ -710,6 +731,10 @@ async function showSettingsMenu(orchestrator: Orchestrator, ctx: any, showFlant
 
     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;
@@ -878,9 +903,10 @@ async function detectCurrentPrContext(orchestrator: Orchestrator): Promise<{ prU
   }
 }
 
-async function openReviewTaskInPlannotator(orchestrator: Orchestrator): Promise<string> {
-  if (!orchestrator.active) return "No active task.";
+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;
@@ -1109,33 +1135,20 @@ export async function showActiveTaskMenu(
     const options: OptionInput[] = [];
     options.push(opt("Finish", "Complete, pause, or continue to next phase"));
     if (!waiting) {
-      options.push(opt(autoLabel, "Run automated review with configured reviewers"));
-      options.push(opt(deepLabel, "Run automated review with higher thinking level"));
-      if (hasPlannotator) {
-        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("Review", "Auto review, Plannotator, or manual review"));
     }
     options.push(opt("Subagents", "Manage running agents"));
-    options.push(opt("Status", "Show current task phase, step, and timing"));
-    options.push(opt("Settings", "LSP and other configuration"));
+    options.push(opt("Settings", "Task status, usage, and LSP"));
     options.push(opt("Back", "Return to the prompt and keep working"));
 
-    const choice = await selectOption(ctx, summary, options);
+    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 === "Status") {
-      showStatus(orchestrator, ctx);
-      continue;
-    }
     if (choice === "Subagents") {
       await showSubagentsMenu(ctx);
       continue;
@@ -1179,17 +1192,95 @@ export async function showActiveTaskMenu(
       return "";
     }
 
-    if (choice === "Review in Plannotator" && isReviewPhase) {
-      const text = await openReviewTaskInPlannotator(orchestrator);
-      ctx.ui.notify(text, "info");
-      continue;
-    }
+    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;
+      }
 
-    finalizeReviewCycle(task);
+      if (reviewChoice === "Review on my own") {
+        if (phase === "plan") {
+          setStep(orchestrator, "synthesize");
+        } else {
+          setStep(orchestrator, "llm_work");
+        }
+        return continueMessage;
+      }
 
-    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)) {
+      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;
@@ -1201,15 +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;
-    }
   }
 }
 
@@ -1217,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;
 }

package/extensions/orchestrator/usage-tracker.ts

@@ -12,7 +12,7 @@ export interface ModelUsage {
 
 export interface UsageTracker {
   recordTurn(modelId: string, provider: string, input: number, output: number, cacheRead: number, cacheWrite: number, cost: number): void;
-  recordSubagentCompletion(tokens: { input?: number; output?: number; total?: number }, cost?: number, meta?: { description?: string; modelId?: string; durationMs?: number; toolUses?: number }): void;
+  recordSubagentCompletion(tokens: { input?: number; output?: number; total?: number }, cost?: number, meta?: { description?: string; agentType?: string; modelId?: string; durationMs?: number; toolUses?: number }): void;
   loadFromSummary(summary: Record<string, unknown>): void;
   getTotalInputTokens(): number;
   getTotalOutputTokens(): number;
@@ -29,6 +29,7 @@ export interface UsageTracker {
 
 export interface SubagentUsage {
   description: string;
+  agentType: string;
   modelId: string;
   inputTokens: number;
   outputTokens: number;
@@ -124,7 +125,7 @@ export function createUsageTracker(): UsageTracker {
     recordSubagentCompletion(
       tokens: { input?: number; output?: number; cacheRead?: number; cacheWrite?: number; total?: number; cost?: number },
       cost?: number,
-      meta?: { description?: string; modelId?: string; durationMs?: number; toolUses?: number },
+      meta?: { description?: string; agentType?: string; modelId?: string; durationMs?: number; toolUses?: number },
     ): void {
       const safeInput = toFiniteNumber(tokens.input);
       const safeOutput = toFiniteNumber(tokens.output);
@@ -141,6 +142,7 @@ export function createUsageTracker(): UsageTracker {
 
       state.subagents.push({
         description: meta?.description ?? "unknown",
+        agentType: meta?.agentType ?? "unknown",
         modelId: meta?.modelId ?? "unknown",
         inputTokens: effectiveInput,
         outputTokens: safeOutput,
@@ -168,6 +170,7 @@ export function createUsageTracker(): UsageTracker {
         for (const sa of summary.subagents as Record<string, unknown>[]) {
           const entry: SubagentUsage = {
             description: typeof sa.description === "string" ? sa.description : "unknown",
+            agentType: typeof sa.agentType === "string" ? sa.agentType : "unknown",
             modelId: typeof sa.modelId === "string" ? sa.modelId : "unknown",
             inputTokens: toFiniteNumber(sa.inputTokens),
             outputTokens: toFiniteNumber(sa.outputTokens),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ilya-lesikov/pi-pi",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Pi-Pi Coding Agent: based on Pi Coding Agent, but twice as good",
   "keywords": [
     "pi-package",