@ilya-lesikov/pi-pi 0.6.0 → 0.8.0

package/extensions/orchestrator/integration.test.ts

@@ -63,12 +63,16 @@ vi.mock("./config.js", async (importOriginal) => {
         debug: { model: "test/model", thinking: "high" },
         brainstorm: { model: "test/model", thinking: "high" },
         review: { model: "test/model", thinking: "high" },
+        quick: { model: "test/model", thinking: "high" },
       },
       subagents: {
         simple: {
           explore: { model: "test/explore", thinking: "low" },
           librarian: { model: "test/librarian", thinking: "medium" },
           task: { model: "test/task", thinking: "medium" },
+          advisor: { model: "test/advisor", thinking: "high" },
+          "deep-debugger": { model: "test/deep-debugger", thinking: "high" },
+          reviewer: { model: "test/reviewer", thinking: "high" },
         },
         presetGroups: {
           planners: {
@@ -215,12 +219,16 @@ function makeConfig() {
         debug: { model: "test/model", thinking: "high" },
         brainstorm: { model: "test/model", thinking: "high" },
         review: { model: "test/model", thinking: "high" },
+        quick: { model: "test/model", thinking: "high" },
       },
       subagents: {
         simple: {
           explore: { model: "test/explore", thinking: "low" },
           librarian: { model: "test/librarian", thinking: "medium" },
           task: { model: "test/task", thinking: "medium" },
+          advisor: { model: "test/advisor", thinking: "high" },
+          "deep-debugger": { model: "test/deep-debugger", thinking: "high" },
+          reviewer: { model: "test/reviewer", thinking: "high" },
         },
         presetGroups: {
           planners: {
@@ -670,7 +678,7 @@ describe("review cycle lifecycle", () => {
     await new Promise((r) => setTimeout(r, 10));
 
     expectReviewAuto(menu);
-    expectReviewOnMyOwn(menu);
+    expectReviewOnMyOwn(menu, "Skip markers");
     const result = await ppPhaseComplete.execute("call-3", { summary: "implemented" }, undefined, undefined, ctx);
 
     expect(result.content[0].text).toContain("continue");
@@ -1353,7 +1361,7 @@ describe("edge cases and regressions", () => {
     await ppPhaseComplete.execute("call-2", { summary: "plan done" }, undefined, undefined, ctx);
     await new Promise((r) => setTimeout(r, 10));
 
-    expectReviewOnMyOwn(menu);
+    expectReviewOnMyOwn(menu, "Skip markers");
     const result = await ppPhaseComplete.execute("call-3", { summary: "partial work" }, undefined, undefined, ctx);
 
     expect(result.content[0].text).toContain("continue");
@@ -1400,6 +1408,47 @@ describe("edge cases and regressions", () => {
     expect(orchestrator.active!.state.step).toBe("synthesize");
   });
 
+  it("editor-review Done returns AI_REVIEW marker instructions in implement phase", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "Editor review test");
+    const taskDir = orchestrator.active!.dir;
+    writeFileSync(join(taskDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
+    writeFileSync(join(taskDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
+    expectBrainstormToPlan(menu);
+    const ppPhaseComplete = getTool(pi, "pp_phase_complete");
+    await ppPhaseComplete.execute("call-1", { summary: "done" }, undefined, undefined, ctx);
+    await new Promise((r) => setTimeout(r, 10));
+
+    emitSubagentCreated(pi, "planner-1", "Planner (test)");
+    const plansDir = join(taskDir, "plans");
+    mkdirSync(plansDir, { recursive: true });
+    writeFileSync(
+      join(plansDir, `${Math.floor(Date.now() / 1000)}_test.md`),
+      makeValidPlan(["- [ ] P1. Planner draft item — Done when: planner output exists"]),
+      "utf-8",
+    );
+    emitSubagentCompleted(pi, "planner-1", "Planner (test)");
+    writeFileSync(
+      join(plansDir, `${Math.floor(Date.now() / 1000) + 1}_synthesized.md`),
+      makeValidPlan(["- [ ] P1. Todo item — Done when: item intentionally remains unchecked"]),
+      "utf-8",
+    );
+    expectPlanToImplement(menu);
+    await ppPhaseComplete.execute("call-2", { summary: "plan done" }, undefined, undefined, ctx);
+    await new Promise((r) => setTimeout(r, 10));
+
+    expectReviewOnMyOwn(menu, "Done");
+    const result = await ppPhaseComplete.execute("call-3", { summary: "implemented" }, undefined, undefined, ctx);
+
+    expect(result.content[0].text).toContain("AI_REVIEW:");
+    expect(result.content[0].text).toContain("CHANGED files");
+    expect(orchestrator.active!.state.phase).toBe("implement");
+    expect(orchestrator.active!.state.step).toBe("llm_work");
+  });
+
   it("generic description task does not auto-trigger agent", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -1565,7 +1614,7 @@ describe("task modes and quick task", () => {
     expect(orchestrator.active!.state.autonomousConfig).toBeDefined();
   });
 
-  it("autonomous pp_phase_complete auto-advances without opening menu", async () => {
+  it("autonomous pp_phase_complete auto-advances (plan→implement) without opening menu", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
     const ctx = makeCtx();
@@ -1581,16 +1630,115 @@ describe("task modes and quick task", () => {
     };
     writeFileSync(join(taskDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
     writeFileSync(join(taskDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
+    // Move to an autonomous-capable phase (plan). brainstorm is always guided
+    // even for an autonomous task, so auto-advance only applies from plan onward.
+    orchestrator.active!.state.phase = "plan";
+    orchestrator.active!.state.step = "llm_work";
+    const plansDir = join(taskDir, "plans");
+    mkdirSync(plansDir, { recursive: true });
+    writeFileSync(
+      join(plansDir, `${Math.floor(Date.now() / 1000)}_synthesized.md`),
+      makeValidPlan([
+        "- [ ] P1. Implement X — Done when: implementation for X is complete",
+      ]),
+      "utf-8",
+    );
 
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
     const result = await ppPhaseComplete.execute("call-1", { summary: "done" }, undefined, undefined, ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     expect(result.content[0].text).toBe("");
-    expect(orchestrator.active!.state.phase).toBe("plan");
+    expect(orchestrator.active!.state.phase).toBe("implement");
     expect(menu.transcript.filter((entry) => entry.question.startsWith("/pp"))).toHaveLength(0);
   });
 
+  it("autonomous task in brainstorm stays guided (pp_phase_complete opens the menu, does NOT auto-advance)", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "implement", undefined, undefined, "autonomous");
+    const taskDir = orchestrator.active!.dir;
+    orchestrator.active!.state.autonomousConfig = {
+      phases: {
+        brainstorm: { reviewPreset: "regular", maxReviewPasses: 0 },
+        plan: { plannerPreset: "regular", reviewPreset: "regular", maxReviewPasses: 0 },
+        implement: { reviewPreset: "regular", maxReviewPasses: 0 },
+      },
+    };
+    writeFileSync(join(taskDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
+    writeFileSync(join(taskDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
+    expect(orchestrator.active!.state.phase).toBe("brainstorm");
+
+    // brainstorm is user-driven: pp_phase_complete must fall through to the
+    // guided menu rather than the autonomous auto-advance branch. (Autonomous
+    // tasks skip the planner preset picker on transition, so only the guided
+    // Next→Continue step is expected here.)
+    expectActiveTaskNext(menu, "Continue to plan & implement");
+    const ppPhaseComplete = getTool(pi, "pp_phase_complete");
+    await ppPhaseComplete.execute("call-1", { summary: "done" }, undefined, undefined, ctx);
+    await new Promise((r) => setTimeout(r, 10));
+
+    // The guided menu was shown (auto-advance did NOT bypass it).
+    expect(menu.transcript.filter((entry) => entry.question.startsWith("/pp"))).not.toHaveLength(0);
+  });
+
+  it("ESC on pp_phase_complete stops the turn cleanly (aborts, no reminder text)", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "esc dismiss");
+    // Guided task in brainstorm; transition controller is running so the
+    // non-ESC dismiss path would normally return the reminder text.
+    expect(orchestrator.transitionController.isRunning()).toBe(true);
+
+    // Simulate a deliberate user ESC on the top-level menu.
+    menu.expect({ question: m.anyTaskMenu, cancel: "user" });
+
+    const ppPhaseComplete = getTool(pi, "pp_phase_complete");
+    const result = await ppPhaseComplete.execute("esc-1", { summary: "done" }, undefined, undefined, ctx);
+
+    expect(ctx.abort).toHaveBeenCalled();
+    expect(result.content[0].text).toBe("");
+  });
+
+  it("Back on pp_phase_complete keeps the artifact-update reminder (does NOT abort)", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "back dismiss");
+    expect(orchestrator.transitionController.isRunning()).toBe(true);
+
+    // Explicit "Back" navigation (not an ESC): the reminder must be preserved.
+    menu.expect({ question: m.anyTaskMenu, options: { include: ["Back"] }, choose: "Back" });
+
+    const ppPhaseComplete = getTool(pi, "pp_phase_complete");
+    const result = await ppPhaseComplete.execute("back-1", { summary: "done" }, undefined, undefined, ctx);
+
+    expect(ctx.abort).not.toHaveBeenCalled();
+    expect(result.content[0].text).toContain("update USER_REQUEST.md and RESEARCH.md");
+  });
+
+  it("ESC on pp_phase_complete for a quick task also stops the turn cleanly", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "quick", "quick esc");
+    expect(orchestrator.active!.type).toBe("quick");
+
+    menu.expect({ question: m.anyTaskMenu, cancel: "user" });
+
+    const ppPhaseComplete = getTool(pi, "pp_phase_complete");
+    const result = await ppPhaseComplete.execute("quick-esc-1", { summary: "done" }, undefined, undefined, ctx);
+
+    expect(ctx.abort).toHaveBeenCalled();
+    expect(result.content[0].text).toBe("");
+  });
+
   it("autonomous review loop re-runs until cap then advances", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -1694,6 +1842,52 @@ describe("task modes and quick task", () => {
     expect(finalState.reviewPassByKind?.implement?.auto).toBe(1);
   });
 
+  it("autonomous PLAN review cycle: apply feedback (clean approve) advances to implement", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "plan review advance", undefined, undefined, "autonomous");
+    const taskDir = orchestrator.active!.dir;
+    orchestrator.active!.state.phase = "plan";
+    orchestrator.active!.state.step = "synthesize";
+    orchestrator.active!.state.reviewPass = 0;
+    orchestrator.active!.state.reviewPassByKind = {};
+    orchestrator.active!.state.autonomousConfig = {
+      phases: { plan: { plannerPreset: "regular", reviewPreset: "regular", maxReviewPasses: 3 } },
+    };
+    writeFileSync(join(taskDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
+    writeFileSync(join(taskDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
+    const plansDir = join(taskDir, "plans");
+    mkdirSync(plansDir, { recursive: true });
+    writeFileSync(
+      join(plansDir, "1_synthesized.md"),
+      makeValidPlan(["- [x] P1. Plan ready — Done when: synthesized plan exists"]),
+      "utf-8",
+    );
+
+    const ppPhaseComplete = getTool(pi, "pp_phase_complete");
+    // First call: plan phase is autonomous, no clean approval yet → starts a review cycle.
+    const first = await ppPhaseComplete.execute("plan-rev-1", { summary: "plan done" }, undefined, undefined, ctx);
+    expect(first.content[0].text).toMatch(/Reviews are running|Started review cycle pass/);
+
+    // Plan reviewers write to plan-reviews/ (not code-reviews/).
+    const planReviewsDir = join(taskDir, "plan-reviews");
+    mkdirSync(planReviewsDir, { recursive: true });
+    const round = orchestrator.active!.state.reviewCycle!.pass;
+    for (const v of ["opus", "gpt", "gemini"]) {
+      writeFileSync(join(planReviewsDir, `1_${v}_round-${round}.md`), "VERDICT: APPROVE\n- CRITICAL: none", "utf-8");
+    }
+    emitSubagentCreated(pi, "plan-reviewer-1", "Plan reviewer (test)");
+    emitSubagentCompleted(pi, "plan-reviewer-1", "Plan reviewer (test)");
+
+    // Second call: finalize the clean-approved pass and advance to implement (single transition).
+    const second = await ppPhaseComplete.execute("plan-rev-2", { summary: "feedback applied" }, undefined, undefined, ctx);
+    expect(second.content[0].text).toBe("");
+    expect(orchestrator.active!.state.phase).toBe("implement");
+    expect(menu.transcript.filter((entry) => entry.question.startsWith("/pp"))).toHaveLength(0);
+  });
+
   it("clean-approved review is not re-run on a later checklist-repair re-entry", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -1932,7 +2126,7 @@ describe("task modes and quick task", () => {
     expect(prompt).toContain("<principles>");
     expect(prompt).toContain("<tools>");
     expect(prompt).toContain("<task>");
-    expect(prompt).toContain("let the user review and advance it via the /pp menu");
+    expect(prompt).toContain("call pp_phase_complete");
     expect(prompt).not.toContain("HARNESS_BASE_PROMPT");
     expect(prompt).toContain(`Working directory: ${cwd}.`);
     expect(prompt).toMatch(/Current month: \d{4}-\d{2}\./);
@@ -2041,10 +2235,11 @@ describe("task modes and quick task", () => {
 
     const title = "implement";
     const pp = getCommand(pi, "pp");
+    const titleMatch = (t: string) => t.includes(title);
     menu
       .expect({ question: "/pp", options: { include: ["Task"] }, choose: "Task" })
       .expect({ question: "Task", options: { include: ["Resume"] }, choose: "Resume" })
-      .expect({ question: "Resume", options: { include: [title] }, choose: title });
+      .expect({ question: "Resume", options: { include: [titleMatch] }, choose: titleMatch });
     await pp(undefined, ctx);
 
     expect(orchestrator.active).not.toBeNull();
@@ -2069,10 +2264,11 @@ describe("task modes and quick task", () => {
     await orchestrator.cleanupActive();
 
     const pp = getCommand(pi, "pp");
+    const configTitleMatch = (t: string) => t.includes("resume autonomous config");
     menu
       .expect({ question: "/pp", options: { include: ["Task"] }, choose: "Task" })
       .expect({ question: "Task", options: { include: ["Resume"] }, choose: "Resume" })
-      .expect({ question: "Resume", options: { include: ["resume autonomous config"] }, choose: "resume autonomous config" });
+      .expect({ question: "Resume", options: { include: [configTitleMatch] }, choose: configTitleMatch });
     await pp(undefined, ctx);
 
     expect(orchestrator.active).not.toBeNull();
@@ -2102,6 +2298,10 @@ describe("task modes and quick task", () => {
     writeFileSync(join(taskDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
     writeFileSync(join(taskDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
 
+    // brainstorm is user-driven even for an autonomous task, so the transition
+    // to plan goes through the guided menu (which auto-skips the planner preset
+    // picker because the task is autonomous).
+    expectActiveTaskNext(menu, "Continue to plan & implement");
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
     await ppPhaseComplete.execute("call-autonomous-skip-planner", { summary: "done" }, undefined, undefined, ctx);
     await new Promise((r) => setTimeout(r, 10));
@@ -2596,7 +2796,7 @@ describe("resume and recovery", () => {
     menu
       .expect({ question: "/pp", options: { include: ["Task"] }, choose: "Task" })
       .expect({ question: "Task", options: { include: ["Resume"] }, choose: "Resume" })
-      .expect({ question: "Resume", options: { include: ["resume phase state"] }, choose: "resume phase state" });
+      .expect({ question: "Resume", options: { include: [(t: string) => t.includes("resume phase state")] }, choose: (t: string) => t.includes("resume phase state") });
     await pp(undefined, ctx);
 
     expect(orchestrator.active).not.toBeNull();
@@ -2625,7 +2825,7 @@ describe("resume and recovery", () => {
     menu
       .expect({ question: "/pp", options: { include: ["Task"] }, choose: "Task" })
       .expect({ question: "Task", options: { include: ["Resume"] }, choose: "Resume" })
-      .expect({ question: "Resume", options: { include: ["resume stale repos"] }, choose: "resume stale repos" });
+      .expect({ question: "Resume", options: { include: [(t: string) => t.includes("resume stale repos")] }, choose: (t: string) => t.includes("resume stale repos") });
     await pp(undefined, ctx);
 
     expect(orchestrator.active!.state.repos).toEqual([{ path: cwd, isRoot: true }]);
@@ -2852,6 +3052,49 @@ describe("brainstorm and plan review cycles", () => {
     expect(readyMessages[readyMessages.length - 1]).toContain("artifacts/");
   });
 
+  const runPlanReviewReady = async (mode?: "autonomous") => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx({ cwd });
+
+    await orchestrator.startTask(ctx as any, "implement", "plan review message", undefined, undefined, mode);
+    const taskDir = orchestrator.active!.dir;
+    writeFileSync(join(taskDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
+    writeFileSync(join(taskDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
+    mkdirSync(join(taskDir, "plan-reviews"), { recursive: true });
+    writeFileSync(
+      join(taskDir, "plan-reviews", `${Math.floor(Date.now() / 1000)}_test_round-1.md`),
+      "Plan review feedback",
+      "utf-8",
+    );
+    orchestrator.active!.state.phase = "plan";
+    orchestrator.active!.state.step = "synthesize";
+    saveTask(taskDir, orchestrator.active!.state);
+
+    await enterReviewCycle(orchestrator, ctx, "regular");
+    await new Promise((r) => setTimeout(r, 10));
+
+    return (pi.sendUserMessage as any).mock.calls
+      .map((c: any[]) => c[0] as string)
+      .filter((text: string) => text.includes("ready for apply_feedback"));
+  };
+
+  it("autonomous plan review-ready message mandates re-calling pp_phase_complete", async () => {
+    const readyMessages = await runPlanReviewReady("autonomous");
+    expect(readyMessages.length).toBeGreaterThan(0);
+    const last = readyMessages[readyMessages.length - 1];
+    expect(last).toContain("pp_phase_complete");
+    expect(last).toContain("Do NOT stop or wait for the user");
+  });
+
+  it("guided plan review-ready message does NOT tell the agent to re-call pp_phase_complete or auto-advance", async () => {
+    const readyMessages = await runPlanReviewReady();
+    expect(readyMessages.length).toBeGreaterThan(0);
+    const last = readyMessages[readyMessages.length - 1];
+    expect(last).not.toContain("pp_phase_complete");
+    expect(last).not.toContain("Do NOT stop or wait for the user");
+  });
+
   it("plan review cycle reaches apply_feedback and finalizeReviewCycle returns to user_gate", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -3044,7 +3287,11 @@ describe("tool blocking", () => {
 });
 
 describe("error retry", () => {
-  it("turn_end with error retries with exponential backoff", async () => {
+  // Non-SDK-retryable error messages exercise pi-pi's OWN retry path. SDK-
+  // retryable errors (rate limit, overloaded, 5xx, stream-ended, timeout, etc.)
+  // are now deferred to the SDK's own auto-retry (see the defer test below), so
+  // these use a message the SDK does NOT retry.
+  it("turn_end with a non-SDK-retryable error uses pi-pi's idle-gated retry", async () => {
     vi.useFakeTimers();
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -3053,7 +3300,7 @@ describe("error retry", () => {
     await orchestrator.startTask(ctx as any, "implement", "retry test");
     const turnEnd = pi._handlers.get("turn_end")!;
 
-    await turnEnd({ message: { stopReason: "error", errorMessage: "rate limited", content: [] } }, ctx);
+    await turnEnd({ message: { stopReason: "error", errorMessage: "invalid tool arguments", content: [] } }, ctx);
 
     expect(orchestrator.errorRetryCount).toBe(1);
     expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("Retrying in 2s"), "warning");
@@ -3063,7 +3310,24 @@ describe("error retry", () => {
     vi.useRealTimers();
   });
 
-  it("turn_end stops retrying after max retries", async () => {
+  it("turn_end defers SDK-retryable errors to the SDK (no pi-pi retry)", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "sdk defer test");
+    const turnEnd = pi._handlers.get("turn_end")!;
+
+    // "stream ended before message_stop" is SDK-retryable — pi-pi must NOT run
+    // its own retry (which would race the SDK's continue()).
+    await turnEnd({ message: { stopReason: "error", errorMessage: "Anthropic stream ended before message_stop", content: [] } }, ctx);
+
+    expect(orchestrator.errorRetryCount).toBe(0);
+    expect(orchestrator.pendingRetryTimer).toBeNull();
+    expect(ctx.ui.notify).not.toHaveBeenCalledWith(expect.stringContaining("Retrying in"), "warning");
+  });
+
+  it("turn_end stops retrying after max retries (non-SDK-retryable)", async () => {
     vi.useFakeTimers();
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -3073,27 +3337,54 @@ describe("error retry", () => {
     const turnEnd = pi._handlers.get("turn_end")!;
 
     for (let i = 0; i < 6; i++) {
-      await turnEnd({ message: { stopReason: "error", errorMessage: "api down", content: [] } }, ctx);
+      await turnEnd({ message: { stopReason: "error", errorMessage: "invalid tool arguments", content: [] } }, ctx);
     }
 
-    expect(orchestrator.errorRetryCount).toBe(0);
     expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("Stopping auto-retry"), "error");
+    expect(orchestrator.errorNudgeHalted).toBe(true);
+
+    // Once halted, further error turns must NOT arm another retry (this is the
+    // guard against the unbounded-nudge bug).
+    ctx.ui.notify.mockClear();
+    await turnEnd({ message: { stopReason: "error", errorMessage: "invalid tool arguments", content: [] } }, ctx);
+    expect(ctx.ui.notify).not.toHaveBeenCalledWith(expect.stringContaining("Retrying in"), "warning");
     vi.useRealTimers();
   });
 
-  it("successful turn resets error count", async () => {
+  it("a benign turn does NOT reset the error count (cap must accumulate)", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
     const ctx = makeCtx();
 
-    await orchestrator.startTask(ctx as any, "implement", "retry reset test");
+    await orchestrator.startTask(ctx as any, "implement", "retry no-reset test");
     const turnEnd = pi._handlers.get("turn_end")!;
 
-    await turnEnd({ message: { stopReason: "error", errorMessage: "once", content: [] } }, ctx);
+    await turnEnd({ message: { stopReason: "error", errorMessage: "invalid tool arguments", content: [] } }, ctx);
     expect(orchestrator.errorRetryCount).toBe(1);
 
+    // A benign (non-error) turn must NOT zero the counter — otherwise a harmless
+    // nudge-induced reply would defeat the cap and allow unbounded error nudges.
     await turnEnd({ message: { stopReason: "stop", content: [] } }, ctx);
-    expect(orchestrator.errorRetryCount).toBe(0);
+    expect(orchestrator.errorRetryCount).toBe(1);
+  });
+
+  it("genuine user re-engagement resets the error count and halt", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "retry reengage test");
+    const turnEnd = pi._handlers.get("turn_end")!;
+
+    await turnEnd({ message: { stopReason: "error", errorMessage: "invalid tool arguments", content: [] } }, ctx);
+    orchestrator.errorNudgeHalted = true;
+
+    const beforeStart = pi._handlers.get("before_agent_start");
+    if (beforeStart) {
+      await beforeStart({ prompt: "user typed something new" }, ctx);
+      expect(orchestrator.errorRetryCount).toBe(0);
+      expect(orchestrator.errorNudgeHalted).toBe(false);
+    }
   });
 
   it("empty turn triggers continuation nudge", async () => {
@@ -3917,6 +4208,9 @@ describe("full user flows", () => {
     writeFileSync(join(taskDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
     writeFileSync(join(taskDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
 
+    // brainstorm is user-driven: the brainstorm→plan transition uses the guided
+    // menu. plan→implement and implement→review below are autonomous auto-advance.
+    expectActiveTaskNext(menu, "Continue to plan & implement");
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
     await ppPhaseComplete.execute("flow-auto-1", { summary: "brainstorm done" }, undefined, undefined, ctx);
     await new Promise((r) => setTimeout(r, 10));

package/extensions/orchestrator/messages.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { advanceBanner } from "./messages.js";
+
+describe("advanceBanner", () => {
+  it("starts with [PI-PI] so the controller-injection guard still matches", () => {
+    const out = advanceBanner("[PI-PI] User wants to continue. Run /pp when ready to advance.");
+    expect(out.startsWith("[PI-PI]")).toBe(true);
+  });
+
+  it("renders separators around the content for visual distinctness", () => {
+    const out = advanceBanner("[PI-PI] hello");
+    const lines = out.split("\n");
+    expect(lines[0]).toBe("[PI-PI]");
+    expect(lines[1]).toMatch(/^─+$/);
+    expect(lines[2]).toBe("hello");
+    expect(lines[3]).toMatch(/^─+$/);
+  });
+
+  it("does not double up the [PI-PI] prefix when the body already has one", () => {
+    const out = advanceBanner("[PI-PI] hello");
+    expect(out.match(/\[PI-PI\]/g)?.length).toBe(1);
+    expect(out).not.toContain("[PI-PI] [PI-PI]");
+  });
+
+  it("adds the prefix when the body lacks one", () => {
+    const out = advanceBanner("plain body");
+    expect(out.startsWith("[PI-PI]")).toBe(true);
+    expect(out).toContain("plain body");
+  });
+});

package/extensions/orchestrator/messages.ts

@@ -0,0 +1,6 @@
+const BANNER_SEPARATOR = "─".repeat(48);
+
+export function advanceBanner(body: string): string {
+  const content = body.startsWith("[PI-PI]") ? body.slice("[PI-PI]".length).trimStart() : body;
+  return `[PI-PI]\n${BANNER_SEPARATOR}\n${content}\n${BANNER_SEPARATOR}`;
+}