@ilya-lesikov/pi-pi 0.7.0 → 0.8.0

package/extensions/orchestrator/integration.test.ts

@@ -70,6 +70,9 @@ vi.mock("./config.js", async (importOriginal) => {
           explore: { model: "test/explore", thinking: "low" },
           librarian: { model: "test/librarian", thinking: "medium" },
           task: { model: "test/task", thinking: "medium" },
+          advisor: { model: "test/advisor", thinking: "high" },
+          "deep-debugger": { model: "test/deep-debugger", thinking: "high" },
+          reviewer: { model: "test/reviewer", thinking: "high" },
         },
         presetGroups: {
           planners: {
@@ -223,6 +226,9 @@ function makeConfig() {
           explore: { model: "test/explore", thinking: "low" },
           librarian: { model: "test/librarian", thinking: "medium" },
           task: { model: "test/task", thinking: "medium" },
+          advisor: { model: "test/advisor", thinking: "high" },
+          "deep-debugger": { model: "test/deep-debugger", thinking: "high" },
+          reviewer: { model: "test/reviewer", thinking: "high" },
         },
         presetGroups: {
           planners: {
@@ -672,7 +678,7 @@ describe("review cycle lifecycle", () => {
     await new Promise((r) => setTimeout(r, 10));
 
     expectReviewAuto(menu);
-    expectReviewOnMyOwn(menu);
+    expectReviewOnMyOwn(menu, "Skip markers");
     const result = await ppPhaseComplete.execute("call-3", { summary: "implemented" }, undefined, undefined, ctx);
 
     expect(result.content[0].text).toContain("continue");
@@ -1355,7 +1361,7 @@ describe("edge cases and regressions", () => {
     await ppPhaseComplete.execute("call-2", { summary: "plan done" }, undefined, undefined, ctx);
     await new Promise((r) => setTimeout(r, 10));
 
-    expectReviewOnMyOwn(menu);
+    expectReviewOnMyOwn(menu, "Skip markers");
     const result = await ppPhaseComplete.execute("call-3", { summary: "partial work" }, undefined, undefined, ctx);
 
     expect(result.content[0].text).toContain("continue");
@@ -1402,6 +1408,47 @@ describe("edge cases and regressions", () => {
     expect(orchestrator.active!.state.step).toBe("synthesize");
   });
 
+  it("editor-review Done returns AI_REVIEW marker instructions in implement phase", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "Editor review test");
+    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",
+    );
+    expectPlanToImplement(menu);
+    await ppPhaseComplete.execute("call-2", { summary: "plan done" }, undefined, undefined, ctx);
+    await new Promise((r) => setTimeout(r, 10));
+
+    expectReviewOnMyOwn(menu, "Done");
+    const result = await ppPhaseComplete.execute("call-3", { summary: "implemented" }, undefined, undefined, ctx);
+
+    expect(result.content[0].text).toContain("AI_REVIEW:");
+    expect(result.content[0].text).toContain("CHANGED files");
+    expect(orchestrator.active!.state.phase).toBe("implement");
+    expect(orchestrator.active!.state.step).toBe("llm_work");
+  });
+
   it("generic description task does not auto-trigger agent", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -2079,7 +2126,7 @@ describe("task modes and quick task", () => {
     expect(prompt).toContain("<principles>");
     expect(prompt).toContain("<tools>");
     expect(prompt).toContain("<task>");
-    expect(prompt).toContain("let the user review and advance it via the /pp menu");
+    expect(prompt).toContain("call pp_phase_complete");
     expect(prompt).not.toContain("HARNESS_BASE_PROMPT");
     expect(prompt).toContain(`Working directory: ${cwd}.`);
     expect(prompt).toMatch(/Current month: \d{4}-\d{2}\./);
@@ -3240,7 +3287,11 @@ describe("tool blocking", () => {
 });
 
 describe("error retry", () => {
-  it("turn_end with error retries with exponential backoff", async () => {
+  // Non-SDK-retryable error messages exercise pi-pi's OWN retry path. SDK-
+  // retryable errors (rate limit, overloaded, 5xx, stream-ended, timeout, etc.)
+  // are now deferred to the SDK's own auto-retry (see the defer test below), so
+  // these use a message the SDK does NOT retry.
+  it("turn_end with a non-SDK-retryable error uses pi-pi's idle-gated retry", async () => {
     vi.useFakeTimers();
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -3249,7 +3300,7 @@ describe("error retry", () => {
     await orchestrator.startTask(ctx as any, "implement", "retry test");
     const turnEnd = pi._handlers.get("turn_end")!;
 
-    await turnEnd({ message: { stopReason: "error", errorMessage: "rate limited", content: [] } }, ctx);
+    await turnEnd({ message: { stopReason: "error", errorMessage: "invalid tool arguments", content: [] } }, ctx);
 
     expect(orchestrator.errorRetryCount).toBe(1);
     expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("Retrying in 2s"), "warning");
@@ -3259,7 +3310,24 @@ describe("error retry", () => {
     vi.useRealTimers();
   });
 
-  it("turn_end stops retrying after max retries", async () => {
+  it("turn_end defers SDK-retryable errors to the SDK (no pi-pi retry)", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "sdk defer test");
+    const turnEnd = pi._handlers.get("turn_end")!;
+
+    // "stream ended before message_stop" is SDK-retryable — pi-pi must NOT run
+    // its own retry (which would race the SDK's continue()).
+    await turnEnd({ message: { stopReason: "error", errorMessage: "Anthropic stream ended before message_stop", content: [] } }, ctx);
+
+    expect(orchestrator.errorRetryCount).toBe(0);
+    expect(orchestrator.pendingRetryTimer).toBeNull();
+    expect(ctx.ui.notify).not.toHaveBeenCalledWith(expect.stringContaining("Retrying in"), "warning");
+  });
+
+  it("turn_end stops retrying after max retries (non-SDK-retryable)", async () => {
     vi.useFakeTimers();
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
@@ -3269,27 +3337,54 @@ describe("error retry", () => {
     const turnEnd = pi._handlers.get("turn_end")!;
 
     for (let i = 0; i < 6; i++) {
-      await turnEnd({ message: { stopReason: "error", errorMessage: "api down", content: [] } }, ctx);
+      await turnEnd({ message: { stopReason: "error", errorMessage: "invalid tool arguments", content: [] } }, ctx);
     }
 
-    expect(orchestrator.errorRetryCount).toBe(0);
     expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("Stopping auto-retry"), "error");
+    expect(orchestrator.errorNudgeHalted).toBe(true);
+
+    // Once halted, further error turns must NOT arm another retry (this is the
+    // guard against the unbounded-nudge bug).
+    ctx.ui.notify.mockClear();
+    await turnEnd({ message: { stopReason: "error", errorMessage: "invalid tool arguments", content: [] } }, ctx);
+    expect(ctx.ui.notify).not.toHaveBeenCalledWith(expect.stringContaining("Retrying in"), "warning");
     vi.useRealTimers();
   });
 
-  it("successful turn resets error count", async () => {
+  it("a benign turn does NOT reset the error count (cap must accumulate)", async () => {
     const cwd = makeTempDir();
     const { pi, orchestrator } = await setupOrchestrator(cwd);
     const ctx = makeCtx();
 
-    await orchestrator.startTask(ctx as any, "implement", "retry reset test");
+    await orchestrator.startTask(ctx as any, "implement", "retry no-reset test");
     const turnEnd = pi._handlers.get("turn_end")!;
 
-    await turnEnd({ message: { stopReason: "error", errorMessage: "once", content: [] } }, ctx);
+    await turnEnd({ message: { stopReason: "error", errorMessage: "invalid tool arguments", content: [] } }, ctx);
     expect(orchestrator.errorRetryCount).toBe(1);
 
+    // A benign (non-error) turn must NOT zero the counter — otherwise a harmless
+    // nudge-induced reply would defeat the cap and allow unbounded error nudges.
     await turnEnd({ message: { stopReason: "stop", content: [] } }, ctx);
-    expect(orchestrator.errorRetryCount).toBe(0);
+    expect(orchestrator.errorRetryCount).toBe(1);
+  });
+
+  it("genuine user re-engagement resets the error count and halt", async () => {
+    const cwd = makeTempDir();
+    const { pi, orchestrator } = await setupOrchestrator(cwd);
+    const ctx = makeCtx();
+
+    await orchestrator.startTask(ctx as any, "implement", "retry reengage test");
+    const turnEnd = pi._handlers.get("turn_end")!;
+
+    await turnEnd({ message: { stopReason: "error", errorMessage: "invalid tool arguments", content: [] } }, ctx);
+    orchestrator.errorNudgeHalted = true;
+
+    const beforeStart = pi._handlers.get("before_agent_start");
+    if (beforeStart) {
+      await beforeStart({ prompt: "user typed something new" }, ctx);
+      expect(orchestrator.errorRetryCount).toBe(0);
+      expect(orchestrator.errorNudgeHalted).toBe(false);
+    }
   });
 
   it("empty turn triggers continuation nudge", async () => {

package/extensions/orchestrator/messages.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { advanceBanner } from "./messages.js";
+
+describe("advanceBanner", () => {
+  it("starts with [PI-PI] so the controller-injection guard still matches", () => {
+    const out = advanceBanner("[PI-PI] User wants to continue. Run /pp when ready to advance.");
+    expect(out.startsWith("[PI-PI]")).toBe(true);
+  });
+
+  it("renders separators around the content for visual distinctness", () => {
+    const out = advanceBanner("[PI-PI] hello");
+    const lines = out.split("\n");
+    expect(lines[0]).toBe("[PI-PI]");
+    expect(lines[1]).toMatch(/^─+$/);
+    expect(lines[2]).toBe("hello");
+    expect(lines[3]).toMatch(/^─+$/);
+  });
+
+  it("does not double up the [PI-PI] prefix when the body already has one", () => {
+    const out = advanceBanner("[PI-PI] hello");
+    expect(out.match(/\[PI-PI\]/g)?.length).toBe(1);
+    expect(out).not.toContain("[PI-PI] [PI-PI]");
+  });
+
+  it("adds the prefix when the body lacks one", () => {
+    const out = advanceBanner("plain body");
+    expect(out.startsWith("[PI-PI]")).toBe(true);
+    expect(out).toContain("plain body");
+  });
+});

package/extensions/orchestrator/messages.ts

@@ -0,0 +1,6 @@
+const BANNER_SEPARATOR = "─".repeat(48);
+
+export function advanceBanner(body: string): string {
+  const content = body.startsWith("[PI-PI]") ? body.slice("[PI-PI]".length).trimStart() : body;
+  return `[PI-PI]\n${BANNER_SEPARATOR}\n${content}\n${BANNER_SEPARATOR}`;
+}

package/extensions/orchestrator/model-registry.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 vi.mock("./log.js", () => ({
   getLogger: () => ({
@@ -11,7 +11,10 @@ import {
   getAllAliases,
   getModelFamilies,
   getModelInfo,
+  isSubscriptionFallbackActive,
   resolveModel,
+  setSubscriptionFallbackActive,
+  toNonSubSpec,
   updateRegistryFromAvailableModels,
 } from "./model-registry.js";
 
@@ -299,4 +302,48 @@ describe("model-registry", () => {
       expect(findLatestFamilyMatch("anthropic/claude-opus-latest", [])).toBeNull();
     });
   });
+
+  describe("subscription fallback rewrite", () => {
+    beforeEach(() => setSubscriptionFallbackActive(false));
+    afterEach(() => setSubscriptionFallbackActive(false));
+
+    it("toNonSubSpec rewrites provider-prefixed sub specs", () => {
+      expect(toNonSubSpec("pp-flant-anthropic-sub/sub/claude-opus-4-8")).toBe("pp-flant-anthropic/claude-opus-4-8");
+    });
+
+    it("toNonSubSpec rewrites bare sub/ ids", () => {
+      expect(toNonSubSpec("sub/claude-haiku-4-5")).toBe("pp-flant-anthropic/claude-haiku-4-5");
+    });
+
+    it("toNonSubSpec leaves non-subscription specs unchanged", () => {
+      expect(toNonSubSpec("pp-flant-anthropic/claude-opus-4-8")).toBe("pp-flant-anthropic/claude-opus-4-8");
+      expect(toNonSubSpec("openai/gpt-5.4")).toBe("openai/gpt-5.4");
+    });
+
+    it("resolveModel leaves sub specs unchanged while fallback inactive", () => {
+      expect(isSubscriptionFallbackActive()).toBe(false);
+      expect(resolveModel("pp-flant-anthropic-sub/sub/claude-opus-4-8")).toBe("pp-flant-anthropic-sub/sub/claude-opus-4-8");
+    });
+
+    it("resolveModel rewrites sub specs to non-sub while fallback active", () => {
+      setSubscriptionFallbackActive(true);
+      expect(isSubscriptionFallbackActive()).toBe(true);
+      expect(resolveModel("pp-flant-anthropic-sub/sub/claude-opus-4-8")).toBe("pp-flant-anthropic/claude-opus-4-8");
+      expect(resolveModel("sub/claude-haiku-4-5")).toBe("pp-flant-anthropic/claude-haiku-4-5");
+    });
+
+    it("resolveModel does not touch non-sub specs while fallback active", () => {
+      setSubscriptionFallbackActive(true);
+      expect(resolveModel("pp-flant-openai/gpt-5-4")).toBe("pp-flant-openai/gpt-5-4");
+    });
+
+    it("resolveModel rewrites a subscription alias after registry update while fallback active", () => {
+      updateRegistryFromAvailableModels([
+        "pp-flant-anthropic-sub/sub/claude-opus-4-7",
+        "pp-flant-anthropic-sub/sub/claude-opus-4-8",
+      ]);
+      setSubscriptionFallbackActive(true);
+      expect(resolveModel("pp-flant-anthropic-sub/claude-opus-latest")).toBe("pp-flant-anthropic/claude-opus-4-8");
+    });
+  });
 });

package/extensions/orchestrator/model-registry.ts

@@ -207,12 +207,54 @@ function findFamily(modelId: string): ModelFamilyDefinition | null {
 }
 
 import { getLogger } from "./log.js";
+import { SUB_MODEL_PREFIX, SUB_PROVIDER } from "./flant-infra.js";
+
+// Session-scoped subscription fallback. When active (set after the user accepts
+// a sub-429 fallback), every model spec resolved through resolveModel that is
+// subscription-routed (`pp-flant-anthropic-sub/sub/<m>` or a bare `sub/<m>`) is
+// rewritten to the regular per-token form `pp-flant-anthropic/<m>`. This is the
+// single lever every resolution site funnels through (main phase switchModel,
+// subagent tool_call input.model, planner/reviewer specs, registerAgents), so a
+// one-shot switch cannot be undone by a later phase/subagent re-resolving a
+// `sub/` spec. Cleared when the user switches back or the task ends.
+let subscriptionFallbackActive = false;
+
+export function setSubscriptionFallbackActive(active: boolean): void {
+  subscriptionFallbackActive = active;
+}
+
+export function isSubscriptionFallbackActive(): boolean {
+  return subscriptionFallbackActive;
+}
+
+// Rewrite a subscription-routed spec to its regular per-token equivalent.
+// Handles both `pp-flant-anthropic-sub/sub/<m>` and a bare `sub/<m>` id.
+// Non-subscription specs pass through unchanged.
+export function toNonSubSpec(spec: string): string {
+  if (spec.startsWith(`${SUB_PROVIDER}/${SUB_MODEL_PREFIX}`)) {
+    return `pp-flant-anthropic/${spec.slice(`${SUB_PROVIDER}/${SUB_MODEL_PREFIX}`.length)}`;
+  }
+  if (spec.startsWith(`${SUB_PROVIDER}/`)) {
+    return `pp-flant-anthropic/${spec.slice(`${SUB_PROVIDER}/`.length)}`;
+  }
+  if (spec.startsWith(SUB_MODEL_PREFIX)) {
+    return `pp-flant-anthropic/${spec.slice(SUB_MODEL_PREFIX.length)}`;
+  }
+  return spec;
+}
 
 export function resolveModel(aliasOrId: string): string {
-  const resolved = aliasMap[aliasOrId] ?? aliasOrId;
+  let resolved = aliasMap[aliasOrId] ?? aliasOrId;
   if (resolved !== aliasOrId) {
     getLogger().debug({ s: "model", alias: aliasOrId, resolved }, "resolved model alias");
   }
+  if (subscriptionFallbackActive) {
+    const rewritten = toNonSubSpec(resolved);
+    if (rewritten !== resolved) {
+      getLogger().debug({ s: "model", from: resolved, to: rewritten }, "subscription fallback rewrite");
+      resolved = rewritten;
+    }
+  }
   return resolved;
 }
 

package/extensions/orchestrator/orchestrator.test.ts

@@ -123,6 +123,119 @@ describe("Orchestrator.safeSendUserMessage", () => {
   });
 });
 
+describe("Orchestrator.cancelPendingRetry", () => {
+  it("clears the pending timer, disarms the ESC interrupt, and resets the counter", () => {
+    vi.useFakeTimers();
+    const send = vi.fn();
+    const orchestrator = new Orchestrator(makePi({ sendUserMessage: send }));
+    const unsub = vi.fn();
+    orchestrator.errorRetryCount = 3;
+    orchestrator.pendingRetryEscUnsub = unsub;
+    orchestrator.pendingRetryTimer = setTimeout(() => send("fired"), 1000) as any;
+
+    orchestrator.cancelPendingRetry();
+
+    expect(orchestrator.pendingRetryTimer).toBeNull();
+    expect(orchestrator.pendingRetryEscUnsub).toBeNull();
+    expect(orchestrator.errorRetryCount).toBe(0);
+    expect(unsub).toHaveBeenCalledTimes(1);
+    vi.advanceTimersByTime(2000);
+    expect(send).not.toHaveBeenCalled();
+    vi.useRealTimers();
+  });
+});
+
+describe("Orchestrator.armRetryEscInterrupt", () => {
+  function makeCtxWithTerminal() {
+    let handler: ((data: string) => any) | null = null;
+    const notify = vi.fn();
+    const ctx = {
+      ui: {
+        notify,
+        onTerminalInput: (h: (data: string) => any) => {
+          handler = h;
+          return () => { handler = null; };
+        },
+      },
+    };
+    return { ctx, notify, feed: (data: string) => handler?.(data) };
+  }
+
+  it("cancels the pending retry on a bare ESC only", () => {
+    vi.useFakeTimers();
+    const orchestrator = new Orchestrator(makePi());
+    const { ctx, notify, feed } = makeCtxWithTerminal();
+    orchestrator.pendingRetryTimer = setTimeout(() => {}, 10000) as any;
+    orchestrator.armRetryEscInterrupt(ctx as any);
+
+    // Arrow key (ESC-prefixed sequence) must NOT cancel and must NOT be consumed.
+    const arrow = feed("\x1b[A");
+    expect(arrow).toBeUndefined();
+    expect(orchestrator.pendingRetryTimer).not.toBeNull();
+
+    // Bare ESC cancels and consumes.
+    const esc = feed("\x1b");
+    expect(esc).toEqual({ consume: true });
+    expect(orchestrator.pendingRetryTimer).toBeNull();
+    expect(notify).toHaveBeenCalled();
+    vi.useRealTimers();
+  });
+
+  it("is a no-op when no retry timer is armed", () => {
+    const orchestrator = new Orchestrator(makePi());
+    const { ctx, feed } = makeCtxWithTerminal();
+    orchestrator.armRetryEscInterrupt(ctx as any);
+    expect(feed("\x1b")).toBeUndefined();
+  });
+});
+
+describe("Orchestrator.sendUserMessageWhenIdle", () => {
+  it("sends immediately when idle", () => {
+    const send = vi.fn();
+    const orchestrator = new Orchestrator(makePi({ sendUserMessage: send }));
+    orchestrator.active = makeActiveTask(null);
+    orchestrator.activeTaskToken = 7;
+    orchestrator.lastCtx = { isIdle: () => true };
+
+    orchestrator.sendUserMessageWhenIdle("[PI-PI] go", 7);
+    expect(send).toHaveBeenCalledWith("[PI-PI] go", { deliverAs: "followUp" });
+  });
+
+  it("defers while busy, then sends once idle", async () => {
+    vi.useFakeTimers();
+    const send = vi.fn();
+    const orchestrator = new Orchestrator(makePi({ sendUserMessage: send }));
+    orchestrator.active = makeActiveTask(null);
+    orchestrator.activeTaskToken = 1;
+    let idle = false;
+    orchestrator.lastCtx = { isIdle: () => idle };
+
+    orchestrator.sendUserMessageWhenIdle("[PI-PI] go", 1);
+    expect(send).not.toHaveBeenCalled();
+    await vi.advanceTimersByTimeAsync(3000);
+    expect(send).not.toHaveBeenCalled();
+    idle = true;
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(send).toHaveBeenCalledWith("[PI-PI] go", { deliverAs: "followUp" });
+    vi.useRealTimers();
+  });
+
+  it("drops (does not send) when the task token changes", async () => {
+    vi.useFakeTimers();
+    const send = vi.fn();
+    const orchestrator = new Orchestrator(makePi({ sendUserMessage: send }));
+    orchestrator.active = makeActiveTask(null);
+    orchestrator.activeTaskToken = 1;
+    orchestrator.lastCtx = { isIdle: () => false };
+
+    orchestrator.sendUserMessageWhenIdle("[PI-PI] go", 1);
+    orchestrator.activeTaskToken = 2; // task switched
+    await vi.advanceTimersByTimeAsync(2000);
+    expect(send).not.toHaveBeenCalled();
+    vi.useRealTimers();
+  });
+});
+
 describe("Orchestrator.switchModel thinking level", () => {
   function makeCtx() {
     return {