@ilya-lesikov/pi-pi 0.7.0 → 0.8.0

package/extensions/orchestrator/event-handlers.ts

@@ -14,17 +14,20 @@ import {
   loadAllContextFiles,
   getPhaseArtifacts,
   getLatestSynthesizedPlan,
+  getArtifactManifest,
   loadBrainstormReviewOutputs,
   loadCodeReviewOutputs,
   loadPlanReviewOutputs,
 } from "./context.js";
-import { PRINCIPLES_BLOCK, TOOLS_BLOCK } from "./agents/tool-routing.js";
+import { PRINCIPLES_BLOCK, TOOLS_BLOCK, DELEGATION_BLOCK } from "./agents/tool-routing.js";
 import { constraintsBlock, phaseConstraint } from "./agents/constraints.js";
 import { registerCbmTools } from "./cbm.js";
 import { registerExaTools } from "./exa.js";
 import { registerAstSearchTool } from "./ast-search.js";
 import { SUBAGENT_SESSION_KEY } from "./index.js";
 import { registerCommandHandlers } from "./command-handlers.js";
+import { registerStateFileTools } from "./pp-state-tools.js";
+import { handleMainRateLimit, handleSubagentRateLimit, isRateLimitError, isSdkRetryableError } from "./rate-limit-fallback.js";
 import { setExtensionOnlyMode, unregisterAgentDefinitions } from "./agents/registry.js";
 import { resolveModel, getModelInfo, updateRegistryFromAvailableModels } from "./model-registry.js";
 import { spawnPlanners, spawnPlanReviewers } from "./phases/planning.js";
@@ -33,9 +36,10 @@ import { spawnBrainstormReviewers } from "./phases/brainstorm.js";
 import { reviewPassUnanimousApprove } from "./phases/verdict.js";
 import { validateExitCriteria } from "./phases/machine.js";
 import { openPlannotator, waitForPlannotatorResult, cancelPendingPlannotatorWait } from "./plannotator.js";
+import { advanceBanner } from "./messages.js";
 import { Orchestrator, type ActiveTask } from "./orchestrator.js";
 import { createCustomFooter, setFooterContext, setFooterTracker } from "./custom-footer.js";
-import { createUsageTracker, dumpUsageSummary, loadUsageSummary, type UsageTracker } from "./usage-tracker.js";
+import { createUsageTracker, dumpUsageSummary, loadUsageSummary, isSubscriptionRouted, type UsageTracker } from "./usage-tracker.js";
 import { askUser, isCancel } from "../../3p/pi-ask-user/index.js";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { findRootRepo, normalizeRepoPath, resolveRepoForFile, type RepoInfo } from "./repo-utils.js";
@@ -51,6 +55,34 @@ function isPathInside(basePath: string, targetPath: string): boolean {
   return rel === "" || (!rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel));
 }
 
+// Builds the spawn-time context block appended to a free agent's spawn prompt:
+// inlines USER_REQUEST + RESEARCH (always present by spawn time) and appends a
+// path-aware manifest of additional on-demand documents (artifacts + plan).
+function buildSpawnContextBlock(taskDir: string): string {
+  const parts: string[] = [];
+
+  const userRequestPath = join(taskDir, "USER_REQUEST.md");
+  if (existsSync(userRequestPath)) {
+    parts.push("=== USER REQUEST ===\n" + readFileSync(userRequestPath, "utf-8").trimEnd());
+  }
+  const researchPath = join(taskDir, "RESEARCH.md");
+  if (existsSync(researchPath)) {
+    parts.push("=== RESEARCH ===\n" + readFileSync(researchPath, "utf-8").trimEnd());
+  }
+
+  const manifest = getArtifactManifest(taskDir);
+  if (manifest.length > 0) {
+    const lines = manifest.map((m) => `- ${m.path}  — ${m.title}`);
+    parts.push(
+      "=== ADDITIONAL DOCUMENTS (read from disk if relevant) ===\n" +
+        lines.join("\n") +
+        "\nDo NOT re-read USER_REQUEST/RESEARCH from disk (already above).",
+    );
+  }
+
+  return parts.join("\n\n");
+}
+
 export async function detectDefaultBranch(orchestrator: Orchestrator, repos: RepoInfo[], repoPath: string): Promise<string> {
   const normalizedPath = normalizeRepoPath(repoPath);
   const repo = repos.find((r) => r.path === normalizedPath);
@@ -206,7 +238,7 @@ function tryCompleteReviewCycle(orchestrator: Orchestrator, spawnedReviewers?: n
     },
     "instruction",
   );
-  orchestrator.safeSendUserMessage(reviewReadyMessage(phase, getEffectivePhaseMode(orchestrator.active.state)));
+  orchestrator.safeSendUserMessage(advanceBanner(reviewReadyMessage(phase, getEffectivePhaseMode(orchestrator.active.state))));
 }
 
 function reviewReadyMessage(phase: string, mode: TaskMode): string {
@@ -421,6 +453,7 @@ function registerOrchestratorTools(orchestrator: Orchestrator): void {
   registerPhaseCompleteTool(orchestrator);
   registerCommitTool(orchestrator);
   registerSpecifyReviewsTool(orchestrator);
+  registerStateFileTools(orchestrator);
 }
 
 function registerRepoTool(orchestrator: Orchestrator): void {
@@ -562,24 +595,24 @@ function registerRepoTool(orchestrator: Orchestrator): void {
   });
 }
 
-function openCodeReviewDirect(
-  pi: ExtensionAPI,
+async function openCodeReviewDirect(
+  orchestrator: Orchestrator,
   payload: Record<string, unknown>,
 ): Promise<{ approved: boolean; feedback?: string } | { error: string }> {
-  return new Promise((resolve) => {
-    pi.events.emit("plannotator:request", {
-      requestId: crypto.randomUUID(),
-      action: "code-review",
-      payload,
-      respond: (response: any) => {
-        if (response.status === "handled") {
-          resolve({ approved: !!response.result?.approved, feedback: response.result?.feedback });
-        } else {
-          resolve({ error: response.error || "Plannotator not available" });
-        }
-      },
-    });
-  });
+  const { opened, reviewId } = await openPlannotator(orchestrator.pi, "code-review", payload);
+  if (!opened) {
+    return { error: "Plannotator not available" };
+  }
+  let result: { approved: boolean; feedback?: string; error?: string };
+  try {
+    result = await waitForPlannotatorResult(orchestrator, reviewId, null);
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : "Plannotator review failed" };
+  }
+  if (result.error) {
+    return { error: result.error };
+  }
+  return { approved: result.approved, feedback: result.feedback };
 }
 
 function registerSpecifyReviewsTool(orchestrator: Orchestrator): void {
@@ -671,7 +704,7 @@ function registerSpecifyReviewsTool(orchestrator: Orchestrator): void {
           continue;
         }
 
-        const result = await openCodeReviewDirect(pi, {
+        const result = await openCodeReviewDirect(orchestrator, {
           cwd: reviewCwd,
           diffType: "branch",
           defaultBranch: compareBase,
@@ -1168,6 +1201,7 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
     if (data.description) {
       orchestrator.agentDescriptions.set(data.id, data.description);
     }
+
     trackSubagentEvent(data, "created");
     startStaleAgentWatchdog();
     const mgr = (globalThis as any)[Symbol.for("pi-subagents:manager")];
@@ -1214,7 +1248,14 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
 
     const failedPlannerVariants = [...orchestrator.failedPlannerVariants];
     const effectiveMode = getEffectiveMode(orchestrator.active.state);
-    if (effectiveMode === "autonomous" && failedPlannerVariants.length > 0) {
+    // Do NOT auto-retry failed variants while a subscription-429 fallback decision
+    // is in flight: re-spawning now would use the still-sub-routed model and
+    // re-hit the limit. Once the user decides, the fallback nudge re-drives this.
+    if (
+      effectiveMode === "autonomous" &&
+      failedPlannerVariants.length > 0 &&
+      !orchestrator.subFallbackPendingDecision
+    ) {
       const alreadyRetried = orchestrator.active.state.plannerFailureAutoRetried === true;
       if (!alreadyRetried) {
         const failedSet = new Set(failedPlannerVariants);
@@ -1386,7 +1427,13 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
 
     const failedReviewerVariants = [...orchestrator.failedReviewerVariants];
     const effectiveMode = getEffectiveMode(orchestrator.active.state);
-    if (effectiveMode === "autonomous" && failedReviewerVariants.length > 0) {
+    // See the planner path: suppress auto-retry while a sub-429 fallback decision
+    // is pending so we don't re-spawn on the still-sub-routed model.
+    if (
+      effectiveMode === "autonomous" &&
+      failedReviewerVariants.length > 0 &&
+      !orchestrator.subFallbackPendingDecision
+    ) {
       const cycle = orchestrator.active.state.reviewCycle;
       const phase = orchestrator.active.state.phase;
       const outputs = loadPhaseReviewOutputs(orchestrator.active.dir, phase, cycle.pass);
@@ -1641,6 +1688,23 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
       orchestrator.abortAllSubagents();
     }
 
+    // Subscription rate-limit (429) on a sub-routed subagent: offer the ONE
+    // global switch-to-non-sub dialogue (never per-subagent). subagents:failed
+    // carries the subagent's resolved model id.
+    const failedModelId = typeof data.modelId === "string" ? data.modelId : undefined;
+    const subRateLimited =
+      isRateLimitError(data.error) &&
+      isSubscriptionRouted(failedModelId) &&
+      !orchestrator.subFallbackActive;
+    if (subRateLimited) {
+      // Set the decision-pending flag SYNCHRONOUSLY (before the completion checks
+      // below) so the autonomous planner/reviewer auto-retry does NOT re-spawn
+      // the failed variant on the still-sub-routed model while the fallback
+      // dialogue is in flight.
+      orchestrator.subFallbackPendingDecision = true;
+      void handleSubagentRateLimit(orchestrator, orchestrator.lastCtx, failedModelId);
+    }
+
     orchestrator.transitionController.sendCustom(
       {
         customType: "pp-subagent-error",
@@ -1821,6 +1885,10 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
     if (!isControllerInjected) {
       orchestrator.nudgeHalted = false;
       orchestrator.consecutiveNudges = 0;
+      // Genuine user re-engagement also clears the API-error retry halt, so a
+      // fresh request can auto-retry again from a clean counter.
+      orchestrator.errorNudgeHalted = false;
+      orchestrator.errorRetryCount = 0;
     }
     orchestrator.updateStatus(ctx);
 
@@ -1855,6 +1923,7 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
       constraintsBlock(phase as Phase, effectiveMode),
       PRINCIPLES_BLOCK,
       TOOLS_BLOCK,
+      DELEGATION_BLOCK,
       projectContext,
       taskBlock,
     ]
@@ -1877,24 +1946,29 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
     if (event.toolName === "Agent" && orchestrator.active) {
       const input = event.input as Record<string, unknown>;
       const requestedType = ((input.subagent_type as string) || "").toLowerCase();
+      const validTypes = ["explore", "librarian", "task", "advisor", "deep-debugger", "reviewer"];
       if (!requestedType) {
-        return { block: true, reason: "subagent_type is required. Use Explore for codebase research, Librarian for external docs, or Task for implementation subtasks." };
+        return { block: true, reason: "subagent_type is required. Valid types: explore (codebase research), librarian (external docs), task (implementation subtask), advisor (design/'why is this broken' judgment), deep-debugger (hard persistent failures), reviewer (code review — only when the user explicitly asks)." };
       }
-      const isExplore = requestedType === "explore";
-      const isLibrarian = requestedType === "librarian";
-
-      if (isExplore) {
-        input.subagent_type = "explore";
-        input.model = resolveModel(orchestrator.config.agents.subagents.simple.explore.model);
-        input.thinking = orchestrator.config.agents.subagents.simple.explore.thinking;
-      } else if (isLibrarian) {
-        input.subagent_type = "librarian";
-        input.model = resolveModel(orchestrator.config.agents.subagents.simple.librarian.model);
-        input.thinking = orchestrator.config.agents.subagents.simple.librarian.thinking;
-      } else {
-        input.subagent_type = "task";
-        input.model = resolveModel(orchestrator.config.agents.subagents.simple.task.model);
-        input.thinking = orchestrator.config.agents.subagents.simple.task.thinking;
+      if (!validTypes.includes(requestedType)) {
+        return { block: true, reason: `Unknown subagent_type "${requestedType}". Valid types: ${validTypes.join(", ")}.` };
+      }
+
+      const simple = orchestrator.config.agents.subagents.simple;
+      const role = requestedType as keyof typeof simple;
+      input.subagent_type = requestedType;
+      input.model = resolveModel(simple[role].model);
+      input.thinking = simple[role].thinking;
+
+      // Spawn-time context injection: append USER_REQUEST + RESEARCH content and a
+      // path-aware manifest of on-demand documents to the LLM-supplied spawn prompt.
+      // explore/librarian intentionally get nothing (fast, scoped retrieval).
+      if (["task", "advisor", "deep-debugger", "reviewer"].includes(requestedType)) {
+        const contextBlock = buildSpawnContextBlock(orchestrator.active.dir);
+        if (contextBlock) {
+          const existingPrompt = typeof input.prompt === "string" ? input.prompt : "";
+          input.prompt = existingPrompt ? `${existingPrompt}\n\n${contextBlock}` : contextBlock;
+        }
       }
     }
 
@@ -2146,6 +2220,39 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
         contentBlocks: msg.content?.length ?? 0,
         contentSummary,
       }, "turn ended with error");
+      // Subscription rate-limit (429) on a sub-routed main turn: retrying the
+      // same sub model is futile against an account-level limit. Offer a
+      // user-gated switch to non-sub Claude instead of the generic backoff.
+      const activeModelId = (typeof msg.model === "string" && msg.model) || ctx.model?.id;
+      const activeProvider = (typeof msg.provider === "string" && msg.provider) || ctx.model?.provider;
+      if (
+        isRateLimitError(errorMsg) &&
+        isSubscriptionRouted(activeModelId, activeProvider) &&
+        !orchestrator.subFallbackActive
+      ) {
+        void handleMainRateLimit(orchestrator, ctx, activeModelId, activeProvider);
+        return;
+      }
+      // The SDK already auto-retries this class of error itself (abortable
+      // backoff bound to ESC, continuing the SAME turn). Running pi-pi's OWN
+      // independent retry on top would double-fire: its followUp races the SDK's
+      // continue() into "Agent is already processing", and it re-nudges a still-
+      // failing model. So for SDK-retryable errors we defer entirely to the SDK
+      // and do nothing here. pi-pi's own idle-gated retry remains only as the
+      // fallback for errors the SDK does NOT retry.
+      if (isSdkRetryableError(errorMsg)) {
+        getLogger().debug({ s: "turn", err: errorMsg }, "deferring to SDK auto-retry; pi-pi retry skipped");
+        return;
+      }
+      // Halt guard: once the consecutive-error cap is exceeded we stop auto-
+      // retrying until the user re-engages. errorRetryCount is NO LONGER reset on
+      // benign intervening turns (see below) — otherwise a retried turn that ends
+      // as a harmless text-only reply would reset the counter and the cap could
+      // never accumulate, letting transient errors nudge unbounded.
+      if (orchestrator.errorNudgeHalted) {
+        getLogger().debug({ s: "turn", err: errorMsg }, "error auto-retry halted; awaiting user re-engagement");
+        return;
+      }
       orchestrator.errorRetryCount = (orchestrator.errorRetryCount ?? 0) + 1;
       const maxRetries = 5;
       if (orchestrator.errorRetryCount <= maxRetries) {
@@ -2153,18 +2260,44 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
         ctx.ui.notify(`API error (attempt ${orchestrator.errorRetryCount}/${maxRetries}): ${errorMsg}. Retrying in ${delay / 1000}s...`, "warning");
         const taskToken = orchestrator.activeTaskToken;
         if (orchestrator.pendingRetryTimer) clearTimeout(orchestrator.pendingRetryTimer);
+        // Arm a direct ESC interrupt for this retry window — no SDK/interactive
+        // binding covers pi-pi's own timer (the turn already ended in error).
+        orchestrator.armRetryEscInterrupt(ctx);
         orchestrator.pendingRetryTimer = setTimeout(() => {
           orchestrator.pendingRetryTimer = null;
-          if (orchestrator.activeTaskToken !== taskToken || !orchestrator.active) return;
-          orchestrator.safeSendUserMessage(`[PI-PI] Previous request failed due to an API error. Continue working on the current phase (${phase}).`);
+          if (orchestrator.activeTaskToken !== taskToken || !orchestrator.active) {
+            orchestrator.disarmRetryEscInterrupt();
+            return;
+          }
+          // Defer until the main session is idle: sending a followUp while the SDK
+          // still has an active run throws an async, runtime-swallowed "Agent is
+          // already processing" error. sendUserMessageWhenIdle polls (reusing
+          // pendingRetryTimer so ESC/abort still cancels) and disarms the ESC hook
+          // once delivered.
+          orchestrator.sendUserMessageWhenIdle(
+            `[PI-PI] Previous request failed due to an API error. Continue working on the current phase (${phase}).`,
+            taskToken,
+          );
         }, delay);
       } else {
-        ctx.ui.notify(`API error persisted after ${maxRetries} retries: ${errorMsg}. Stopping auto-retry.`, "error");
-        orchestrator.errorRetryCount = 0;
+        ctx.ui.notify(`API error persisted after ${maxRetries} retries: ${errorMsg}. Stopping auto-retry — send any message to resume.`, "error");
+        // Halt (do NOT reset the counter) so no further error turn re-arms a retry
+        // until the user re-engages. cancelPendingRetry would reset the count and
+        // re-open the floodgate, so only clear the live timer/ESC hook here.
+        orchestrator.errorNudgeHalted = true;
+        if (orchestrator.pendingRetryTimer) {
+          clearTimeout(orchestrator.pendingRetryTimer);
+          orchestrator.pendingRetryTimer = null;
+        }
+        orchestrator.disarmRetryEscInterrupt();
       }
       return;
     }
-    orchestrator.errorRetryCount = 0;
+    // NOTE: errorRetryCount is intentionally NOT reset here. Resetting on every
+    // non-error turn let a benign nudge-induced turn zero the counter, defeating
+    // the maxRetries cap and allowing unbounded error nudges. The counter is
+    // reset only on genuine user re-engagement (before_agent_start) and on task
+    // reset / cancelPendingRetry.
 
     if ((globalThis as any)[SUBAGENT_SESSION_KEY]) {
       return;

package/extensions/orchestrator/flant-infra.test.ts

@@ -427,6 +427,7 @@ describe("flant-infra", () => {
       enabled: false,
       autoUpdate: true,
       cacheTTLDays: 7,
+      switchBackIntervalMinutes: 30,
       subscription: false,
       lastUpdated: null,
       cachedFlantModels: null,
@@ -465,6 +466,7 @@ describe("flant-infra", () => {
       enabled: true,
       autoUpdate: false,
       cacheTTLDays: 3,
+      switchBackIntervalMinutes: 30,
       subscription: false,
       lastUpdated: "2026-01-02T03:04:05.000Z",
       cachedFlantModels: ["gpt-5-4", "claude-opus-4-6"],
@@ -488,6 +490,7 @@ describe("flant-infra", () => {
       enabled: true,
       autoUpdate: true,
       cacheTTLDays: 14,
+      switchBackIntervalMinutes: 30,
       subscription: true,
       lastUpdated: "2026-02-01T00:00:00.000Z",
       cachedFlantModels: ["claude-opus-4-6", "gpt-5-4"],
@@ -508,4 +511,26 @@ describe("flant-infra", () => {
     expect(loaded).toEqual(settings);
     expect(existsSync(join(dir, "extensions", "pp", "cache", "flant-models.json"))).toBe(true);
   });
+
+  it("normalizes switchBackIntervalMinutes: default when missing, parsed, floored to >=1", async () => {
+    const dir = makeTempDir();
+    const mod = await loadFlantInfraModule(dir);
+    const settingsDir = join(dir, "extensions", "pp", "cache");
+    const settingsPath = join(settingsDir, "flant-models.json");
+    mkdirSync(settingsDir, { recursive: true });
+
+    // Missing -> default 30.
+    writeFileSync(settingsPath, JSON.stringify({ enabled: true }), "utf-8");
+    expect(mod.loadFlantSettings().switchBackIntervalMinutes).toBe(30);
+
+    // String numeric -> parsed and rounded.
+    writeFileSync(settingsPath, JSON.stringify({ enabled: true, switchBackIntervalMinutes: "45" }), "utf-8");
+    expect(mod.loadFlantSettings().switchBackIntervalMinutes).toBe(45);
+
+    // Invalid / <1 -> floored to 1.
+    writeFileSync(settingsPath, JSON.stringify({ enabled: true, switchBackIntervalMinutes: 0 }), "utf-8");
+    expect(mod.loadFlantSettings().switchBackIntervalMinutes).toBe(1);
+    writeFileSync(settingsPath, JSON.stringify({ enabled: true, switchBackIntervalMinutes: "nonsense" }), "utf-8");
+    expect(mod.loadFlantSettings().switchBackIntervalMinutes).toBe(30);
+  });
 });

package/extensions/orchestrator/flant-infra.ts

@@ -35,6 +35,13 @@ export interface FlantSettings {
    * Claude OAuth token (billed against their personal Claude subscription).
    */
   subscription: boolean;
+  /**
+   * Minutes between out-of-band "is the subscription limit cleared yet?" probes
+   * while the sub→non-sub rate-limit fallback is active. On each interval a
+   * cheap probe hits the sub model; on success the user is asked to switch back.
+   * Default 30.
+   */
+  switchBackIntervalMinutes: number;
 }
 
 const GEMINI_MAP: Record<string, string> = {
@@ -64,6 +71,7 @@ const DEFAULT_SETTINGS: FlantSettings = {
   cachedFlantModels: null,
   cachedOpenRouterData: null,
   subscription: false,
+  switchBackIntervalMinutes: 30,
 };
 
 /** Provider name for the personal-subscription Claude routing. */
@@ -245,10 +253,15 @@ function normalizeSettings(raw: unknown): FlantSettings {
   if (!raw || typeof raw !== "object") return { ...DEFAULT_SETTINGS };
   const value = raw as Record<string, unknown>;
   const cacheTTLDays = Math.max(1, Math.round(toNumber(value.cacheTTLDays, DEFAULT_SETTINGS.cacheTTLDays)));
+  const switchBackIntervalMinutes = Math.max(
+    1,
+    Math.round(toNumber(value.switchBackIntervalMinutes, DEFAULT_SETTINGS.switchBackIntervalMinutes)),
+  );
   return {
     enabled: !!value.enabled,
     autoUpdate: value.autoUpdate === undefined ? true : !!value.autoUpdate,
     cacheTTLDays,
+    switchBackIntervalMinutes,
     subscription: !!value.subscription,
     lastUpdated: typeof value.lastUpdated === "string" ? value.lastUpdated : null,
     cachedFlantModels: Array.isArray(value.cachedFlantModels)
@@ -347,6 +360,81 @@ function mapFlantToOpenRouterId(modelId: string): string | null {
   return null;
 }
 
+/**
+ * Out-of-band probe: is the personal Claude subscription limit cleared yet?
+ * Sends a tiny, fully throwaway request (NOT part of the session, so it cannot
+ * pollute conversation/context/cache) to the gateway's Anthropic endpoint using
+ * the personal Claude OAuth token. Returns:
+ *   "ok"          — 200: capacity is back (offer switch-back)
+ *   "rate_limited" — 429: still limited (stay on non-sub, retry later)
+ *   "error"       — credentials missing / network / other status (treat as not-back)
+ *
+ * The OAuth token is refreshed first so a failure is a genuine 429 and not an
+ * expired-token false negative. `max_tokens: 1` + an explicit "just respond hi"
+ * instruction keep output at ~1 token.
+ */
+// Derive the gateway probe model id (`sub/<bare-claude-id>`) from any stored
+// form: `pp-flant-anthropic-sub/sub/<m>`, `sub/<m>`, or a bare `<m>`. Exported
+// for testing the derivation without a network call.
+export function subProbeModelId(modelId: string): string {
+  let bare = modelId;
+  if (bare.startsWith(`${SUB_PROVIDER}/`)) bare = bare.slice(`${SUB_PROVIDER}/`.length);
+  if (bare.startsWith(SUB_MODEL_PREFIX)) bare = bare.slice(SUB_MODEL_PREFIX.length);
+  return `${SUB_MODEL_PREFIX}${bare}`;
+}
+
+export async function probeSubscriptionCleared(
+  modelId: string,
+): Promise<"ok" | "rate_limited" | "error"> {
+  const log = getLogger();
+  await refreshClaudeOAuthToken();
+  const oauthToken = readClaudeOAuthToken();
+  const gatewayKey = readGatewayApiKey();
+  if (!oauthToken || !gatewayKey) {
+    log.debug({ s: "flant", hasOAuth: !!oauthToken, hasGatewayKey: !!gatewayKey }, "probe skipped: missing credentials");
+    return "error";
+  }
+  // The gateway expects the bare claude-* id under the `sub/` prefix.
+  const probeModel = subProbeModelId(modelId);
+  try {
+    const res = await fetch("https://llm-api.flant.ru/v1/messages", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "anthropic-version": "2023-06-01",
+        // Claude Code OAuth identity headers — the gateway requires these for
+        // subscription (sub/) routing; without them it can reject the probe and
+        // we would never detect that the limit cleared. Mirrors doctor.ts.
+        "anthropic-beta": "claude-code-20250219,oauth-2025-04-20",
+        "user-agent": "claude-cli/1.0.0",
+        "x-app": "cli",
+        Authorization: `Bearer ${oauthToken}`,
+        "x-litellm-api-key": `Bearer ${gatewayKey}`,
+      },
+      body: JSON.stringify({
+        model: probeModel,
+        max_tokens: 1,
+        temperature: 0,
+        messages: [{ role: "user", content: "just respond hi" }],
+      }),
+      signal: AbortSignal.timeout(30000),
+    });
+    if (res.status === 429) {
+      log.debug({ s: "flant", model: probeModel }, "probe: still rate limited");
+      return "rate_limited";
+    }
+    if (res.ok) {
+      log.debug({ s: "flant", model: probeModel }, "probe: capacity back");
+      return "ok";
+    }
+    log.debug({ s: "flant", model: probeModel, status: res.status }, "probe: unexpected status");
+    return "error";
+  } catch (err: any) {
+    log.debug({ s: "flant", err: err?.message }, "probe failed");
+    return "error";
+  }
+}
+
 export async function discoverFlantModels(apiKey: string): Promise<string[]> {
   const res = await fetch("https://llm-api.flant.ru/v1/models", {
     headers: { Authorization: `Bearer ${apiKey}` },
@@ -655,6 +743,9 @@ export function generateFlantConfig(models: string[], subscriptionActive = false
           explore: { model: modelSpec(fastModel, sub), thinking: "low" },
           librarian: { model: modelSpec(fastModel, sub), thinking: "medium" },
           task: { model: modelSpec(taskModel, sub), thinking: "medium" },
+          advisor: { model: modelSpec(latestGpt ?? fallback, sub), thinking: "high" },
+          "deep-debugger": { model: modelSpec(latestGpt ?? fallback, sub), thinking: "high" },
+          reviewer: { model: modelSpec(latestGpt ?? fallback, sub), thinking: "high" },
         },
         presetGroups: {
           planners: buildPresetGroup({

package/extensions/orchestrator/index.ts

@@ -65,7 +65,7 @@ function registerSubagentTools(pi: ExtensionAPI): void {
             ...event.content,
             {
               type: "text" as const,
-              text: `\n\n<validation-error>\nPlan structure is invalid:\n${result.errors.map((e) => `- ${e}`).join("\n")}\n\nFix immediately. Required structure:\n# Plan\n## Scope\n<2-4 lines>\n## Checklist\n- [ ] <outcome> — Done when: <observable condition>\n## Blockers (optional)\n<issues>\n\nRewrite the file now.\n</validation-error>`,
+              text: `\n\n<validation-error>\nPlan structure is invalid:\n${result.errors.map((e) => `- ${e}`).join("\n")}\n\nFix immediately. Required structure:\n# Plan\n## Scope\n<2-4 lines>\n## Checklist\n- [ ] <outcome> — Done when: <observable condition>\n## Pattern constraints (optional; include when adding a type/function/user-facing value)\n<closest existing analog + conventions to mirror>\n## Blockers (optional)\n<issues>\n\nRewrite the file now.\n</validation-error>`,
             },
           ],
         };