onto-mcp 0.3.2 → 0.4.0

package/dist/core-runtime/review/review-config-validator.test.js

@@ -1,236 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { validateReviewConfig } from "./review-config-validator.js";
-// ---------------------------------------------------------------------------
-// validateReviewConfig — Review UX Redesign P1 (2026-04-20)
-// ---------------------------------------------------------------------------
-//
-// These tests lock in three kinds of invariants:
-//
-//   (1) Happy paths — every config variation shown in design doc §3.2
-//       parses to the expected OntoReviewConfig with no errors.
-//
-//   (2) Discriminated-union enforcement — the YAML cast in readConfigAt
-//       can silently allow `main-native + model_id`, so the validator
-//       must reject it explicitly. Same for foreign providers missing
-//       model_id.
-//
-//   (3) Cross-field constraints — lens_deliberation=sendmessage-a2a
-//       with an external teamlead is statically invalid and must fail
-//       at validation time (not runtime).
-// ---------------------------------------------------------------------------
-describe("validateReviewConfig — happy paths", () => {
-    it("accepts undefined / null as empty config (universal fallback)", () => {
-        const a = validateReviewConfig(undefined);
-        expect(a.ok).toBe(true);
-        if (a.ok)
-            expect(a.config).toEqual({});
-        const b = validateReviewConfig(null);
-        expect(b.ok).toBe(true);
-        if (b.ok)
-            expect(b.config).toEqual({});
-    });
-    it("accepts empty object as empty config", () => {
-        const r = validateReviewConfig({});
-        expect(r.ok).toBe(true);
-        if (r.ok)
-            expect(r.config).toEqual({});
-    });
-    it("accepts universal fallback (teamlead=main, subagent=main-native)", () => {
-        const r = validateReviewConfig({
-            teamlead: { model: "main" },
-            subagent: { provider: "main-native" },
-        });
-        expect(r.ok).toBe(true);
-        if (r.ok) {
-            expect(r.config.teamlead).toEqual({ model: "main" });
-            expect(r.config.subagent).toEqual({ provider: "main-native" });
-        }
-    });
-    it("accepts Claude Code + codex subagent + effort + concurrency", () => {
-        const r = validateReviewConfig({
-            teamlead: { model: "main" },
-            subagent: { provider: "codex", model_id: "gpt-5.4", effort: "high" },
-            max_concurrent_lenses: 6,
-            lens_deliberation: "synthesizer-only",
-        });
-        expect(r.ok).toBe(true);
-        if (r.ok) {
-            expect(r.config.subagent).toEqual({
-                provider: "codex",
-                model_id: "gpt-5.4",
-                effort: "high",
-            });
-            expect(r.config.max_concurrent_lenses).toBe(6);
-            expect(r.config.lens_deliberation).toBe("synthesizer-only");
-        }
-    });
-    it("accepts Claude Code + a2a deliberation (teamlead=main)", () => {
-        const r = validateReviewConfig({
-            teamlead: { model: "main" },
-            subagent: { provider: "main-native" },
-            lens_deliberation: "sendmessage-a2a",
-        });
-        expect(r.ok).toBe(true);
-    });
-    it("accepts codex-nested (teamlead=codex external, subagent=codex)", () => {
-        const r = validateReviewConfig({
-            teamlead: {
-                model: { provider: "codex", model_id: "gpt-5.4", effort: "high" },
-            },
-            subagent: { provider: "codex", model_id: "gpt-5.4" },
-        });
-        expect(r.ok).toBe(true);
-        if (r.ok) {
-            expect(r.config.teamlead?.model).toEqual({
-                provider: "codex",
-                model_id: "gpt-5.4",
-                effort: "high",
-            });
-        }
-    });
-    it("accepts litellm subagent without effort", () => {
-        const r = validateReviewConfig({
-            subagent: { provider: "litellm", model_id: "llama-8b" },
-            max_concurrent_lenses: 2,
-        });
-        expect(r.ok).toBe(true);
-        if (r.ok) {
-            expect(r.config.subagent).toEqual({
-                provider: "litellm",
-                model_id: "llama-8b",
-            });
-        }
-    });
-});
-describe("validateReviewConfig — structural rejections", () => {
-    it("rejects non-object review block", () => {
-        const r = validateReviewConfig("string-config");
-        expect(r.ok).toBe(false);
-        if (!r.ok) {
-            expect(r.errors.some((e) => e.path === "review")).toBe(true);
-        }
-    });
-    it("rejects array as review block", () => {
-        const r = validateReviewConfig([1, 2, 3]);
-        expect(r.ok).toBe(false);
-    });
-    it("rejects unknown top-level keys", () => {
-        const r = validateReviewConfig({ unknown_field: 1 });
-        expect(r.ok).toBe(false);
-        if (!r.ok) {
-            expect(r.errors.some((e) => e.path === "review.unknown_field")).toBe(true);
-        }
-    });
-    it("rejects teamlead without model field", () => {
-        const r = validateReviewConfig({ teamlead: {} });
-        expect(r.ok).toBe(false);
-        if (!r.ok) {
-            expect(r.errors.some((e) => e.path === "review.teamlead.model")).toBe(true);
-        }
-    });
-});
-describe("validateReviewConfig — discriminated-union enforcement", () => {
-    it("rejects subagent.provider=main-native with model_id", () => {
-        const r = validateReviewConfig({
-            subagent: { provider: "main-native", model_id: "anything" },
-        });
-        expect(r.ok).toBe(false);
-        if (!r.ok) {
-            expect(r.errors.some((e) => e.path === "review.subagent.model_id")).toBe(true);
-        }
-    });
-    it("rejects subagent.provider=main-native with effort", () => {
-        const r = validateReviewConfig({
-            subagent: { provider: "main-native", effort: "high" },
-        });
-        expect(r.ok).toBe(false);
-        if (!r.ok) {
-            expect(r.errors.some((e) => e.path === "review.subagent.effort")).toBe(true);
-        }
-    });
-    it("rejects foreign subagent without model_id", () => {
-        const r = validateReviewConfig({
-            subagent: { provider: "codex" },
-        });
-        expect(r.ok).toBe(false);
-        if (!r.ok) {
-            expect(r.errors.some((e) => e.path === "review.subagent.model_id")).toBe(true);
-        }
-    });
-    it("rejects unknown subagent provider", () => {
-        const r = validateReviewConfig({
-            subagent: { provider: "unknown-ai" },
-        });
-        expect(r.ok).toBe(false);
-        if (!r.ok) {
-            expect(r.errors.some((e) => e.path === "review.subagent.provider")).toBe(true);
-        }
-    });
-    it("rejects teamlead.model=main-native (only subagent can be main-native)", () => {
-        // ExplicitModelSpec type restricts provider to foreign providers only.
-        // "main-native" under teamlead.model (as object.provider) must be rejected.
-        const r = validateReviewConfig({
-            teamlead: {
-                model: { provider: "main-native", model_id: "x" },
-            },
-        });
-        expect(r.ok).toBe(false);
-        if (!r.ok) {
-            expect(r.errors.some((e) => e.path === "review.teamlead.model.provider")).toBe(true);
-        }
-    });
-    it("rejects explicit teamlead without model_id", () => {
-        const r = validateReviewConfig({
-            teamlead: { model: { provider: "codex" } },
-        });
-        expect(r.ok).toBe(false);
-        if (!r.ok) {
-            expect(r.errors.some((e) => e.path === "review.teamlead.model.model_id")).toBe(true);
-        }
-    });
-});
-describe("validateReviewConfig — scalar axis constraints", () => {
-    it("rejects non-integer concurrency", () => {
-        const r = validateReviewConfig({ max_concurrent_lenses: 2.5 });
-        expect(r.ok).toBe(false);
-    });
-    it("rejects zero / negative concurrency", () => {
-        expect(validateReviewConfig({ max_concurrent_lenses: 0 }).ok).toBe(false);
-        expect(validateReviewConfig({ max_concurrent_lenses: -1 }).ok).toBe(false);
-    });
-    it("rejects non-numeric concurrency (e.g. string)", () => {
-        const r = validateReviewConfig({ max_concurrent_lenses: "6" });
-        expect(r.ok).toBe(false);
-    });
-    it("rejects unknown deliberation value", () => {
-        const r = validateReviewConfig({ lens_deliberation: "whatever" });
-        expect(r.ok).toBe(false);
-        if (!r.ok) {
-            expect(r.errors.some((e) => e.path === "review.lens_deliberation")).toBe(true);
-        }
-    });
-});
-describe("validateReviewConfig — cross-field constraints", () => {
-    it("rejects sendmessage-a2a with external teamlead", () => {
-        const r = validateReviewConfig({
-            teamlead: {
-                model: { provider: "codex", model_id: "gpt-5.4" },
-            },
-            subagent: { provider: "main-native" },
-            lens_deliberation: "sendmessage-a2a",
-        });
-        expect(r.ok).toBe(false);
-        if (!r.ok) {
-            expect(r.errors.some((e) => e.path === "review.lens_deliberation")).toBe(true);
-        }
-    });
-    it("accepts sendmessage-a2a with implicit teamlead (model=main) — absent teamlead block", () => {
-        // teamlead 블록 미기재 시 runtime 기본값 = main, 따라서 cross-field 제약 미발동.
-        // D=true 검증은 runtime 책임 (P1 syntactic 경계 밖).
-        const r = validateReviewConfig({
-            subagent: { provider: "main-native" },
-            lens_deliberation: "sendmessage-a2a",
-        });
-        expect(r.ok).toBe(true);
-    });
-});

package/dist/core-runtime/review/shape-pipeline-audit.test.js

@@ -1,311 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { PR_A_SUPPORTED_TOPOLOGIES, TOPOLOGY_CATALOG, resolveExecutionTopology, } from "./execution-topology-resolver.js";
-import { PR_B_SUPPORTED_TOPOLOGIES } from "../cli/topology-executor-mapping.js";
-import { shapeToTopologyId } from "./shape-to-topology-id.js";
-import { deriveTopologyShape, } from "./topology-shape-derivation.js";
-// ---------------------------------------------------------------------------
-// P8 — 6 Shape × 7 Pipeline Step Smoke Audit
-// ---------------------------------------------------------------------------
-//
-// Purpose: **design-integrity verification** across the 6 canonical
-// TopologyShapes introduced by P1–P5. The audit answers three questions:
-//
-//   (1) Can each shape be derived from a valid OntoReviewConfig + signals?
-//   (2) Does each shape map to a canonical TopologyId in the existing 10-
-//       value catalog (not null, not generic-*)?
-//   (3) For each shape, what fraction of the 7-step review pipeline is
-//       currently wired for spawn-time execution vs blocked on a future
-//       PR (PR-C nested-codex, PR-D agent-teams deliberation)?
-//
-// The test is **hermetic** — no real LLM calls, no spawn. Each table row
-// exercises the dispatch path (resolver + mapping + executor support set)
-// and records the expected state, so regressions surface in CI instead of
-// during a real review invocation.
-//
-// Pipeline steps referenced:
-//   1. interpret         — InvocationInterpretation (topology-agnostic)
-//   2. bind              — target binding + session creation (topology-agnostic)
-//   3. start-session     — session artifact seed (topology-agnostic)
-//   4. materialize       — prompt packets (topology-agnostic per sketch v3 §2)
-//   5. dispatch lenses   — **topology-specific**, the sole shape-sensitive step
-//   6. synthesize        — single-lens context, topology-agnostic
-//   7. complete          — session close, topology-agnostic
-//
-// Only step 5 is shape-sensitive. Steps 1-4/6-7 consume the resolved
-// ExecutionTopology but their behaviour is the same for any valid topology.
-// The audit therefore focuses coverage on step 5 while asserting catalog
-// integrity for steps 1-4/6-7.
-// ---------------------------------------------------------------------------
-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 PLAIN_TERMINAL = {
-    claudeHost: false,
-    codexSessionActive: false,
-    experimentalAgentTeams: false,
-};
-// ---------------------------------------------------------------------------
-// Audit matrix — 6 rows, one per TopologyShape
-// ---------------------------------------------------------------------------
-const AUDIT_MATRIX = [
-    {
-        shape: "main_native",
-        axes: {
-            teamlead: { model: "main" },
-            subagent: { provider: "main-native" },
-        },
-        signals: CLAUDE_NO_TEAMS,
-        expected_topology_id: "cc-main-agent-subagent",
-        expected_spawn_supported: true,
-    },
-    {
-        shape: "main_foreign",
-        axes: {
-            subagent: { provider: "codex", model_id: "gpt-5.4", effort: "high" },
-        },
-        signals: CLAUDE_NO_TEAMS,
-        expected_topology_id: "cc-main-codex-subprocess",
-        expected_spawn_supported: true,
-    },
-    {
-        shape: "main-teams_native",
-        axes: {
-            subagent: { provider: "main-native" },
-        },
-        signals: CLAUDE_TEAMS,
-        expected_topology_id: "cc-teams-agent-subagent",
-        expected_spawn_supported: true,
-    },
-    {
-        shape: "main-teams_foreign",
-        axes: {
-            subagent: { provider: "codex", model_id: "gpt-5.4", effort: "high" },
-        },
-        signals: CLAUDE_TEAMS,
-        expected_topology_id: "cc-teams-codex-subprocess",
-        expected_spawn_supported: true,
-    },
-    {
-        shape: "main-teams_a2a",
-        axes: {
-            subagent: { provider: "main-native" },
-            lens_deliberation: "sendmessage-a2a",
-        },
-        signals: CLAUDE_TEAMS,
-        expected_topology_id: "cc-teams-lens-agent-deliberation",
-        expected_spawn_supported: false,
-        blocked_on: "PR-D (agent-teams A2A)",
-        // Double opt-in gate — cc-teams-lens-agent-deliberation additionally
-        // requires this config flag on top of CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1
-        // because keeping lens agents alive for A2A materially changes the
-        // memory/latency profile (sketch v3 §3).
-        config_extras: { lens_agent_teams_mode: true },
-    },
-    {
-        shape: "ext-teamlead_native",
-        axes: {
-            teamlead: { model: { provider: "codex", model_id: "gpt-5.4" } },
-            subagent: { provider: "codex", model_id: "gpt-5.4" },
-        },
-        signals: PLAIN_TERMINAL,
-        expected_topology_id: "codex-nested-subprocess",
-        expected_spawn_supported: false,
-        blocked_on: "PR-C (ext-codex teamlead)",
-    },
-];
-// ---------------------------------------------------------------------------
-// Stage 1 — derivation correctness
-// ---------------------------------------------------------------------------
-describe("P8 audit — stage 1: shape derivation reaches every canonical shape", () => {
-    for (const row of AUDIT_MATRIX) {
-        it(`${row.shape} derives from axes + signals`, () => {
-            const r = deriveTopologyShape(row.axes, row.signals);
-            expect(r.ok).toBe(true);
-            if (r.ok) {
-                expect(r.derived.shape).toBe(row.shape);
-            }
-        });
-    }
-    it("every shape in the audit is unique (no drift between runtime and audit matrix)", () => {
-        const shapes = new Set(AUDIT_MATRIX.map((r) => r.shape));
-        expect(shapes.size).toBe(AUDIT_MATRIX.length);
-        expect(shapes.size).toBe(6);
-    });
-});
-// ---------------------------------------------------------------------------
-// Stage 2 — shape → TopologyId mapping
-// ---------------------------------------------------------------------------
-describe("P8 audit — stage 2: every shape maps to a canonical TopologyId", () => {
-    for (const row of AUDIT_MATRIX) {
-        it(`${row.shape} → ${row.expected_topology_id}`, () => {
-            const r = deriveTopologyShape(row.axes, row.signals);
-            expect(r.ok).toBe(true);
-            if (!r.ok)
-                return;
-            const mapping = shapeToTopologyId({
-                shape: r.derived.shape,
-                subagent_provider: r.derived.subagent_provider,
-                signals: {
-                    claudeHost: row.signals.claudeHost,
-                    codexSessionActive: row.signals.codexSessionActive,
-                },
-            });
-            expect(mapping.ok).toBe(true);
-            if (mapping.ok) {
-                expect(mapping.topology_id).toBe(row.expected_topology_id);
-                // Mapped id must exist in the catalog (no drift from TopologyId type).
-                expect(TOPOLOGY_CATALOG[mapping.topology_id]).toBeDefined();
-            }
-        });
-    }
-});
-// ---------------------------------------------------------------------------
-// Stage 3 — resolver end-to-end (axis-first branch)
-// ---------------------------------------------------------------------------
-describe("P8 audit — stage 3: resolver end-to-end selects expected topology", () => {
-    for (const row of AUDIT_MATRIX) {
-        it(`${row.shape}: resolver picks ${row.expected_topology_id} via axis-first`, () => {
-            const res = resolveExecutionTopology({
-                ontoConfig: { review: row.axes, ...(row.config_extras ?? {}) },
-                claudeHost: row.signals.claudeHost,
-                codexSessionActive: row.signals.codexSessionActive,
-                experimentalAgentTeams: row.signals.experimentalAgentTeams,
-                codexAvailable: true, // P8 audit assumes codex is present for codex-flavored shapes
-                liteLlmEndpointAvailable: false,
-            });
-            if (res.type !== "resolved") {
-                throw new Error(`expected resolved for shape=${row.shape}, got no_host: ${res.reason.slice(0, 120)}`);
-            }
-            expect(res.topology.id).toBe(row.expected_topology_id);
-            expect(res.topology.plan_trace.some((l) => l.includes("topology source=review-axes"))).toBe(true);
-        });
-    }
-});
-// ---------------------------------------------------------------------------
-// Stage 4 — spawn-readiness (PR_B_SUPPORTED_TOPOLOGIES)
-// ---------------------------------------------------------------------------
-describe("P8 audit — stage 4: spawn-readiness per shape", () => {
-    for (const row of AUDIT_MATRIX) {
-        it(`${row.shape}: spawn-supported=${row.expected_spawn_supported}${row.blocked_on ? ` (blocked_on=${row.blocked_on})` : ""}`, () => {
-            const supported = PR_B_SUPPORTED_TOPOLOGIES.has(row.expected_topology_id);
-            expect(supported).toBe(row.expected_spawn_supported);
-            if (!supported) {
-                expect(row.blocked_on).toBeDefined();
-            }
-        });
-    }
-    it("support sets are monotonically widening (PR_A ⊆ PR_B)", () => {
-        for (const id of PR_A_SUPPORTED_TOPOLOGIES) {
-            expect(PR_B_SUPPORTED_TOPOLOGIES.has(id)).toBe(true);
-        }
-        // PR_B strictly widens PR_A. Do not hard-code the delta — PR-C / PR-D
-        // will further widen PR_B (or introduce PR_C_SUPPORTED_TOPOLOGIES).
-        // The structural invariant (monotonic widening) is what matters here.
-        expect(PR_B_SUPPORTED_TOPOLOGIES.size).toBeGreaterThan(PR_A_SUPPORTED_TOPOLOGIES.size);
-    });
-    it("the 4 spawn-ready shapes cover 5 of the 6 spawn-supported TopologyIds " +
-        "(cc-teams-litellm-sessions is reachable via main-teams_foreign with provider=litellm)", () => {
-        const spawnReadyIds = new Set(AUDIT_MATRIX.filter((r) => r.expected_spawn_supported).map((r) => r.expected_topology_id));
-        // main_native (Claude), main_foreign, main-teams_native, main-teams_foreign
-        expect(spawnReadyIds.size).toBe(4);
-        // litellm variant is the 5th, reached by flipping subagent.provider
-        // to litellm under main-teams_foreign (same shape, different provider).
-        const litellmRow = {
-            ...AUDIT_MATRIX.find((r) => r.shape === "main-teams_foreign"),
-            axes: {
-                subagent: {
-                    provider: "litellm",
-                    model_id: "llama-8b",
-                },
-            },
-        };
-        const r = deriveTopologyShape(litellmRow.axes, litellmRow.signals);
-        expect(r.ok).toBe(true);
-        if (r.ok) {
-            expect(r.derived.shape).toBe("main-teams_foreign");
-            const mapping = shapeToTopologyId({
-                shape: r.derived.shape,
-                subagent_provider: r.derived.subagent_provider,
-                signals: {
-                    claudeHost: litellmRow.signals.claudeHost,
-                    codexSessionActive: litellmRow.signals.codexSessionActive,
-                },
-            });
-            expect(mapping.ok).toBe(true);
-            if (mapping.ok) {
-                expect(mapping.topology_id).toBe("cc-teams-litellm-sessions");
-                expect(PR_B_SUPPORTED_TOPOLOGIES.has(mapping.topology_id)).toBe(true);
-            }
-        }
-    });
-});
-// ---------------------------------------------------------------------------
-// Stage 5 — pipeline step invariants (catalog integrity for steps 1-4, 6-7)
-// ---------------------------------------------------------------------------
-describe("P8 audit — stage 5: pipeline step invariants (topology-agnostic steps)", () => {
-    // Steps 1-4, 6-7 consume ExecutionTopology as an opaque snapshot. The
-    // audit verifies that the resolved topology always carries the 5
-    // load-bearing fields those steps read.
-    for (const row of AUDIT_MATRIX) {
-        it(`${row.shape}: resolved topology exposes the 6 step-agnostic fields`, () => {
-            const res = resolveExecutionTopology({
-                ontoConfig: { review: row.axes, ...(row.config_extras ?? {}) },
-                claudeHost: row.signals.claudeHost,
-                codexSessionActive: row.signals.codexSessionActive,
-                experimentalAgentTeams: row.signals.experimentalAgentTeams,
-                codexAvailable: true,
-                liteLlmEndpointAvailable: false,
-            });
-            if (res.type !== "resolved") {
-                throw new Error(`expected resolved for shape=${row.shape}, got no_host`);
-            }
-            const t = res.topology;
-            // steps 1 (interpret) / 3 (start-session) read topology.id + lens_spawn_mechanism
-            expect(typeof t.id).toBe("string");
-            expect(typeof t.lens_spawn_mechanism).toBe("string");
-            // step 2 (bind) reads teamlead_location
-            expect(typeof t.teamlead_location).toBe("string");
-            // step 4 (materialize) reads max_concurrent_lenses
-            expect(typeof t.max_concurrent_lenses).toBe("number");
-            expect(t.max_concurrent_lenses).toBeGreaterThan(0);
-            // step 5 (dispatch) reads everything; step 6 (synthesize) reads deliberation_channel
-            expect(typeof t.deliberation_channel).toBe("string");
-            // step 7 (complete) reads plan_trace
-            expect(Array.isArray(t.plan_trace)).toBe(true);
-            expect(t.plan_trace.length).toBeGreaterThan(0);
-        });
-    }
-});
-// ---------------------------------------------------------------------------
-// Stage 6 — catalog non-drift (guards against future refactor regressions)
-// ---------------------------------------------------------------------------
-describe("P8 audit — stage 6: catalog + default priority non-drift", () => {
-    it("TOPOLOGY_CATALOG contains every expected_topology_id from the audit", () => {
-        for (const row of AUDIT_MATRIX) {
-            expect(TOPOLOGY_CATALOG[row.expected_topology_id]).toBeDefined();
-        }
-    });
-    it("TOPOLOGY_CATALOG exposes every audit topology id (post-P9.1 ladder-free invariant)", () => {
-        // P9.1 (2026-04-21): DEFAULT_TOPOLOGY_PRIORITY is retired. The catalog
-        // is now the SSOT for resolvable TopologyIds — the audit must assert
-        // every expected_topology_id is materialized as a catalog entry so
-        // the axis-first pipeline can produce it.
-        for (const row of AUDIT_MATRIX) {
-            expect(TOPOLOGY_CATALOG[row.expected_topology_id]).toBeDefined();
-        }
-    });
-    // Note: shape-name uniqueness is already asserted in Stage 1. Not repeated
-    // here — see `"every shape in the audit is unique"` above.
-});

package/dist/core-runtime/review/shape-to-topology-id.js

@@ -1,117 +0,0 @@
-/**
- * Review topology shape → TopologyId mapping.
- *
- * # What this module is
- *
- * A pure function that converts the axis-derived `TopologyShape` plus
- * host-context signals into a canonical `TopologyId`.
- *
- * # Why it exists
- *
- * Shape does not uniquely determine TopologyId because several shapes
- * depend on host type:
- *
- *   - `main_native` + Claude host  → `cc-main-agent-subagent`
- *   - `main_native` + Codex host   → `codex-main-subprocess`
- *   - `main_foreign` (codex) + CC  → `cc-main-codex-subprocess`
- *   - `main_foreign` (codex) + Codex host → `codex-main-subprocess`
- *   - `main-teams_foreign` (codex) → `cc-teams-codex-subprocess`
- *
- * # How it relates
- *
- * - Input: `TopologyShape` (from `topology-shape-derivation.ts`) +
- *   `{claudeHost, codexSessionActive}` + optional foreign subagent provider.
- * - Output: a `TopologyId` or a failure reason.
- */
-// ---------------------------------------------------------------------------
-// Main mapping function
-// ---------------------------------------------------------------------------
-/**
- * Map a shape classification to a canonical TopologyId value.
- *
- * Returns failure when the shape + signal combination has no canonical
- * TopologyId in the current catalog. Failure cases (post-P2):
- *   - `main_native` with neither Claude nor Codex host (plain terminal
- *     without codex OAuth — truly unreachable).
- *   - `main_foreign` with a provider that cannot be handled by the current
- *     host. Currently only `codex` is mapped; non-codex LLM model selection
- *     belongs to `llm`, not this topology axis.
- */
-export function shapeToTopologyId(input) {
-    const { shape, subagent_provider, signals } = input;
-    const trace = [];
-    const log = (line) => {
-        trace.push(line);
-    };
-    log(`mapping shape=${shape} subagent_provider=${subagent_provider ?? "null"} ` +
-        `claudeHost=${signals.claudeHost} codexSessionActive=${signals.codexSessionActive}`);
-    switch (shape) {
-        case "main_native": {
-            if (signals.claudeHost) {
-                log("→ cc-main-agent-subagent (Claude host + native = Agent tool)");
-                return { ok: true, topology_id: "cc-main-agent-subagent", trace };
-            }
-            if (signals.codexSessionActive) {
-                log("→ codex-main-subprocess (Codex host + native = codex subprocess)");
-                return { ok: true, topology_id: "codex-main-subprocess", trace };
-            }
-            log("no canonical TopologyId: main_native requires Claude or Codex host");
-            return {
-                ok: false,
-                reason: "main_native shape requires Claude Code host or Codex execution. " +
-                    "Neither Claude host nor Codex execution was detected.",
-                trace,
-            };
-        }
-        case "main_foreign": {
-            if (signals.claudeHost && subagent_provider === "codex") {
-                log("→ cc-main-codex-subprocess (Claude + main + codex lens)");
-                return { ok: true, topology_id: "cc-main-codex-subprocess", trace };
-            }
-            if (signals.codexSessionActive && subagent_provider === "codex") {
-                log("→ codex-main-subprocess (Codex host + codex lens)");
-                return { ok: true, topology_id: "codex-main-subprocess", trace };
-            }
-            log(`no canonical TopologyId: main_foreign with provider=${subagent_provider} ` +
-                `requires Claude host, Codex execution, or a different provider`);
-            return {
-                ok: false,
-                reason: `main_foreign shape with provider=${subagent_provider} has no canonical TopologyId. ` +
-                    "Either (a) enable CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 for main-teams_foreign, " +
-                    "(b) use provider=codex under Claude host for cc-main-codex-subprocess, " +
-                    "or (c) run through Codex for codex-main-subprocess.",
-                trace,
-            };
-        }
-        case "main-teams_native": {
-            log("→ cc-teams-agent-subagent (TeamCreate + native lens)");
-            return { ok: true, topology_id: "cc-teams-agent-subagent", trace };
-        }
-        case "main-teams_foreign": {
-            if (subagent_provider === "codex") {
-                log("→ cc-teams-codex-subprocess (TeamCreate + codex lens)");
-                return { ok: true, topology_id: "cc-teams-codex-subprocess", trace };
-            }
-            log(`no canonical TopologyId: main-teams_foreign with provider=${subagent_provider}`);
-            return {
-                ok: false,
-                reason: `main-teams_foreign shape with provider=${subagent_provider} has no canonical TopologyId. ` +
-                    "Only provider=codex is mapped in the review topology axis. Use llm.provider for API-key/local model selection.",
-                trace,
-            };
-        }
-        case "main-teams_deliberation": {
-            log("→ cc-teams-lens-agent-deliberation (TeamCreate + native + controlled deliberation)");
-            return {
-                ok: true,
-                topology_id: "cc-teams-lens-agent-deliberation",
-                trace,
-            };
-        }
-        case "ext-teamlead_native": {
-            // Only codex is supported as external teamlead in the current catalog.
-            log("→ codex-nested-subprocess (external codex teamlead + nested codex lens)");
-            return { ok: true, topology_id: "codex-nested-subprocess", trace };
-        }
-    }
-}