onto-mcp 0.3.2 → 0.4.0

package/dist/core-runtime/config/onto-config-key-path.test.js

@@ -1,195 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { applySet, SUPPORTED_SET_PATHS } from "./onto-config-key-path.js";
-// ---------------------------------------------------------------------------
-// applySet — Review UX Redesign P5 (2026-04-21)
-// ---------------------------------------------------------------------------
-//
-// These tests cover the coercion + discriminated-union invariants the
-// `onto config set` and `edit` subcommands depend on:
-//
-//   (1) Happy paths for each supported key, round-tripping through the
-//       expected OntoReviewConfig shape.
-//   (2) Discriminated-union preservation — switching subagent.provider
-//       from `main-native` to a foreign value adds model_id/effort slots;
-//       switching back to `main-native` drops them.
-//   (3) Value coercion errors (integers, enums) returned as `ok: false`
-//       with a clear error string — caller forwards verbatim to the user.
-//   (4) Unsupported paths return an error pointing to `edit` for richer
-//       spec objects.
-// ---------------------------------------------------------------------------
-describe("applySet — supported paths declared", () => {
-    it("SUPPORTED_SET_PATHS matches README / help text exactly", () => {
-        expect(SUPPORTED_SET_PATHS).toEqual([
-            "teamlead.model",
-            "subagent.provider",
-            "subagent.model_id",
-            "subagent.effort",
-            "max_concurrent_lenses",
-            "lens_deliberation",
-        ]);
-    });
-});
-describe("applySet — teamlead.model", () => {
-    it("accepts `main` literal", () => {
-        const r = applySet({}, "teamlead.model", "main");
-        expect(r.ok).toBe(true);
-        if (r.ok)
-            expect(r.config.teamlead).toEqual({ model: "main" });
-    });
-    it("rejects foreign teamlead values and points to `edit`", () => {
-        const r = applySet({}, "teamlead.model", "codex");
-        expect(r.ok).toBe(false);
-        if (!r.ok)
-            expect(r.error).toMatch(/edit/);
-    });
-});
-describe("applySet — subagent.provider (discriminated-union preservation)", () => {
-    it("main-native → main-native is idempotent", () => {
-        const r = applySet({ subagent: { provider: "main-native" } }, "subagent.provider", "main-native");
-        expect(r.ok).toBe(true);
-        if (r.ok)
-            expect(r.config.subagent).toEqual({ provider: "main-native" });
-    });
-    it("main-native → codex preserves (empty) model_id slot", () => {
-        const r = applySet({ subagent: { provider: "main-native" } }, "subagent.provider", "codex");
-        expect(r.ok).toBe(true);
-        if (r.ok) {
-            expect(r.config.subagent).toEqual({ provider: "codex", model_id: "" });
-        }
-    });
-    it("codex → litellm carries over model_id + effort (user may prune later)", () => {
-        const r = applySet({
-            subagent: { provider: "codex", model_id: "gpt-5.4", effort: "high" },
-        }, "subagent.provider", "litellm");
-        expect(r.ok).toBe(true);
-        if (r.ok) {
-            expect(r.config.subagent).toEqual({
-                provider: "litellm",
-                model_id: "gpt-5.4",
-                effort: "high",
-            });
-        }
-    });
-    it("codex → main-native drops model_id + effort (union branch change)", () => {
-        const r = applySet({
-            subagent: { provider: "codex", model_id: "gpt-5.4", effort: "high" },
-        }, "subagent.provider", "main-native");
-        expect(r.ok).toBe(true);
-        if (r.ok)
-            expect(r.config.subagent).toEqual({ provider: "main-native" });
-    });
-    it("rejects unknown provider", () => {
-        const r = applySet({}, "subagent.provider", "hal9000");
-        expect(r.ok).toBe(false);
-    });
-});
-describe("applySet — subagent.model_id", () => {
-    it("requires a foreign provider to be set first", () => {
-        const r = applySet({ subagent: { provider: "main-native" } }, "subagent.model_id", "gpt-5.4");
-        expect(r.ok).toBe(false);
-        if (!r.ok)
-            expect(r.error).toMatch(/foreign provider/);
-    });
-    it("rejects empty model_id", () => {
-        const r = applySet({
-            subagent: { provider: "codex", model_id: "prev" },
-        }, "subagent.model_id", "");
-        expect(r.ok).toBe(false);
-    });
-    it("sets model_id on codex subagent", () => {
-        const r = applySet({ subagent: { provider: "codex", model_id: "" } }, "subagent.model_id", "gpt-5.4");
-        expect(r.ok).toBe(true);
-        if (r.ok) {
-            expect(r.config.subagent).toEqual({
-                provider: "codex",
-                model_id: "gpt-5.4",
-            });
-        }
-    });
-    it("preserves effort when updating model_id", () => {
-        const r = applySet({
-            subagent: { provider: "codex", model_id: "gpt-5.4", effort: "high" },
-        }, "subagent.model_id", "gpt-5.4-preview");
-        expect(r.ok).toBe(true);
-        if (r.ok) {
-            expect(r.config.subagent).toEqual({
-                provider: "codex",
-                model_id: "gpt-5.4-preview",
-                effort: "high",
-            });
-        }
-    });
-});
-describe("applySet — subagent.effort", () => {
-    it("requires a foreign provider", () => {
-        const r = applySet({ subagent: { provider: "main-native" } }, "subagent.effort", "high");
-        expect(r.ok).toBe(false);
-    });
-    it("sets effort on a foreign subagent", () => {
-        const r = applySet({ subagent: { provider: "codex", model_id: "gpt-5.4" } }, "subagent.effort", "xhigh");
-        expect(r.ok).toBe(true);
-        if (r.ok) {
-            expect(r.config.subagent).toEqual({
-                provider: "codex",
-                model_id: "gpt-5.4",
-                effort: "xhigh",
-            });
-        }
-    });
-});
-describe("applySet — max_concurrent_lenses", () => {
-    it("accepts positive integer", () => {
-        const r = applySet({}, "max_concurrent_lenses", "9");
-        expect(r.ok).toBe(true);
-        if (r.ok)
-            expect(r.config.max_concurrent_lenses).toBe(9);
-    });
-    it("rejects zero / negative / float / non-numeric", () => {
-        expect(applySet({}, "max_concurrent_lenses", "0").ok).toBe(false);
-        expect(applySet({}, "max_concurrent_lenses", "-1").ok).toBe(false);
-        expect(applySet({}, "max_concurrent_lenses", "2.5").ok).toBe(false);
-        expect(applySet({}, "max_concurrent_lenses", "six").ok).toBe(false);
-    });
-});
-describe("applySet — lens_deliberation", () => {
-    it("accepts synthesizer-only", () => {
-        const r = applySet({}, "lens_deliberation", "synthesizer-only");
-        expect(r.ok).toBe(true);
-        if (r.ok)
-            expect(r.config.lens_deliberation).toBe("synthesizer-only");
-    });
-    it("accepts sendmessage-a2a", () => {
-        const r = applySet({}, "lens_deliberation", "sendmessage-a2a");
-        expect(r.ok).toBe(true);
-        if (r.ok)
-            expect(r.config.lens_deliberation).toBe("sendmessage-a2a");
-    });
-    it("rejects unknown deliberation value", () => {
-        const r = applySet({}, "lens_deliberation", "loud");
-        expect(r.ok).toBe(false);
-    });
-});
-describe("applySet — unsupported paths", () => {
-    it("rejects unknown key path with hint to `edit`", () => {
-        const r = applySet({}, "review_mode", "full");
-        expect(r.ok).toBe(false);
-        if (!r.ok) {
-            expect(r.error).toMatch(/edit/);
-            expect(r.error).toMatch(/Supported paths/);
-        }
-    });
-    it("rejects nested teamlead.model.provider path (use edit)", () => {
-        const r = applySet({}, "teamlead.model.provider", "codex");
-        expect(r.ok).toBe(false);
-    });
-});
-describe("applySet — purity", () => {
-    it("does not mutate the input config", () => {
-        const original = {
-            subagent: { provider: "codex", model_id: "gpt-5.4", effort: "high" },
-        };
-        const snapshot = structuredClone(original);
-        applySet(original, "subagent.provider", "main-native");
-        expect(original).toEqual(snapshot);
-    });
-});

package/dist/core-runtime/config/onto-config-preview.js

@@ -1,108 +0,0 @@
-/**
- * Review UX Redesign P5 — `onto config validate` / `onto config show`
- * preview helper.
- *
- * # What this module is
- *
- * A pure function that takes a validated `OntoReviewConfig` + host signals
- * and returns a deterministic textual preview showing:
- *   (a) which topology shape the config would derive to,
- *   (b) which canonical `TopologyId` that shape would map to under the
- *       current environment, and
- *   (c) the exact validation or mapping point that would stop execution.
- *
- * # Why it exists
- *
- * The onboard + config-edit UX promise is "what you configured is what
- * runs". Without a preview step, users only see the runtime outcome after
- * starting a review (via the `[topology]` STDERR trace). This helper
- * surfaces the derivation BEFORE any review call, making config-time and
- * run-time answer the same question with the same inputs.
- *
- * # How it relates
- *
- * - Input: validated `OntoReviewConfig` (from `validateReviewConfig`) +
- *   detected axes (from `detectReviewAxes`).
- * - Output: a typed `Preview` object (topology id, shape) plus
- *   a rendered string for CLI display.
- * - Shares derivation/mapping logic with `resolveAxisFirstTopology` so
- *   the preview and the runtime can never drift.
- */
-import { shapeToTopologyId } from "../review/shape-to-topology-id.js";
-import { deriveTopologyShape, } from "../review/topology-shape-derivation.js";
-// ---------------------------------------------------------------------------
-// Main
-// ---------------------------------------------------------------------------
-/**
- * Run derivation + mapping preview. Mirrors the
- * runtime resolver's axis-first path so the output matches what the user
- * would see in `[topology]` STDERR during a real review invocation.
- */
-export function previewTopologyDerivation(config, signals) {
-    const trace = [];
-    const derivation = deriveTopologyShape(config, signals);
-    for (const line of derivation.ok ? derivation.derived.trace : derivation.trace) {
-        trace.push(`derive: ${line}`);
-    }
-    if (!derivation.ok) {
-        return {
-            ok: false,
-            reason: derivation.reasons[0] ?? "topology shape derivation failed",
-            trace,
-        };
-    }
-    const mapping = shapeToTopologyId({
-        shape: derivation.derived.shape,
-        subagent_provider: derivation.derived.subagent_provider,
-        signals: {
-            claudeHost: signals.claudeHost,
-            codexSessionActive: signals.codexSessionActive,
-        },
-    });
-    for (const line of mapping.trace) {
-        trace.push(`map: ${line}`);
-    }
-    if (!mapping.ok) {
-        return {
-            ok: false,
-            reason: mapping.reason,
-            trace,
-        };
-    }
-    trace.push(`result: shape=${derivation.derived.shape} topology=${mapping.topology_id}`);
-    return {
-        ok: true,
-        shape: derivation.derived.shape,
-        topology_id: mapping.topology_id,
-        trace,
-    };
-}
-// ---------------------------------------------------------------------------
-// Rendering
-// ---------------------------------------------------------------------------
-/**
- * Render a preview result as a human-readable block for CLI display.
- * Handles both success and failure outputs. Keep the format stable — the
- * onboard prose and `onto config` output use the same template so the
- * user learns one visual vocabulary.
- */
-export function renderPreview(result) {
-    const lines = [];
-    if (result.ok) {
-        lines.push("## Topology derivation preview");
-        lines.push("");
-        lines.push(`  shape:        ${result.shape}`);
-        lines.push(`  topology_id:  ${result.topology_id}`);
-    }
-    else {
-        lines.push("## Topology derivation preview — FAILED");
-        lines.push("");
-        lines.push(`  reason: ${result.reason}`);
-    }
-    lines.push("");
-    lines.push("  Trace:");
-    for (const line of result.trace) {
-        lines.push(`    ${line}`);
-    }
-    return lines.join("\n");
-}

package/dist/core-runtime/config/onto-config-preview.test.js

@@ -1,132 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { previewTopologyDerivation, renderPreview, } from "./onto-config-preview.js";
-// ---------------------------------------------------------------------------
-// previewTopologyDerivation — Review UX Redesign P5 (2026-04-21)
-// ---------------------------------------------------------------------------
-//
-// These tests verify that the preview helper mirrors the runtime resolver's
-// axis-first path:
-//
-//   (1) Happy path — a valid config + suitable host → correct shape +
-//       canonical TopologyId + degraded=false.
-//   (2) Derivation failure (a2a + no teams) → degrades to main_native.
-//   (3) Mapping failure (main_foreign + litellm) → degrades to main_native.
-//   (4) No Claude, no Codex → main_native unmappable → preview fails
-//       (runtime would fall through to legacy ladder / no_host).
-//   (5) renderPreview produces a stable human-readable block for CLI use.
-// ---------------------------------------------------------------------------
-const CLAUDE_NO_TEAMS = {
-    claudeHost: true,
-    codexSessionActive: false,
-    experimentalAgentTeams: false,
-};
-const CLAUDE_TEAMS = {
-    claudeHost: true,
-    codexSessionActive: false,
-    experimentalAgentTeams: true,
-};
-const CODEX_HOST = {
-    claudeHost: false,
-    codexSessionActive: true,
-    experimentalAgentTeams: false,
-};
-const NEITHER = {
-    claudeHost: false,
-    codexSessionActive: false,
-    experimentalAgentTeams: false,
-};
-describe("previewTopologyDerivation — happy paths", () => {
-    it("empty config + Claude host → main_native / cc-main-agent-subagent", () => {
-        const r = previewTopologyDerivation({}, CLAUDE_NO_TEAMS);
-        expect(r.ok).toBe(true);
-        if (r.ok) {
-            expect(r.shape).toBe("main_native");
-            expect(r.topology_id).toBe("cc-main-agent-subagent");
-            expect(r.degraded).toBe(false);
-        }
-    });
-    it("teams + main-native → main-teams_native / cc-teams-agent-subagent", () => {
-        const config = {
-            teamlead: { model: "main" },
-            subagent: { provider: "main-native" },
-        };
-        const r = previewTopologyDerivation(config, CLAUDE_TEAMS);
-        expect(r.ok).toBe(true);
-        if (r.ok) {
-            expect(r.shape).toBe("main-teams_native");
-            expect(r.topology_id).toBe("cc-teams-agent-subagent");
-            expect(r.degraded).toBe(false);
-        }
-    });
-    it("Codex host + main-native → main_native / codex-main-subprocess", () => {
-        const r = previewTopologyDerivation({ subagent: { provider: "main-native" } }, CODEX_HOST);
-        expect(r.ok).toBe(true);
-        if (r.ok) {
-            expect(r.shape).toBe("main_native");
-            expect(r.topology_id).toBe("codex-main-subprocess");
-        }
-    });
-});
-describe("previewTopologyDerivation — degrade paths", () => {
-    it("a2a without teams → degrades to main_native", () => {
-        const config = {
-            subagent: { provider: "main-native" },
-            lens_deliberation: "sendmessage-a2a",
-        };
-        const r = previewTopologyDerivation(config, CLAUDE_NO_TEAMS);
-        expect(r.ok).toBe(true);
-        if (r.ok) {
-            expect(r.degraded).toBe(true);
-            expect(r.shape).toBe("main_native");
-            expect(r.topology_id).toBe("cc-main-agent-subagent");
-            expect(r.trace.some((l) => l.startsWith("degrade:"))).toBe(true);
-        }
-    });
-    it("main_foreign + litellm (Claude host) → degrades to main_native", () => {
-        const config = {
-            subagent: { provider: "litellm", model_id: "llama-8b" },
-        };
-        const r = previewTopologyDerivation(config, CLAUDE_NO_TEAMS);
-        expect(r.ok).toBe(true);
-        if (r.ok) {
-            expect(r.degraded).toBe(true);
-            expect(r.topology_id).toBe("cc-main-agent-subagent");
-            expect(r.trace.some((l) => l.includes("main_foreign(litellm)"))).toBe(true);
-        }
-    });
-});
-describe("previewTopologyDerivation — total failure (no host)", () => {
-    it("main_native unmappable → preview fails with explanatory reason", () => {
-        const r = previewTopologyDerivation({}, NEITHER);
-        expect(r.ok).toBe(false);
-        if (!r.ok) {
-            expect(r.reason).toContain("main_native fallback");
-            expect(r.trace.some((l) => l.includes("unmappable"))).toBe(true);
-        }
-    });
-});
-describe("renderPreview — human-readable output", () => {
-    it("success block includes shape + topology_id + trace", () => {
-        const r = previewTopologyDerivation({}, CLAUDE_NO_TEAMS);
-        const text = renderPreview(r);
-        expect(text).toContain("Topology derivation preview");
-        expect(text).toContain("shape:");
-        expect(text).toContain("cc-main-agent-subagent");
-        expect(text).toContain("Trace:");
-    });
-    it("degraded block includes (degraded) marker and fallback note", () => {
-        const config = {
-            subagent: { provider: "litellm", model_id: "llama-8b" },
-        };
-        const r = previewTopologyDerivation(config, CLAUDE_NO_TEAMS);
-        const text = renderPreview(r);
-        expect(text).toContain("(degraded)");
-        expect(text).toContain("P3 universal fallback");
-    });
-    it("failure block includes reason + FAILED header", () => {
-        const r = previewTopologyDerivation({}, NEITHER);
-        const text = renderPreview(r);
-        expect(text).toContain("FAILED");
-        expect(text).toContain("reason:");
-    });
-});

package/dist/core-runtime/discovery/config-chain.js

@@ -1,118 +0,0 @@
-import path from "node:path";
-import { fileExists, readYamlDocument } from "../review/review-artifact-utils.js";
-import { adoptProfile, mergeOrthogonalFields, } from "./config-profile.js";
-async function readConfigAt(dir) {
-    const configPath = path.join(dir, ".onto", "config.yml");
-    if (!(await fileExists(configPath))) {
-        return {};
-    }
-    const raw = await readYamlDocument(configPath);
-    if (raw === null || typeof raw !== "object") {
-        return {};
-    }
-    assertKnownConfigKeys(raw, configPath);
-    return raw;
-}
-const TOP_LEVEL_CONFIG_KEYS = [
-    "llm",
-    "review",
-    "review_mode",
-    "max_concurrent_lenses",
-    "domain",
-    "secondary_domains",
-    "domains",
-    "excluded_names",
-    "max_listing_depth",
-    "max_listing_entries",
-    "max_embed_lines",
-    "output_language",
-    "learning_extract_mode",
-    "main_llm",
-    "lens_agent_teams_mode",
-];
-function assertKnownConfigKeys(raw, configPath) {
-    const allowed = new Set(TOP_LEVEL_CONFIG_KEYS);
-    const unknown = Object.keys(raw).filter((key) => !allowed.has(key));
-    if (unknown.length === 0)
-        return;
-    throw new Error([
-        `Unsupported .onto config key(s) in ${configPath}: ${unknown.join(", ")}`,
-        "Supported top-level keys:",
-        `  ${TOP_LEVEL_CONFIG_KEYS.join(", ")}`,
-        "LLM selection belongs under:",
-        "  llm:",
-        "    auth: oauth | api_key | local",
-        "    provider: openai | anthropic | grok | lmstudio",
-        "    model: <model-id>",
-        "    effort: high",
-        "    base_url: <optional>",
-    ].join("\n"));
-}
-/**
- * Orthogonal-only config chain resolver.
- *
- * # What this is
- *
- * Reads home + project `.onto/config.yml`, merges ONLY the orthogonal
- * fields (output_language, domains, review_mode, learning_extract_mode,
- * etc. — see `config-profile.ts:PROFILE_FIELDS` for the complement set),
- * and returns the merged partial config without running `adoptProfile`.
- *
- * # Why this exists
- *
- * Callers that only need a single orthogonal field (e.g.,
- * `resolveReviewSessionExtractMode` reading `learning_extract_mode`) do
- * NOT need provider-profile validation. Routing them through
- * `resolveConfigChain` caused false fail-fast throws once PR #96's atomic
- * profile adoption started rejecting "no provider profile declared"
- * configs — a test/tooling fixture that cares only about orthogonal
- * settings would be blocked by an unrelated profile gate.
- *
- * # How it relates
- *
- * Same underlying `readConfigAt` + `mergeOrthogonalFields` that
- * `resolveConfigChain` uses, sequenced without profile adoption.
- * Callers that need a full config continue to use `resolveConfigChain`.
- */
-export async function resolveOrthogonalConfigChain(ontoHome, projectRoot) {
-    const homeConfig = await readConfigAt(ontoHome);
-    const sameRoot = ontoHome === projectRoot;
-    const projectConfig = sameRoot ? homeConfig : await readConfigAt(projectRoot);
-    return mergeOrthogonalFields(homeConfig, projectConfig);
-}
-/**
- * Config chain resolver (home + project) with atomic profile adoption.
- *
- * # Behavior
- *
- *   - Project declares any profile fields  → project owns the profile atomically.
- *   - Project declares none, home declares some → global profile adopted silently.
- *   - Neither side declares any profile fields → empty profile returned.
- *
- * Orthogonal fields (output_language, domains, review_mode, listing limits,
- * learning_extract_mode, etc.) continue to merge last-wins — they do not
- * carry cross-provider semantics.
- *
- * # Why atomic adoption still runs
- *
- * Atomic ownership prevents mixed provider state from different config files.
- * `extractProfileFields` + `adoptProfile` transfer PROFILE_FIELDS as a group
- * from exactly one source.
- */
-export async function resolveConfigChain(ontoHome, projectRoot) {
-    const homeConfig = await readConfigAt(ontoHome);
-    const sameRoot = ontoHome === projectRoot;
-    const projectConfig = sameRoot ? homeConfig : await readConfigAt(projectRoot);
-    const homePath = path.join(ontoHome, ".onto", "config.yml");
-    const projectPath = path.join(projectRoot, ".onto", "config.yml");
-    const adoption = adoptProfile({
-        home: homeConfig,
-        project: projectConfig,
-        homePath,
-        projectPath,
-        sameRoot,
-    });
-    const orthogonal = mergeOrthogonalFields(homeConfig, projectConfig);
-    const merged = { ...orthogonal, ...adoption.profile };
-    return merged;
-}

package/dist/core-runtime/discovery/config-chain.test.js

@@ -1,103 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { resolveConfigChain } from "./config-chain.js";
-// ---------------------------------------------------------------------------
-// config-chain — P9.5 graceful-ignore regression guard (2026-04-21).
-//
-// P9.5 retired `legacy-field-deprecation.ts`. Legacy provider-profile
-// fields (host_runtime, execution_realization, execution_mode,
-// executor_realization, api_provider) in YAML no longer throw
-// `LegacyFieldRemovedError` at config load. The OntoConfig type omits
-// them, so typed code cannot read them; Record-cast paths can still
-// see the values, but no production consumer does so — the fields are
-// effectively inert.
-//
-// These tests lock in the graceful-ignore contract so a future refactor
-// that reintroduces a throw surfaces as a test failure, and so the
-// "config loads + downstream path still works" invariant is explicit.
-// ---------------------------------------------------------------------------
-const cleanupDirs = [];
-function makeTmpDir(prefix) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), `onto-p95-${prefix}-`));
-    cleanupDirs.push(dir);
-    return dir;
-}
-function writeConfig(dir, yaml) {
-    fs.mkdirSync(path.join(dir, ".onto"), { recursive: true });
-    fs.writeFileSync(path.join(dir, ".onto", "config.yml"), yaml, "utf8");
-}
-afterEach(() => {
-    while (cleanupDirs.length > 0) {
-        const dir = cleanupDirs.pop();
-        if (dir) {
-            try {
-                fs.rmSync(dir, { recursive: true, force: true });
-            }
-            catch {
-                /* ignore */
-            }
-        }
-    }
-});
-describe("resolveConfigChain — P9.5 legacy field graceful ignore", () => {
-    it("legacy-only project config → loads without throw; OntoConfig type omits legacy keys", async () => {
-        // Pre-P9.5: `host_runtime: codex` + no `review:` block threw
-        // LegacyFieldRemovedError. Post-P9.5: loads successfully.
-        const homeDir = makeTmpDir("legacy-h");
-        const projDir = makeTmpDir("legacy-p");
-        writeConfig(projDir, "host_runtime: codex\napi_provider: codex\n");
-        // Must not throw. The promise resolving is the primary invariant.
-        const config = await resolveConfigChain(homeDir, projDir);
-        expect(config).toBeDefined();
-        // The OntoConfig type omits the legacy fields — typed access via
-        // `config.host_runtime` would be a TypeScript error. No runtime
-        // consumer reads these values; they remain in the underlying
-        // Record only for Record-cast backward compatibility.
-        expect(config.review).toBeUndefined();
-        expect(config.codex).toBeUndefined();
-    });
-    it("legacy fields + review block → config loads, review block survives and is authoritative", async () => {
-        const homeDir = makeTmpDir("mixed-h");
-        const projDir = makeTmpDir("mixed-p");
-        writeConfig(projDir, [
-            "host_runtime: anthropic", // legacy ghost field — not consumed
-            "review:",
-            "  subagent:",
-            "    provider: codex",
-            "    model_id: gpt-5.4",
-            "codex:",
-            "  model: gpt-5.4",
-        ].join("\n"));
-        const config = await resolveConfigChain(homeDir, projDir);
-        // Review block (orthogonal) + codex namespace (profile) are the
-        // authoritative sources post-P9.5.
-        expect(config.review?.subagent?.provider).toBe("codex");
-        expect(config.codex?.model).toBe("gpt-5.4");
-    });
-    it("legacy-only home + absent project → home profile adopted via atomic adoption", async () => {
-        // Home has legacy-only YAML + a codex namespace. Pre-P9.5 the
-        // legacy throw would fire before adoption ran. Post-P9.5 adoption
-        // sees `hasAnyProfileField(home) === true` (via `codex`) and picks
-        // up the home profile; legacy fields are inert.
-        const homeDir = makeTmpDir("home-legacy-h");
-        const projDir = makeTmpDir("home-legacy-p");
-        writeConfig(homeDir, ["host_runtime: codex", "codex:", "  model: gpt-5.4"].join("\n"));
-        // No project config.
-        const config = await resolveConfigChain(homeDir, projDir);
-        expect(config.codex?.model).toBe("gpt-5.4");
-    });
-    it("completely empty configs → loads without throw (resolver owns no_host fail-fast downstream)", async () => {
-        // Pre-P9.4 `buildBothIncompleteError` threw; pre-P9.5
-        // `LegacyFieldRemovedError` threw when legacy present. Post-P9.5
-        // config load never throws for these cases — the topology resolver
-        // is the sole fail-fast point via `no_host`.
-        const homeDir = makeTmpDir("empty-h");
-        const projDir = makeTmpDir("empty-p");
-        const config = await resolveConfigChain(homeDir, projDir);
-        expect(config).toBeDefined();
-        expect(config.codex).toBeUndefined();
-        expect(config.review).toBeUndefined();
-    });
-});