@ilya-lesikov/pi-pi 0.2.0 → 0.4.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/agents/brainstorm-reviewer.ts

@@ -51,7 +51,10 @@ export function createBrainstormReviewerAgent(
       "- SUGGESTIONS: (improvements, not required)",
       "- VERDICT: APPROVE or NEEDS_WORK (with reason)",
       "",
-      'You can spawn subagents: Agent(subagent_type="Explore", ...) for codebase, Agent(subagent_type="Librarian", ...) for external docs.',
+      "subagent_type is REQUIRED when spawning subagents — calls without it are rejected:",
+    '- Agent(subagent_type="Explore", ...) — codebase research. Prefer this for most lookups. Fast and cheap.',
+    '- Agent(subagent_type="Librarian", ...) — external docs, library APIs, web research.',
+    "Spawn multiple Explore agents in parallel for broad searches.",
       "",
       "# MANDATORY: Write your review to this exact file using the write tool:",
       `  ${outputPath}`,

package/extensions/orchestrator/agents/code-reviewer.ts

@@ -65,7 +65,10 @@ export function createCodeReviewerAgent(
       "- OPEN QUESTIONS: (low-confidence concerns, speculative follow-ups)",
       "- VERDICT: APPROVE or NEEDS_CHANGES",
       "",
-      'You can spawn subagents: Agent(subagent_type="Explore", ...) for codebase, Agent(subagent_type="Librarian", ...) for external docs.',
+      "subagent_type is REQUIRED when spawning subagents — calls without it are rejected:",
+    '- Agent(subagent_type="Explore", ...) — codebase research. Prefer this for most lookups. Fast and cheap.',
+    '- Agent(subagent_type="Librarian", ...) — external docs, library APIs, web research.',
+    "Spawn multiple Explore agents in parallel for broad searches.",
       "",
       // --- dynamic suffix ---
       "# MANDATORY: Write your review to this exact file using the write tool:",

package/extensions/orchestrator/agents/plan-reviewer.ts

@@ -51,7 +51,10 @@ export function createPlanReviewerAgent(
       "- SUGGESTIONS: (improvements, not required)",
       "- VERDICT: APPROVE or REJECT (with reason)",
       "",
-      'You can spawn subagents: Agent(subagent_type="Explore", ...) for codebase, Agent(subagent_type="Librarian", ...) for external docs.',
+      "subagent_type is REQUIRED when spawning subagents — calls without it are rejected:",
+    '- Agent(subagent_type="Explore", ...) — codebase research. Prefer this for most lookups. Fast and cheap.',
+    '- Agent(subagent_type="Librarian", ...) — external docs, library APIs, web research.',
+    "Spawn multiple Explore agents in parallel for broad searches.",
       "",
       // --- dynamic suffix ---
       "# MANDATORY OUTPUT",

package/extensions/orchestrator/agents/planner.ts

@@ -40,7 +40,10 @@ export function createPlannerAgent(
       "- No other top-level sections allowed",
       "- Describe outcomes, not code-level mechanics",
       "",
-      'You can spawn subagents: Agent(subagent_type="Explore", ...) for codebase, Agent(subagent_type="Librarian", ...) for external docs.',
+      "subagent_type is REQUIRED when spawning subagents — calls without it are rejected:",
+    '- Agent(subagent_type="Explore", ...) — codebase research. Prefer this for most lookups. Fast and cheap.',
+    '- Agent(subagent_type="Librarian", ...) — external docs, library APIs, web research.',
+    "Spawn multiple Explore agents in parallel for broad searches.",
       "",
       // --- dynamic suffix ---
       "# MANDATORY OUTPUT",

package/extensions/orchestrator/agents/task.ts

@@ -28,8 +28,10 @@ export function createTaskAgent(
       FAILURE_RECOVERY,
       "",
       "# Constraints",
-      "- Do NOT spawn task subagents (no recursion)",
-      '- You CAN spawn subagents: Agent(subagent_type="Explore", ...) for codebase, Agent(subagent_type="Librarian", ...) for external docs',
+    "- Do NOT spawn task subagents (no recursion)",
+    "- subagent_type is REQUIRED when spawning subagents — calls without it are rejected:",
+    '  Agent(subagent_type="Explore", ...) — codebase research. Prefer this for most lookups. Fast and cheap.',
+    '  Agent(subagent_type="Librarian", ...) — external docs, library APIs, web research.',
       "- Focus only on your subtask — do not modify unrelated code",
       "- Before modifying a function, use lsp findReferences to understand all callers",
       "- After editing files, run lsp diagnostics and fix errors before moving on",

package/extensions/orchestrator/command-handlers.ts

@@ -109,7 +109,7 @@ export function registerCommandHandlers(orchestrator: Orchestrator): void {
       const { showPpMenu } = await import("./pp-menu.js");
       const text = await showPpMenu(orchestrator, ctx, "command");
       if (text) {
-        pi.sendUserMessage(`[PI-PI] ${text}`);
+        pi.sendUserMessage(`[PI-PI] ${text}`, { deliverAs: "followUp" });
       }
     },
   });

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,
@@ -927,7 +943,10 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
     if (event.toolName === "Agent" && orchestrator.active) {
       const input = event.input as Record<string, unknown>;
       const requestedType = ((input.subagent_type as string) || "").toLowerCase();
-      const isExplore = !requestedType || requestedType === "explore";
+      if (!requestedType) {
+        return { block: true, reason: "subagent_type is required. Use Explore for codebase research, Librarian for external docs, or Task for implementation subtasks." };
+      }
+      const isExplore = requestedType === "explore";
       const isLibrarian = requestedType === "librarian";
 
       if (isExplore) {
@@ -1167,7 +1186,7 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
         orchestrator.pendingRetryTimer = setTimeout(() => {
           orchestrator.pendingRetryTimer = null;
           if (orchestrator.activeTaskToken !== taskToken || !orchestrator.active) return;
-          pi.sendUserMessage(`[PI-PI] Previous request failed due to an API error. Continue working on the current phase (${phase}).`);
+          pi.sendUserMessage(`[PI-PI] Previous request failed due to an API error. Continue working on the current phase (${phase}).`, { deliverAs: "followUp" });
         }, delay);
       } else {
         ctx.ui.notify(`API error persisted after 3 retries: ${errorMsg}. Stopping auto-retry.`, "error");
@@ -1202,7 +1221,7 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
                 orchestrator.pendingSubagentSpawns = 0;
                 orchestrator.active.state.step = "synthesize";
                 saveTask(orchestrator.active.dir, orchestrator.active.state);
-                pi.sendUserMessage("[PI-PI] All planners completed. Read their outputs and synthesize the plan.");
+                pi.sendUserMessage("[PI-PI] All planners completed. Read their outputs and synthesize the plan.", { deliverAs: "followUp" });
               }
             }
           } else if (orchestrator.active.state.step === "await_reviewers" && orchestrator.active.state.reviewCycle) {
@@ -1233,7 +1252,7 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
                 { customType: "pp-review-ready", content: `[PI-PI] Reviewer outputs are ready.\n\n${rendered}`, display: false },
                 { deliverAs: "followUp" },
               );
-              pi.sendUserMessage("[PI-PI] Review cycle is ready for apply_feedback. Read reviewer outputs and proceed.");
+              pi.sendUserMessage("[PI-PI] Review cycle is ready for apply_feedback. Read reviewer outputs and proceed.", { deliverAs: "followUp" });
             }
           } else {
             clearInterval(orchestrator.awaitPollTimer!);
@@ -1258,7 +1277,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

@@ -344,7 +344,7 @@ export class Orchestrator {
     } else if (isWaitingForPlanners) {
       ctx.ui.notify("Entered plan phase. Waiting for planners to complete before synthesis.", "info");
     } else {
-      this.pi.sendUserMessage(`[PI-PI] Entered ${this.active.state.phase} phase. Begin working.`);
+      this.pi.sendUserMessage(`[PI-PI] Entered ${this.active.state.phase} phase. Begin working.`, { deliverAs: "followUp" });
     }
 
     if (this.active.state.phase === "plan" && this.active.state.step === "await_planners") {
@@ -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,11 +476,15 @@ 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");
         } else {
-          this.pi.sendUserMessage(`[PI-PI] Entered ${phase} phase. Begin working.`);
+          this.pi.sendUserMessage(`[PI-PI] Entered ${phase} phase. Begin working.`, { deliverAs: "followUp" });
         }
       },
       onError: (err) => {
@@ -484,11 +495,15 @@ 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");
         } else {
-          this.pi.sendUserMessage(`[PI-PI] Entered ${phase} phase. Begin working.`);
+          this.pi.sendUserMessage(`[PI-PI] Entered ${phase} phase. Begin working.`, { deliverAs: "followUp" });
         }
       },
     });

package/extensions/orchestrator/phases/brainstorm.ts

@@ -22,7 +22,11 @@ export function brainstormSystemPrompt(taskType: TaskType, taskDescription: stri
     "",
     "# Your job:",
     "1. Clarify the problem with the user if needed",
-    '2. Spawn explore subagents via Agent(subagent_type="Explore", ...) for codebase research',
+    "2. Spawn subagents for research (subagent_type is REQUIRED — calls without it are rejected):",
+    '   - Agent(subagent_type="Explore", ...) — codebase research. Prefer this for most lookups.',
+    '   - Agent(subagent_type="Librarian", ...) — external docs, library APIs, web research.',
+    '   - Agent(subagent_type="Task", ...) — only when you need a subtask that writes files or runs complex multi-step commands.',
+    "   Explore is fast and cheap. Use it liberally for codebase questions. Spawn multiple in parallel.",
     "3. Use bash to run commands, check logs, reproduce issues",
     "4. Use tools to trace the bug:",
     "   - cbm_search/cbm_search_code: find relevant code by concept or text",
@@ -31,8 +35,6 @@ export function brainstormSystemPrompt(taskType: TaskType, taskDescription: stri
     "   - lsp diagnostics: find type errors",
     "   - cbm_trace: trace call chains to/from suspect functions",
     "   - ast_search: find structural patterns (e.g. error handling, goroutines)",
-      "",
-      "IMPORTANT: Always specify subagent_type. Use Explore for codebase, Librarian for external docs.",
       "",
       "Produce two files:",
       `- ${taskDir}/USER_REQUEST.md — the fix request. MUST follow this exact structure:`,
@@ -76,8 +78,11 @@ export function brainstormSystemPrompt(taskType: TaskType, taskDescription: stri
       "",
       "# How to work:",
       "- Discuss the topic with the user. Ask clarifying questions. Propose approaches. Analyze tradeoffs.",
-      '- Spawn subagents for research: Agent(subagent_type="Explore", ...) for codebase, Agent(subagent_type="Librarian", ...) for external docs.',
-      "  IMPORTANT: Always specify subagent_type. Do NOT omit it.",
+    "- Spawn subagents for research (subagent_type is REQUIRED — calls without it are rejected):",
+    '  Agent(subagent_type="Explore", ...) — codebase research. Prefer this for most lookups. Fast and cheap.',
+    '  Agent(subagent_type="Librarian", ...) — external docs, library APIs, web research.',
+    '  Agent(subagent_type="Task", ...) — only when you need a subtask that writes files or runs complex multi-step commands.',
+    "  Spawn multiple Explore agents in parallel for broad searches.",
       "- Use tools directly for quick lookups (cbm_search, lsp, ast_search, grep, etc.)",
       "- Present findings to the user and discuss them. Don't just dump raw results.",
       "- Do NOT modify project source code.",
@@ -120,18 +125,19 @@ export function brainstormSystemPrompt(taskType: TaskType, taskDescription: stri
     "",
     "# Steps:",
     "1. Clarify requirements with the user if anything is ambiguous",
-    '2. Spawn explore subagents via Agent(subagent_type="Explore", ...) for codebase research',
-    '3. Spawn librarian subagents via Agent(subagent_type="Librarian", ...) for external docs/library research',
-    "4. Use tools to understand code structure:",
+    "2. Spawn subagents for research (subagent_type is REQUIRED — calls without it are rejected):",
+    '   - Agent(subagent_type="Explore", ...) — codebase research. Prefer this for most lookups. Fast and cheap.',
+    '   - Agent(subagent_type="Librarian", ...) — external docs, library APIs, web research.',
+    '   - Agent(subagent_type="Task", ...) — only when you need a subtask that writes files or runs complex multi-step commands.',
+    "   Spawn multiple Explore agents in parallel for broad searches.",
+    "3. Use tools to understand code structure:",
     "   - cbm_search: natural-language search across all symbols",
     "   - cbm_search_code: graph-augmented grep (deduplicates into functions)",
     "   - lsp documentSymbol, goToDefinition, findReferences, goToImplementation, hover",
     "   - cbm_trace: trace call chains for dependency understanding",
     "   - ast_search: find structural patterns across the codebase",
-    "5. Ask the user follow-up questions as needed",
-    "6. Write findings into RESEARCH.md as results come back — don't wait for all subagents",
-    "",
-    "IMPORTANT: Always specify subagent_type. Use Explore for codebase, Librarian for external docs.",
+    "4. Ask the user follow-up questions as needed",
+    "5. Write findings into RESEARCH.md as results come back — don't wait for all subagents",
     "",
     "Produce two files:",
     `- ${taskDir}/USER_REQUEST.md — MUST follow this exact structure:`,

package/extensions/orchestrator/phases/implementation.ts

@@ -22,9 +22,11 @@ export function implementationSystemPrompt(taskDir: string): string {
     "   - cbm_trace: trace dependencies across the codebase",
     "   - ast_search: find structural patterns (e.g. error handling conventions)",
     "6. After completing changes, run cbm_changes to verify blast radius",
-    '7. For parallelizable, self-contained subtasks, delegate via Agent(subagent_type="Task", ...)',
-    '8. For codebase research, use Agent(subagent_type="Explore", ...)',
-    '9. For external docs research, use Agent(subagent_type="Librarian", ...)',
+    "7. Spawn subagents as needed (subagent_type is REQUIRED — calls without it are rejected):",
+    '   - Agent(subagent_type="Explore", ...) — codebase research. Prefer this for most lookups. Fast and cheap.',
+    '   - Agent(subagent_type="Librarian", ...) — external docs, library APIs, web research.',
+    '   - Agent(subagent_type="Task", ...) — parallelizable, self-contained implementation subtasks.',
+    "   Spawn multiple Explore agents in parallel for broad searches.",
     "",
     "If a fix fails 3 times, STOP and re-plan the approach — do not keep pushing.",
     "",

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

@@ -10,6 +10,11 @@ export function reviewSystemPrompt(taskDir: string): string {
     "- read, lsp, grep, find for understanding the code",
     "- gh pr view for GitHub PR context if a PR URL is mentioned",
     "",
+    "Spawn subagents as needed (subagent_type is REQUIRED — calls without it are rejected):",
+    '- Agent(subagent_type="Explore", ...) — codebase research. Prefer this for most lookups. Fast and cheap.',
+    '- Agent(subagent_type="Librarian", ...) — external docs, library APIs, web research.',
+    "Spawn multiple Explore agents in parallel for broad searches.",
+    "",
     "Write your findings:",
     `- ${taskDir}/USER_REQUEST.md — update with a clear problem statement of issues found`,
     `- ${taskDir}/RESEARCH.md — detailed technical analysis`,

package/extensions/orchestrator/pp-menu.ts

@@ -344,9 +344,9 @@ export async function resumeTask(
   if (step === "await_planners" || step === "await_reviewers") {
     ctx.ui.notify(`Resumed task. Awaiting subagents (${step}).`, "info");
   } else if (step === "apply_feedback") {
-    pi.sendUserMessage(`[PI-PI] Resumed ${orchestrator.active.state.phase} phase. Read reviewer outputs and apply feedback.`);
+    pi.sendUserMessage(`[PI-PI] Resumed ${orchestrator.active.state.phase} phase. Read reviewer outputs and apply feedback.`, { deliverAs: "followUp" });
   } else {
-    pi.sendUserMessage(`[PI-PI] Resumed ${orchestrator.active.state.phase} phase. Continue working.`);
+    pi.sendUserMessage(`[PI-PI] Resumed ${orchestrator.active.state.phase} phase. Continue working.`, { deliverAs: "followUp" });
   }
 
   return { ok: true };
@@ -591,8 +591,11 @@ function showUsage(ctx: any): void {
         getTotalInputTokens(): number; getTotalOutputTokens(): number;
         getTotalCacheReadTokens(): number; getTotalCacheWriteTokens(): number;
         getTotalCost(): number; getCacheHitRate(): number;
+        getMainInputTokens(): number; getMainOutputTokens(): number;
+        getMainCacheReadTokens(): number; getMainCacheWriteTokens(): number;
+        getMainCost(): 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;
 
@@ -601,44 +604,34 @@ function showUsage(ctx: any): void {
     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 totalInput = tracker.getTotalInputTokens();
+  const totalOutput = tracker.getTotalOutputTokens();
+  const totalCacheRead = tracker.getTotalCacheReadTokens();
+  const totalCost = tracker.getTotalCost();
   const totalCacheRate = (totalCacheRead + totalInput) > 0
     ? totalCacheRead / (totalCacheRead + totalInput)
     : 0;
 
+  const mainInput = tracker.getMainInputTokens();
+  const mainOutput = tracker.getMainOutputTokens();
+  const mainCacheRead = tracker.getMainCacheReadTokens();
+  const mainCost = tracker.getMainCost();
+  const models = tracker.getPerModelUsage();
+  const subagents = tracker.getSubagentList();
+
   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 +651,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 +660,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 +711,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 +724,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 +896,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 +1128,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 +1185,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";
+        }
 
-    finalizeReviewCycle(task);
+        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;
+      }
 
-    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 +1285,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 +1292,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,13 +12,18 @@ 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;
   getTotalCacheReadTokens(): number;
   getTotalCacheWriteTokens(): number;
   getTotalCost(): number;
+  getMainInputTokens(): number;
+  getMainOutputTokens(): number;
+  getMainCacheReadTokens(): number;
+  getMainCacheWriteTokens(): number;
+  getMainCost(): number;
   getCacheHitRate(): number;
   getPerModelUsage(): Record<string, ModelUsage>;
   getSubagentTotals(): { inputTokens: number; outputTokens: number; cost: number };
@@ -29,6 +34,7 @@ export interface UsageTracker {
 
 export interface SubagentUsage {
   description: string;
+  agentType: string;
   modelId: string;
   inputTokens: number;
   outputTokens: number;
@@ -124,7 +130,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 +147,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 +175,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),
@@ -200,11 +208,11 @@ export function createUsageTracker(): UsageTracker {
     },
 
     getTotalInputTokens(): number {
-      return state.totalInputTokens;
+      return state.totalInputTokens + state.subagentInputTokens;
     },
 
     getTotalOutputTokens(): number {
-      return state.totalOutputTokens;
+      return state.totalOutputTokens + state.subagentOutputTokens;
     },
 
     getTotalCacheReadTokens(): number {
@@ -216,13 +224,35 @@ export function createUsageTracker(): UsageTracker {
     },
 
     getTotalCost(): number {
+      return state.totalCost + state.subagentCost;
+    },
+
+    getMainInputTokens(): number {
+      return state.totalInputTokens;
+    },
+
+    getMainOutputTokens(): number {
+      return state.totalOutputTokens;
+    },
+
+    getMainCacheReadTokens(): number {
+      return state.totalCacheReadTokens;
+    },
+
+    getMainCacheWriteTokens(): number {
+      return state.totalCacheWriteTokens;
+    },
+
+    getMainCost(): number {
       return state.totalCost;
     },
 
     getCacheHitRate(): number {
-      const denominator = state.totalCacheReadTokens + state.totalInputTokens;
+      const totalInput = state.totalInputTokens + state.subagentInputTokens;
+      const totalCacheRead = state.totalCacheReadTokens;
+      const denominator = totalCacheRead + totalInput;
       if (denominator <= 0) return 0;
-      return state.totalCacheReadTokens / denominator;
+      return totalCacheRead / denominator;
     },
 
     getPerModelUsage(): Record<string, ModelUsage> {

package/package.json

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