@ilya-lesikov/pi-pi 0.11.0 → 0.12.0

package/extensions/orchestrator/pp-state-tools.ts

@@ -138,7 +138,7 @@ function validateStateContent(taskDir: string, absolute: string, content: string
     const res = validatePlan(content);
     return res.ok
       ? { ok: true }
-      : { ok: false, errors: res.errors, hint: "Keep exactly: # Plan, ## Scope, ## Checklist (items need 'Done when:'), ## Blockers (optional)." };
+      : { ok: false, errors: res.errors, hint: "Keep exactly: # Plan, ## Scope, ## Checklist (items need 'Done when:'), ## Pattern constraints (optional), ## Blockers (optional)." };
   }
   return { ok: true };
 }

package/extensions/orchestrator/rate-limit-fallback-flow.test.ts

@@ -30,14 +30,14 @@ import { handleMainRateLimit, handleSubagentRateLimit } from "./rate-limit-fallb
 
 function makeOrchestrator() {
   return {
-    active: { state: { phase: "debug" } },
+    active: { state: { phase: "implement" } },
     activeTaskToken: 1,
     subFallbackActive: false,
     subFallbackDialogPending: false,
     subFallbackPendingDecision: false,
     subFallbackModelId: null as string | null,
     subSwitchBackTimer: null as any,
-    config: { agents: { orchestrators: { debug: { thinking: "high" }, implement: { thinking: "high" } } } },
+    config: { agents: { orchestrators: { implement: { thinking: "high" } } } },
     switchModel: vi.fn().mockResolvedValue(true),
     sendUserMessageWhenIdle: vi.fn(),
     cancelPendingRetry: vi.fn(),

package/extensions/orchestrator/rate-limit-fallback.ts

@@ -160,7 +160,7 @@ async function activateFallback(
 function currentThinking(orchestrator: Orchestrator): string {
   const phase = orchestrator.active?.state.phase;
   const orchestrators = orchestrator.config?.agents?.orchestrators as Record<string, { thinking?: string }> | undefined;
-  const key = phase === "debug" || phase === "brainstorm" || phase === "review" || phase === "quick" ? phase : "implement";
+  const key = phase === "brainstorm" || phase === "review" || phase === "quick" ? phase : "implement";
   return orchestrators?.[key]?.thinking ?? "high";
 }
 

package/extensions/orchestrator/state.test.ts

@@ -52,15 +52,6 @@ describe("createTask", () => {
     expect(raw.endsWith("\n")).toBe(true);
   });
 
-  it("uses debug as initial phase for debug", () => {
-    const cwd = makeCwd();
-    const taskDir = createTask(cwd, "debug", "Fix timeout issue");
-    const state = loadTask(taskDir);
-    expect(state.phase).toBe("debug");
-    expect(state.step).toBe("llm_work");
-    expect(state.reviewCycle).toBeNull();
-    expect(state.reviewPass).toBe(0);
-  });
 
   it("uses brainstorm as initial phase for brainstorm", () => {
     const cwd = makeCwd();
@@ -103,6 +94,16 @@ describe("loadTask", () => {
 
     expect(() => loadTask(taskDir)).toThrowError(/Failed to parse .*state\.json:/);
   });
+
+  it("throws for a legacy debug-phase task", () => {
+    const cwd = makeCwd();
+    const taskDir = createTask(cwd, "implement", "Legacy debug");
+    const state = loadTask(taskDir);
+    (state as any).phase = "debug";
+    saveTask(taskDir, state);
+
+    expect(() => loadTask(taskDir)).toThrowError(/Debug tasks are no longer supported/);
+  });
 });
 
 describe("saveTask", () => {
@@ -134,18 +135,18 @@ describe("listTasks", () => {
   it("lists only non-done tasks and respects type filter", () => {
     const cwd = makeCwd();
     const implementTask = createTask(cwd, "implement", "Implement feature");
-    const debugTask = createTask(cwd, "debug", "Debug crash");
+    const reviewTask = createTask(cwd, "review", "Review crash");
     const brainstormTask = createTask(cwd, "brainstorm", "Idea storm");
 
-    const doneState = loadTask(debugTask);
+    const doneState = loadTask(reviewTask);
     doneState.phase = "done";
-    saveTask(debugTask, doneState);
+    saveTask(reviewTask, doneState);
 
     const all = listTasks(cwd);
     const allDirs = all.map((t) => t.dir);
     expect(allDirs).toContain(implementTask);
     expect(allDirs).toContain(brainstormTask);
-    expect(allDirs).not.toContain(debugTask);
+    expect(allDirs).not.toContain(reviewTask);
 
     const brainstormOnly = listTasks(cwd, "brainstorm");
     expect(brainstormOnly).toHaveLength(1);
@@ -384,7 +385,7 @@ describe("getActiveTask", () => {
   it("returns null when multiple unlocked tasks exist (ambiguous)", () => {
     const cwd = makeCwd();
     createTask(cwd, "implement", "First abandoned");
-    createTask(cwd, "debug", "Second abandoned");
+    createTask(cwd, "review", "Second abandoned");
     vi.spyOn(lockfile, "checkSync").mockReturnValue(false);
 
     expect(getActiveTask(cwd)).toBeNull();
@@ -393,7 +394,7 @@ describe("getActiveTask", () => {
   it("returns the single unlocked task when others are locked", () => {
     const cwd = makeCwd();
     const lockedTask = createTask(cwd, "implement", "Locked by other");
-    const unlockedTask = createTask(cwd, "debug", "Abandoned");
+    const unlockedTask = createTask(cwd, "review", "Abandoned");
 
     vi.spyOn(lockfile, "checkSync").mockImplementation((path: string, _options?: { stale?: number }) => {
       if (path === join(lockedTask, "state.json")) return true;
@@ -434,7 +435,7 @@ describe("getActiveTaskStatus", () => {
   it("reports ambiguous with all tasks when multiple are unlocked", () => {
     const cwd = makeCwd();
     createTask(cwd, "implement", "First");
-    createTask(cwd, "debug", "Second");
+    createTask(cwd, "review", "Second");
     vi.spyOn(lockfile, "checkSync").mockReturnValue(false);
 
     const status = getActiveTaskStatus(cwd);
@@ -447,7 +448,6 @@ describe("getFirstPhase", () => {
   it("returns expected first phase for each task type", () => {
     expect(getFirstPhase("implement")).toBe("brainstorm");
     expect(getFirstPhase("brainstorm")).toBe("brainstorm");
-    expect(getFirstPhase("debug")).toBe("debug");
     expect(getFirstPhase("review")).toBe("review");
     expect(getFirstPhase("quick")).toBe("quick");
   });

package/extensions/orchestrator/state.ts

@@ -28,14 +28,13 @@ export interface AutonomousConfig {
   phases: Record<string, AutonomousPhaseConfig>;
 }
 
-export type TaskType = "implement" | "debug" | "brainstorm" | "review" | "quick";
+export type TaskType = "implement" | "brainstorm" | "review" | "quick";
 
 export type ImplementPhase = "brainstorm" | "plan" | "implement" | "done";
-export type DebugPhase = "debug" | "plan" | "implement" | "done";
 export type BrainstormPhase = "brainstorm" | "plan" | "implement" | "done";
 export type ReviewPhase = "review" | "plan" | "implement" | "done";
 export type QuickPhase = "quick";
-export type Phase = ImplementPhase | DebugPhase | BrainstormPhase | ReviewPhase | QuickPhase;
+export type Phase = ImplementPhase | BrainstormPhase | ReviewPhase | QuickPhase;
 
 export interface TaskState {
   phase: Phase;
@@ -76,10 +75,24 @@ export interface TaskState {
   // the guided/autonomous transition or the autonomous terminal handoff), so the
   // hooks never run twice for the same completion.
   afterImplementRan?: boolean;
-  // Per-repo interleaved Plannotator review cursor (#3a). repoPaths is the ordered
-  // set of repos to review; index is the next repo. Persisted so the loop resumes
-  // on the next /pp after the agent fixes one repo's feedback. Undefined = no loop.
-  plannotatorCursor?: { repoPaths: string[]; index: number };
+  // State-freshness reconcile markers (see maybePromptReconcile). Absent on legacy
+  // tasks. reconcilePending forces a re-prompt after a pause/complete that could
+  // not reconcile in-line.
+  reconcilePromptedPhase?: string;
+  reconciledPhase?: string;
+  reconcilePending?: boolean;
+  // Per-repo Plannotator review cursor. repoPaths is the ordered set of repos to
+  // review; index is read only by the single-repo path (retained for
+  // backward-compatible deserialization of older cursors). For multi-repo reviews
+  // the user drives repo selection via a status picker; `status` records each
+  // repo's outcome (absent = unreviewed) and `feedback` holds pending
+  // changes-requested feedback not yet applied. Undefined = no active loop.
+  plannotatorCursor?: {
+    repoPaths: string[];
+    index: number;
+    status?: Record<string, "approved" | "changes-requested" | "fixes-applied">;
+    feedback?: Record<string, string>;
+  };
   // The phase the task was in when it was marked done. Recorded so the Resume
   // "reopen a done task" flow (#2) can restore the actual last working phase
   // (done itself carries no phase history). Absent on legacy done tasks.
@@ -102,7 +115,6 @@ function taskStatePath(taskDir: string): string {
 
 export function getFirstPhase(type: TaskType): Exclude<Phase, "done"> {
   if (type === "implement" || type === "brainstorm") return "brainstorm";
-  if (type === "debug") return "debug";
   if (type === "review") return "review";
   return "quick";
 }
@@ -115,7 +127,7 @@ export function getEffectiveMode(state: TaskState): TaskMode | undefined {
 // drives them, so they never inherit the task's autonomous mode even when one is set.
 // plan/implement are autonomous-capable regardless of whether they are the task's initial phase.
 export function getEffectivePhaseMode(state: TaskState): TaskMode {
-  if (state.phase === "brainstorm" || state.phase === "debug" || state.phase === "review") return "guided";
+  if (state.phase === "brainstorm" || state.phase === "review") return "guided";
   return getEffectiveMode(state) ?? "guided";
 }
 
@@ -162,8 +174,19 @@ export function createTask(cwd: string, type: TaskType, description: string, mod
 export function loadTask(taskDir: string): TaskState {
   const sp = taskStatePath(taskDir);
   const raw = readFileSync(sp, "utf-8");
+  let parsed: TaskState;
+  try {
+    parsed = JSON.parse(raw) as TaskState;
+  } catch (err: any) {
+    throw new Error(`Failed to parse ${sp}: ${err.message}`);
+  }
+  if ((parsed as any).phase === "debug") {
+    throw new Error(
+      "Debug tasks are no longer supported; use /pp → Implement → From to reuse their artifacts.",
+    );
+  }
   try {
-    const state = JSON.parse(raw) as TaskState;
+    const state = parsed;
     if ((state as any).phase === "planning") {
       state.phase = "plan";
     }
@@ -203,7 +226,7 @@ export function listTasks(cwd: string, typeOrOptions?: TaskType | ListTasksOptio
   const base = stateDir(cwd);
   if (!existsSync(base)) return [];
 
-  const types: TaskType[] = options.type ? [options.type] : ["implement", "debug", "brainstorm", "review", "quick"];
+  const types: TaskType[] = options.type ? [options.type] : ["implement", "brainstorm", "review", "quick"];
   const results: TaskInfo[] = [];
 
   for (const t of types) {
@@ -343,7 +366,7 @@ function firstMarkdownContent(path: string): string | null {
 export function taskFullName(taskDir: string, state: TaskState): string {
   let desc = state.description ?? "";
 
-  if (["implement", "debug", "brainstorm", "review", "quick"].includes(desc)) {
+  if (["implement", "brainstorm", "review", "quick"].includes(desc)) {
     const fallback =
       firstMarkdownContent(join(taskDir, "USER_REQUEST.md")) ??
       firstMarkdownContent(join(taskDir, "RESEARCH.md")) ??

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ilya-lesikov/pi-pi",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Pi-Pi Coding Agent: based on Pi Coding Agent, but twice as good",
   "keywords": [
     "pi-package",
@@ -33,7 +33,7 @@
     "AGENTS.md"
   ],
   "scripts": {
-    "postinstall": "bash scripts/postinstall.sh",
+    "postinstall": "node scripts/postinstall.mjs",
     "test": "vitest run --exclude '3p/**'",
     "test:watch": "vitest --exclude '3p/**'",
     "test:3p": "bash scripts/test-3p.sh",

package/scripts/postinstall.mjs

@@ -0,0 +1,93 @@
+// Vendor-source decision: on non-Windows we invoke the existing bash `vendor.sh` UNCHANGED so
+// Linux/CI stay byte-for-byte identical; on Windows we SKIP the bash vendor step (a documented
+// Windows limitation) and rely on the npm-pack HTML fallback below. vendor.sh is still the single
+// source used by `npm run build`/CI — this script does not fork its logic.
+import { execFileSync, spawnSync } from "node:child_process";
+import { existsSync, mkdtempSync, rmSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { gunzipSync } from "node:zlib";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(SCRIPT_DIR, "..");
+const PI_EXT_DIR = join(REPO_ROOT, "3p", "pi-plannotator", "apps", "pi-extension");
+const isWindows = process.platform === "win32";
+
+function fail(msg) {
+  console.error(`  ✗ ${msg}`);
+  process.exit(1);
+}
+
+function runVendor() {
+  if (isWindows) {
+    console.log("  ⚠ skipping plannotator vendor step on Windows (bash vendor.sh unavailable)");
+    return;
+  }
+  const res = spawnSync("bash", [join(PI_EXT_DIR, "vendor.sh")], { cwd: REPO_ROOT, stdio: "inherit" });
+  if (res.status !== 0) fail(`vendor.sh failed with exit code ${res.status ?? "unknown"}`);
+}
+
+function htmlPresent() {
+  return existsSync(join(PI_EXT_DIR, "plannotator.html")) && existsSync(join(PI_EXT_DIR, "review-editor.html"));
+}
+
+// Extract a specific file from an npm tarball (gzipped POSIX/ustar tar) using only
+// Node builtins — no external `tar` executable, which is not guaranteed on native
+// Windows. Returns the file's bytes, or null when the entry is absent.
+function extractFromTar(tarBytes, wantPath) {
+  let off = 0;
+  while (off + 512 <= tarBytes.length) {
+    const header = tarBytes.subarray(off, off + 512);
+    const name = header.subarray(0, 100).toString("utf-8").replace(/\0.*$/, "");
+    if (name === "") break;
+    const size = parseInt(header.subarray(124, 136).toString("utf-8").replace(/\0.*$/, "").trim() || "0", 8);
+    const dataStart = off + 512;
+    if (name === wantPath) return tarBytes.subarray(dataStart, dataStart + size);
+    off = dataStart + Math.ceil(size / 512) * 512;
+  }
+  return null;
+}
+
+// Run `npm pack` without depending on PATH/PATHEXT resolution of `npm`, which on
+// Windows is `npm.cmd` and cannot be spawned by execFileSync without a shell
+// (Node rejects .cmd without shell:true). In a lifecycle script npm exports
+// npm_execpath (the CLI's JS entry); run it with the current node. Fall back to a
+// shell-resolved `npm`/`npm.cmd` only if that env var is somehow absent.
+function runNpmPack(destDir) {
+  const npmCli = process.env.npm_execpath;
+  if (npmCli) {
+    execFileSync(process.execPath, [npmCli, "pack", "@plannotator/pi-extension", "--pack-destination", destDir, "--silent"], {
+      stdio: ["ignore", "ignore", "ignore"],
+    });
+    return;
+  }
+  const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+  execFileSync(npmCmd, ["pack", "@plannotator/pi-extension", "--pack-destination", destDir, "--silent"], {
+    stdio: ["ignore", "ignore", "ignore"],
+    shell: true,
+  });
+}
+
+function extractHtmlFallback() {
+  const tmp = mkdtempSync(join(tmpdir(), "pi-pi-plannotator-"));
+  try {
+    runNpmPack(tmp);
+    const tgz = readdirSync(tmp).find((name) => name.endsWith(".tgz"));
+    if (!tgz) fail("npm pack produced no tarball for @plannotator/pi-extension");
+    const tarBytes = gunzipSync(readFileSync(join(tmp, tgz)));
+    for (const file of ["plannotator.html", "review-editor.html"]) {
+      const bytes = extractFromTar(tarBytes, `package/${file}`);
+      if (!bytes) fail(`@plannotator/pi-extension tarball is missing ${file}`);
+      writeFileSync(join(PI_EXT_DIR, file), bytes);
+    }
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+runVendor();
+
+if (htmlPresent()) process.exit(0);
+
+extractHtmlFallback();

package/scripts/postinstall.sh

@@ -1,18 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-cd "$(dirname "$0")/.."
-
-bash 3p/pi-plannotator/apps/pi-extension/vendor.sh
-
-PI_EXT_DIR="3p/pi-plannotator/apps/pi-extension"
-if [ -f "$PI_EXT_DIR/plannotator.html" ] && [ -f "$PI_EXT_DIR/review-editor.html" ]; then
-  exit 0
-fi
-
-TMPDIR=$(mktemp -d)
-trap 'rm -rf "$TMPDIR"' EXIT
-
-npm pack @plannotator/pi-extension --pack-destination "$TMPDIR" --silent 2>/dev/null
-tar -xzf "$TMPDIR"/*.tgz -C "$TMPDIR"
-cp "$TMPDIR/package/plannotator.html" "$PI_EXT_DIR/plannotator.html"
-cp "$TMPDIR/package/review-editor.html" "$PI_EXT_DIR/review-editor.html"