onto-mcp 0.3.2 → 0.4.0

package/dist/core-runtime/review/citation-audit.test.js

@@ -1,165 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { auditCitations, extractSignificantQuotes } from "./citation-audit.js";
-describe("extractSignificantQuotes", () => {
-    it("extracts double-quoted strings above threshold", () => {
-        const text = 'The lens said "Top-level value lacks operational backing" in evidence.';
-        const quotes = extractSignificantQuotes(text);
-        expect(quotes.map((q) => q.text)).toContain("Top-level value lacks operational backing");
-    });
-    it("extracts backtick code spans above threshold", () => {
-        const text = "The evidence is at `src/core-runtime/scope-runtime/state-machine.ts` in the module.";
-        const quotes = extractSignificantQuotes(text);
-        expect(quotes.map((q) => q.text)).toContain("src/core-runtime/scope-runtime/state-machine.ts");
-    });
-    it("skips quotes below threshold (default 20)", () => {
-        const text = 'The status is "performed" for now, file `x.ts`.';
-        const quotes = extractSignificantQuotes(text).map((q) => q.text);
-        expect(quotes).not.toContain("performed");
-        expect(quotes).not.toContain("x.ts");
-    });
-    it("respects a custom threshold", () => {
-        const text = "File `x.ts` matters.";
-        const quotes = extractSignificantQuotes(text, { minQuoteLength: 3 });
-        expect(quotes.map((q) => q.text)).toContain("x.ts");
-    });
-    it("de-duplicates identical quotes", () => {
-        const text = '"Declaration without operational backing" appears here and "Declaration without operational backing" again.';
-        const quotes = extractSignificantQuotes(text);
-        expect(quotes.filter((q) => q.text === "Declaration without operational backing").length).toBe(1);
-    });
-    it("handles multi-line quote bodies (single newline tolerated)", () => {
-        const text = '"Line one of a long citation\nthat wraps across one linebreak"';
-        const quotes = extractSignificantQuotes(text);
-        expect(quotes[0]?.text.includes("Line one")).toBe(true);
-    });
-    it("does not extract from triple-backtick code fences as code spans", () => {
-        const text = "Before\n```ts\nconst x = 1;\n```\nAfter";
-        const quotes = extractSignificantQuotes(text);
-        expect(quotes.length).toBe(0);
-    });
-    it("returns empty array when no quoted strings present", () => {
-        const text = "Pure prose with no quotations or backtick spans above threshold.";
-        expect(extractSignificantQuotes(text)).toEqual([]);
-    });
-});
-describe("attribution classification", () => {
-    it("classifies `<lens>:` colon attribution", () => {
-        const text = 'axiology: "Declaration without operational grounding detected"';
-        const [q] = extractSignificantQuotes(text);
-        expect(q?.is_attribution).toBe(true);
-        expect(q?.attributed_lens).toBe("axiology");
-    });
-    it("classifies `**<lens>**:` bold attribution", () => {
-        const text = '**logic**: "Circular dependency across module boundary"';
-        const [q] = extractSignificantQuotes(text);
-        expect(q?.is_attribution).toBe(true);
-        expect(q?.attributed_lens).toBe("logic");
-    });
-    it("classifies verb attribution (said / reports / claims)", () => {
-        const texts = [
-            'Axiology said "purpose-value misalignment in executor"',
-            "Logic reports \"tier-level equivalence cannot be decided\"",
-            'Semantics claims "synonymous terms not consolidated"',
-        ];
-        for (const text of texts) {
-            const [q] = extractSignificantQuotes(text);
-            expect(q?.is_attribution).toBe(true);
-        }
-    });
-    it("classifies `<Lens> lens said` phrasing", () => {
-        const text = 'Coverage lens notes "sub-area missing from scope"';
-        const [q] = extractSignificantQuotes(text);
-        expect(q?.is_attribution).toBe(true);
-        expect(q?.attributed_lens).toBe("coverage");
-    });
-    it("classifies `per <lens>` / `from <lens>` / `according to <lens>` prefix", () => {
-        const texts = [
-            'per logic, "tier-equivalence can be demonstrated structurally"',
-            'from structure: "isolated node in dependency graph found"',
-            'according to pragmatics: "usage context narrows applicability"',
-        ];
-        for (const text of texts) {
-            const [q] = extractSignificantQuotes(text);
-            expect(q?.is_attribution).toBe(true);
-        }
-    });
-    it("does NOT classify a bare quote without a nearby lens reference", () => {
-        const text = 'The synthesis includes a "conditional consensus" section per the canonical taxonomy.';
-        const [q] = extractSignificantQuotes(text);
-        expect(q?.is_attribution).toBe(false);
-        expect(q?.attributed_lens).toBeUndefined();
-    });
-    it("does NOT leak attribution across sentence boundaries", () => {
-        // Lens reference is in the previous sentence; quote here is a bare concept
-        // label, not an attributed citation.
-        const text = 'Axiology covered the purpose axis. Elsewhere the report discusses "conditional consensus" as a taxonomy label.';
-        const quotes = extractSignificantQuotes(text);
-        const taxonomy = quotes.find((q) => q.text === "conditional consensus");
-        expect(taxonomy?.is_attribution).toBe(false);
-    });
-});
-describe("auditCitations", () => {
-    it("flags an attribution-style fabrication in quotes_unmatched (the A3 case)", () => {
-        const synthesize = "### Disagreement\n" +
-            '- Axiology said "Naming alignment between value, activity, and concept is not yet resolved".';
-        const axiologyLens = "Findings: Top-level value 시간/비용 최소화 lacks operational backing in executor.";
-        const depLens = "Authority chain integrity circular between core-lexicon.yaml and .onto/principles/.";
-        const structLens = "Naming alignment resolved as of W-A-77.";
-        const result = auditCitations(synthesize, [axiologyLens, depLens, structLens]);
-        expect(result.quotes_checked).toBe(1);
-        expect(result.attribution_count).toBe(1);
-        expect(result.quotes_unmatched).toContain("Naming alignment between value, activity, and concept is not yet resolved");
-        expect(result.quotes_unmatched_meta).toEqual([]);
-    });
-    it("routes non-attribution unmatched quotes to quotes_unmatched_meta (taxonomy labels)", () => {
-        const synthesize = 'The section is titled "conditional consensus" per the canonical taxonomy, and separately "cross-process deliberation" appears as a meta-concept.';
-        const lensA = "Irrelevant lens body without any taxonomy phrase.";
-        const result = auditCitations(synthesize, [lensA]);
-        // Both taxonomy labels are above threshold 20 and unmatched.
-        expect(result.quotes_unmatched).toEqual([]);
-        expect(result.quotes_unmatched_meta.length).toBeGreaterThanOrEqual(1);
-        // Neither was an attribution citation.
-        expect(result.attribution_count).toBe(0);
-    });
-    it("passes an attribution-style quote that substring-matches a lens", () => {
-        const synthesize = 'axiology: "Top-level value 시간/비용 최소화 lacks operational backing"';
-        const lensContent = "Findings: Top-level value 시간/비용 최소화 lacks operational backing in executor selection.";
-        const result = auditCitations(synthesize, [lensContent]);
-        expect(result.quotes_checked).toBe(1);
-        expect(result.attribution_count).toBe(1);
-        expect(result.quotes_unmatched).toEqual([]);
-        expect(result.quotes_unmatched_meta).toEqual([]);
-    });
-    it("matches against any lens (disjunction)", () => {
-        const synthesize = 'logic: "unique phrase of sufficient length here"';
-        const lensA = "not related content at all";
-        const lensB = "some prose containing unique phrase of sufficient length here inside it";
-        const result = auditCitations(synthesize, [lensA, lensB]);
-        expect(result.quotes_unmatched).toEqual([]);
-        expect(result.quotes_unmatched_meta).toEqual([]);
-    });
-    it("reports empty unmatched lists when no quotes present", () => {
-        const result = auditCitations("Pure synthesis prose.", ["some lens content"]);
-        expect(result.quotes_checked).toBe(0);
-        expect(result.quotes_unmatched).toEqual([]);
-        expect(result.quotes_unmatched_meta).toEqual([]);
-        expect(result.attribution_count).toBe(0);
-    });
-    it("includes min_quote_length in result for traceability", () => {
-        const result = auditCitations("", [], { minQuoteLength: 30 });
-        expect(result.min_quote_length).toBe(30);
-    });
-    it("uses default threshold 20 when options omitted", () => {
-        const result = auditCitations("", []);
-        expect(result.min_quote_length).toBe(20);
-    });
-    it("empty lens pool: attribution unmatched → strict, non-attribution → meta", () => {
-        const synthesize = 'logic: "attribution style phrase of sufficient length for threshold"\n' +
-            'Separately, "non-attributed taxonomy label phrase here" appears.';
-        const result = auditCitations(synthesize, []);
-        expect(result.quotes_checked).toBe(2);
-        expect(result.attribution_count).toBe(1);
-        expect(result.quotes_unmatched).toContain("attribution style phrase of sufficient length for threshold");
-        expect(result.quotes_unmatched_meta).toContain("non-attributed taxonomy label phrase here");
-    });
-});

package/dist/core-runtime/review/execution-plan-resolver.js

@@ -1,247 +0,0 @@
-/** Resolves the concrete review execution plan from host signals and llm config. */
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { detectCodexBinaryAvailable } from "../discovery/host-detection.js";
-import { normalizeLlmModelSwitcher, } from "../llm/model-switcher.js";
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-const DEFAULT_TIMEOUT_MS = Number(process.env.ONTO_LLM_TIMEOUT_MS) || 120_000;
-const DEFAULT_MAX_ATTEMPTS = 2;
-// ---------------------------------------------------------------------------
-// Observability
-// ---------------------------------------------------------------------------
-/**
- * Plan-level STDERR log. Mirrors `[provider-ladder]` and `[model-call]`
- * patterns (PR #91 / PR #93) so operators can reconstruct the full decision
- * sequence from a single STDERR capture.
- *
- * No suppressor env var: decision rationale is load-bearing for review
- * reproducibility. Tests capture via vi.spyOn(process.stderr, "write").
- */
-function emitPlanLog(line) {
-    process.stderr.write(`[plan] ${line}\n`);
-}
-function readCodexAuthState() {
-    const codexAuthPath = path.join(os.homedir(), ".codex", "auth.json");
-    if (!fs.existsSync(codexAuthPath)) {
-        return { chatgptOAuth: false, openaiApiKey: null };
-    }
-    try {
-        const auth = JSON.parse(fs.readFileSync(codexAuthPath, "utf8"));
-        const oauth = auth.auth_mode === "chatgpt" ||
-            (auth.tokens && typeof auth.tokens.access_token === "string");
-        const openaiKey = typeof auth.OPENAI_API_KEY === "string" && auth.OPENAI_API_KEY.length > 0
-            ? auth.OPENAI_API_KEY
-            : null;
-        return { chatgptOAuth: Boolean(oauth), openaiApiKey: openaiKey };
-    }
-    catch {
-        return { chatgptOAuth: false, openaiApiKey: null };
-    }
-}
-// ---------------------------------------------------------------------------
-// Ladder resolution
-// ---------------------------------------------------------------------------
-/**
- * Compute the ExecutionPlan by walking the context-separation ladder.
- *
- * Priority (higher rank = preferred, matches sketch §3.2):
- *   P0  Mock (ONTO_LLM_MOCK=1)                        — test only
- *   P1a Explicit --codex CLI flag                      — subprocess (S0)
- *   P1f env ONTO_HOST_RUNTIME override                 — any rank
- *   P2  Auto-detected Claude Code host (CLAUDECODE=1)  — host nested spawn (S2)
- *   P3  Auto-detected codex binary + auth.json         — subprocess (S0)
- *   P4  llm auth/provider switcher                     — external HTTP (S1) or codex OAuth
- *   Fail-fast when nothing is viable.
- *
- * The `review:` axis block owns topology. The `llm` switcher owns provider
- * and auth selection. Missing viable execution input returns `no_host`.
- */
-export function resolveExecutionPlan(args) {
-    const env = args.env ?? process.env;
-    const claudeHost = args.claudeHost ?? env.CLAUDECODE === "1";
-    const codexAvailable = args.codexAvailable ?? detectCodexBinaryAvailable();
-    const trace = [];
-    const log = (line) => {
-        emitPlanLog(line);
-        trace.push(line);
-    };
-    const retry_policy = {
-        timeout_ms: DEFAULT_TIMEOUT_MS,
-        max_attempts: DEFAULT_MAX_ATTEMPTS,
-        backoff: "exponential",
-    };
-    // P0: Mock — test envelope.
-    if (env.ONTO_LLM_MOCK === "1") {
-        log("P0 mock: matched (ONTO_LLM_MOCK=1)");
-        return {
-            type: "resolved",
-            plan: {
-                separation_rank: "S3",
-                execution_realization: "mock",
-                host_runtime: "mock",
-                provider_identity: "mock",
-                retry_policy,
-                plan_trace: trace,
-            },
-        };
-    }
-    // P1a: Explicit --codex flag. Overrides all other inputs.
-    if (args.explicitCodex) {
-        log("P1 explicit-codex: matched (--codex flag)");
-        return resolveCodexPlan(log, trace, retry_policy, args.ontoConfig);
-    }
-    // P1f: env ONTO_HOST_RUNTIME override.
-    const envHost = env.ONTO_HOST_RUNTIME?.trim().toLowerCase();
-    if (envHost === "codex") {
-        log("P1 env-override: ONTO_HOST_RUNTIME=codex");
-        return resolveCodexPlan(log, trace, retry_policy, args.ontoConfig);
-    }
-    if (envHost === "claude") {
-        log("P1 env-override: ONTO_HOST_RUNTIME=claude → agent-teams");
-        return {
-            type: "resolved",
-            plan: {
-                separation_rank: "S2",
-                execution_realization: "agent-teams",
-                host_runtime: "claude",
-                provider_identity: "claude-code",
-                retry_policy,
-                plan_trace: trace,
-            },
-        };
-    }
-    if (envHost === "anthropic" || envHost === "openai" || envHost === "grok" || envHost === "lmstudio") {
-        log(`P1 env-override: ONTO_HOST_RUNTIME=${envHost} → ts_inline_http`);
-        return resolveExternalHttpPlan(log, trace, retry_policy, args.ontoConfig, { forcedProvider: envHost });
-    }
-    if (envHost === "standalone") {
-        log("P1 env-override: ONTO_HOST_RUNTIME=standalone → ts_inline_http");
-        return resolveExternalHttpPlan(log, trace, retry_policy, args.ontoConfig);
-    }
-    // P2: Auto-detected Claude Code host (stay-in-host).
-    if (claudeHost) {
-        log("P2 auto: claudeHost=true → agent-teams / host-nested-spawn");
-        return {
-            type: "resolved",
-            plan: {
-                separation_rank: "S2",
-                execution_realization: "agent-teams",
-                host_runtime: "claude",
-                provider_identity: "claude-code",
-                retry_policy,
-                plan_trace: trace,
-            },
-        };
-    }
-    // P3: Auto-detected codex. Auth content is validated at invocation time.
-    if (codexAvailable) {
-        log("P3 auto: codex binary + auth.json present → subprocess");
-        return resolveCodexPlan(log, trace, retry_policy, args.ontoConfig);
-    }
-    log("P3 auto: codex binary unavailable → skip");
-    // P4: canonical llm switcher.
-    const llmSelection = normalizeLlmModelSwitcher(args.ontoConfig.llm);
-    if (llmSelection) {
-        if (llmSelection.provider === "codex") {
-            log("P4 llm switcher: auth=oauth provider=openai → codex subprocess");
-            return resolveCodexPlan(log, trace, retry_policy, args.ontoConfig);
-        }
-        log(`P4 llm switcher: auth=${llmSelection.auth} provider=${llmSelection.provider} → ts_inline_http`);
-        return resolveExternalHttpPlan(log, trace, retry_policy, args.ontoConfig);
-    }
-    log("final: no viable path → no_host");
-    return {
-        type: "no_host",
-        plan_trace: trace,
-        reason: buildNoHostReason(),
-    };
-}
-// ---------------------------------------------------------------------------
-// Sub-resolvers
-// ---------------------------------------------------------------------------
-function resolveCodexPlan(log, trace, retry_policy, config) {
-    const selection = normalizeLlmModelSwitcher(config.llm);
-    const modelId = selection?.provider === "codex" ? selection.model_id : undefined;
-    log(`codex plan: separation_rank=S0 executor=subprocess model_id=${modelId ?? "(codex default)"}`);
-    return {
-        type: "resolved",
-        plan: {
-            separation_rank: "S0",
-            execution_realization: "subagent",
-            host_runtime: "codex",
-            provider_identity: "codex",
-            ...(modelId ? { model_id: modelId } : {}),
-            retry_policy,
-            plan_trace: trace,
-        },
-    };
-}
-function resolveExternalHttpPlan(log, trace, retry_policy, config, opts) {
-    const providerField = pickExternalProviderField(config, opts);
-    if (!providerField.provider) {
-        log("external-http: no provider identified (llm.provider unset)");
-        return {
-            type: "no_host",
-            plan_trace: trace,
-            reason: buildMissingExternalProviderReason(),
-        };
-    }
-    const provider = providerField.provider;
-    const selection = normalizeLlmModelSwitcher(config.llm);
-    const modelId = selection?.model_id;
-    const base_url = selection?.base_url;
-    log(`external-http plan: provider=${provider} source=${providerField.source} model_id=${modelId ?? "(unresolved)"} base_url=${base_url ?? "(default)"}`);
-    return {
-        type: "resolved",
-        plan: {
-            separation_rank: "S1",
-            execution_realization: "ts_inline_http",
-            host_runtime: provider,
-            provider_identity: provider,
-            ...(modelId ? { model_id: modelId } : {}),
-            ...(base_url ? { base_url } : {}),
-            retry_policy,
-            plan_trace: trace,
-        },
-    };
-}
-function pickExternalProviderField(config, opts) {
-    if (opts?.forcedProvider) {
-        return { provider: opts.forcedProvider, source: "forced (env ONTO_HOST_RUNTIME)" };
-    }
-    const selection = normalizeLlmModelSwitcher(config.llm);
-    if (selection && selection.provider !== "codex") {
-        return { provider: selection.provider, source: "llm" };
-    }
-    return { provider: null, source: "(none)" };
-}
-// ---------------------------------------------------------------------------
-// Error messages
-// ---------------------------------------------------------------------------
-function buildNoHostReason() {
-    return [
-        "Review execution plan을 해소할 수 없습니다.",
-        "현재 감지 결과: Claude Code 세션 아님(CLAUDECODE unset), codex 바이너리 또는 ~/.codex/auth.json 부재, llm switcher 미설정.",
-        "",
-        "다음 중 한 가지로 해결하세요:",
-        "  1. Claude Code 세션에서 `onto review` 재실행",
-        "  2. codex CLI 설치 + `codex login` 후 재실행",
-        "  3. `--codex` 플래그로 codex subprocess 강제",
-        "  4. `.onto/config.yml` 에 `review:` block 추가 (`.onto/processes/configuration.md` 참고)",
-        "  5. `.onto/config.yml` 에 llm: { auth, provider, model } 설정",
-        "  6. local 실행은 llm.auth=local + llm.provider=lmstudio 로 설정",
-    ].join("\n");
-}
-function buildMissingExternalProviderReason() {
-    return [
-        "LLM switcher 미지정.",
-        "`.onto/config.yml` 에 llm block 을 추가하세요:",
-        "  llm:",
-        "    auth: api_key",
-        "    provider: anthropic    # 또는 openai | grok | lmstudio",
-        "    model: <model-id>",
-    ].join("\n");
-}

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

@@ -1,243 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { resolveExecutionPlan, } from "./execution-plan-resolver.js";
-// ---------------------------------------------------------------------------
-// These tests assert two invariants of the unified ExecutionPlan resolver:
-//
-// (1) Every decision point writes a trace line, so operators can reconstruct
-//     the ladder walk from STDERR + plan_trace alone. "Silent divergence" —
-//     the failure mode that made review fail 5 times on 2026-04-17~18 — is
-//     structurally impossible when every branch logs.
-//
-// (2) The returned ExecutionPlan shape is stable: separation_rank,
-//     execution_realization, host_runtime, and provider_identity are always
-//     populated together; callers can rely on this quadruple without
-//     defensive undefined checks.
-// ---------------------------------------------------------------------------
-const BASE_CONFIG = {};
-function expectResolved(resolution) {
-    if (resolution.type !== "resolved") {
-        throw new Error(`expected resolved, got no_host: ${resolution.reason.slice(0, 80)}`);
-    }
-    return resolution;
-}
-function expectNoHost(resolution) {
-    if (resolution.type !== "no_host") {
-        throw new Error(`expected no_host, got resolved plan with rank=${resolution.plan.separation_rank}`);
-    }
-    return resolution;
-}
-describe("resolveExecutionPlan — P0 mock", () => {
-    it("P0 mock: ONTO_LLM_MOCK=1 short-circuits the ladder at S3", () => {
-        const res = resolveExecutionPlan({
-            explicitCodex: false,
-            ontoConfig: BASE_CONFIG,
-            env: { ONTO_LLM_MOCK: "1" },
-            claudeHost: false,
-            codexAvailable: false,
-        });
-        const resolved = expectResolved(res);
-        expect(resolved.plan.separation_rank).toBe("S3");
-        expect(resolved.plan.execution_realization).toBe("mock");
-        expect(resolved.plan.provider_identity).toBe("mock");
-        expect(resolved.plan.plan_trace[0]).toContain("P0 mock: matched");
-    });
-});
-describe("resolveExecutionPlan — P1 explicit", () => {
-    it("P1a --codex flag wins over claudeHost auto-detection", () => {
-        const res = resolveExecutionPlan({
-            explicitCodex: true,
-            ontoConfig: {},
-            env: {},
-            claudeHost: true, // would otherwise match P2
-            codexAvailable: false,
-        });
-        const resolved = expectResolved(res);
-        expect(resolved.plan.separation_rank).toBe("S0");
-        expect(resolved.plan.host_runtime).toBe("codex");
-        expect(resolved.plan.provider_identity).toBe("codex");
-        expect(resolved.plan.plan_trace[0]).toContain("P1 explicit-codex");
-    });
-    it("P1f env ONTO_HOST_RUNTIME=litellm forces ts_inline_http with matching provider", () => {
-        const res = resolveExecutionPlan({
-            explicitCodex: false,
-            ontoConfig: {
-                external_http_provider: "litellm",
-                llm_base_url: "http://proxy.local",
-                litellm: { model: "llama-8b" },
-            },
-            env: { ONTO_HOST_RUNTIME: "litellm" },
-            claudeHost: false,
-            codexAvailable: false,
-        });
-        const resolved = expectResolved(res);
-        expect(resolved.plan.separation_rank).toBe("S1");
-        expect(resolved.plan.execution_realization).toBe("ts_inline_http");
-        expect(resolved.plan.provider_identity).toBe("litellm");
-        expect(resolved.plan.base_url).toBe("http://proxy.local");
-    });
-});
-describe("resolveExecutionPlan — P2/P3 auto-detection", () => {
-    it("P2 claudeHost=true wins over codexAvailable (stay-in-host)", () => {
-        const res = resolveExecutionPlan({
-            explicitCodex: false,
-            ontoConfig: {},
-            env: {},
-            claudeHost: true,
-            codexAvailable: true, // would match P3 if P2 didn't exist
-        });
-        const resolved = expectResolved(res);
-        expect(resolved.plan.host_runtime).toBe("claude");
-        expect(resolved.plan.separation_rank).toBe("S2");
-    });
-    it("P3 codexAvailable=true → S0 subprocess", () => {
-        const res = resolveExecutionPlan({
-            explicitCodex: false,
-            ontoConfig: {},
-            env: {},
-            claudeHost: false,
-            codexAvailable: true,
-        });
-        const resolved = expectResolved(res);
-        expect(resolved.plan.separation_rank).toBe("S0");
-        expect(resolved.plan.provider_identity).toBe("codex");
-    });
-    it("P4 external_http_provider config → ts_inline_http when no host/codex", () => {
-        const res = resolveExecutionPlan({
-            explicitCodex: false,
-            ontoConfig: {
-                external_http_provider: "anthropic",
-                anthropic: { model: "claude-sonnet-4" },
-            },
-            env: {},
-            claudeHost: false,
-            codexAvailable: false,
-        });
-        const resolved = expectResolved(res);
-        expect(resolved.plan.separation_rank).toBe("S1");
-        expect(resolved.plan.provider_identity).toBe("anthropic");
-        expect(resolved.plan.model_id).toBe("claude-sonnet-4");
-    });
-    it("no viable path → no_host with reason", () => {
-        const res = resolveExecutionPlan({
-            explicitCodex: false,
-            ontoConfig: {},
-            env: {},
-            claudeHost: false,
-            codexAvailable: false,
-        });
-        const nohost = expectNoHost(res);
-        expect(nohost.reason).toContain("Review execution plan");
-        expect(nohost.plan_trace.length).toBeGreaterThan(0);
-        expect(nohost.plan_trace.at(-1)).toContain("no viable path");
-    });
-});
-describe("resolveExecutionPlan — env override", () => {
-    it("ONTO_HOST_RUNTIME=standalone → ts_inline_http + provider lookup", () => {
-        const res = resolveExecutionPlan({
-            explicitCodex: false,
-            ontoConfig: { external_http_provider: "openai", openai: { model: "gpt-5" } },
-            env: { ONTO_HOST_RUNTIME: "standalone" },
-            claudeHost: true, // env should override claudeHost auto-detection
-            codexAvailable: true,
-        });
-        const resolved = expectResolved(res);
-        expect(resolved.plan.execution_realization).toBe("ts_inline_http");
-        expect(resolved.plan.provider_identity).toBe("openai");
-        expect(resolved.plan.model_id).toBe("gpt-5");
-    });
-    it("ONTO_HOST_RUNTIME=codex → subprocess even without explicit flag", () => {
-        const res = resolveExecutionPlan({
-            explicitCodex: false,
-            ontoConfig: {},
-            env: { ONTO_HOST_RUNTIME: "codex" },
-            claudeHost: false,
-            codexAvailable: false, // env override ignores auto-detection
-        });
-        const resolved = expectResolved(res);
-        expect(resolved.plan.host_runtime).toBe("codex");
-    });
-});
-describe("resolveExecutionPlan — observability", () => {
-    let stderrSpy;
-    beforeEach(() => {
-        stderrSpy = vi.spyOn(process.stderr, "write").mockImplementation(() => true);
-    });
-    afterEach(() => {
-        stderrSpy.mockRestore();
-    });
-    it("emits [plan] prefix for every decision line", () => {
-        resolveExecutionPlan({
-            explicitCodex: false,
-            ontoConfig: {},
-            env: {},
-            claudeHost: true,
-            codexAvailable: false,
-        });
-        const calls = stderrSpy.mock.calls.map((c) => String(c[0]));
-        const planLines = calls.filter((l) => l.startsWith("[plan]"));
-        expect(planLines.length).toBeGreaterThan(0);
-        for (const line of planLines) {
-            expect(line).toMatch(/^\[plan\] /);
-        }
-    });
-    it("plan_trace matches what was emitted to stderr (single source of truth)", () => {
-        const res = resolveExecutionPlan({
-            explicitCodex: true,
-            ontoConfig: {},
-            env: {},
-            claudeHost: false,
-            codexAvailable: false,
-        });
-        const resolved = expectResolved(res);
-        const stderrLines = stderrSpy.mock.calls
-            .map((c) => String(c[0]))
-            .filter((l) => l.startsWith("[plan] "))
-            .map((l) => l.replace(/^\[plan\] /, "").replace(/\n$/, ""));
-        expect(resolved.plan.plan_trace).toEqual(stderrLines);
-    });
-    it("no_host resolution still surfaces plan_trace for debugging", () => {
-        const res = resolveExecutionPlan({
-            explicitCodex: false,
-            ontoConfig: {},
-            env: {},
-            claudeHost: false,
-            codexAvailable: false,
-        });
-        const nohost = expectNoHost(res);
-        expect(nohost.plan_trace).toBeDefined();
-        expect(nohost.plan_trace.length).toBeGreaterThan(0);
-    });
-});
-describe("resolveExecutionPlan — provider resolution priority", () => {
-    it("external_http_provider > subagent_llm.provider", () => {
-        const res = resolveExecutionPlan({
-            explicitCodex: false,
-            ontoConfig: {
-                external_http_provider: "anthropic",
-                subagent_llm: { provider: "litellm" }, // loser
-                anthropic: { model: "claude-x" },
-            },
-            env: {},
-            claudeHost: false,
-            codexAvailable: false,
-        });
-        const resolved = expectResolved(res);
-        expect(resolved.plan.provider_identity).toBe("anthropic");
-    });
-});
-describe("resolveExecutionPlan — retry policy", () => {
-    it("retry_policy is populated on every resolved plan", () => {
-        const res = resolveExecutionPlan({
-            explicitCodex: true,
-            ontoConfig: {},
-            env: {},
-            claudeHost: false,
-            codexAvailable: false,
-        });
-        const resolved = expectResolved(res);
-        expect(resolved.plan.retry_policy).toBeDefined();
-        expect(resolved.plan.retry_policy.timeout_ms).toBeGreaterThan(0);
-        expect(resolved.plan.retry_policy.max_attempts).toBeGreaterThanOrEqual(1);
-        expect(["exponential", "linear", "none"]).toContain(resolved.plan.retry_policy.backoff);
-    });
-});