onto-mcp 0.3.2 → 0.4.0

package/dist/core-runtime/review/execution-topology-resolver.test.js

@@ -1,315 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { PR_A_SUPPORTED_TOPOLOGIES, TOPOLOGY_CATALOG, UnsupportedTopologyError, assertSupportedInPrA, resolveExecutionTopology, } from "./execution-topology-resolver.js";
-const CLEAN_ENV = {};
-function withSignals(overrides) {
-    return {
-        ontoConfig: {},
-        env: CLEAN_ENV,
-        claudeHost: false,
-        experimentalAgentTeams: false,
-        codexAvailable: false,
-        codexSessionActive: false,
-        liteLlmEndpointAvailable: false,
-        ...overrides,
-    };
-}
-function expectResolved(res) {
-    if (res.type !== "resolved") {
-        throw new Error(`expected resolved, got no_host: ${res.reason.slice(0, 120)}`);
-    }
-    return res;
-}
-function expectNoHost(res) {
-    if (res.type !== "no_host") {
-        throw new Error(`expected no_host, got resolved topology id=${res.topology.id}`);
-    }
-    return res;
-}
-/**
- * Minimal `config.review` axis block that derives to `cc-main-agent-subagent`
- * under a Claude host. Used as a vehicle for exercising resolver plumbing
- * (overrides, observability) without duplicating axis-first happy-path
- * coverage.
- */
-const REVIEW_BLOCK_MAIN_NATIVE = {
-    teamlead: { model: "main" },
-    subagent: { provider: "main-native" },
-};
-// ---------------------------------------------------------------------------
-// (3) review.max_concurrent_lenses — canonical concurrency override (P9.2)
-// ---------------------------------------------------------------------------
-describe("resolveExecutionTopology — review.max_concurrent_lenses override", () => {
-    it("positive review.max_concurrent_lenses takes effect and logs the change", () => {
-        const res = resolveExecutionTopology(withSignals({
-            ontoConfig: {
-                review: {
-                    ...REVIEW_BLOCK_MAIN_NATIVE,
-                    max_concurrent_lenses: 6,
-                },
-            },
-            claudeHost: true,
-        }));
-        const resolved = expectResolved(res);
-        expect(resolved.topology.id).toBe("cc-main-agent-subagent");
-        expect(resolved.topology.max_concurrent_lenses).toBe(6);
-        expect(resolved.topology.plan_trace.some((l) => l.includes("override max_concurrent_lenses 10 → 6 (via review.max_concurrent_lenses)"))).toBe(true);
-    });
-    it("zero/negative review.max_concurrent_lenses is ignored with a warning log", () => {
-        const res = resolveExecutionTopology(withSignals({
-            ontoConfig: {
-                review: {
-                    ...REVIEW_BLOCK_MAIN_NATIVE,
-                    max_concurrent_lenses: 0,
-                },
-            },
-            claudeHost: true,
-        }));
-        const resolved = expectResolved(res);
-        expect(resolved.topology.plan_trace.some((l) => l.includes("review.max_concurrent_lenses=0 ignored (must be positive integer)"))).toBe(true);
-        expect(resolved.topology.max_concurrent_lenses).toBe(10);
-    });
-});
-// ---------------------------------------------------------------------------
-// (4) plan_trace + [topology] STDERR — single source of truth
-// ---------------------------------------------------------------------------
-describe("resolveExecutionTopology — observability", () => {
-    let stderrSpy;
-    beforeEach(() => {
-        stderrSpy = vi.spyOn(process.stderr, "write").mockImplementation(() => true);
-    });
-    afterEach(() => {
-        stderrSpy.mockRestore();
-    });
-    it("emits [topology] prefix for every decision line", () => {
-        resolveExecutionTopology(withSignals({
-            ontoConfig: { review: REVIEW_BLOCK_MAIN_NATIVE },
-            claudeHost: true,
-        }));
-        const calls = stderrSpy.mock.calls.map((c) => String(c[0]));
-        const topologyLines = calls.filter((l) => l.startsWith("[topology]"));
-        expect(topologyLines.length).toBeGreaterThan(0);
-        for (const line of topologyLines) {
-            expect(line).toMatch(/^\[topology\] /);
-        }
-    });
-    it("plan_trace matches the lines emitted to STDERR (no divergence)", () => {
-        const res = resolveExecutionTopology(withSignals({
-            ontoConfig: { review: REVIEW_BLOCK_MAIN_NATIVE },
-            claudeHost: true,
-        }));
-        const resolved = expectResolved(res);
-        const stderrLines = stderrSpy.mock.calls
-            .map((c) => String(c[0]))
-            .filter((l) => l.startsWith("[topology] "))
-            .map((l) => l.replace(/^\[topology\] /, "").replace(/\n$/, ""));
-        expect(resolved.topology.plan_trace).toEqual(stderrLines);
-    });
-    // (5) no_host composition
-    it("no_host resolution surfaces plan_trace + guidance reason", () => {
-        const res = resolveExecutionTopology(withSignals({}));
-        const nohost = expectNoHost(res);
-        expect(nohost.plan_trace.length).toBeGreaterThan(0);
-        expect(nohost.reason).toContain("Execution topology 를 도출할 수 없습니다");
-        expect(nohost.reason).toContain("현재 환경 시그널");
-        expect(nohost.reason).toContain("해결 방법");
-    });
-});
-// ---------------------------------------------------------------------------
-// (2) PR-A support set — spawn-time guard
-// ---------------------------------------------------------------------------
-describe("resolveExecutionTopology — PR-A support set", () => {
-    it("PR-A supports exactly 3 topologies", () => {
-        expect(PR_A_SUPPORTED_TOPOLOGIES.size).toBe(3);
-        expect(PR_A_SUPPORTED_TOPOLOGIES.has("cc-main-agent-subagent")).toBe(true);
-        expect(PR_A_SUPPORTED_TOPOLOGIES.has("cc-main-codex-subprocess")).toBe(true);
-        expect(PR_A_SUPPORTED_TOPOLOGIES.has("codex-main-subprocess")).toBe(true);
-    });
-    it("assertSupportedInPrA passes for supported ids", () => {
-        for (const id of PR_A_SUPPORTED_TOPOLOGIES) {
-            expect(() => assertSupportedInPrA({
-                ...TOPOLOGY_CATALOG[id],
-                plan_trace: [],
-            })).not.toThrow();
-        }
-    });
-    it("assertSupportedInPrA throws UnsupportedTopologyError for non-supported ids", () => {
-        const unsupported = [
-            "cc-teams-lens-agent-deliberation",
-            "cc-teams-agent-subagent",
-            "cc-teams-codex-subprocess",
-            "cc-teams-litellm-sessions",
-            "codex-nested-subprocess",
-        ];
-        for (const id of unsupported) {
-            expect(() => assertSupportedInPrA({ ...TOPOLOGY_CATALOG[id], plan_trace: [] })).toThrow(UnsupportedTopologyError);
-        }
-    });
-    it("UnsupportedTopologyError message names the PR where the option lands", () => {
-        try {
-            assertSupportedInPrA({
-                ...TOPOLOGY_CATALOG["cc-teams-agent-subagent"],
-                plan_trace: [],
-            });
-            expect.fail("expected throw");
-        }
-        catch (err) {
-            expect(err).toBeInstanceOf(UnsupportedTopologyError);
-            const msg = err.message;
-            expect(msg).toContain("PR-B");
-            expect(msg).toContain("cc-main-agent-subagent");
-        }
-    });
-});
-// ---------------------------------------------------------------------------
-// (1) Catalog shape stability
-// ---------------------------------------------------------------------------
-const EXPECTED_CATALOG_IDS = [
-    "cc-teams-lens-agent-deliberation",
-    "cc-teams-agent-subagent",
-    "cc-teams-codex-subprocess",
-    "cc-main-agent-subagent",
-    "cc-main-codex-subprocess",
-    "cc-teams-litellm-sessions",
-    "codex-nested-subprocess",
-    "codex-main-subprocess",
-];
-describe("TOPOLOGY_CATALOG — shape", () => {
-    it("has exactly 8 canonical entries (post-P7 trim)", () => {
-        const catalogIds = Object.keys(TOPOLOGY_CATALOG).sort();
-        expect(catalogIds).toEqual([...EXPECTED_CATALOG_IDS].sort());
-        expect(catalogIds.length).toBe(8);
-    });
-    it("each entry has all required static attributes populated", () => {
-        for (const id of Object.keys(TOPOLOGY_CATALOG)) {
-            const entry = TOPOLOGY_CATALOG[id];
-            expect(entry.id).toBe(id);
-            expect(entry.teamlead_location).toBeTruthy();
-            expect(entry.lens_spawn_mechanism).toBeTruthy();
-            expect(entry.max_concurrent_lenses).toBeGreaterThan(0);
-            expect(["S0", "S1", "S2", "S3"]).toContain(entry.transport_rank);
-            expect(["sendmessage-a2a", "synthesizer-only"]).toContain(entry.deliberation_channel);
-        }
-    });
-    it("only cc-teams-lens-agent-deliberation declares SendMessage A2A deliberation", () => {
-        const a2a = Object.keys(TOPOLOGY_CATALOG).filter((id) => TOPOLOGY_CATALOG[id].deliberation_channel === "sendmessage-a2a");
-        expect(a2a).toEqual(["cc-teams-lens-agent-deliberation"]);
-    });
-});
-// ---------------------------------------------------------------------------
-// (6) P9.1 — legacy `execution_topology_priority` is ignored at runtime
-// (7) review absent → main_native degrade (no ladder walk)
-// ---------------------------------------------------------------------------
-describe("resolveExecutionTopology — P9.1 ladder retirement", () => {
-    let stderrSpy;
-    beforeEach(() => {
-        stderrSpy = vi.spyOn(process.stderr, "write").mockImplementation(() => true);
-    });
-    afterEach(() => {
-        stderrSpy.mockRestore();
-    });
-    it("no review block + CC host → main_native degrade → cc-main-agent-subagent", () => {
-        const res = resolveExecutionTopology(withSignals({
-            ontoConfig: {},
-            claudeHost: true,
-        }));
-        const resolved = expectResolved(res);
-        expect(resolved.topology.id).toBe("cc-main-agent-subagent");
-        expect(resolved.topology.plan_trace.some((l) => l.includes("topology source=fallback-main-native"))).toBe(true);
-        expect(resolved.topology.plan_trace.some((l) => l.includes("degraded: requested=<review-block-absent>"))).toBe(true);
-    });
-    it("no review block + no host signals → no_host (fail-fast, no ladder)", () => {
-        const res = resolveExecutionTopology(withSignals({}));
-        const nohost = expectNoHost(res);
-        expect(nohost.plan_trace.some((l) => l.includes("no topology resolved (axis-first + main_native fallback both failed)"))).toBe(true);
-        // Guarantee we did NOT emit the old priority-ladder trace shape.
-        expect(nohost.plan_trace.some((l) => l.includes("priority source="))).toBe(false);
-    });
-    // P9.2 (2026-04-21): the "legacy execution_topology_priority acknowledged
-    // but ignored" test was removed — the field no longer exists in `OntoConfig`,
-    // so TypeScript alone prevents its assignment. No runtime assertion needed.
-});
-// ---------------------------------------------------------------------------
-// (2-bis) checkTopologyRequirements — per-branch negative coverage
-//
-// Restored in PR #161 self-review (2026-04-21). Axis-first pipeline
-// produces each TopologyId, then the detailed requirements check rejects
-// it due to a single missing signal. The resolver returns `no_host` and
-// the plan_trace records the precise skip reason.
-// ---------------------------------------------------------------------------
-describe("checkTopologyRequirements — axis-first derives id but requirement fails", () => {
-    it("cc-teams-lens-agent-deliberation skips when lens_agent_teams_mode=false", () => {
-        const res = resolveExecutionTopology(withSignals({
-            ontoConfig: {
-                review: {
-                    subagent: { provider: "main-native" },
-                    lens_deliberation: "sendmessage-a2a",
-                },
-                lens_agent_teams_mode: false,
-            },
-            claudeHost: true,
-            experimentalAgentTeams: true,
-        }));
-        const nohost = expectNoHost(res);
-        expect(nohost.plan_trace.some((l) => l.includes("cc-teams-lens-agent-deliberation: skip — need config.lens_agent_teams_mode=true"))).toBe(true);
-    });
-    it("cc-teams-codex-subprocess skips when codex binary missing", () => {
-        const res = resolveExecutionTopology(withSignals({
-            ontoConfig: {
-                review: {
-                    subagent: { provider: "codex", model_id: "gpt-5.4" },
-                },
-            },
-            claudeHost: true,
-            experimentalAgentTeams: true,
-            codexAvailable: false,
-        }));
-        const nohost = expectNoHost(res);
-        expect(nohost.plan_trace.some((l) => l.includes("cc-teams-codex-subprocess: skip — need codex binary + ~/.codex/auth.json"))).toBe(true);
-    });
-    it("cc-teams-litellm-sessions skips when LiteLLM endpoint missing", () => {
-        const res = resolveExecutionTopology(withSignals({
-            ontoConfig: {
-                review: {
-                    subagent: { provider: "litellm", model_id: "gpt-4o" },
-                },
-            },
-            claudeHost: true,
-            experimentalAgentTeams: true,
-            liteLlmEndpointAvailable: false,
-        }));
-        const nohost = expectNoHost(res);
-        expect(nohost.plan_trace.some((l) => l.includes("cc-teams-litellm-sessions: skip — need LITELLM_BASE_URL or config.llm_base_url"))).toBe(true);
-    });
-    it("codex-main-subprocess skips when codex binary missing despite session signal", () => {
-        const res = resolveExecutionTopology(withSignals({
-            ontoConfig: {
-                review: {
-                    subagent: { provider: "main-native" },
-                },
-            },
-            claudeHost: false,
-            codexSessionActive: true,
-            codexAvailable: false,
-        }));
-        const nohost = expectNoHost(res);
-        expect(nohost.plan_trace.some((l) => l.includes("codex-main-subprocess: skip — need codex binary + ~/.codex/auth.json"))).toBe(true);
-    });
-});
-// ---------------------------------------------------------------------------
-// env-defaulting (no injected signals) — uses process.env
-// ---------------------------------------------------------------------------
-describe("resolveExecutionTopology — env defaults", () => {
-    it("falls back to host-detection helpers when signals are not injected", () => {
-        // Inject ontoConfig but omit detection flag args. The resolver should
-        // call detectClaudeCodeEnvSignal() etc. — we only assert the shape is
-        // valid (resolved or no_host with a trace).
-        const res = resolveExecutionTopology({
-            ontoConfig: { review: REVIEW_BLOCK_MAIN_NATIVE },
-            env: {},
-        });
-        expect(["resolved", "no_host"]).toContain(res.type);
-        if (res.type === "no_host") {
-            expect(res.plan_trace.length).toBeGreaterThan(0);
-        }
-    });
-});

package/dist/core-runtime/review/inline-context-embedder.test.js

@@ -1,154 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { embedInlineContext } from "./inline-context-embedder.js";
-let scratchDir;
-let ontoHome;
-let projectRoot;
-let savedHome;
-beforeEach(() => {
-    scratchDir = mkdtempSync(path.join(tmpdir(), "inline-embed-test-"));
-    ontoHome = path.join(scratchDir, ".onto");
-    projectRoot = path.join(scratchDir, "project");
-    mkdirSync(ontoHome, { recursive: true });
-    mkdirSync(projectRoot, { recursive: true });
-    savedHome = process.env.HOME;
-    process.env.HOME = scratchDir;
-});
-afterEach(() => {
-    if (savedHome === undefined) {
-        delete process.env.HOME;
-    }
-    else {
-        process.env.HOME = savedHome;
-    }
-    rmSync(scratchDir, { recursive: true, force: true });
-});
-function writeDomain(domain, file, content) {
-    const dir = path.join(ontoHome, "domains", domain);
-    mkdirSync(dir, { recursive: true });
-    const filePath = path.join(dir, file);
-    writeFileSync(filePath, content, "utf8");
-    return filePath;
-}
-describe("embedInlineContext — domain doc embedding", () => {
-    it("expands `- Primary: <path>.md` reference to inline content block", () => {
-        writeDomain("software-engineering", "logic_rules.md", "## Logic Rules\n\nRule 1: ...\n");
-        const packet = `## Domain Documents
-- Primary: ~/.onto/domains/software-engineering/logic_rules.md
-`;
-        const result = embedInlineContext(packet, { ontoHome, projectRoot });
-        expect(result).toContain("Inline content (logic_rules.md)");
-        expect(result).toContain("## Logic Rules");
-        expect(result).toContain("Rule 1: ...");
-        expect(result).toContain("inline-context-embedder: domain doc references expanded");
-    });
-    it("expands Korean section labels (기본/보조)", () => {
-        writeDomain("ontology", "concepts.md", "## Concepts\n\nDefinition: X\n");
-        const packet = `## Domain Documents
-- 기본: ~/.onto/domains/ontology/concepts.md
-- 보조: ~/.onto/domains/ontology/concepts.md
-`;
-        const result = embedInlineContext(packet, { ontoHome, projectRoot });
-        // Both Korean labels should produce inline content (twice)
-        const matches = result.match(/Inline content \(concepts\.md\)/g);
-        expect(matches).not.toBeNull();
-        expect(matches.length).toBe(2);
-    });
-    it("leaves missing file refs unchanged with `not-found` comment", () => {
-        const packet = `## Domain Documents
-- Primary: ~/.onto/domains/nonexistent/missing.md
-`;
-        const result = embedInlineContext(packet, { ontoHome, projectRoot });
-        expect(result).toContain("- Primary: ~/.onto/domains/nonexistent/missing.md");
-        expect(result).toContain("inline-embed: not-found");
-        expect(result).not.toContain("Inline content");
-    });
-    it("does not add header when no embeddings happened", () => {
-        const packet = `## Notes
-Some unrelated content.
-- Primary: ~/.onto/domains/missing/x.md
-`;
-        const result = embedInlineContext(packet, { ontoHome, projectRoot });
-        // Failed embed does not add the "expansion happened" header
-        expect(result).not.toContain("inline-context-embedder: domain doc references expanded");
-    });
-    it("ignores non-md paths (only .md is matched)", () => {
-        const packet = `## Domain Documents
-- Primary: ~/.onto/domains/x/file.txt
-- Supplementary: ~/.onto/domains/y/script.sh
-`;
-        const result = embedInlineContext(packet, { ontoHome, projectRoot });
-        // Original lines preserved untouched
-        expect(result).toContain("- Primary: ~/.onto/domains/x/file.txt");
-        expect(result).toContain("- Supplementary: ~/.onto/domains/y/script.sh");
-        expect(result).not.toContain("Inline content");
-    });
-    it("truncates very long files at maxEmbedLines", () => {
-        const longContent = Array.from({ length: 1000 }, (_, i) => `Line ${i + 1}`).join("\n");
-        writeDomain("big", "huge.md", longContent);
-        const packet = `## Domain Documents
-- Primary: ~/.onto/domains/big/huge.md
-`;
-        const result = embedInlineContext(packet, { ontoHome, projectRoot, maxEmbedLines: 50 });
-        expect(result).toContain("Inline content (huge.md)");
-        expect(result).toContain("Line 1");
-        expect(result).toContain("Line 50");
-        expect(result).not.toContain("Line 51");
-        expect(result).toContain("...truncated: 950 more lines omitted");
-    });
-    it("expands ${ONTO_PLUGIN_DIR:-default} fallback notation", () => {
-        // Set ONTO_PLUGIN_DIR to a real dir with a doc.
-        // Phase 4 layout: processes/ moved to .onto/processes/, so fixture
-        // must create the file at the new canonical location to match the
-        // packet path below.
-        const pluginDir = path.join(scratchDir, "plugin");
-        mkdirSync(path.join(pluginDir, ".onto", "processes"), { recursive: true });
-        writeFileSync(path.join(pluginDir, ".onto", "processes", "test.md"), "## Test Process\n", "utf8");
-        process.env.ONTO_PLUGIN_DIR = pluginDir;
-        try {
-            const packet = `## Domain Documents
-- Primary: \${ONTO_PLUGIN_DIR:-~/.claude/plugins/onto}/.onto/processes/test.md
-`;
-            const result = embedInlineContext(packet, { ontoHome, projectRoot });
-            expect(result).toContain("Inline content (test.md)");
-            expect(result).toContain("## Test Process");
-        }
-        finally {
-            delete process.env.ONTO_PLUGIN_DIR;
-        }
-    });
-    it("preserves untouched packet content surrounding refs", () => {
-        writeDomain("se", "logic.md", "Logic content");
-        const packet = `# Header
-
-Some intro paragraph.
-
-## Domain Documents
-- Primary: ~/.onto/domains/se/logic.md
-
-## Other Section
-Unrelated content here.
-`;
-        const result = embedInlineContext(packet, { ontoHome, projectRoot });
-        expect(result).toContain("# Header");
-        expect(result).toContain("Some intro paragraph.");
-        expect(result).toContain("## Other Section");
-        expect(result).toContain("Unrelated content here.");
-        expect(result).toContain("Inline content (logic.md)");
-    });
-    it("multiple refs in same packet all get embedded", () => {
-        writeDomain("se", "logic.md", "Logic body");
-        writeDomain("se", "concepts.md", "Concepts body");
-        const packet = `## Domain Documents
-- Primary: ~/.onto/domains/se/logic.md
-- Supplementary: ~/.onto/domains/se/concepts.md
-`;
-        const result = embedInlineContext(packet, { ontoHome, projectRoot });
-        expect(result).toContain("Inline content (logic.md)");
-        expect(result).toContain("Logic body");
-        expect(result).toContain("Inline content (concepts.md)");
-        expect(result).toContain("Concepts body");
-    });
-});

package/dist/core-runtime/review/legacy-mode-policy.js

@@ -1,88 +0,0 @@
-/**
- * Legacy review-mode policy — centralized seat for handling renamed mode values.
- *
- * # Why this file exists (evolution-F1)
- *
- * Before v0.2.0, `ReviewMode` values were `'light' | 'full'`. PR #127
- * (2026-04-19) renamed `'light'` → `'core-axis'` to align the mode name with
- * its selection rationale (at that time: meta-level 4 axes; revised in
- * v0.2.1 to cost-constrained Pareto-optimal core lens set — registry is SSOT).
- * The rename is big-bang (dual-read 미제공) but the runtime still needs to:
- *
- *   1. Reject new inputs that carry old values with a friendly migration
- *      message (not a bare "Invalid review mode" error).
- *   2. Normalize old values found in historical persisted artifacts
- *      (`.onto/review/<session>/execution-result.yaml`) so progressiveness
- *      and audit readers remain functional.
- *
- * Previously (PR #127 initial) these two policies were duplicated across
- * 4 consumers:
- *   - prepare-review-session.ts requireReviewMode validator
- *   - bootstrap-review-binding.ts requireReviewMode validator
- *   - write-review-interpretation.ts requireReviewMode validator
- *   - review-log.ts parseSession reader normalization
- *
- * Duplication means future rename/alias changes must touch 4 seats, each
- * a drift risk. This module consolidates the policy into one canonical seat
- * so future rename cycles have a single entry point.
- *
- * # What this file owns
- *
- * - `LEGACY_REVIEW_MODE_MAP`: single source of truth for old → new mode
- *   mappings
- * - `isLegacyReviewMode`: predicate for old values
- * - `getLegacyReplacement`: look up the new value for a legacy input
- * - `formatLegacyMigrationError`: produce a user-facing friendly error for
- *   stale CLI/config inputs
- * - `normalizeLegacyReviewMode`: map legacy values for reader-only
- *   normalization (returns `string` to preserve original when there is
- *   no mapping)
- *
- * # What this file does NOT own
- *
- * - The canonical `ReviewMode` union (that lives in `artifact-types.ts`)
- * - Other legacy fields (e.g. `suggest_light` JSON key in
- *   `complexity-assessment.ts`) — those use structural `undefined`
- *   fallback, not this map
- *
- * Reference: CHANGELOG.md "Legacy persisted-state policy" + Consumer
- * migration matrix; `development-records/evolve/20260418-light-to-core-axis-rename-proposal.md`
- */
-/**
- * Single source of truth for legacy → current ReviewMode value mappings.
- * Adding a new rename cycle: add the old → new entry here; the 4 consumers
- * automatically pick up the new mapping.
- */
-export const LEGACY_REVIEW_MODE_MAP = {
-    light: "core-axis",
-};
-/** True if `value` is a known legacy ReviewMode name. */
-export function isLegacyReviewMode(value) {
-    return Object.prototype.hasOwnProperty.call(LEGACY_REVIEW_MODE_MAP, value);
-}
-/** Returns the current ReviewMode for a legacy input, or null if unknown. */
-export function getLegacyReplacement(value) {
-    return LEGACY_REVIEW_MODE_MAP[value] ?? null;
-}
-/**
- * Friendly migration error for stale CLI/config inputs.
- * `flag` is the surface the user was using (e.g. `--review-mode`,
- * `review_mode`, `--review-mode-recommendation`).
- */
-export function formatLegacyMigrationError(flag, legacyValue) {
-    const replacement = getLegacyReplacement(legacyValue);
-    if (replacement === null) {
-        return `Invalid ${flag}: ${legacyValue}`;
-    }
-    return (`\`${flag} ${legacyValue}\` was renamed to ` +
-        `\`${flag} ${replacement}\` in v0.2.0 (PR #127). ` +
-        `See CHANGELOG.md for migration.`);
-}
-/**
- * Reader-only normalization: map a raw value to its canonical replacement
- * when it is a known legacy name. Returns the original string otherwise
- * (caller narrows to ReviewMode if it trusts the source).
- */
-export function normalizeLegacyReviewMode(value) {
-    return LEGACY_REVIEW_MODE_MAP[value] ?? value;
-}

package/dist/core-runtime/review/materializers-effort-persist.test.js

@@ -1,79 +0,0 @@
-/**
- * Effort persist (Option A) — bootstrap 시점에 OntoConfig 로부터 resolved_llm_plan
- * 을 session-metadata.yaml 에 durable 기록하는 동작 검증.
- *
- * Source authority: development-records/plan (없음 — memory
- * project_framework_v1_session_20260420.md backlog [4]).
- */
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import fs from "node:fs/promises";
-import path from "node:path";
-import os from "node:os";
-import { parse as parseYaml } from "yaml";
-import { bootstrapInvocationBindingArtifacts } from "./materializers.js";
-async function readYaml(p) {
-    const text = await fs.readFile(p, "utf8");
-    return parseYaml(text);
-}
-async function makeTmpProject() {
-    const base = await fs.mkdtemp(path.join(os.tmpdir(), "onto-effort-persist-"));
-    return base;
-}
-async function writeConfig(projectRoot, yaml) {
-    const dir = path.join(projectRoot, ".onto");
-    await fs.mkdir(dir, { recursive: true });
-    await fs.writeFile(path.join(dir, "config.yml"), yaml, "utf8");
-}
-function commonParams(projectRoot) {
-    return {
-        projectRoot,
-        requestedTarget: "src/foo.ts",
-        targetScopeKind: "file",
-        resolvedTargetRefs: [path.join(projectRoot, "src/foo.ts")],
-        domainFinalValue: "software-engineering",
-        domainSelectionMode: "auto",
-        executionRealization: "subagent",
-        hostRuntime: "codex",
-        reviewMode: "core-axis",
-        resolvedLensIds: ["structure"],
-    };
-}
-describe("bootstrapInvocationBindingArtifacts — resolved_llm_plan persistence", () => {
-    let tmp;
-    beforeEach(async () => {
-        tmp = await makeTmpProject();
-    });
-    afterEach(async () => {
-        await fs.rm(tmp, { recursive: true, force: true });
-    });
-    it("persists resolved_llm_plan from OntoConfig top-level model + codex.effort", async () => {
-        await writeConfig(tmp, "model: gpt-5.4\ncodex:\n  effort: high\n");
-        const { sessionMetadataPath } = await bootstrapInvocationBindingArtifacts(commonParams(tmp));
-        const md = await readYaml(sessionMetadataPath);
-        expect(md.resolved_llm_plan).toBeDefined();
-        expect(md.resolved_llm_plan?.model).toBe("gpt-5.4");
-        expect(md.resolved_llm_plan?.reasoning_effort).toBe("high");
-    });
-    it("persists provider when external_http_provider is set", async () => {
-        await writeConfig(tmp, "external_http_provider: anthropic\nanthropic:\n  model: claude-sonnet-4-6\n");
-        const { sessionMetadataPath } = await bootstrapInvocationBindingArtifacts(commonParams(tmp));
-        const md = await readYaml(sessionMetadataPath);
-        expect(md.resolved_llm_plan?.provider).toBe("anthropic");
-        expect(md.resolved_llm_plan?.model).toBe("claude-sonnet-4-6");
-    });
-    it("omits resolved_llm_plan field when config.yml is missing", async () => {
-        const { sessionMetadataPath } = await bootstrapInvocationBindingArtifacts(commonParams(tmp));
-        const md = await readYaml(sessionMetadataPath);
-        expect(md.resolved_llm_plan).toBeUndefined();
-    });
-    it("omits resolved_llm_plan field when config.yml has no LLM fields", async () => {
-        // Fixture writes an orthogonal-only field so the config YAML is
-        // non-empty but carries no LLM profile information. P9.6 (2026-04-21):
-        // swapped from legacy `execution_topology_priority` to `output_language`
-        // after the P9 runtime cleanup track retired all legacy fields.
-        await writeConfig(tmp, "output_language: en\n");
-        const { sessionMetadataPath } = await bootstrapInvocationBindingArtifacts(commonParams(tmp));
-        const md = await readYaml(sessionMetadataPath);
-        expect(md.resolved_llm_plan).toBeUndefined();
-    });
-});