@blackbelt-technology/pi-agent-dashboard 0.3.0 → 0.4.1

package/packages/extension/src/__tests__/openspec-poller.test.ts

@@ -1,119 +1,124 @@
+/**
+ * Tests for openspec-poller.ts — the higher-level aggregator that combines
+ * `openspec list` + per-change `openspec status` into the dashboard's
+ * `OpenSpecData` shape.
+ *
+ * The file now delegates to `platform/openspec.ts` for the subprocess work.
+ * We mock that module so the tests focus on the aggregation logic
+ * (empty results, artifact mapping, per-change status failures) without
+ * spawning openspec.
+ *
+ * See change: platform-command-executor.
+ */
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import type { SpawnSyncReturns } from "node:child_process";
-
-// We need to mock spawnSync before importing the module under test
-const mockSpawnSync = vi.fn<(...args: any[]) => any>();
-const mockExecFile = vi.fn<(...args: any[]) => any>();
-vi.mock("node:child_process", () => ({
-  spawnSync: mockSpawnSync,
-  execFile: mockExecFile,
-  // re-export defaults that node:child_process has
-  default: { spawnSync: mockSpawnSync, execFile: mockExecFile },
+
+const { listOr, statusOr } = vi.hoisted(() => ({
+  listOr: vi.fn(),
+  statusOr: vi.fn(),
 }));
 
-// Import after mock is set up
-const { pollOpenSpec } = await import("@blackbelt-technology/pi-dashboard-shared/openspec-poller.js");
-
-function ok(data: unknown): Partial<SpawnSyncReturns<string>> {
-  return { status: 0, stdout: JSON.stringify(data), stderr: "" };
-}
-
-function fail(): Partial<SpawnSyncReturns<string>> {
-  return { status: 1, stdout: "", stderr: "error" };
-}
-
-function mockCli(responses: Map<string, unknown>) {
-  mockSpawnSync.mockImplementation((_cmd: any, args: any) => {
-    const a = args as string[];
-    if (a.includes("list")) {
-      const d = responses.get("list");
-      return d ? ok(d) : fail();
-    }
-    if (a.includes("status")) {
-      const idx = a.indexOf("--change");
-      const name = idx >= 0 ? a[idx + 1] : "";
-      const d = responses.get(`status:${name}`);
-      return d ? ok(d) : fail();
-    }
-    return fail();
-  });
-}
+vi.mock("@blackbelt-technology/pi-dashboard-shared/platform/openspec.js", () => ({
+  listOr,
+  statusOr,
+}));
 
-beforeEach(() => {
-  mockSpawnSync.mockReset();
-});
+import { pollOpenSpec } from "@blackbelt-technology/pi-dashboard-shared/openspec-poller.js";
 
 describe("pollOpenSpec", () => {
-  it("returns initialized=false when CLI throws", () => {
-    mockSpawnSync.mockImplementation(() => { throw new Error("ENOENT"); });
-    const result = pollOpenSpec("/project");
-    expect(result).toEqual({ initialized: false, changes: [] });
+  beforeEach(() => {
+    listOr.mockReset();
+    statusOr.mockReset();
   });
 
-  it("returns initialized=false when list returns non-zero exit", () => {
-    mockSpawnSync.mockReturnValue(fail());
-    const result = pollOpenSpec("/project");
-    expect(result).toEqual({ initialized: false, changes: [] });
+  it("returns initialized=false when list fails", () => {
+    listOr.mockReturnValue(null);
+    expect(pollOpenSpec("/test")).toEqual({ initialized: false, changes: [] });
+  });
+
+  it("returns initialized=false when list returns non-array changes", () => {
+    listOr.mockReturnValue({ changes: "not an array" });
+    expect(pollOpenSpec("/test")).toEqual({ initialized: false, changes: [] });
   });
 
   it("returns initialized=true with changes on success", () => {
-    mockCli(new Map([
-      ["list", {
-        changes: [
-          { name: "feat-a", status: "in-progress", completedTasks: 3, totalTasks: 5 },
-          { name: "feat-b", status: "complete", completedTasks: 4, totalTasks: 4 },
-        ],
-      }],
-      ["status:feat-a", {
-        artifacts: [
-          { id: "proposal", status: "done" },
-          { id: "design", status: "ready" },
-          { id: "tasks", status: "blocked" },
-        ],
-      }],
-      ["status:feat-b", {
-        artifacts: [
-          { id: "proposal", status: "done" },
-          { id: "tasks", status: "done" },
-        ],
-      }],
-    ]));
-
-    const result = pollOpenSpec("/project");
-    expect(result.initialized).toBe(true);
-    expect(result.changes).toHaveLength(2);
-    expect(result.changes[0]).toEqual({
-      name: "feat-a",
-      status: "in-progress",
-      completedTasks: 3,
-      totalTasks: 5,
+    listOr.mockReturnValue({
+      changes: [
+        { name: "add-auth", status: "in-progress", completedTasks: 3, totalTasks: 10 },
+      ],
+    });
+    statusOr.mockReturnValue({
       artifacts: [
         { id: "proposal", status: "done" },
-        { id: "design", status: "ready" },
-        { id: "tasks", status: "blocked" },
+        { id: "tasks", status: "ready" },
       ],
     });
-    expect(result.changes[1].status).toBe("complete");
-  });
 
-  it("handles invalid JSON gracefully", () => {
-    mockSpawnSync.mockReturnValue({ status: 0, stdout: "not json {{{", stderr: "" });
-    const result = pollOpenSpec("/project");
-    expect(result).toEqual({ initialized: false, changes: [] });
+    const result = pollOpenSpec("/test");
+    expect(result.initialized).toBe(true);
+    expect(result.changes).toHaveLength(1);
+    expect(result.changes[0]).toMatchObject({
+      name: "add-auth",
+      status: "in-progress",
+      completedTasks: 3,
+      totalTasks: 10,
+    });
+    expect(result.changes[0].artifacts).toEqual([
+      { id: "proposal", status: "done" },
+      { id: "tasks", status: "ready" },
+    ]);
   });
 
   it("handles status call failure gracefully (empty artifacts)", () => {
-    mockCli(new Map([
-      ["list", {
-        changes: [
-          { name: "feat-a", status: "no-tasks", completedTasks: 0, totalTasks: 0 },
-        ],
-      }],
-      // No status:feat-a — status call fails
-    ]));
-
-    const result = pollOpenSpec("/project");
+    listOr.mockReturnValue({
+      changes: [
+        { name: "x", status: "complete", completedTasks: 5, totalTasks: 5 },
+      ],
+    });
+    statusOr.mockReturnValue(null); // status failed
+
+    const result = pollOpenSpec("/test");
     expect(result.initialized).toBe(true);
     expect(result.changes[0].artifacts).toEqual([]);
   });
+
+  it("normalizes unknown status values to 'no-tasks'", () => {
+    listOr.mockReturnValue({
+      changes: [
+        { name: "x", status: "weird-future-status", completedTasks: 0, totalTasks: 0 },
+      ],
+    });
+    statusOr.mockReturnValue(null);
+
+    const result = pollOpenSpec("/test");
+    expect(result.changes[0].status).toBe("no-tasks");
+  });
+
+  it("normalizes unknown artifact statuses to 'blocked'", () => {
+    listOr.mockReturnValue({
+      changes: [
+        { name: "x", status: "in-progress", completedTasks: 0, totalTasks: 1 },
+      ],
+    });
+    statusOr.mockReturnValue({
+      artifacts: [{ id: "proposal", status: "some-new-state" }],
+    });
+
+    const result = pollOpenSpec("/test");
+    expect(result.changes[0].artifacts[0].status).toBe("blocked");
+  });
+
+  it("calls statusOr once per change, with the change name", () => {
+    listOr.mockReturnValue({
+      changes: [
+        { name: "a", status: "in-progress", completedTasks: 0, totalTasks: 1 },
+        { name: "b", status: "complete", completedTasks: 2, totalTasks: 2 },
+      ],
+    });
+    statusOr.mockReturnValue({ artifacts: [] });
+
+    pollOpenSpec("/test");
+    expect(statusOr).toHaveBeenCalledTimes(2);
+    expect(statusOr).toHaveBeenNthCalledWith(1, { cwd: "/test", change: "a" });
+    expect(statusOr).toHaveBeenNthCalledWith(2, { cwd: "/test", change: "b" });
+  });
 });

package/packages/extension/src/__tests__/process-scanner-kill.test.ts

@@ -0,0 +1,61 @@
+/**
+ * Tests that `killProcessByPgid` routes through the platform's
+ * `killPidWithGroup` helper (not raw `process.kill`).
+ *
+ * See change: route-kill-paths-through-platform.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const killPidWithGroupSpy = vi.fn((_pid: number, _sig: any, _opts?: any) => undefined);
+
+vi.mock("@blackbelt-technology/pi-dashboard-shared/platform/process.js", async () => {
+  const actual = await vi.importActual<typeof import("@blackbelt-technology/pi-dashboard-shared/platform/process.js")>(
+    "@blackbelt-technology/pi-dashboard-shared/platform/process.js",
+  );
+  return {
+    ...actual,
+    killPidWithGroup: (pid: number, sig: any, opts?: any) => killPidWithGroupSpy(pid, sig, opts),
+  };
+});
+
+const { killProcessByPgid } = await import("../process-scanner.js");
+
+describe("killProcessByPgid platform routing", () => {
+  beforeEach(() => {
+    killPidWithGroupSpy.mockClear();
+  });
+
+  it("invokes killPidWithGroup with the resolved platform on Unix", () => {
+    const ok = killProcessByPgid(4242, { _platform: "linux" } as any);
+    expect(ok).toBe(true);
+    expect(killPidWithGroupSpy).toHaveBeenCalledTimes(1);
+    const [pid, sig, opts] = killPidWithGroupSpy.mock.calls[0];
+    expect(pid).toBe(4242);
+    expect(sig).toBe("SIGTERM");
+    expect(opts?.platform).toBe("linux");
+  });
+
+  it("invokes killPidWithGroup with platform=darwin for macOS pgids", () => {
+    killProcessByPgid(9999, { _platform: "darwin" } as any);
+    const [pid, , opts] = killPidWithGroupSpy.mock.calls[0];
+    expect(pid).toBe(9999);
+    expect(opts?.platform).toBe("darwin");
+  });
+
+  it("does NOT call process.kill directly on Unix", () => {
+    const processKillSpy = vi.spyOn(process, "kill");
+    try {
+      killProcessByPgid(1234, { _platform: "linux" } as any);
+    } catch { /* ignore */ }
+    expect(processKillSpy).not.toHaveBeenCalled();
+    processKillSpy.mockRestore();
+  });
+
+  it("reports failure if killPidWithGroup throws", () => {
+    killPidWithGroupSpy.mockImplementationOnce(() => {
+      throw new Error("ESRCH");
+    });
+    const ok = killProcessByPgid(4242, { _platform: "linux" } as any);
+    expect(ok).toBe(false);
+  });
+});

package/packages/extension/src/__tests__/provider-register-reload.test.ts

@@ -0,0 +1,394 @@
+/**
+ * Tests for the provider-register hot-reload path.
+ *
+ * `reloadProviders(pi)` diffs the current providers.json against a
+ * last-registered snapshot and calls pi.registerProvider / pi.unregisterProvider
+ * as needed. Async model discovery is stubbed via a fetch mock.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// We re-import the module fresh in each test so module-level `lastRegistered`
+// state starts empty.
+async function importFresh() {
+  vi.resetModules();
+  return (await import("../provider-register.js")) as typeof import("../provider-register.js");
+}
+
+function makeMockPi() {
+  const registerProvider = vi.fn();
+  const unregisterProvider = vi.fn();
+  const pi = {
+    registerProvider,
+    unregisterProvider,
+    events: { on: vi.fn(), emit: vi.fn() },
+    on: vi.fn(),
+  } as any;
+  return { pi, registerProvider, unregisterProvider };
+}
+
+function writeProvidersJson(home: string, providers: Record<string, any>) {
+  const dir = join(home, ".pi", "agent");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    join(dir, "providers.json"),
+    JSON.stringify({ providers }, null, 2),
+    "utf-8",
+  );
+}
+
+describe("reloadProviders", () => {
+  let tmpHome: string;
+  const originalHome = process.env.HOME;
+  const originalFetch = globalThis.fetch;
+
+  beforeEach(() => {
+    tmpHome = mkdtempSync(join(tmpdir(), "provider-reload-"));
+    process.env.HOME = tmpHome;
+    // Stub fetch to return 2 models so discovery succeeds cheaply
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify({ data: [{ id: "m1" }, { id: "m2" }] }), { status: 200 }),
+    ) as any;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    process.env.HOME = originalHome;
+    rmSync(tmpHome, { recursive: true, force: true });
+  });
+
+  it("adds a new provider when providers.json gains an entry (snapshot was empty)", async () => {
+    const mod = await importFresh();
+    const { pi, registerProvider, unregisterProvider } = makeMockPi();
+
+    writeProvidersJson(tmpHome, {
+      "my-llm": {
+        baseUrl: "https://api.example.com/v1",
+        apiKey: "sk-abc",
+        api: "openai-completions",
+      },
+    });
+
+    const diff = await mod.reloadProviders(pi);
+    expect(diff.added).toEqual(["my-llm"]);
+    expect(diff.removed).toEqual([]);
+    expect(diff.changed).toEqual([]);
+    expect(registerProvider).toHaveBeenCalledTimes(1);
+    expect(registerProvider).toHaveBeenCalledWith("my-llm", expect.objectContaining({
+      baseUrl: "https://api.example.com/v1",
+      api: "openai-completions",
+    }));
+    expect(unregisterProvider).not.toHaveBeenCalled();
+  });
+
+  it("removes a provider when its entry disappears from providers.json", async () => {
+    const mod = await importFresh();
+    const { pi, registerProvider, unregisterProvider } = makeMockPi();
+
+    writeProvidersJson(tmpHome, {
+      "my-llm": { baseUrl: "https://x", apiKey: "k", api: "openai-completions" },
+    });
+    await mod.reloadProviders(pi);
+    expect(registerProvider).toHaveBeenCalledTimes(1);
+
+    writeProvidersJson(tmpHome, {});
+    const diff = await mod.reloadProviders(pi);
+
+    expect(diff.removed).toEqual(["my-llm"]);
+    expect(diff.added).toEqual([]);
+    expect(unregisterProvider).toHaveBeenCalledTimes(1);
+    expect(unregisterProvider).toHaveBeenCalledWith("my-llm");
+  });
+
+  it("re-registers (unregister then register) when baseUrl changes", async () => {
+    const mod = await importFresh();
+    const { pi, registerProvider, unregisterProvider } = makeMockPi();
+
+    writeProvidersJson(tmpHome, {
+      "my-llm": { baseUrl: "https://old.example.com/v1", apiKey: "k", api: "openai-completions" },
+    });
+    await mod.reloadProviders(pi);
+    expect(registerProvider).toHaveBeenCalledTimes(1);
+
+    writeProvidersJson(tmpHome, {
+      "my-llm": { baseUrl: "https://new.example.com/v1", apiKey: "k", api: "openai-completions" },
+    });
+    const diff = await mod.reloadProviders(pi);
+
+    expect(diff.changed).toEqual(["my-llm"]);
+    // unregister must be called before the second register
+    const unregOrder = unregisterProvider.mock.invocationCallOrder[0];
+    const reg2Order = registerProvider.mock.invocationCallOrder[1];
+    expect(unregOrder).toBeLessThan(reg2Order);
+    expect(registerProvider).toHaveBeenLastCalledWith(
+      "my-llm",
+      expect.objectContaining({ baseUrl: "https://new.example.com/v1" }),
+    );
+  });
+
+  it("unchanged providers.json produces no register/unregister calls on second reload", async () => {
+    const mod = await importFresh();
+    const { pi, registerProvider, unregisterProvider } = makeMockPi();
+
+    writeProvidersJson(tmpHome, {
+      "my-llm": { baseUrl: "https://x", apiKey: "k", api: "openai-completions" },
+    });
+    await mod.reloadProviders(pi);
+    registerProvider.mockClear();
+    unregisterProvider.mockClear();
+
+    const diff = await mod.reloadProviders(pi);
+    expect(diff.added).toEqual([]);
+    expect(diff.removed).toEqual([]);
+    expect(diff.changed).toEqual([]);
+    expect(registerProvider).not.toHaveBeenCalled();
+    expect(unregisterProvider).not.toHaveBeenCalled();
+  });
+
+  it("malformed providers.json returns empty diff and does not throw", async () => {
+    const mod = await importFresh();
+    const { pi } = makeMockPi();
+
+    const dir = join(tmpHome, ".pi", "agent");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "providers.json"), "not valid json {", "utf-8");
+
+    await expect(mod.reloadProviders(pi)).resolves.toEqual({
+      added: [],
+      removed: [],
+      changed: [],
+    });
+  });
+
+  it("treats apiKey change as 'changed'", async () => {
+    const mod = await importFresh();
+    const { pi, registerProvider, unregisterProvider } = makeMockPi();
+
+    writeProvidersJson(tmpHome, {
+      "my-llm": { baseUrl: "https://x", apiKey: "old", api: "openai-completions" },
+    });
+    await mod.reloadProviders(pi);
+
+    writeProvidersJson(tmpHome, {
+      "my-llm": { baseUrl: "https://x", apiKey: "new", api: "openai-completions" },
+    });
+    const diff = await mod.reloadProviders(pi);
+    expect(diff.changed).toEqual(["my-llm"]);
+    expect(unregisterProvider).toHaveBeenCalledWith("my-llm");
+  });
+
+  it("treats api type change as 'changed'", async () => {
+    const mod = await importFresh();
+    const { pi } = makeMockPi();
+
+    writeProvidersJson(tmpHome, {
+      "my-llm": { baseUrl: "https://x", apiKey: "k", api: "openai-completions" },
+    });
+    await mod.reloadProviders(pi);
+
+    writeProvidersJson(tmpHome, {
+      "my-llm": { baseUrl: "https://x", apiKey: "k", api: "openai-responses" },
+    });
+    const diff = await mod.reloadProviders(pi);
+    expect(diff.changed).toEqual(["my-llm"]);
+  });
+
+  // ── input capability default (see change: enable-image-input-custom-providers) ─────
+  // Every discovered model must advertise `input: ["text", "image"]` so pi-ai does
+  // not strip pasted images via `downgradeUnsupportedImages` before the request
+  // leaves the bridge. This guards both the initial-registration path and the
+  // reloadProviders() re-register path.
+
+  it("discovered models default to input: [\"text\", \"image\"] on fresh register", async () => {
+    const mod = await importFresh();
+    const { pi, registerProvider } = makeMockPi();
+
+    writeProvidersJson(tmpHome, {
+      "my-llm": {
+        baseUrl: "https://api.example.com/v1",
+        apiKey: "sk-abc",
+        api: "openai-completions",
+      },
+    });
+
+    await mod.reloadProviders(pi);
+
+    expect(registerProvider).toHaveBeenCalledTimes(1);
+    const [, config] = registerProvider.mock.calls[0];
+    expect(Array.isArray(config.models)).toBe(true);
+    expect(config.models.length).toBe(2); // two models from the fetch stub
+    for (const m of config.models) {
+      expect(m.input).toEqual(["text", "image"]);
+    }
+  });
+
+  it("re-registered models (after reload diff) retain input: [\"text\", \"image\"]", async () => {
+    const mod = await importFresh();
+    const { pi, registerProvider } = makeMockPi();
+
+    // Initial register
+    writeProvidersJson(tmpHome, {
+      "my-llm": { baseUrl: "https://old.example.com/v1", apiKey: "k", api: "openai-completions" },
+    });
+    await mod.reloadProviders(pi);
+
+    // Change baseUrl → triggers unregister + re-register
+    writeProvidersJson(tmpHome, {
+      "my-llm": { baseUrl: "https://new.example.com/v1", apiKey: "k", api: "openai-completions" },
+    });
+    const diff = await mod.reloadProviders(pi);
+    expect(diff.changed).toEqual(["my-llm"]);
+
+    // Second registerProvider call is the re-register; must carry same input default
+    expect(registerProvider).toHaveBeenCalledTimes(2);
+    const [, secondConfig] = registerProvider.mock.calls[1];
+    for (const m of secondConfig.models) {
+      expect(m.input).toEqual(["text", "image"]);
+    }
+  });
+
+  // ── model metadata enrichment (see change: enrich-custom-provider-model-metadata) ──
+  // registerEntry() resolves per-model metadata via enrichModelMetadata() which
+  // consults pi-ai's bundled catalog. These tests verify the end-to-end path:
+  // discovered id → catalog match → registerProvider receives accurate fields.
+
+  it("captures ctx.modelRegistry from session_start and re-registers providers with enriched metadata", async () => {
+    const mod = await importFresh();
+    const { pi, registerProvider } = makeMockPi();
+
+    // Capture the session_start handler registered by activate().
+    const handlers = new Map<string, (event: any, ctx: any) => Promise<void> | void>();
+    pi.on = vi.fn((event: string, handler: any) => {
+      handlers.set(event, handler);
+    });
+
+    // Fake pi's ModelRegistry. `find(provider, id)` returns Opus 4.7's real
+    // metadata for the anthropic entry, simulating what pi passes via
+    // ctx.modelRegistry at session_start.
+    const fakeRegistry = {
+      find: vi.fn((provider: string, id: string) => {
+        if (provider === "anthropic" && id === "claude-opus-4-7") {
+          return {
+            contextWindow: 1_000_000,
+            maxTokens: 128_000,
+            reasoning: true,
+            cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+            input: ["text", "image"],
+          };
+        }
+        return null;
+      }),
+    };
+
+    // Fetch mock advertises the real model id.
+    globalThis.fetch = vi.fn(async () =>
+      new Response(
+        JSON.stringify({ data: [{ id: "cc/claude-opus-4-7" }] }),
+        { status: 200 },
+      ),
+    ) as any;
+
+    writeProvidersJson(tmpHome, {
+      proxy: {
+        baseUrl: "https://llmproxy.example.com/v1",
+        apiKey: "sk-test",
+        api: "anthropic-messages",
+      },
+    });
+
+    // 1) activate() registers the provider BEFORE ctx.modelRegistry is
+    //    available — first registration hits the fallback path.
+    mod.activate(pi);
+    // Wait a microtask for the fire-and-forget registerEntry inside activate.
+    await new Promise((r) => setTimeout(r, 10));
+
+    expect(registerProvider).toHaveBeenCalledTimes(1);
+    const firstCall = registerProvider.mock.calls[0];
+    expect(firstCall[1].models[0].contextWindow).toBe(200_000); // fallback
+
+    // 2) Fire session_start with ctx.modelRegistry — the handler captures it
+    //    and re-registers all known providers with the enriched metadata.
+    const sessionStartHandler = handlers.get("session_start");
+    expect(sessionStartHandler).toBeDefined();
+    await sessionStartHandler!({ type: "session_start" }, {
+      ui: { notify: vi.fn() },
+      modelRegistry: fakeRegistry,
+      model: undefined,
+    });
+
+    // 3) The re-registration should have issued a second registerProvider
+    //    call, this time with the catalog-enriched metadata.
+    expect(registerProvider).toHaveBeenCalledTimes(2);
+    const secondCall = registerProvider.mock.calls[1];
+    const [name, config] = secondCall;
+    expect(name).toBe("proxy");
+    const [opus] = config.models;
+    expect(opus.id).toBe("cc/claude-opus-4-7");
+    expect(opus.contextWindow).toBe(1_000_000);
+    expect(opus.maxTokens).toBe(128_000);
+    expect(opus.reasoning).toBe(true);
+    expect(opus.cost.input).toBe(5);
+    expect(opus.cost.output).toBe(25);
+    // Probed with prefix-stripped bare id under `anthropic`.
+    expect(fakeRegistry.find).toHaveBeenCalledWith("anthropic", "claude-opus-4-7");
+  });
+
+  it("without modelRegistry (never captured), discovered models fall back to api-appropriate defaults", async () => {
+    const mod = await importFresh();
+    const { pi, registerProvider } = makeMockPi();
+
+    // No session_start fires — modelRegistryRef stays null and the probe is
+    // null, so every discovered id hits the fallback table.
+    globalThis.fetch = vi.fn(async () =>
+      new Response(
+        JSON.stringify({ data: [{ id: "cc/claude-opus-4-7" }] }),
+        { status: 200 },
+      ),
+    ) as any;
+
+    writeProvidersJson(tmpHome, {
+      proxy: {
+        baseUrl: "https://llmproxy.example.com/v1",
+        apiKey: "sk-test",
+        api: "anthropic-messages",
+      },
+    });
+
+    await mod.reloadProviders(pi);
+
+    const [, config] = registerProvider.mock.calls[0];
+    const [opus] = config.models;
+    // anthropic-messages fallback: 200k / 64k / no reasoning / zero cost / text+image.
+    expect(opus.contextWindow).toBe(200_000);
+    expect(opus.maxTokens).toBe(64_000);
+    expect(opus.reasoning).toBe(false);
+    expect(opus.input).toEqual(["text", "image"]);
+  });
+
+  it("discovered unknown model falls back to api-appropriate defaults (openai-completions → 128k)", async () => {
+    const mod = await importFresh();
+    const { pi, registerProvider } = makeMockPi();
+
+    // Default beforeEach fetch stub returns `m1` and `m2` — neither exists in catalog.
+    writeProvidersJson(tmpHome, {
+      "my-llm": {
+        baseUrl: "https://api.example.com/v1",
+        apiKey: "sk-abc",
+        api: "openai-completions",
+      },
+    });
+
+    await mod.reloadProviders(pi);
+
+    const [, config] = registerProvider.mock.calls[0];
+    for (const m of config.models) {
+      expect(m.contextWindow).toBe(128_000);
+      expect(m.maxTokens).toBe(16_384);
+      expect(m.reasoning).toBe(false);
+      expect(m.cost).toEqual({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+      expect(m.input).toEqual(["text", "image"]);
+    }
+  });
+});