onto-mcp 0.3.2 → 0.4.0

package/dist/core-runtime/cli/migrate-session-roots.js

@@ -1,118 +0,0 @@
-/**
- * Session Root Migrator — DD-8 (Step 11b).
- *
- * Design authority:
- *   - learn-phase3-design-v4.md DD-8 (1-time idempotent migration)
- *   - learn-phase3-design-v9.md DD-8 (.layout-version.yaml seat)
- *
- * Responsibility:
- *   - Move pre-v3 session directories from `.onto/sessions/{id}/` to
- *     `.onto/sessions/review/{id}/`. Pre-v3 sessions were all review
- *     sessions; promote and reclassify-insights are post-v3 additions, so
- *     unscoped legacy ids are unambiguous.
- *   - Write the layout-version marker after migration succeeds so
- *     subsequent commands skip the gate.
- *   - Idempotent: re-running after a successful migration writes nothing,
- *     reports `migrated_count: 0`. Safe to re-run if a partial run was
- *     interrupted.
- *
- * Failure semantics:
- *   - Per-session move uses `fs.renameSync` (atomic on the same filesystem).
- *     If a move fails mid-list, the function records the partial state and
- *     surfaces it to the caller. The caller decides whether to retry.
- *   - Marker is only written when ALL legacy sessions migrated successfully
- *     — partial migration leaves the marker absent so the gate keeps firing.
- *
- * Dry-run support:
- *   - The CLI exposes `--dry-run` so operators can preview the plan without
- *     touching the filesystem. The dry-run path emits the same MigrationResult
- *     shape so plan output is structured.
- */
-import fs from "node:fs";
-import path from "node:path";
-import { inspectMigrationStatus, writeLayoutMarker, getSessionsDir, } from "./session-root-guard.js";
-// ---------------------------------------------------------------------------
-// Migration entry point
-// ---------------------------------------------------------------------------
-export function migrateSessionRoots(config) {
-    const before = inspectMigrationStatus(config.projectRoot);
-    // Already-migrated case: just write the marker if needed.
-    if (before.legacy_session_count === 0) {
-        if (config.dryRun) {
-            return {
-                dry_run: true,
-                before,
-                migrated: [],
-                failures: [],
-                marker_written: false,
-            };
-        }
-        if (!before.marker_present) {
-            writeLayoutMarker(config.projectRoot);
-            return {
-                dry_run: false,
-                before,
-                migrated: [],
-                failures: [],
-                marker_written: true,
-            };
-        }
-        return {
-            dry_run: false,
-            before,
-            migrated: [],
-            failures: [],
-            marker_written: false,
-        };
-    }
-    const sessionsDir = getSessionsDir(config.projectRoot);
-    const reviewDir = path.join(sessionsDir, "review");
-    const planned = before.legacy_session_ids.map((id) => ({
-        session_id: id,
-        from: path.join(sessionsDir, id),
-        to: path.join(reviewDir, id),
-    }));
-    if (config.dryRun) {
-        return {
-            dry_run: true,
-            before,
-            migrated: planned,
-            failures: [],
-            marker_written: false,
-        };
-    }
-    fs.mkdirSync(reviewDir, { recursive: true });
-    const migrated = [];
-    const failures = [];
-    for (const session of planned) {
-        try {
-            // Defensive: refuse to overwrite an existing destination.
-            if (fs.existsSync(session.to)) {
-                throw new Error(`destination ${session.to} already exists`);
-            }
-            fs.renameSync(session.from, session.to);
-            migrated.push(session);
-        }
-        catch (error) {
-            failures.push({
-                session_id: session.session_id,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    // Marker is only written when ALL legacy sessions migrated successfully.
-    // Partial runs leave the marker absent so the gate keeps firing on the
-    // next invocation.
-    let marker_written = false;
-    if (failures.length === 0) {
-        writeLayoutMarker(config.projectRoot);
-        marker_written = true;
-    }
-    return {
-        dry_run: false,
-        before,
-        migrated,
-        failures,
-        marker_written,
-    };
-}

package/dist/core-runtime/cli/repo-layout-migration-replace.smoke.test.js

@@ -1,106 +0,0 @@
-/**
- * Smoke test for scripts/repo-layout-migration-replace.py.
- *
- * Phase 7 review follow-up (`coverage::migration-script-reuse-test-gap`):
- * the script is retained as a generic tool for future similar migrations,
- * but without a test surface its reuse claim has no executable evidence.
- * These tests pin the load-bearing invariants:
- *   - `--old` trailing-slash contract (substring-safety)
- *   - marker-based double-prefix prevention (the guard that makes the
- *     Phase 6–style `new` ⊃ `old` case work)
- *   - `--dry-run` does not write files
- *
- * The script is Python; the tests invoke it via child_process.spawnSync.
- */
-import { spawnSync } from "node:child_process";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-const __filename = fileURLToPath(import.meta.url);
-const REPO_ROOT = path.resolve(path.dirname(__filename), "..", "..", "..");
-const SCRIPT_PATH = path.join(REPO_ROOT, "scripts", "repo-layout-migration-replace.py");
-function runScript(args, cwd) {
-    const result = spawnSync("python3", [SCRIPT_PATH, ...args], {
-        cwd,
-        encoding: "utf8",
-    });
-    return {
-        stdout: result.stdout ?? "",
-        stderr: result.stderr ?? "",
-        status: typeof result.status === "number" ? result.status : -1,
-    };
-}
-function makeTempRoot(prefix) {
-    return fs.mkdtempSync(path.join(os.tmpdir(), `onto-migration-smoke-${prefix}-`));
-}
-describe("scripts/repo-layout-migration-replace.py — smoke invariants", () => {
-    const tmpRoots = [];
-    beforeEach(() => {
-        tmpRoots.length = 0;
-    });
-    afterEach(() => {
-        for (const root of tmpRoots) {
-            try {
-                fs.rmSync(root, { recursive: true, force: true });
-            }
-            catch {
-                // ignore
-            }
-        }
-    });
-    it("rejects --old without trailing slash (substring-safe contract)", () => {
-        const root = makeTempRoot("no-slash");
-        tmpRoots.push(root);
-        const result = runScript(["--old", "foo", "--new", ".onto/foo/", "--root", root, "--dry-run"], root);
-        expect(result.status).not.toBe(0);
-        expect(result.stderr).toMatch(/substring-safe contract|must end with '\/'/);
-    });
-    it("performs a simple rewrite when new does not contain old", () => {
-        const root = makeTempRoot("simple");
-        tmpRoots.push(root);
-        const fixture = path.join(root, "notes.md");
-        fs.writeFileSync(fixture, "reference to oldpath/file.md and oldpath/other.md\n", "utf8");
-        const result = runScript(["--old", "oldpath/", "--new", "canon/", "--root", root], root);
-        expect(result.status).toBe(0);
-        expect(fs.readFileSync(fixture, "utf8")).toBe("reference to canon/file.md and canon/other.md\n");
-    });
-    it("marker guard: when --new contains --old, rewriting is idempotent across reruns", () => {
-        // This is the Phase 6 pattern — `.onto/authority/` contains `authority/`.
-        // Naive str.replace would produce `.onto/.onto/authority/authority/...`
-        // on rerun. The NUL-sentinel marker protects already-new references.
-        const root = makeTempRoot("marker");
-        tmpRoots.push(root);
-        const fixture = path.join(root, "refs.md");
-        fs.writeFileSync(fixture, "legacy authority/core.yaml and existing .onto/authority/other.yaml\n", "utf8");
-        // First run — rewrite legacy to canonical.
-        let result = runScript(["--old", "authority/", "--new", ".onto/authority/", "--root", root], root);
-        expect(result.status).toBe(0);
-        expect(fs.readFileSync(fixture, "utf8")).toBe("legacy .onto/authority/core.yaml and existing .onto/authority/other.yaml\n");
-        // Second run — file already fully canonical. Guard must keep it stable.
-        result = runScript(["--old", "authority/", "--new", ".onto/authority/", "--root", root], root);
-        expect(result.status).toBe(0);
-        expect(fs.readFileSync(fixture, "utf8")).toBe("legacy .onto/authority/core.yaml and existing .onto/authority/other.yaml\n");
-    });
-    it("--dry-run does not write files even when matches exist", () => {
-        const root = makeTempRoot("dry-run");
-        tmpRoots.push(root);
-        const fixture = path.join(root, "refs.md");
-        const original = "pointer to oldref/x.md\n";
-        fs.writeFileSync(fixture, original, "utf8");
-        const result = runScript(["--old", "oldref/", "--new", "newref/", "--root", root, "--dry-run"], root);
-        expect(result.status).toBe(0);
-        expect(fs.readFileSync(fixture, "utf8")).toBe(original);
-    });
-    it("excludes .onto/review/ by default (audit-artifact guard)", () => {
-        const root = makeTempRoot("review-exclude");
-        tmpRoots.push(root);
-        const reviewFile = path.join(root, ".onto", "review", "past-session", "final.md");
-        fs.mkdirSync(path.dirname(reviewFile), { recursive: true });
-        fs.writeFileSync(reviewFile, "historical reference to oldname/x.md\n", "utf8");
-        const result = runScript(["--old", "oldname/", "--new", "newname/", "--root", root], root);
-        expect(result.status).toBe(0);
-        expect(fs.readFileSync(reviewFile, "utf8")).toBe("historical reference to oldname/x.md\n");
-    });
-});

package/dist/core-runtime/cli/review-invoke-auto-resolution.test.js

@@ -1,268 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { resolveExecutionRealizationHandoff, detectClaudeCodeHost, detectCodexAvailable, } from "./review-invoke.js";
-// ─── Helpers ───
-const originalEnv = { ...process.env };
-function clearEnv() {
-    delete process.env.CLAUDECODE;
-    // Don't touch PATH/HOME globally — we override them in tests that need to.
-}
-function restoreEnv() {
-    for (const k of Object.keys(process.env)) {
-        if (!(k in originalEnv))
-            delete process.env[k];
-    }
-    for (const [k, v] of Object.entries(originalEnv)) {
-        process.env[k] = v;
-    }
-}
-function createTmpHome() {
-    const home = fs.mkdtempSync(path.join(os.tmpdir(), "onto-auto-resolution-test-"));
-    fs.mkdirSync(path.join(home, ".codex"), { recursive: true });
-    return {
-        home,
-        cleanup: () => fs.rmSync(home, { recursive: true, force: true }),
-    };
-}
-// ─── detectClaudeCodeHost ───
-describe("detectClaudeCodeHost", () => {
-    beforeEach(() => {
-        clearEnv();
-    });
-    afterEach(() => {
-        restoreEnv();
-    });
-    it("returns true when CLAUDECODE=1", () => {
-        process.env.CLAUDECODE = "1";
-        expect(detectClaudeCodeHost()).toBe(true);
-    });
-    it("returns false when CLAUDECODE unset", () => {
-        expect(detectClaudeCodeHost()).toBe(false);
-    });
-    it("returns false when CLAUDECODE=0 or other value", () => {
-        process.env.CLAUDECODE = "0";
-        expect(detectClaudeCodeHost()).toBe(false);
-        process.env.CLAUDECODE = "true";
-        expect(detectClaudeCodeHost()).toBe(false);
-    });
-});
-// ─── detectCodexAvailable ───
-describe("detectCodexAvailable", () => {
-    let tmp = null;
-    const originalPath = process.env.PATH;
-    const originalHome = process.env.HOME;
-    beforeEach(() => {
-        tmp = createTmpHome();
-        process.env.HOME = tmp.home;
-    });
-    afterEach(() => {
-        if (tmp)
-            tmp.cleanup();
-        tmp = null;
-        if (originalPath !== undefined)
-            process.env.PATH = originalPath;
-        if (originalHome !== undefined)
-            process.env.HOME = originalHome;
-    });
-    it("returns false when codex binary not on PATH", () => {
-        const emptyDir = fs.mkdtempSync(path.join(os.tmpdir(), "onto-empty-path-"));
-        process.env.PATH = emptyDir;
-        try {
-            expect(detectCodexAvailable()).toBe(false);
-        }
-        finally {
-            fs.rmSync(emptyDir, { recursive: true, force: true });
-        }
-    });
-    it("returns false when binary on PATH but auth.json missing", () => {
-        const binDir = fs.mkdtempSync(path.join(os.tmpdir(), "onto-bin-"));
-        const fakeCodex = path.join(binDir, "codex");
-        fs.writeFileSync(fakeCodex, "#!/bin/sh\necho fake\n");
-        fs.chmodSync(fakeCodex, 0o755);
-        process.env.PATH = binDir;
-        // HOME has tmp with .codex dir but no auth.json
-        try {
-            expect(detectCodexAvailable()).toBe(false);
-        }
-        finally {
-            fs.rmSync(binDir, { recursive: true, force: true });
-        }
-    });
-    it("returns true when both binary and auth.json exist", () => {
-        const binDir = fs.mkdtempSync(path.join(os.tmpdir(), "onto-bin-"));
-        const fakeCodex = path.join(binDir, "codex");
-        fs.writeFileSync(fakeCodex, "#!/bin/sh\necho fake\n");
-        fs.chmodSync(fakeCodex, 0o755);
-        process.env.PATH = binDir;
-        fs.writeFileSync(path.join(tmp.home, ".codex", "auth.json"), "{}");
-        try {
-            expect(detectCodexAvailable()).toBe(true);
-        }
-        finally {
-            fs.rmSync(binDir, { recursive: true, force: true });
-        }
-    });
-});
-// ─── resolveExecutionRealizationHandoff ───
-describe("resolveExecutionRealizationHandoff", () => {
-    let tmp = null;
-    const originalPath = process.env.PATH;
-    const originalHome = process.env.HOME;
-    beforeEach(() => {
-        clearEnv();
-        tmp = createTmpHome();
-        process.env.HOME = tmp.home;
-        // Default: empty PATH (codex not available) unless test sets it.
-        process.env.PATH = "/tmp/none-existing-dir";
-    });
-    afterEach(() => {
-        if (tmp)
-            tmp.cleanup();
-        tmp = null;
-        if (originalPath !== undefined)
-            process.env.PATH = originalPath;
-        else
-            delete process.env.PATH;
-        if (originalHome !== undefined)
-            process.env.HOME = originalHome;
-        restoreEnv();
-    });
-    it("E1 explicit --codex → self", () => {
-        const out = resolveExecutionRealizationHandoff({
-            explicitCodex: true,
-            prepareOnly: false,
-            ontoConfig: {},
-        });
-        expect(out.type).toBe("self");
-        if (out.type === "self") {
-            expect(out.profile.host_runtime).toBe("codex");
-        }
-    });
-    it("E1b prepare-only on Claude host → self with Claude profile (artifact seam)", () => {
-        // coordinator-state-machine calls reviewPrepareOnly(--prepare-only) from within
-        // a Claude Code session; it must receive the Claude profile so prepared session
-        // artifacts get recorded as agent-teams+claude, not subagent+codex. This is the
-        // artifact seam fix (review consensus #1, 2026-04-16).
-        process.env.CLAUDECODE = "1";
-        const out = resolveExecutionRealizationHandoff({
-            explicitCodex: false,
-            prepareOnly: true,
-            ontoConfig: {},
-        });
-        expect(out.type).toBe("self");
-        if (out.type === "self") {
-            expect(out.profile.host_runtime).toBe("claude");
-            expect(out.profile.execution_realization).toBe("agent-teams");
-        }
-    });
-    it("E2 env ONTO_HOST_RUNTIME=claude → coordinator_start with agent-teams default", () => {
-        process.env.ONTO_HOST_RUNTIME = "claude";
-        const out = resolveExecutionRealizationHandoff({
-            explicitCodex: false,
-            prepareOnly: false,
-            ontoConfig: {},
-        });
-        expect(out.type).toBe("coordinator_start");
-        if (out.type === "coordinator_start") {
-            expect(out.profile.execution_realization).toBe("agent-teams");
-        }
-    });
-    it("E2c env ONTO_HOST_RUNTIME=codex → self", () => {
-        process.env.ONTO_HOST_RUNTIME = "codex";
-        const out = resolveExecutionRealizationHandoff({
-            explicitCodex: false,
-            prepareOnly: false,
-            ontoConfig: {},
-        });
-        expect(out.type).toBe("self");
-        if (out.type === "self") {
-            expect(out.profile.host_runtime).toBe("codex");
-        }
-    });
-    it("E3 auto + CLAUDECODE=1 → coordinator_start with agent-teams", () => {
-        process.env.CLAUDECODE = "1";
-        const out = resolveExecutionRealizationHandoff({
-            explicitCodex: false,
-            prepareOnly: false,
-            ontoConfig: {},
-        });
-        expect(out.type).toBe("coordinator_start");
-        if (out.type === "coordinator_start") {
-            expect(out.profile.execution_realization).toBe("agent-teams");
-        }
-    });
-    it("E4 auto + codex available + no CLAUDECODE → self", () => {
-        const binDir = fs.mkdtempSync(path.join(os.tmpdir(), "onto-bin-"));
-        const fakeCodex = path.join(binDir, "codex");
-        fs.writeFileSync(fakeCodex, "#!/bin/sh\n");
-        fs.chmodSync(fakeCodex, 0o755);
-        process.env.PATH = binDir;
-        fs.writeFileSync(path.join(tmp.home, ".codex", "auth.json"), "{}");
-        try {
-            const out = resolveExecutionRealizationHandoff({
-                explicitCodex: false,
-                prepareOnly: false,
-                ontoConfig: {},
-            });
-            expect(out.type).toBe("self");
-            if (out.type === "self") {
-                expect(out.profile.host_runtime).toBe("codex");
-            }
-        }
-        finally {
-            fs.rmSync(binDir, { recursive: true, force: true });
-        }
-    });
-    it("E5 auto + both CLAUDECODE and codex available → stay-in-host (Claude wins)", () => {
-        process.env.CLAUDECODE = "1";
-        const binDir = fs.mkdtempSync(path.join(os.tmpdir(), "onto-bin-"));
-        const fakeCodex = path.join(binDir, "codex");
-        fs.writeFileSync(fakeCodex, "#!/bin/sh\n");
-        fs.chmodSync(fakeCodex, 0o755);
-        process.env.PATH = binDir;
-        fs.writeFileSync(path.join(tmp.home, ".codex", "auth.json"), "{}");
-        try {
-            const out = resolveExecutionRealizationHandoff({
-                explicitCodex: false,
-                prepareOnly: false,
-                ontoConfig: {},
-            });
-            expect(out.type).toBe("coordinator_start");
-            if (out.type === "coordinator_start") {
-                expect(out.profile.execution_realization).toBe("agent-teams");
-            }
-        }
-        finally {
-            fs.rmSync(binDir, { recursive: true, force: true });
-        }
-    });
-    it("E6 auto + nothing available → no_host", () => {
-        const out = resolveExecutionRealizationHandoff({
-            explicitCodex: false,
-            prepareOnly: false,
-            ontoConfig: {},
-        });
-        expect(out).toEqual({ type: "no_host" });
-    });
-    it("E7 external_http_provider=litellm → ts_inline_http self-execute", () => {
-        // LiteLLM wiring is live via the P4 auto-detection branch —
-        // `resolveExecutionPlan` sees `external_http_provider` set, routes to
-        // the S1 external HTTP path, and the handoff returns `self` so the
-        // invoking process runs the executor in-band.
-        const out = resolveExecutionRealizationHandoff({
-            explicitCodex: false,
-            prepareOnly: false,
-            ontoConfig: {
-                external_http_provider: "litellm",
-                llm_base_url: "http://proxy.local",
-                litellm: { model: "llama-8b" },
-            },
-        });
-        expect(out).toEqual({
-            type: "self",
-            profile: { execution_realization: "ts_inline_http", host_runtime: "litellm" },
-        });
-    });
-});

package/dist/core-runtime/cli/review-invoke-coordinator-topology.test.js

@@ -1,136 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { tryResolveTopologyForHandoff } from "./review-invoke.js";
-// ---------------------------------------------------------------------------
-// Coordinator handoff descriptor invariants (P9.3, 2026-04-21):
-//
-// (1) `tryResolveTopologyForHandoff` attempts axis-first resolution
-//     unconditionally; the former opt-in gate (config.review presence)
-//     is gone. Every review invocation that reaches a reachable host
-//     ships a descriptor.
-// (2) Resolvable topology → non-null descriptor with all 6 static
-//     attributes, minus plan_trace (handoff payload stays compact).
-// (3) Descriptor is JSON-serializable with deterministic shape —
-//     downstream coordinator consumers parse it unmodified.
-// (4) Returns null ONLY when ontoConfig is undefined (defensive) or
-//     the resolver itself returns `no_host` (axis + main_native
-//     degrade both failed, i.e. no Claude or Codex host reachable).
-// ---------------------------------------------------------------------------
-const ORIGINAL_ENV = { ...process.env };
-function restoreEnv() {
-    for (const k of Object.keys(process.env)) {
-        if (!(k in ORIGINAL_ENV))
-            delete process.env[k];
-    }
-    for (const [k, v] of Object.entries(ORIGINAL_ENV)) {
-        process.env[k] = v;
-    }
-}
-describe("tryResolveTopologyForHandoff — null paths", () => {
-    beforeEach(() => {
-        delete process.env.CLAUDECODE;
-        delete process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS;
-    });
-    afterEach(restoreEnv);
-    it("undefined ontoConfig → null (defensive guard)", () => {
-        expect(tryResolveTopologyForHandoff(undefined)).toBeNull();
-    });
-    it("no host signals → null (resolver returns no_host)", () => {
-        // No CLAUDECODE, no codex session. With no reachable host even the
-        // main_native degrade cannot map — resolver returns no_host and the
-        // handoff payload omits the topology field.
-        expect(tryResolveTopologyForHandoff({})).toBeNull();
-    });
-    it("review block declares unreachable subagent → null (axis + degrade both fail)", () => {
-        // No CLAUDECODE, no experimental, no codex, no litellm. Axis-first
-        // derives `cc-teams-codex-subprocess` which fails requirements; the
-        // main_native degrade then fails to map (no host) → no_host.
-        expect(tryResolveTopologyForHandoff({
-            review: {
-                subagent: { provider: "codex", model_id: "gpt-5.4" },
-            },
-        })).toBeNull();
-    });
-});
-describe("tryResolveTopologyForHandoff — always-on axis-first (P9.3)", () => {
-    beforeEach(() => {
-        delete process.env.CLAUDECODE;
-        delete process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS;
-    });
-    afterEach(restoreEnv);
-    it("plain CC session without review block → cc-main-agent-subagent descriptor via main_native degrade", () => {
-        // P9.3 invariant: every review invocation produces a descriptor
-        // when a host is reachable, even without an explicit `review:`
-        // axis block. Main_native degrade maps to cc-main-agent-subagent
-        // under CLAUDECODE=1.
-        process.env.CLAUDECODE = "1";
-        const descriptor = tryResolveTopologyForHandoff({});
-        expect(descriptor).not.toBeNull();
-        expect(descriptor.id).toBe("cc-main-agent-subagent");
-    });
-    it("empty `review: {}` ALSO resolves via main_native degrade under CC host", () => {
-        // The former M2 opt-in guard is gone — empty review blocks are no
-        // longer distinct from absent ones at dispatch time. Both produce
-        // the same cc-main-agent-subagent descriptor on CLAUDECODE=1.
-        process.env.CLAUDECODE = "1";
-        const descriptor = tryResolveTopologyForHandoff({
-            review: {},
-        });
-        expect(descriptor).not.toBeNull();
-        expect(descriptor.id).toBe("cc-main-agent-subagent");
-    });
-});
-describe("tryResolveTopologyForHandoff — resolved descriptor", () => {
-    beforeEach(() => {
-        delete process.env.CLAUDECODE;
-        delete process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS;
-    });
-    afterEach(restoreEnv);
-    it("cc-main-agent-subagent resolves to descriptor with 6 static attributes", () => {
-        process.env.CLAUDECODE = "1";
-        const descriptor = tryResolveTopologyForHandoff({
-            review: { subagent: { provider: "main-native" } },
-        });
-        expect(descriptor).not.toBeNull();
-        expect(descriptor.id).toBe("cc-main-agent-subagent");
-        expect(descriptor.teamlead_location).toBe("onto-main");
-        expect(descriptor.lens_spawn_mechanism).toBe("claude-agent-tool");
-        expect(descriptor.max_concurrent_lenses).toBe(10);
-        expect(descriptor.transport_rank).toBe("S2");
-        expect(descriptor.deliberation_channel).toBe("synthesizer-only");
-    });
-    it("cc-teams-lens-agent-deliberation resolves when triple opt-in met", () => {
-        process.env.CLAUDECODE = "1";
-        process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS = "1";
-        // P9.2 (2026-04-21): deliberation topology is selected through the
-        // `config.review` axis block (`lens_deliberation: sendmessage-a2a`)
-        // + `lens_agent_teams_mode: true` double opt-in.
-        const descriptor = tryResolveTopologyForHandoff({
-            review: {
-                subagent: { provider: "main-native" },
-                lens_deliberation: "sendmessage-a2a",
-            },
-            lens_agent_teams_mode: true,
-        });
-        expect(descriptor).not.toBeNull();
-        expect(descriptor.id).toBe("cc-teams-lens-agent-deliberation");
-        expect(descriptor.deliberation_channel).toBe("sendmessage-a2a");
-        expect(descriptor.lens_spawn_mechanism).toBe("claude-teamcreate-member");
-    });
-    it("descriptor does NOT include plan_trace (compact handoff JSON)", () => {
-        process.env.CLAUDECODE = "1";
-        const descriptor = tryResolveTopologyForHandoff({
-            review: { subagent: { provider: "main-native" } },
-        });
-        expect(descriptor).not.toBeNull();
-        expect(Object.keys(descriptor)).not.toContain("plan_trace");
-    });
-    it("descriptor is JSON round-trip stable", () => {
-        process.env.CLAUDECODE = "1";
-        const descriptor = tryResolveTopologyForHandoff({
-            review: { subagent: { provider: "main-native" } },
-        });
-        const json = JSON.stringify(descriptor);
-        const parsed = JSON.parse(json);
-        expect(parsed).toEqual(descriptor);
-    });
-});