@ilya-lesikov/pi-pi 0.4.0 → 0.6.0

package/extensions/orchestrator/cbm.ts

@@ -2,6 +2,7 @@ import { spawn, execFileSync, type ChildProcess } from "child_process";
 import { createInterface, type Interface as ReadlineInterface } from "readline";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
+import { getLogger } from "./log.js";
 
 function findCbmBin(): string | null {
   try {
@@ -34,7 +35,7 @@ function setGlobalDaemon(daemon: CbmDaemon): void {
   (globalThis as any)[CBM_DAEMON_KEY] = daemon;
 }
 
-class CbmDaemon {
+export class CbmDaemon {
   private proc: ChildProcess | null = null;
   private rl: ReadlineInterface | null = null;
   private nextId = 1;
@@ -46,24 +47,30 @@ class CbmDaemon {
   start(): void {
     if (this.proc) return;
 
-    this.proc = spawn(getCbmBin()!, [], { stdio: ["pipe", "pipe", "ignore"] });
+    this.proc = spawn(getCbmBin()!, [], { stdio: ["pipe", "pipe", "pipe"] });
     this.proc.unref();
     (this.proc.stdout as any)?.unref?.();
     (this.proc.stdin as any)?.unref?.();
+    (this.proc.stderr as any)?.unref?.();
 
     this.rl = createInterface({ input: this.proc.stdout! });
     this.rl.on("line", (line) => this.handleLine(line));
 
+    this.proc.stderr?.on("data", (chunk) => {
+      const text = chunk.toString().trim();
+      if (text) getLogger().error({ s: "cbm", stderr: text }, "CBM daemon stderr");
+    });
+
     this.proc.on("exit", () => this.cleanup());
     this.proc.on("error", (err) => {
-      console.error(`[pi-pi] CBM daemon error: ${err.message}`);
+      getLogger().error({ s: "cbm", err: err.message }, "CBM daemon error");
       this.cleanup();
     });
 
     this.initPromise = this.initialize();
   }
 
-  private cleanup(): void {
+  cleanup(): void {
     for (const [, entry] of this.pending) {
       clearTimeout(entry.timer);
       entry.reject(new Error("CBM daemon exited"));
@@ -74,11 +81,14 @@ class CbmDaemon {
     this.proc = null;
     this.initialized = false;
     this.initPromise = null;
+    this.indexedProjects.clear();
   }
 
   stop(): void {
     if (!this.proc) return;
-    try { this.proc.kill(); } catch {}
+    try { this.proc.kill(); } catch (err: any) {
+      getLogger().debug({ s: "cbm", err: err?.message }, "CBM daemon kill failed");
+    }
     this.cleanup();
   }
 
@@ -88,6 +98,9 @@ class CbmDaemon {
       capabilities: {},
       clientInfo: { name: "pi-pi", version: "1.0" },
     });
+    if (this.proc?.stdin?.writable) {
+      this.proc.stdin.write(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized", params: {} }) + "\n");
+    }
     this.initialized = true;
   }
 
@@ -147,6 +160,10 @@ class CbmDaemon {
     }
   }
 
+  hasIndexed(cwd: string): boolean {
+    return this.indexedProjects.has(projectName(cwd));
+  }
+
   async ensureIndexed(cwd: string): Promise<string> {
     const name = projectName(cwd);
     if (this.indexedProjects.has(name)) return name;
@@ -200,10 +217,12 @@ export function registerCbmTools(pi: ExtensionAPI, cwd: string): boolean {
       semantic_query: Type.Optional(Type.Array(Type.String(), { description: "Array of keywords for vector similarity search" })),
       label: Type.Optional(Type.String({ description: "Filter by node type: Function, Method, Interface, Class, Type, Route" })),
       limit: Type.Optional(Type.Number({ description: "Max results (default: 20)" })),
+      project_path: Type.Optional(Type.String({ description: "Absolute path to the repo to search. Defaults to root project." })),
     }),
     async execute(_toolCallId, params: any) {
       try {
-        const project = await daemon.ensureIndexed(cwd);
+        const targetCwd = params.project_path ?? cwd;
+        const project = await daemon.ensureIndexed(targetCwd);
         const p: Record<string, unknown> = { project, limit: params.limit ?? 20 };
         if (params.query) p.query = params.query;
         if (params.name_pattern) p.name_pattern = params.name_pattern;
@@ -228,10 +247,12 @@ export function registerCbmTools(pi: ExtensionAPI, cwd: string): boolean {
       file_pattern: Type.Optional(Type.String({ description: "Glob filter (e.g. '*.go', '*.ts')" })),
       path_filter: Type.Optional(Type.String({ description: "Regex filter on file paths (e.g. '^pkg/')" })),
       limit: Type.Optional(Type.Number({ description: "Max results (default: 20)" })),
+      project_path: Type.Optional(Type.String({ description: "Absolute path to the repo to search. Defaults to root project." })),
     }),
     async execute(_toolCallId, params: any) {
       try {
-        const project = await daemon.ensureIndexed(cwd);
+        const targetCwd = params.project_path ?? cwd;
+        const project = await daemon.ensureIndexed(targetCwd);
         const p: Record<string, unknown> = { project, pattern: params.pattern, limit: params.limit ?? 20 };
         if (params.file_pattern) p.file_pattern = params.file_pattern;
         if (params.path_filter) p.path_filter = params.path_filter;
@@ -252,10 +273,12 @@ export function registerCbmTools(pi: ExtensionAPI, cwd: string): boolean {
       function_name: Type.String({ description: "Function name to trace" }),
       direction: Type.Optional(Type.String({ description: "inbound, outbound, or both (default: both)" })),
       depth: Type.Optional(Type.Number({ description: "Max traversal depth (default: 3)" })),
+      project_path: Type.Optional(Type.String({ description: "Absolute path to the repo to search. Defaults to root project." })),
     }),
     async execute(_toolCallId, params: any) {
       try {
-        const project = await daemon.ensureIndexed(cwd);
+        const targetCwd = params.project_path ?? cwd;
+        const project = await daemon.ensureIndexed(targetCwd);
         const p: Record<string, unknown> = {
           project,
           function_name: params.function_name,
@@ -278,10 +301,12 @@ export function registerCbmTools(pi: ExtensionAPI, cwd: string): boolean {
     parameters: Type.Object({
       base_branch: Type.Optional(Type.String({ description: "Compare against this branch (default: main)" })),
       since: Type.Optional(Type.String({ description: "Git ref or date (e.g. HEAD~5, v0.5.0)" })),
+      project_path: Type.Optional(Type.String({ description: "Absolute path to the repo to search. Defaults to root project." })),
     }),
     async execute(_toolCallId, params: any) {
       try {
-        const project = await daemon.ensureIndexed(cwd);
+        const targetCwd = params.project_path ?? cwd;
+        const project = await daemon.ensureIndexed(targetCwd);
         const p: Record<string, unknown> = { project };
         if (params.base_branch) p.base_branch = params.base_branch;
         if (params.since) p.since = params.since;
@@ -300,10 +325,12 @@ export function registerCbmTools(pi: ExtensionAPI, cwd: string): boolean {
       "Example: MATCH (f:Function)-[:CALLS]->(g:Function) WHERE f.name = 'main' RETURN g.name, g.file_path LIMIT 10",
     parameters: Type.Object({
       query: Type.String({ description: "Cypher query string" }),
+      project_path: Type.Optional(Type.String({ description: "Absolute path to the repo to search. Defaults to root project." })),
     }),
     async execute(_toolCallId, params: any) {
       try {
-        const project = await daemon.ensureIndexed(cwd);
+        const targetCwd = params.project_path ?? cwd;
+        const project = await daemon.ensureIndexed(targetCwd);
         return ok(JSON.stringify(await daemon.callTool("query_graph", { project, query: params.query }), null, 2));
       } catch (e: any) {
         return fail(`cbm_query error: ${e.message}`);
@@ -315,10 +342,13 @@ export function registerCbmTools(pi: ExtensionAPI, cwd: string): boolean {
     name: "cbm_architecture",
     label: "CBM",
     description: "Get high-level architecture overview of the indexed codebase — node/edge counts, schema, structure.",
-    parameters: Type.Object({}),
-    async execute() {
+    parameters: Type.Object({
+      project_path: Type.Optional(Type.String({ description: "Absolute path to the repo to inspect. Defaults to root project." })),
+    }),
+    async execute(_toolCallId, params: any) {
       try {
-        const project = await daemon.ensureIndexed(cwd);
+        const targetCwd = params.project_path ?? cwd;
+        const project = await daemon.ensureIndexed(targetCwd);
         return ok(JSON.stringify(await daemon.callTool("get_architecture", { project }), null, 2));
       } catch (e: any) {
         return fail(`cbm_architecture error: ${e.message}`);

package/extensions/orchestrator/command-handlers.test.ts

@@ -2,8 +2,12 @@ import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "fs";
 import { tmpdir } from "os";
 import { join } from "path";
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { registerCommandHandlers } from "./command-handlers.js";
+import { registerCommandHandlers, transitionToNextPhase } from "./command-handlers.js";
 import { Orchestrator, type ActiveTask } from "./orchestrator.js";
+import { getDefaultConfig } from "./config.js";
+import * as machineModule from "./phases/machine.js";
+import * as commandsModule from "./commands.js";
+import * as stateModule from "./state.js";
 
 vi.mock("./pp-menu.js", () => ({
   showPpMenu: vi.fn().mockResolvedValue(undefined),
@@ -22,6 +26,7 @@ function makeTempDir(): string {
 }
 
 afterEach(() => {
+  vi.restoreAllMocks();
   vi.mocked(showPpMenu).mockClear();
   while (tempDirs.length > 0) {
     const dir = tempDirs.pop();
@@ -48,26 +53,38 @@ function makePi() {
 }
 
 function makeConfig() {
-  return {
-    mainModel: {
-      implement: { model: "a/b", thinking: "high" },
-      debug: { model: "a/b", thinking: "high" },
-      brainstorm: { model: "a/b", thinking: "high" },
-      review: { model: "a/b", thinking: "high" },
+  const config = getDefaultConfig();
+  config.general.autoCommit = false;
+  config.agents.subagents.presetGroups.codeReviewers = {
+    default: "regular",
+    presets: {
+      regular: {
+        enabled: true,
+        agents: {
+          variant1: { enabled: true, model: "x/1", thinking: "low" },
+        },
+      },
     },
-    planners: {},
-    planReviewers: {},
-    codeReviewers: { variant1: { enabled: true, model: "x/1", thinking: "low" } },
-    brainstormReviewers: { variant1: { enabled: true, model: "x/1", thinking: "low" } },
-    agents: {
-      explore: { model: "x/e", thinking: "low" },
-      librarian: { model: "x/l", thinking: "medium" },
-      task: { model: "x/t", thinking: "medium" },
+  };
+  config.agents.subagents.presetGroups.brainstormReviewers = {
+    default: "regular",
+    presets: {
+      regular: {
+        enabled: true,
+        agents: {
+          variant1: { enabled: true, model: "x/1", thinking: "low" },
+        },
+      },
     },
-    commands: { afterEdit: [], afterImplement: [] },
-    timeouts: { afterEdit: 1, afterImplement: 1, agentSpawn: 1, agentReadyPing: 1, lockStale: 1, lockUpdate: 1 },
-    autoCommit: false,
   };
+  config.commands.afterEdit = {};
+  config.commands.afterImplement = {};
+  config.performance.commands.afterEdit = 1;
+  config.performance.commands.afterImplement = 1;
+  config.performance.internals.subagentStale = 1;
+  config.performance.internals.taskLockStale = 1;
+  config.performance.internals.taskLockRefresh = 1;
+  return config;
 }
 
 function makeActiveTask(taskDir: string): ActiveTask {
@@ -143,7 +160,7 @@ describe("pp command", () => {
     const pp = pi._commands.get("pp");
     expect(pp).toBeTruthy();
     await pp!.handler(undefined, ctx);
-    expect(pi.sendUserMessage).toHaveBeenCalledWith("[PI-PI] User wants to continue. Run /pp when ready to advance.");
+    expect(pi.sendUserMessage).toHaveBeenCalledWith("[PI-PI] User wants to continue. Run /pp when ready to advance.", { deliverAs: "followUp" });
   });
 
   it("registers pp command", () => {
@@ -158,3 +175,357 @@ describe("pp command", () => {
     expect(pi._commands.has("pp")).toBe(true);
   });
 });
+
+describe("transitionToNextPhase", () => {
+  function makeTransitionCtx() {
+    return {
+      ui: {
+        notify: vi.fn(),
+        setStatus: vi.fn(),
+      },
+      isIdle: vi.fn().mockReturnValue(true),
+      compact: vi.fn(),
+    };
+  }
+
+  function makeTransitionTask(taskDir: string, phase: "brainstorm" | "implement" | "quick" = "brainstorm"): ActiveTask {
+    if (phase === "quick") {
+      return {
+        dir: taskDir,
+        type: "quick",
+        state: {
+          phase: "quick",
+          step: "llm_work",
+          reviewCycle: null,
+          reviewPass: 0,
+          reviewPassByKind: {},
+          from: null,
+          description: "Quick",
+          startedAt: new Date().toISOString(),
+          repos: [{ path: taskDir, isRoot: true }],
+        },
+        release: null,
+        taskId: "quick-1",
+        modifiedFiles: new Set(),
+        reviewPass: 0,
+        description: "Quick",
+      };
+    }
+
+    return {
+      dir: taskDir,
+      type: "implement",
+      state: {
+        phase,
+        step: "llm_work",
+        reviewCycle: null,
+        reviewPass: 0,
+        reviewPassByKind: {},
+        from: null,
+        description: "Task",
+        startedAt: new Date().toISOString(),
+        repos: [{ path: taskDir, isRoot: true }],
+      },
+      release: null,
+      taskId: "impl-1",
+      modifiedFiles: new Set([join(taskDir, "src", "a.ts")]),
+      reviewPass: 0,
+      description: "Task",
+    };
+  }
+
+  it("blocks transition when exit criteria fail", async () => {
+    const pi = makePi();
+    const orchestrator = new Orchestrator(pi as any);
+    const taskDir = makeTempDir();
+    orchestrator.cwd = taskDir;
+    orchestrator.config = makeConfig() as any;
+    orchestrator.active = makeTransitionTask(taskDir, "brainstorm");
+    const ctx = makeTransitionCtx();
+    const validateSpy = vi.spyOn(machineModule, "validateExitCriteria").mockReturnValue({ ok: false, reason: "no artifacts" });
+
+    const result = await transitionToNextPhase(orchestrator, ctx);
+
+    expect(result).toEqual({ ok: false, error: "no artifacts" });
+    expect(orchestrator.active?.state.phase).toBe("brainstorm");
+    validateSpy.mockRestore();
+  });
+
+  it("runs afterImplement when transitioning from implement", async () => {
+    const pi = makePi();
+    const orchestrator = new Orchestrator(pi as any);
+    const taskDir = makeTempDir();
+    orchestrator.cwd = taskDir;
+    orchestrator.config = makeConfig() as any;
+    orchestrator.active = makeTransitionTask(taskDir, "implement");
+    const ctx = makeTransitionCtx();
+    const validateSpy = vi.spyOn(machineModule, "validateExitCriteria").mockReturnValue({ ok: true });
+    const groupSpy = vi.spyOn(await import("./repo-utils.js"), "groupFilesByRepo").mockReturnValue(new Map([[taskDir, [join(taskDir, "src", "a.ts")]]]) as any);
+    const runSpy = vi.spyOn(commandsModule, "runAfterImplement").mockReturnValue([{ ok: true, command: "npm test", output: "ok" }]);
+    const cleanupSpy = vi.spyOn(orchestrator, "cleanupActive").mockImplementation(async () => {
+      orchestrator.active = null;
+    });
+    const abortSpy = vi.spyOn(orchestrator, "abortAllSubagents").mockImplementation(() => undefined);
+    const saveSpy = vi.spyOn(stateModule, "saveTask").mockImplementation(() => undefined);
+
+    const result = await transitionToNextPhase(orchestrator, ctx);
+
+    expect(result.ok).toBe(true);
+    expect(runSpy).toHaveBeenCalledTimes(1);
+    expect(cleanupSpy).toHaveBeenCalledTimes(1);
+    expect(abortSpy).toHaveBeenCalledTimes(1);
+    expect(saveSpy).toHaveBeenCalled();
+    validateSpy.mockRestore();
+    groupSpy.mockRestore();
+  });
+
+  it("runs afterImplement for root repo during implement to done transition", async () => {
+    const pi = makePi();
+    const orchestrator = new Orchestrator(pi as any);
+    const taskDir = makeTempDir();
+    orchestrator.cwd = taskDir;
+    orchestrator.config = makeConfig() as any;
+    orchestrator.active = makeTransitionTask(taskDir, "implement");
+    orchestrator.active.state.repos = [{ path: taskDir, isRoot: true }];
+    orchestrator.active.modifiedFiles = new Set([join(taskDir, "src", "root.ts")]);
+    const ctx = makeTransitionCtx();
+    vi.spyOn(machineModule, "validateExitCriteria").mockReturnValue({ ok: true });
+    vi.spyOn(await import("./repo-utils.js"), "groupFilesByRepo").mockReturnValue(
+      new Map([[taskDir, [join(taskDir, "src", "root.ts")]]]) as any,
+    );
+    const runSpy = vi.spyOn(commandsModule, "runAfterImplement").mockReturnValue([{ ok: true, command: "npm test", output: "ok" }]);
+    const cleanupSpy = vi.spyOn(orchestrator, "cleanupActive").mockImplementation(async () => {
+      orchestrator.active = null;
+    });
+
+    const result = await transitionToNextPhase(orchestrator, ctx);
+
+    expect(result.ok).toBe(true);
+    expect(runSpy).toHaveBeenCalledWith(
+      orchestrator.config.commands.afterImplement,
+      orchestrator.config.performance.commands.afterImplement,
+      orchestrator.cwd,
+    );
+    expect(cleanupSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("clears reviewCycle and review bookkeeping on the done transition (Issue 4)", async () => {
+    const pi = makePi();
+    const orchestrator = new Orchestrator(pi as any);
+    const taskDir = makeTempDir();
+    orchestrator.cwd = taskDir;
+    orchestrator.config = makeConfig() as any;
+    orchestrator.active = makeTransitionTask(taskDir, "implement");
+    orchestrator.active.state.repos = [{ path: taskDir, isRoot: true }];
+    orchestrator.active.state.reviewCycle = { kind: "auto", step: "apply_feedback", pass: 2 };
+    orchestrator.active.state.reviewPass = 2;
+    orchestrator.active.state.reviewApprovedClean = true;
+    const ctx = makeTransitionCtx();
+    vi.spyOn(machineModule, "validateExitCriteria").mockReturnValue({ ok: true });
+    vi.spyOn(commandsModule, "runAfterImplement").mockReturnValue([{ ok: true, command: "npm test", output: "ok" }]);
+    let savedState: any = null;
+    vi.spyOn(orchestrator, "cleanupActive").mockImplementation(async () => {
+      savedState = orchestrator.active?.state;
+      orchestrator.active = null;
+    });
+
+    const result = await transitionToNextPhase(orchestrator, ctx);
+
+    expect(result.ok).toBe(true);
+    expect(savedState.phase).toBe("done");
+    expect(savedState.reviewCycle).toBeNull();
+    expect(savedState.reviewPass).toBe(0);
+    expect(savedState.reviewApprovedClean).toBe(false);
+  });
+
+  it("runs afterImplement for extra repo when extra repo configs are enabled", async () => {
+    const pi = makePi();
+    const orchestrator = new Orchestrator(pi as any);
+    const taskDir = makeTempDir();
+    const extraRepo = join(taskDir, "extra");
+    mkdirSync(extraRepo, { recursive: true });
+    orchestrator.cwd = taskDir;
+    orchestrator.config = {
+      ...makeConfig(),
+      general: { ...makeConfig().general, loadExtraRepoConfigs: true },
+    } as any;
+    orchestrator.active = makeTransitionTask(taskDir, "implement");
+    orchestrator.active.state.repos = [
+      { path: taskDir, isRoot: true },
+      { path: extraRepo, isRoot: false },
+    ];
+    orchestrator.active.modifiedFiles = new Set([join(extraRepo, "src", "extra.ts")]);
+    const ctx = makeTransitionCtx();
+    vi.spyOn(machineModule, "validateExitCriteria").mockReturnValue({ ok: true });
+    vi.spyOn(await import("./repo-utils.js"), "groupFilesByRepo").mockReturnValue(
+      new Map([[extraRepo, [join(extraRepo, "src", "extra.ts")]]]) as any,
+    );
+    vi.spyOn(commandsModule, "loadRepoAfterImplementCommands").mockReturnValue({ "cmd-1": { run: "npm run lint" } });
+    const runSpy = vi.spyOn(commandsModule, "runAfterImplement").mockReturnValue([{ ok: true, command: "npm run lint", output: "ok" }]);
+    vi.spyOn(orchestrator, "cleanupActive").mockImplementation(async () => {
+      orchestrator.active = null;
+    });
+
+    const result = await transitionToNextPhase(orchestrator, ctx);
+
+    expect(result.ok).toBe(true);
+    expect(runSpy).toHaveBeenCalledWith({ "cmd-1": { run: "npm run lint" } }, orchestrator.config.performance.commands.afterImplement, extraRepo);
+  });
+
+  it("blocks transition when afterImplement fails in extra repo", async () => {
+    const pi = makePi();
+    const orchestrator = new Orchestrator(pi as any);
+    const taskDir = makeTempDir();
+    const extraRepo = join(taskDir, "extra");
+    mkdirSync(extraRepo, { recursive: true });
+    orchestrator.cwd = taskDir;
+    orchestrator.config = {
+      ...makeConfig(),
+      general: { ...makeConfig().general, loadExtraRepoConfigs: true },
+    } as any;
+    orchestrator.active = makeTransitionTask(taskDir, "implement");
+    orchestrator.active.state.repos = [
+      { path: taskDir, isRoot: true },
+      { path: extraRepo, isRoot: false },
+    ];
+    orchestrator.active.modifiedFiles = new Set([join(extraRepo, "src", "extra.ts")]);
+    const ctx = makeTransitionCtx();
+    vi.spyOn(machineModule, "validateExitCriteria").mockReturnValue({ ok: true });
+    vi.spyOn(await import("./repo-utils.js"), "groupFilesByRepo").mockReturnValue(
+      new Map([[extraRepo, [join(extraRepo, "src", "extra.ts")]]]) as any,
+    );
+    vi.spyOn(commandsModule, "loadRepoAfterImplementCommands").mockReturnValue({ "cmd-1": { run: "npm run lint" } });
+    vi.spyOn(commandsModule, "runAfterImplement").mockReturnValue([{ ok: false, command: "npm run lint", output: "lint failed" }]);
+    const cleanupSpy = vi.spyOn(orchestrator, "cleanupActive");
+
+    const result = await transitionToNextPhase(orchestrator, ctx);
+
+    expect(result.ok).toBe(false);
+    expect(result.error).toContain("afterImplement commands failed");
+    expect(result.error).toContain("npm run lint: lint failed");
+    expect(cleanupSpy).not.toHaveBeenCalled();
+    expect(orchestrator.active?.state.phase).toBe("implement");
+  });
+
+  it("skips afterImplement for extra repo when ignoreExtraRepoConfigs is true", async () => {
+    const pi = makePi();
+    const orchestrator = new Orchestrator(pi as any);
+    const taskDir = makeTempDir();
+    const extraRepo = join(taskDir, "extra");
+    mkdirSync(extraRepo, { recursive: true });
+    orchestrator.cwd = taskDir;
+    orchestrator.config = {
+      ...makeConfig(),
+      general: { ...makeConfig().general, loadExtraRepoConfigs: false },
+    } as any;
+    orchestrator.active = makeTransitionTask(taskDir, "implement");
+    orchestrator.active.state.repos = [
+      { path: taskDir, isRoot: true },
+      { path: extraRepo, isRoot: false },
+    ];
+    orchestrator.active.modifiedFiles = new Set([join(extraRepo, "src", "extra.ts")]);
+    const ctx = makeTransitionCtx();
+    vi.spyOn(machineModule, "validateExitCriteria").mockReturnValue({ ok: true });
+    vi.spyOn(await import("./repo-utils.js"), "groupFilesByRepo").mockReturnValue(
+      new Map([[extraRepo, [join(extraRepo, "src", "extra.ts")]]]) as any,
+    );
+    const loadExtraSpy = vi.spyOn(commandsModule, "loadRepoAfterImplementCommands");
+    const runSpy = vi.spyOn(commandsModule, "runAfterImplement").mockReturnValue([{ ok: true, command: "npm test", output: "ok" }]);
+    vi.spyOn(orchestrator, "cleanupActive").mockImplementation(async () => {
+      orchestrator.active = null;
+    });
+
+    const result = await transitionToNextPhase(orchestrator, ctx);
+
+    expect(result.ok).toBe(true);
+    expect(loadExtraSpy).not.toHaveBeenCalled();
+    expect(runSpy).not.toHaveBeenCalled();
+  });
+
+  it("transition to done cleans up active task", async () => {
+    const pi = makePi();
+    const orchestrator = new Orchestrator(pi as any);
+    const taskDir = makeTempDir();
+    orchestrator.cwd = taskDir;
+    orchestrator.config = makeConfig() as any;
+    orchestrator.active = makeTransitionTask(taskDir, "implement");
+    const ctx = makeTransitionCtx();
+    vi.spyOn(machineModule, "validateExitCriteria").mockReturnValue({ ok: true });
+    vi.spyOn(await import("./repo-utils.js"), "groupFilesByRepo").mockReturnValue(new Map([[taskDir, [join(taskDir, "src", "a.ts")]]]) as any);
+    vi.spyOn(commandsModule, "runAfterImplement").mockReturnValue([{ ok: true, command: "npm test", output: "ok" }]);
+    const cleanupSpy = vi.spyOn(orchestrator, "cleanupActive").mockImplementation(async () => {
+      orchestrator.active = null;
+    });
+
+    const result = await transitionToNextPhase(orchestrator, ctx);
+
+    expect(result).toEqual({ ok: true });
+    expect(cleanupSpy).toHaveBeenCalledTimes(1);
+    // Done transition routes through the controller; idle ctx -> compacts now.
+    expect(ctx.compact).toHaveBeenCalledTimes(1);
+  });
+
+  it("transition to plan sets await_planners step", async () => {
+    const pi = makePi();
+    const orchestrator = new Orchestrator(pi as any);
+    const taskDir = makeTempDir();
+    orchestrator.cwd = taskDir;
+    orchestrator.config = makeConfig() as any;
+    orchestrator.active = makeTransitionTask(taskDir, "brainstorm");
+    const ctx = makeTransitionCtx();
+    const validateSpy = vi.spyOn(machineModule, "validateExitCriteria").mockReturnValue({ ok: true });
+    const compactSpy = vi.spyOn(orchestrator, "compactAndTransition").mockImplementation(() => undefined);
+    const saveSpy = vi.spyOn(stateModule, "saveTask").mockImplementation(() => undefined);
+
+    const result = await transitionToNextPhase(orchestrator, ctx, "regular");
+
+    expect(result).toEqual({ ok: true });
+    expect(orchestrator.active?.state.phase).toBe("plan");
+    expect(orchestrator.active?.state.step).toBe("await_planners");
+    expect(orchestrator.active?.state.activePlannerPreset).toBe("regular");
+    expect(compactSpy).toHaveBeenCalledTimes(1);
+    expect(saveSpy).toHaveBeenCalled();
+    validateSpy.mockRestore();
+  });
+
+  it("skips afterImplement for quick tasks", async () => {
+    const pi = makePi();
+    const orchestrator = new Orchestrator(pi as any);
+    const taskDir = makeTempDir();
+    orchestrator.cwd = taskDir;
+    orchestrator.config = makeConfig() as any;
+    orchestrator.active = makeTransitionTask(taskDir, "quick");
+    const ctx = makeTransitionCtx();
+    vi.spyOn(machineModule, "validateExitCriteria").mockReturnValue({ ok: true });
+    const runSpy = vi.spyOn(commandsModule, "runAfterImplement");
+    const cleanupSpy = vi.spyOn(orchestrator, "cleanupActive").mockImplementation(async () => {
+      orchestrator.active = null;
+    });
+
+    const result = await transitionToNextPhase(orchestrator, ctx);
+
+    expect(result).toEqual({ ok: true });
+    expect(runSpy).not.toHaveBeenCalled();
+    expect(cleanupSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("skips afterImplement when phase is not implement", async () => {
+    const pi = makePi();
+    const orchestrator = new Orchestrator(pi as any);
+    const taskDir = makeTempDir();
+    orchestrator.cwd = taskDir;
+    orchestrator.config = makeConfig() as any;
+    orchestrator.active = makeTransitionTask(taskDir, "brainstorm");
+    const ctx = makeTransitionCtx();
+    vi.spyOn(machineModule, "validateExitCriteria").mockReturnValue({ ok: true });
+    const runSpy = vi.spyOn(commandsModule, "runAfterImplement");
+    const compactSpy = vi.spyOn(orchestrator, "compactAndTransition").mockImplementation(() => undefined);
+
+    const result = await transitionToNextPhase(orchestrator, ctx);
+
+    expect(result).toEqual({ ok: true });
+    expect(runSpy).not.toHaveBeenCalled();
+    expect(orchestrator.active?.state.phase).toBe("plan");
+    expect(compactSpy).toHaveBeenCalledTimes(1);
+  });
+});