test: add plan-based model routing tests (14 cases)

- model-store: plan map build, reverse index, plan updates, non-Codex
slug filtering, gpt-oss admission, store debug output
- account-pool: plan-matched acquire, team-only rejection, fallback
on empty plans, plan map update re-routing, preference ordering

Covers the exact code path where free accounts get blocked from models
that the backend has since opened to free tier (gpt-5.4 case).

src/auth/__tests__/plan-routing-acquire.test.ts

@@ -0,0 +1,142 @@
+/**
+ * Tests that account-pool correctly routes requests based on model→plan mapping.
+ *
+ * Verifies the critical path: when a model is available to both free and team,
+ * free accounts should be selected. When only team has it, free accounts must
+ * NOT be used (return null instead of wrong account).
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Mock getModelPlanTypes to control plan routing
+const mockGetModelPlanTypes = vi.fn<(id: string) => string[]>(() => []);
+
+vi.mock("../../models/model-store.js", () => ({
+  getModelPlanTypes: (...args: unknown[]) => mockGetModelPlanTypes(args[0] as string),
+}));
+
+vi.mock("../../config.js", () => ({
+  getConfig: vi.fn(() => ({
+    server: { account_strategy: "round_robin" },
+    auth: { jwt_token: "" },
+  })),
+}));
+
+// Control planType by returning it from extractUserProfile
+let profileForToken: Record<string, { chatgpt_plan_type: string; email: string }> = {};
+
+vi.mock("../../auth/jwt-utils.js", () => ({
+  isTokenExpired: vi.fn(() => false),
+  decodeJwtPayload: vi.fn(() => ({})),
+  extractChatGptAccountId: vi.fn((token: string) => `aid-${token}`),
+  extractUserProfile: vi.fn((token: string) => profileForToken[token] ?? null),
+}));
+
+vi.mock("../../utils/jitter.js", () => ({
+  jitter: vi.fn((val: number) => val),
+}));
+
+vi.mock("fs", () => ({
+  readFileSync: vi.fn(() => JSON.stringify({ accounts: [] })),
+  writeFileSync: vi.fn(),
+  existsSync: vi.fn(() => false),
+  mkdirSync: vi.fn(),
+}));
+
+import { AccountPool } from "../account-pool.js";
+
+function createPool(...accounts: Array<{ token: string; planType: string; email: string }>) {
+  // Set up profile mocks before creating pool
+  profileForToken = {};
+  for (const a of accounts) {
+    profileForToken[a.token] = { chatgpt_plan_type: a.planType, email: a.email };
+  }
+
+  const pool = new AccountPool();
+  for (const a of accounts) {
+    pool.addAccount(a.token);
+  }
+  return pool;
+}
+
+describe("account-pool plan-based routing", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    profileForToken = {};
+  });
+
+  it("returns null when model only supports team but only free accounts exist", () => {
+    mockGetModelPlanTypes.mockReturnValue(["team"]);
+    const pool = createPool(
+      { token: "tok-free", planType: "free", email: "free@test.com" },
+    );
+
+    const acquired = pool.acquire({ model: "gpt-5.4" });
+    expect(acquired).toBeNull();
+  });
+
+  it("acquires team account when model only supports team", () => {
+    mockGetModelPlanTypes.mockReturnValue(["team"]);
+    const pool = createPool(
+      { token: "tok-free", planType: "free", email: "free@test.com" },
+      { token: "tok-team", planType: "team", email: "team@test.com" },
+    );
+
+    const acquired = pool.acquire({ model: "gpt-5.4" });
+    expect(acquired).not.toBeNull();
+    expect(acquired!.token).toBe("tok-team");
+  });
+
+  it("uses any account when model has no known plan requirements", () => {
+    mockGetModelPlanTypes.mockReturnValue([]);
+    const pool = createPool(
+      { token: "tok-free", planType: "free", email: "free@test.com" },
+    );
+
+    const acquired = pool.acquire({ model: "unknown-model" });
+    expect(acquired).not.toBeNull();
+  });
+
+  it("after plan map update, free account can access previously team-only model", () => {
+    const pool = createPool(
+      { token: "tok-free", planType: "free", email: "free@test.com" },
+    );
+
+    // Initially: gpt-5.4 only for team
+    mockGetModelPlanTypes.mockReturnValue(["team"]);
+    const before = pool.acquire({ model: "gpt-5.4" });
+    expect(before).toBeNull(); // blocked
+
+    // Backend updates: gpt-5.4 now available for free too
+    mockGetModelPlanTypes.mockReturnValue(["free", "team"]);
+    const after = pool.acquire({ model: "gpt-5.4" });
+    expect(after).not.toBeNull();
+    expect(after!.token).toBe("tok-free");
+  });
+
+  it("prefers plan-matched accounts over others", () => {
+    mockGetModelPlanTypes.mockReturnValue(["team"]);
+    const pool = createPool(
+      { token: "tok-free1", planType: "free", email: "free1@test.com" },
+      { token: "tok-free2", planType: "free", email: "free2@test.com" },
+      { token: "tok-team", planType: "team", email: "team@test.com" },
+    );
+
+    const acquired = pool.acquire({ model: "gpt-5.4" });
+    expect(acquired).not.toBeNull();
+    expect(acquired!.token).toBe("tok-team");
+  });
+
+  it("acquires free account when model supports both free and team", () => {
+    mockGetModelPlanTypes.mockReturnValue(["free", "team"]);
+    const pool = createPool(
+      { token: "tok-free", planType: "free", email: "free@test.com" },
+      { token: "tok-team", planType: "team", email: "team@test.com" },
+    );
+
+    const acquired = pool.acquire({ model: "gpt-5.4" });
+    expect(acquired).not.toBeNull();
+    // Both are valid candidates, should get one of them
+    expect(["tok-free", "tok-team"]).toContain(acquired!.token);
+  });
+});

src/models/__tests__/plan-routing.test.ts

@@ -0,0 +1,160 @@
+/**
+ * Tests for plan-based model routing.
+ *
+ * Verifies that:
+ * 1. applyBackendModelsForPlan correctly builds planModelMap
+ * 2. getModelPlanTypes returns correct plan associations
+ * 3. When both free and team plans include a model, both are returned
+ * 4. Account pool respects plan routing when acquiring accounts
+ */
+
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("../../config.js", () => ({
+  getConfig: vi.fn(() => ({
+    server: {},
+    model: {},
+    api: { base_url: "https://chatgpt.com/backend-api" },
+    client: { app_version: "1.0.0" },
+  })),
+}));
+
+vi.mock("fs", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("fs")>();
+  return {
+    ...actual,
+    readFileSync: vi.fn(() => "models: []"),
+    writeFileSync: vi.fn(),
+    writeFile: vi.fn((_p: string, _d: string, _e: string, cb: (err: Error | null) => void) => cb(null)),
+    existsSync: vi.fn(() => false),
+    mkdirSync: vi.fn(),
+  };
+});
+
+vi.mock("js-yaml", () => ({
+  default: {
+    load: vi.fn(() => ({ models: [], aliases: {} })),
+    dump: vi.fn(() => ""),
+  },
+}));
+
+import {
+  loadStaticModels,
+  applyBackendModelsForPlan,
+  getModelPlanTypes,
+  getModelStoreDebug,
+} from "../model-store.js";
+
+// Minimal backend model entry matching what Codex API returns
+function makeModel(slug: string) {
+  return { slug, id: slug, name: slug };
+}
+
+describe("plan-based model routing", () => {
+  beforeEach(() => {
+    // Reset model store state by reloading empty static catalog
+    loadStaticModels();
+  });
+
+  it("applyBackendModelsForPlan registers models for a plan", () => {
+    applyBackendModelsForPlan("free", [
+      makeModel("gpt-5.2-codex"),
+      makeModel("gpt-5.4"),
+    ]);
+
+    expect(getModelPlanTypes("gpt-5.2-codex")).toContain("free");
+    expect(getModelPlanTypes("gpt-5.4")).toContain("free");
+  });
+
+  it("models available in both plans return both plan types", () => {
+    applyBackendModelsForPlan("free", [
+      makeModel("gpt-5.2-codex"),
+      makeModel("gpt-5.4"),
+    ]);
+    applyBackendModelsForPlan("team", [
+      makeModel("gpt-5.2-codex"),
+      makeModel("gpt-5.4"),
+      makeModel("gpt-5.4-mini"),
+    ]);
+
+    const plans54 = getModelPlanTypes("gpt-5.4");
+    expect(plans54).toContain("free");
+    expect(plans54).toContain("team");
+
+    const plansCodex = getModelPlanTypes("gpt-5.2-codex");
+    expect(plansCodex).toContain("free");
+    expect(plansCodex).toContain("team");
+  });
+
+  it("model only in team plan does not include free", () => {
+    applyBackendModelsForPlan("free", [
+      makeModel("gpt-5.2-codex"),
+    ]);
+    applyBackendModelsForPlan("team", [
+      makeModel("gpt-5.2-codex"),
+      makeModel("gpt-5.4"),
+    ]);
+
+    const plans54 = getModelPlanTypes("gpt-5.4");
+    expect(plans54).toContain("team");
+    expect(plans54).not.toContain("free");
+  });
+
+  it("replacing a plan's models updates the index", () => {
+    // Initially free doesn't have gpt-5.4
+    applyBackendModelsForPlan("free", [makeModel("gpt-5.2-codex")]);
+    expect(getModelPlanTypes("gpt-5.4")).not.toContain("free");
+
+    // Backend now returns gpt-5.4 for free → re-fetch
+    applyBackendModelsForPlan("free", [
+      makeModel("gpt-5.2-codex"),
+      makeModel("gpt-5.4"),
+    ]);
+    expect(getModelPlanTypes("gpt-5.4")).toContain("free");
+  });
+
+  it("unknown model returns empty plan list", () => {
+    applyBackendModelsForPlan("free", [makeModel("gpt-5.2-codex")]);
+    expect(getModelPlanTypes("nonexistent-model")).toEqual([]);
+  });
+
+  it("non-Codex model slugs are filtered out", () => {
+    applyBackendModelsForPlan("free", [
+      makeModel("gpt-5.2-codex"),
+      makeModel("research"),           // not Codex-compatible
+      makeModel("gpt-5-2"),            // hyphen instead of dot
+      makeModel("some-internal-slug"), // not Codex-compatible
+    ]);
+
+    expect(getModelPlanTypes("gpt-5.2-codex")).toContain("free");
+    expect(getModelPlanTypes("research")).toEqual([]);
+    expect(getModelPlanTypes("gpt-5-2")).toEqual([]);
+    expect(getModelPlanTypes("some-internal-slug")).toEqual([]);
+  });
+
+  it("gpt-oss-* models are admitted", () => {
+    applyBackendModelsForPlan("free", [
+      makeModel("gpt-oss-120b"),
+      makeModel("gpt-oss-20b"),
+    ]);
+
+    expect(getModelPlanTypes("gpt-oss-120b")).toContain("free");
+    expect(getModelPlanTypes("gpt-oss-20b")).toContain("free");
+  });
+
+  it("planMap in store info reflects current state", () => {
+    applyBackendModelsForPlan("free", [
+      makeModel("gpt-5.2-codex"),
+      makeModel("gpt-5.4"),
+    ]);
+    applyBackendModelsForPlan("team", [
+      makeModel("gpt-5.4"),
+    ]);
+
+    const info = getModelStoreDebug();
+    expect(info.planMap.free).toContain("gpt-5.2-codex");
+    expect(info.planMap.free).toContain("gpt-5.4");
+    expect(info.planMap.team).toContain("gpt-5.4");
+    expect(info.planMap.team).not.toContain("gpt-5.2-codex");
+  });
+});