@ilya-lesikov/pi-pi 0.9.0 → 0.10.0

package/extensions/orchestrator/integration.test.ts

@@ -40,13 +40,18 @@ vi.mock("./cbm.js", () => ({ registerCbmTools: vi.fn() }));
 vi.mock("./exa.js", () => ({ registerExaTools: vi.fn() }));
 vi.mock("./ast-search.js", () => ({ registerAstSearchTool: vi.fn() }));
 vi.mock("./doctor.js", () => ({ runDoctor: vi.fn(async () => undefined) }));
-vi.mock("./agents/registry.js", () => ({
-  registerAgentDefinitions: vi.fn(),
-  unregisterAgentDefinitions: vi.fn(),
-  setExtensionOnlyMode: vi.fn(),
-  spawnViaRpc: vi.fn(async (_pi: any, _type: string) => ({ id: `mock-${Math.random().toString(36).slice(2)}` })),
-  waitForCompletion: vi.fn(async () => undefined),
-}));
+vi.mock("./agents/registry.js", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("./agents/registry.js")>();
+  return {
+    ...actual,
+    registerAgentDefinitions: vi.fn(),
+    unregisterAgentDefinitions: vi.fn(),
+    setExtensionOnlyMode: vi.fn(),
+    getAgentConfigSnapshot: vi.fn(() => undefined),
+    spawnViaRpc: vi.fn(async (_pi: any, _type: string) => ({ id: `mock-${Math.random().toString(36).slice(2)}` })),
+    waitForCompletion: vi.fn(async () => undefined),
+  };
+});
 
 vi.mock("./config.js", async (importOriginal) => {
   const original = await importOriginal<typeof import("./config.js")>();
@@ -58,6 +63,7 @@ vi.mock("./config.js", async (importOriginal) => {
       logLevel: "info",
     },
     agents: {
+      maxConcurrentSubagents: 7,
       orchestrators: {
         implement: { model: "test/model", thinking: "high" },
         plan: { model: "test/model", thinking: "high" },
@@ -71,9 +77,14 @@ vi.mock("./config.js", async (importOriginal) => {
           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" },
+        },
+        pools: {
+          advisors: [
+            { enabled: true, model: "test/advisor-fable", thinking: "high" },
+            { enabled: true, model: "test/advisor-gpt", thinking: "high" },
+          ],
+          reviewers: [{ enabled: true, model: "test/reviewer", thinking: "high" }],
+          deepDebuggers: [{ enabled: true, model: "test/deep-debugger", thinking: "high" }],
         },
         presetGroups: {
           planners: {
@@ -215,6 +226,7 @@ function makeConfig() {
       logLevel: "info",
     },
     agents: {
+      maxConcurrentSubagents: 7,
       orchestrators: {
         implement: { model: "test/model", thinking: "high" },
         plan: { model: "test/model", thinking: "high" },
@@ -228,9 +240,14 @@ function makeConfig() {
           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" },
+        },
+        pools: {
+          advisors: [
+            { enabled: true, model: "test/advisor-fable", thinking: "high" },
+            { enabled: true, model: "test/advisor-gpt", thinking: "high" },
+          ],
+          reviewers: [{ enabled: true, model: "test/reviewer", thinking: "high" }],
+          deepDebuggers: [{ enabled: true, model: "test/deep-debugger", thinking: "high" }],
         },
         presetGroups: {
           planners: {
@@ -1317,6 +1334,49 @@ describe("edge cases and regressions", () => {
     expect(finalState.reviewCycle).toBeNull();
   });
 
+  it("manual auto-review (item 5) loops in a guided phase then stops in-phase on clean approve", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    // Guided implement task, parked in the implement phase.
+    await orchestrator.startTask(ctx as any, "implement", "Manual auto-review test", undefined, undefined, "guided");
+    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");
+    const plansDir = join(taskDir, "plans");
+    mkdirSync(plansDir, { recursive: true });
+    writeFileSync(
+      join(plansDir, `${Math.floor(Date.now() / 1000)}_synthesized.md`),
+      makeValidPlan(["- [x] P1. Done item — Done when: synthesized plan is fully checked"]),
+      "utf-8",
+    );
+    orchestrator.active!.state.phase = "implement";
+    orchestrator.active!.state.step = "llm_work";
+    // Arm the item-5 flag (advanceOnComplete=false): stop in-phase on approve.
+    orchestrator.active!.state.manualAutoReview = { phase: "implement", preset: "regular", maxPasses: 3, advanceOnComplete: false };
+    saveTask(taskDir, orchestrator.active!.state);
+
+    const ppPhaseComplete = getTool(pi, "pp_phase_complete");
+    // First call: enters the review cycle (spawns reviewers).
+    const first = await ppPhaseComplete.execute("m-1", { summary: "implemented" }, undefined, undefined, ctx);
+    expect(first.content[0].text).toContain("pass 1/3");
+    expect(orchestrator.active!.state.reviewCycle).not.toBeNull();
+
+    // Reviewer approves.
+    const reviewsDir = join(taskDir, "code-reviews");
+    mkdirSync(reviewsDir, { recursive: true });
+    writeFileSync(join(reviewsDir, `${Math.floor(Date.now() / 1000)}_test_round-1.md`), "VERDICT: APPROVE", "utf-8");
+    emitSubagentCreated(pi, "reviewer-1", "Code reviewer (test)");
+    emitSubagentCompleted(pi, "reviewer-1", "Code reviewer (test)");
+
+    // Second call: finalizes the clean pass; item 5 stops in-phase and clears the flag.
+    const second = await ppPhaseComplete.execute("m-2", { summary: "fixes applied" }, undefined, undefined, ctx);
+    expect(second.content[0].text).toContain("Staying in the implement phase");
+    expect(orchestrator.active!.state.phase).toBe("implement");
+    expect(orchestrator.active!.state.manualAutoReview).toBeUndefined();
+  });
+
   it("continue brainstorming sets step back to llm_work", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -1678,7 +1738,7 @@ describe("task modes and quick task", () => {
     const ctx = makeCtx();
 
     await orchestrator.startTask(ctx as any, "quick", "quick");
-    menu.expect({ question: m.taskMenu("quick", "quick"), options: { include: ["Complete", "Pause"], exclude: ["Next", "Review"] }, choose: "Back" });
+    menu.expect({ question: m.taskMenu("quick", "quick"), options: { include: ["Complete", "Pause"], exclude: ["Next", "Review"] }, choose: "Back to prompt" });
     const pp = getCommand(pi, "pp");
     await pp(undefined, ctx);
   });
@@ -1796,7 +1856,7 @@ describe("task modes and quick task", () => {
     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" });
+    menu.expect({ question: m.anyTaskMenu, options: { include: ["Back to prompt"] }, choose: "Back to prompt" });
 
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
     const result = await ppPhaseComplete.execute("back-1", { summary: "done" }, undefined, undefined, ctx);
@@ -2130,7 +2190,7 @@ describe("task modes and quick task", () => {
       .expect({ question: "Implement", options: { include: ["Resume", "Back"] }, choose: "Resume" })
       .expect({ question: "Implement", options: { include: ["Back"] }, choose: "Back" })
       .expect({ question: "Task", options: { include: ["Back"] }, choose: "Back" })
-      .expect({ question: "/pp", options: { include: ["Back"] }, choose: "Back" });
+      .expect({ question: "/pp", options: { include: ["Back to prompt"] }, choose: "Back to prompt" });
     const pp = getCommand(pi, "pp");
     await pp(undefined, ctx);
 
@@ -2194,7 +2254,8 @@ describe("task modes and quick task", () => {
     const beforeStart = pi._handlers.get("before_agent_start")!;
     const result = await beforeStart({ systemPrompt: "HARNESS_BASE_PROMPT" }, ctx);
     const prompt = result?.systemPrompt ?? "";
-    expect(prompt.startsWith("<constraints>")).toBe(true);
+    expect(prompt.startsWith("<identity>")).toBe(true);
+    expect(prompt).toContain("<constraints>");
     expect(prompt).not.toContain("HARNESS_BASE_PROMPT");
     expect(prompt).toContain("The moment its work is complete, call pp_phase_complete");
     // No interactive '/pp menu' advance guidance in autonomous mode.
@@ -2213,7 +2274,8 @@ describe("task modes and quick task", () => {
 
     const beforeStart = pi._handlers.get("before_agent_start")!;
     const prompt = (await beforeStart({ systemPrompt: "HARNESS_BASE_PROMPT" }, ctx))?.systemPrompt ?? "";
-    expect(prompt.startsWith("<constraints>")).toBe(true);
+    expect(prompt.startsWith("<identity>")).toBe(true);
+    expect(prompt).toContain("<constraints>");
     expect(prompt).toContain("ACTIVE PHASE: plan (READ-ONLY)");
     expect(prompt).toContain("<principles>");
     expect(prompt).toContain("<tools>");
@@ -2351,6 +2413,52 @@ describe("task modes and quick task", () => {
     expect(state.reviewerFailureAutoRetried).toBe(false);
   });
 
+  it("captures the initiating prompt into a generic-description task name (#7)", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx({ cwd });
+
+    await orchestrator.startTask({ ...ctx, cwd } as any, "review", "review", undefined, undefined, "guided");
+    const beforeStart = pi._handlers.get("before_agent_start")!;
+    await beforeStart({ systemPrompt: "base", prompt: "  Review the   payment refactor PR  " }, ctx);
+    expect(orchestrator.active!.state.description).toBe("Review the payment refactor PR");
+    expect(orchestrator.active!.description).toBe("Review the payment refactor PR");
+  });
+
+  it("does not overwrite a non-generic description or capture a [PI-PI] injection", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx({ cwd });
+
+    await orchestrator.startTask({ ...ctx, cwd } as any, "review", "review", undefined, undefined, "guided");
+    const beforeStart = pi._handlers.get("before_agent_start")!;
+    await beforeStart({ systemPrompt: "base", prompt: "[PI-PI] Continue working on the current phase" }, ctx);
+    expect(orchestrator.active!.state.description).toBe("review");
+  });
+
+  it("collapses a multi-line initiating prompt into one line (#8), bounded by the 700-char cap", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx({ cwd });
+
+    await orchestrator.startTask({ ...ctx, cwd } as any, "review", "review", undefined, undefined, "guided");
+    const beforeStart = pi._handlers.get("before_agent_start")!;
+    await beforeStart({ systemPrompt: "base", prompt: "Review the auth refactor\nand the token store\nfor race conditions" }, ctx);
+    expect(orchestrator.active!.state.description).toBe("Review the auth refactor and the token store for race conditions");
+  });
+
+  it("caps the collapsed multi-line description at 700 chars (#8)", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx({ cwd });
+
+    await orchestrator.startTask({ ...ctx, cwd } as any, "review", "review", undefined, undefined, "guided");
+    const beforeStart = pi._handlers.get("before_agent_start")!;
+    const longPrompt = "line one\n" + "x".repeat(2000);
+    await beforeStart({ systemPrompt: "base", prompt: longPrompt }, ctx);
+    expect(orchestrator.active!.state.description.length).toBe(700);
+  });
+
   it("blocks ask_user in autonomous mode after first phase", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -3462,10 +3570,10 @@ describe("tool blocking", () => {
 });
 
 describe("error retry", () => {
-  // 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.
+  // Both SDK-retryable and non-SDK-retryable errors now exercise pi-pi's OWN
+  // idle-gated retry. By the time turn_end fires, the SDK's short in-prompt
+  // retry budget is already exhausted, so pi-pi's longer retry (8×, up to ~4min)
+  // takes over instead of the session silently dying after the SDK's ~14s budget.
   it("turn_end with a non-SDK-retryable error uses pi-pi's idle-gated retry", async () => {
     vi.useFakeTimers();
     const cwd = makeTempDir();
@@ -3478,28 +3586,33 @@ describe("error retry", () => {
     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");
+    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("Retrying in 2s"), "info");
 
     await vi.advanceTimersByTimeAsync(2000);
-    expect(pi.sendUserMessage).toHaveBeenCalledWith(expect.stringContaining("Previous request failed"), { deliverAs: "followUp" });
+    expect(pi.sendUserMessage).toHaveBeenCalledWith(expect.stringContaining("Transient API error"), { deliverAs: "followUp" });
     vi.useRealTimers();
   });
 
-  it("turn_end defers SDK-retryable errors to the SDK (no pi-pi retry)", async () => {
+  it("turn_end retries SDK-retryable errors via pi-pi's idle-gated retry", async () => {
+    vi.useFakeTimers();
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
     const ctx = makeCtx();
 
-    await orchestrator.startTask(ctx as any, "implement", "sdk defer test");
+    await orchestrator.startTask(ctx as any, "implement", "sdk retryable 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()).
+    // "stream ended before message_stop" is SDK-retryable, but by turn_end the
+    // SDK's own short retry budget is exhausted, so pi-pi's longer retry takes
+    // over rather than letting the autonomous session die.
     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");
+    expect(orchestrator.errorRetryCount).toBe(1);
+    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("Retrying in 2s"), "info");
+
+    await vi.advanceTimersByTimeAsync(2000);
+    expect(pi.sendUserMessage).toHaveBeenCalledWith(expect.stringContaining("Transient API error"), { deliverAs: "followUp" });
+    vi.useRealTimers();
   });
 
   it("turn_end stops retrying after max retries (non-SDK-retryable)", async () => {
@@ -3511,7 +3624,8 @@ describe("error retry", () => {
     await orchestrator.startTask(ctx as any, "implement", "retry max test");
     const turnEnd = pi._handlers.get("turn_end")!;
 
-    for (let i = 0; i < 6; i++) {
+    // 8 retries then a 9th error turn that trips the halt.
+    for (let i = 0; i < 9; i++) {
       await turnEnd({ message: { stopReason: "error", errorMessage: "invalid tool arguments", content: [] } }, ctx);
     }
 
@@ -4038,7 +4152,7 @@ describe("session lifecycle", () => {
     expect(toolNames).toContain("pp_register_repo");
   });
 
-  it("session_start detects paused tasks and notifies", async () => {
+  it("session_start does not notify about paused tasks (#1: all hints removed)", async () => {
     const cwd = makeTempDir();
     createTask(cwd, "implement", "Paused task");
     const pi = makePi();
@@ -4050,7 +4164,7 @@ describe("session lifecycle", () => {
     const sessionStart = pi._handlers.get("session_start")!;
     await sessionStart({}, ctx);
 
-    expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("Paused task"), "info");
+    expect(ctx.ui.notify).not.toHaveBeenCalledWith(expect.stringContaining("Paused task"), "info");
   });
 
   it("session_start loads config", async () => {
@@ -4082,29 +4196,31 @@ describe("menu contracts", () => {
 
     menu
       .expect({ question: "/pp", options: { include: ["Settings"] }, choose: "Settings" })
-      .expect({ question: "Settings", options: { exact: ["General", "Agents", "Commands", "Performance", "LSP", "Back"] }, choose: "Back" })
-      .expect({ question: "/pp", options: { include: ["Back"] }, choose: "Back" });
+      .expect({ question: "Settings", options: { exact: ["General", "Agents", "Commands", "Performance", "LSP", "Flant", "Info", "Back"] }, choose: "Back" })
+      .expect({ question: "/pp", options: { include: ["Back to prompt"] }, choose: "Back to prompt" });
 
     const pp = getCommand(pi, "pp");
     await pp(undefined, ctx);
   });
 
-  it("info menu shows Doctor and hides LSP", async () => {
+  it("info menu (under Settings) shows Doctor and hides LSP", async () => {
     const cwd = makeTempDir();
     const { pi } = await setupOrchestrator(cwd);
     const ctx = makeCtx();
 
     menu
-      .expect({ question: "/pp", options: { include: ["Info"] }, choose: "Info" })
+      .expect({ question: "/pp", options: { include: ["Settings"] }, choose: "Settings" })
+      .expect({ question: "Settings", options: { include: ["Info"] }, choose: "Info" })
       .expect({
         question: "Info",
         options: {
-          include: ["Subagents", "Usage", "Doctor", "Back"],
-          exclude: ["LSP"],
+          include: ["Usage", "Doctor", "Back"],
+          exclude: ["LSP", "Subagents"],
         },
         choose: "Back",
       })
-      .expect({ question: "/pp", options: { include: ["Back"] }, choose: "Back" });
+      .expect({ question: "Settings", options: { include: ["Back"] }, choose: "Back" })
+      .expect({ question: "/pp", options: { include: ["Back to prompt"] }, choose: "Back to prompt" });
 
     const pp = getCommand(pi, "pp");
     await pp(undefined, ctx);
@@ -4117,10 +4233,12 @@ describe("menu contracts", () => {
     const runDoctorSpy = vi.mocked(doctorModule.runDoctor);
 
     menu
-      .expect({ question: "/pp", options: { include: ["Info"] }, choose: "Info" })
+      .expect({ question: "/pp", options: { include: ["Settings"] }, choose: "Settings" })
+      .expect({ question: "Settings", options: { include: ["Info"] }, choose: "Info" })
       .expect({ question: "Info", options: { include: ["Doctor", "Back"] }, choose: "Doctor" })
       .expect({ question: "Info", options: { include: ["Back"] }, choose: "Back" })
-      .expect({ question: "/pp", options: { include: ["Back"] }, choose: "Back" });
+      .expect({ question: "Settings", options: { include: ["Back"] }, choose: "Back" })
+      .expect({ question: "/pp", options: { include: ["Back to prompt"] }, choose: "Back to prompt" });
 
     const pp = getCommand(pi, "pp");
     await pp(undefined, ctx);
@@ -4142,7 +4260,7 @@ describe("menu contracts", () => {
       .expect({ question: "LSP", options: { exact: ["Restart all servers", "Back"] }, choose: "Restart all servers" })
       .expect({ question: "LSP", options: { include: ["Back"] }, choose: "Back" })
       .expect({ question: "Settings", options: { include: ["Back"] }, choose: "Back" })
-      .expect({ question: "/pp", options: { include: ["Back"] }, choose: "Back" });
+      .expect({ question: "/pp", options: { include: ["Back to prompt"] }, choose: "Back to prompt" });
 
     const pp = getCommand(pi, "pp");
     await pp(undefined, ctx);
@@ -4162,7 +4280,7 @@ describe("menu contracts", () => {
       .expect({ question: "LSP", options: { exact: ["Restart all servers", "Back"] }, choose: "Restart all servers" })
       .expect({ question: "LSP", options: { include: ["Back"] }, choose: "Back" })
       .expect({ question: "Settings", options: { include: ["Back"] }, choose: "Back" })
-      .expect({ question: "/pp", options: { include: ["Back"] }, choose: "Back" });
+      .expect({ question: "/pp", options: { include: ["Back to prompt"] }, choose: "Back to prompt" });
 
     const pp = getCommand(pi, "pp");
     await pp(undefined, ctx);
@@ -4178,9 +4296,9 @@ describe("menu contracts", () => {
     menu
       .expect({ question: "/pp", options: { include: ["Settings"] }, choose: "Settings" })
       .expect({ question: "Settings", options: { include: ["Agents", "Back"] }, choose: "Agents" })
-      .expect({ question: "Agents", options: { exact: ["Orchestrators", "Subagents", "Back"] }, choose: "Back" })
+      .expect({ question: "Agents", options: { exact: ["Orchestrators", "Subagents", "Max concurrent subagents: 7", "Back"] }, choose: "Back" })
       .expect({ question: "Settings", options: { include: ["Back"] }, choose: "Back" })
-      .expect({ question: "/pp", options: { include: ["Back"] }, choose: "Back" });
+      .expect({ question: "/pp", options: { include: ["Back to prompt"] }, choose: "Back to prompt" });
 
     const pp = getCommand(pi, "pp");
     await pp(undefined, ctx);
@@ -4196,9 +4314,9 @@ describe("menu contracts", () => {
     menu.expect({
       question: m.taskMenu("implement", "brainstorm"),
       options: {
-        exact: ["Next", "Review", "Info", "Settings", "Back"],
+        exact: ["Next", "Review", "Subagents", "Settings", "Back to prompt"],
       },
-      choose: "Back",
+      choose: "Back to prompt",
     });
 
     const pp = getCommand(pi, "pp");
@@ -4218,9 +4336,9 @@ describe("menu contracts", () => {
     menu.expect({
       question: m.taskMenu("implement", "plan"),
       options: {
-        exact: ["Next", "Info", "Settings", "Back"],
+        exact: ["Next", "Subagents", "Settings", "Back to prompt"],
       },
-      choose: "Back",
+      choose: "Back to prompt",
     });
 
     const pp = getCommand(pi, "pp");
@@ -4239,9 +4357,9 @@ describe("menu contracts", () => {
     menu.expect({
       question: m.taskMenu("implement", "brainstorm"),
       options: {
-        exact: ["Next", "Review", "Info", "Settings", "Back"],
+        exact: ["Next", "Review", "Subagents", "Settings", "Back to prompt"],
       },
-      choose: "Back",
+      choose: "Back to prompt",
     });
 
     const pp = getCommand(pi, "pp");
@@ -4258,9 +4376,9 @@ describe("menu contracts", () => {
     menu.expect({
       question: m.taskMenu("debug", "debug"),
       options: {
-        exact: ["Next", "Review", "Info", "Settings", "Back"],
+        exact: ["Next", "Review", "Subagents", "Settings", "Back to prompt"],
       },
-      choose: "Back",
+      choose: "Back to prompt",
     });
 
     const pp = getCommand(pi, "pp");
@@ -4277,9 +4395,9 @@ describe("menu contracts", () => {
     menu.expect({
       question: m.taskMenu("review", "review"),
       options: {
-        exact: ["Next", "Review", "Info", "Settings", "Back"],
+        exact: ["Next", "Review", "Subagents", "Settings", "Back to prompt"],
       },
-      choose: "Back",
+      choose: "Back to prompt",
     });
 
     const pp = getCommand(pi, "pp");
@@ -4378,9 +4496,9 @@ describe("menu contracts", () => {
     menu.expect({
       question: m.taskMenu("quick", "quick"),
       options: {
-        exact: ["Complete", "Pause", "Info", "Settings", "Back"],
+        exact: ["Complete", "Pause", "Subagents", "Settings", "Back to prompt"],
       },
-      choose: "Back",
+      choose: "Back to prompt",
     });
 
     const pp = getCommand(pi, "pp");
@@ -4395,8 +4513,8 @@ describe("menu contracts", () => {
     await orchestrator.startTask(ctx as any, "implement", "contract next");
     menu
       .expect({ question: m.taskMenu("implement", "brainstorm"), options: { include: ["Next"] }, choose: "Next" })
-      .expect({ question: "Next", options: { exact: ["Continue to plan & implement", "Complete", "Pause", "Back"] }, choose: "Back" })
-      .expect({ question: m.taskMenu("implement", "brainstorm"), options: { include: ["Back"] }, choose: "Back" });
+      .expect({ question: "Next", options: { exact: ["Continue to plan & implement", "Auto review, then continue to plan & implement", "Complete", "Pause", "Back"] }, choose: "Back" })
+      .expect({ question: m.taskMenu("implement", "brainstorm"), options: { include: ["Back to prompt"] }, choose: "Back to prompt" });
 
     const pp = getCommand(pi, "pp");
     await pp(undefined, ctx);
@@ -4408,7 +4526,7 @@ describe("menu contracts", () => {
     menu
       .expect({ question: m.taskMenu("implement", "implement"), options: { include: ["Next"] }, choose: "Next" })
       .expect({ question: "Next", options: { exact: ["Complete", "Pause", "Back"] }, choose: "Back" })
-      .expect({ question: m.taskMenu("implement", "implement"), options: { include: ["Back"] }, choose: "Back" });
+      .expect({ question: m.taskMenu("implement", "implement"), options: { include: ["Back to prompt"] }, choose: "Back to prompt" });
 
     await pp(undefined, ctx);
   });
@@ -4422,8 +4540,8 @@ describe("menu contracts", () => {
 
     menu
       .expect({ question: m.taskMenu("implement", "brainstorm"), options: { include: ["Review"] }, choose: "Review" })
-      .expect({ question: "Review", options: { exact: [m.autoReview, "Review on my own", "Back"] }, choose: "Back" })
-      .expect({ question: m.taskMenu("implement", "brainstorm"), options: { include: ["Back"] }, choose: "Back" });
+      .expect({ question: "Review", options: { exact: [m.autoReview, "Auto review until approved", "Review in Plannotator", "Review on my own", "Back"] }, choose: "Back" })
+      .expect({ question: m.taskMenu("implement", "brainstorm"), options: { include: ["Back to prompt"] }, choose: "Back to prompt" });
 
     const pp = getCommand(pi, "pp");
     await pp(undefined, ctx);
@@ -4441,7 +4559,7 @@ describe("menu contracts", () => {
       .expect({ question: "Mode", options: { exact: ["Guided", "Autonomous", "Back"] }, choose: "Back" })
       .expect({ question: "Implement", options: { include: ["Back"] }, choose: "Back" })
       .expect({ question: "Task", options: { include: ["Back"] }, choose: "Back" })
-      .expect({ question: "/pp", options: { include: ["Back"] }, choose: "Back" });
+      .expect({ question: "/pp", options: { include: ["Back to prompt"] }, choose: "Back to prompt" });
 
     const pp = getCommand(pi, "pp");
     await pp(undefined, ctx);

package/extensions/orchestrator/model-registry.test.ts

@@ -248,9 +248,10 @@ describe("model-registry", () => {
 
   it("getModelFamilies returns all family definitions", () => {
     const families = getModelFamilies();
-    expect(families).toHaveLength(10);
+    expect(families).toHaveLength(11);
     expect(families.map((f) => f.family).sort()).toEqual([
       "deepseek",
+      "fable",
       "gemini-flash",
       "gemini-pro",
       "gpt",

package/extensions/orchestrator/model-registry.ts

@@ -1,7 +1,7 @@
 import { compareModelVersion } from "./model-version.js";
 
 export type Vendor = "anthropic" | "openai" | "google" | "deepseek" | "xai" | "qwen" | "unknown";
-export type Family = "opus" | "sonnet" | "haiku" | "gpt" | "gpt-mini" | "gemini-pro" | "gemini-flash" | "deepseek" | "grok" | "qwen" | "unknown";
+export type Family = "opus" | "fable" | "sonnet" | "haiku" | "gpt" | "gpt-mini" | "gemini-pro" | "gemini-flash" | "deepseek" | "grok" | "qwen" | "unknown";
 export type Tier = "stupid" | "regular" | "smart" | "xsmart" | "unknown";
 
 export interface ModelInfo {
@@ -13,7 +13,7 @@ export interface ModelInfo {
 
 type ProviderPrefix = "anthropic" | "openai" | "google" | "deepseek" | "x-ai" | "qwen" | "pp-flant-anthropic" | "pp-flant-anthropic-sub" | "pp-flant-openai";
 type KnownVendor = "anthropic" | "openai" | "google" | "deepseek" | "xai" | "qwen";
-type KnownFamily = "opus" | "sonnet" | "haiku" | "gpt" | "gpt-mini" | "gemini-pro" | "gemini-flash" | "deepseek" | "grok" | "qwen";
+type KnownFamily = "opus" | "fable" | "sonnet" | "haiku" | "gpt" | "gpt-mini" | "gemini-pro" | "gemini-flash" | "deepseek" | "grok" | "qwen";
 type KnownTier = "stupid" | "regular" | "smart" | "xsmart";
 
 export interface ModelFamilyDefinition {
@@ -47,6 +47,16 @@ export const MODEL_FAMILIES: ModelFamilyDefinition[] = [
     providers: ["anthropic", "pp-flant-anthropic", "pp-flant-anthropic-sub"],
     nativeLatestProviders: ["anthropic"],
   },
+  {
+    vendor: "anthropic",
+    family: "fable",
+    tier: "xsmart",
+    displayName: "Claude Fable",
+    patterns: [/^(anthropic|pp-flant-anthropic)\/claude-fable-[a-z0-9.-]+$/, /^pp-flant-anthropic-sub\/sub\/claude-fable-[a-z0-9.-]+$/],
+    aliasTemplate: "claude-fable-latest",
+    providers: ["anthropic", "pp-flant-anthropic", "pp-flant-anthropic-sub"],
+    nativeLatestProviders: ["anthropic"],
+  },
   {
     vendor: "anthropic",
     family: "sonnet",

package/extensions/orchestrator/orchestrator.test.ts

@@ -123,6 +123,46 @@ describe("Orchestrator.safeSendUserMessage", () => {
   });
 });
 
+describe("Orchestrator.deliverReviewReady (item 9: no editor leak on /pp close)", () => {
+  function setup() {
+    const sendUserMessage = vi.fn();
+    const orchestrator = new Orchestrator(makePi({ sendUserMessage }));
+    orchestrator.active = makeActiveTask(null);
+    // isIdle true so sendUserMessageWhenIdle delivers synchronously.
+    orchestrator.lastCtx = { isIdle: () => true };
+    return { orchestrator, sendUserMessage };
+  }
+
+  it("does NOT queue the banner while a menu/ask dialogue is live (nothing to leak on ESC)", () => {
+    const { orchestrator, sendUserMessage } = setup();
+    orchestrator.interactivePromptOpen = true;
+    orchestrator.deliverReviewReady("[PI-PI] Review cycle is ready for apply_feedback.");
+    expect(sendUserMessage).not.toHaveBeenCalled();
+    expect(orchestrator.pendingReviewReady).toContain("ready for apply_feedback");
+  });
+
+  it("delivers exactly once as a fresh turn when the dialogue closes, then never re-fires", () => {
+    const { orchestrator, sendUserMessage } = setup();
+    orchestrator.interactivePromptOpen = true;
+    orchestrator.deliverReviewReady("[PI-PI] Review cycle is ready for apply_feedback.");
+    orchestrator.interactivePromptOpen = false;
+    orchestrator.flushPendingReviewReady();
+    expect(sendUserMessage).toHaveBeenCalledTimes(1);
+    expect(orchestrator.pendingReviewReady).toBeNull();
+    // A second flush (e.g. a later idle) must not re-send.
+    orchestrator.flushPendingReviewReady();
+    expect(sendUserMessage).toHaveBeenCalledTimes(1);
+  });
+
+  it("delivers immediately when no dialogue is open", () => {
+    const { orchestrator, sendUserMessage } = setup();
+    orchestrator.interactivePromptOpen = false;
+    orchestrator.deliverReviewReady("[PI-PI] Review cycle is ready for apply_feedback.");
+    expect(sendUserMessage).toHaveBeenCalledTimes(1);
+    expect(orchestrator.pendingReviewReady).toBeNull();
+  });
+});
+
 describe("Orchestrator.cancelPendingRetry", () => {
   it("clears the pending timer, disarms the ESC interrupt, and resets the counter", () => {
     vi.useFakeTimers();
@@ -404,6 +444,33 @@ describe("Orchestrator.checkForConflictingExtensions", () => {
   });
 });
 
+describe("Orchestrator.applySubagentConcurrency", () => {
+  const MANAGER_KEY = Symbol.for("pi-subagents:manager");
+
+  afterEach(() => {
+    delete (globalThis as any)[MANAGER_KEY];
+  });
+
+  it("applies the configured limit to the manager handle", () => {
+    const setMaxConcurrent = vi.fn();
+    (globalThis as any)[MANAGER_KEY] = { setMaxConcurrent };
+    const orchestrator = new Orchestrator(makePi());
+    orchestrator.config = getDefaultConfig() as any;
+    orchestrator.config.agents.maxConcurrentSubagents = 7;
+
+    orchestrator.applySubagentConcurrency();
+
+    expect(setMaxConcurrent).toHaveBeenCalledWith(7);
+  });
+
+  it("no-ops when the manager handle is absent", () => {
+    const orchestrator = new Orchestrator(makePi());
+    orchestrator.config = getDefaultConfig() as any;
+
+    expect(() => orchestrator.applySubagentConcurrency()).not.toThrow();
+  });
+});
+
 describe("Orchestrator.abortAllSubagents", () => {
   it("emits stop events for all spawned subagents and clears the set", () => {
     const emit = vi.fn();