@ilya-lesikov/pi-pi 0.10.0 → 0.12.0

package/extensions/orchestrator/integration.test.ts

@@ -331,6 +331,16 @@ function getTool(pi: ReturnType<typeof makePi>, name: string): any {
   return tool;
 }
 
+// The pp_phase_complete reconcile gate returns a one-time "reconcile your state
+// files" directive on the FIRST completion call of each phase; the real
+// advancement/spawn happens on the acknowledging re-call. Tests that assert
+// post-completion behavior go through this helper so the gate is observable.
+async function completePhase(tool: any, callId: string, summary: string, ctx: any) {
+  const first = await tool.execute(`${callId}-reconcile`, { summary }, undefined, undefined, ctx);
+  expect(first.content[0].text).toContain("reconcile the task's state files");
+  return tool.execute(callId, { summary }, undefined, undefined, ctx);
+}
+
 function emitSubagentCreated(pi: ReturnType<typeof makePi>, id: string, description: string) {
   pi.events.emit("subagents:created", { id, description });
 }
@@ -368,7 +378,7 @@ async function moveTaskToImplementPhase(
 
   expectBrainstormToPlan(menu);
   const ppPhaseComplete = getTool(pi, "pp_phase_complete");
-  await ppPhaseComplete.execute(firstCallId, { summary: "phase complete" }, undefined, undefined, ctx);
+  await completePhase(ppPhaseComplete, firstCallId, "phase complete", ctx);
   await new Promise((r) => setTimeout(r, 10));
 
   const plansDir = join(taskDir, "plans");
@@ -388,7 +398,7 @@ async function moveTaskToImplementPhase(
   );
 
   expectPlanToImplement(menu);
-  await ppPhaseComplete.execute(secondCallId, { summary: "plan complete" }, undefined, undefined, ctx);
+  await completePhase(ppPhaseComplete, secondCallId, "plan complete", ctx);
   await new Promise((r) => setTimeout(r, 10));
 }
 
@@ -412,7 +422,7 @@ describe("implement pipeline: brainstorm → plan → implement → done", () =>
     expectBrainstormToPlan(menu);
 
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
-    const result1 = await ppPhaseComplete.execute("call-1", { summary: "Research complete" }, undefined, undefined, ctx);
+    const result1 = await completePhase(ppPhaseComplete, "call-1", "Research complete", ctx);
     expect(result1.content[0].text).toBeDefined();
 
     await new Promise((r) => setTimeout(r, 10));
@@ -447,7 +457,7 @@ describe("implement pipeline: brainstorm → plan → implement → done", () =>
 
     expectPlanToImplement(menu);
 
-    const result2 = await ppPhaseComplete.execute("call-2", { summary: "Plan synthesized" }, undefined, undefined, ctx);
+    const result2 = await completePhase(ppPhaseComplete, "call-2", "Plan synthesized", ctx);
     expect(result2.content[0]).toBeDefined();
 
     await new Promise((r) => setTimeout(r, 10));
@@ -460,7 +470,7 @@ describe("implement pipeline: brainstorm → plan → implement → done", () =>
 
     expectImplementToDone(menu);
 
-    const result3 = await ppPhaseComplete.execute("call-3", { summary: "All items implemented" }, undefined, undefined, ctx);
+    const result3 = await completePhase(ppPhaseComplete, "call-3", "All items implemented", ctx);
     expect(result3.content[0]).toBeDefined();
 
     expect(orchestrator.active).toBeNull();
@@ -475,6 +485,7 @@ describe("implement pipeline: brainstorm → plan → implement → done", () =>
     const ctx = makeCtx();
 
     await orchestrator.startTask(ctx as any, "implement", "Test task");
+    orchestrator.active!.state.reconciledPhase = orchestrator.active!.state.phase;
 
     expectBrainstormToPlan(menu);
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
@@ -497,7 +508,7 @@ describe("implement pipeline: brainstorm → plan → implement → done", () =>
 
     expectBrainstormToPlan(menu);
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
-    await ppPhaseComplete.execute("call-1", { summary: "done" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "call-1", "done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     emitSubagentCreated(pi, "planner-1", "Planner (test)");
@@ -517,7 +528,7 @@ describe("implement pipeline: brainstorm → plan → implement → done", () =>
     );
 
     expectPlanToImplement(menu);
-    await ppPhaseComplete.execute("call-2", { summary: "plan done" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "call-2", "plan done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     expect(orchestrator.active!.state.phase).toBe("implement");
@@ -545,7 +556,7 @@ describe("review cycle lifecycle", () => {
 
     expectBrainstormToPlan(menu);
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
-    await ppPhaseComplete.execute("call-1", { summary: "done" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "call-1", "done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     emitSubagentCreated(pi, "planner-1", "Planner (test)");
@@ -565,13 +576,13 @@ describe("review cycle lifecycle", () => {
     );
 
     expectPlanToImplement(menu);
-    await ppPhaseComplete.execute("call-2", { summary: "plan done" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "call-2", "plan done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     expect(orchestrator.active!.state.phase).toBe("implement");
 
     expectReviewAuto(menu);
-    const result = await ppPhaseComplete.execute("call-3", { summary: "implemented" }, undefined, undefined, ctx);
+    const result = await completePhase(ppPhaseComplete, "call-3", "implemented", ctx);
     expect(result.content[0].text).toContain("Waiting for reviewers");
 
     expect(orchestrator.active!.state.reviewCycle).not.toBeNull();
@@ -612,7 +623,7 @@ describe("review cycle lifecycle", () => {
     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 completePhase(ppPhaseComplete, "call-1", "done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     emitSubagentCreated(pi, "planner-1", "Planner (test)");
@@ -631,11 +642,11 @@ describe("review cycle lifecycle", () => {
       "utf-8",
     );
     expectPlanToImplement(menu);
-    await ppPhaseComplete.execute("call-2", { summary: "plan done" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "call-2", "plan done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     expectReviewAuto(menu);
-    await ppPhaseComplete.execute("call-3", { summary: "implemented" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "call-3", "implemented", ctx);
 
     emitSubagentCreated(pi, "reviewer-1", "Code reviewer (test)");
     emitSubagentFailed(pi, "reviewer-1", "model error");
@@ -674,7 +685,7 @@ describe("review cycle lifecycle", () => {
     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 completePhase(ppPhaseComplete, "call-1", "done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     emitSubagentCreated(pi, "planner-1", "Planner (test)");
@@ -693,7 +704,7 @@ describe("review cycle lifecycle", () => {
       "utf-8",
     );
     expectPlanToImplement(menu);
-    await ppPhaseComplete.execute("call-2", { summary: "plan done" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "call-2", "plan done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     // Pick the auto preset first: with zero enabled reviewers it notifies and
@@ -702,11 +713,85 @@ describe("review cycle lifecycle", () => {
     expectReviewAuto(menu);
     menu.expect({ question: "Review", options: { include: ["Review on my own"] }, choose: "Review on my own" });
     menu.expect({ question: "Editor review", options: { include: ["Skip markers"] }, choose: "Skip markers" });
-    const result = await ppPhaseComplete.execute("call-3", { summary: "implemented" }, undefined, undefined, ctx);
+    const result = await completePhase(ppPhaseComplete, "call-3", "implemented", ctx);
 
     expect(result.content[0].text).toContain("continue");
     expect(orchestrator.active!.state.reviewCycle).toBeNull();
   });
+
+  it("manual /pp Review on an un-reconciled phase warns and cancels without spawning", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "stale review cancel");
+    const taskDir = orchestrator.active!.dir;
+    orchestrator.active!.state.phase = "implement";
+    orchestrator.active!.state.step = "llm_work";
+    // No reconciledPhase stamp → the phase is stale; the manual Review path must warn.
+    saveTask(taskDir, orchestrator.active!.state);
+    const plansDir = join(taskDir, "plans");
+    mkdirSync(plansDir, { recursive: true });
+    writeFileSync(join(plansDir, `${Math.floor(Date.now() / 1000)}_synthesized.md`), makeValidPlan(["- [x] P1 — Done when: done"]), "utf-8");
+
+    expectReviewAuto(menu);
+    menu.expect({ question: /may not include the agent's latest findings/, options: { include: ["Review anyway", "Cancel"] }, choose: "Cancel" });
+    menu.expect({ question: "Review", options: { include: [m.autoReview] }, choose: "Back" });
+    menu.expect({ question: m.anyTaskMenu, options: { include: ["Back to prompt"] }, choose: "Back to prompt" });
+
+    const pp = getCommand(pi, "pp");
+    await pp(undefined, ctx);
+
+    expect(orchestrator.active!.state.reviewCycle).toBeNull();
+    expect(orchestrator.active!.state.step).toBe("llm_work");
+  });
+
+  it("manual /pp Review 'Review anyway' proceeds and keeps reconcilePending for the next agent turn", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "stale review proceed");
+    orchestrator.config = {
+      ...orchestrator.config,
+      agents: {
+        ...orchestrator.config.agents,
+        subagents: {
+          ...orchestrator.config.agents.subagents,
+          presetGroups: {
+            ...orchestrator.config.agents.subagents.presetGroups,
+            codeReviewers: {
+              ...orchestrator.config.agents.subagents.presetGroups.codeReviewers,
+              presets: {
+                ...orchestrator.config.agents.subagents.presetGroups.codeReviewers.presets,
+                regular: { enabled: true, agents: {} },
+              },
+            },
+          },
+        },
+      },
+    } as any;
+    const taskDir = orchestrator.active!.dir;
+    orchestrator.active!.state.phase = "implement";
+    orchestrator.active!.state.step = "llm_work";
+    saveTask(taskDir, orchestrator.active!.state);
+    const plansDir = join(taskDir, "plans");
+    mkdirSync(plansDir, { recursive: true });
+    writeFileSync(join(plansDir, `${Math.floor(Date.now() / 1000)}_synthesized.md`), makeValidPlan(["- [x] P1 — Done when: done"]), "utf-8");
+
+    // Zero configured agents under the enabled preset → after confirming, the flow
+    // notifies "no reviewers" and loops back, letting us assert the confirm's effect
+    // (reconcilePending stays set) without a real reviewer spawn.
+    expectReviewAuto(menu);
+    menu.expect({ question: /may not include the agent's latest findings/, options: { include: ["Review anyway"] }, choose: "Review anyway" });
+    menu.expect({ question: "Review", options: { include: [m.autoReview] }, choose: "Back" });
+    menu.expect({ question: m.anyTaskMenu, options: { include: ["Back to prompt"] }, choose: "Back to prompt" });
+
+    const pp = getCommand(pi, "pp");
+    await pp(undefined, ctx);
+
+    expect(loadTask(taskDir).reconcilePending).toBe(true);
+  });
 });
 
 describe("subagent instrumentation", () => {
@@ -802,7 +887,7 @@ describe("standalone brainstorm", () => {
     expectImplementToDone(menu);
 
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
-    const result = await ppPhaseComplete.execute("call-1", { summary: "Explored ideas" }, undefined, undefined, ctx);
+    const result = await completePhase(ppPhaseComplete, "call-1", "Explored ideas", ctx);
     expect(result.content[0].text).toBe("");
 
     expect(orchestrator.active).toBeNull();
@@ -826,7 +911,7 @@ describe("standalone brainstorm", () => {
       .expect({ question: "Planner preset", options: { include: [m.preset("regular"), "Back"] }, choose: m.preset("regular") });
 
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
-    await ppPhaseComplete.execute("call-1", { summary: "Conclusions ready" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "call-1", "Conclusions ready", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     expect(orchestrator.active!.type).toBe("brainstorm");
@@ -835,33 +920,6 @@ describe("standalone brainstorm", () => {
   });
 });
 
-describe("debug flow", () => {
-  it("finishes debug and can start implementation", async () => {
-    const cwd = makeTempDir();
-    const { pi, orchestrator } = await setupOrchestrator(cwd);
-    const ctx = makeCtx();
-
-    await orchestrator.startTask(ctx as any, "debug", "Fix timeout bug");
-
-    expect(orchestrator.active!.state.phase).toBe("debug");
-    expect(orchestrator.active!.type).toBe("debug");
-
-    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: "Diagnosis complete" }, undefined, undefined, ctx);
-    await new Promise((r) => setTimeout(r, 10));
-
-    expect(orchestrator.active!.type).toBe("debug");
-    expect(orchestrator.active!.state.phase).toBe("plan");
-    expect(orchestrator.active!.state.step).toBe("await_planners");
-  });
-});
-
 describe("planner completion tracking", () => {
   it("transitions await_planners → synthesize when all planners complete", async () => {
     const cwd = makeTempDir();
@@ -876,7 +934,7 @@ describe("planner completion tracking", () => {
 
     expectBrainstormToPlan(menu);
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
-    await ppPhaseComplete.execute("call-1", { summary: "done" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "call-1", "done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     expect(orchestrator.active!.state.phase).toBe("plan");
@@ -910,7 +968,7 @@ describe("planner completion tracking", () => {
 
     expectBrainstormToPlan(menu);
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
-    await ppPhaseComplete.execute("call-1", { summary: "done" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "call-1", "done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     emitSubagentCreated(pi, "planner-1", "Planner (test)");
@@ -957,7 +1015,7 @@ describe("planner completion tracking", () => {
 
     expectBrainstormToPlan(menu);
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
-    await ppPhaseComplete.execute("call-1", { summary: "done" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "call-1", "done", ctx);
 
     expect(orchestrator.active!.state.phase).toBe("plan");
     expect(orchestrator.active!.state.step).toBe("await_planners");
@@ -985,7 +1043,7 @@ describe("planner completion tracking", () => {
 
     expectBrainstormToPlan(menu);
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
-    await ppPhaseComplete.execute("call-1", { summary: "done" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "call-1", "done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     const plansDir = join(taskDir, "plans");
@@ -1060,12 +1118,62 @@ describe("pp:done cancellation", () => {
 
     expectImplementToDone(menu);
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
-    await ppPhaseComplete.execute("call-1", { summary: "done" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "call-1", "done", ctx);
 
     expect(orchestrator.active).toBeNull();
     const state = loadTask(taskDir);
     expect(state.phase).toBe("done");
   });
+
+  it("autonomous task reaching done emits a terminal assumptions summary", async () => {
+    const cwd = makeTempDir();
+    const { orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "terminal assumptions", undefined, undefined, "autonomous");
+    const taskDir = orchestrator.active!.dir;
+    orchestrator.active!.state.phase = "implement";
+    orchestrator.active!.state.reconciledPhase = "implement";
+    saveTask(taskDir, orchestrator.active!.state);
+    const plansDir = join(taskDir, "plans");
+    mkdirSync(plansDir, { recursive: true });
+    writeFileSync(join(plansDir, `${Math.floor(Date.now() / 1000)}_synthesized.md`), makeValidPlan(["- [x] Done — Done when: shipped"]), "utf-8");
+    mkdirSync(join(taskDir, "artifacts"), { recursive: true });
+    writeFileSync(
+      join(taskDir, "artifacts", "ASSUMPTIONS.md"),
+      "# Assumptions\n\n- statement: build is hermetic; confidence: med; status: open\n",
+      "utf-8",
+    );
+
+    await orchestrator.transitionToNextPhase(ctx as any);
+
+    const summaryCall = (ctx.ui.notify as any).mock.calls.find((c: any[]) => String(c[0]).includes("Assumptions recorded this run"));
+    expect(summaryCall).toBeTruthy();
+    expect(String(summaryCall[0])).toContain("build is hermetic");
+    expect(loadTask(taskDir).phase).toBe("done");
+  });
+
+  it("guided task reaching done does NOT emit a terminal assumptions summary", async () => {
+    const cwd = makeTempDir();
+    const { orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "no terminal assumptions");
+    const taskDir = orchestrator.active!.dir;
+    orchestrator.active!.state.phase = "implement";
+    orchestrator.active!.state.reconciledPhase = "implement";
+    saveTask(taskDir, orchestrator.active!.state);
+    const plansDir = join(taskDir, "plans");
+    mkdirSync(plansDir, { recursive: true });
+    writeFileSync(join(plansDir, `${Math.floor(Date.now() / 1000)}_synthesized.md`), makeValidPlan(["- [x] Done — Done when: shipped"]), "utf-8");
+    mkdirSync(join(taskDir, "artifacts"), { recursive: true });
+    writeFileSync(join(taskDir, "artifacts", "ASSUMPTIONS.md"), "# A\n\n- statement: x; confidence: low; status: open\n", "utf-8");
+
+    await orchestrator.transitionToNextPhase(ctx as any);
+
+    const summaryCall = (ctx.ui.notify as any).mock.calls.find((c: any[]) => String(c[0]).includes("Assumptions recorded this run"));
+    expect(summaryCall).toBeFalsy();
+  });
 });
 
 describe("edge cases and regressions", () => {
@@ -1220,7 +1328,7 @@ describe("edge cases and regressions", () => {
     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 completePhase(ppPhaseComplete, "call-1", "done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     emitSubagentCreated(pi, "planner-1", "Planner (test)");
@@ -1239,11 +1347,11 @@ describe("edge cases and regressions", () => {
       "utf-8",
     );
     expectPlanToImplement(menu);
-    await ppPhaseComplete.execute("call-2", { summary: "plan done" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "call-2", "plan done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     expectReviewAuto(menu);
-    await ppPhaseComplete.execute("call-3", { summary: "implemented" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "call-3", "implemented", ctx);
 
     const reviewsDir = join(taskDir, "code-reviews");
     mkdirSync(reviewsDir, { recursive: true });
@@ -1274,7 +1382,7 @@ describe("edge cases and regressions", () => {
     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 completePhase(ppPhaseComplete, "call-1", "done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     emitSubagentCreated(pi, "planner-1", "Planner (test)");
@@ -1293,13 +1401,13 @@ describe("edge cases and regressions", () => {
       "utf-8",
     );
     expectPlanToImplement(menu);
-    await ppPhaseComplete.execute("call-2", { summary: "plan done" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "call-2", "plan done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     expect(orchestrator.active!.state.phase).toBe("implement");
 
     expectReviewAuto(menu);
-    await ppPhaseComplete.execute("call-3", { summary: "implemented" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "call-3", "implemented", ctx);
 
     const reviewsDir = join(taskDir, "code-reviews");
     mkdirSync(reviewsDir, { recursive: true });
@@ -1355,6 +1463,7 @@ describe("edge cases and regressions", () => {
     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 };
+    orchestrator.active!.state.reconciledPhase = "implement";
     saveTask(taskDir, orchestrator.active!.state);
 
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
@@ -1386,7 +1495,7 @@ describe("edge cases and regressions", () => {
 
     expectReviewOnMyOwn(menu, "Skip markers");
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
-    const result = await ppPhaseComplete.execute("call-1", { summary: "not done yet" }, undefined, undefined, ctx);
+    const result = await completePhase(ppPhaseComplete, "call-1", "not done yet", ctx);
 
     expect(result.content[0].text).toContain("continue");
     expect(orchestrator.active!.state.phase).toBe("brainstorm");
@@ -1405,7 +1514,7 @@ describe("edge cases and regressions", () => {
     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 completePhase(ppPhaseComplete, "call-1", "done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     emitSubagentCreated(pi, "planner-1", "Planner (test)");
@@ -1424,11 +1533,11 @@ describe("edge cases and regressions", () => {
       "utf-8",
     );
     expectPlanToImplement(menu);
-    await ppPhaseComplete.execute("call-2", { summary: "plan done" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "call-2", "plan done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     expectReviewOnMyOwn(menu, "Skip markers");
-    const result = await ppPhaseComplete.execute("call-3", { summary: "partial work" }, undefined, undefined, ctx);
+    const result = await completePhase(ppPhaseComplete, "call-3", "partial work", ctx);
 
     expect(result.content[0].text).toContain("continue");
     expect(orchestrator.active!.state.phase).toBe("implement");
@@ -1447,7 +1556,7 @@ describe("edge cases and regressions", () => {
     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 completePhase(ppPhaseComplete, "call-1", "done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     emitSubagentCreated(pi, "planner-1", "Planner (test)");
@@ -1467,7 +1576,7 @@ describe("edge cases and regressions", () => {
     );
 
     expectReviewOnMyOwn(menu, "Skip markers");
-    const result = await ppPhaseComplete.execute("call-2", { summary: "plan ready" }, undefined, undefined, ctx);
+    const result = await completePhase(ppPhaseComplete, "call-2", "plan ready", ctx);
 
     expect(result.content[0].text).toContain("continue");
     expect(orchestrator.active!.state.phase).toBe("plan");
@@ -1485,7 +1594,7 @@ describe("edge cases and regressions", () => {
     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 completePhase(ppPhaseComplete, "call-1", "done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     emitSubagentCreated(pi, "planner-1", "Planner (test)");
@@ -1503,11 +1612,11 @@ describe("edge cases and regressions", () => {
       "utf-8",
     );
     expectPlanToImplement(menu);
-    await ppPhaseComplete.execute("call-2", { summary: "plan done" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "call-2", "plan done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     expectReviewOnMyOwn(menu, "Done");
-    const result = await ppPhaseComplete.execute("call-3", { summary: "implemented" }, undefined, undefined, ctx);
+    const result = await completePhase(ppPhaseComplete, "call-3", "implemented", ctx);
 
     expect(result.content[0].text).toContain("AI_REVIEW:");
     expect(result.content[0].text).toContain("CHANGED files");
@@ -1524,7 +1633,7 @@ describe("edge cases and regressions", () => {
 
     expectReviewOnMyOwn(menu, "Done");
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
-    const result = await ppPhaseComplete.execute("call-1", { summary: "researched" }, undefined, undefined, ctx);
+    const result = await completePhase(ppPhaseComplete, "call-1", "researched", ctx);
 
     expect(result.content[0].text).toContain("AI_REVIEW:");
     expect(result.content[0].text).toContain("USER_REQUEST.md");
@@ -1535,24 +1644,6 @@ describe("edge cases and regressions", () => {
     expect(orchestrator.active!.state.step).toBe("llm_work");
   });
 
-  it("editor-review Done returns AI_REVIEW state-file instructions in debug phase", async () => {
-    const cwd = makeTempDir();
-    const { pi, orchestrator } = await setupOrchestrator(cwd);
-    const ctx = makeCtx();
-
-    await orchestrator.startTask(ctx as any, "debug", "Debug editor review");
-
-    expectReviewOnMyOwn(menu, "Done");
-    const ppPhaseComplete = getTool(pi, "pp_phase_complete");
-    const result = await ppPhaseComplete.execute("call-1", { summary: "diagnosed" }, undefined, undefined, ctx);
-
-    expect(result.content[0].text).toContain("AI_REVIEW:");
-    expect(result.content[0].text).toContain("USER_REQUEST.md");
-    expect(result.content[0].text).not.toContain("CHANGED files");
-    expect(orchestrator.active!.state.phase).toBe("debug");
-    expect(orchestrator.active!.state.step).toBe("llm_work");
-  });
-
   it("editor-review Done targets synthesized plan in plan phase", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -1564,7 +1655,7 @@ describe("edge cases and regressions", () => {
     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 completePhase(ppPhaseComplete, "call-1", "done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     emitSubagentCreated(pi, "planner-1", "Planner (test)");
@@ -1583,7 +1674,7 @@ describe("edge cases and regressions", () => {
     );
 
     expectReviewOnMyOwn(menu, "Done");
-    const result = await ppPhaseComplete.execute("call-2", { summary: "plan ready" }, undefined, undefined, ctx);
+    const result = await completePhase(ppPhaseComplete, "call-2", "plan ready", ctx);
 
     expect(result.content[0].text).toContain("AI_REVIEW:");
     expect(result.content[0].text).toContain("_synthesized.md");
@@ -1606,17 +1697,17 @@ describe("edge cases and regressions", () => {
     expect(sendUserCalls.length).toBe(0);
   });
 
-  it("implement --from debug skips brainstorm", async () => {
+  it("implement --from review skips brainstorm", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
     const ctx = makeCtx();
 
-    await orchestrator.startTask(ctx as any, "debug", "Find bug");
-    const debugDir = orchestrator.active!.dir;
-    writeFileSync(join(debugDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
-    writeFileSync(join(debugDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
+    await orchestrator.startTask(ctx as any, "review", "Find bug");
+    const reviewDir = orchestrator.active!.dir;
+    writeFileSync(join(reviewDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
+    writeFileSync(join(reviewDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
 
-    await orchestrator.startTask(ctx as any, "implement", "Fix it", debugDir, true);
+    await orchestrator.startTask(ctx as any, "implement", "Fix it", reviewDir, true);
 
     expect(orchestrator.active!.state.phase).toBe("plan");
     expect(orchestrator.active!.state.step).toBe("await_planners");
@@ -1624,17 +1715,17 @@ describe("edge cases and regressions", () => {
     expect(existsSync(join(orchestrator.active!.dir, "RESEARCH.md"))).toBe(true);
   });
 
-  it("implement --from debug with generic description skips blank-task prompt", async () => {
+  it("implement --from review with generic description skips blank-task prompt", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
     const ctx = makeCtx();
 
-    await orchestrator.startTask(ctx as any, "debug", "Find bug");
-    const debugDir = orchestrator.active!.dir;
-    writeFileSync(join(debugDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
-    writeFileSync(join(debugDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
+    await orchestrator.startTask(ctx as any, "review", "Find bug");
+    const reviewDir = orchestrator.active!.dir;
+    writeFileSync(join(reviewDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
+    writeFileSync(join(reviewDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
 
-    await orchestrator.startTask(ctx as any, "implement", "implement", debugDir, true);
+    await orchestrator.startTask(ctx as any, "implement", "implement", reviewDir, true);
 
     expect(ctx.ui.notify).not.toHaveBeenCalledWith("Task created. Describe what you'd like to do.", "info");
     expect(ctx.ui.notify).toHaveBeenCalledWith("Entered plan phase. Waiting for planners to complete before synthesis.", "info");
@@ -1661,22 +1752,22 @@ describe("edge cases and regressions", () => {
     expect(existsSync(join(orchestrator.active!.dir, "RESEARCH.md"))).toBe(true);
   });
 
-  it("implement from debug task stores source path and skips brainstorm", async () => {
+  it("implement from review task stores source path and skips brainstorm", async () => {
     const cwd = makeTempDir();
     const { orchestrator } = await setupOrchestrator(cwd);
     const ctx = makeCtx();
 
-    await orchestrator.startTask(ctx as any, "debug", "Find bug");
-    const debugDir = orchestrator.active!.dir;
-    writeFileSync(join(debugDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
-    writeFileSync(join(debugDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
+    await orchestrator.startTask(ctx as any, "review", "Find bug");
+    const reviewDir = orchestrator.active!.dir;
+    writeFileSync(join(reviewDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
+    writeFileSync(join(reviewDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
 
-    await orchestrator.startTask(ctx as any, "implement", "implement", debugDir, true);
+    await orchestrator.startTask(ctx as any, "implement", "implement", reviewDir, true);
 
     expect(orchestrator.active!.type).toBe("implement");
     expect(orchestrator.active!.state.phase).toBe("plan");
     expect(orchestrator.active!.state.step).toBe("await_planners");
-    expect(orchestrator.active!.state.from).toBe(`debug/${debugDir.split("/").pop()}`);
+    expect(orchestrator.active!.state.from).toBe(`review/${reviewDir.split("/").pop()}`);
     expect(orchestrator.active!.state.description).toBe("implement");
     expect(ctx.ui.notify).toHaveBeenCalledWith("Entered plan phase. Waiting for planners to complete before synthesis.", "info");
   });
@@ -1777,6 +1868,7 @@ describe("task modes and quick task", () => {
     // even for an autonomous task, so auto-advance only applies from plan onward.
     orchestrator.active!.state.phase = "plan";
     orchestrator.active!.state.step = "llm_work";
+    orchestrator.active!.state.reconciledPhase = "plan";
     const plansDir = join(taskDir, "plans");
     mkdirSync(plansDir, { recursive: true });
     writeFileSync(
@@ -1820,7 +1912,7 @@ describe("task modes and quick task", () => {
     // 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 completePhase(ppPhaseComplete, "call-1", "done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     // The guided menu was shown (auto-advance did NOT bypass it).
@@ -1833,6 +1925,7 @@ describe("task modes and quick task", () => {
     const ctx = makeCtx();
 
     await orchestrator.startTask(ctx as any, "implement", "esc dismiss");
+    orchestrator.active!.state.reconciledPhase = orchestrator.active!.state.phase;
     // 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);
@@ -1853,6 +1946,7 @@ describe("task modes and quick task", () => {
     const ctx = makeCtx();
 
     await orchestrator.startTask(ctx as any, "implement", "back dismiss");
+    orchestrator.active!.state.reconciledPhase = orchestrator.active!.state.phase;
     expect(orchestrator.transitionController.isRunning()).toBe(true);
 
     // Explicit "Back" navigation (not an ESC): the reminder must be preserved.
@@ -1893,6 +1987,7 @@ describe("task modes and quick task", () => {
     orchestrator.active!.state.step = "llm_work";
     orchestrator.active!.state.reviewPass = 0;
     orchestrator.active!.state.reviewPassByKind = {};
+    orchestrator.active!.state.reconciledPhase = "implement";
     orchestrator.active!.state.autonomousConfig = {
       phases: {
         implement: { reviewPreset: "regular", maxReviewPasses: 2 },
@@ -1964,6 +2059,7 @@ describe("task modes and quick task", () => {
       "utf-8",
     );
 
+    orchestrator.active!.state.reconciledPhase = "implement";
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
     const first = await ppPhaseComplete.execute("call-1", { summary: "done" }, undefined, undefined, ctx);
     expect(first.content[0].text).toMatch(/Reviews are running|Started review cycle pass/);
@@ -1991,6 +2087,46 @@ describe("task modes and quick task", () => {
     expect(finalState.reviewPassByKind?.implement?.auto).toBe(1);
   });
 
+  it("autonomous review disabled with maxReviewPasses:0 advances without spawning reviewers", 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.phase = "implement";
+    orchestrator.active!.state.step = "llm_work";
+    orchestrator.active!.state.reviewPass = 0;
+    orchestrator.active!.state.reviewPassByKind = {};
+    orchestrator.active!.state.autonomousConfig = {
+      phases: { 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");
+    const plansDir = join(taskDir, "plans");
+    mkdirSync(plansDir, { recursive: true });
+    writeFileSync(
+      join(plansDir, "1_synthesized.md"),
+      makeValidPlan(["- [x] P1. Done item — Done when: synthesized plan is fully checked"]),
+      "utf-8",
+    );
+
+    orchestrator.active!.state.reconciledPhase = "implement";
+    const ppPhaseComplete = getTool(pi, "pp_phase_complete");
+    // implement→done is the terminal handoff, so the guided menu opens instead of
+    // auto-completing; the key assertion is that NO review cycle was ever entered.
+    expectImplementToDone(menu);
+    const result = await ppPhaseComplete.execute("call-1", { summary: "done" }, undefined, undefined, ctx);
+
+    expect(result.content[0].text).not.toMatch(/Reviews are running|review cycle/i);
+    expect(orchestrator.active).toBeNull();
+    const finalState = loadTask(taskDir);
+    expect(finalState.phase).toBe("done");
+    expect(finalState.reviewCycle).toBeNull();
+    // No auto review pass ran because review was disabled.
+    expect(finalState.reviewPassByKind?.implement?.auto ?? 0).toBe(0);
+  });
+
   it("autonomous PLAN review cycle: apply feedback (clean approve) advances to implement", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -2015,6 +2151,7 @@ describe("task modes and quick task", () => {
       "utf-8",
     );
 
+    orchestrator.active!.state.reconciledPhase = "plan";
     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);
@@ -2060,6 +2197,7 @@ describe("task modes and quick task", () => {
       "utf-8",
     );
 
+    orchestrator.active!.state.reconciledPhase = "implement";
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
     // Terminal handoff (#1): clean-approved re-entry opens the guided menu rather
     // than auto-completing; the user drives Next→Complete to finish.
@@ -2098,6 +2236,7 @@ describe("task modes and quick task", () => {
     mkdirSync(reviewsDir, { recursive: true });
     writeFileSync(join(reviewsDir, "1_a_round-1.md"), "- CRITICAL: bug at x.ts:1\n- VERDICT: NEEDS_CHANGES", "utf-8");
 
+    orchestrator.active!.state.reconciledPhase = "implement";
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
     const next = await ppPhaseComplete.execute("call-1", { summary: "fixes applied, re-review" }, undefined, undefined, ctx);
     expect(orchestrator.active!.state.reviewApprovedClean).toBeFalsy();
@@ -2127,6 +2266,7 @@ describe("task modes and quick task", () => {
       "utf-8",
     );
 
+    orchestrator.active!.state.reconciledPhase = "implement";
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
     const first = await ppPhaseComplete.execute("call-1", { summary: "done" }, undefined, undefined, ctx);
     expect(first.content[0].text).toMatch(/Cannot start review yet/);
@@ -2213,7 +2353,7 @@ describe("task modes and quick task", () => {
       .expect({ question: "Mode", options: { include: ["Autonomous"] }, choose: "Autonomous" })
       .expect({ question: "Autonomous", options: { include: ["Start"] }, choose: "Start" });
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
-    await ppPhaseComplete.execute("call-1", { summary: "Conclusions ready" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "call-1", "Conclusions ready", ctx);
 
     expect(orchestrator.active!.state.autonomousConfig?.phases.plan).toBeDefined();
     expect(orchestrator.active!.state.autonomousConfig?.phases.implement).toBeDefined();
@@ -2224,12 +2364,12 @@ describe("task modes and quick task", () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
 
-    await orchestrator.startTask({ ...makeCtx(), cwd } as any, "debug", "Find bug");
-    const debugDir = orchestrator.active!.dir;
-    writeFileSync(join(debugDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
-    writeFileSync(join(debugDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
+    await orchestrator.startTask({ ...makeCtx(), cwd } as any, "review", "Find bug");
+    const reviewDir = orchestrator.active!.dir;
+    writeFileSync(join(reviewDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
+    writeFileSync(join(reviewDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
 
-    await orchestrator.startTask({ ...makeCtx(), cwd } as any, "implement", "implement", debugDir, true, "autonomous");
+    await orchestrator.startTask({ ...makeCtx(), cwd } as any, "implement", "implement", reviewDir, true, "autonomous");
     expect(orchestrator.active!.state.initialPhase).toBe("plan");
     expect(orchestrator.active!.state.phase).toBe("plan");
 
@@ -2243,11 +2383,11 @@ describe("task modes and quick task", () => {
     const { pi, orchestrator } = await setupOrchestrator(cwd);
     const ctx = makeCtx();
 
-    await orchestrator.startTask({ ...ctx, cwd } as any, "debug", "Find bug");
-    const debugDir = orchestrator.active!.dir;
-    writeFileSync(join(debugDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
-    writeFileSync(join(debugDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
-    await orchestrator.startTask({ ...ctx, cwd } as any, "implement", "implement", debugDir, true, "autonomous");
+    await orchestrator.startTask({ ...ctx, cwd } as any, "review", "Find bug");
+    const reviewDir = orchestrator.active!.dir;
+    writeFileSync(join(reviewDir, "USER_REQUEST.md"), VALID_USER_REQUEST, "utf-8");
+    writeFileSync(join(reviewDir, "RESEARCH.md"), VALID_RESEARCH, "utf-8");
+    await orchestrator.startTask({ ...ctx, cwd } as any, "implement", "implement", reviewDir, true, "autonomous");
     orchestrator.active!.state.phase = "implement";
     orchestrator.active!.state.step = "llm_work";
 
@@ -2563,7 +2703,7 @@ describe("task modes and quick task", () => {
     // 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 completePhase(ppPhaseComplete, "call-autonomous-skip-planner", "done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     expect(menu.transcript.filter((entry) => entry.question.includes("Planner preset"))).toHaveLength(0);
@@ -2592,6 +2732,7 @@ describe("task modes and quick task", () => {
       "utf-8",
     );
 
+    orchestrator.active!.state.reconciledPhase = "implement";
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
     const first = await ppPhaseComplete.execute("call-autonomous-review-1", { summary: "done" }, undefined, undefined, ctx);
     expect(first.content[0].text).toMatch(/Reviews are running|Started review cycle pass/);
@@ -2738,7 +2879,7 @@ describe("review task lifecycle", () => {
 
     expectImplementToDone(menu);
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
-    await ppPhaseComplete.execute("call-implement-to-done", { summary: "done" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "call-implement-to-done", "done", ctx);
 
     expect(orchestrator.active).toBeNull();
     expect(loadTask(taskDir).phase).toBe("done");
@@ -2750,6 +2891,7 @@ describe("review task lifecycle", () => {
     const ctx = makeCtx();
 
     await orchestrator.startTask(ctx as any, "review", "Review validation");
+    orchestrator.active!.state.reconciledPhase = orchestrator.active!.state.phase;
 
     expectBrainstormToPlan(menu);
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
@@ -2761,37 +2903,6 @@ describe("review task lifecycle", () => {
   });
 });
 
-describe("debug task lifecycle", () => {
-  it("debug task starts in debug phase", async () => {
-    const cwd = makeTempDir();
-    const { orchestrator } = await setupOrchestrator(cwd);
-
-    await orchestrator.startTask(makeCtx() as any, "debug", "Debug issue");
-
-    expect(orchestrator.active!.type).toBe("debug");
-    expect(orchestrator.active!.state.phase).toBe("debug");
-  });
-
-  it("debug task transitions debug to plan to implement to done", async () => {
-    const cwd = makeTempDir();
-    const { pi, orchestrator } = await setupOrchestrator(cwd);
-    const ctx = makeCtx();
-
-    await orchestrator.startTask(ctx as any, "debug", "Debug flow");
-    const taskDir = orchestrator.active!.dir;
-
-    await moveTaskToImplementPhase(pi, orchestrator, ctx, "call-debug-to-plan", "call-debug-plan-to-implement");
-    expect(orchestrator.active!.state.phase).toBe("implement");
-
-    expectImplementToDone(menu);
-    const ppPhaseComplete = getTool(pi, "pp_phase_complete");
-    await ppPhaseComplete.execute("call-debug-implement-to-done", { summary: "done" }, undefined, undefined, ctx);
-
-    expect(orchestrator.active).toBeNull();
-    expect(loadTask(taskDir).phase).toBe("done");
-  });
-});
-
 describe("modified file tracking", () => {
   it("tool_result tracks write and edit in implement phase", async () => {
     const cwd = makeTempDir();
@@ -3118,7 +3229,7 @@ describe("resume and recovery", () => {
   it("getActiveTask returns null when multiple unlocked tasks exist", () => {
     const cwd = makeTempDir();
     createTask(cwd, "implement", "first unlocked");
-    createTask(cwd, "debug", "second unlocked");
+    createTask(cwd, "review", "second unlocked");
 
     const active = getActiveTask(cwd);
 
@@ -4366,15 +4477,15 @@ describe("menu contracts", () => {
     await pp(undefined, ctx);
   });
 
-  it("autonomous debug task shows interactive menu in debug phase", async () => {
+  it("autonomous review task shows interactive menu in review phase", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
     const ctx = makeCtx();
 
-    await orchestrator.startTask(ctx as any, "debug", "contract debug auto", undefined, undefined, "autonomous");
+    await orchestrator.startTask(ctx as any, "review", "contract review auto", undefined, undefined, "autonomous");
 
     menu.expect({
-      question: m.taskMenu("debug", "debug"),
+      question: m.taskMenu("review", "review"),
       options: {
         exact: ["Next", "Review", "Subagents", "Settings", "Back to prompt"],
       },
@@ -4385,40 +4496,58 @@ describe("menu contracts", () => {
     await pp(undefined, ctx);
   });
 
-  it("autonomous review task shows interactive menu in review phase", async () => {
+  it("autonomous menu 'Complete task' completes the task", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
     const ctx = makeCtx();
 
-    await orchestrator.startTask(ctx as any, "review", "contract review auto", undefined, undefined, "autonomous");
+    await orchestrator.startTask(ctx as any, "implement", "contract complete", undefined, undefined, "autonomous");
+    const taskDir = orchestrator.active!.dir;
 
-    menu.expect({
-      question: m.taskMenu("review", "review"),
-      options: {
-        exact: ["Next", "Review", "Subagents", "Settings", "Back to prompt"],
-      },
-      choose: "Back to prompt",
-    });
+    expectActiveTaskNext(menu, "Complete");
 
     const pp = getCommand(pi, "pp");
     await pp(undefined, ctx);
+
+    expect(orchestrator.active).toBeNull();
+    expect(loadTask(taskDir).phase).toBe("done");
   });
 
-  it("autonomous menu 'Complete task' completes the task", async () => {
+  it("autonomous /pp Complete emits the terminal assumptions summary", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
     const ctx = makeCtx();
 
-    await orchestrator.startTask(ctx as any, "implement", "contract complete", undefined, undefined, "autonomous");
+    await orchestrator.startTask(ctx as any, "implement", "complete assumptions", undefined, undefined, "autonomous");
     const taskDir = orchestrator.active!.dir;
+    mkdirSync(join(taskDir, "artifacts"), { recursive: true });
+    writeFileSync(join(taskDir, "artifacts", "ASSUMPTIONS.md"), "# A\n\n- statement: idempotent; confidence: med; status: open\n", "utf-8");
 
     expectActiveTaskNext(menu, "Complete");
+    const pp = getCommand(pi, "pp");
+    await pp(undefined, ctx);
+
+    const summaryCall = (ctx.ui.notify as any).mock.calls.find((c: any[]) => String(c[0]).includes("Assumptions recorded this run"));
+    expect(summaryCall).toBeTruthy();
+    expect(String(summaryCall[0])).toContain("idempotent");
+  });
 
+  it("guided /pp Complete does NOT emit a terminal assumptions summary", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "guided complete no assumptions");
+    const taskDir = orchestrator.active!.dir;
+    mkdirSync(join(taskDir, "artifacts"), { recursive: true });
+    writeFileSync(join(taskDir, "artifacts", "ASSUMPTIONS.md"), "# A\n\n- statement: x; confidence: low; status: open\n", "utf-8");
+
+    expectActiveTaskNext(menu, "Complete");
     const pp = getCommand(pi, "pp");
     await pp(undefined, ctx);
 
-    expect(orchestrator.active).toBeNull();
-    expect(loadTask(taskDir).phase).toBe("done");
+    const summaryCall = (ctx.ui.notify as any).mock.calls.find((c: any[]) => String(c[0]).includes("Assumptions recorded this run"));
+    expect(summaryCall).toBeFalsy();
   });
 
   it("autonomous menu 'Pause task' pauses without completing", async () => {
@@ -4438,6 +4567,59 @@ describe("menu contracts", () => {
     expect(loadTask(taskDir).phase).not.toBe("done");
   });
 
+  it("pausing an un-reconciled phase flags reconcilePending so the next resume reconciles before spawning", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "contract pause reconcile", undefined, undefined, "autonomous");
+    const taskDir = orchestrator.active!.dir;
+    expect(orchestrator.active!.state.reconciledPhase).toBeUndefined();
+
+    expectActiveTaskNext(menu, "Pause");
+    const pp = getCommand(pi, "pp");
+    await pp(undefined, ctx);
+
+    expect(orchestrator.active).toBeNull();
+    expect(loadTask(taskDir).reconcilePending).toBe(true);
+  });
+
+  it("pausing an already-reconciled phase STILL flags reconcilePending (later work may have made it stale)", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "contract pause noflag", undefined, undefined, "autonomous");
+    const taskDir = orchestrator.active!.dir;
+    orchestrator.active!.state.reconciledPhase = orchestrator.active!.state.phase;
+    saveTask(taskDir, orchestrator.active!.state);
+
+    expectActiveTaskNext(menu, "Pause");
+    const pp = getCommand(pi, "pp");
+    await pp(undefined, ctx);
+
+    expect(orchestrator.active).toBeNull();
+    expect(loadTask(taskDir).reconcilePending).toBe(true);
+  });
+
+  it("a resumed task with reconcilePending re-prompts the reconcile gate before advancing", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "contract resume reconcile", undefined, undefined, "autonomous");
+    const taskDir = orchestrator.active!.dir;
+    // Simulate a resume after a pause that left the phase reconciled but pending.
+    orchestrator.active!.state.reconciledPhase = orchestrator.active!.state.phase;
+    orchestrator.active!.state.reconcilePending = true;
+    saveTask(taskDir, orchestrator.active!.state);
+
+    const ppPhaseComplete = getTool(pi, "pp_phase_complete");
+    const first = await ppPhaseComplete.execute("resume-1", { summary: "done" }, undefined, undefined, ctx);
+    expect(first.content[0].text).toContain("reconcile the task's state files");
+    expect(loadTask(taskDir).reconcilePending ?? false).toBe(false);
+  });
+
   it("completing a task mid-review clears reviewCycle without incrementing reviewPass", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -4579,7 +4761,7 @@ describe("full user flows", () => {
 
     expectBrainstormToPlan(menu);
     const ppPhaseComplete = getTool(pi, "pp_phase_complete");
-    await ppPhaseComplete.execute("flow-guided-1", { summary: "brainstorm done" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "flow-guided-1", "brainstorm done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     const plansDir = join(taskDir, "plans");
@@ -4590,11 +4772,11 @@ describe("full user flows", () => {
     writeFileSync(join(plansDir, `${Math.floor(Date.now() / 1000) + 1}_synthesized.md`), makeValidPlan(["- [x] P1. Ready — Done when: checked"]), "utf-8");
 
     expectPlanToImplement(menu);
-    await ppPhaseComplete.execute("flow-guided-2", { summary: "plan done" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "flow-guided-2", "plan done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     expectImplementToDone(menu);
-    await ppPhaseComplete.execute("flow-guided-3", { summary: "implement done" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "flow-guided-3", "implement done", ctx);
 
     expect(orchestrator.active).toBeNull();
     expect(loadTask(taskDir).phase).toBe("done");
@@ -4623,7 +4805,7 @@ describe("full user flows", () => {
     // 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 completePhase(ppPhaseComplete, "flow-auto-1", "brainstorm done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
     const plansDir = join(taskDir, "plans");
@@ -4633,10 +4815,10 @@ describe("full user flows", () => {
     emitSubagentCompleted(pi, "flow-auto-planner", "Planner (test)");
     writeFileSync(join(plansDir, `${Math.floor(Date.now() / 1000) + 1}_synthesized.md`), makeValidPlan(["- [x] P1. Ready — Done when: checked"]), "utf-8");
 
-    await ppPhaseComplete.execute("flow-auto-2", { summary: "plan done" }, undefined, undefined, ctx);
+    await completePhase(ppPhaseComplete, "flow-auto-2", "plan done", ctx);
     await new Promise((r) => setTimeout(r, 10));
 
-    const firstReview = await ppPhaseComplete.execute("flow-auto-3", { summary: "implement done" }, undefined, undefined, ctx);
+    const firstReview = await completePhase(ppPhaseComplete, "flow-auto-3", "implement done", ctx);
     expect(firstReview.content[0].text).toMatch(/Reviews are running|Started review cycle pass/);
 
     const reviewsDir = join(taskDir, "code-reviews");