test: reset gateway in afterAll in cli-multimodal-integration — cross-file config leak

Review hardening on #3116: the file resets the gateway in beforeEach but
left it configured after the last test, leaking a multimodal gateway
config into whatever file runs next in its shard (same class as the
adaptive-embed-batch leak fixed on master).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

docs/architecture/KEY_FILES.md

@@ -79,7 +79,7 @@ per-release `**vX.Y.Z:**` narration — CI enforces this
 - `docs/architecture/RETRIEVAL.md` + `docs/architecture/RETRIEVAL_MAXPOOL_INCIDENT.md` — retrieval-pipeline architecture reference + the named-thing-miss incident write-up (root cause, the five-layer fix, the eval that pins it).
 - `src/core/types.ts` extension + `src/core/operations.ts:search` + `src/core/import-file.ts` + `src/cli.ts` + `src/core/search/telemetry.ts` — the wiring layer for the retrieval cathedral. `SearchResult` gains `evidence`, `create_safety`, `title_match_boost`, `alias_hit` (all optional; evidence/create_safety reference the union types in `evidence.ts`). The `search` MCP op uses a cheap-hybrid path by default and accepts a per-call `mode` (conservative|balanced|tokenmax) honored ONLY for trusted/local callers (`resolvePerCallMode(ctx, ...)` — remote callers use the configured mode so a remote provider can't force tokenmax spend); every search path stamps evidence fail-soft. `importFromContent` projects frontmatter `aliases:` into `page_aliases` via `normalizeAliasList` + `engine.setPageAliases` so new + changed pages register aliases at ingest. `src/cli.ts` adds the `gbrain search diagnose` dispatch (lazy import) and reconciles the `search` CLI path with the cheap-hybrid op. `src/core/search/telemetry.ts` extends the rollup with the rank-1 base_score drift signal (sum/count + 3 coarse buckets, aggregate not per-query), surfaced via `gbrain search stats`, backed by migration v111's `search_telemetry` columns. Tests: `test/cli-search-dispatch.test.ts`, `test/search/per-call-mode.test.ts`, `test/search/telemetry-rank1.test.ts`, `test/search/title-boost-stage.test.ts`, `test/search/alias-hop.test.ts`, `test/search/evidence.test.ts`, `test/search/searchvector-maxpool.test.ts`, `test/search/pre-migration-failopen.test.ts`.
 - `src/commands/eval.ts` — `gbrain eval` command: single-run table + A/B config comparison. Sub-subcommand dispatch on `args[0]` routes `gbrain eval export` + `gbrain eval prune` + `gbrain eval replay` into session-capture handlers; bare `gbrain eval --qrels …` fall-through preserves the legacy IR-metrics flow. `gbrain eval cross-modal` is in the dispatch (the user-facing path is the cli.ts no-DB branch — `src/commands/eval.ts:cross-modal` only fires when callers re-enter with an existing engine).
-- `src/commands/eval-cross-modal.ts` — multi-model quality gate. Three different-provider frontier models score the OUTPUT against the TASK on a 5-dim list. Verdict `pass` (exit 0) / `fail` (exit 1) / `inconclusive` (exit 2; <2/3 model successes). Reuses `src/core/ai/gateway.ts:chat()` so config/auth/aliasing comes from the gateway recipe registry — no parallel provider stack. Self-configures the gateway (`configureGateway(loadConfig() + process.env)`) since the cli.ts dispatch bypasses `connectEngine()`. Default cycles 3 in TTY, 1 in non-TTY (partial cost guardrail) via the shared `resolveCycleDefault(explicit, isTty)` in `src/core/eval/cycle-default.ts`; the cost-estimate banner appends `cycleDefaultSuffix(...)` (`for 1 cycle(s) (non-interactive default; --cycles N for more)`) when the value is the silent non-TTY fallback, so the 1-vs-3 difference isn't hidden. Receipts land at `gbrainPath('eval-receipts')/<slug>-<sha8-of-output>.json`. `--batch <jsonl> [--limit N] [--concurrent N] [--max-usd FLOAT] [--yes]` fans out cross-modal scoring across a LongMemEval-shape JSONL; mutually exclusive with `--task` (fail-fast usage error if both set); filters `kind: "by_type_summary"` rows; pre-flight cost estimate refuses if `> --max-usd` without `--yes` (default cap 5.00 USD). Semaphore-bounded fan-out via inline `runWithLimit<T>(items, limit, fn)` (exported for unit tests): max N questions in-flight × 3 model slots = ceiling of 3N parallel API calls (default `--concurrent 3` → 9). Per-question receipts land in a per-batch tempdir and are deleted at end of run; the summary receipt inlines per-question verdicts as JSON, not file paths. Exit precedence (batch-level policy, NOT inherited from aggregate.ts): ERROR > FAIL > INCONCLUSIVE > PASS. DI seam: `runEvalCrossModal(args, opts?: {runEval?: typeof runEval})` mirrors `runEvalLongMemEval(args, {client?})`; tests pass `opts.runEval` to bypass real LLM calls AND the gateway availability check. Pinned by `test/eval-cross-modal-batch.test.ts`.
+- `src/commands/eval-cross-modal.ts` — multi-model quality gate. Three different-provider frontier models score the OUTPUT against the TASK on a 5-dim list. Verdict `pass` (exit 0) / `fail` (exit 1) / `inconclusive` (exit 2; <2/3 model successes). Reuses `src/core/ai/gateway.ts:chat()` so config/auth/aliasing comes from the gateway recipe registry — no parallel provider stack. Self-configures the gateway via `buildGatewayConfig(loadConfig() ?? {})` since the cli.ts dispatch bypasses `connectEngine()`, so file-plane keys, env base URLs, and provider_chat_options follow the same adapter path as runtime. Default cycles 3 in TTY, 1 in non-TTY (partial cost guardrail) via the shared `resolveCycleDefault(explicit, isTty)` in `src/core/eval/cycle-default.ts`; the cost-estimate banner appends `cycleDefaultSuffix(...)` (`for 1 cycle(s) (non-interactive default; --cycles N for more)`) when the value is the silent non-TTY fallback, so the 1-vs-3 difference isn't hidden. Receipts land at `gbrainPath('eval-receipts')/<slug>-<sha8-of-output>.json`. `--batch <jsonl> [--limit N] [--concurrent N] [--max-usd FLOAT] [--yes]` fans out cross-modal scoring across a LongMemEval-shape JSONL; mutually exclusive with `--task` (fail-fast usage error if both set); filters `kind: "by_type_summary"` rows; pre-flight cost estimate refuses if `> --max-usd` without `--yes` (default cap 5.00 USD). Semaphore-bounded fan-out via inline `runWithLimit<T>(items, limit, fn)` (exported for unit tests): max N questions in-flight × 3 model slots = ceiling of 3N parallel API calls (default `--concurrent 3` → 9). Per-question receipts land in a per-batch tempdir and are deleted at end of run; the summary receipt inlines per-question verdicts as JSON, not file paths. Exit precedence (batch-level policy, NOT inherited from aggregate.ts): ERROR > FAIL > INCONCLUSIVE > PASS. DI seam: `runEvalCrossModal(args, opts?: {runEval?: typeof runEval})` mirrors `runEvalLongMemEval(args, {client?})`; tests pass `opts.runEval` to bypass real LLM calls AND the gateway availability check. Pinned by `test/eval-cross-modal-batch.test.ts`.
 - `src/core/eval/cycle-default.ts` — single source of truth for the eval cycle-count default. Exports `DEFAULT_CYCLES_TTY = 3`, `DEFAULT_CYCLES_NONTTY = 1`, `resolveCycleDefault(explicit, isTty): {cycles, usedNonTtyDefault}`, and `cycleDefaultSuffix(r)` (returns ` (non-interactive default; --cycles N for more)` only when the non-TTY default was applied, else `''`). Consumed by `eval-cross-modal.ts`, `eval-takes-quality.ts` (run + regress), and `takes-quality-eval/runner.ts` (core uses only the constant — library stays TTY-agnostic; the CLI owns the TTY=3 upgrade + banner annotation). `eval-suspected-contradictions.ts` applies the same transparency to its `$5`/`$1` budget default via a `budgetUsdExplicit` flag (the budget is overwritten in-place so explicitness can't be inferred post-hoc). Not shared with `resolveWorkersWithClamp` (different domain, no engine, no dedup). Pinned by `test/eval/cycle-default.test.ts`, `test/eval-suspected-contradictions-budget-default.test.ts`.
 - `src/core/cross-modal-eval/json-repair.ts` — `parseModelJSON(raw)` named export with a 4-strategy fallback chain (direct parse → fence-strip → trailing-comma + single-quote + embedded-newline repair → regex nuclear option). Adversarial input throws rather than fabricating scores — the aggregator treats a throw as "this model contributed nothing this cycle" so the gate stays correct at >=2/3 successes.
 - `src/core/cross-modal-eval/aggregate.ts` — pure verdict logic. Pass criterion: `(successes >= 2) AND (every dim mean >= 7) AND (every dim min across models >= 5)`. Inconclusive when <2/3 models returned parseable scores (regression guard for the v1 `Object.values({}).every(...) === true` empty-array PASS bug).
@@ -138,7 +138,7 @@ per-release `**vX.Y.Z:**` narration — CI enforces this
 - `src/core/minions/queue.ts` extension — `MinionQueue.add()` rejects `subagent` jobs whose `data.model` resolves via `isAnthropicProvider()` to a non-Anthropic provider. Lazy-imports `model-config.ts` to avoid pulling engine types into queue's eager-load surface. Layer 1 of the three-layer subagent provider enforcement (layers 2+3: `model-config.ts:enforceSubagentAnthropic` runtime fallback + `src/commands/doctor.ts` `subagent_provider` check). Pinned by `test/agent-cli.test.ts`.
 - `src/commands/models.ts` — `gbrain models [--json]` read-only routing dashboard: prints tier defaults (`utility`/`reasoning`/`deep`/`subagent`), the resolved value for each (re-walking the resolution chain), every per-task override (11 `PER_TASK_KEYS`: `models.dream.synthesize`, `models.dream.patterns`, `models.drift`, `models.auto_think`, `models.think`, `models.subagent`, `facts.extraction_model`, `models.eval.longmemeval`, `models.expansion`, `models.chat`, `models.dream.synthesize_verdict`), the alias map, and a source-of-truth column (`default` / `config: <key>` / `env: <VAR>`). `gbrain models doctor [--skip=<provider>] [--json]` fires a 1-token `gateway.chat()` probe against each configured chat + expansion model and classifies failures into `{model_not_found, auth, rate_limit, network, unknown}`. Wired into `cli.ts` dispatch + `CLI_ONLY` set. A zero-token `embedding_config` probe runs FIRST, before any chat/expansion probes spend money: `probeEmbeddingConfig()` reads `getEmbeddingModel()` + `getEmbeddingDimensions()` and (for Voyage flexible-dim models) checks `isValidVoyageOutputDim(dims)` against `VOYAGE_VALID_OUTPUT_DIMS`. `ProbeStatus` variant `'config'` + optional `fix?: string` on `ProbeResult` surface a paste-ready `gbrain config set ...` line in human + JSON output; touchpoint label `'embedding_config'` joins `'chat'` and `'expansion'`.
 - `src/core/init-embed-check.ts` — embedding-key validation at `gbrain init`. `runInitEmbedCheck(opts)` runs a config-only `diagnoseEmbedding` (catches a missing key for ANY provider) plus a best-effort `liveTestEmbed` (1-token `gateway.embed(['probe'], {inputType:'query', abortSignal})`, 5s `AbortController` timeout, never throws — catches an invalid/expired key). Loud warning to stderr; init still exits 0 (`--no-embedding` is the deferred-setup escape; `--skip-embed-check` / `GBRAIN_INIT_SKIP_EMBED_CHECK=1` skip the check). Builds the effective env (`process.env` + file-plane `openai/anthropic/zeroentropy_api_key` from `loadConfigFileOnly()` + `opts.apiKey`) and configures the gateway via `buildGatewayConfig` before diagnose/probe, so the check sees the same keys AND provider base URLs runtime will (no false "missing key" for config.json-keyed users; the probe hits the right endpoint). Init-specific warning text names `--no-embedding` / `--skip-embed-check`, not the sync-flavored `--no-embed`. Wired into `initPGLite` + `initPostgres` in `src/commands/init.ts`, with the result added to the `--json` envelope as `embedding_check {ok, reason?, live_ok?}`. Pinned by `test/init-embed-check.test.ts` (hermetic via the gateway embed-transport seam + `withEnv`).
-- `src/core/ai/build-gateway-config.ts` — `buildGatewayConfig(c: GBrainConfig): AIGatewayConfig`, extracted from `src/cli.ts` (which re-exports it for back-compat). Lets core modules (`init-embed-check.ts`) reuse it without importing the CLI entrypoint. Single owner of folding file-plane API keys (openai/anthropic/zeroentropy) into the gateway env and threading local-server `*_BASE_URL` env vars into base_urls. `process.env` wins EXCEPT empty-string / undefined values are dropped before the merge, so an injected empty `ANTHROPIC_API_KEY=''` (Claude Code neuters subprocess LLM calls this way) can't clobber a valid config-plane key; `'0'` / `'false'` are preserved. Pinned by `test/ai/build-gateway-config.test.ts`.
+- `src/core/ai/build-gateway-config.ts` — `buildGatewayConfig(c: GBrainConfig): AIGatewayConfig`, extracted from `src/cli.ts` (which re-exports it for back-compat). Single owner of translating stored config into gateway config — consumed by CLI runtime, init (`gbrain init`'s three configureGateway sites), `init-embed-check.ts`, the eval commands (cross-modal, takes-quality), provider diagnostics, and the in-process migration path. Folds file-plane API keys (openai/anthropic/zeroentropy/openrouter) into the gateway env and threads local-server `*_BASE_URL` env vars into base_urls; caller-provided `provider_base_urls` config wins over env base URLs. `process.env` wins EXCEPT empty-string / undefined values are dropped before the merge, so an injected empty `ANTHROPIC_API_KEY=''` (Claude Code neuters subprocess LLM calls this way) can't clobber a valid config-plane key; `'0'` / `'false'` are preserved. Pinned by `test/ai/build-gateway-config.test.ts`.
 - `src/commands/doctor.ts` extension — `subagent_provider` check (layer 3 of 3). Warns when `models.tier.subagent` is explicitly set non-Anthropic (message names the bad value + paste-ready fix `gbrain config set models.tier.subagent anthropic:claude-sonnet-4-6`); also warns when `models.default` would sneak `subagent` into a non-Anthropic provider via tier inheritance. OK when subagent tier resolves to Anthropic. Tests in `test/doctor.test.ts`.
 - `src/core/skill-trigger-index.ts` — Shared loader that unions per-skill SKILL.md frontmatter `triggers:` with curated RESOLVER.md / AGENTS.md rows from `skillsDir` AND the parent dir (preserves the OpenClaw workspace-root layout). UNION semantics: explicit RESOLVER.md rows ADD to frontmatter triggers (don't replace). Dedup keyed on `(skillPath, trigger.trim().toLowerCase())`. Three consumers fold through this primitive — `checkResolvable`, `runRoutingEvalCli`, `mounts-cache.composeResolvers` — so fixing frontmatter reaches all of them. Exports `loadSkillTriggerIndex(skillsDir): SkillTriggerEntry[]`, `entriesToResolverContent(entries): string` (synthesizes a markdown-table resolver string for `runRoutingEval`'s string-content API), `findPrimaryResolverPath(skillsDir): string | null`, the `FRONTMATTER_SECTION` constant, and `_resetWarnedSkillsForTests`. Skip rules: non-directory entries, `_*`/`.*` prefixes, `conventions/`+`migrations/` subdirs, skills with no `SKILL.md` (deprecated `install/` graceful-skipped), no `triggers:` array, or malformed YAML (warn-once + skip). Reuses `parseSkillFrontmatter` from `src/core/skill-frontmatter.ts` (regex-based, not full YAML). Pinned by `test/skill-trigger-index.test.ts` (18 hermetic cases). CI gate `bun run check:resolver` (= `bun src/cli.ts check-resolvable --strict --skills-dir skills/`) wired into `bun run verify`.
 - `src/core/skill-catalog.ts` — host-repo skill catalog backing the MCP `list_skills` / `get_skill` ops. Lets a thin MCP client (Codex desktop, Claude Code, Claude Cowork, Perplexity) DISCOVER + FOLLOW the agent repo's fat-markdown skills over `gbrain serve` — a skill is prose, so "using" one = fetching its body then calling the gbrain MCP tools the server already exposes. Read-scope, NOT localOnly (defensible only via the full mitigation stack): (1) **publish gate** — `assertPublishEnabled(ctx, publishSkills)`; remote callers require `mcp.publish_skills === true`, default-OFF so an upgrade never silently grants existing read tokens host-skill read; local callers (`ctx.remote === false`) always pass. (2) **path confinement** — `assertSkillNameShape` rejects separators/`..`/null/space before any FS access; the client `name` is a manifest LOOKUP KEY (via `loadOrDeriveManifest`), never a raw path segment; `confineManifestPath` does realpath + relative-containment + `SKILL.md`-regular-file check on EVERY entry (defeats poisoned manifest.json `path`, symlink/`..` escape). (3) **frontmatter allowlist** — `GetSkillResult.frontmatter` projects a safe subset; private `writes_to` + `sources` dropped. (4) **prose-only + 256KB cap** (`MAX_SKILL_MD_BYTES`, env `GBRAIN_MAX_SKILL_MD_BYTES`), size-checked twice (statSync + UTF-8 byte length). (5) **no install_path serve for remote** — remote callers use `autoDetectSkillsDir` (no install-path tier) so a hosted gbrain with no agent repo returns `storage_error`; local callers use `autoDetectSkillsDirReadOnly`. (6) MCP rate-limiter caps call rate. Config reads honor BOTH planes: `readMcpPublishSkills` / `readMcpSkillsDir` prefer the DB plane (`engine.getConfig`) over the file plane (`ctx.config.mcp`). Tool-honesty: `crossReferenceTools(declared, ctx)` splits a skill's declared `tools:` into `usable_tools` vs `unavailable_tools`; `buildSkillCatalog`'s `instructions` envelope (`SKILL_CATALOG_INSTRUCTIONS`) carries the "these are prose, follow-then-call-tools" protocol. Skills are host-filesystem repo-global — `sourceScopeOpts(ctx)` / `ctx.brainId` deliberately do NOT apply. `buildSkillCatalog` is resilient (one malformed/escaping skill is skipped, never throws). Config keys in `src/core/config.ts`: `GBrainConfig.mcp?: { publish_skills?, skills_dir? }` + `KNOWN_CONFIG_KEYS` entries `mcp.publish_skills`/`mcp.publish_skills_prompted`/`mcp.skills_dir` + `mcp.` prefix in `KNOWN_CONFIG_KEY_PREFIXES`. `src/commands/init.ts` writes `config.mcp = { publish_skills: true, ... }` for new installs (existing config wins on re-init). `src/commands/upgrade.ts:runPostUpgrade` adds a one-time consent prompt (gated by `mcp.publish_skills_prompted`; existing installs stay OFF until owner opts in). Two ops register in `src/core/operations.ts` (`list_skills` with optional `section` filter + `cliHints:{name:'skills'}`; `get_skill` taking `name` + `cliHints:{name:'skill', positional:['name']}`) and dynamically import this module to avoid the import cycle (skill-catalog statically imports the `operations` array). Descriptions in `src/core/operations-descriptions.ts` (`LIST_SKILLS_DESCRIPTION`, `GET_SKILL_DESCRIPTION`, `SKILL_CATALOG_INSTRUCTIONS`, `SKILL_CLIENT_GUIDANCE`), pinned by `test/operations-descriptions.test.ts`. CLI: `gbrain skills` / `gbrain skill <name>`. Pinned by `test/skill-catalog.test.ts`, `test/skill-catalog-security.test.ts` (path-confinement / poisoned-manifest / symlink-escape), `test/skill-catalog-transports.test.ts` (publish-gate + remote-vs-local) over `test/fixtures/skill-catalog/`.

src/commands/embed.ts

@@ -1,5 +1,5 @@
 import type { BrainEngine } from '../core/engine.ts';
-import { embedBatch, currentEmbeddingSignature, resolveEmbeddingModelLabel } from '../core/embedding.ts';
+import { embedBatch, currentEmbeddingSignature } from '../core/embedding.ts';
 import type { ChunkInput } from '../core/types.ts';
 import { chunkText } from '../core/chunkers/recursive.ts';
 import { createProgress, type ProgressReporter } from '../core/progress.ts';
@@ -581,16 +581,11 @@ async function embedPage(
   for (let j = 0; j < toEmbed.length; j++) {
     embeddingMap.set(toEmbed[j].chunk_index, embeddings[j]);
   }
-  // #1717: label each (re)embedded chunk with the model that actually
-  // produced its vector. Preserved chunks (not re-embedded this pass) keep
-  // their existing model so a mixed-model page isn't relabeled wholesale.
-  const embedModelLabel = resolveEmbeddingModelLabel();
   const updated: ChunkInput[] = chunks.map(c => ({
     chunk_index: c.chunk_index,
     chunk_text: c.chunk_text,
     chunk_source: c.chunk_source,
     embedding: embeddingMap.get(c.chunk_index),
-    model: embeddingMap.has(c.chunk_index) && embedModelLabel ? embedModelLabel : c.model,
     token_count: c.token_count || Math.ceil(c.chunk_text.length / 4),
   }));
 
@@ -722,16 +717,12 @@ async function embedAll(
       for (let j = 0; j < toEmbed.length; j++) {
         embeddingMap.set(toEmbed[j].chunk_index, embeddings[j]);
       }
-      // #1717: stamp the resolved embedding model on (re)embedded chunks;
-      // preserve the existing model on chunks left untouched.
-      const embedModelLabel = resolveEmbeddingModelLabel();
       // Preserve ALL chunks, only update embeddings for stale ones
       const updated: ChunkInput[] = chunks.map(c => ({
         chunk_index: c.chunk_index,
         chunk_text: c.chunk_text,
         chunk_source: c.chunk_source,
         embedding: embeddingMap.get(c.chunk_index) ?? undefined,
-        model: embeddingMap.has(c.chunk_index) && embedModelLabel ? embedModelLabel : c.model,
         token_count: c.token_count || Math.ceil(c.chunk_text.length / 4),
       }));
       await observed(pacer, () => engine.upsertChunks(page.slug, updated, pageOpts));
@@ -1021,15 +1012,11 @@ async function embedAllStale(
           for (let j = 0; j < stale.length; j++) {
             staleIdxToEmbedding.set(stale[j].chunk_index, embeddings[j]);
           }
-          // #1717: label the re-embedded (stale) chunks with the resolved
-          // model; preserve the existing model on the non-stale chunks.
-          const embedModelLabel = resolveEmbeddingModelLabel();
           const merged: ChunkInput[] = existing.map(c => ({
             chunk_index: c.chunk_index,
             chunk_text: c.chunk_text,
             chunk_source: c.chunk_source,
             embedding: staleIdxToEmbedding.get(c.chunk_index) ?? undefined,
-            model: staleIdxToEmbedding.has(c.chunk_index) && embedModelLabel ? embedModelLabel : c.model,
             token_count: c.token_count || Math.ceil(c.chunk_text.length / 4),
           }));
           await observed(pacer, () => engine.upsertChunks(slug, merged, { sourceId: keySourceId }));

src/commands/eval-cross-modal.ts

@@ -21,7 +21,8 @@ import { join } from 'path';
 import { tmpdir } from 'os';
 import { createHash } from 'crypto';
 
-import { gbrainPath, loadConfig } from '../core/config.ts';
+import { gbrainPath, loadConfig, type GBrainConfig } from '../core/config.ts';
+import { buildGatewayConfig } from '../core/ai/build-gateway-config.ts';
 import { configureGateway, isAvailable } from '../core/ai/gateway.ts';
 import { runWithLimit } from '../core/worker-pool.ts';
 import { resolveCycleDefault, cycleDefaultSuffix } from '../core/eval/cycle-default.ts';
@@ -264,32 +265,11 @@ function isTTY(): boolean {
  * Returns true on success; false (and prints a hint) when no config is found.
  */
 function configureGatewayForCli(): boolean {
+  // Route through buildGatewayConfig (the single adapter seam) so file-plane
+  // API keys, env base URLs, and provider_chat_options follow the same
+  // precedence as the runtime path. No config file is fine — env alone serves.
   const config = loadConfig();
-  if (!config) {
-    // No config file is fine for the eval command — env vars alone may serve.
-    // We still call configureGateway so gateway recipes can read the env map.
-    configureGateway({
-      embedding_model: undefined,
-      embedding_dimensions: undefined,
-      expansion_model: undefined,
-      chat_model: undefined,
-      chat_fallback_chain: undefined,
-      base_urls: undefined,
-      provider_chat_options: undefined,
-      env: { ...process.env },
-    });
-    return true;
-  }
-  configureGateway({
-    embedding_model: config.embedding_model,
-    embedding_dimensions: config.embedding_dimensions,
-    expansion_model: config.expansion_model,
-    chat_model: config.chat_model,
-    chat_fallback_chain: config.chat_fallback_chain,
-    base_urls: config.provider_base_urls,
-    provider_chat_options: config.provider_chat_options,
-    env: { ...process.env },
-  });
+  configureGateway(buildGatewayConfig(config ?? ({} as GBrainConfig)));
   return true;
 }
 

src/commands/eval-takes-quality.ts

@@ -21,7 +21,8 @@
  */
 import type { BrainEngine } from '../core/engine.ts';
 import { configureGateway } from '../core/ai/gateway.ts';
-import { loadConfig } from '../core/config.ts';
+import { buildGatewayConfig } from '../core/ai/build-gateway-config.ts';
+import { loadConfig, type GBrainConfig } from '../core/config.ts';
 import { runEval, DEFAULT_MODEL_PANEL } from '../core/takes-quality-eval/runner.ts';
 import { resolveCycleDefault, cycleDefaultSuffix } from '../core/eval/cycle-default.ts';
 import { writeReceipt } from '../core/takes-quality-eval/receipt-write.ts';
@@ -127,8 +128,12 @@ export async function runReplayNoBrain(argv: string[]): Promise<number> {
 export async function runEvalTakesQuality(engine: BrainEngine, args: string[]): Promise<void> {
   // Self-configure the AI gateway (mirrors eval-cross-modal pattern). The
   // gateway needs config.ai_gateway + env vars; configureGateway reads both.
+  // Route through buildGatewayConfig: the old `{ ...cfg, ...process.env }`
+  // spread never populated the gateway's `env` field (the gateway NEVER reads
+  // process.env at call time), so availability checks saw no keys at all and
+  // file-plane API keys / provider base URLs were dropped.
   const cfg = loadConfig();
-  configureGateway({ ...cfg, ...(process.env as Record<string, string>) } as any);
+  configureGateway(buildGatewayConfig(cfg ?? ({} as GBrainConfig)));
 
   const { subcmd, argv, json } = parseSubcmd(args);
 

src/commands/init.ts

@@ -7,6 +7,7 @@ import { homedir } from 'os';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 import { saveConfig, loadConfig, loadConfigFileOnly, toEngineConfig, gbrainPath, configPath, isThinClient, effectiveEnvDatabaseUrl, type GBrainConfig } from '../core/config.ts';
+import { buildGatewayConfig } from '../core/ai/build-gateway-config.ts';
 import { createEngine } from '../core/engine-factory.ts';
 import { discoverOAuth, mintClientCredentialsToken, smokeTestMcp } from '../core/remote-mcp-probe.ts';
 import { runInitEmbedCheck } from '../core/init-embed-check.ts';
@@ -722,7 +723,8 @@ async function configureGatewayWithMergedPrecedence(
   // pollutes config.json.
   const envOverlay = loadConfig() ?? ({} as GBrainConfig);
 
-  const merged = {
+  const merged: GBrainConfig = {
+    ...envOverlay,
     embedding_model: aiOpts?.embedding_model ?? envOverlay.embedding_model ?? existingFile.embedding_model,
     embedding_dimensions: aiOpts?.embedding_dimensions ?? envOverlay.embedding_dimensions ?? existingFile.embedding_dimensions,
     expansion_model: aiOpts?.expansion_model ?? envOverlay.expansion_model ?? existingFile.expansion_model,
@@ -730,13 +732,9 @@ async function configureGatewayWithMergedPrecedence(
   };
 
   const { configureGateway, getEmbeddingModel, getEmbeddingDimensions, getExpansionModel, getChatModel } = await import('../core/ai/gateway.ts');
-  configureGateway({
-    embedding_model: merged.embedding_model,
-    embedding_dimensions: merged.embedding_dimensions,
-    expansion_model: merged.expansion_model,
-    chat_model: merged.chat_model,
-    env: { ...process.env },
-  });
+  // buildGatewayConfig (the single adapter seam) so file-plane API keys and
+  // env base URLs reach the gateway — a hand-rolled config here dropped them.
+  configureGateway(buildGatewayConfig(merged));
 
   // Read back resolved values — gateway applies internal defaults for unset
   // fields, so these are the values that actually shaped the schema.
@@ -831,13 +829,13 @@ async function initPGLite(opts: {
   // resolveAIOptions above: CLI flags > env vars > existing file > gateway
   // defaults.
   const { configureGateway } = await import('../core/ai/gateway.ts');
-  configureGateway({
+  configureGateway(buildGatewayConfig({
+    ...(loadConfig() ?? ({} as GBrainConfig)),
     embedding_model: resolvedModel ?? opts.aiOpts?.embedding_model,
     embedding_dimensions: resolvedDim ?? opts.aiOpts?.embedding_dimensions,
     expansion_model: opts.aiOpts?.expansion_model,
     chat_model: opts.aiOpts?.chat_model,
-    env: { ...process.env },
-  });
+  } as GBrainConfig));
   if (resolvedModel) console.log(`  Embedding: ${resolvedModel} (${resolvedDim}d)`);
   if (opts.aiOpts?.expansion_model) console.log(`  Expansion: ${opts.aiOpts.expansion_model}`);
   if (opts.aiOpts?.chat_model) console.log(`  Chat: ${opts.aiOpts.chat_model}`);
@@ -1046,13 +1044,13 @@ async function initPostgres(opts: {
 
   // T6: unconditional configureGateway BEFORE initSchema.
   const { configureGateway } = await import('../core/ai/gateway.ts');
-  configureGateway({
+  configureGateway(buildGatewayConfig({
+    ...(loadConfig() ?? ({} as GBrainConfig)),
     embedding_model: resolvedModel ?? opts.aiOpts?.embedding_model,
     embedding_dimensions: resolvedDim ?? opts.aiOpts?.embedding_dimensions,
     expansion_model: opts.aiOpts?.expansion_model,
     chat_model: opts.aiOpts?.chat_model,
-    env: { ...process.env },
-  });
+  } as GBrainConfig));
   if (resolvedModel) console.log(`  Embedding: ${resolvedModel} (${resolvedDim}d)`);
   if (opts.aiOpts?.expansion_model) console.log(`  Expansion: ${opts.aiOpts.expansion_model}`);
   if (opts.aiOpts?.chat_model) console.log(`  Chat: ${opts.aiOpts.chat_model}`);

src/commands/migrations/in-process.ts

@@ -66,15 +66,11 @@ export async function runMigrateOnlyCore(opts?: { timeoutMs?: number }): Promise
 
   // configureGateway BEFORE initSchema (init.ts B.3): a schema bump on a brain
   // whose file config is missing embedding fields must not fall through to
-  // stale hardcoded fallbacks. loadConfig already merged env; propagate it.
+  // stale hardcoded fallbacks. Route through buildGatewayConfig so file-plane
+  // API keys and provider base URLs follow the same precedence as runtime.
   const { configureGateway } = await import('../../core/ai/gateway.ts');
-  configureGateway({
-    embedding_model: config.embedding_model,
-    embedding_dimensions: config.embedding_dimensions,
-    expansion_model: config.expansion_model,
-    chat_model: config.chat_model,
-    env: { ...process.env },
-  });
+  const { buildGatewayConfig } = await import('../../core/ai/build-gateway-config.ts');
+  configureGateway(buildGatewayConfig(config));
 
   const timeoutMs = opts?.timeoutMs ?? MIGRATE_ONLY_TIMEOUT_MS;
   const engine = await createEngine(toEngineConfig(config));

src/core/brain-score-recommendations.ts

@@ -12,8 +12,8 @@ import { parseModelId } from './ai/model-resolver.ts';
  * `resolveKey` closure without re-parsing recipes.
  *
  * Only OPENAI_API_KEY and ZEROENTROPY_API_KEY appear here because those are the
- * only embedding keys `buildGatewayConfig` (src/cli.ts) folds from config into
- * the gateway env. VOYAGE_API_KEY / GOOGLE_GENERATIVE_AI_API_KEY are deliberately
+ * only embedding keys `buildGatewayConfig` (src/core/ai/build-gateway-config.ts)
+ * folds from config into the gateway env. VOYAGE_API_KEY / GOOGLE_GENERATIVE_AI_API_KEY are deliberately
  * absent: their config fields are NOT threaded to the gateway today, so the
  * producer closures fall through to checking `process.env` ONLY for them. That
  * matches what the gateway can actually use (the recipes read those keys from

src/core/embed-stale.ts

@@ -20,7 +20,6 @@
 import type { BrainEngine } from './engine.ts';
 import type { ChunkInput } from './types.ts';
 import { embedBatchWithBackoff } from '../commands/embed.ts';
-import { resolveEmbeddingModelLabel } from './embedding.ts';
 import { type DbPacer, createNoopPacer, observed } from './db-pacer.ts';
 import { AbortError } from './abort-check.ts';
 
@@ -201,17 +200,11 @@ export async function embedStaleForSource(
         for (let j = 0; j < stale.length; j++) {
           staleIdxToEmbedding.set(stale[j].chunk_index, embeddings[j]);
         }
-        // #1717: label re-embedded chunks with the model that produced the
-        // vector; preserved chunks keep their existing model. Without this,
-        // upsertChunks falls back to DEFAULT_EMBEDDING_MODEL for every chunk
-        // (the same mislabel the embed.ts paths fixed).
-        const embedModelLabel = resolveEmbeddingModelLabel();
         const merged: ChunkInput[] = existing.map((c) => ({
           chunk_index: c.chunk_index,
           chunk_text: c.chunk_text,
           chunk_source: c.chunk_source,
           embedding: staleIdxToEmbedding.get(c.chunk_index) ?? undefined,
-          model: staleIdxToEmbedding.has(c.chunk_index) && embedModelLabel ? embedModelLabel : c.model,
           token_count: c.token_count || Math.ceil(c.chunk_text.length / 4),
           // Carry through per-chunk metadata. upsertChunks writes these as
           // EXCLUDED.<col> (not COALESCE), so omitting them here resets image

src/core/embedding.ts

@@ -113,21 +113,6 @@ export async function embedBatch(
   return results;
 }
 
-/**
- * Resolve the embedding model label (`provider:model`) to stamp onto
- * `content_chunks.model`, so each chunk records the model that actually
- * produced its vector instead of the engine's hardcoded default (#1717).
- * Returns undefined if the gateway is unconfigured; callers then fall back
- * to the chunk's existing model rather than mislabeling it.
- */
-export function resolveEmbeddingModelLabel(): string | undefined {
-  try {
-    return gatewayGetModel();
-  } catch {
-    return undefined;
-  }
-}
-
 /** Currently-configured embedding model (short form without provider prefix). */
 export function getEmbeddingModelName(): string {
   return gatewayGetModel().split(':').slice(1).join(':') || 'text-embedding-3-large';

src/core/import-file.ts

@@ -8,7 +8,7 @@ import { chunkText } from './chunkers/recursive.ts';
 import { chunkCodeText, chunkCodeTextFull, detectCodeLanguage, CHUNKER_VERSION } from './chunkers/code.ts';
 import { findChunkForOffset } from './chunkers/edge-extractor.ts';
 import { extractCodeRefs, imageOfCandidates } from './link-extraction.ts';
-import { embedBatch, embedMultimodal, currentEmbeddingSignature, resolveEmbeddingModelLabel } from './embedding.ts';
+import { embedBatch, embedMultimodal, currentEmbeddingSignature } from './embedding.ts';
 import { slugifyPath, slugifyCodePath, isCodeFilePath } from './sync.ts';
 import type { ChunkInput, PageInput, PageType } from './types.ts';
 import { computeEffectiveDate } from './effective-date.ts';
@@ -716,12 +716,8 @@ export async function importFromContent(
       ? chunks.map((c) => wrapChunkForEmbedding(c.chunk_text, prefix, c.chunk_source))
       : chunks.map((c) => c.chunk_text);
     const embeddings = await embedBatch(wrappedTexts);
-    // #1717: label each chunk with the model that actually produced its
-    // vector, not the engine's hardcoded default.
-    const embedModelLabel = resolveEmbeddingModelLabel();
     for (let i = 0; i < chunks.length; i++) {
       chunks[i].embedding = embeddings[i];
-      if (embedModelLabel) chunks[i].model = embedModelLabel;
       // token_count tracks the wrapped string length so cost reporting
       // reflects what we actually sent to the embedder.
       chunks[i].token_count = Math.ceil(wrappedTexts[i].length / 4);
@@ -1145,10 +1141,7 @@ export async function importCodeFile(
     const matched = existingByKey.get(key);
     if (matched && matched.embedding) {
       // Reuse the existing embedding verbatim. No API call, no cost.
-      // #1717: carry the existing model label along with the reused vector
-      // so the upsert doesn't relabel it with the engine default.
       chunks[i]!.embedding = matched.embedding as Float32Array;
-      chunks[i]!.model = matched.model ?? undefined;
       chunks[i]!.token_count = matched.token_count ?? undefined;
     } else {
       needsEmbedIndexes.push(i);
@@ -1160,12 +1153,9 @@ export async function importCodeFile(
     try {
       const textsToEmbed = needsEmbedIndexes.map((i) => chunks[i]!.chunk_text);
       const embeddings = await embedBatch(textsToEmbed);
-      // #1717: stamp the model that produced these vectors.
-      const embedModelLabel = resolveEmbeddingModelLabel();
       for (let j = 0; j < needsEmbedIndexes.length; j++) {
         const i = needsEmbedIndexes[j]!;
         chunks[i]!.embedding = embeddings[j]!;
-        if (embedModelLabel) chunks[i]!.model = embedModelLabel;
         chunks[i]!.token_count = Math.ceil(chunks[i]!.chunk_text.length / 4);
       }
     } catch (e: unknown) {

test/ai/build-gateway-config.test.ts

@@ -25,6 +25,7 @@ import { withEnv } from '../helpers/with-env.ts';
 
 const PASSTHROUGHS: Array<{ envVar: string; recipeId: string }> = [
   { envVar: 'LLAMA_SERVER_BASE_URL', recipeId: 'llama-server' },
+  { envVar: 'LLAMA_SERVER_RERANKER_BASE_URL', recipeId: 'llama-server-reranker' },
   { envVar: 'OLLAMA_BASE_URL', recipeId: 'ollama' },
   { envVar: 'LMSTUDIO_BASE_URL', recipeId: 'lmstudio' },
   { envVar: 'LITELLM_BASE_URL', recipeId: 'litellm' },

test/cli-multimodal-integration.test.ts

@@ -11,32 +11,13 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'bun:test';
 import { PGLiteEngine } from '../src/core/pglite-engine.ts';
 import { loadConfigWithEngine, type GBrainConfig } from '../src/core/config.ts';
+import { buildGatewayConfig } from '../src/core/ai/build-gateway-config.ts';
 import {
   configureGateway,
   getEmbeddingModel,
   getMultimodalModel,
   resetGateway,
 } from '../src/core/ai/gateway.ts';
-import type { AIGatewayConfig } from '../src/core/ai/types.ts';
-
-// Mirror the cli.ts buildGatewayConfig helper exactly. Keeping a copy here
-// (instead of exporting from cli.ts) is intentional: the test asserts the
-// shape of the contract, not the helper's identity. If cli.ts drifts, the
-// e2e behavior these tests care about (DB-set value lands in gateway) still
-// holds, but a helper-shape test would also catch the drift in PR review.
-function buildGatewayConfig(c: GBrainConfig): AIGatewayConfig {
-  return {
-    embedding_model: c.embedding_model,
-    embedding_dimensions: c.embedding_dimensions,
-    embedding_multimodal_model: c.embedding_multimodal_model,
-    expansion_model: c.expansion_model,
-    chat_model: c.chat_model,
-    chat_fallback_chain: c.chat_fallback_chain,
-    base_urls: c.provider_base_urls,
-    provider_chat_options: c.provider_chat_options,
-    env: { ...process.env },
-  };
-}
 
 let engine: PGLiteEngine;
 
@@ -47,6 +28,7 @@ beforeAll(async () => {
 });
 
 afterAll(async () => {
+  resetGateway(); // don't leak this file's gateway config into shard siblings
   await engine.disconnect();
 });
 

test/embed-stale.serial.test.ts

@@ -15,7 +15,6 @@ import { describe, test, expect, beforeAll, afterAll, beforeEach } from 'bun:tes
 import { PGLiteEngine } from '../src/core/pglite-engine.ts';
 import { resetPgliteState } from './helpers/reset-pglite.ts';
 import { embedStaleForSource } from '../src/core/embed-stale.ts';
-import { configureGateway, resetGateway } from '../src/core/ai/gateway.ts';
 import type { ChunkInput } from '../src/core/types.ts';
 
 let engine: PGLiteEngine;
@@ -277,49 +276,4 @@ describe('embedStaleForSource', () => {
     // The stale text row actually got its embedding.
     expect(txtRow.embedded_at).not.toBeNull();
   });
-
-  // #1717: the backfill path must label re-embedded chunks with the model
-  // that produced the vector, and preserve the existing label on chunks it
-  // did not touch (before the fix, both were reset to the engine default).
-  test('labels re-embedded chunks with the gateway model, preserves untouched labels (#1717)', async () => {
-    configureGateway({
-      embedding_model: 'openai:text-embedding-3-large',
-      env: { OPENAI_API_KEY: 'sk-test-embed-stale-1717' },
-    });
-    try {
-      await engine.putPage('notes/model-label', {
-        type: 'note',
-        title: 'model-label',
-        compiled_truth: '# model-label\n\nseeded',
-      });
-      await engine.upsertChunks('notes/model-label', [
-        {
-          chunk_index: 0,
-          chunk_text: 'already embedded elsewhere',
-          chunk_source: 'compiled_truth',
-          embedding: new Float32Array(1536).fill(0.01),
-          model: 'voyage:voyage-3',
-          token_count: 4,
-        },
-        {
-          chunk_index: 1,
-          chunk_text: 'stale chunk needing embed',
-          chunk_source: 'compiled_truth',
-          token_count: 5,
-          embedding: undefined, // stale
-        },
-      ]);
-
-      const result = await embedStaleForSource(engine, 'default', { embedFn: fakeEmbedFn });
-      expect(result.embedded).toBe(1);
-
-      const after = await engine.getChunks('notes/model-label');
-      const preserved = after.find((c) => c.chunk_index === 0)!;
-      const reembedded = after.find((c) => c.chunk_index === 1)!;
-      expect(reembedded.model).toBe('openai:text-embedding-3-large');
-      expect(preserved.model).toBe('voyage:voyage-3');
-    } finally {
-      resetGateway();
-    }
-  });
 });

test/embed.serial.test.ts

@@ -37,8 +37,6 @@ mock.module('../src/core/embedding.ts', () => ({
   // setPageEmbeddingSignature / invalidateStaleSignatureEmbeddings resolve to
   // null via the Proxy default, so the signature value is inert here.
   currentEmbeddingSignature: () => 'test:model:1536',
-  // #1717: embed paths stamp this label on (re)embedded chunks.
-  resolveEmbeddingModelLabel: () => 'openai:text-embedding-3-large',
 }));
 
 // Import AFTER mocking.
@@ -805,34 +803,3 @@ describe('embedAllStale --source threading (D7)', () => {
     expect((firstCallOpts as { sourceId?: string }).sourceId).toBe('media-corpus');
   });
 });
-
-// #1717: content_chunks.model must record the model that actually produced
-// each vector, not the gateway/engine default.
-describe('content_chunks.model labeling (#1717)', () => {
-  test('stamps the resolved embedding model on re-embedded chunks, preserves it on untouched chunks', async () => {
-    let upserted: any[] | undefined;
-    // Chunk 0 is stale (no embedded_at) → gets re-embedded this pass.
-    // Chunk 1 is already embedded with a DIFFERENT model → must be preserved,
-    // not relabeled to the current model.
-    const chunks = [
-      { chunk_index: 0, chunk_text: 'a', chunk_source: 'compiled_truth', embedded_at: null, model: 'zeroentropyai:zembed-1', token_count: 1 },
-      { chunk_index: 1, chunk_text: 'b', chunk_source: 'compiled_truth', embedded_at: '2026-01-01', embedding: new Float32Array(1536), model: 'voyage:voyage-3', token_count: 1 },
-    ];
-    const engine = mockEngine({
-      getPage: async () => ({ slug: 'notes/x', compiled_truth: 'a', timeline: '', source_id: 'default' }),
-      getChunks: async () => chunks,
-      upsertChunks: async (_slug: string, c: any[]) => { upserted = c; },
-      setPageEmbeddingSignature: async () => null,
-    });
-
-    await runEmbedCore(engine, { slugs: ['notes/x'] });
-
-    expect(upserted).toBeDefined();
-    const byIdx = Object.fromEntries(upserted!.map(c => [c.chunk_index, c]));
-    // Re-embedded chunk carries the model that produced its vector (was
-    // mislabeled with the default before the fix).
-    expect(byIdx[0].model).toBe('openai:text-embedding-3-large');
-    // Untouched chunk keeps its original model — no wholesale relabel.
-    expect(byIdx[1].model).toBe('voyage:voyage-3');
-  });
-});

test/eval-takes-quality-gateway.test.ts

@@ -0,0 +1,57 @@
+/**
+ * eval-takes-quality gateway self-config — adapter-boundary regression
+ * (takeover of PR #2430).
+ *
+ * The old callsite spread `{ ...cfg, ...process.env }` straight into
+ * configureGateway. The gateway NEVER reads process.env at call time — it
+ * reads `_config.env` — and that spread never populated an `env` field at
+ * all, so every availability/diagnose check dereferenced `undefined.env[k]`
+ * and file-plane API keys (config.json `openai_api_key` etc.) were dropped.
+ * Routing through buildGatewayConfig fixes both. This test fails (throws)
+ * on the old code path.
+ */
+import { afterAll, describe, expect, test } from 'bun:test';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { runEvalTakesQuality } from '../src/commands/eval-takes-quality.ts';
+import { isAvailable, resetGateway } from '../src/core/ai/gateway.ts';
+import { withEnv } from './helpers/with-env.ts';
+import type { BrainEngine } from '../src/core/engine.ts';
+
+afterAll(() => {
+  resetGateway();
+});
+
+describe('runEvalTakesQuality — gateway self-config routes through buildGatewayConfig', () => {
+  test('file-plane openai_api_key reaches the gateway env (help path, engine untouched)', async () => {
+    const home = mkdtempSync(join(tmpdir(), 'gbrain-etq-gw-'));
+    try {
+      mkdirSync(join(home, '.gbrain'), { recursive: true });
+      writeFileSync(
+        join(home, '.gbrain', 'config.json'),
+        JSON.stringify({
+          engine: 'pglite',
+          database_path: join(home, '.gbrain', 'brain'),
+          openai_api_key: 'sk-file-plane-test',
+        }),
+      );
+      await withEnv(
+        {
+          GBRAIN_HOME: home,
+          OPENAI_API_KEY: undefined,
+          DATABASE_URL: undefined,
+          GBRAIN_DATABASE_URL: undefined,
+        },
+        async () => {
+          // 'help' returns before touching the engine, but the gateway is
+          // configured first — exactly the seam under test.
+          await runEvalTakesQuality({} as BrainEngine, ['--help']);
+          expect(isAvailable('embedding', 'openai:text-embedding-3-small')).toBe(true);
+        },
+      );
+    } finally {
+      rmSync(home, { recursive: true, force: true });
+    }
+  });
+});

test/import-signature-stamp.serial.test.ts

@@ -73,21 +73,4 @@ describe('importFromContent embedding_signature stamping (F1)', () => {
     await importFromContent(engine, 'concepts/unstamped', '# Unstamped\n\nbody content.', { noEmbed: true });
     expect(await signatureOf('concepts/unstamped')).toBeNull();
   });
-
-  // #1717: content_chunks.model must record the model that produced the
-  // vector (the configured gateway model), not the engine's hardcoded
-  // default. The gateway here is configured to openai:text-embedding-3-large,
-  // which differs from DEFAULT_EMBEDDING_MODEL — so this fails without the
-  // import-path model stamping.
-  test('inline embed labels content_chunks.model with the configured model (#1717)', async () => {
-    await importFromContent(engine, 'concepts/labeled', '# Labeled\n\nsome body content to chunk and embed.', {});
-    const rows = await engine.executeRaw<{ model: string }>(
-      `SELECT cc.model FROM content_chunks cc
-        JOIN pages p ON p.id = cc.page_id
-       WHERE p.slug = $1 AND p.source_id = 'default'`,
-      ['concepts/labeled'],
-    );
-    expect(rows.length).toBeGreaterThan(0);
-    for (const r of rows) expect(r.model).toBe('openai:text-embedding-3-large');
-  });
 });