@ilya-lesikov/pi-pi 0.8.0 → 0.9.0

package/extensions/orchestrator/integration.test.ts

@@ -53,6 +53,7 @@ vi.mock("./config.js", async (importOriginal) => {
   return { ...original, loadConfig: () => ({
     general: {
       autoCommit: false,
+      injectAgentsMd: true,
       loadExtraRepoConfigs: true,
       logLevel: "info",
     },
@@ -209,6 +210,7 @@ function makeConfig() {
   return {
     general: {
       autoCommit: false,
+      injectAgentsMd: true,
       loadExtraRepoConfigs: true,
       logLevel: "info",
     },
@@ -677,8 +679,12 @@ describe("review cycle lifecycle", () => {
     await ppPhaseComplete.execute("call-2", { summary: "plan done" }, undefined, undefined, ctx);
     await new Promise((r) => setTimeout(r, 10));
 
+    // Pick the auto preset first: with zero enabled reviewers it notifies and
+    // (#3d) loops back to the Review submenu — NOT the top-level /pp menu — so the
+    // next expectation is the Review submenu directly, without re-selecting "Review".
     expectReviewAuto(menu);
-    expectReviewOnMyOwn(menu, "Skip markers");
+    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);
 
     expect(result.content[0].text).toContain("continue");
@@ -1318,7 +1324,7 @@ describe("edge cases and regressions", () => {
 
     await orchestrator.startTask(ctx as any, "implement", "Continue test");
 
-    expectReviewOnMyOwn(menu);
+    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);
 
@@ -1400,7 +1406,7 @@ describe("edge cases and regressions", () => {
       "utf-8",
     );
 
-    expectReviewOnMyOwn(menu);
+    expectReviewOnMyOwn(menu, "Skip markers");
     const result = await ppPhaseComplete.execute("call-2", { summary: "plan ready" }, undefined, undefined, ctx);
 
     expect(result.content[0].text).toContain("continue");
@@ -1449,6 +1455,83 @@ describe("edge cases and regressions", () => {
     expect(orchestrator.active!.state.step).toBe("llm_work");
   });
 
+  it("editor-review Done returns AI_REVIEW state-file instructions in brainstorm phase", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "brainstorm", "Brainstorm editor review");
+
+    expectReviewOnMyOwn(menu, "Done");
+    const ppPhaseComplete = getTool(pi, "pp_phase_complete");
+    const result = await ppPhaseComplete.execute("call-1", { summary: "researched" }, 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).toContain("RESEARCH.md");
+    expect(result.content[0].text).toContain("artifacts/*.md");
+    expect(result.content[0].text).not.toContain("CHANGED files");
+    expect(orchestrator.active!.state.phase).toBe("brainstorm");
+    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);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "Plan editor review");
+    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",
+    );
+
+    expectReviewOnMyOwn(menu, "Done");
+    const result = await ppPhaseComplete.execute("call-2", { summary: "plan ready" }, undefined, undefined, ctx);
+
+    expect(result.content[0].text).toContain("AI_REVIEW:");
+    expect(result.content[0].text).toContain("_synthesized.md");
+    expect(result.content[0].text).not.toContain("CHANGED files");
+    expect(orchestrator.active!.state.phase).toBe("plan");
+    expect(orchestrator.active!.state.step).toBe("synthesize");
+  });
+
   it("generic description task does not auto-trigger agent", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -1788,8 +1871,11 @@ describe("task modes and quick task", () => {
     emitSubagentCreated(pi, "reviewer-2", "Code reviewer (test)");
     emitSubagentCompleted(pi, "reviewer-2", "Code reviewer (test)");
 
+    // Terminal handoff (#1): at the cap the autonomous implement no longer auto-
+    // completes — it opens the guided menu; the user drives Next→Complete to finish.
+    expectImplementToDone(menu);
     const fourth = await ppPhaseComplete.execute("call-4", { summary: "applied 2" }, undefined, undefined, ctx);
-    expect(fourth.content[0].text).toBe("");
+    expect(fourth.content[0].text).toMatch(/completed/);
     expect(orchestrator.active).toBeNull();
     expect(loadTask(taskDir).phase).toBe("done");
   });
@@ -1831,8 +1917,11 @@ describe("task modes and quick task", () => {
     emitSubagentCreated(pi, "reviewer-1", "Code reviewer (test)");
     emitSubagentCompleted(pi, "reviewer-1", "Code reviewer (test)");
 
+    // Terminal handoff (#1): instead of auto-completing, the guided menu opens
+    // and the user drives Next→Complete to finish.
+    expectImplementToDone(menu);
     const second = await ppPhaseComplete.execute("call-2", { summary: "applied" }, undefined, undefined, ctx);
-    expect(second.content[0].text).toBe("");
+    expect(second.content[0].text).toMatch(/completed/);
     expect(orchestrator.active).toBeNull();
     const finalState = loadTask(taskDir);
     expect(finalState.phase).toBe("done");
@@ -1912,8 +2001,11 @@ describe("task modes and quick task", () => {
     );
 
     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.
+    expectImplementToDone(menu);
     const result = await ppPhaseComplete.execute("call-1", { summary: "checklist repaired" }, undefined, undefined, ctx);
-    expect(result.content[0].text).toBe("");
+    expect(result.content[0].text).toMatch(/completed/);
     expect(orchestrator.active).toBeNull();
     expect(loadTask(taskDir).phase).toBe("done");
   });
@@ -2173,6 +2265,66 @@ describe("task modes and quick task", () => {
     expect(prompt).not.toContain("advance it via the /pp menu");
   });
 
+  it("injects root AGENTS.md into the system prompt when enabled, ignoring nested/extra-repo files", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx({ cwd });
+
+    writeFileSync(join(cwd, "AGENTS.md"), "ROOT_AGENTS_CONTENT", "utf-8");
+    mkdirSync(join(cwd, "nested"), { recursive: true });
+    writeFileSync(join(cwd, "nested", "AGENTS.md"), "NESTED_AGENTS_CONTENT", "utf-8");
+
+    await orchestrator.startTask({ ...ctx, cwd } as any, "implement", "implement", undefined, undefined, "guided");
+    orchestrator.active!.state.phase = "plan";
+    orchestrator.active!.state.step = "synthesize";
+
+    const beforeStart = pi._handlers.get("before_agent_start")!;
+    const prompt = (await beforeStart({ systemPrompt: "base" }, ctx))?.systemPrompt ?? "";
+    expect(prompt).toContain(`<agents_md source="${join(cwd, "AGENTS.md")}">`);
+    expect(prompt).toContain("ROOT_AGENTS_CONTENT");
+    expect(prompt).not.toContain("NESTED_AGENTS_CONTENT");
+  });
+
+  it("omits AGENTS.md block when disabled or file absent", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx({ cwd });
+
+    await orchestrator.startTask({ ...ctx, cwd } as any, "implement", "implement", undefined, undefined, "guided");
+    orchestrator.active!.state.phase = "plan";
+    orchestrator.active!.state.step = "synthesize";
+
+    const beforeStart = pi._handlers.get("before_agent_start")!;
+    const absent = (await beforeStart({ systemPrompt: "base" }, ctx))?.systemPrompt ?? "";
+    expect(absent).not.toContain("<agents_md");
+
+    writeFileSync(join(cwd, "AGENTS.md"), "ROOT_AGENTS_CONTENT", "utf-8");
+    orchestrator.config.general.injectAgentsMd = false;
+    const disabled = (await beforeStart({ systemPrompt: "base" }, ctx))?.systemPrompt ?? "";
+    expect(disabled).not.toContain("<agents_md");
+    expect(disabled).not.toContain("ROOT_AGENTS_CONTENT");
+  });
+
+  it("auto-refreshes AGENTS.md content on the next turn without restart", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx({ cwd });
+
+    writeFileSync(join(cwd, "AGENTS.md"), "FIRST_VERSION", "utf-8");
+    await orchestrator.startTask({ ...ctx, cwd } as any, "implement", "implement", undefined, undefined, "guided");
+    orchestrator.active!.state.phase = "plan";
+    orchestrator.active!.state.step = "synthesize";
+
+    const beforeStart = pi._handlers.get("before_agent_start")!;
+    const first = (await beforeStart({ systemPrompt: "base" }, ctx))?.systemPrompt ?? "";
+    expect(first).toContain("FIRST_VERSION");
+
+    writeFileSync(join(cwd, "AGENTS.md"), "SECOND_VERSION", "utf-8");
+    const second = (await beforeStart({ systemPrompt: "base" }, ctx))?.systemPrompt ?? "";
+    expect(second).toContain("SECOND_VERSION");
+    expect(second).not.toContain("FIRST_VERSION");
+  });
+
   it("autonomous plan-phase prompt body contains no /pp guidance", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -2347,8 +2499,11 @@ describe("task modes and quick task", () => {
     emitSubagentCreated(pi, "reviewer-auto-1", "Code reviewer (test)");
     emitSubagentCompleted(pi, "reviewer-auto-1", "Code reviewer (test)");
 
+    // Terminal handoff (#1): the clean second pass opens the guided menu; the user
+    // drives Next→Complete to finish rather than auto-completing.
+    expectImplementToDone(menu);
     const second = await ppPhaseComplete.execute("call-autonomous-review-2", { summary: "applied" }, undefined, undefined, ctx);
-    expect(second.content[0].text).toBe("");
+    expect(second.content[0].text).toMatch(/completed/);
     expect(orchestrator.active).toBeNull();
   });
 
@@ -2393,10 +2548,9 @@ describe("task modes and quick task", () => {
     menu
       .expect({ question: "/pp", options: { include: ["Task"] }, choose: "Task" })
       .expect({ question: "Task", options: { include: ["Review"] }, choose: "Review" })
-      .expect({ question: "Review", options: { include: ["Describe"] }, choose: "Describe" })
+      .expect({ question: "Review", options: { exact: ["New", "Resume", "Back"] }, choose: "New" })
       .expect({ question: "Mode", options: { include: ["Autonomous"] }, choose: "Autonomous" })
       .expect({ question: "Autonomous", options: { include: ["Start"] }, choose: "Start" });
-    ctx.ui.input.mockResolvedValueOnce("Review current branch changes");
     const pp = getCommand(pi, "pp");
     await pp(undefined, ctx);
 
@@ -2466,6 +2620,11 @@ describe("review task lifecycle", () => {
     await orchestrator.startTask(ctx as any, "review", "Review flow");
     const taskDir = orchestrator.active!.dir;
 
+    // #10: the review phase cannot complete without an ANCHORS-bearing final_pass file.
+    const reviewsDir = join(taskDir, "code-reviews");
+    mkdirSync(reviewsDir, { recursive: true });
+    writeFileSync(join(reviewsDir, "1_final_pass-1.md"), "# Review\nANCHORS: (none)\n", "utf-8");
+
     await moveTaskToImplementPhase(pi, orchestrator, ctx, "call-review-to-plan", "call-plan-to-implement");
     expect(orchestrator.active!.state.phase).toBe("implement");
 
@@ -2557,6 +2716,22 @@ describe("modified file tracking", () => {
     expect(orchestrator.active!.state.reviewApprovedClean).toBe(false);
   });
 
+  it("source write clears afterImplementRan so post-handoff edits re-run afterImplement (#1)", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "Rerun hooks");
+    await moveTaskToImplementPhase(pi, orchestrator, ctx, "call-rerun-brainstorm", "call-rerun-plan");
+    // Simulate the terminal handoff having already run afterImplement.
+    orchestrator.active!.state.afterImplementRan = true;
+
+    const toolResult = pi._handlers.get("tool_result")!;
+    await toolResult({ toolName: "write", input: { path: "src/d.ts" }, isError: false, content: [] }, {});
+
+    expect(orchestrator.active!.state.afterImplementRan).toBe(false);
+  });
+
   it("tool_result ignores writes inside .pp directory", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -3403,6 +3578,76 @@ describe("error retry", () => {
     expect(pi.sendUserMessage).toHaveBeenCalledWith(expect.stringContaining("Continue the implement phase"), { deliverAs: "followUp" });
   });
 
+  it("drops a continuation nudge whose phase no longer matches at delivery", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "stale phase nudge");
+    orchestrator.active!.state.phase = "plan";
+    orchestrator.active!.state.step = "llm_work";
+    const turnEnd = pi._handlers.get("turn_end")!;
+    await turnEnd({ message: { stopReason: "stop", content: [] }, toolResults: [] }, ctx);
+    const nudge = (pi.sendUserMessage as any).mock.calls.map((c: any[]) => c[0]).find((t: string) => t.includes("Continue the plan phase"));
+    expect(nudge).toBeDefined();
+    expect(orchestrator.pendingNudges.has(nudge)).toBe(true);
+
+    // Phase advances before the queued nudge is delivered.
+    orchestrator.active!.state.phase = "implement";
+    const beforeStart = pi._handlers.get("before_agent_start")!;
+    const abort = vi.fn();
+    await beforeStart({ systemPrompt: "base", prompt: nudge }, makeCtx({ abort }));
+
+    expect(abort).toHaveBeenCalledOnce();
+    expect(orchestrator.pendingNudges.has(nudge)).toBe(false);
+  });
+
+  it("drops a continuation nudge whose task token changed at delivery (same phase)", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "stale token nudge");
+    orchestrator.active!.state.phase = "plan";
+    orchestrator.active!.state.step = "llm_work";
+    const turnEnd = pi._handlers.get("turn_end")!;
+    await turnEnd({ message: { stopReason: "stop", content: [] }, toolResults: [] }, ctx);
+    const nudge = (pi.sendUserMessage as any).mock.calls.map((c: any[]) => c[0]).find((t: string) => t.includes("Continue the plan phase"));
+    expect(nudge).toBeDefined();
+
+    // A new task starts (token bumped), also at the plan phase — the old nudge
+    // must not drive a turn in the new task even though the phase name matches.
+    orchestrator.activeTaskToken++;
+    orchestrator.active!.state.phase = "plan";
+    const beforeStart = pi._handlers.get("before_agent_start")!;
+    const abort = vi.fn();
+    await beforeStart({ systemPrompt: "base", prompt: nudge }, makeCtx({ abort }));
+
+    expect(abort).toHaveBeenCalledOnce();
+  });
+
+  it("delivers a continuation nudge whose phase and token still match", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "fresh nudge");
+    orchestrator.active!.state.phase = "implement";
+    orchestrator.active!.state.step = "llm_work";
+    const turnEnd = pi._handlers.get("turn_end")!;
+    await turnEnd({ message: { stopReason: "stop", content: [] }, toolResults: [] }, ctx);
+    const nudge = (pi.sendUserMessage as any).mock.calls.map((c: any[]) => c[0]).find((t: string) => t.includes("Continue the implement phase"));
+    expect(nudge).toBeDefined();
+
+    const beforeStart = pi._handlers.get("before_agent_start")!;
+    const abort = vi.fn();
+    const result = await beforeStart({ systemPrompt: "base", prompt: nudge }, makeCtx({ abort }));
+
+    expect(abort).not.toHaveBeenCalled();
+    expect(result?.systemPrompt).toContain("<task>");
+    expect(orchestrator.pendingNudges.has(nudge)).toBe(false);
+  });
+
   it("suppresses nudges while the controller is transitioning (not running)", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -3634,6 +3879,54 @@ describe("compaction", () => {
     expect(result.compaction.summary).toBe("Task done summary");
   });
 
+  it("task-boundary discard uses distinct discard wording and keeps no verbatim transcript", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    orchestrator.lastCtx = makeCtx({ isIdle: vi.fn().mockReturnValue(false) });
+
+    void orchestrator.transitionController.requestTransition({
+      kind: "done",
+      discard: true,
+      summary: "Task \"x\" (implement) is finished — DISCARD its entire conversation. Do NOT carry forward.",
+    });
+    orchestrator.transitionController.onAgentEnd();
+    const beforeCompact = pi._handlers.get("session_before_compact")!;
+    const result = await beforeCompact(
+      {
+        preparation: { firstKeptEntryId: "old-kept", tokensBefore: 999 },
+        branchEntries: [{ id: "e-a" }, { id: "e-b" }, { id: "newest" }],
+      },
+      {},
+    );
+
+    // Distinct from the phase-transition summary, and instructs discard.
+    expect(result.compaction.summary).not.toBe("Phase transition in progress.");
+    expect(result.compaction.summary).toContain("DISCARD");
+    // Verbatim window collapsed to the newest entry — nothing prior kept.
+    expect(result.compaction.firstKeptEntryId).toBe("newest");
+  });
+
+  it("phase transition keeps the default recent verbatim window (no discard)", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    orchestrator.lastCtx = makeCtx({ isIdle: vi.fn().mockReturnValue(false) });
+
+    void orchestrator.transitionController.requestTransition({ kind: "phase", summary: "Phase summary text" });
+    orchestrator.transitionController.onAgentEnd();
+    const beforeCompact = pi._handlers.get("session_before_compact")!;
+    const result = await beforeCompact(
+      {
+        preparation: { firstKeptEntryId: "old-kept", tokensBefore: 111 },
+        branchEntries: [{ id: "e-a" }, { id: "newest" }],
+      },
+      {},
+    );
+
+    expect(result.compaction.summary).toBe("Phase summary text");
+    expect(result.compaction.firstKeptEntryId).toBe("old-kept");
+  });
+
+
   it("session_before_compact re-injects artifacts after natural compaction", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -4234,6 +4527,9 @@ describe("full user flows", () => {
     emitSubagentCreated(pi, "flow-auto-reviewer", "Code reviewer (test)");
     emitSubagentCompleted(pi, "flow-auto-reviewer", "Code reviewer (test)");
 
+    // Terminal handoff (#1): autonomous implement does NOT auto-complete. It opens
+    // the GUIDED implement menu and waits; the user drives Next→Complete to finish.
+    expectImplementToDone(menu);
     await ppPhaseComplete.execute("flow-auto-4", { summary: "feedback applied" }, undefined, undefined, ctx);
 
     expect(orchestrator.active).toBeNull();

package/extensions/orchestrator/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -0,0 +1 @@
+{"version":"4.1.4","results":[[":pp-menu.test.ts",{"duration":5.372961000000032,"failed":false}],[":integration.test.ts",{"duration":943.253143,"failed":false}],[":phases/review.test.ts",{"duration":2.5133239999999546,"failed":false}],[":pr-comments.test.ts",{"duration":4.420278999999994,"failed":false}],[":transition-controller.test.ts",{"duration":5.222491000000005,"failed":false}],[":event-handlers.test.ts",{"duration":10.928670000000011,"failed":false}],[":ai-comment-cleanup.test.ts",{"duration":3.3210659999999947,"failed":false}],[":flant-infra.test.ts",{"duration":40.368476,"failed":false}],[":command-handlers.test.ts",{"duration":13.727003000000025,"failed":false}],[":usage-tracker.test.ts",{"duration":7.265218000000004,"failed":false}],[":doctor.test.ts",{"duration":10.992058,"failed":false}],[":context.test.ts",{"duration":8.419984999999997,"failed":false}],[":orchestrator.test.ts",{"duration":12.065533000000016,"failed":false}],[":config.test.ts",{"duration":8.647639000000026,"failed":false}],[":model-registry.test.ts",{"duration":9.934792000000002,"failed":false}],[":state.test.ts",{"duration":13.755476000000002,"failed":false}],[":commands.test.ts",{"duration":270.744763,"failed":false}],[":phases/machine.test.ts",{"duration":8.854923999999983,"failed":false}],[":pp-state-tools.test.ts",{"duration":7.878408999999991,"failed":false}],[":log.test.ts",{"duration":884.438896,"failed":false}],[":repo-utils.test.ts",{"duration":3.7061610000000016,"failed":false}],[":phases/verdict.test.ts",{"duration":4.656940000000006,"failed":false}],[":rate-limit-fallback-flow.test.ts",{"duration":6.88740700000001,"failed":false}],[":agents/prompts.test.ts",{"duration":4.860277999999994,"failed":false}],[":tracer.test.ts",{"duration":3.9392250000000004,"failed":false}],[":rate-limit-fallback.test.ts",{"duration":3.124099000000001,"failed":false}],[":validate-artifacts.test.ts",{"duration":3.718504000000003,"failed":false}],[":plannotator.test.ts",{"duration":6.168539999999993,"failed":false}],[":agents/constraints.test.ts",{"duration":2.458521999999995,"failed":false}],[":custom-footer.test.ts",{"duration":3.8825789999999927,"failed":false}],[":phases/spawn-blocking.test.ts",{"duration":54.621959000000004,"failed":false}],[":exa.test.ts",{"duration":3.8611999999999966,"failed":false}],[":spawn-cleanup.test.ts",{"duration":2.2092779999999976,"failed":false}],[":subagent-session-marker.test.ts",{"duration":1.6192010000000039,"failed":false}],[":model-version.test.ts",{"duration":5.690410999999997,"failed":false}],[":messages.test.ts",{"duration":1.798244000000004,"failed":false}],[":cbm.test.ts",{"duration":2.306488999999999,"failed":false}],[":phases/brainstorm.test.ts",{"duration":1.6732620000000225,"failed":false}],[":phases/planning.test.ts",{"duration":1.6508400000000165,"failed":false}],[":phases/implementation.test.ts",{"duration":2.0228309999999965,"failed":false}]]}

package/extensions/orchestrator/orchestrator.ts

@@ -13,7 +13,6 @@ import {
   type TaskState,
   type Phase,
 } from "./state.js";
-import { phasePipeline } from "./phases/machine.js";
 import { getContextDirs, loadAllContextFiles, getPhaseArtifacts, getLatestSynthesizedPlan } from "./context.js";
 import { brainstormSystemPrompt } from "./phases/brainstorm.js";
 import { planningSystemPrompt, spawnPlanners } from "./phases/planning.js";
@@ -31,6 +30,7 @@ import { resolveModel, getModelInfo, findLatestFamilyMatch, setSubscriptionFallb
 import { buildRepoContext } from "./agents/repo-context.js";
 import { getLogger, addTaskDestination, removeTaskDestination, setLogLevel } from "./log.js";
 import { handleSpawnResult } from "./spawn-cleanup.js";
+import { getTracer } from "./tracer.js";
 import { TransitionController, type TransitionHost } from "./transition-controller.js";
 
 function isEnabled(value: { enabled?: boolean } | undefined): boolean {
@@ -73,6 +73,16 @@ export class Orchestrator {
     step?: string;
   }>();
   staleAgentTimer: ReturnType<typeof setInterval> | null = null;
+  // Main-turn stall watchdog (BUG-2). A main turn that starts but never emits a
+  // terminal turn_end/error can wedge the session ("Working…" forever). Unlike
+  // staleAgentTimer (subagents only), this watches the MAIN session: any main-
+  // session stream/tool/turn activity refreshes mainTurnLastActivity; when a turn
+  // is in flight with no activity beyond config.performance.internals.mainTurnStale,
+  // the watchdog recovers via the idle-gated single-send path.
+  mainTurnTimer: ReturnType<typeof setInterval> | null = null;
+  mainTurnLastActivity = 0;
+  mainTurnInFlight = false;
+  mainTurnRecovering = false;
   // Single consecutive-nudge guard (replaces the old multi-tier throttle). Reset
   // to 0 on any productive turn; once it reaches the cap the nudges halt with one
   // user notification.
@@ -96,6 +106,14 @@ export class Orchestrator {
   // without this ESC would not cancel it.
   pendingRetryEscUnsub: (() => void) | null = null;
   activeTaskToken = 0;
+  // Side-channel for stale-nudge re-validation. A continuation nudge is delivered
+  // as a followUp whose prompt STRING carries no phase/task token, and the SDK
+  // queue only surfaces the string in before_agent_start. So at nudge-generation
+  // time we record {phase, taskToken} keyed by the exact nudge string; at delivery
+  // we re-check both against the live phase/token and drop the nudge on mismatch
+  // (a nudge generated for an old phase/task must not drive a turn in the new one).
+  // Last-wins per distinct string; a stale entry only ever fails-closed to drop.
+  pendingNudges = new Map<string, { phase: Phase; taskToken: number }>();
   // Subscription rate-limit fallback (Issue 5). subFallbackActive mirrors the
   // model-registry override flag; subFallbackDialogPending guards against
   // opening more than one switch dialogue at a time (across main + subagents);
@@ -103,6 +121,11 @@ export class Orchestrator {
   // switch-back probe); subSwitchBackTimer is the fixed-interval probe timer.
   subFallbackActive = false;
   subFallbackDialogPending = false;
+  // True while a user-facing dialogue (ask_user / the /pp menu / any interactive
+  // selectOption) is open. The main-turn watchdog skips while set so a turn
+  // legitimately parked on a human is not aborted. Set on dialogue open, cleared
+  // in finally on every exit (resolve, ESC/cancel, error).
+  interactivePromptOpen = false;
   // Set SYNCHRONOUSLY the moment a sub-429 is detected (before any async dialog),
   // and cleared once the decision resolves. The autonomous planner/reviewer
   // auto-retry consults this to avoid re-spawning a failed variant on the still-
@@ -129,10 +152,16 @@ export class Orchestrator {
   checkPlannerCompletion: () => void = () => {};
   readonly transitionController: TransitionController;
 
+  // The single live instance, so module-level dialogue wrappers (selectOption in
+  // event-handlers/pp-menu) can toggle interactivePromptOpen without threading a
+  // reference through ~70 call sites.
+  static current: Orchestrator | null = null;
+
   constructor(readonly pi: ExtensionAPI) {
     // The controller calls pi (the main session) directly for sends, and uses the
     // host only for live-ctx-dependent bits (compact/isIdle/currentStep).
     this.transitionController = new TransitionController(this.makeTransitionHost(), this.pi);
+    Orchestrator.current = this;
   }
 
   // Live-session host the TransitionController uses for compaction/idle/step.
@@ -329,67 +358,17 @@ export class Orchestrator {
     return true;
   }
 
+  // The footer's phase/mode display (line 1) reads orchestrator state directly; this only
+  // sets a hidden "pp-phase" status whose value changes per transition so the host repaints
+  // the footer. Nothing renders this string (footer line 3 was removed), so it stays terse.
   updateStatus(ctx: ExtensionContext): void {
     if (!this.active || this.active.state.phase === "done") {
       ctx.ui.setStatus("pp-phase", undefined);
       return;
     }
-
-    const type = this.active.type;
-    const phase = this.active.state.phase;
-    const step = this.active.state.step;
-    const reviewCycle = this.active.state.reviewCycle;
-    const effectiveMode = this.active.state.effectiveMode ?? this.active.state.mode;
-    const modeLabel = effectiveMode === "autonomous" ? " [autonomous]" : "";
-
-    if (type === "debug" || type === "brainstorm" || type === "quick") {
-      const elapsed = this.phaseStartTime > 0 ? this.formatElapsed(this.phaseStartTime) : "";
-      const suffix = elapsed ? ` (${elapsed})` : "";
-      ctx.ui.setStatus("pp-phase", `pp: ${type}${modeLabel}${suffix}`);
-      return;
-    }
-
-    const pipeline = phasePipeline(type).filter((p) => p !== "done");
-    const currentIdx = pipeline.indexOf(phase as (typeof pipeline)[number]);
-
-    const parts: string[] = [];
-    for (let i = 0; i < pipeline.length; i++) {
-      const p = pipeline[i];
-      if (i < currentIdx) {
-        parts.push(`✔ ${p}`);
-      } else if (p === phase) {
-        let detail = "";
-        if (step === "await_planners") detail = "planners";
-        else if (step === "await_reviewers") detail = "reviewers";
-        else if (step === "synthesize") detail = "synthesize";
-        else if (step === "apply_feedback") detail = "feedback";
-        else if (step === "user_gate") detail = "review";
-
-        if (reviewCycle) {
-          const kind = reviewCycle.kind === "plannotator" ? "plannotator" : "review";
-          detail = `${kind} #${reviewCycle.pass}`;
-        }
-
-        const elapsed = this.phaseStartTime > 0 ? this.formatElapsed(this.phaseStartTime) : "";
-        const sub = [detail, elapsed].filter(Boolean).join(", ");
-        parts.push(sub ? `${p} (${sub})` : p);
-      } else {
-        parts.push(p);
-      }
-    }
-
-    ctx.ui.setStatus("pp-phase", `pp: ${parts.join(" → ")}${modeLabel}`);
-  }
-
-  private formatElapsed(startTime: number): string {
-    const sec = Math.floor((Date.now() - startTime) / 1000);
-    if (sec < 60) return `${sec}s`;
-    const min = Math.floor(sec / 60);
-    const remSec = sec % 60;
-    if (min < 60) return remSec > 0 ? `${min}m ${remSec}s` : `${min}m`;
-    const hr = Math.floor(min / 60);
-    const remMin = min % 60;
-    return remMin > 0 ? `${hr}h ${remMin}m` : `${hr}h`;
+    const s = this.active.state;
+    const cycle = s.reviewCycle ? `:${s.reviewCycle.kind}#${s.reviewCycle.pass}` : "";
+    ctx.ui.setStatus("pp-phase", `${this.active.type}:${s.phase}:${s.step}:${getEffectivePhaseMode(s)}${cycle}`);
   }
 
   getPlanStartState(taskDir: string, plannerPresetName?: string): { step: string; shouldSpawnPlanners: boolean } {
@@ -480,7 +459,8 @@ export class Orchestrator {
       this.lastCtx = ctx;
       await this.transitionController.requestTransition({
         kind: "done",
-        summary: `Starting new ${type} task. Previous conversation discarded.`,
+        discard: true,
+        summary: `A new, unrelated ${type} task is starting. The previous task is finished — DISCARD its entire conversation. Do NOT carry forward, reference, or act on any prior task's messages, phase, plan, or aborted turns; treat the new task as a clean slate.`,
       });
     }
 
@@ -653,6 +633,7 @@ export class Orchestrator {
     this.commitReminderSent = false;
     this.consecutiveNudges = 0;
     this.nudgeHalted = false;
+    this.pendingNudges.clear();
     this.phaseStartTime = 0;
     this.userGatePending = false;
     this.failedPlannerVariants = [];
@@ -668,6 +649,12 @@ export class Orchestrator {
       clearInterval(this.staleAgentTimer);
       this.staleAgentTimer = null;
     }
+    if (this.mainTurnTimer) {
+      clearInterval(this.mainTurnTimer);
+      this.mainTurnTimer = null;
+    }
+    this.mainTurnInFlight = false;
+    this.mainTurnRecovering = false;
     this.clearSubscriptionFallback();
   }
 
@@ -681,6 +668,7 @@ export class Orchestrator {
     }
     this.subFallbackActive = false;
     this.subFallbackDialogPending = false;
+    this.interactivePromptOpen = false;
     this.subFallbackPendingDecision = false;
     this.subFallbackModelId = null;
     setSubscriptionFallbackActive(false);