@ilya-lesikov/pi-pi 0.3.0 → 0.5.0

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

@@ -72,15 +72,15 @@ export async function transitionToNextPhase(
   }
 
   orchestrator.updateStatus(ctx);
+  orchestrator.phaseCompactionSummary = `Phase "${currentPhase}" completed. Now entering "${next}" phase.`;
 
   if (next === "plan") {
     orchestrator.active.state.step = "await_planners";
     saveTask(orchestrator.active.dir, orchestrator.active.state);
   }
 
-  orchestrator.compactAndTransition(ctx, orchestrator.active.dir, orchestrator.active.state.phase);
-
-  if (next === "plan") {
+  const onReady = next === "plan" ? () => {
+    if (!orchestrator.active) return;
     orchestrator.pendingSubagentSpawns = Object.values(orchestrator.config.planners).filter((v) => v.enabled).length;
     orchestrator.failedPlannerVariants = [];
     spawnPlanners(orchestrator.pi, orchestrator.cwd, orchestrator.active.dir, orchestrator.active.taskId, orchestrator.config).then((result) => {
@@ -94,7 +94,9 @@ export async function transitionToNextPhase(
       orchestrator.pendingSubagentSpawns = 0;
       console.error(`[pi-pi] spawnPlanners failed: ${err.message}`);
     });
-  }
+  } : undefined;
+
+  orchestrator.compactAndTransition(ctx, orchestrator.active.dir, orchestrator.active.state.phase, onReady);
 
   return { ok: true };
 }
@@ -109,7 +111,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}`);
+        orchestrator.safeSendUserMessage(`[PI-PI] ${text}`);
       }
     },
   });

package/extensions/orchestrator/event-handlers.ts

@@ -94,7 +94,7 @@ function tryCompleteReviewCycle(orchestrator: Orchestrator): void {
     },
     { deliverAs: "followUp" },
   );
-  pi.sendUserMessage("[PI-PI] Review cycle is ready for apply_feedback. Read reviewer outputs and proceed.", { deliverAs: "followUp" });
+  orchestrator.safeSendUserMessage("[PI-PI] Review cycle is ready for apply_feedback. Read reviewer outputs and proceed.");
 }
 
 export async function enterReviewCycle(orchestrator: Orchestrator, ctx: any, kind: "auto" | "auto-deep" | "plannotator") {
@@ -204,13 +204,12 @@ export async function enterReviewCycle(orchestrator: Orchestrator, ctx: any, kin
 export async function stopTask(orchestrator: Orchestrator): Promise<string> {
   if (!orchestrator.active) return "No active task.";
   orchestrator.abortAllSubagents();
-  orchestrator.active.state.phase = "done";
   saveTask(orchestrator.active.dir, orchestrator.active.state);
   const desc = orchestrator.active.description;
   await orchestrator.cleanupActive();
   const taskStore = (globalThis as any)[Symbol.for("pi-tasks:store")];
   taskStore?.clearAll?.();
-  return `Task "${desc}" stopped.`;
+  return `Task "${desc}" stopped. Use /pp → Resume to continue.`;
 }
 
 export function finalizeReviewCycle(task: ActiveTask): void {
@@ -311,8 +310,8 @@ 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) {
-          await orchestrator.waitForCompaction();
-          return { content: [{ type: "text" as const, text: "Phase transition complete." }], details: {} };
+          ctx.abort?.();
+          return { content: [{ type: "text" as const, text: "" }], details: {} };
         }
         if (!text) {
           return { content: [{ type: "text" as const, text: "User dismissed the menu. Wait for the user's next message. When you resume work, update USER_REQUEST.md and RESEARCH.md with any new findings before calling pp_phase_complete." }], details: {} };
@@ -409,8 +408,8 @@ 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) {
-          await orchestrator.waitForCompaction();
-          return { content: [{ type: "text" as const, text: "Phase transition complete." }], details: {} };
+          ctx.abort?.();
+          return { content: [{ type: "text" as const, text: "" }], details: {} };
         }
         if (!text) {
           return { content: [{ type: "text" as const, text: "User dismissed the menu. Wait for the user's next message. When you resume work, update USER_REQUEST.md and RESEARCH.md with any new findings before calling pp_phase_complete." }], details: {} };
@@ -545,7 +544,8 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
       orchestrator.active.state.phase !== "plan" ||
       orchestrator.active.state.step !== "await_planners" ||
       orchestrator.spawnedAgentIds.size > 0 ||
-      orchestrator.pendingSubagentSpawns > 0
+      orchestrator.pendingSubagentSpawns > 0 ||
+      orchestrator.phaseCompactionPending
     ) return;
 
     const plansDir = join(orchestrator.active.dir, "plans");
@@ -594,13 +594,13 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
                 console.error(`[pi-pi] retry spawnPlanners failed: ${err.message}`);
                 checkPlannerCompletion();
               });
-              pi.sendUserMessage(`[PI-PI] Retrying failed planners: ${variantsText}.`, { deliverAs: "followUp" });
+              orchestrator.safeSendUserMessage(`[PI-PI] Retrying failed planners: ${variantsText}.`);
               return;
             }
           }
 
           if (choice === "Stop task") {
-            pi.sendUserMessage(`[PI-PI] ${await stopTask(orchestrator)}`, { deliverAs: "followUp" });
+            orchestrator.safeSendUserMessage(`[PI-PI] ${await stopTask(orchestrator)}`);
             return;
           }
 
@@ -632,7 +632,7 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
     orchestrator.failedPlannerVariants = [];
     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.", { deliverAs: "followUp" });
+    orchestrator.safeSendUserMessage("[PI-PI] All planners completed. Read their outputs and synthesize the plan.");
   }
 
   function checkReviewCycleCompletion(): void {
@@ -640,7 +640,8 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
       !orchestrator.active?.state.reviewCycle ||
       orchestrator.active.state.reviewCycle.step !== "await_reviewers" ||
       orchestrator.spawnedAgentIds.size > 0 ||
-      orchestrator.pendingSubagentSpawns > 0
+      orchestrator.pendingSubagentSpawns > 0 ||
+      orchestrator.phaseCompactionPending
     ) return;
 
     const failedReviewerVariants = [...orchestrator.failedReviewerVariants];
@@ -705,14 +706,14 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
                   console.error(`[pi-pi] retry spawn reviewers failed (${phase}): ${err.message}`);
                   checkReviewCycleCompletion();
                 });
-                pi.sendUserMessage(`[PI-PI] Retrying failed reviewers: ${variantsText}.`, { deliverAs: "followUp" });
+                orchestrator.safeSendUserMessage(`[PI-PI] Retrying failed reviewers: ${variantsText}.`);
                 return;
               }
             }
           }
 
           if (choice === "Stop task") {
-            pi.sendUserMessage(`[PI-PI] ${await stopTask(orchestrator)}`, { deliverAs: "followUp" });
+            orchestrator.safeSendUserMessage(`[PI-PI] ${await stopTask(orchestrator)}`);
             return;
           }
 
@@ -722,7 +723,7 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
             orchestrator.active.state.reviewCycle = null;
             orchestrator.active.state.step = "user_gate";
             saveTask(orchestrator.active.dir, orchestrator.active.state);
-            pi.sendUserMessage("[PI-PI] Review cycle skipped. Use /pp to choose the next action.", { deliverAs: "followUp" });
+            orchestrator.safeSendUserMessage("[PI-PI] Review cycle skipped. Use /pp to choose the next action.");
             return;
           }
 
@@ -943,7 +944,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) {
@@ -1096,9 +1100,11 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
     if (!orchestrator.active || orchestrator.active.state.phase === "done") return;
 
     if (orchestrator.phaseCompactionPending) {
+      const summary = orchestrator.phaseCompactionSummary || "Phase transition in progress.";
+      orchestrator.phaseCompactionSummary = "";
       return {
         compaction: {
-          summary: `Previous phase (${orchestrator.active.state.phase}) completed. Transitioning to next phase.`,
+          summary,
           firstKeptEntryId: event.preparation.firstKeptEntryId,
           tokensBefore: event.preparation.tokensBefore,
         },
@@ -1140,6 +1146,7 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
     }
 
     if (!orchestrator.active || orchestrator.active.state.phase === "done") return;
+    if (orchestrator.phaseCompactionPending || orchestrator.taskDoneCompactionPending) return;
     orchestrator.updateStatus(ctx);
 
     if (
@@ -1183,7 +1190,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}).`);
+          orchestrator.safeSendUserMessage(`[PI-PI] Previous request failed due to an API error. Continue working on the current phase (${phase}).`);
         }, delay);
       } else {
         ctx.ui.notify(`API error persisted after 3 retries: ${errorMsg}. Stopping auto-retry.`, "error");
@@ -1205,6 +1212,7 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
             orchestrator.awaitPollTimer = null;
             return;
           }
+          if (orchestrator.phaseCompactionPending) return;
           const taskDir = orchestrator.active.dir;
           if (orchestrator.active.state.step === "await_planners") {
             const plansDir = join(taskDir, "plans");
@@ -1218,7 +1226,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.");
+                orchestrator.safeSendUserMessage("[PI-PI] All planners completed. Read their outputs and synthesize the plan.");
               }
             }
           } else if (orchestrator.active.state.step === "await_reviewers" && orchestrator.active.state.reviewCycle) {
@@ -1249,7 +1257,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.");
+              orchestrator.safeSendUserMessage("[PI-PI] Review cycle is ready for apply_feedback. Read reviewer outputs and proceed.");
             }
           } else {
             clearInterval(orchestrator.awaitPollTimer!);
@@ -1278,19 +1286,16 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
       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(
-            {
-              customType: "pp-phase-complete-reminder",
-              content: `[PI-PI] You stopped without calling pp_phase_complete. If you are done with the ${phase} phase, call pp_phase_complete now. If not, continue working.`,
-              display: false,
-            },
-            { deliverAs: "followUp" },
-          );
+        if (step !== "await_planners" && step !== "await_reviewers" && !orchestrator.textStopReminderSent) {
+          orchestrator.textStopReminderSent = true;
+          orchestrator.safeSendUserMessage(`[PI-PI] You stopped without calling pp_phase_complete. If you are done with the ${phase} phase, call pp_phase_complete now. If not, continue working.`);
         }
+      } else {
+        orchestrator.textStopReminderSent = false;
       }
       return;
     }
+    orchestrator.textStopReminderSent = false;
     if (orchestrator.nudgeHalted) return;
     if (orchestrator.spawnedAgentIds.size > 0 || orchestrator.pendingSubagentSpawns > 0) return;
 
@@ -1303,14 +1308,7 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
     orchestrator.nudgeTimestamps = orchestrator.nudgeTimestamps.filter((t) => now - t < 60000);
 
     const sendNudge = () => {
-      pi.sendMessage(
-        {
-          customType: "pp-continuation",
-          content: `[PI-PI] Your previous response was interrupted. Continue working on the current phase (${phase}). Pick up where you left off.`,
-          display: false,
-        },
-        { deliverAs: "followUp" },
-      );
+      orchestrator.safeSendUserMessage(`[PI-PI] Your previous response was interrupted. Continue working on the current phase (${phase}). Pick up where you left off.`);
     };
 
     if (orchestrator.nudgeTimestamps.length <= 3) {

package/extensions/orchestrator/orchestrator.ts

@@ -7,6 +7,7 @@ import {
   loadTask,
   saveTask,
   lockTask,
+  appendTaskLog,
   type TaskType,
   type TaskState,
   type Phase,
@@ -60,7 +61,7 @@ export class Orchestrator {
   }>();
   staleAgentTimer: ReturnType<typeof setInterval> | null = null;
   phaseCompactionPending = false;
-  phaseCompactionResolve: (() => void) | null = null;
+  phaseCompactionSummary = "";
   taskDoneCompactionPending = false;
   taskDoneCompactionSummary = "";
   nudgeTimestamps: number[] = [];
@@ -69,6 +70,7 @@ export class Orchestrator {
   pendingSubagentSpawns = 0;
   errorRetryCount = 0;
   commitReminderSent = false;
+  textStopReminderSent = false;
   phaseStartTime = 0;
   awaitPollTimer: ReturnType<typeof setInterval> | null = null;
   pendingRetryTimer: ReturnType<typeof setTimeout> | null = null;
@@ -86,6 +88,25 @@ export class Orchestrator {
 
   constructor(readonly pi: ExtensionAPI) {}
 
+  safeSendUserMessage(text: string): void {
+    const log = (event: string, extra?: Record<string, unknown>) => {
+      if (this.active) appendTaskLog(this.active.dir, "debug.jsonl", { timestamp: new Date().toISOString(), event, text: text.slice(0, 200), ...extra });
+    };
+    const attempt = (retries: number) => {
+      try {
+        this.pi.sendUserMessage(text);
+        log("safeSend_sent", { retries });
+      } catch (err: any) {
+        if (retries < 30) {
+          setTimeout(() => attempt(retries + 1), 1000);
+        } else {
+          log("safeSend_failed", { error: err?.message ?? String(err), retries });
+        }
+      }
+    };
+    attempt(0);
+  }
+
   truncateResult(result: string): string {
     const trimmed = result.trim();
     if (!trimmed) return "";
@@ -247,11 +268,10 @@ export class Orchestrator {
   ): Promise<void> {
     if (this.active) {
       ctx.ui.notify(
-        `Finishing previous task "${this.active.description}" (phase: ${this.active.state.phase})…`,
+        `Pausing previous task "${this.active.description}" (phase: ${this.active.state.phase})…`,
         "info",
       );
       this.abortAllSubagents();
-      this.active.state.phase = "done";
       saveTask(this.active.dir, this.active.state);
       unregisterAgentDefinitions(this.pi);
       await this.cleanupActive();
@@ -344,7 +364,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.safeSendUserMessage(`[PI-PI] Entered ${this.active.state.phase} phase. Begin working.`);
     }
 
     if (this.active.state.phase === "plan" && this.active.state.step === "await_planners") {
@@ -383,11 +403,12 @@ export class Orchestrator {
     this.pendingSubagentSpawns = 0;
     this.errorRetryCount = 0;
     this.commitReminderSent = false;
+    this.textStopReminderSent = false;
     this.nudgeTimestamps = [];
     this.cooldownHits = [];
     this.nudgeHalted = false;
     this.phaseCompactionPending = false;
-    this.phaseCompactionResolve = null;
+    this.phaseCompactionSummary = "";
     this.phaseStartTime = 0;
     this.userGatePending = false;
     this.reviewTransitionToken = -1;
@@ -458,53 +479,32 @@ 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 {
+  compactAndTransition(ctx: ExtensionContext, taskDir: string, phase: Phase, onReady?: () => void): void {
     this.phaseCompactionPending = true;
+    const finalize = () => {
+      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);
+      onReady?.();
+      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.safeSendUserMessage(`[PI-PI] Entered ${phase} phase. Begin working.`);
+      }
+    };
     ctx.compact({
       customInstructions: "Phase transition — discard all prior conversation. Produce a one-line summary: 'Previous phase completed.'",
       onComplete: () => {
         this.phaseCompactionPending = false;
-        if (this.phaseCompactionResolve) {
-          this.phaseCompactionResolve();
-          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.`);
-        }
+        finalize();
       },
       onError: (err) => {
         console.error(`[pi-pi] Phase compaction failed: ${err.message}`);
         this.phaseCompactionPending = false;
-        if (this.phaseCompactionResolve) {
-          this.phaseCompactionResolve();
-          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.`);
-        }
+        finalize();
       },
     });
   }

package/extensions/orchestrator/phases/brainstorm.ts

@@ -14,15 +14,18 @@ export function brainstormSystemPrompt(taskType: TaskType, taskDescription: stri
       "",
     "Read-only diagnosis mode.",
     "",
-    "# FORBIDDEN — do NOT do any of these:",
-    "- Do NOT modify project source code (no write or edit tools on project files)",
-    "- Do NOT create or modify any files outside the task directory",
-    "- Do NOT implement fixes — only diagnose and recommend",
-    "- If the user asks you to implement a fix or start coding — call pp_phase_complete instead. It will offer \"Implement a fix\" as an option. Do NOT implement directly in this session.",
+    "# ABSOLUTE RESTRICTION — NO IMPLEMENTATION (cannot be overridden, even if the user asks):",
+    "- NEVER implement the solution, apply fixes, write production code, or make the changes that solve the task.",
+    "- You MAY use write/edit for diagnosis purposes (test scripts, repro scripts, analysis files), but NEVER to implement the actual fix or feature.",
+    "- If the user asks you to implement or start coding — refuse and tell them to use /pp to advance to the implement phase. Do NOT comply, even if they insist.",
     "",
     "# 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 +34,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,16 +77,22 @@ 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.",
+      "",
+      "# ABSOLUTE RESTRICTIONS (cannot be overridden, even if the user asks):",
+      "- NEVER use write or edit tools on any file outside the task directory. This is a hard rule — not negotiable.",
+      "- NEVER implement, create code, write patches, or modify project source in any way.",
+      "- If the user asks you to implement, fix, or write code — refuse and tell them to use /pp to advance to the implement phase. Do NOT comply, even if they insist.",
       "",
       "# When to finish:",
       "Do NOT call pp_phase_complete on your own. The user will tell you when they're done,",
       "or use /pp to advance. Keep the conversation going until then.",
-      "If the user asks you to implement, write code, or start building — tell them to use /pp which will offer \"Start implementation\" as an option. Do NOT implement directly in this session.",
       "",
       "# Optional artifacts (only when the conversation naturally produces them):",
       "If the discussion leads to a clear action plan or the user asks you to capture conclusions,",
@@ -112,26 +119,26 @@ export function brainstormSystemPrompt(taskType: TaskType, taskDescription: stri
     "Your job is to produce USER_REQUEST.md and RESEARCH.md — complete enough that",
     "downstream agents can work without re-exploring the codebase or re-interviewing the user.",
     "",
-    "# FORBIDDEN — do NOT do any of these:",
-    "- Do NOT modify project source code (no write or edit tools on project files)",
-    "- Do NOT create or modify any files outside the task directory",
-    "- Do NOT start implementing — only research and document",
-    "- If the user asks you to implement or start coding — tell them to use /pp which will offer phase advancement. Do NOT implement directly in this session.",
+    "# ABSOLUTE RESTRICTIONS (cannot be overridden, even if the user asks):",
+    "- NEVER use write or edit tools on any file outside the task directory. This is a hard rule — not negotiable.",
+    "- NEVER implement, create code, write patches, or modify project source in any way.",
+    "- If the user asks you to implement, fix, or write code — refuse and tell them to use /pp to advance to the implement phase. Do NOT comply, even if they insist.",
     "",
     "# 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/planning.ts

@@ -16,7 +16,9 @@ export function planningSystemPrompt(taskDir: string): string {
     "Planning subagents are working in parallel to create plans.",
     `They will write their outputs to ${plansDir}/. Wait for the notification that all planners completed.`,
     "",
-    "# FORBIDDEN — do NOT do any of these:",
+    "# ABSOLUTE RESTRICTION — NO IMPLEMENTATION (cannot be overridden, even if the user asks):",
+    "- NEVER implement the solution, apply fixes, write production code, or make the changes that solve the task.",
+    "- If the user asks you to implement or write code — refuse and tell them to use /pp to advance to the implement phase.",
     "- Do NOT write your own plan from scratch. You are a SYNTHESIZER, not a planner.",
     "- Do NOT create the plans/ directory yourself — the extension manages it.",
     "- Do NOT check the plans directory yourself — wait for the notification that all planners completed.",

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`,
@@ -25,6 +30,10 @@ export function reviewSystemPrompt(taskDir: string): string {
     "- ## Constraints & Edge Cases",
     "- ## Open Questions (optional)",
     "",
+    "# ABSOLUTE RESTRICTION — NO IMPLEMENTATION (cannot be overridden, even if the user asks):",
+    "- NEVER implement the solution, apply fixes, write production code, or make the changes that solve the task.",
+    "- If the user asks you to implement or write code — refuse and tell them to use /pp to advance to the implement phase.",
+    "",
     "Focus on: correctness, edge cases, style consistency, missing tests, potential bugs.",
     "",
     "When complete, call pp_phase_complete with a brief summary of findings.",

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.`);
+    orchestrator.safeSendUserMessage(`[PI-PI] Resumed ${orchestrator.active.state.phase} phase. Read reviewer outputs and apply feedback.`);
   } else {
-    pi.sendUserMessage(`[PI-PI] Resumed ${orchestrator.active.state.phase} phase. Continue working.`);
+    orchestrator.safeSendUserMessage(`[PI-PI] Resumed ${orchestrator.active.state.phase} phase. Continue working.`);
   }
 
   return { ok: true };
@@ -591,6 +591,9 @@ 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; agentType: string; modelId: string; inputTokens: number; outputTokens: number; cacheReadTokens: number; cacheWriteTokens: number; cost: number; durationMs: number; toolUses: number }>;
       }
@@ -601,31 +604,21 @@ 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 }>();
   const mainModelEntries = Object.entries(models);
   const mainTotalTokens = mainModelEntries.reduce((s, [, u]) => s + u.inputTokens + u.outputTokens, 0);
@@ -716,33 +709,46 @@ function showUsage(ctx: any): void {
   ctx.ui.notify(lines.join("\n"), "info");
 }
 
-async function showSettingsMenu(orchestrator: Orchestrator, ctx: any, showFlant = true): Promise<typeof BACK> {
+async function showInfoMenu(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK> {
   while (true) {
     const options: OptionInput[] = [];
+    options.push({ title: "Subagents", description: "Manage running agents" });
+    options.push({ title: "LSP", description: "Language server status and controls" });
+    options.push({ title: "Usage", description: "Show session token usage and cost breakdown" });
     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);
+    const choice = await selectOption(ctx, "Info", options);
     if (!choice || choice === "Back") return BACK;
-    if (choice === "Task status") {
-      showStatus(orchestrator, ctx);
+    if (choice === "Subagents") {
+      await showSubagentsMenu(ctx);
+      continue;
+    }
+    if (choice === "LSP") {
+      await showLspMenu(ctx);
       continue;
     }
     if (choice === "Usage") {
       showUsage(ctx);
       continue;
     }
-    if (choice === "LSP") {
-      await showLspMenu(ctx);
+    if (choice === "Task status") {
+      showStatus(orchestrator, ctx);
       continue;
     }
+  }
+}
+
+async function showSettingsMenu(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK> {
+  while (true) {
+    const options: OptionInput[] = [];
+    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;
     await showFlantInfraMenu(orchestrator, ctx);
   }
 }
@@ -1028,56 +1034,72 @@ async function showTaskTypeMenu(
   }
 }
 
-async function showNoActiveMenu(orchestrator: Orchestrator, ctx: any): Promise<string | undefined> {
+async function showTaskMenu(orchestrator: Orchestrator, ctx: any): Promise<typeof BACK | "started"> {
   while (true) {
-    const choice = await selectOption(ctx, "/pp", [
+    const choice = await selectOption(ctx, "Task", [
       { 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: "Settings", description: "LSP, Flant AI, and other configuration" },
-      { title: "Back", description: "Close this menu" },
+      { title: "Back", description: "Return to the previous menu" },
     ]);
-    if (!choice || choice === "Back") return undefined;
+    if (!choice || choice === "Back") return BACK;
 
     if (choice === "Debug") {
       const result = await showTaskTypeMenu(orchestrator, ctx, "debug", "Describe the task");
-      if (result === "started") return undefined;
+      if (result === "started") return "started";
       continue;
     }
 
     if (choice === "Brainstorm") {
       const result = await showTaskTypeMenu(orchestrator, ctx, "brainstorm", "Describe the task");
-      if (result === "started") return undefined;
+      if (result === "started") return "started";
       continue;
     }
 
     if (choice === "Implement") {
       const result = await showImplementMenu(orchestrator, ctx);
-      if (result === "started") return undefined;
+      if (result === "started") return "started";
       continue;
     }
 
     if (choice === "Review") {
       const result = await showReviewMenu(orchestrator, ctx);
-      if (result === "started") return undefined;
+      if (result === "started") return "started";
       continue;
     }
 
     if (choice === "Resume") {
       const result = await showResumeMenu(orchestrator, ctx, undefined, "No paused tasks found.");
+      if (result === "started") return "started";
+      continue;
+    }
+  }
+}
+
+async function showNoActiveMenu(orchestrator: Orchestrator, ctx: any): Promise<string | undefined> {
+  while (true) {
+    const choice = await selectOption(ctx, "/pp", [
+      { title: "Task", description: "Start a new task or resume a paused one" },
+      { title: "Info", description: "Subagents, LSP, usage, and task status" },
+      { title: "Settings", description: "Flant AI and other configuration" },
+      { title: "Back", description: "Close this menu" },
+    ]);
+    if (!choice || choice === "Back") return undefined;
+
+    if (choice === "Task") {
+      const result = await showTaskMenu(orchestrator, ctx);
       if (result === "started") return undefined;
       continue;
     }
 
-    if (choice === "Subagents") {
-      await showSubagentsMenu(ctx);
+    if (choice === "Info") {
+      await showInfoMenu(orchestrator, ctx);
       continue;
     }
 
-    await showSettingsMenu(orchestrator, ctx, true);
+    await showSettingsMenu(orchestrator, ctx);
   }
 }
 
@@ -1133,12 +1155,12 @@ export async function showActiveTaskMenu(
     const opt = (title: string, description: string): OptionInput => ({ title, description });
 
     const options: OptionInput[] = [];
-    options.push(opt("Finish", "Complete, pause, or continue to next phase"));
+    options.push(opt("Next", "Complete, pause, or continue to next phase"));
     if (!waiting) {
       options.push(opt("Review", "Auto review, Plannotator, or manual review"));
     }
-    options.push(opt("Subagents", "Manage running agents"));
-    options.push(opt("Settings", "Task status, usage, and LSP"));
+    options.push(opt("Info", "Subagents, LSP, usage, and task status"));
+    options.push(opt("Settings", "Flant AI and other configuration"));
     options.push(opt("Back", "Return to the prompt and keep working"));
 
     const headerLines = [`/pp\n\nTask: ${task.type}\nPhase: ${phase}`];
@@ -1149,12 +1171,12 @@ export async function showActiveTaskMenu(
       return "";
     }
 
-    if (choice === "Subagents") {
-      await showSubagentsMenu(ctx);
+    if (choice === "Info") {
+      await showInfoMenu(orchestrator, ctx);
       continue;
     }
     if (choice === "Settings") {
-      await showSettingsMenu(orchestrator, ctx, false);
+      await showSettingsMenu(orchestrator, ctx);
       continue;
     }
 
@@ -1162,7 +1184,7 @@ export async function showActiveTaskMenu(
       await abortCurrentWork(orchestrator, ctx);
     }
 
-    if (choice === "Finish") {
+    if (choice === "Next") {
       const canContinue = phase !== "implement" && !waiting;
       const continueLabel = phase === "plan" ? "Continue to implement" : "Continue to plan & implement";
       const finishOptions: OptionInput[] = [];
@@ -1173,7 +1195,7 @@ export async function showActiveTaskMenu(
       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);
+      const finishChoice = await selectOption(ctx, "Next", finishOptions);
       if (!finishChoice || finishChoice === "Back") continue;
       if (finishChoice === "Pause") {
         const text = await pauseTask(orchestrator, ctx);

package/extensions/orchestrator/usage-tracker.ts

@@ -19,6 +19,11 @@ export interface UsageTracker {
   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 };
@@ -203,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 {
@@ -219,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.3.0",
+  "version": "0.5.0",
   "description": "Pi-Pi Coding Agent: based on Pi Coding Agent, but twice as good",
   "keywords": [
     "pi-package",