@oh-my-pi/pi-coding-agent 17.1.5 → 17.1.7

package/src/advisor/__tests__/config.test.ts

@@ -1,349 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import * as fsp from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import {
-	advisorConfigFilePath,
-	discoverAdvisorConfigs,
-	getOrCreateAdvisorProviderSessionId,
-	loadWatchdogConfigFile,
-	resolveAdvisorConfigEditPath,
-	saveWatchdogConfigFile,
-	serializeWatchdogConfig,
-	slugifyAdvisorName,
-	type WatchdogConfigDoc,
-} from "../config";
-
-describe("discoverAdvisorConfigs", () => {
-	let tmp: string;
-	let agentDir: string;
-
-	beforeEach(async () => {
-		tmp = await fsp.mkdtemp(path.join(os.tmpdir(), "omp-advisor-config-"));
-		// Empty agent dir so the user-level search path can't pick up a real ~/.omp/WATCHDOG.yml.
-		agentDir = await fsp.mkdtemp(path.join(os.tmpdir(), "omp-advisor-agentdir-"));
-	});
-
-	afterEach(async () => {
-		await fsp.rm(tmp, { recursive: true, force: true });
-		await fsp.rm(agentDir, { recursive: true, force: true });
-	});
-
-	it("parses advisors, the model thinking suffix, tool filtering, and shared instructions", async () => {
-		const yaml = [
-			"instructions: Shared baseline for all advisors.",
-			"advisors:",
-			"  - name: Architecture",
-			"    model: x-ai/grok-code-fast:high",
-			"    instructions: Watch module boundaries.",
-			"  - name: Security Reviewer",
-			"    tools: [read, definitely-not-a-tool]",
-		].join("\n");
-		await Bun.write(path.join(tmp, "WATCHDOG.yml"), yaml);
-
-		const { advisors, sharedInstructions } = await discoverAdvisorConfigs(tmp, agentDir);
-		expect(advisors).toHaveLength(2);
-		const [arch, sec] = advisors;
-		expect(arch.name).toBe("Architecture");
-		// The model selector (incl. the `:high` thinking suffix) is stored verbatim;
-		// resolution happens later in the session, not here.
-		expect(arch.model).toBe("x-ai/grok-code-fast:high");
-		expect(arch.instructions).toBe("Watch module boundaries.");
-		expect(sec.name).toBe("Security Reviewer");
-		expect(sec.model).toBeUndefined();
-		// The unknown/non-read-only tool is dropped; only `read` survives.
-		expect(sec.tools).toEqual(["read"]);
-		expect(sharedInstructions).toBe("Shared baseline for all advisors.");
-	});
-
-	it("distinguishes omitted tools, explicit no-tools, and invalid-only lists", async () => {
-		const yaml = [
-			"advisors:",
-			"  - name: No Tools",
-			"    tools: []",
-			"  - name: Default Tools",
-			"  - name: Invalid Only",
-			"    tools: [reed]",
-		].join("\n");
-		await Bun.write(path.join(tmp, "WATCHDOG.yml"), yaml);
-
-		const { advisors } = await discoverAdvisorConfigs(tmp, agentDir);
-		const noTools = advisors.find(a => a.name === "No Tools");
-		const defaultTools = advisors.find(a => a.name === "Default Tools");
-		const invalidOnly = advisors.find(a => a.name === "Invalid Only");
-
-		expect(noTools?.tools).toEqual([]);
-		expect(defaultTools?.tools).toBeUndefined();
-		expect(invalidOnly?.tools).toBeUndefined();
-	});
-
-	it("ignores a malformed YAML file without throwing", async () => {
-		await Bun.write(path.join(tmp, "WATCHDOG.yml"), "advisors: [unclosed bracket");
-		const result = await discoverAdvisorConfigs(tmp, agentDir);
-		expect(result.advisors).toEqual([]);
-		expect(result.sharedInstructions).toBeUndefined();
-	});
-
-	it("skips a file whose shape fails the schema (advisors must be a list)", async () => {
-		await Bun.write(path.join(tmp, "WATCHDOG.yml"), "advisors: not-an-array");
-		const result = await discoverAdvisorConfigs(tmp, agentDir);
-		expect(result.advisors).toEqual([]);
-	});
-
-	it("returns an empty roster when no config file exists", async () => {
-		const result = await discoverAdvisorConfigs(tmp, agentDir);
-		expect(result.advisors).toEqual([]);
-		expect(result.sharedInstructions).toBeUndefined();
-	});
-});
-
-describe("slugifyAdvisorName", () => {
-	it("lowercases and collapses non-alphanumeric runs to single hyphens", () => {
-		expect(slugifyAdvisorName("Security Reviewer")).toBe("security-reviewer");
-		expect(slugifyAdvisorName("  Arch/Boundaries!  ")).toBe("arch-boundaries");
-	});
-
-	it("falls back to 'advisor' when nothing alphanumeric survives", () => {
-		expect(slugifyAdvisorName("!!!")).toBe("advisor");
-	});
-});
-
-describe("getOrCreateAdvisorProviderSessionId", () => {
-	const primarySessionA = "018f8f5d-75b0-7cc6-8a6f-2f1c0b8e4c9d";
-	const primarySessionB = "018f8f5d-75b1-7cc6-8a6f-2f1c0b8e4c9d";
-
-	it("returns the generated UUIDv7 instead of a local advisor label", () => {
-		const generated = "0193c8f2-7b1a-7c4d-9e2f-123456789abc";
-
-		const providerSessionId = getOrCreateAdvisorProviderSessionId(
-			new Map<string, string>(),
-			primarySessionA,
-			"security-advisor",
-			() => generated,
-		);
-
-		expect(providerSessionId).toBe(generated);
-		expect(providerSessionId).not.toContain("-advisor");
-	});
-
-	it("reuses the same generated UUIDv7 for repeated calls with the same primary session and slug", () => {
-		const generatedIds = ["0193c8f2-7b1a-7c4d-9e2f-123456789abc", "0193c8f2-7b1b-7c4d-9e2f-123456789abc"];
-		let nextGeneratedIdIndex = 0;
-		const ids = new Map<string, string>();
-
-		const first = getOrCreateAdvisorProviderSessionId(ids, primarySessionA, "architecture", () => {
-			const generated = generatedIds[nextGeneratedIdIndex];
-			if (!generated) throw new Error("unexpected generator call");
-			nextGeneratedIdIndex += 1;
-			return generated;
-		});
-		const second = getOrCreateAdvisorProviderSessionId(ids, primarySessionA, "architecture", () => {
-			const generated = generatedIds[nextGeneratedIdIndex];
-			if (!generated) throw new Error("unexpected generator call");
-			nextGeneratedIdIndex += 1;
-			return generated;
-		});
-
-		expect(first).toBe(generatedIds[0]);
-		expect(second).toBe(generatedIds[0]);
-		expect(nextGeneratedIdIndex).toBe(1);
-	});
-
-	it("creates distinct UUIDv7 values for different advisor slugs or primary sessions", () => {
-		const generatedIds = [
-			"0193c8f2-7b1a-7c4d-9e2f-123456789abc",
-			"0193c8f2-7b1b-7c4d-9e2f-123456789abc",
-			"0193c8f2-7b1c-7c4d-9e2f-123456789abc",
-		];
-		let nextGeneratedIdIndex = 0;
-		const ids = new Map<string, string>();
-		const nextGeneratedId = () => {
-			const generated = generatedIds[nextGeneratedIdIndex];
-			if (!generated) throw new Error("unexpected generator call");
-			nextGeneratedIdIndex += 1;
-			return generated;
-		};
-
-		const architecture = getOrCreateAdvisorProviderSessionId(ids, primarySessionA, "architecture", nextGeneratedId);
-		const security = getOrCreateAdvisorProviderSessionId(ids, primarySessionA, "security", nextGeneratedId);
-		const architectureForOtherSession = getOrCreateAdvisorProviderSessionId(
-			ids,
-			primarySessionB,
-			"architecture",
-			nextGeneratedId,
-		);
-
-		expect(architecture).toBe(generatedIds[0]);
-		expect(security).toBe(generatedIds[1]);
-		expect(architectureForOtherSession).toBe(generatedIds[2]);
-		expect(new Set([architecture, security, architectureForOtherSession]).size).toBe(3);
-	});
-
-	it("rejects generated values that are not UUIDv7", () => {
-		expect(() =>
-			getOrCreateAdvisorProviderSessionId(
-				new Map<string, string>(),
-				primarySessionA,
-				"architecture",
-				() => "550e8400-e29b-41d4-a716-446655440000",
-			),
-		).toThrow("non-UUIDv7");
-	});
-});
-
-describe("WATCHDOG.yml file round-trip", () => {
-	let tmp: string;
-	beforeEach(async () => {
-		tmp = await fsp.mkdtemp(path.join(os.tmpdir(), "omp-advisor-file-"));
-	});
-	afterEach(async () => {
-		await fsp.rm(tmp, { recursive: true, force: true });
-	});
-
-	const doc: WatchdogConfigDoc = {
-		instructions: 'Shared baseline.\n\nSecond line with: a colon and "quotes".',
-		advisors: [
-			{
-				name: "Architecture",
-				model: "x-ai/grok-code-fast:high",
-				instructions: "Watch module boundaries.\nReport coupling.",
-			},
-			{ name: "Security", tools: ["read", "grep"] },
-		],
-	};
-
-	it("saves and reloads a doc byte-equivalently (incl. multiline and special chars)", async () => {
-		const file = path.join(tmp, "WATCHDOG.yml");
-		await saveWatchdogConfigFile(file, doc);
-		const loaded = await loadWatchdogConfigFile(file);
-		expect(loaded).toEqual(doc);
-	});
-
-	it("serializes block-style YAML that the discovery path also parses", async () => {
-		const file = path.join(tmp, "WATCHDOG.yml");
-		await saveWatchdogConfigFile(file, doc);
-		const text = await Bun.file(file).text();
-		// Block style (not the flow `{...}` form), so it stays hand-editable.
-		expect(text).toContain("advisors:");
-		expect(text).not.toMatch(/^\{/);
-		expect(text).toContain('instructions: |2-\n  Shared baseline.\n  \n  Second line with: a colon and "quotes".');
-		expect(text).toContain("    instructions: |2-\n      Watch module boundaries.\n      Report coupling.");
-		expect(text).not.toContain("\\n");
-		const { advisors, sharedInstructions } = await discoverAdvisorConfigs(tmp, tmp);
-		expect(advisors.map(a => a.name)).toEqual(["Architecture", "Security"]);
-		expect(sharedInstructions).toContain("Shared baseline.");
-	});
-
-	it("preserves significant leading whitespace and trailing newlines in block scalars", async () => {
-		const file = path.join(tmp, "WATCHDOG.yml");
-		const whitespaceDoc: WatchdogConfigDoc = {
-			instructions: "  indented first line\nplain second line\n\n",
-			advisors: [{ name: "Whitespace", instructions: "\n  indented after blank\nplain" }],
-		};
-
-		await saveWatchdogConfigFile(file, whitespaceDoc);
-		expect(await loadWatchdogConfigFile(file)).toEqual(whitespaceDoc);
-	});
-
-	it("round-trips an explicit empty tools list without collapsing it into the default", async () => {
-		const file = path.join(tmp, "WATCHDOG.yml");
-		const explicitNoToolsDoc: WatchdogConfigDoc = {
-			advisors: [{ name: "No Tools", tools: [] }, { name: "Default Tools" }],
-		};
-
-		await saveWatchdogConfigFile(file, explicitNoToolsDoc);
-		const serializedDoc = await loadWatchdogConfigFile(file);
-		expect(serializedDoc).toEqual(explicitNoToolsDoc);
-
-		const { advisors } = await discoverAdvisorConfigs(tmp, tmp);
-		expect(advisors.find(a => a.name === "No Tools")?.tools).toEqual([]);
-		expect(advisors.find(a => a.name === "Default Tools")?.tools).toBeUndefined();
-	});
-
-	it("removes the file when the doc is empty so legacy discovery resumes", async () => {
-		const file = path.join(tmp, "WATCHDOG.yml");
-		await saveWatchdogConfigFile(file, doc);
-		await saveWatchdogConfigFile(file, { advisors: [] });
-		expect(await Bun.file(file).exists()).toBe(false);
-		// Loading a missing file yields an empty doc, never throws.
-		expect(await loadWatchdogConfigFile(file)).toEqual({ advisors: [] });
-	});
-
-	it("returns an empty serialization for an empty doc", () => {
-		expect(serializeWatchdogConfig({ advisors: [] })).toBe("");
-	});
-
-	it("resolves project and user scope paths", () => {
-		expect(advisorConfigFilePath("project", { projectDir: "/repo", agentDir: "/home/.omp" })).toBe(
-			path.join("/repo", "WATCHDOG.yml"),
-		);
-		expect(advisorConfigFilePath("user", { projectDir: "/repo", agentDir: "/home/.omp" })).toBe(
-			path.join("/home/.omp", "WATCHDOG.yml"),
-		);
-	});
-});
-
-describe("resolveAdvisorConfigEditPath", () => {
-	let tmp: string;
-	beforeEach(async () => {
-		tmp = await fsp.mkdtemp(path.join(os.tmpdir(), "omp-advisor-resolve-"));
-	});
-	afterEach(async () => {
-		await fsp.rm(tmp, { recursive: true, force: true });
-	});
-
-	const dirs = (d: string) => ({ projectDir: d, agentDir: d });
-
-	it("defaults to .yml when neither file exists", async () => {
-		expect(await resolveAdvisorConfigEditPath("project", dirs(tmp))).toBe(path.join(tmp, "WATCHDOG.yml"));
-	});
-
-	it("edits an existing .yaml in place when only it exists", async () => {
-		await Bun.write(path.join(tmp, "WATCHDOG.yaml"), "advisors: []\n");
-		expect(await resolveAdvisorConfigEditPath("project", dirs(tmp))).toBe(path.join(tmp, "WATCHDOG.yaml"));
-	});
-
-	it("prefers the canonical .yml when both exist", async () => {
-		await Bun.write(path.join(tmp, "WATCHDOG.yml"), "advisors: []\n");
-		await Bun.write(path.join(tmp, "WATCHDOG.yaml"), "advisors: []\n");
-		expect(await resolveAdvisorConfigEditPath("project", dirs(tmp))).toBe(path.join(tmp, "WATCHDOG.yml"));
-	});
-});
-
-describe("per-advisor enabled field", () => {
-	it("preserves explicit true, explicit false, and absence through save and discovery", async () => {
-		const tmp = await fsp.mkdtemp(path.join(os.tmpdir(), "omp-advisor-enabled-"));
-		try {
-			const doc: WatchdogConfigDoc = {
-				advisors: [
-					{ name: "Explicit On", model: "test/model-a", enabled: true },
-					{ name: "Explicit Off", model: "test/model-b", enabled: false },
-					{ name: "Default", model: "test/model-c" },
-				],
-			};
-			const file = path.join(tmp, "WATCHDOG.yml");
-			await saveWatchdogConfigFile(file, doc);
-
-			const loaded = await loadWatchdogConfigFile(file);
-			expect(loaded.advisors.map(advisor => advisor.enabled)).toEqual([true, false, undefined]);
-
-			const { advisors } = await discoverAdvisorConfigs(tmp, tmp);
-			expect(advisors.map(advisor => advisor.enabled)).toEqual([true, false, undefined]);
-		} finally {
-			await fsp.rm(tmp, { recursive: true, force: true });
-		}
-	});
-
-	it("emits explicit boolean values but omits an absent enabled field", () => {
-		const text = serializeWatchdogConfig({
-			advisors: [
-				{ name: "Explicit On", enabled: true },
-				{ name: "Explicit Off", enabled: false },
-				{ name: "Default" },
-			],
-		});
-		expect(text).toContain("enabled: true");
-		expect(text).toContain("enabled: false");
-		expect(text.match(/enabled:/g)).toHaveLength(2);
-	});
-});

package/src/advisor/__tests__/emission-guard.test.ts

@@ -1,147 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { AdvisorEmissionGuard, normalizeAdvisorNote } from "../emission-guard";
-
-describe("normalizeAdvisorNote", () => {
-	it("collapses punctuation, casing, and surrounding whitespace into one canonical key", () => {
-		// The reporter's three top duplicates all key to the same canonical form
-		// regardless of trailing punctuation or casing — that's what makes the
-		// dedupe + suppression checks single-membership.
-		expect(normalizeAdvisorNote("Stop.")).toBe("stop");
-		expect(normalizeAdvisorNote("  STOP!  ")).toBe("stop");
-		expect(normalizeAdvisorNote("*Stop*")).toBe("stop");
-		expect(normalizeAdvisorNote("Done.")).toBe("done");
-		expect(normalizeAdvisorNote("No issue; continue.")).toBe("no issue continue");
-	});
-
-	it("returns empty string for whitespace-only input so callers can short-circuit", () => {
-		expect(normalizeAdvisorNote("")).toBe("");
-		expect(normalizeAdvisorNote("   ")).toBe("");
-		expect(normalizeAdvisorNote("...")).toBe("");
-	});
-
-	it("preserves internal letters/digits but folds non-alphanumeric runs to one space", () => {
-		expect(normalizeAdvisorNote("Refactor `auth-flow.ts`: drop legacy branch.")).toBe(
-			"refactor auth flow ts drop legacy branch",
-		);
-	});
-});
-
-describe("AdvisorEmissionGuard", () => {
-	it("drops the exact content-free filler the reporter observed flooding the chat", () => {
-		// Issue #3520: 114× "Stop.", 52× "No issue; continue.", 41× "Done." —
-		// none of these carry a concrete reason and they cannot be acted on, so
-		// the guard suppresses them regardless of severity.
-		const guard = new AdvisorEmissionGuard();
-		expect(guard.accept("Stop.")).toBe(false);
-		expect(guard.accept("Done.")).toBe(false);
-		expect(guard.accept("No issue; continue.")).toBe(false);
-		expect(guard.accept("LGTM")).toBe(false);
-		expect(guard.accept("No further watcher input needed.")).toBe(false);
-	});
-
-	it("dedupes by normalized text across the session, ignoring casing and trailing punctuation", () => {
-		const guard = new AdvisorEmissionGuard();
-		expect(guard.accept("Move retries into the queue, not the request path.")).toBe(true);
-		// Same advice with different casing and trailing punctuation must NOT
-		// land twice in the primary transcript.
-		expect(guard.accept("move retries into the queue, not the request path")).toBe(false);
-		expect(guard.accept("Move retries into the queue, not the request path!")).toBe(false);
-	});
-
-	it("rate-limits to one accepted advise per advisor update cycle", () => {
-		// The advisor system prompt says "at most one `advise` per update". Real
-		// models violate this; the guard enforces it at the boundary so the
-		// primary transcript never receives two advisories from one model cycle.
-		const guard = new AdvisorEmissionGuard();
-		expect(guard.accept("First concern: missing await in #handleRetry.")).toBe(true);
-		expect(guard.accept("Second concern: wrong env var name.")).toBe(false);
-		guard.beginUpdate();
-		// New cycle: budget reset.
-		expect(guard.accept("Second concern: wrong env var name.")).toBe(true);
-	});
-
-	it("does not let a suppressed call consume the per-update budget", () => {
-		// A noise call like "Stop." must never displace a real concern that
-		// follows in the same advisor model cycle.
-		const guard = new AdvisorEmissionGuard();
-		expect(guard.accept("Stop.")).toBe(false);
-		expect(guard.accept("Concrete: read race in #handleRetry.")).toBe(true);
-	});
-
-	it("does not let a deduped call consume the per-update budget", () => {
-		// A repeat of a prior session note is dropped, but the model can still
-		// follow it with a fresh concrete concern in the same cycle.
-		const guard = new AdvisorEmissionGuard();
-		expect(guard.accept("Concrete: read race in #handleRetry.")).toBe(true);
-		guard.beginUpdate();
-		expect(guard.accept("Concrete: read race in #handleRetry.")).toBe(false);
-		expect(guard.accept("New concern: cache eviction never fires.")).toBe(true);
-	});
-
-	it("reset clears dedupe and the per-update gate so a re-primed advisor can re-raise old issues", () => {
-		// Compaction / session-switch rewrites the primary transcript. The
-		// advisor is re-primed from scratch and may legitimately re-raise the
-		// same concerns — they're new context for a freshly-primed reviewer.
-		const guard = new AdvisorEmissionGuard();
-		expect(guard.accept("Race in #handleRetry.")).toBe(true);
-		expect(guard.accept("Race in #handleRetry.")).toBe(false);
-		guard.reset();
-		expect(guard.accept("Race in #handleRetry.")).toBe(true);
-	});
-
-	it("evicts oldest entries when dedupe history exceeds capacity", () => {
-		// Bounded so very long sessions cannot grow the dedupe state without
-		// bound. Pre-eviction unique notes are remembered; post-eviction the
-		// oldest one is forgotten and can resurface.
-		const guard = new AdvisorEmissionGuard({ capacity: 3 });
-		expect(guard.accept("first")).toBe(true);
-		guard.beginUpdate();
-		expect(guard.accept("second")).toBe(true);
-		guard.beginUpdate();
-		expect(guard.accept("third")).toBe(true);
-		guard.beginUpdate();
-		// "first" still in history.
-		expect(guard.accept("first")).toBe(false);
-		guard.beginUpdate();
-		// Fourth unique entry evicts "first".
-		expect(guard.accept("fourth")).toBe(true);
-		guard.beginUpdate();
-		expect(guard.accept("first")).toBe(true);
-	});
-
-	it("rejects empty / whitespace-only notes without consuming the budget", () => {
-		const guard = new AdvisorEmissionGuard();
-		expect(guard.accept("")).toBe(false);
-		expect(guard.accept("   ")).toBe(false);
-		expect(guard.accept("Concrete advice.")).toBe(true);
-	});
-
-	it("end-to-end: the reporter's 309-call spam log produces ≤1 accepted note across many updates", () => {
-		// Mimic the issue's distribution: 114× "Stop.", 52× "No issue; continue.",
-		// 41× "Done.", plus 102 copies of one concrete-but-repeated nit. Spread
-		// the calls across 50 advisor update cycles. Each cycle is allowed at
-		// most one accepted note, and identical-text repeats never escape the
-		// guard. After all calls, exactly the concrete nit has been accepted
-		// — and only once.
-		const guard = new AdvisorEmissionGuard();
-		const accepted: string[] = [];
-		const stream: string[] = [
-			...Array(114).fill("Stop."),
-			...Array(52).fill("No issue; continue."),
-			...Array(41).fill("Done."),
-			...Array(102).fill("Concrete-but-repeated nit: x"),
-		];
-		// Interleave across 50 update cycles.
-		const cycles = 50;
-		const perCycle = Math.ceil(stream.length / cycles);
-		for (let c = 0; c < cycles; c++) {
-			guard.beginUpdate();
-			for (let i = 0; i < perCycle; i++) {
-				const note = stream[c * perCycle + i];
-				if (note === undefined) break;
-				if (guard.accept(note)) accepted.push(note);
-			}
-		}
-		expect(accepted).toEqual(["Concrete-but-repeated nit: x"]);
-	});
-});

package/src/cli/__tests__/auth-gateway-catalog.test.ts

@@ -1,111 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { AuthStorage } from "@oh-my-pi/pi-ai";
-import { getBundledModels } from "@oh-my-pi/pi-catalog/models";
-import { TempDir } from "@oh-my-pi/pi-utils";
-import { ModelRegistry } from "../../config/model-registry";
-import { indexModelsByRequestId } from "../auth-gateway-cli";
-
-function stubAuthStorage(configKeys?: string[]): AuthStorage {
-	const stub = {
-		setFallbackResolver: () => {},
-		clearConfigApiKeys: () => {},
-		setConfigApiKey: (provider: string) => configKeys?.push(provider),
-		removeConfigApiKey: () => {},
-		hasAuth: () => true,
-		getAll: () => ({ anthropic: {} }),
-	};
-	return stub as unknown as AuthStorage;
-}
-
-describe("indexModelsByRequestId (auth-gateway catalog)", () => {
-	test("resolves a discovery-only model absent from the bundled catalog", () => {
-		const registry = new ModelRegistry(stubAuthStorage());
-		// Simulate a model reached via provider discovery but not compiled into
-		// the bundle (e.g. a post-release id). registerProvider merges it into
-		// getAll() exactly as runtime discovery does.
-		registry.registerProvider("anthropic", {
-			baseUrl: "https://api.anthropic.com",
-			api: "anthropic-messages",
-			apiKey: "test-key",
-			models: [
-				{
-					id: "claude-opus-5-repro",
-					name: "Claude Opus 5 (repro)",
-					reasoning: false,
-					input: ["text"],
-					cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-					contextWindow: 200000,
-					maxTokens: 8192,
-				},
-			],
-		});
-		expect(getBundledModels("anthropic").map(m => m.id)).not.toContain("claude-opus-5-repro");
-
-		const index = indexModelsByRequestId(registry.getAll(), new Set(["anthropic"]));
-
-		// The gateway can now resolve it by qualified id and bare id — was
-		// "Unknown model" when the index was built from getBundledModels only.
-		expect(index.get("anthropic/claude-opus-5-repro")?.id).toBe("claude-opus-5-repro");
-		expect(index.get("claude-opus-5-repro")?.id).toBe("claude-opus-5-repro");
-	});
-
-	test("gateway registry ignores local models.yml credential and routing overrides", async () => {
-		using tempDir = TempDir.createSync("@omp-auth-gateway-catalog-");
-		const modelsPath = tempDir.join("models.yml");
-		// anthropic: a plain credential/baseUrl override (no transport) — the
-		// reviewer's leak. openai: a pi-native gateway route — the self-routing loop.
-		await Bun.write(
-			modelsPath,
-			[
-				"providers:",
-				"  anthropic:",
-				"    baseUrl: http://127.0.0.1:18899",
-				"    apiKey: gateway-token",
-				"  openai:",
-				"    baseUrl: http://127.0.0.1:18899",
-				"    apiKey: gateway-token",
-				"    transport: pi-native",
-				"",
-			].join("\n"),
-		);
-
-		// A normal client registry applies the local overrides and installs the
-		// config API keys into AuthStorage.
-		const clientKeys: string[] = [];
-		const clientRegistry = new ModelRegistry(stubAuthStorage(clientKeys), modelsPath);
-		expect(clientRegistry.find("anthropic", "claude-sonnet-4-5")?.baseUrl).toBe("http://127.0.0.1:18899");
-		expect(clientRegistry.getAll().find(model => model.provider === "openai")?.transport).toBe("pi-native");
-		expect(clientKeys).toContain("anthropic");
-
-		// The gateway registry ignores models.yml entirely: bundled routing wins,
-		// no config key reaches AuthStorage, and no pi-native self-route survives.
-		const gatewayKeys: string[] = [];
-		const gatewayRegistry = new ModelRegistry(stubAuthStorage(gatewayKeys), modelsPath, {
-			ignoreLocalModelConfig: true,
-		});
-		const gatewayModel = gatewayRegistry.find("anthropic", "claude-sonnet-4-5");
-		const bundledModel = getBundledModels("anthropic").find(model => model.id === "claude-sonnet-4-5");
-		if (!gatewayModel || !bundledModel) throw new Error("expected bundled Anthropic model");
-
-		expect(gatewayModel.baseUrl).toBe(bundledModel.baseUrl);
-		expect(gatewayModel.transport).toBeUndefined();
-		expect(gatewayKeys).toHaveLength(0);
-		expect(gatewayRegistry.getAll().find(model => model.provider === "openai")?.transport).toBeUndefined();
-		expect(indexModelsByRequestId(gatewayRegistry.getAll(), new Set(["anthropic"])).get(gatewayModel.id)).toBe(
-			gatewayModel,
-		);
-	});
-
-	test("scopes the catalog to providers with credentials", () => {
-		const registry = new ModelRegistry(stubAuthStorage());
-		const all = registry.getAll();
-		const anthropicModel = all.find(m => m.provider === "anthropic");
-		const foreignModel = all.find(m => m.provider !== "anthropic");
-		if (!anthropicModel || !foreignModel) throw new Error("expected mixed-provider bundled catalog");
-
-		const index = indexModelsByRequestId(all, new Set(["anthropic"]));
-
-		expect(index.get(`anthropic/${anthropicModel.id}`)).toBeDefined();
-		expect(index.get(`${foreignModel.provider}/${foreignModel.id}`)).toBeUndefined();
-	});
-});

package/src/cli/update-cli.test.ts

@@ -1,28 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "bun:test";
-import { runUpdateCommand } from "./update-cli";
-
-type FetchInput = string | URL | Request;
-type FetchInit = RequestInit | BunFetchRequestInit;
-
-describe("runUpdateCommand fetch cancellation", () => {
-	afterEach(() => {
-		vi.restoreAllMocks();
-	});
-
-	it("checks release metadata with a timeout signal", async () => {
-		let requestSignal: AbortSignal | undefined;
-		vi.spyOn(console, "log").mockImplementation(() => {});
-		const fetchStub = Object.assign(
-			async (_input: FetchInput, init?: FetchInit) => {
-				requestSignal = init?.signal ?? undefined;
-				return Response.json({ version: "999.0.0" });
-			},
-			{ preconnect: globalThis.fetch.preconnect },
-		);
-		vi.spyOn(globalThis, "fetch").mockImplementation(fetchStub);
-
-		await runUpdateCommand({ force: false, check: true });
-
-		expect(requestSignal).toBeInstanceOf(AbortSignal);
-	});
-});