@ilya-lesikov/pi-pi 0.7.0 → 0.9.0

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

@@ -0,0 +1,243 @@
+import type { Orchestrator } from "./orchestrator.js";
+import { getLogger } from "./log.js";
+import { isSubscriptionRouted } from "./usage-tracker.js";
+import { setSubscriptionFallbackActive, toNonSubSpec } from "./model-registry.js";
+import { loadFlantSettings, probeSubscriptionCleared } from "./flant-infra.js";
+import { askUser, isCancel } from "../../3p/pi-ask-user/index.js";
+
+// Recognise a rate-limit / 429 error from a turn's or subagent's error message.
+export function isRateLimitError(message?: string): boolean {
+  if (typeof message !== "string") return false;
+  return /\b429\b|rate.?limit|too many requests|exceed your account/i.test(message);
+}
+
+// Mirror of the SDK's AgentSession._isRetryableError classifier
+// (agent-session.js: overloaded/rate-limit/5xx/network/stream-ended/timeout/...).
+// When true, the SDK auto-retries the SAME turn itself (abortable backoff bound
+// to ESC, visible countdown). pi-pi must NOT ALSO schedule its own post-error
+// retry for these: a second, independent retry races the SDK's continue() and
+// reproduces "Agent is already processing", and re-nudges a futile sub-429. This
+// list is kept in sync with the SDK regex; if they drift, pi-pi at worst falls
+// back to its own idle-gated retry (still safe, just not unified).
+export function isSdkRetryableError(message?: string): boolean {
+  if (typeof message !== "string" || !message) return false;
+  return /overloaded|provider.?returned.?error|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|network.?error|connection.?error|connection.?refused|connection.?lost|websocket.?closed|websocket.?error|other side closed|fetch failed|upstream.?connect|reset before headers|socket hang up|ended without|stream ended before message_stop|http2 request did not get a response|timed? out|timeout|terminated|retry delay/i.test(
+    message,
+  );
+}
+
+const SWITCH_DIALOG_CONTEXT =
+  "Switching between the personal subscription and regular flant Claude changes the provider/endpoint, " +
+  "so the prompt cache is LOST and the full conversation context is re-sent on the next call. " +
+  "Regular (non-subscription) flant Claude is billed PER TOKEN (paid).";
+
+// Handle a subscription-routed 429 on the MAIN turn. Stops futile retries on the
+// still-limited sub model, then (once, session-sticky) asks the user whether to
+// fall back to non-sub Claude. On confirm: activates the session-scoped override,
+// switches the active model, arms the switch-back probe, and nudges to continue.
+export async function handleMainRateLimit(
+  orchestrator: Orchestrator,
+  ctx: any,
+  modelId: string | undefined,
+  provider: string | undefined,
+): Promise<void> {
+  const log = getLogger();
+  if (!isSubscriptionRouted(modelId, provider)) return;
+
+  // Stop the futile same-model retry (SDK backoff + pi-pi's own timer): retrying
+  // the sub model against an account-level limit cannot succeed.
+  ctx?.abort?.();
+  orchestrator.cancelPendingRetry();
+
+  if (orchestrator.subFallbackActive) return; // sticky — already on non-sub
+  await offerFallback(orchestrator, ctx, modelId ?? orchestrator.subFallbackModelId ?? "", "main");
+}
+
+// Handle a subscription-routed 429 reported via subagents:failed. Uses ONE
+// global dialogue (never per-subagent) — the same offerFallback path as the
+// main turn, guarded so only one dialogue is open at a time.
+export async function handleSubagentRateLimit(
+  orchestrator: Orchestrator,
+  ctx: any,
+  modelId: string | undefined,
+): Promise<void> {
+  if (!isSubscriptionRouted(modelId)) return;
+  if (orchestrator.subFallbackActive) return; // sticky
+  await offerFallback(orchestrator, ctx, modelId ?? "", "subagent");
+}
+
+async function offerFallback(
+  orchestrator: Orchestrator,
+  ctx: any,
+  subModelId: string,
+  origin: "main" | "subagent",
+): Promise<void> {
+  const log = getLogger();
+  if (orchestrator.subFallbackDialogPending) return;
+  if (!ctx?.hasUI) {
+    // No UI to ask — leave sub routing in place; the error is surfaced elsewhere.
+    log.debug({ s: "ratelimit" }, "no UI available to offer subscription fallback");
+    return;
+  }
+  orchestrator.subFallbackDialogPending = true;
+  const taskToken = orchestrator.activeTaskToken;
+  try {
+    const result = await askUser(ctx, {
+      question: "Personal Claude subscription is rate-limited. Switch to regular (paid) flant Claude?",
+      context: SWITCH_DIALOG_CONTEXT,
+      options: [
+        { title: "Switch to non-sub Claude", description: "Continue on regular flant Claude (paid per token) until you switch back." },
+        { title: "Stay on subscription", description: "Do not switch. Work stays paused until the limit clears." },
+      ],
+      allowFreeform: false,
+      allowComment: false,
+      allowMultiple: false,
+    });
+    if (orchestrator.activeTaskToken !== taskToken || !orchestrator.active) return;
+    const chose = result && !isCancel(result) && result.kind === "selection" ? result.selections[0] : undefined;
+    if (chose !== "Switch to non-sub Claude") {
+      ctx.ui?.notify?.("Staying on subscription. Auto-continuation paused until you resume or the limit clears.", "info");
+      return;
+    }
+    await activateFallback(orchestrator, ctx, subModelId, origin);
+  } finally {
+    orchestrator.subFallbackDialogPending = false;
+    orchestrator.subFallbackPendingDecision = false;
+  }
+}
+
+async function activateFallback(
+  orchestrator: Orchestrator,
+  ctx: any,
+  subModelId: string,
+  origin: "main" | "subagent",
+): Promise<void> {
+  const log = getLogger();
+  orchestrator.subFallbackActive = true;
+  orchestrator.subFallbackModelId = subModelId || orchestrator.subFallbackModelId;
+  // Activate the session-scoped override so EVERY future model resolution
+  // (phase switches, new subagents, planner/reviewer specs) rewrites sub→non-sub.
+  // This is what actually re-routes future subagent spawns, regardless of origin.
+  setSubscriptionFallbackActive(true);
+
+  // Switch the CURRENT main model to the non-sub equivalent ONLY when the 429 was
+  // on the main turn. For a SUBAGENT 429 the failing model is the subagent's, not
+  // the main session's — switching the main model here would change the active
+  // orchestrator model the user never touched (e.g. debug's GPT -> Claude). The
+  // session override above already re-routes the retried/next subagent.
+  if (origin === "main" && subModelId) {
+    const nonSub = toNonSubSpec(subModelId);
+    const ok = await orchestrator.switchModel(ctx, nonSub, currentThinking(orchestrator));
+    if (!ok) log.warn({ s: "ratelimit", nonSub }, "failed to switch main model to non-sub");
+  }
+
+  ctx.ui?.notify?.("Switched to regular flant Claude (paid per token). Will periodically check if the subscription limit has cleared.", "info");
+
+  armSwitchBackProbe(orchestrator);
+
+  // Nudge to continue — retries were cancelled, so the turn is stopped. Idle-gated
+  // (same guard as the post-error nudge) so it never races the SDK into an
+  // "Agent is already processing" error.
+  const phase = orchestrator.active?.state.phase ?? "current";
+  orchestrator.sendUserMessageWhenIdle(
+    `[PI-PI] Switched to regular (non-subscription) flant Claude after a rate limit. Continue working on the current phase (${phase}).`,
+    orchestrator.activeTaskToken,
+  );
+}
+
+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";
+  return orchestrators?.[key]?.thinking ?? "high";
+}
+
+// Arm the fixed-interval switch-back probe. On each interval an out-of-band probe
+// checks whether the sub limit cleared; a 429/failure silently re-arms, a success
+// opens the switch-back dialogue. Only one timer runs at a time.
+export function armSwitchBackProbe(orchestrator: Orchestrator): void {
+  if (orchestrator.subSwitchBackTimer) clearTimeout(orchestrator.subSwitchBackTimer);
+  const minutes = Math.max(1, loadFlantSettings().switchBackIntervalMinutes || 30);
+  const taskToken = orchestrator.activeTaskToken;
+  orchestrator.subSwitchBackTimer = setTimeout(() => {
+    orchestrator.subSwitchBackTimer = null;
+    void runSwitchBackProbe(orchestrator, taskToken);
+  }, minutes * 60 * 1000);
+}
+
+async function runSwitchBackProbe(orchestrator: Orchestrator, taskToken: number): Promise<void> {
+  const log = getLogger();
+  if (orchestrator.activeTaskToken !== taskToken || !orchestrator.active || !orchestrator.subFallbackActive) {
+    return;
+  }
+  const modelId = orchestrator.subFallbackModelId;
+  if (!modelId) {
+    armSwitchBackProbe(orchestrator);
+    return;
+  }
+  const outcome = await probeSubscriptionCleared(modelId);
+  if (orchestrator.activeTaskToken !== taskToken || !orchestrator.active || !orchestrator.subFallbackActive) {
+    return;
+  }
+  if (outcome !== "ok") {
+    // Still limited (or transient error) — stay on non-sub, silently re-arm.
+    log.debug({ s: "ratelimit", outcome }, "switch-back probe: not cleared, re-arming");
+    armSwitchBackProbe(orchestrator);
+    return;
+  }
+  await offerSwitchBack(orchestrator, modelId);
+}
+
+async function offerSwitchBack(orchestrator: Orchestrator, subModelId: string): Promise<void> {
+  const log = getLogger();
+  const ctx = orchestrator.lastCtx;
+  if (orchestrator.subFallbackDialogPending || !ctx?.hasUI) {
+    armSwitchBackProbe(orchestrator);
+    return;
+  }
+  orchestrator.subFallbackDialogPending = true;
+  const taskToken = orchestrator.activeTaskToken;
+  try {
+    const result = await askUser(ctx, {
+      question: "Your Claude subscription limit appears to have cleared. Switch back to the subscription?",
+      context: SWITCH_DIALOG_CONTEXT,
+      options: [
+        { title: "Switch back to subscription", description: "Resume on the personal Claude subscription (flat-rate)." },
+        { title: "Stay on non-sub Claude", description: "Keep using regular flant Claude; check again later." },
+      ],
+      allowFreeform: false,
+      allowComment: false,
+      allowMultiple: false,
+    });
+    if (orchestrator.activeTaskToken !== taskToken || !orchestrator.active) return;
+    const chose = result && !isCancel(result) && result.kind === "selection" ? result.selections[0] : undefined;
+    if (chose !== "Switch back to subscription") {
+      // Stay on non-sub; re-arm so we check again after the interval.
+      armSwitchBackProbe(orchestrator);
+      return;
+    }
+    await switchBackToSub(orchestrator, ctx, subModelId);
+  } finally {
+    orchestrator.subFallbackDialogPending = false;
+  }
+}
+
+async function switchBackToSub(orchestrator: Orchestrator, ctx: any, subModelId: string): Promise<void> {
+  const log = getLogger();
+  // Clear the override FIRST so switchModel resolves the sub spec unrewritten.
+  orchestrator.subFallbackActive = false;
+  setSubscriptionFallbackActive(false);
+  if (orchestrator.subSwitchBackTimer) {
+    clearTimeout(orchestrator.subSwitchBackTimer);
+    orchestrator.subSwitchBackTimer = null;
+  }
+  const ok = await orchestrator.switchModel(ctx, subModelId, currentThinking(orchestrator));
+  if (!ok) log.warn({ s: "ratelimit", subModelId }, "failed to switch back to sub model");
+  orchestrator.subFallbackModelId = null;
+  ctx.ui?.notify?.("Switched back to the personal Claude subscription.", "info");
+  const phase = orchestrator.active?.state.phase ?? "current";
+  orchestrator.sendUserMessageWhenIdle(
+    `[PI-PI] Switched back to the personal Claude subscription. Continue working on the current phase (${phase}).`,
+    orchestrator.activeTaskToken,
+  );
+}

package/extensions/orchestrator/state.test.ts

@@ -5,6 +5,7 @@ import { afterEach, describe, expect, it, vi } from "vitest";
 import lockfile from "proper-lockfile";
 import {
   createTask,
+  formatModeIndicator,
   getActiveTask,
   getEffectiveMode,
   getFirstPhase,
@@ -410,4 +411,12 @@ describe("getEffectiveMode", () => {
 
     expect(getEffectiveMode(state)).toBeUndefined();
   });
+
+  it("formatModeIndicator: autonomous stays autonomous, quick shows nothing, else guided (#4)", () => {
+    expect(formatModeIndicator({ ...baseState(), mode: "autonomous" }, "implement")).toBe("autonomous");
+    expect(formatModeIndicator({ ...baseState(), effectiveMode: "autonomous" }, "implement")).toBe("autonomous");
+    expect(formatModeIndicator({ ...baseState(), mode: "guided" }, "implement")).toBe("guided");
+    expect(formatModeIndicator({ ...baseState() }, "implement")).toBe("guided");
+    expect(formatModeIndicator({ ...baseState(), mode: "autonomous" }, "quick")).toBeUndefined();
+  });
 });

package/extensions/orchestrator/state.ts

@@ -58,6 +58,14 @@ export interface TaskState {
   autonomousConfig?: AutonomousConfig;
   plannerFailureAutoRetried?: boolean;
   reviewerFailureAutoRetried?: boolean;
+  // Set once afterImplement has run for the current implement phase (either at
+  // 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 };
 }
 
 export interface TaskInfo {
@@ -93,6 +101,13 @@ export function getEffectivePhaseMode(state: TaskState): TaskMode {
   return getEffectiveMode(state) ?? "guided";
 }
 
+// Display-only: reflects the task's chosen mode regardless of per-phase interactivity.
+// Returns undefined for quick tasks so the footer omits the mode segment entirely.
+export function formatModeIndicator(state: TaskState, type: TaskType): TaskMode | undefined {
+  if (type === "quick") return undefined;
+  return getEffectiveMode(state) === "autonomous" ? "autonomous" : "guided";
+}
+
 export function createTask(cwd: string, type: TaskType, description: string, mode?: TaskMode): string {
   const log = getLogger();
   const id = crypto.randomUUID().slice(0, 12);

package/extensions/orchestrator/test-helpers.ts

@@ -215,9 +215,12 @@ export function expectReviewAuto(menu: AskUserHarness, preset = "regular"): void
   menu.expect({ question: "Review preset", options: { include: [m.preset(preset), "Back"] }, choose: m.preset(preset) });
 }
 
-export function expectReviewOnMyOwn(menu: AskUserHarness): void {
+export function expectReviewOnMyOwn(menu: AskUserHarness, editorGate?: "Done" | "Skip markers"): void {
   menu.expect({ question: m.anyTaskMenu, options: { include: ["Review"] }, choose: "Review" });
   menu.expect({ question: "Review", options: { include: ["Review on my own"] }, choose: "Review on my own" });
+  if (editorGate) {
+    menu.expect({ question: "Editor review", options: { include: [editorGate] }, choose: editorGate });
+  }
 }
 
 export function expectPpStartImplementAutonomous(menu: AskUserHarness): void {

package/extensions/orchestrator/transition-controller.test.ts

@@ -205,3 +205,103 @@ describe("TransitionController phase transition flow", () => {
     expect(onResume).toHaveBeenCalledOnce();
   });
 });
+
+describe("TransitionController done supersession (task-boundary discard cannot be swallowed)", () => {
+  it("a done request supersedes a PENDING transition in place (no swallowed discard)", async () => {
+    const { host, session, calls, completeCompaction } = makeHost({ idle: false });
+    const c = new TransitionController(host, session);
+    // A phase transition is pending (not yet compacting: waiting for agent_end).
+    const staleResume = vi.fn();
+    const pPhase = c.requestTransition({ kind: "phase", summary: "phase", onResume: staleResume, instruction: "Begin working." });
+    expect(c.getState()).toBe("pending");
+    // A new-task done arrives before agent_end. It must replace the pending req.
+    const pDone = c.requestTransition({ kind: "done", discard: true, summary: "DISCARD" });
+    expect(c.getState()).toBe("pending");
+    expect(c.currentSummary()).toBe("DISCARD");
+    expect(c.isDiscardTransition()).toBe(true);
+
+    c.onAgentEnd();
+    expect(calls.compactStarted).toBe(1);
+    completeCompaction();
+    await Promise.all([pPhase, pDone]);
+    // The superseded phase resume/instruction must NOT have run.
+    expect(staleResume).not.toHaveBeenCalled();
+    expect(calls.userMessages).toHaveLength(0);
+    expect(c.getState()).toBe("running");
+  });
+
+  it("queues a done request behind a COMPACTING transition and runs its discard after", async () => {
+    const { host, session, calls, completeCompaction } = makeHost({ idle: false });
+    const c = new TransitionController(host, session);
+    const staleResume = vi.fn();
+    const pPhase = c.requestTransition({ kind: "phase", summary: "phase", onResume: staleResume, instruction: "Begin working." });
+    c.onAgentEnd();
+    expect(c.getState()).toBe("compacting");
+
+    // done arrives mid-compaction — must be queued, not dropped, not double-resumed.
+    let doneResolved = false;
+    const pDone = c.requestTransition({ kind: "done", discard: true, summary: "DISCARD" }).then(() => { doneResolved = true; });
+    expect(calls.compactStarted).toBe(1);
+
+    // First (phase) compaction settles. The superseded phase instruction must be
+    // suppressed because a done is queued behind it; the queued done then runs.
+    completeCompaction();
+    await pPhase;
+    expect(staleResume).toHaveBeenCalledOnce(); // phase onResume still ran (it was the active req)
+    // The queued done must not have resolved yet — its own compaction must run.
+    expect(doneResolved).toBe(false);
+    expect(calls.compactStarted).toBe(2);
+    expect(c.currentSummary()).toBe("DISCARD");
+    expect(c.isDiscardTransition()).toBe(true);
+
+    completeCompaction();
+    await pDone;
+    expect(doneResolved).toBe(true);
+    expect(c.getState()).toBe("running");
+    // The superseded phase instruction ("Begin working.") must NOT have been sent.
+    expect(calls.userMessages).toHaveLength(0);
+  });
+
+  it("queues a done request behind a RESUMING transition", async () => {
+    const { host, session, calls, completeCompaction } = makeHost({ idle: false });
+    const c = new TransitionController(host, session);
+    // onResume that lets us inject the done request while state === "resuming".
+    let injected: Promise<void> | null = null;
+    const pPhase = c.requestTransition({
+      kind: "phase",
+      summary: "phase",
+      onResume: () => {
+        expect(c.getState()).toBe("resuming");
+        injected = c.requestTransition({ kind: "done", discard: true, summary: "DISCARD" });
+      },
+      instruction: "Begin working.",
+    });
+    c.onAgentEnd();
+    completeCompaction();
+    await pPhase;
+    // A done was queued during resuming — it must run its own compaction now.
+    expect(injected).not.toBeNull();
+    expect(calls.compactStarted).toBe(2);
+    completeCompaction();
+    await injected!;
+    expect(c.getState()).toBe("running");
+    expect(c.isDiscardTransition()).toBe(false);
+  });
+
+  it("last-wins when two done requests queue behind an in-flight transition", async () => {
+    const { host, session, calls, completeCompaction } = makeHost({ idle: false });
+    const c = new TransitionController(host, session);
+    const pPhase = c.requestTransition({ kind: "phase", summary: "phase", onResume: () => {}, instruction: "go" });
+    c.onAgentEnd();
+    const pDone1 = c.requestTransition({ kind: "done", discard: true, summary: "FIRST" });
+    const pDone2 = c.requestTransition({ kind: "done", discard: true, summary: "SECOND" });
+
+    completeCompaction(); // phase settles -> queued done runs
+    await pPhase;
+    expect(c.currentSummary()).toBe("SECOND");
+    completeCompaction(); // done settles -> both queued callers resolve
+    await Promise.all([pDone1, pDone2]);
+    expect(c.getState()).toBe("running");
+    expect(calls.compactStarted).toBe(2);
+  });
+});

package/extensions/orchestrator/transition-controller.ts

@@ -26,6 +26,13 @@ export interface TransitionRequest {
   kind: TransitionKind;
   // Compaction summary used by the session_before_compact handler.
   summary?: string;
+  // Task-boundary discard: the previous task is finished/replaced and its
+  // conversation must be genuinely dropped (not softly summarized) so it cannot
+  // leak into the next task. Drives session_before_compact to keep no verbatim
+  // transcript beyond the summary. Only set on finished/replaced-task "done"
+  // transitions (startTask/finishTask/task-complete) — NOT pause/stop (those
+  // resume later and must preserve context).
+  discard?: boolean;
   // Runs after compaction completes (or is skipped), before the resume message.
   // Used for phase transitions to switch model + inject context/artifacts and to
   // spawn planners at the right moment. Throwing here is logged, not fatal.
@@ -80,6 +87,11 @@ export class TransitionController {
   private active: TransitionRequest | null = null;
   // Resolvers for callers that await the transition (done/stop/new-task paths).
   private waiters: Array<() => void> = [];
+  // A single "done" transition queued behind an in-flight (compacting/resuming)
+  // transition it supersedes. Run once the current transition settles so its
+  // discard compaction is guaranteed to execute. Last-wins (never a queue).
+  private pendingNext: TransitionRequest | null = null;
+  private pendingNextWaiters: Array<() => void> = [];
 
   constructor(
     private readonly host: TransitionHost,
@@ -141,6 +153,13 @@ export class TransitionController {
     return this.active?.summary ?? "";
   }
 
+  // True when the in-flight transition is a task-boundary discard (see
+  // TransitionRequest.discard). Lets session_before_compact drop the verbatim
+  // transcript window instead of keeping the default recent tokens.
+  isDiscardTransition(): boolean {
+    return this.active?.discard === true;
+  }
+
   // Outbound plain user-message. The ONLY path for main-session user messaging.
   // Plain user messages (pi.sendUserMessage) ALWAYS start a turn — even with
   // deliverAs:"steer" when idle (SDK prompt()) — so this only serves the
@@ -168,8 +187,29 @@ export class TransitionController {
   requestTransition(req: TransitionRequest): Promise<void> {
     const log = getLogger();
     if (this.state !== "running") {
-      // A transition is already in flight. Coalesce: ignore the new request but
-      // still attach the waiter so the caller is released when this settles.
+      // A transition is already in flight. A task-boundary discard (kind:"done")
+      // must NOT be silently skipped by an in-flight/aborted transition — that
+      // is the concrete cause of prior-task context leaking into the next task.
+      if (req.kind === "done") {
+        if (this.state === "pending") {
+          // Not compacting yet (waiting for agent_end). Replace the pending
+          // request in place: its onResume/instruction is dropped (superseded),
+          // its waiters ride along and resolve when the done transition settles.
+          log.debug({ s: "controller", superseded: this.active?.kind }, "done supersedes pending transition");
+          this.active = req;
+          const promise = new Promise<void>((resolve) => this.waiters.push(resolve));
+          if (this.host.isIdle()) this.beginCompaction();
+          return promise;
+        }
+        // compacting/resuming: a compaction is already in flight for the old
+        // request. Queue the done request to run once it settles so its discard
+        // compaction actually executes; suppress the superseded instruction.
+        // Last-wins if one is already queued (never an unbounded queue).
+        log.debug({ s: "controller", state: this.state }, "done queued behind in-flight transition");
+        this.pendingNext = req;
+        return new Promise<void>((resolve) => this.pendingNextWaiters.push(resolve));
+      }
+      // phase (or other) while not running: keep conservative coalescing.
       if (req.kind === "phase") {
         log.warn({ s: "controller", state: this.state }, "phase transition coalesced while not running — onResume/instruction dropped");
       } else {
@@ -247,7 +287,10 @@ export class TransitionController {
     } catch (err: any) {
       getLogger().error({ s: "controller", err: err?.message ?? String(err) }, "onResume failed");
     }
-    if (req?.instruction) {
+    // Suppress the superseded transition's resume instruction when a done
+    // request is queued to supersede it (its followUp would resume a task that
+    // is about to be discarded).
+    if (req?.instruction && !this.pendingNext) {
       this.send(req.instruction, "instruction");
     }
     this.active = null;
@@ -255,5 +298,20 @@ export class TransitionController {
     const waiters = this.waiters;
     this.waiters = [];
     for (const w of waiters) w();
+    // A done transition queued while this one was in flight: run it now. We are
+    // post-compaction with no agent turn in flight, so begin its compaction
+    // directly rather than through the isIdle/agent_end gate. Its queued callers
+    // ride the new transition's waiters, so they resolve only AFTER the discard
+    // compaction settles.
+    if (this.pendingNext) {
+      const next = this.pendingNext;
+      const resolvers = this.pendingNextWaiters;
+      this.pendingNext = null;
+      this.pendingNextWaiters = [];
+      this.active = next;
+      this.state = "pending";
+      for (const r of resolvers) this.waiters.push(r);
+      this.beginCompaction();
+    }
   }
 }

package/extensions/orchestrator/usage-tracker.ts

@@ -12,7 +12,11 @@ import { SUB_MODEL_PREFIX, SUB_PROVIDER } from "./flant-infra.js";
  */
 export function isSubscriptionRouted(modelId?: string, provider?: string): boolean {
   if (provider === SUB_PROVIDER) return true;
-  return typeof modelId === "string" && modelId.startsWith(SUB_MODEL_PREFIX);
+  if (typeof modelId !== "string") return false;
+  // Accept a bare `sub/<m>` id OR a full provider-prefixed spec
+  // `pp-flant-anthropic-sub/sub/<m>` passed as a single id (the form callers
+  // store/pass without a separate provider field).
+  return modelId.startsWith(SUB_MODEL_PREFIX) || modelId.startsWith(`${SUB_PROVIDER}/`);
 }
 
 export interface ModelUsage {

package/extensions/orchestrator/validate-artifacts.test.ts

@@ -41,6 +41,26 @@ Ship minimal fix.
     expect(result.ok).toBe(true);
   });
 
+  it("accepts a Pattern constraints section", () => {
+    const content = `# Plan
+
+## Scope
+Add a new annotation.
+
+## Checklist
+- [ ] Add annotation — Done when: tests pass
+
+## Pattern constraints
+- Mirror deletePolicies: one typed slice, kebab-case values.
+
+## Blockers
+- none
+`;
+
+    const result = validatePlan(content);
+    expect(result.ok).toBe(true);
+  });
+
   it("accepts multiline Done when continuation", () => {
     const content = `# Plan
 

package/extensions/orchestrator/validate-artifacts.ts

@@ -5,7 +5,7 @@ const USER_REQUEST_ALLOWED_SECTIONS = ["Problem", "Constraints"] as const;
 const RESEARCH_REQUIRED_SECTIONS = ["Affected Code", "Architecture Context", "Constraints & Edge Cases"] as const;
 const RESEARCH_ALLOWED_SECTIONS = ["Affected Code", "Architecture Context", "Constraints & Edge Cases", "Open Questions"] as const;
 const PLAN_REQUIRED_SECTIONS = ["Scope", "Checklist"] as const;
-const PLAN_ALLOWED_SECTIONS = ["Scope", "Checklist", "Blockers"] as const;
+const PLAN_ALLOWED_SECTIONS = ["Scope", "Checklist", "Pattern constraints", "Blockers"] as const;
 const PLACEHOLDER_PATTERNS = /^(?:[-*.…—]|tbd|todo|n\/a|na|none|\.{2,})$/i;
 
 function splitLines(content: string): string[] {
@@ -186,7 +186,7 @@ export function validatePlan(content: string): ValidationResult {
   const errors: string[] = [];
   const h1 = getH1(content);
   const firstHeading = getFirstHeading(content);
-  const expectedSections = formatSectionList(PLAN_REQUIRED_SECTIONS, ["Blockers"]);
+  const expectedSections = formatSectionList(PLAN_REQUIRED_SECTIONS, ["Pattern constraints", "Blockers"]);
 
   if (!firstHeading) {
     errors.push("Missing required heading: # Plan. Expected first heading: # Plan");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ilya-lesikov/pi-pi",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Pi-Pi Coding Agent: based on Pi Coding Agent, but twice as good",
   "keywords": [
     "pi-package",

package/AGENTS.md

@@ -1,28 +0,0 @@
-# Repository Guidelines
-
-All rules in this document are requirements — not suggestions. ALWAYS follow them.
-
-## Highest-priority rule (MANDATORY)
-
-- NEVER add comments unless they document a non-obvious public API or explain genuinely non-obvious logic. NEVER add comments that restate what the code does, repeat the field/function name, describe obvious error handling, or act as section separators. When in doubt, don't comment.
-- ALWAYS verify, don't assume — check the actual state before making changes.
-- ALWAYS start with the simplest possible solution. If it works, stop. Add complexity only when justified by a concrete, current requirement — NEVER for hypothetical future needs.
-- NEVER leave TODOs, stubs, or partial implementations.
-- ALWAYS stay within the scope of what was asked. When asked to update a plan — only update the plan, don't change code. When asked to brainstorm/discuss — only discuss, don't write code. When asked to do X — do X and nothing else. NEVER make unsolicited changes.
-
-## Code style
-
-### Design (MANDATORY)
-
-- ALWAYS prefer stupid and simple over abstract and extendable.
-- ALWAYS prefer a bit of duplication over complex abstractions.
-- ALWAYS prefer clarity over brevity in names.
-- ALWAYS minimize interfaces, generics, embedding.
-- ALWAYS prefer fewer types. Prefer no types over few. Prefer data types over types with behavior.
-- ALWAYS prefer functions over methods. ALWAYS prefer public fields over getters/setters.
-- ALWAYS keep everything private/internal as much as possible.
-- ALWAYS validate early, validate a lot. ALWAYS keep APIs stupid and minimal.
-- NEVER prefer global state. ALWAYS prefer simplicity over micro-optimizations.
-- ALWAYS use libraries for complex things instead of reinventing the wheel.
-- NEVER add comments unless they document a non-obvious public API or explain genuinely non-obvious logic. NEVER add obvious/redundant comments, NEVER add comments restating what code does. When in doubt, don't comment.
-