@ilya-lesikov/pi-pi 0.4.0 → 0.5.0

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}`, { deliverAs: "followUp" });
+        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;
           }
 
@@ -1099,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,
         },
@@ -1143,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 (
@@ -1186,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}).`, { deliverAs: "followUp" });
+          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");
@@ -1208,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");
@@ -1221,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.", { deliverAs: "followUp" });
+                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) {
@@ -1252,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.", { deliverAs: "followUp" });
+              orchestrator.safeSendUserMessage("[PI-PI] Review cycle is ready for apply_feedback. Read reviewer outputs and proceed.");
             }
           } else {
             clearInterval(orchestrator.awaitPollTimer!);
@@ -1281,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;
 
@@ -1306,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.`, { deliverAs: "followUp" });
+      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.`, { deliverAs: "followUp" });
-        }
+        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.`, { deliverAs: "followUp" });
-        }
+        finalize();
       },
     });
   }

package/extensions/orchestrator/phases/brainstorm.ts

@@ -14,11 +14,10 @@ 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",
@@ -85,12 +84,15 @@ export function brainstormSystemPrompt(taskType: TaskType, taskDescription: stri
     "  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,",
@@ -117,11 +119,10 @@ 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",

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

@@ -30,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.`, { deliverAs: "followUp" });
+    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.`, { deliverAs: "followUp" });
+    orchestrator.safeSendUserMessage(`[PI-PI] Resumed ${orchestrator.active.state.phase} phase. Continue working.`);
   }
 
   return { ok: true };
@@ -709,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);
   }
 }
@@ -1021,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);
   }
 }
 
@@ -1126,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}`];
@@ -1142,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;
     }
 
@@ -1155,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[] = [];
@@ -1166,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/package.json

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