onto-mcp 0.3.2 → 0.4.1

package/dist/core-runtime/cli/teamcreate-lens-deliberation-executor.test.js

@@ -1,351 +0,0 @@
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { DeliberationOptInError, buildDeliberationPlan, buildDeliberationRound1Prompt, buildDeliberationRound2Prompt, deliberationArtifactPath, extractDisagreements, readDeliberationArtifact, requireDeliberationOptIn, runLensAgentDeliberation, writeDeliberationArtifact, } from "./teamcreate-lens-deliberation-executor.js";
-// ---------------------------------------------------------------------------
-// These tests assert the PR-D deliberation protocol invariants:
-//
-// (1) Triple opt-in is enforced at module boundary — missing any of
-//     CLAUDECODE, CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS, or
-//     config.lens_agent_teams_mode throws DeliberationOptInError with
-//     the missing items enumerated.
-// (2) Round 1 prompt embeds OTHER lens outputs (not own), asks for
-//     re-evaluation, declares the required response section headings.
-// (3) Round 2 prompt embeds ALL round-1 responses, asks for convergence
-//     + explicit persistent disagreements.
-// (4) Artifact paths are deterministic: <dir>/round{N}/<lens>-deliberation.md.
-// (5) Read/write round-trip preserves content.
-// (6) Disagreement extraction finds "## 지속적 이견" sections, parses
-//     "- **이견 항목**:" entries, tolerates English variant heading.
-// (7) runLensAgentDeliberation produces a plan with N*round steps in
-//     stable order, each with prompt + artifact_path populated.
-// ---------------------------------------------------------------------------
-const LENSES = [
-    { lens_id: "logic", output_path: "/tmp/fake/round0/logic.md" },
-    { lens_id: "pragmatics", output_path: "/tmp/fake/round0/pragmatics.md" },
-    { lens_id: "axiology", output_path: "/tmp/fake/round0/axiology.md" },
-];
-// ---------------------------------------------------------------------------
-// requireDeliberationOptIn
-// ---------------------------------------------------------------------------
-describe("requireDeliberationOptIn", () => {
-    it("passes when all three flags satisfied", () => {
-        expect(() => requireDeliberationOptIn({ lens_agent_teams_mode: true }, {
-            CLAUDECODE: "1",
-            CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: "1",
-        })).not.toThrow();
-    });
-    it("throws with CLAUDECODE missing", () => {
-        try {
-            requireDeliberationOptIn({ lens_agent_teams_mode: true }, { CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: "1" });
-            expect.fail("expected throw");
-        }
-        catch (err) {
-            expect(err).toBeInstanceOf(DeliberationOptInError);
-            expect(err.missing.join("\n")).toContain("CLAUDECODE=1");
-        }
-    });
-    it("throws with experimental flag missing", () => {
-        try {
-            requireDeliberationOptIn({ lens_agent_teams_mode: true }, { CLAUDECODE: "1" });
-            expect.fail("expected throw");
-        }
-        catch (err) {
-            const m = err.missing.join("\n");
-            expect(m).toContain("EXPERIMENTAL_AGENT_TEAMS");
-        }
-    });
-    it("throws with config.lens_agent_teams_mode missing", () => {
-        try {
-            requireDeliberationOptIn({}, {
-                CLAUDECODE: "1",
-                CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: "1",
-            });
-            expect.fail("expected throw");
-        }
-        catch (err) {
-            const m = err.missing.join("\n");
-            expect(m).toContain("lens_agent_teams_mode");
-        }
-    });
-    it("message enumerates ALL missing flags (not just the first)", () => {
-        try {
-            requireDeliberationOptIn({ lens_agent_teams_mode: false }, {});
-            expect.fail("expected throw");
-        }
-        catch (err) {
-            const msg = err.message;
-            expect(msg).toContain("CLAUDECODE=1");
-            expect(msg).toContain("EXPERIMENTAL_AGENT_TEAMS");
-            expect(msg).toContain("lens_agent_teams_mode");
-        }
-    });
-});
-// ---------------------------------------------------------------------------
-// Prompt templates
-// ---------------------------------------------------------------------------
-describe("buildDeliberationRound1Prompt", () => {
-    it("embeds every OTHER lens output as its own block", () => {
-        const prompt = buildDeliberationRound1Prompt({
-            own_lens_id: "logic",
-            own_output_summary: "logic 의 기존 결론",
-            other_lens_outputs: [
-                { lens_id: "pragmatics", content: "pragmatics output body" },
-                { lens_id: "axiology", content: "axiology output body" },
-            ],
-        });
-        expect(prompt).toContain("## Lens: pragmatics");
-        expect(prompt).toContain("pragmatics output body");
-        expect(prompt).toContain("## Lens: axiology");
-        expect(prompt).toContain("axiology output body");
-    });
-    it("does NOT embed the lens's own output verbatim (it's already in its session memory)", () => {
-        const prompt = buildDeliberationRound1Prompt({
-            own_lens_id: "logic",
-            own_output_summary: "summary of logic body",
-            other_lens_outputs: [{ lens_id: "pragmatics", content: "other body" }],
-        });
-        expect(prompt).toContain("summary of logic body");
-        expect(prompt).not.toContain("## Lens: logic");
-    });
-    it("declares the required response section headings", () => {
-        const prompt = buildDeliberationRound1Prompt({
-            own_lens_id: "logic",
-            own_output_summary: "x",
-            other_lens_outputs: [],
-        });
-        expect(prompt).toContain("재평가 요약");
-        expect(prompt).toContain("동의/강화 지점");
-        expect(prompt).toContain("충돌/수정 지점");
-        expect(prompt).toContain("추가 발견");
-    });
-});
-describe("buildDeliberationRound2Prompt", () => {
-    it("embeds all round-1 responses", () => {
-        const prompt = buildDeliberationRound2Prompt({
-            own_lens_id: "logic",
-            round1_responses: [
-                { lens_id: "logic", content: "logic r1" },
-                { lens_id: "pragmatics", content: "pragmatics r1" },
-            ],
-        });
-        expect(prompt).toContain("Round 1 response — lens: logic");
-        expect(prompt).toContain("Round 1 response — lens: pragmatics");
-        expect(prompt).toContain("logic r1");
-        expect(prompt).toContain("pragmatics r1");
-    });
-    it("declares required round-2 section headings (수렴 / 이견 / 최종)", () => {
-        const prompt = buildDeliberationRound2Prompt({
-            own_lens_id: "logic",
-            round1_responses: [],
-        });
-        expect(prompt).toContain("수렴 요약");
-        expect(prompt).toContain("지속적 이견");
-        expect(prompt).toContain("최종 입장");
-    });
-    it("explicitly instructs NOT to hide disagreement", () => {
-        const prompt = buildDeliberationRound2Prompt({
-            own_lens_id: "logic",
-            round1_responses: [],
-        });
-        expect(prompt).toContain("숨기지");
-    });
-});
-// ---------------------------------------------------------------------------
-// Artifact path / read / write
-// ---------------------------------------------------------------------------
-describe("deliberationArtifactPath", () => {
-    it("composes <dir>/round{N}/<lens>-deliberation.md", () => {
-        expect(deliberationArtifactPath("/base", 1, "logic")).toBe(path.join("/base", "round1", "logic-deliberation.md"));
-        expect(deliberationArtifactPath("/base", 2, "axiology")).toBe(path.join("/base", "round2", "axiology-deliberation.md"));
-    });
-});
-describe("writeDeliberationArtifact / readDeliberationArtifact", () => {
-    let tmpRoot;
-    beforeEach(async () => {
-        tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), "onto-deliberation-"));
-    });
-    afterEach(async () => {
-        await fs.rm(tmpRoot, { recursive: true, force: true });
-    });
-    it("round-trips content through disk, creating parent directories", async () => {
-        const content = "## 재평가 요약\n\n유지.\n";
-        const filePath = await writeDeliberationArtifact(tmpRoot, 1, "logic", content);
-        expect(filePath).toBe(deliberationArtifactPath(tmpRoot, 1, "logic"));
-        const read = await readDeliberationArtifact(tmpRoot, 1, "logic");
-        expect(read).toBe(content);
-    });
-    it("readDeliberationArtifact returns null for missing artifact (not an error)", async () => {
-        const read = await readDeliberationArtifact(tmpRoot, 2, "never-written");
-        expect(read).toBeNull();
-    });
-});
-// ---------------------------------------------------------------------------
-// extractDisagreements
-// ---------------------------------------------------------------------------
-describe("extractDisagreements", () => {
-    it("extracts items from a '## 지속적 이견' section", () => {
-        const round2 = [
-            {
-                lens_id: "logic",
-                content: [
-                    "## 수렴 요약",
-                    "- 모두 동의",
-                    "",
-                    "## 지속적 이견",
-                    "- **이견 항목**: scope creep 정의",
-                    "  - 당신의 입장: task 내 한정",
-                    "  - 반대 입장 (axiology): 가치 질문 포함 필요",
-                    "- **이견 항목**: severity 스케일",
-                    "  - 당신의 입장: 3단계",
-                    "  - 반대 입장 (pragmatics): 5단계",
-                    "",
-                    "## 최종 입장",
-                    "입장 유지.",
-                ].join("\n"),
-            },
-        ];
-        const result = extractDisagreements(round2);
-        expect(result).toHaveLength(2);
-        expect(result[0].source_lens_id).toBe("logic");
-        expect(result[0].title).toBe("scope creep 정의");
-        expect(result[0].body).toContain("task 내 한정");
-        expect(result[1].title).toBe("severity 스케일");
-    });
-    it("empty section yields empty array", () => {
-        const round2 = [
-            { lens_id: "logic", content: "## 수렴 요약\n- OK\n\n## 최종 입장\n입장 유지." },
-        ];
-        expect(extractDisagreements(round2)).toEqual([]);
-    });
-    it("tolerates English heading 'Persistent Disagreements'", () => {
-        const round2 = [
-            {
-                lens_id: "pragmatics",
-                content: [
-                    "## Persistent Disagreements",
-                    "- **이견 항목**: naming convention",
-                    "  - details here",
-                ].join("\n"),
-            },
-        ];
-        const result = extractDisagreements(round2);
-        expect(result).toHaveLength(1);
-        expect(result[0].title).toBe("naming convention");
-    });
-    it("stops at the next ## heading", () => {
-        const round2 = [
-            {
-                lens_id: "logic",
-                content: [
-                    "## 지속적 이견",
-                    "- **이견 항목**: X",
-                    "  - detail",
-                    "## 최종 입장",
-                    "- **이견 항목**: should-not-appear",
-                ].join("\n"),
-            },
-        ];
-        const result = extractDisagreements(round2);
-        expect(result).toHaveLength(1);
-        expect(result[0].title).toBe("X");
-    });
-    it("aggregates across multiple round-2 artifacts", () => {
-        const round2 = [
-            {
-                lens_id: "logic",
-                content: "## 지속적 이견\n- **이견 항목**: A\n  - body A",
-            },
-            {
-                lens_id: "pragmatics",
-                content: "## 지속적 이견\n- **이견 항목**: B\n  - body B",
-            },
-        ];
-        const result = extractDisagreements(round2);
-        expect(result).toHaveLength(2);
-        expect(result.map((d) => `${d.source_lens_id}:${d.title}`)).toEqual([
-            "logic:A",
-            "pragmatics:B",
-        ]);
-    });
-});
-// ---------------------------------------------------------------------------
-// buildDeliberationPlan
-// ---------------------------------------------------------------------------
-describe("buildDeliberationPlan", () => {
-    it("emits N round-1 steps when rounds=1", () => {
-        const plan = buildDeliberationPlan({ lenses: LENSES, deliberation_dir: "/tmp/d", rounds: 1 }, (lens) => `round1-prompt-for-${lens.lens_id}`);
-        expect(plan.steps).toHaveLength(3);
-        for (let i = 0; i < 3; i += 1) {
-            expect(plan.steps[i].round).toBe(1);
-            expect(plan.steps[i].lens_id).toBe(LENSES[i].lens_id);
-            expect(plan.steps[i].prompt).toContain(LENSES[i].lens_id);
-        }
-    });
-    it("emits 2N steps when rounds=2 with round1 before round2", () => {
-        const plan = buildDeliberationPlan({ lenses: LENSES, deliberation_dir: "/tmp/d", rounds: 2 }, (lens) => `round1-${lens.lens_id}`, (lens) => `round2-${lens.lens_id}`);
-        expect(plan.steps).toHaveLength(6);
-        expect(plan.steps.slice(0, 3).every((s) => s.round === 1)).toBe(true);
-        expect(plan.steps.slice(3).every((s) => s.round === 2)).toBe(true);
-    });
-    it("all_artifact_paths lists every step's target", () => {
-        const plan = buildDeliberationPlan({ lenses: LENSES, deliberation_dir: "/tmp/d", rounds: 2 }, (lens) => `r1-${lens.lens_id}`, (lens) => `r2-${lens.lens_id}`);
-        expect(plan.all_artifact_paths).toHaveLength(6);
-        expect(plan.all_artifact_paths[0]).toContain("round1");
-        expect(plan.all_artifact_paths[3]).toContain("round2");
-    });
-});
-// ---------------------------------------------------------------------------
-// runLensAgentDeliberation
-// ---------------------------------------------------------------------------
-describe("runLensAgentDeliberation", () => {
-    const VALID_ENV = {
-        CLAUDECODE: "1",
-        CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: "1",
-    };
-    it("throws DeliberationOptInError when opt-in not met", async () => {
-        await expect(runLensAgentDeliberation({
-            ontoConfig: {},
-            input: { lenses: LENSES, deliberation_dir: "/tmp/d", rounds: 1 },
-            env: {},
-        })).rejects.toThrow(DeliberationOptInError);
-    });
-    it("reads primary lens outputs via injected reader and builds round-1 prompts", async () => {
-        const primaries = new Map([
-            ["logic", "LOGIC primary output body with findings."],
-            ["pragmatics", "PRAG primary output body."],
-            ["axiology", "AXIOLOGY primary output body."],
-        ]);
-        const plan = await runLensAgentDeliberation({
-            ontoConfig: { lens_agent_teams_mode: true },
-            input: { lenses: LENSES, deliberation_dir: "/tmp/d", rounds: 1 },
-            env: VALID_ENV,
-            readPrimary: async (p) => {
-                const lensId = path.basename(p).replace(".md", "");
-                return primaries.get(lensId) ?? "";
-            },
-        });
-        expect(plan.steps).toHaveLength(3);
-        // Logic's prompt should contain PRAG + AXIOLOGY bodies (as "other" blocks)
-        // but should NOT include a "## Lens: logic" block — logic's own body
-        // stays in its session memory. The own_output_summary header may
-        // echo a truncated first paragraph (that's the name anchor) which
-        // is intentional; we check the block-shaped inclusion only.
-        const logicStep = plan.steps.find((s) => s.lens_id === "logic");
-        expect(logicStep.prompt).toContain("PRAG primary output body");
-        expect(logicStep.prompt).toContain("AXIOLOGY primary output body");
-        expect(logicStep.prompt).not.toContain("## Lens: logic");
-    });
-    it("rounds=2 produces round-1 + round-2 steps (round-2 prompt has runtime placeholder)", async () => {
-        const plan = await runLensAgentDeliberation({
-            ontoConfig: { lens_agent_teams_mode: true },
-            input: { lenses: LENSES, deliberation_dir: "/tmp/d", rounds: 2 },
-            env: VALID_ENV,
-            readPrimary: async () => "primary body",
-        });
-        expect(plan.steps).toHaveLength(6);
-        const round2Step = plan.steps.find((s) => s.round === 2);
-        expect(round2Step.prompt).toContain("coordinator-replace-at-runtime");
-    });
-});

package/dist/core-runtime/cli/topology-executor-mapping.js

@@ -1,139 +0,0 @@
-/**
- * Topology → ReviewUnitExecutor mapping.
- *
- * # What this module is
- *
- * A thin function seat that maps a resolved `ExecutionTopology` (from
- * `src/core-runtime/review/execution-topology-resolver.ts`) to the concrete
- * `ReviewUnitExecutorConfig` (bin + argv) used by
- * `executeReviewPromptExecution` to spawn each lens / synthesize unit.
- *
- * # Why it exists
- *
- * Topology is the primary decision seat. This module maps topology metadata
- * to the executor binary for per-lens reasoning.
- *
- * The mapping is deterministic — it reads only `topology.lens_spawn_mechanism`:
- *
- *   - `codex-subprocess`          → codex-review-unit-executor.ts
- *   - `claude-agent-tool`         → coordinator-start handoff path
- *                                   (no standalone executor binary; the
- *                                   Claude coordinator subagent spawns
- *                                   lens subagents via its own Agent tool)
- *   - `claude-teamcreate-member`  → controlled lens deliberation transport
- *
- * # How it relates
- *
- * - `resolveExecutionTopology()` decides WHICH topology applies.
- * - `mapTopologyToExecutorConfig()` (here) decides HOW to run each lens
- *   under that topology at the TS subprocess level.
- * - The TeamCreate teamlead layer (`cc-teams-*` variants vs `cc-main-*`)
- *   is an orthogonal coordinator-state-machine concern — same lens
- *   executor applies within either teamlead pattern.
- */
-// ---------------------------------------------------------------------------
-// Direct executor support set
-// ---------------------------------------------------------------------------
-/**
- * Topology ids whose lens spawn path is wired to a direct executor.
- */
-export const EXECUTOR_MAPPING_SUPPORTED_TOPOLOGIES = new Set([
-    "cc-main-agent-subagent",
-    "cc-main-codex-subprocess",
-    "codex-main-subprocess",
-    "cc-teams-agent-subagent",
-    "cc-teams-codex-subprocess",
-]);
-/**
- * Mechanisms whose executor binary lives in the onto TS distribution.
- *
- * `claude-agent-tool` is NOT in this set — there is no standalone binary
- * for it; lens subagents are spawned by the Claude coordinator via its
- * own Agent tool invocation, not via `child_process.spawn` from TS.
- */
-const TS_EXECUTABLE_MECHANISMS = new Set([
-    "codex-subprocess",
-]);
-/**
- * True when the topology's lens spawn mechanism resolves to a TS-executable
- * binary (`codex-review-unit-executor.ts`), i.e. the caller can invoke
- * `mapTopologyToExecutorConfig()` and feed the result to
- * `executeReviewPromptExecution()`.
- *
- * For `claude-agent-tool` topologies the caller must route via the
- * coordinator-start handoff instead — no subprocess executor exists.
- */
-export function hasStandaloneLensExecutor(topology) {
-    return TS_EXECUTABLE_MECHANISMS.has(topology.lens_spawn_mechanism);
-}
-// ---------------------------------------------------------------------------
-// Error types
-// ---------------------------------------------------------------------------
-export class TopologyExecutorMappingError extends Error {
-    topologyId;
-    reason;
-    constructor(topologyId, reason) {
-        super(`ExecutionTopology id="${topologyId}" 를 ReviewUnitExecutor 로 매핑할 수 없습니다: ${reason}`);
-        this.topologyId = topologyId;
-        this.reason = reason;
-        this.name = "TopologyExecutorMappingError";
-    }
-}
-// ---------------------------------------------------------------------------
-// Executor config builders (delegate to existing binary paths)
-// ---------------------------------------------------------------------------
-/**
- * Kept local (not imported from review-invoke) to avoid circular imports
- * — review-invoke.ts already imports from cli/run-review-prompt-execution,
- * and this module imports from cli/run-review-prompt-execution's type
- * exports. Direct dependency on review-invoke would close the cycle.
- */
-import path from "node:path";
-function codexExecutorConfig(ontoHome) {
-    return {
-        bin: "node",
-        args: [path.join(ontoHome, "dist", "core-runtime", "cli", "codex-review-unit-executor.js")],
-    };
-}
-// ---------------------------------------------------------------------------
-// Main mapping function
-// ---------------------------------------------------------------------------
-/**
- * Map a resolved topology to the review-unit executor that handles each
- * lens / synthesize invocation under that topology.
- *
- * Throws `TopologyExecutorMappingError` when:
- *   - The topology id is not in `EXECUTOR_MAPPING_SUPPORTED_TOPOLOGIES` (caller should
- *     not reach this function for unsupported ids; guard upstream).
- *   - The lens_spawn_mechanism requires a TS-invisible dispatch path
- *     (`claude-agent-tool`, `claude-teamcreate-member`) —
- *     these are not subprocess executors; see `hasStandaloneLensExecutor`.
- *
- * This module's scope is mechanism→binary, not config→argv.
- */
-export function mapTopologyToExecutorConfig(topology, ontoHome) {
-    if (!EXECUTOR_MAPPING_SUPPORTED_TOPOLOGIES.has(topology.id)) {
-        throw new TopologyExecutorMappingError(topology.id, `Executor mapping 지원 set 밖. 지원되는 옵션: ${[...EXECUTOR_MAPPING_SUPPORTED_TOPOLOGIES].join(", ")}`);
-    }
-    switch (topology.lens_spawn_mechanism) {
-        case "codex-subprocess":
-            return codexExecutorConfig(ontoHome);
-        case "claude-agent-tool":
-            throw new TopologyExecutorMappingError(topology.id, "claude-agent-tool lens spawn 은 coordinator-start handoff 로 route 하세요 " +
-                "(Claude coordinator subagent 가 Agent tool 로 lens subagent 를 spawn). " +
-                "Subprocess executor 가 존재하지 않습니다.");
-        case "claude-teamcreate-member":
-            throw new TopologyExecutorMappingError(topology.id, "claude-teamcreate-member lens spawn 은 controlled lens deliberation transport 에서 다룹니다.");
-    }
-}
-/** Drop `plan_trace` for handoff transmission. */
-export function toCoordinatorTopologyDescriptor(topology) {
-    return {
-        id: topology.id,
-        teamlead_location: topology.teamlead_location,
-        lens_spawn_mechanism: topology.lens_spawn_mechanism,
-        max_concurrent_lenses: topology.max_concurrent_lenses,
-        transport_rank: topology.transport_rank,
-        deliberation_channel: topology.deliberation_channel,
-    };
-}

package/dist/core-runtime/cli/topology-executor-mapping.test.js

@@ -1,173 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { TOPOLOGY_CATALOG, } from "../review/execution-topology-resolver.js";
-import { PR_B_SUPPORTED_TOPOLOGIES, TopologyExecutorMappingError, hasStandaloneLensExecutor, mapTopologyToExecutorConfig, toCoordinatorTopologyDescriptor, } from "./topology-executor-mapping.js";
-// ---------------------------------------------------------------------------
-// These tests assert the PR-B mapping invariants:
-//
-// (1) The PR-B supported set is exactly {2-1, 2-2, codex-B, 1-1, 1-2, 3-1} —
-//     the 3 PR-A options plus the 3 TeamCreate-teamlead options whose lens
-//     spawn mechanism reuses existing executor binaries.
-//
-// (2) Mapping is deterministic per lens_spawn_mechanism:
-//       codex-subprocess → codex-review-unit-executor
-//       litellm-http     → inline-http-review-unit-executor
-//       claude-agent-tool / claude-teamcreate-member / generic-subagent
-//                        → throw (no subprocess binary exists)
-//
-// (3) `hasStandaloneLensExecutor` agrees with the mapping's throw/return shape.
-//
-// (4) `toCoordinatorTopologyDescriptor` strips plan_trace but preserves all
-//     other topology attributes — the handoff payload stays compact.
-// ---------------------------------------------------------------------------
-const FAKE_ONTO_HOME = "/tmp/fake-onto-home";
-function synthesize(id) {
-    return {
-        ...TOPOLOGY_CATALOG[id],
-        plan_trace: [`synthesized for test: ${id}`],
-    };
-}
-// ---------------------------------------------------------------------------
-// Support set
-// ---------------------------------------------------------------------------
-describe("PR_B_SUPPORTED_TOPOLOGIES", () => {
-    it("contains exactly 6 topologies (PR-A 3 + PR-B 3)", () => {
-        expect(PR_B_SUPPORTED_TOPOLOGIES.size).toBe(6);
-        expect(PR_B_SUPPORTED_TOPOLOGIES.has("cc-main-agent-subagent")).toBe(true);
-        expect(PR_B_SUPPORTED_TOPOLOGIES.has("cc-main-codex-subprocess")).toBe(true);
-        expect(PR_B_SUPPORTED_TOPOLOGIES.has("codex-main-subprocess")).toBe(true);
-        expect(PR_B_SUPPORTED_TOPOLOGIES.has("cc-teams-agent-subagent")).toBe(true);
-        expect(PR_B_SUPPORTED_TOPOLOGIES.has("cc-teams-codex-subprocess")).toBe(true);
-        expect(PR_B_SUPPORTED_TOPOLOGIES.has("cc-teams-litellm-sessions")).toBe(true);
-    });
-    it("does NOT include 1-0 deliberation (PR-D scope)", () => {
-        expect(PR_B_SUPPORTED_TOPOLOGIES.has("cc-teams-lens-agent-deliberation")).toBe(false);
-    });
-    it("does NOT include codex-nested (PR-C scope)", () => {
-        expect(PR_B_SUPPORTED_TOPOLOGIES.has("codex-nested-subprocess")).toBe(false);
-    });
-    // P7 (2026-04-21): generic-* removed entirely from TopologyId enum.
-    // Previous test "does NOT include generic-*" is no longer meaningful —
-    // the type system now prevents generic-* from existing anywhere.
-});
-// ---------------------------------------------------------------------------
-// mapTopologyToExecutorConfig — codex mechanisms
-// ---------------------------------------------------------------------------
-describe("mapTopologyToExecutorConfig — codex-subprocess", () => {
-    it("2-2 cc-main-codex-subprocess → codex executor", () => {
-        const cfg = mapTopologyToExecutorConfig(synthesize("cc-main-codex-subprocess"), FAKE_ONTO_HOME);
-        expect(cfg.bin).toBe("node");
-        expect(cfg.args[0]).toContain("codex-review-unit-executor.js");
-        expect(cfg.args[0]).toContain(FAKE_ONTO_HOME);
-    });
-    it("codex-B codex-main-subprocess → codex executor", () => {
-        const cfg = mapTopologyToExecutorConfig(synthesize("codex-main-subprocess"), FAKE_ONTO_HOME);
-        expect(cfg.args[0]).toContain("codex-review-unit-executor.js");
-    });
-    it("1-2 cc-teams-codex-subprocess → codex executor (same as 2-2 at TS level)", () => {
-        const cfg = mapTopologyToExecutorConfig(synthesize("cc-teams-codex-subprocess"), FAKE_ONTO_HOME);
-        expect(cfg.args[0]).toContain("codex-review-unit-executor.js");
-    });
-});
-// ---------------------------------------------------------------------------
-// mapTopologyToExecutorConfig — litellm-http
-// ---------------------------------------------------------------------------
-describe("mapTopologyToExecutorConfig — litellm-http", () => {
-    it("3-1 cc-teams-litellm-sessions → inline-http executor", () => {
-        const cfg = mapTopologyToExecutorConfig(synthesize("cc-teams-litellm-sessions"), FAKE_ONTO_HOME);
-        expect(cfg.bin).toBe("node");
-        expect(cfg.args[0]).toContain("inline-http-review-unit-executor.js");
-    });
-});
-// ---------------------------------------------------------------------------
-// mapTopologyToExecutorConfig — claude-agent-tool (no binary; throw)
-// ---------------------------------------------------------------------------
-describe("mapTopologyToExecutorConfig — claude-agent-tool", () => {
-    it("2-1 cc-main-agent-subagent throws (route via coordinator-start handoff)", () => {
-        expect(() => mapTopologyToExecutorConfig(synthesize("cc-main-agent-subagent"), FAKE_ONTO_HOME)).toThrow(TopologyExecutorMappingError);
-    });
-    it("1-1 cc-teams-agent-subagent throws (route via coordinator-start handoff)", () => {
-        expect(() => mapTopologyToExecutorConfig(synthesize("cc-teams-agent-subagent"), FAKE_ONTO_HOME)).toThrow(TopologyExecutorMappingError);
-    });
-    it("claude-agent-tool throw mentions coordinator-start handoff path", () => {
-        try {
-            mapTopologyToExecutorConfig(synthesize("cc-main-agent-subagent"), FAKE_ONTO_HOME);
-            expect.fail("expected throw");
-        }
-        catch (err) {
-            expect(err).toBeInstanceOf(TopologyExecutorMappingError);
-            expect(err.message).toContain("coordinator-start handoff");
-        }
-    });
-});
-// ---------------------------------------------------------------------------
-// mapTopologyToExecutorConfig — unsupported ids
-// ---------------------------------------------------------------------------
-describe("mapTopologyToExecutorConfig — unsupported", () => {
-    it("1-0 cc-teams-lens-agent-deliberation throws (outside PR-B support set)", () => {
-        expect(() => mapTopologyToExecutorConfig(synthesize("cc-teams-lens-agent-deliberation"), FAKE_ONTO_HOME)).toThrow(TopologyExecutorMappingError);
-    });
-    it("codex-A codex-nested-subprocess throws (outside PR-B; PR-C scope)", () => {
-        expect(() => mapTopologyToExecutorConfig(synthesize("codex-nested-subprocess"), FAKE_ONTO_HOME)).toThrow(TopologyExecutorMappingError);
-    });
-    // P7 (2026-04-21): generic-* removed from TopologyId. Their "reserved"
-    // guard is no longer needed — the type system prevents the values from
-    // appearing at all.
-    it("error message lists all PR-B supported ids for discoverability", () => {
-        try {
-            mapTopologyToExecutorConfig(synthesize("codex-nested-subprocess"), FAKE_ONTO_HOME);
-            expect.fail("expected throw");
-        }
-        catch (err) {
-            const msg = err.message;
-            for (const id of PR_B_SUPPORTED_TOPOLOGIES) {
-                expect(msg).toContain(id);
-            }
-        }
-    });
-});
-// ---------------------------------------------------------------------------
-// hasStandaloneLensExecutor
-// ---------------------------------------------------------------------------
-describe("hasStandaloneLensExecutor", () => {
-    it("codex-subprocess mechanisms have a TS executor binary", () => {
-        expect(hasStandaloneLensExecutor(synthesize("cc-main-codex-subprocess"))).toBe(true);
-        expect(hasStandaloneLensExecutor(synthesize("cc-teams-codex-subprocess"))).toBe(true);
-        expect(hasStandaloneLensExecutor(synthesize("codex-main-subprocess"))).toBe(true);
-        expect(hasStandaloneLensExecutor(synthesize("codex-nested-subprocess"))).toBe(true);
-    });
-    it("litellm-http mechanism has a TS executor binary", () => {
-        expect(hasStandaloneLensExecutor(synthesize("cc-teams-litellm-sessions"))).toBe(true);
-    });
-    it("claude-agent-tool mechanisms do NOT have a TS executor binary", () => {
-        expect(hasStandaloneLensExecutor(synthesize("cc-main-agent-subagent"))).toBe(false);
-        expect(hasStandaloneLensExecutor(synthesize("cc-teams-agent-subagent"))).toBe(false);
-    });
-    it("claude-teamcreate-member (1-0 deliberation) does NOT have a TS executor binary", () => {
-        expect(hasStandaloneLensExecutor(synthesize("cc-teams-lens-agent-deliberation"))).toBe(false);
-    });
-    // P7 (2026-04-21): generic-subagent mechanism tests removed along with
-    // generic-* TopologyId values.
-});
-// ---------------------------------------------------------------------------
-// toCoordinatorTopologyDescriptor
-// ---------------------------------------------------------------------------
-describe("toCoordinatorTopologyDescriptor", () => {
-    it("preserves all topology attributes except plan_trace", () => {
-        const topology = synthesize("cc-teams-codex-subprocess");
-        const descriptor = toCoordinatorTopologyDescriptor(topology);
-        expect(descriptor.id).toBe(topology.id);
-        expect(descriptor.teamlead_location).toBe(topology.teamlead_location);
-        expect(descriptor.lens_spawn_mechanism).toBe(topology.lens_spawn_mechanism);
-        expect(descriptor.max_concurrent_lenses).toBe(topology.max_concurrent_lenses);
-        expect(descriptor.transport_rank).toBe(topology.transport_rank);
-        expect(descriptor.deliberation_channel).toBe(topology.deliberation_channel);
-        expect(Object.keys(descriptor)).not.toContain("plan_trace");
-    });
-    it("is JSON-serializable (handoff transport requirement)", () => {
-        const topology = synthesize("cc-teams-lens-agent-deliberation");
-        const descriptor = toCoordinatorTopologyDescriptor(topology);
-        const json = JSON.stringify(descriptor);
-        const parsed = JSON.parse(json);
-        expect(parsed).toEqual(descriptor);
-    });
-});