@ilya-lesikov/pi-pi 0.10.0 → 0.12.0

package/extensions/orchestrator/assumptions.test.ts

@@ -0,0 +1,77 @@
+import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { openAssumptionsBanner, readAssumptions, terminalAssumptionsSummary } from "./assumptions.js";
+
+function taskDirWith(content?: string): string {
+  const dir = mkdtempSync(join(tmpdir(), "pp-assumptions-"));
+  if (content !== undefined) {
+    mkdirSync(join(dir, "artifacts"), { recursive: true });
+    writeFileSync(join(dir, "artifacts", "ASSUMPTIONS.md"), content, "utf-8");
+  }
+  return dir;
+}
+
+describe("readAssumptions", () => {
+  it("treats an absent file as no assumptions", () => {
+    expect(readAssumptions(taskDirWith())).toEqual([]);
+  });
+
+  it("treats an explicit _No open assumptions._ sentinel as none", () => {
+    expect(readAssumptions(taskDirWith("# Assumptions\n\n_No open assumptions._\n"))).toEqual([]);
+  });
+
+  it("parses list items and classifies confidence and resolved status", () => {
+    const md = [
+      "# Assumptions",
+      "",
+      "- statement: API is idempotent; confidence: low; basis: docs; invalidation test: retry; decision impact: skip lock; status: open",
+      "- statement: config lives in root; confidence: high; basis: grep; status: resolved",
+    ].join("\n");
+    const entries = readAssumptions(taskDirWith(md));
+    expect(entries).toHaveLength(2);
+    expect(entries[0].confidence).toBe("low");
+    expect(entries[0].resolved).toBe(false);
+    expect(entries[1].confidence).toBe("high");
+    expect(entries[1].resolved).toBe(true);
+  });
+});
+
+describe("openAssumptionsBanner", () => {
+  it("is null when there are no open low/med entries", () => {
+    expect(openAssumptionsBanner(taskDirWith())).toBeNull();
+    const resolvedHigh = "# A\n\n- statement: x; confidence: high; status: resolved\n";
+    expect(openAssumptionsBanner(taskDirWith(resolvedHigh))).toBeNull();
+  });
+
+  it("surfaces a count when open low/med entries exist", () => {
+    const md = [
+      "# A",
+      "- statement: a; confidence: low; status: open",
+      "- statement: b; confidence: med; status: open",
+      "- statement: c; confidence: high; status: open",
+    ].join("\n");
+    const banner = openAssumptionsBanner(taskDirWith(md));
+    expect(banner).toContain("2 unresolved");
+    expect(banner).toContain("ASSUMPTIONS.md");
+  });
+});
+
+describe("terminalAssumptionsSummary", () => {
+  it("states none when empty", () => {
+    expect(terminalAssumptionsSummary(taskDirWith())).toBe("Assumptions: none recorded.");
+  });
+
+  it("lists every recorded assumption with status regardless of confidence", () => {
+    const md = [
+      "# A",
+      "- statement: a; confidence: low; status: open",
+      "- statement: b; confidence: high; status: resolved",
+    ].join("\n");
+    const summary = terminalAssumptionsSummary(taskDirWith(md));
+    expect(summary).toContain("Assumptions recorded this run (2)");
+    expect(summary).toContain("[open, low]");
+    expect(summary).toContain("[resolved, high]");
+  });
+});

package/extensions/orchestrator/assumptions.ts

@@ -0,0 +1,85 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+export const ASSUMPTIONS_PATH = "artifacts/ASSUMPTIONS.md";
+
+// The optional artifact the main agent writes unverified assumptions to (see
+// agents/constraints.ts assumptionsRule). Absence — or an explicit
+// `_No open assumptions._` sentinel — means there are none. Entries are markdown
+// list items carrying statement/confidence/basis/invalidation test/decision
+// impact plus an open|resolved status marker.
+export interface AssumptionEntry {
+  text: string;
+  confidence: "low" | "med" | "high" | "unknown";
+  resolved: boolean;
+}
+
+function assumptionsFile(taskDir: string): string {
+  return join(taskDir, "artifacts", "ASSUMPTIONS.md");
+}
+
+// Split the file into top-level list items (each assumption). A list item starts
+// with `-`/`*`/`1.`; continuation/detail lines are folded into the current item
+// so multi-line entries parse as one.
+function parseEntries(content: string): AssumptionEntry[] {
+  const entries: AssumptionEntry[] = [];
+  let current: string[] | null = null;
+  const flush = () => {
+    if (!current) return;
+    const text = current.join(" ").trim();
+    if (text) entries.push(classify(text));
+    current = null;
+  };
+  for (const raw of content.split("\n")) {
+    const line = raw.trimEnd();
+    if (/^\s*([-*]|\d+\.)\s+/.test(line)) {
+      flush();
+      current = [line.replace(/^\s*([-*]|\d+\.)\s+/, "")];
+    } else if (current && line.trim()) {
+      current.push(line.trim());
+    } else {
+      flush();
+    }
+  }
+  flush();
+  return entries;
+}
+
+function classify(text: string): AssumptionEntry {
+  const lower = text.toLowerCase();
+  const resolved = /\bresolved\b/.test(lower) && !/\bstatus:\s*open\b/.test(lower);
+  let confidence: AssumptionEntry["confidence"] = "unknown";
+  if (/confidence:?\s*low\b/.test(lower) || /\blow confidence\b/.test(lower)) confidence = "low";
+  else if (/confidence:?\s*med(ium)?\b/.test(lower) || /\bmed(ium)? confidence\b/.test(lower)) confidence = "med";
+  else if (/confidence:?\s*high\b/.test(lower) || /\bhigh confidence\b/.test(lower)) confidence = "high";
+  return { text, confidence, resolved };
+}
+
+export function readAssumptions(taskDir: string): AssumptionEntry[] {
+  const file = assumptionsFile(taskDir);
+  if (!existsSync(file)) return [];
+  const content = readFileSync(file, "utf-8");
+  if (/^\s*_no open assumptions\._\s*$/im.test(content) && parseEntries(content).length === 0) return [];
+  return parseEntries(content);
+}
+
+// A one-line /pp gate banner when there are open low/med-confidence assumptions
+// the user should double-check; null when there is nothing worth surfacing.
+export function openAssumptionsBanner(taskDir: string): string | null {
+  const open = readAssumptions(taskDir).filter((e) => !e.resolved && (e.confidence === "low" || e.confidence === "med"));
+  if (open.length === 0) return null;
+  return `⚠ ${open.length} unresolved low/medium-confidence assumption${open.length === 1 ? "" : "s"} recorded — review ${ASSUMPTIONS_PATH} before advancing.`;
+}
+
+// End-of-run summary for an autonomous task that never hit a /pp gate: lists every
+// recorded assumption (open and resolved, all confidence levels), or states none.
+export function terminalAssumptionsSummary(taskDir: string): string {
+  const entries = readAssumptions(taskDir);
+  if (entries.length === 0) return "Assumptions: none recorded.";
+  const lines = entries.map((e) => {
+    const status = e.resolved ? "resolved" : "open";
+    const conf = e.confidence === "unknown" ? "" : `, ${e.confidence}`;
+    return `- [${status}${conf}] ${e.text}`;
+  });
+  return [`Assumptions recorded this run (${entries.length}):`, ...lines].join("\n");
+}

package/extensions/orchestrator/cbm.ts

@@ -6,7 +6,10 @@ import { getLogger } from "./log.js";
 
 function findCbmBin(): string | null {
   try {
-    return execFileSync("which", ["codebase-memory-mcp"], { encoding: "utf-8", stdio: "pipe" }).trim() || null;
+    const whichCmd = process.platform === "win32" ? "where" : "which";
+    const out = execFileSync(whichCmd, ["codebase-memory-mcp"], { encoding: "utf-8", stdio: "pipe" });
+    const first = out.split("\n").map((line) => line.trim()).find((line) => line.length > 0);
+    return first || null;
   } catch {
     return null;
   }

package/extensions/orchestrator/cbm.which.test.ts

@@ -0,0 +1,92 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  execFileSync: vi.fn(),
+}));
+
+vi.mock("child_process", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("child_process")>();
+  return { ...actual, execFileSync: mocks.execFileSync };
+});
+
+import { registerCbmTools } from "./cbm.js";
+
+const CBM_BIN_KEY = Symbol.for("pi-pi:cbm-bin");
+const CBM_DAEMON_KEY = Symbol.for("pi-pi:cbm-daemon");
+
+function setPlatform(platform: NodeJS.Platform) {
+  Object.defineProperty(process, "platform", { value: platform, configurable: true });
+}
+
+function seedFakeDaemon() {
+  (globalThis as any)[CBM_DAEMON_KEY] = {
+    ensureIndexed: vi.fn().mockResolvedValue("repo"),
+    callTool: vi.fn().mockResolvedValue({}),
+  };
+}
+
+describe("cbm platform-aware executable resolution", () => {
+  const originalPlatform = process.platform;
+
+  afterEach(() => {
+    setPlatform(originalPlatform);
+    (globalThis as any)[CBM_BIN_KEY] = undefined;
+    (globalThis as any)[CBM_DAEMON_KEY] = undefined;
+    mocks.execFileSync.mockReset();
+    vi.restoreAllMocks();
+  });
+
+  it("uses `which` on posix and resolves the trimmed path", () => {
+    setPlatform("linux");
+    seedFakeDaemon();
+    mocks.execFileSync.mockImplementation((cmd: string, args: string[]) => {
+      if (cmd === "which" && args[0] === "codebase-memory-mcp") return "/usr/bin/codebase-memory-mcp\n";
+      throw new Error(`unexpected: ${cmd}`);
+    });
+
+    const registered = registerCbmTools({ registerTool: vi.fn() } as any, "/repo");
+
+    expect(registered).toBe(true);
+    expect(mocks.execFileSync).toHaveBeenCalledWith("which", ["codebase-memory-mcp"], expect.anything());
+  });
+
+  it("returns unavailable on posix when `which` throws (not found)", () => {
+    setPlatform("linux");
+    mocks.execFileSync.mockImplementation(() => {
+      throw new Error("not found");
+    });
+
+    const registered = registerCbmTools({ registerTool: vi.fn() } as any, "/repo");
+
+    expect(registered).toBe(false);
+    expect(mocks.execFileSync).toHaveBeenCalledWith("which", ["codebase-memory-mcp"], expect.anything());
+  });
+
+  it("uses `where` on win32 and takes the first non-empty line", () => {
+    setPlatform("win32");
+    seedFakeDaemon();
+    mocks.execFileSync.mockImplementation((cmd: string, args: string[]) => {
+      if (cmd === "where" && args[0] === "codebase-memory-mcp") {
+        return "C:\\bin\\codebase-memory-mcp.exe\r\nC:\\other\\codebase-memory-mcp.exe\r\n";
+      }
+      throw new Error(`unexpected: ${cmd}`);
+    });
+
+    const registered = registerCbmTools({ registerTool: vi.fn() } as any, "/repo");
+
+    expect(registered).toBe(true);
+    expect(mocks.execFileSync).toHaveBeenCalledWith("where", ["codebase-memory-mcp"], expect.anything());
+  });
+
+  it("returns unavailable on win32 when `where` throws (not found)", () => {
+    setPlatform("win32");
+    mocks.execFileSync.mockImplementation(() => {
+      throw new Error("INFO: Could not find files");
+    });
+
+    const registered = registerCbmTools({ registerTool: vi.fn() } as any, "/repo");
+
+    expect(registered).toBe(false);
+    expect(mocks.execFileSync).toHaveBeenCalledWith("where", ["codebase-memory-mcp"], expect.anything());
+  });
+});

package/extensions/orchestrator/command-handlers.ts

@@ -6,6 +6,7 @@ import { spawnPlanners } from "./phases/planning.js";
 import { Orchestrator } from "./orchestrator.js";
 import { groupFilesByRepo } from "./repo-utils.js";
 import { getEffectiveMode, saveTask } from "./state.js";
+import { terminalAssumptionsSummary } from "./assumptions.js";
 import { getLogger } from "./log.js";
 import { handleSpawnResult } from "./spawn-cleanup.js";
 
@@ -97,7 +98,7 @@ export async function transitionToNextPhase(
     orchestrator.active.state.step = "spawn_planners";
   } else if (next === "implement") {
     orchestrator.active.state.step = "llm_work";
-  } else if (next === "brainstorm" || next === "debug") {
+  } else if (next === "brainstorm") {
     orchestrator.active.state.step = "llm_work";
   } else if (next === "done") {
     orchestrator.active.state.step = null;
@@ -111,6 +112,13 @@ export async function transitionToNextPhase(
     const name = orchestrator.active.description;
     const type = orchestrator.active.type;
 
+    // Terminal assumptions summary (#B/e): an autonomous run can reach done without
+    // ever hitting a /pp gate (where the banner surfaces), so emit the full list of
+    // recorded assumptions once here. Read before cleanup while the task dir is live.
+    if (getEffectiveMode(orchestrator.active.state) === "autonomous") {
+      ctx.ui.notify(terminalAssumptionsSummary(orchestrator.active.dir), "info");
+    }
+
     orchestrator.abortAllSubagents();
     unregisterAgentDefinitions(orchestrator.pi);
     await orchestrator.cleanupActive();

package/extensions/orchestrator/config.test.ts

@@ -203,7 +203,6 @@ describe("loadConfig", () => {
 
     expect(config.agents.orchestrators.implement.model).toBe("custom/implement");
     expect(config.agents.orchestrators.plan.model).toBe("anthropic/claude-opus-latest");
-    expect(config.agents.orchestrators.debug.model).toBe("openai/gpt-latest");
     const planners = resolvePreset(config, "planners");
     expect(planners.opus.enabled).toBe(false);
     expect(planners.opus.model).toBe("anthropic/claude-opus-latest");
@@ -553,9 +552,8 @@ describe("config write helpers", () => {
 });
 
 describe("reviewPresetGroupForPhase", () => {
-  it("routes brainstorm and debug to brainstormReviewers", () => {
+  it("routes brainstorm to brainstormReviewers", () => {
     expect(reviewPresetGroupForPhase("brainstorm")).toBe("brainstormReviewers");
-    expect(reviewPresetGroupForPhase("debug")).toBe("brainstormReviewers");
   });
 
   it("routes plan to planReviewers", () => {

package/extensions/orchestrator/config.ts

@@ -6,7 +6,7 @@ import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { isValidLogLevel, getLogger, type LogLevel } from "./log.js";
 
 export type DurationValue = string | number;
-export type OrchestratorRole = "implement" | "plan" | "debug" | "brainstorm" | "review" | "quick";
+export type OrchestratorRole = "implement" | "plan" | "brainstorm" | "review" | "quick";
 export type SimpleSubagentRole = "explore" | "librarian" | "task";
 export type PresetGroupKey = "planners" | "codeReviewers" | "planReviewers" | "brainstormReviewers";
 // Dynamic on-demand subagent pools (item 2): advisor / reviewer / deep-debugger
@@ -105,7 +105,7 @@ export type PresetGroup = PresetGroupKey;
 export type VariantConfig = PresetAgentConfig;
 
 export function reviewPresetGroupForPhase(phase: string): PresetGroupKey {
-  if (phase === "brainstorm" || phase === "debug") return "brainstormReviewers";
+  if (phase === "brainstorm") return "brainstormReviewers";
   if (phase === "plan") return "planReviewers";
   return "codeReviewers";
 }
@@ -113,7 +113,7 @@ export type TimeoutConfig = NormalizedPiPiConfig["performance"]["internals"];
 
 export const PRESET_GROUPS = ["planners", "codeReviewers", "planReviewers", "brainstormReviewers"] as const;
 
-const ORCHESTRATOR_ROLES: OrchestratorRole[] = ["implement", "plan", "debug", "brainstorm", "review", "quick"];
+const ORCHESTRATOR_ROLES: OrchestratorRole[] = ["implement", "plan", "brainstorm", "review", "quick"];
 const SIMPLE_SUBAGENT_ROLES: SimpleSubagentRole[] = ["explore", "librarian", "task"];
 
 const DEFAULT_CONFIG: PiPiConfig = {
@@ -129,7 +129,6 @@ const DEFAULT_CONFIG: PiPiConfig = {
     orchestrators: {
       implement: { model: "anthropic/claude-opus-latest", thinking: "high" },
       plan: { model: "anthropic/claude-opus-latest", thinking: "high" },
-      debug: { model: "openai/gpt-latest", thinking: "high" },
       brainstorm: { model: "anthropic/claude-opus-latest", thinking: "high" },
       review: { model: "anthropic/claude-opus-latest", thinking: "high" },
       quick: { model: "anthropic/claude-opus-latest", thinking: "high" },

package/extensions/orchestrator/context.test.ts

@@ -189,7 +189,7 @@ describe("loadContextFiles", () => {
       loadContextFiles(cwd, "codeReviewer", "context", "review", { vendor: "google", family: "gpt-mini", tier: "stupid" }),
     ).toEqual([]);
     expect(
-      loadContextFiles(cwd, "codeReviewer", "context", "debug", { vendor: "openai", family: "gpt-mini", tier: "stupid" }),
+      loadContextFiles(cwd, "codeReviewer", "context", "plan", { vendor: "openai", family: "gpt-mini", tier: "stupid" }),
     ).toEqual([]);
   });
 
@@ -530,17 +530,12 @@ describe("context regressions", () => {
     ]);
   });
 
-  it("loadPhaseReviewOutputs reads brainstorm-reviews for both brainstorm and debug", () => {
+  it("loadPhaseReviewOutputs reads brainstorm-reviews for brainstorm", () => {
     const taskDir = makeTempDir();
     const brainstormReviewsDir = join(taskDir, "brainstorm-reviews");
     mkdirSync(brainstormReviewsDir, { recursive: true });
     writeFileSync(join(brainstormReviewsDir, "001_alpha_round-1.md"), "artifact review", "utf-8");
 
-    // Debug must resolve to the brainstorm-reviews dir (regression: it previously
-    // fell through to the empty code-reviews dir, discarding reviewer outputs).
-    expect(loadPhaseReviewOutputs(taskDir, "debug", 1).map((r) => r.name)).toEqual([
-      "001_alpha_round-1.md",
-    ]);
     expect(loadPhaseReviewOutputs(taskDir, "brainstorm", 1).map((r) => r.name)).toEqual([
       "001_alpha_round-1.md",
     ]);

package/extensions/orchestrator/context.ts

@@ -10,7 +10,7 @@ import { reviewPresetGroupForPhase } from "./config.js";
 type AgentType = "main" | "explore" | "librarian" | "planner" | "planReviewer" | "task" | "codeReviewer" | "brainstormReviewer" | "advisor" | "deep-debugger" | "reviewer";
 type AgentGroup = "all" | "subagents";
 type InjectMode = "system" | "context";
-type PhaseFilter = "brainstorm" | "debug" | "plan" | "implement" | "review";
+type PhaseFilter = "brainstorm" | "plan" | "implement" | "review";
 type VendorFilter = "anthropic" | "openai" | "google" | "unknown";
 type FamilyFilter = "opus" | "fable" | "sonnet" | "haiku" | "gpt" | "gpt-mini" | "gemini-pro" | "gemini-flash" | "unknown";
 type TierFilter = "stupid" | "regular" | "smart" | "xsmart" | "unknown";
@@ -34,7 +34,7 @@ interface Frontmatter {
 const VALID_INJECT_MODES: readonly string[] = ["system", "context"];
 const VALID_AGENTS: readonly string[] = ["main", "explore", "librarian", "planner", "planReviewer", "task", "codeReviewer", "brainstormReviewer", "advisor", "deep-debugger", "reviewer"];
 const VALID_AGENT_GROUPS: readonly string[] = ["all", "subagents"];
-const VALID_PHASES: readonly string[] = ["brainstorm", "debug", "plan", "implement", "review"];
+const VALID_PHASES: readonly string[] = ["brainstorm", "plan", "implement", "review"];
 const VALID_VENDORS: readonly string[] = ["anthropic", "openai", "google", "unknown"];
 const VALID_FAMILIES: readonly string[] = ["opus", "fable", "sonnet", "haiku", "gpt", "gpt-mini", "gemini-pro", "gemini-flash", "unknown"];
 const VALID_TIERS: readonly string[] = ["stupid", "regular", "smart", "xsmart", "unknown"];
@@ -388,7 +388,7 @@ export function loadPlanReviewOutputs(taskDir: string, pass: number): { name: st
 }
 
 // Single source for phase→review-output loading, mirroring reviewPresetGroupForPhase
-// (brainstorm/debug → brainstorm-reviews, plan → plan-reviews, else code-reviews).
+// (brainstorm → brainstorm-reviews, plan → plan-reviews, else code-reviews).
 // Imported by both the /pp menu and the review-cycle completion path so the two
 // cannot drift.
 export function loadPhaseReviewOutputs(taskDir: string, phase: string, pass: number): { name: string; content: string }[] {

package/extensions/orchestrator/doctor.test.ts

@@ -381,6 +381,41 @@ describe("runDoctor", () => {
     expect(report).toContain("gh: /usr/local/bin/gh");
   });
 
+  it("resolves binaries via `where` on win32, taking the first line", async () => {
+    const originalPlatform = process.platform;
+    Object.defineProperty(process, "platform", { value: "win32", configurable: true });
+    const cwd = makeTempDir("pi-pi-doctor-win-");
+    const ctx = createCtx();
+    const orchestrator = {
+      cwd,
+      config: createConfig(),
+      active: null,
+    } as any;
+
+    mocks.execFileSync.mockImplementation((command: string, args: string[]) => {
+      if (command !== "where") throw new Error(`Unexpected command: ${command}`);
+      const bin = args[0];
+      if (bin === "git") return "C:\\Program Files\\Git\\cmd\\git.exe\r\nC:\\other\\git.exe\r\n";
+      if (bin === "gh") return "C:\\bin\\gh.exe\r\n";
+      if (bin === "codebase-memory-mcp") throw new Error("INFO: Could not find files");
+      if (bin === "sg") throw new Error("INFO: Could not find files");
+      if (bin === "node") return "C:\\Program Files\\nodejs\\node.exe\r\n";
+      if (bin === "npm") return "C:\\Program Files\\nodejs\\npm.cmd\r\n";
+      throw new Error(`${bin} not found`);
+    });
+
+    try {
+      await runDoctor(orchestrator, ctx);
+    } finally {
+      Object.defineProperty(process, "platform", { value: originalPlatform, configurable: true });
+    }
+
+    const [report] = ctx.ui.notify.mock.calls[0] as [string, string];
+    expect(report).toContain("git: C:\\Program Files\\Git\\cmd\\git.exe");
+    expect(report).not.toContain("C:\\other\\git.exe");
+    expect(report).toContain("gh: C:\\bin\\gh.exe");
+  });
+
   it("checks current working directory as repo when no task is active", async () => {
     const cwd = makeTempDir("pi-pi-doctor-cwd-repo-");
     mkdirSync(join(cwd, ".git"), { recursive: true });

package/extensions/orchestrator/doctor.ts

@@ -53,8 +53,10 @@ function flantCacheDir(): string {
 
 function which(bin: string): string | null {
   try {
-    const out = execFileSync("which", [bin], { encoding: "utf-8", stdio: "pipe" }).trim();
-    return out || null;
+    const whichCmd = process.platform === "win32" ? "where" : "which";
+    const out = execFileSync(whichCmd, [bin], { encoding: "utf-8", stdio: "pipe" });
+    const first = out.split("\n").map((line) => line.trim()).find((line) => line.length > 0);
+    return first || null;
   } catch {
     return null;
   }