@ilya-lesikov/pi-pi 0.6.0 → 0.7.0

package/3p/pi-ask-user/index.ts

@@ -113,7 +113,7 @@ type AskResponse =
 
 // Reason a question was cancelled. Only "user" (a deliberate top-level ESC)
 // should abort the LLM turn; "timeout" and "signal" are programmatic and must not.
-type CancelReason = "user" | "timeout" | "signal";
+export type CancelReason = "user" | "timeout" | "signal";
 
 // Sentinel returned through the UI/askUser boundary to carry a cancel reason.
 // Distinct from a plain AskResponse so callers can disambiguate cancel vs answer.

package/extensions/orchestrator/config.ts

@@ -6,7 +6,7 @@ import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { isValidLogLevel, getLogger, type LogLevel } from "./log.js";
 
 export type DurationValue = string | number;
-export type OrchestratorRole = "implement" | "plan" | "debug" | "brainstorm" | "review";
+export type OrchestratorRole = "implement" | "plan" | "debug" | "brainstorm" | "review" | "quick";
 export type SimpleSubagentRole = "explore" | "librarian" | "task";
 export type PresetGroupKey = "planners" | "codeReviewers" | "planReviewers" | "brainstormReviewers";
 
@@ -91,7 +91,7 @@ export type TimeoutConfig = NormalizedPiPiConfig["performance"]["internals"];
 
 export const PRESET_GROUPS = ["planners", "codeReviewers", "planReviewers", "brainstormReviewers"] as const;
 
-const ORCHESTRATOR_ROLES: OrchestratorRole[] = ["implement", "plan", "debug", "brainstorm", "review"];
+const ORCHESTRATOR_ROLES: OrchestratorRole[] = ["implement", "plan", "debug", "brainstorm", "review", "quick"];
 const SIMPLE_SUBAGENT_ROLES: SimpleSubagentRole[] = ["explore", "librarian", "task"];
 
 const DEFAULT_CONFIG: PiPiConfig = {
@@ -108,6 +108,7 @@ const DEFAULT_CONFIG: PiPiConfig = {
       debug: { model: "openai/gpt-latest", thinking: "high" },
       brainstorm: { model: "anthropic/claude-opus-latest", thinking: "high" },
       review: { model: "anthropic/claude-opus-latest", thinking: "high" },
+      quick: { model: "anthropic/claude-opus-latest", thinking: "high" },
     },
     subagents: {
       simple: {

package/extensions/orchestrator/custom-footer.ts

@@ -58,7 +58,9 @@ function renderStatsLine(width: number, theme: Theme): string {
   const ctx = footerCtx;
   const tracker = footerTracker;
 
-  const inputTokens = tracker?.getTotalInputTokens() ?? 0;
+  // ↑ is the total input the model actually processed (uncached + cache read +
+  // cache write) across main + subagents — not just the tiny uncached sliver.
+  const inputTokens = tracker?.getTotalProcessedInputTokens() ?? 0;
   const outputTokens = tracker?.getTotalOutputTokens() ?? 0;
   const cacheRate = tracker?.getCacheHitRate() ?? 0;
   const totalCost = tracker?.getTotalCost() ?? 0;
@@ -66,7 +68,8 @@ function renderStatsLine(width: number, theme: Theme): string {
   const cacheSupported = tracker?.isCacheSupported() ?? false;
   const leftParts: string[] = [`↑${formatTokens(inputTokens)}`, `↓${formatTokens(outputTokens)}`];
   if (cacheSupported) leftParts.push(`⚡${Math.round(cacheRate * 100)}%`);
-  if (totalCost > 0) leftParts.push(`$${totalCost.toFixed(2)}`);
+  // Always show cost, even $0.00 (subscription/flat-rate sessions).
+  leftParts.push(`$${totalCost.toFixed(2)}`);
   leftParts.push(toContextUsagePart(ctx, theme));
   let left = leftParts.join(" ");
 

package/extensions/orchestrator/doctor.test.ts

@@ -58,6 +58,7 @@ function createConfig() {
         debug: { model: "openai/gpt-latest", thinking: "high" },
         brainstorm: { model: "anthropic/claude-opus-latest", thinking: "high" },
         review: { model: "anthropic/claude-opus-latest", thinking: "high" },
+        quick: { model: "anthropic/claude-opus-latest", thinking: "high" },
       },
       subagents: {
         simple: {
@@ -143,6 +144,7 @@ function createCtx() {
     },
     modelRegistry: {
       getAvailable: vi.fn(() => [
+        { provider: "anthropic", id: "claude-opus-latest" },
         { provider: "anthropic", id: "claude-opus-4-6" },
         { provider: "openai", id: "gpt-5.4" },
         { provider: "google", id: "gemini-3.1-flash" },
@@ -154,7 +156,7 @@ function createCtx() {
 
 beforeEach(() => {
   const aliasMap: Record<string, string> = {
-    "anthropic/claude-opus-latest": "anthropic/claude-opus-4-6",
+    "anthropic/claude-opus-latest": "anthropic/claude-opus-latest",
     "openai/gpt-latest": "openai/gpt-5.4",
     "google/gemini-flash-latest": "google/gemini-3.1-flash",
     "google/gemini-pro-latest": "google/gemini-3.1-pro",

package/extensions/orchestrator/doctor.ts

@@ -12,7 +12,7 @@ import {
   PRESET_GROUPS,
 } from "./config.js";
 import { resolveModel, getAllAliases } from "./model-registry.js";
-import { loadFlantSettings } from "./flant-infra.js";
+import { loadFlantSettings, readClaudeOAuthToken, readGatewayApiKey, refreshClaudeOAuthToken } from "./flant-infra.js";
 import type { Orchestrator } from "./orchestrator.js";
 
 type Severity = "pass" | "warning" | "failure";
@@ -470,7 +470,7 @@ export async function runDoctor(orchestrator: Orchestrator, ctx: any): Promise<v
 
   await safeCheck(async () => {
     const settings = loadFlantSettings();
-    const shouldCheck = Boolean(process.env.FLANT_API_KEY) || settings.enabled || !!settings.cachedFlantModels || !!settings.cachedOpenRouterData;
+    const shouldCheck = Boolean(process.env.FLANT_API_KEY) || settings.enabled || settings.subscription || !!settings.cachedFlantModels || !!settings.cachedOpenRouterData;
     if (!shouldCheck) {
       addLine({ severity: "pass", text: "Skipped: FLANT_API_KEY not set and no Flant configuration detected" });
       return;
@@ -526,6 +526,44 @@ export async function runDoctor(orchestrator: Orchestrator, ctx: any): Promise<v
     } catch (error) {
       addLine({ severity: "failure", text: `OpenRouter probe failed: ${toErrorMessage(error)}` });
     }
+
+    if (settings.subscription) {
+      const oauthToken = (await refreshClaudeOAuthToken()) ?? readClaudeOAuthToken();
+      const gatewayKey = readGatewayApiKey();
+      if (!oauthToken) {
+        addLine({ severity: "warning", text: "Personal subscription enabled, but no valid Claude OAuth token found (log in to your subscription in pi)" });
+      } else if (!gatewayKey) {
+        addLine({ severity: "warning", text: "Personal subscription enabled, but no gateway key (LLM_API_KEY / FLANT_API_KEY)" });
+      } else {
+        const started = Date.now();
+        try {
+          const response = await timedFetch("https://llm-api.flant.ru/v1/messages", {
+            method: "POST",
+            headers: {
+              "content-type": "application/json",
+              "anthropic-version": "2023-06-01",
+              "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: "sub/claude-haiku-4-5",
+              max_tokens: 4,
+              messages: [{ role: "user", content: "ping" }],
+            }),
+          }, 15000);
+          if (!response.ok) {
+            addLine({ severity: "failure", text: `Personal subscription probe failed with HTTP ${response.status}` });
+          } else {
+            addLine({ severity: "pass", text: `Personal subscription reachable (sub/claude-*, ${Date.now() - started}ms)` });
+          }
+        } catch (error) {
+          addLine({ severity: "failure", text: `Personal subscription probe failed: ${toErrorMessage(error)}` });
+        }
+      }
+    }
   }, "Flant checks failed");
 
   addCategory("LSP");

package/extensions/orchestrator/event-handlers.ts

@@ -206,14 +206,21 @@ function tryCompleteReviewCycle(orchestrator: Orchestrator, spawnedReviewers?: n
     },
     "instruction",
   );
-  orchestrator.safeSendUserMessage(reviewReadyMessage(phase));
+  orchestrator.safeSendUserMessage(reviewReadyMessage(phase, getEffectivePhaseMode(orchestrator.active.state)));
 }
 
-function reviewReadyMessage(phase: string): string {
+function reviewReadyMessage(phase: string, mode: TaskMode): string {
   if (phase === "brainstorm") {
     return "[PI-PI] Review cycle is ready for apply_feedback. The reviewers assessed your artifacts (USER_REQUEST.md, RESEARCH.md, and artifacts/), not a code diff. Read their outputs and update those artifacts as needed.";
   }
-  return "[PI-PI] Review cycle is ready for apply_feedback. Read reviewer outputs and proceed.";
+  // Only autonomous plan/implement auto-advance: those must re-call
+  // pp_phase_complete to finalize the pass and transition. Guided phases
+  // (including debug and the interactive review phase) stay user-driven, so
+  // they get neutral wording with no re-call/auto-advance directive.
+  if (mode === "autonomous") {
+    return "[PI-PI] Review cycle is ready for apply_feedback. Read the reviewer outputs, apply any required changes, then call pp_phase_complete again to finalize this review pass and advance the phase. Do NOT stop or wait for the user — the phase is NOT complete until you re-call pp_phase_complete.";
+  }
+  return "[PI-PI] Review cycle is ready for apply_feedback. Read the reviewer outputs and apply any required changes.";
 }
 
 export async function enterReviewCycle(
@@ -713,8 +720,14 @@ function registerSpecifyReviewsTool(orchestrator: Orchestrator): void {
 
       ctx.ui?.setWorkingMessage?.("Waiting for user input…");
       try {
-        const { showActiveTaskMenu } = await import("./pp-menu.js");
+        const { showActiveTaskMenu, USER_CANCELLED } = await import("./pp-menu.js");
         const text = await showActiveTaskMenu(orchestrator, ctx, `Plannotator review complete.\n\n${summary}`, "tool");
+        // Deliberate user ESC: stop the turn cleanly (mirror ask_user), no
+        // reminder text that would start a new LLM turn.
+        if (text === USER_CANCELLED) {
+          ctx.abort?.();
+          return { content: [{ type: "text" as const, text: "" }], details: {} };
+        }
         // A transition may have started while the menu was open. The controller
         // is the source of truth; abort the agent's pending turn so it doesn't
         // race the transition. (Interactive-UX abort — stays local, not routed.)
@@ -840,7 +853,10 @@ function registerPhaseCompleteTool(orchestrator: Orchestrator): void {
         const count = orchestrator.spawnedAgentIds.size + orchestrator.pendingSubagentSpawns;
         return { content: [{ type: "text" as const, text: `${count} subagent(s) still running. Wait for them to complete before calling pp_phase_complete.` }], isError: true as const, details: {} };
       }
-      const effectiveMode = getEffectiveMode(orchestrator.active.state);
+      // Gate on the effective PHASE mode, not the task mode: brainstorm/debug/
+      // review are always user-driven even for an autonomous task, so they must
+      // fall through to the guided menu path below rather than auto-advancing.
+      const effectiveMode = getEffectivePhaseMode(orchestrator.active.state);
       if (effectiveMode === "autonomous") {
         const phase = orchestrator.active.state.phase;
         let justFinalizedReviewCycle = false;
@@ -908,8 +924,16 @@ function registerPhaseCompleteTool(orchestrator: Orchestrator): void {
       }
       ctx.ui.setWorkingMessage?.("Waiting for user approval…");
       try {
-        const { showActiveTaskMenu } = await import("./pp-menu.js");
+        const { showActiveTaskMenu, USER_CANCELLED } = await import("./pp-menu.js");
         const text = await showActiveTaskMenu(orchestrator, ctx, params.summary, "tool");
+        // A deliberate user ESC on the menu means "stop cleanly, let me type" —
+        // mirror ask_user: abort the turn and return nothing so no new LLM turn
+        // starts. This takes precedence over the reminder path below, in ALL
+        // interactive cases (including while a transition is mid-flight).
+        if (text === USER_CANCELLED) {
+          ctx.abort?.();
+          return { content: [{ type: "text" as const, text: "" }], details: {} };
+        }
         // A transition or await may have started while the menu was open. The
         // controller is the source of truth; abort the pending turn so it can't
         // race. (Interactive-UX abort — stays local, not routed.)
@@ -923,6 +947,8 @@ function registerPhaseCompleteTool(orchestrator: Orchestrator): void {
           return { content: [{ type: "text" as const, text: "" }], details: {} };
         }
         if (!text) {
+          // Non-ESC dismissal (explicit "Back") while a transition is running:
+          // keep the intentional artifact-update reminder (commit 10e7021).
           return { content: [{ type: "text" as const, text: "User dismissed the menu. Wait for the user's next message. When you resume work, update USER_REQUEST.md and RESEARCH.md with any new findings before calling pp_phase_complete." }], details: {} };
         }
         return { content: [{ type: "text" as const, text }], details: {} };
@@ -993,6 +1019,21 @@ export function registerEventHandlers(orchestrator: Orchestrator): void {
 
   registerMainTraceHooks(orchestrator);
 
+  // Personal-subscription Claude routing registers the sub provider with a
+  // literal OAuth token (a static snapshot). That token expires within a few
+  // hours, so a long-lived session would keep sending a stale token and the
+  // gateway would return 401. Refresh (and re-register on change) before each
+  // turn's LLM call. Cheap no-op when subscription routing is inactive or the
+  // token is unchanged. registerEventHandlers runs only on the root session.
+  pi.on("turn_start", async () => {
+    try {
+      const { refreshSubProvider } = await import("./flant-infra.js");
+      await refreshSubProvider(pi);
+    } catch (err: any) {
+      getLogger().debug({ s: "flant", err: err?.message }, "sub provider refresh failed");
+    }
+  });
+
   // TransitionController drivers. These are the reliable idle/completion signals:
   //   - agent_end: the main loop went idle. If a transition is pending, this is
   //     when the controller fires compaction.

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

@@ -1,8 +1,14 @@
 import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { readFileSync } from "node:fs";
 import { afterEach, describe, expect, it, vi } from "vitest";
 
+const refreshAnthropicTokenMock = vi.fn();
+vi.mock("@earendil-works/pi-ai/oauth", () => ({
+  refreshAnthropicToken: (...args: unknown[]) => refreshAnthropicTokenMock(...args),
+}));
+
 const tempDirs: string[] = [];
 
 function makeTempDir(): string {
@@ -32,6 +38,7 @@ function collectModelSpecs(value: unknown): string[] {
 }
 
 afterEach(() => {
+  refreshAnthropicTokenMock.mockReset();
   delete process.env.PI_CODING_AGENT_DIR;
   for (const dir of tempDirs.splice(0)) {
     rmSync(dir, { recursive: true, force: true });
@@ -57,6 +64,210 @@ describe("flant-infra", () => {
     expect([...registered.keys()].sort()).toEqual(["pp-flant-anthropic", "pp-flant-openai"]);
   });
 
+  it("does not register the sub provider when subscription is disabled", async () => {
+    const dir = makeTempDir();
+    const mod = await loadFlantInfraModule(dir);
+    const registered = new Map<string, unknown>();
+    const pi = {
+      registerProvider: vi.fn((name: string, config: unknown) => registered.set(name, config)),
+      unregisterProvider: vi.fn((name: string) => registered.delete(name)),
+    } as any;
+
+    mod.registerFlantProviders(pi, ["claude-opus-4-8", "gpt-5"], {}, { subscription: false });
+    expect([...registered.keys()].sort()).toEqual(["pp-flant-anthropic", "pp-flant-openai"]);
+  });
+
+  it("registers the sub provider with sub/ models when subscription enabled and credentials present", async () => {
+    const dir = makeTempDir();
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, "auth.json"),
+      JSON.stringify({ anthropic: { type: "oauth", access: "sk-ant-oat01-test-token", expires: Date.now() + 3_600_000 } }),
+      "utf-8",
+    );
+    const prevKey = process.env.LLM_API_KEY;
+    process.env.LLM_API_KEY = "sk-gateway-test";
+    try {
+      const mod = await loadFlantInfraModule(dir);
+      const registered = new Map<string, any>();
+      const pi = {
+        registerProvider: vi.fn((name: string, config: any) => registered.set(name, config)),
+        unregisterProvider: vi.fn((name: string) => registered.delete(name)),
+      } as any;
+
+      mod.registerFlantProviders(pi, ["claude-opus-4-8", "claude-haiku-4-5", "gpt-5"], {}, { subscription: true });
+
+      expect([...registered.keys()].sort()).toEqual(["pp-flant-anthropic", "pp-flant-anthropic-sub", "pp-flant-openai"]);
+      const sub = registered.get("pp-flant-anthropic-sub");
+      expect(sub.api).toBe("anthropic-messages");
+      expect(sub.baseUrl).toBe("https://llm-api.flant.ru");
+      expect(sub.apiKey).toBe("sk-ant-oat01-test-token");
+      expect(sub.headers["x-litellm-api-key"]).toBe("Bearer sk-gateway-test");
+      expect(sub.models.map((m: any) => m.id).sort()).toEqual(["sub/claude-haiku-4-5", "sub/claude-opus-4-8"]);
+    } finally {
+      if (prevKey === undefined) delete process.env.LLM_API_KEY;
+      else process.env.LLM_API_KEY = prevKey;
+    }
+  });
+
+  it("skips the sub provider when subscription enabled but OAuth token missing", async () => {
+    const dir = makeTempDir();
+    const prevKey = process.env.LLM_API_KEY;
+    process.env.LLM_API_KEY = "sk-gateway-test";
+    try {
+      const mod = await loadFlantInfraModule(dir);
+      const registered = new Map<string, unknown>();
+      const pi = {
+        registerProvider: vi.fn((name: string, config: unknown) => registered.set(name, config)),
+        unregisterProvider: vi.fn((name: string) => registered.delete(name)),
+      } as any;
+
+      mod.registerFlantProviders(pi, ["claude-opus-4-8"], {}, { subscription: true });
+      expect(registered.has("pp-flant-anthropic-sub")).toBe(false);
+    } finally {
+      if (prevKey === undefined) delete process.env.LLM_API_KEY;
+      else process.env.LLM_API_KEY = prevKey;
+    }
+  });
+
+  it("refreshSubProvider re-registers the sub provider when the token changes", async () => {
+    const dir = makeTempDir();
+    mkdirSync(dir, { recursive: true });
+    const authPath = join(dir, "auth.json");
+    // Start with an expired token that has a refresh token available.
+    writeFileSync(
+      authPath,
+      JSON.stringify({ anthropic: { type: "oauth", access: "sk-ant-oat01-old", refresh: "rt-old", expires: Date.now() - 1000 } }),
+      "utf-8",
+    );
+    const prevKey = process.env.LLM_API_KEY;
+    process.env.LLM_API_KEY = "sk-gateway-test";
+    try {
+      const mod = await loadFlantInfraModule(dir);
+      const registered = new Map<string, any>();
+      const pi = {
+        registerProvider: vi.fn((name: string, config: any) => registered.set(name, config)),
+        unregisterProvider: vi.fn((name: string) => registered.delete(name)),
+      } as any;
+
+      // Refresh yields a fresh token, which is what the initial registration reads.
+      refreshAnthropicTokenMock.mockResolvedValueOnce({ access: "sk-ant-oat01-fresh", refresh: "rt-fresh", expires: Date.now() + 3_600_000 });
+      await mod.refreshClaudeOAuthToken();
+      mod.registerFlantProviders(pi, ["claude-opus-4-8"], {}, { subscription: true });
+      expect(registered.get("pp-flant-anthropic-sub").apiKey).toBe("sk-ant-oat01-fresh");
+
+      // A no-op refresh (token unchanged) must not re-register.
+      const callsBefore = pi.registerProvider.mock.calls.length;
+      await mod.refreshSubProvider(pi);
+      expect(pi.registerProvider.mock.calls.length).toBe(callsBefore);
+
+      // Simulate the token expiring and a refresh minting a new one: the sub
+      // provider is re-registered with the new token.
+      writeFileSync(
+        authPath,
+        JSON.stringify({ anthropic: { type: "oauth", access: "sk-ant-oat01-expired", refresh: "rt-fresh", expires: Date.now() - 1000 } }),
+        "utf-8",
+      );
+      refreshAnthropicTokenMock.mockResolvedValueOnce({ access: "sk-ant-oat01-rotated", refresh: "rt-rotated", expires: Date.now() + 3_600_000 });
+      await mod.refreshSubProvider(pi);
+      expect(registered.get("pp-flant-anthropic-sub").apiKey).toBe("sk-ant-oat01-rotated");
+    } finally {
+      if (prevKey === undefined) delete process.env.LLM_API_KEY;
+      else process.env.LLM_API_KEY = prevKey;
+    }
+  });
+
+  it("refreshSubProvider is a no-op when subscription routing is inactive", async () => {
+    const dir = makeTempDir();
+    const mod = await loadFlantInfraModule(dir);
+    const pi = {
+      registerProvider: vi.fn(),
+      unregisterProvider: vi.fn(),
+    } as any;
+    // No registerFlantProviders({ subscription: true }) call happened, so there
+    // is no cached sub-provider context: refresh must do nothing.
+    await mod.refreshSubProvider(pi);
+    expect(pi.registerProvider).not.toHaveBeenCalled();
+  });
+
+  it("readClaudeOAuthToken returns null for expired token", async () => {
+    const dir = makeTempDir();
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, "auth.json"),
+      JSON.stringify({ anthropic: { access: "sk-ant-oat01-old", expires: Date.now() - 1000 } }),
+      "utf-8",
+    );
+    const mod = await loadFlantInfraModule(dir);
+    expect(mod.readClaudeOAuthToken()).toBeNull();
+  });
+
+  it("refreshClaudeOAuthToken returns the current token when not expired", async () => {
+    const dir = makeTempDir();
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, "auth.json"),
+      JSON.stringify({ anthropic: { type: "oauth", access: "sk-ant-oat01-fresh", refresh: "rt", expires: Date.now() + 3_600_000 } }),
+      "utf-8",
+    );
+    const mod = await loadFlantInfraModule(dir);
+    await expect(mod.refreshClaudeOAuthToken()).resolves.toBe("sk-ant-oat01-fresh");
+    expect(refreshAnthropicTokenMock).not.toHaveBeenCalled();
+  });
+
+  it("refreshClaudeOAuthToken refreshes an expired token and persists it", async () => {
+    const dir = makeTempDir();
+    mkdirSync(dir, { recursive: true });
+    const authPath = join(dir, "auth.json");
+    writeFileSync(
+      authPath,
+      JSON.stringify({ anthropic: { type: "oauth", access: "sk-ant-oat01-old", refresh: "rt-old", expires: Date.now() - 1000 } }),
+      "utf-8",
+    );
+    const newExpires = Date.now() + 3_600_000;
+    refreshAnthropicTokenMock.mockResolvedValue({ access: "sk-ant-oat01-new", refresh: "rt-new", expires: newExpires });
+
+    const mod = await loadFlantInfraModule(dir);
+    await expect(mod.refreshClaudeOAuthToken()).resolves.toBe("sk-ant-oat01-new");
+    expect(refreshAnthropicTokenMock).toHaveBeenCalledWith("rt-old");
+
+    const persisted = JSON.parse(readFileSync(authPath, "utf-8"));
+    expect(persisted.anthropic).toMatchObject({
+      type: "oauth",
+      access: "sk-ant-oat01-new",
+      refresh: "rt-new",
+      expires: newExpires,
+    });
+    // A subsequent synchronous read now sees the fresh token.
+    expect(mod.readClaudeOAuthToken()).toBe("sk-ant-oat01-new");
+  });
+
+  it("refreshClaudeOAuthToken returns null when expired and no refresh token present", async () => {
+    const dir = makeTempDir();
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, "auth.json"),
+      JSON.stringify({ anthropic: { type: "oauth", access: "sk-ant-oat01-old", expires: Date.now() - 1000 } }),
+      "utf-8",
+    );
+    const mod = await loadFlantInfraModule(dir);
+    await expect(mod.refreshClaudeOAuthToken()).resolves.toBeNull();
+    expect(refreshAnthropicTokenMock).not.toHaveBeenCalled();
+  });
+
+  it("refreshClaudeOAuthToken returns null when refresh fails", async () => {
+    const dir = makeTempDir();
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, "auth.json"),
+      JSON.stringify({ anthropic: { type: "oauth", access: "sk-ant-oat01-old", refresh: "rt-old", expires: Date.now() - 1000 } }),
+      "utf-8",
+    );
+    refreshAnthropicTokenMock.mockRejectedValue(new Error("refresh boom"));
+    const mod = await loadFlantInfraModule(dir);
+    await expect(mod.refreshClaudeOAuthToken()).resolves.toBeNull();
+  });
+
   it("generateDisplayName formats model ids", async () => {
     const dir = makeTempDir();
     const mod = await loadFlantInfraModule(dir);
@@ -94,6 +305,79 @@ describe("flant-infra", () => {
     expect(config.agents.subagents.presetGroups.planners.presets.regular.agents.gemini.model).toBe("pp-flant-openai/gemini-3-1-pro");
   });
 
+  it("generateFlantConfig routes Claude roles through subs when subscription active", async () => {
+    const dir = makeTempDir();
+    const mod = await loadFlantInfraModule(dir);
+
+    const config = mod.generateFlantConfig(
+      ["claude-opus-4-8", "claude-haiku-4-5", "gpt-5-4", "gemini-3-1-pro", "gemini-3-1-flash"],
+      true,
+    ) as any;
+
+    // Claude roles -> sub provider
+    expect(config.agents.orchestrators.implement.model).toBe("pp-flant-anthropic-sub/sub/claude-opus-4-8");
+    expect(config.agents.orchestrators.plan.model).toBe("pp-flant-anthropic-sub/sub/claude-opus-4-8");
+    expect(config.agents.orchestrators.brainstorm.model).toBe("pp-flant-anthropic-sub/sub/claude-opus-4-8");
+    expect(config.agents.subagents.simple.task.model).toBe("pp-flant-anthropic-sub/sub/claude-opus-4-8");
+    expect(config.agents.subagents.presetGroups.planners.presets.regular.agents.opus.model).toBe("pp-flant-anthropic-sub/sub/claude-opus-4-8");
+    // Non-Claude roles stay on the openai (company-billed) provider
+    expect(config.agents.orchestrators.debug.model).toBe("pp-flant-openai/gpt-5-4");
+    expect(config.agents.subagents.simple.explore.model).toBe("pp-flant-openai/gemini-3-1-flash");
+    expect(config.agents.subagents.presetGroups.planners.presets.regular.agents.gpt.model).toBe("pp-flant-openai/gpt-5-4");
+  });
+
+  it("generateFlantConfig keeps Claude roles on the company provider when subscription inactive", async () => {
+    const dir = makeTempDir();
+    const mod = await loadFlantInfraModule(dir);
+
+    const config = mod.generateFlantConfig(["claude-opus-4-8", "gpt-5-4"], false) as any;
+    expect(config.agents.orchestrators.implement.model).toBe("pp-flant-anthropic/claude-opus-4-8");
+  });
+
+  it("isSubscriptionActive requires flag + oauth token + gateway key", async () => {
+    const dir = makeTempDir();
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, "auth.json"),
+      JSON.stringify({ anthropic: { access: "sk-ant-oat01-test", expires: Date.now() + 3_600_000 } }),
+      "utf-8",
+    );
+    const settingsDir = join(dir, "extensions", "pp", "cache");
+    mkdirSync(settingsDir, { recursive: true });
+    writeFileSync(join(settingsDir, "flant-models.json"), JSON.stringify({ enabled: true, subscription: true }), "utf-8");
+    const prevKey = process.env.LLM_API_KEY;
+    process.env.LLM_API_KEY = "sk-gateway-test";
+    try {
+      const mod = await loadFlantInfraModule(dir);
+      expect(mod.isSubscriptionActive()).toBe(true);
+      expect(mod.isSubscriptionActive({ subscription: false } as any)).toBe(false);
+    } finally {
+      if (prevKey === undefined) delete process.env.LLM_API_KEY;
+      else process.env.LLM_API_KEY = prevKey;
+    }
+  });
+
+  it("isSubscriptionActive is false without a gateway key", async () => {
+    const dir = makeTempDir();
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, "auth.json"),
+      JSON.stringify({ anthropic: { access: "sk-ant-oat01-test", expires: Date.now() + 3_600_000 } }),
+      "utf-8",
+    );
+    const prevKey = process.env.LLM_API_KEY;
+    const prevFlant = process.env.FLANT_API_KEY;
+    delete process.env.LLM_API_KEY;
+    delete process.env.FLANT_API_KEY;
+    try {
+      const mod = await loadFlantInfraModule(dir);
+      expect(mod.isSubscriptionActive({ subscription: true } as any)).toBe(false);
+    } finally {
+      if (prevKey !== undefined) process.env.LLM_API_KEY = prevKey;
+      if (prevFlant !== undefined) process.env.FLANT_API_KEY = prevFlant;
+    }
+  });
+
   it("generateFlantConfig returns empty object for empty models", async () => {
     const dir = makeTempDir();
     const mod = await loadFlantInfraModule(dir);
@@ -143,6 +427,7 @@ describe("flant-infra", () => {
       enabled: false,
       autoUpdate: true,
       cacheTTLDays: 7,
+      subscription: false,
       lastUpdated: null,
       cachedFlantModels: null,
       cachedOpenRouterData: null,
@@ -180,6 +465,7 @@ describe("flant-infra", () => {
       enabled: true,
       autoUpdate: false,
       cacheTTLDays: 3,
+      subscription: false,
       lastUpdated: "2026-01-02T03:04:05.000Z",
       cachedFlantModels: ["gpt-5-4", "claude-opus-4-6"],
       cachedOpenRouterData: {
@@ -202,6 +488,7 @@ describe("flant-infra", () => {
       enabled: true,
       autoUpdate: true,
       cacheTTLDays: 14,
+      subscription: true,
       lastUpdated: "2026-02-01T00:00:00.000Z",
       cachedFlantModels: ["claude-opus-4-6", "gpt-5-4"],
       cachedOpenRouterData: {