@ilya-lesikov/pi-pi 0.7.0 → 0.9.0

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/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -0,0 +1 @@
+{"version":"4.1.4","results":[[":pp-menu.test.ts",{"duration":5.372961000000032,"failed":false}],[":integration.test.ts",{"duration":943.253143,"failed":false}],[":phases/review.test.ts",{"duration":2.5133239999999546,"failed":false}],[":pr-comments.test.ts",{"duration":4.420278999999994,"failed":false}],[":transition-controller.test.ts",{"duration":5.222491000000005,"failed":false}],[":event-handlers.test.ts",{"duration":10.928670000000011,"failed":false}],[":ai-comment-cleanup.test.ts",{"duration":3.3210659999999947,"failed":false}],[":flant-infra.test.ts",{"duration":40.368476,"failed":false}],[":command-handlers.test.ts",{"duration":13.727003000000025,"failed":false}],[":usage-tracker.test.ts",{"duration":7.265218000000004,"failed":false}],[":doctor.test.ts",{"duration":10.992058,"failed":false}],[":context.test.ts",{"duration":8.419984999999997,"failed":false}],[":orchestrator.test.ts",{"duration":12.065533000000016,"failed":false}],[":config.test.ts",{"duration":8.647639000000026,"failed":false}],[":model-registry.test.ts",{"duration":9.934792000000002,"failed":false}],[":state.test.ts",{"duration":13.755476000000002,"failed":false}],[":commands.test.ts",{"duration":270.744763,"failed":false}],[":phases/machine.test.ts",{"duration":8.854923999999983,"failed":false}],[":pp-state-tools.test.ts",{"duration":7.878408999999991,"failed":false}],[":log.test.ts",{"duration":884.438896,"failed":false}],[":repo-utils.test.ts",{"duration":3.7061610000000016,"failed":false}],[":phases/verdict.test.ts",{"duration":4.656940000000006,"failed":false}],[":rate-limit-fallback-flow.test.ts",{"duration":6.88740700000001,"failed":false}],[":agents/prompts.test.ts",{"duration":4.860277999999994,"failed":false}],[":tracer.test.ts",{"duration":3.9392250000000004,"failed":false}],[":rate-limit-fallback.test.ts",{"duration":3.124099000000001,"failed":false}],[":validate-artifacts.test.ts",{"duration":3.718504000000003,"failed":false}],[":plannotator.test.ts",{"duration":6.168539999999993,"failed":false}],[":agents/constraints.test.ts",{"duration":2.458521999999995,"failed":false}],[":custom-footer.test.ts",{"duration":3.8825789999999927,"failed":false}],[":phases/spawn-blocking.test.ts",{"duration":54.621959000000004,"failed":false}],[":exa.test.ts",{"duration":3.8611999999999966,"failed":false}],[":spawn-cleanup.test.ts",{"duration":2.2092779999999976,"failed":false}],[":subagent-session-marker.test.ts",{"duration":1.6192010000000039,"failed":false}],[":model-version.test.ts",{"duration":5.690410999999997,"failed":false}],[":messages.test.ts",{"duration":1.798244000000004,"failed":false}],[":cbm.test.ts",{"duration":2.306488999999999,"failed":false}],[":phases/brainstorm.test.ts",{"duration":1.6732620000000225,"failed":false}],[":phases/planning.test.ts",{"duration":1.6508400000000165,"failed":false}],[":phases/implementation.test.ts",{"duration":2.0228309999999965,"failed":false}]]}

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 {

package/extensions/orchestrator/orchestrator.ts

@@ -13,7 +13,6 @@ import {
   type TaskState,
   type Phase,
 } from "./state.js";
-import { phasePipeline } from "./phases/machine.js";
 import { getContextDirs, loadAllContextFiles, getPhaseArtifacts, getLatestSynthesizedPlan } from "./context.js";
 import { brainstormSystemPrompt } from "./phases/brainstorm.js";
 import { planningSystemPrompt, spawnPlanners } from "./phases/planning.js";
@@ -24,10 +23,14 @@ import { registerAgentDefinitions, unregisterAgentDefinitions } from "./agents/r
 import { createExploreAgent } from "./agents/explore.js";
 import { createLibrarianAgent } from "./agents/librarian.js";
 import { createTaskAgent } from "./agents/task.js";
-import { resolveModel, getModelInfo, findLatestFamilyMatch } from "./model-registry.js";
+import { createAdvisorAgent } from "./agents/advisor.js";
+import { createDeepDebuggerAgent } from "./agents/deep-debugger.js";
+import { createReviewerAgent } from "./agents/reviewer.js";
+import { resolveModel, getModelInfo, findLatestFamilyMatch, setSubscriptionFallbackActive } from "./model-registry.js";
 import { buildRepoContext } from "./agents/repo-context.js";
 import { getLogger, addTaskDestination, removeTaskDestination, setLogLevel } from "./log.js";
 import { handleSpawnResult } from "./spawn-cleanup.js";
+import { getTracer } from "./tracer.js";
 import { TransitionController, type TransitionHost } from "./transition-controller.js";
 
 function isEnabled(value: { enabled?: boolean } | undefined): boolean {
@@ -70,6 +73,16 @@ export class Orchestrator {
     step?: string;
   }>();
   staleAgentTimer: ReturnType<typeof setInterval> | null = null;
+  // Main-turn stall watchdog (BUG-2). A main turn that starts but never emits a
+  // terminal turn_end/error can wedge the session ("Working…" forever). Unlike
+  // staleAgentTimer (subagents only), this watches the MAIN session: any main-
+  // session stream/tool/turn activity refreshes mainTurnLastActivity; when a turn
+  // is in flight with no activity beyond config.performance.internals.mainTurnStale,
+  // the watchdog recovers via the idle-gated single-send path.
+  mainTurnTimer: ReturnType<typeof setInterval> | null = null;
+  mainTurnLastActivity = 0;
+  mainTurnInFlight = false;
+  mainTurnRecovering = false;
   // Single consecutive-nudge guard (replaces the old multi-tier throttle). Reset
   // to 0 on any productive turn; once it reaches the cap the nudges halt with one
   // user notification.
@@ -77,10 +90,49 @@ export class Orchestrator {
   nudgeHalted = false;
   pendingSubagentSpawns = 0;
   errorRetryCount = 0;
+  // Halts the API-error auto-retry once errorRetryCount exceeds its cap, mirroring
+  // nudgeHalted. Without this, a benign intervening turn (e.g. the retried turn
+  // ends as a text-only "I'll wait") reset errorRetryCount to 0, so the 5-retry
+  // cap never accumulated and the "Previous request failed" nudge could fire
+  // unbounded (hundreds of times) against transient errors. Cleared only on
+  // genuine (non-[PI-PI]) user re-engagement, like nudgeHalted.
+  errorNudgeHalted = false;
   commitReminderSent = false;
   phaseStartTime = 0;
   pendingRetryTimer: ReturnType<typeof setTimeout> | null = null;
+  // Unsubscribe for the direct ESC interrupt armed while pendingRetryTimer is
+  // live. pi-pi's own post-error retry is NOT covered by any SDK/interactive ESC
+  // binding (the turn already ended in error, the session is not streaming), so
+  // without this ESC would not cancel it.
+  pendingRetryEscUnsub: (() => void) | null = null;
   activeTaskToken = 0;
+  // Side-channel for stale-nudge re-validation. A continuation nudge is delivered
+  // as a followUp whose prompt STRING carries no phase/task token, and the SDK
+  // queue only surfaces the string in before_agent_start. So at nudge-generation
+  // time we record {phase, taskToken} keyed by the exact nudge string; at delivery
+  // we re-check both against the live phase/token and drop the nudge on mismatch
+  // (a nudge generated for an old phase/task must not drive a turn in the new one).
+  // Last-wins per distinct string; a stale entry only ever fails-closed to drop.
+  pendingNudges = new Map<string, { phase: Phase; taskToken: number }>();
+  // Subscription rate-limit fallback (Issue 5). subFallbackActive mirrors the
+  // model-registry override flag; subFallbackDialogPending guards against
+  // opening more than one switch dialogue at a time (across main + subagents);
+  // subFallbackModelId records the sub model that hit the limit (used by the
+  // switch-back probe); subSwitchBackTimer is the fixed-interval probe timer.
+  subFallbackActive = false;
+  subFallbackDialogPending = false;
+  // True while a user-facing dialogue (ask_user / the /pp menu / any interactive
+  // selectOption) is open. The main-turn watchdog skips while set so a turn
+  // legitimately parked on a human is not aborted. Set on dialogue open, cleared
+  // in finally on every exit (resolve, ESC/cancel, error).
+  interactivePromptOpen = false;
+  // Set SYNCHRONOUSLY the moment a sub-429 is detected (before any async dialog),
+  // and cleared once the decision resolves. The autonomous planner/reviewer
+  // auto-retry consults this to avoid re-spawning a failed variant on the still-
+  // sub-routed model while the fallback decision is in flight.
+  subFallbackPendingDecision = false;
+  subFallbackModelId: string | null = null;
+  subSwitchBackTimer: ReturnType<typeof setTimeout> | null = null;
   userGatePending = false;
   lastCtx: any = null;
   failedPlannerVariants: string[] = [];
@@ -100,10 +152,16 @@ export class Orchestrator {
   checkPlannerCompletion: () => void = () => {};
   readonly transitionController: TransitionController;
 
+  // The single live instance, so module-level dialogue wrappers (selectOption in
+  // event-handlers/pp-menu) can toggle interactivePromptOpen without threading a
+  // reference through ~70 call sites.
+  static current: Orchestrator | null = null;
+
   constructor(readonly pi: ExtensionAPI) {
     // The controller calls pi (the main session) directly for sends, and uses the
     // host only for live-ctx-dependent bits (compact/isIdle/currentStep).
     this.transitionController = new TransitionController(this.makeTransitionHost(), this.pi);
+    Orchestrator.current = this;
   }
 
   // Live-session host the TransitionController uses for compaction/idle/step.
@@ -123,6 +181,87 @@ export class Orchestrator {
     };
   }
 
+  // Arm a direct ESC interrupt for the post-error retry window. Idempotent: a
+  // single onTerminalInput handler stays registered until the retry is delivered,
+  // cancelled, or the task is reset. While pendingRetryTimer is live, ESC cancels
+  // the pending retry (no other binding covers this window).
+  armRetryEscInterrupt(ctx: any): void {
+    if (this.pendingRetryEscUnsub) return;
+    const onTerminalInput = ctx?.ui?.onTerminalInput;
+    if (typeof onTerminalInput !== "function") return;
+    const unsub = onTerminalInput.call(ctx.ui, (data: string) => {
+      if (!this.pendingRetryTimer) return undefined;
+      // Match a STANDALONE ESC only. Arrow/function/mouse sequences also start
+      // with 0x1b (e.g. "\x1b[A"), so `includes` would misfire on navigation
+      // keys and swallow them; a bare ESC is exactly the one-byte string.
+      if (data === "\x1b") {
+        this.cancelPendingRetry();
+        ctx?.ui?.notify?.("Retry cancelled.", "info");
+        return { consume: true };
+      }
+      return undefined;
+    });
+    this.pendingRetryEscUnsub = typeof unsub === "function" ? unsub : null;
+  }
+
+  disarmRetryEscInterrupt(): void {
+    if (this.pendingRetryEscUnsub) {
+      try {
+        this.pendingRetryEscUnsub();
+      } catch {
+        // ignore unsubscribe failures
+      }
+      this.pendingRetryEscUnsub = null;
+    }
+  }
+
+  // Cancel a pending post-error retry (timer + ESC interrupt) and reset the retry
+  // counter. Used by the ESC interrupt handler and by abort paths.
+  cancelPendingRetry(): void {
+    if (this.pendingRetryTimer) {
+      clearTimeout(this.pendingRetryTimer);
+      this.pendingRetryTimer = null;
+    }
+    this.disarmRetryEscInterrupt();
+    this.errorRetryCount = 0;
+    this.errorNudgeHalted = false;
+  }
+
+  // Deliver a queued message only once the main session is idle. Firing a
+  // followUp while the SDK still has an active run triggers an async, runtime-
+  // swallowed "Agent is already processing" rejection (surfaces as
+  // Extension "<runtime>" error), so we PRE-CHECK idle and DEFER (bounded poll)
+  // rather than dropping the nudge. Guarded by activeTaskToken; the poll reuses
+  // pendingRetryTimer so ESC/abort cancels it.
+  sendUserMessageWhenIdle(text: string, taskToken: number, attempt = 0): void {
+    const log = getLogger();
+    if (this.activeTaskToken !== taskToken || !this.active) {
+      this.disarmRetryEscInterrupt();
+      return;
+    }
+    const idleFn = this.lastCtx?.isIdle;
+    const idle = typeof idleFn === "function" ? !!idleFn.call(this.lastCtx) : true;
+    if (idle) {
+      this.disarmRetryEscInterrupt();
+      this.safeSendUserMessage(text);
+      return;
+    }
+    const MAX_ATTEMPTS = 120; // ~2min at 1s poll
+    if (attempt >= MAX_ATTEMPTS) {
+      log.warn({ s: "orchestrator", attempt }, "sendUserMessageWhenIdle gave up waiting for idle");
+      this.disarmRetryEscInterrupt();
+      this.lastCtx?.ui?.notify?.(
+        "pi-pi stopped waiting for the agent to go idle; auto-continuation was dropped. Send any message to resume.",
+        "warning",
+      );
+      return;
+    }
+    this.pendingRetryTimer = setTimeout(() => {
+      this.pendingRetryTimer = null;
+      this.sendUserMessageWhenIdle(text, taskToken, attempt + 1);
+    }, 1000);
+  }
+
   safeSendUserMessage(text: string): void {
     const log = getLogger();
     const attempt = (retries: number) => {
@@ -219,67 +358,17 @@ export class Orchestrator {
     return true;
   }
 
+  // The footer's phase/mode display (line 1) reads orchestrator state directly; this only
+  // sets a hidden "pp-phase" status whose value changes per transition so the host repaints
+  // the footer. Nothing renders this string (footer line 3 was removed), so it stays terse.
   updateStatus(ctx: ExtensionContext): void {
     if (!this.active || this.active.state.phase === "done") {
       ctx.ui.setStatus("pp-phase", undefined);
       return;
     }
-
-    const type = this.active.type;
-    const phase = this.active.state.phase;
-    const step = this.active.state.step;
-    const reviewCycle = this.active.state.reviewCycle;
-    const effectiveMode = this.active.state.effectiveMode ?? this.active.state.mode;
-    const modeLabel = effectiveMode === "autonomous" ? " [autonomous]" : "";
-
-    if (type === "debug" || type === "brainstorm" || type === "quick") {
-      const elapsed = this.phaseStartTime > 0 ? this.formatElapsed(this.phaseStartTime) : "";
-      const suffix = elapsed ? ` (${elapsed})` : "";
-      ctx.ui.setStatus("pp-phase", `pp: ${type}${modeLabel}${suffix}`);
-      return;
-    }
-
-    const pipeline = phasePipeline(type).filter((p) => p !== "done");
-    const currentIdx = pipeline.indexOf(phase as (typeof pipeline)[number]);
-
-    const parts: string[] = [];
-    for (let i = 0; i < pipeline.length; i++) {
-      const p = pipeline[i];
-      if (i < currentIdx) {
-        parts.push(`✔ ${p}`);
-      } else if (p === phase) {
-        let detail = "";
-        if (step === "await_planners") detail = "planners";
-        else if (step === "await_reviewers") detail = "reviewers";
-        else if (step === "synthesize") detail = "synthesize";
-        else if (step === "apply_feedback") detail = "feedback";
-        else if (step === "user_gate") detail = "review";
-
-        if (reviewCycle) {
-          const kind = reviewCycle.kind === "plannotator" ? "plannotator" : "review";
-          detail = `${kind} #${reviewCycle.pass}`;
-        }
-
-        const elapsed = this.phaseStartTime > 0 ? this.formatElapsed(this.phaseStartTime) : "";
-        const sub = [detail, elapsed].filter(Boolean).join(", ");
-        parts.push(sub ? `${p} (${sub})` : p);
-      } else {
-        parts.push(p);
-      }
-    }
-
-    ctx.ui.setStatus("pp-phase", `pp: ${parts.join(" → ")}${modeLabel}`);
-  }
-
-  private formatElapsed(startTime: number): string {
-    const sec = Math.floor((Date.now() - startTime) / 1000);
-    if (sec < 60) return `${sec}s`;
-    const min = Math.floor(sec / 60);
-    const remSec = sec % 60;
-    if (min < 60) return remSec > 0 ? `${min}m ${remSec}s` : `${min}m`;
-    const hr = Math.floor(min / 60);
-    const remMin = min % 60;
-    return remMin > 0 ? `${hr}h ${remMin}m` : `${hr}h`;
+    const s = this.active.state;
+    const cycle = s.reviewCycle ? `:${s.reviewCycle.kind}#${s.reviewCycle.pass}` : "";
+    ctx.ui.setStatus("pp-phase", `${this.active.type}:${s.phase}:${s.step}:${getEffectivePhaseMode(s)}${cycle}`);
   }
 
   getPlanStartState(taskDir: string, plannerPresetName?: string): { step: string; shouldSpawnPlanners: boolean } {
@@ -370,7 +459,8 @@ export class Orchestrator {
       this.lastCtx = ctx;
       await this.transitionController.requestTransition({
         kind: "done",
-        summary: `Starting new ${type} task. Previous conversation discarded.`,
+        discard: true,
+        summary: `A new, unrelated ${type} task is starting. The previous task is finished — DISCARD its entire conversation. Do NOT carry forward, reference, or act on any prior task's messages, phase, plan, or aborted turns; treat the new task as a clean slate.`,
       });
     }
 
@@ -539,9 +629,11 @@ export class Orchestrator {
     this.agentLifecycle.clear();
     this.pendingSubagentSpawns = 0;
     this.errorRetryCount = 0;
+    this.errorNudgeHalted = false;
     this.commitReminderSent = false;
     this.consecutiveNudges = 0;
     this.nudgeHalted = false;
+    this.pendingNudges.clear();
     this.phaseStartTime = 0;
     this.userGatePending = false;
     this.failedPlannerVariants = [];
@@ -552,10 +644,34 @@ export class Orchestrator {
       clearTimeout(this.pendingRetryTimer);
       this.pendingRetryTimer = null;
     }
+    this.disarmRetryEscInterrupt();
     if (this.staleAgentTimer) {
       clearInterval(this.staleAgentTimer);
       this.staleAgentTimer = null;
     }
+    if (this.mainTurnTimer) {
+      clearInterval(this.mainTurnTimer);
+      this.mainTurnTimer = null;
+    }
+    this.mainTurnInFlight = false;
+    this.mainTurnRecovering = false;
+    this.clearSubscriptionFallback();
+  }
+
+  // Reset the subscription rate-limit fallback: cancel the switch-back probe
+  // timer, clear the model-registry override, and reset guards. Called on task
+  // reset/cleanup so the sticky override never leaks across tasks.
+  clearSubscriptionFallback(): void {
+    if (this.subSwitchBackTimer) {
+      clearTimeout(this.subSwitchBackTimer);
+      this.subSwitchBackTimer = null;
+    }
+    this.subFallbackActive = false;
+    this.subFallbackDialogPending = false;
+    this.interactivePromptOpen = false;
+    this.subFallbackPendingDecision = false;
+    this.subFallbackModelId = null;
+    setSubscriptionFallbackActive(false);
   }
 
   async cleanupActive(): Promise<void> {
@@ -578,7 +694,10 @@ export class Orchestrator {
     const log = getLogger();
     const explore = createExploreAgent(this.config);
     const librarian = createLibrarianAgent(this.config);
-    const taskAgent = createTaskAgent(this.config, "{{subtask}}", { userRequest: "", synthesizedPlan: "" });
+    const taskAgent = createTaskAgent(this.config);
+    const advisor = createAdvisorAgent(this.config);
+    const deepDebugger = createDeepDebuggerAgent(this.config);
+    const reviewer = createReviewerAgent(this.config);
     const phase = this.active?.state.phase;
     const repos = this.active?.state.repos ?? [];
     log.debug({ s: "agents", phase, repoCount: repos.length }, "registering agent definitions");
@@ -615,6 +734,24 @@ export class Orchestrator {
         ...taskAgent,
         prompt: appendContext("task", taskAgent.prompt, getModelInfo(resolveModel(this.config.agents.subagents.simple.task.model))),
       },
+      {
+        type: "advisor",
+        variant: null,
+        ...advisor,
+        prompt: appendContext("advisor", advisor.prompt, getModelInfo(resolveModel(this.config.agents.subagents.simple.advisor.model))),
+      },
+      {
+        type: "deep-debugger",
+        variant: null,
+        ...deepDebugger,
+        prompt: appendContext("deep-debugger", deepDebugger.prompt, getModelInfo(resolveModel(this.config.agents.subagents.simple["deep-debugger"].model))),
+      },
+      {
+        type: "reviewer",
+        variant: null,
+        ...reviewer,
+        prompt: appendContext("reviewer", reviewer.prompt, getModelInfo(resolveModel(this.config.agents.subagents.simple.reviewer.model))),
+      },
     ]);
   }