onto-mcp 0.3.0

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

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

package/dist/core-runtime/review/review-execution-profile.js

@@ -0,0 +1,193 @@
+import { defaultReviewExecution } from "../discovery/settings-chain.js";
+import { detectCodexBinaryAvailable } from "../discovery/host-detection.js";
+import { normalizeLlmModelSwitcher, } from "../llm/model-switcher.js";
+function settingsExecution(settings) {
+    const defaults = defaultReviewExecution();
+    const execution = settings.review?.execution;
+    if (!execution)
+        return defaults;
+    return {
+        ...defaults,
+        ...execution,
+        teamlead: {
+            ...defaults.teamlead,
+            ...execution.teamlead,
+        },
+        lens: {
+            ...defaults.lens,
+            ...execution.lens,
+        },
+        synthesize: {
+            ...defaults.synthesize,
+            ...execution.synthesize,
+        },
+    };
+}
+function actorLlm(actorLlmRef, inherited) {
+    if (actorLlmRef === "inherit")
+        return inherited ?? "inherit";
+    const shouldOverlayInherited = actorLlmRef.auth === undefined && actorLlmRef.provider === undefined;
+    return {
+        ...(shouldOverlayInherited ? inherited ?? {} : {}),
+        ...actorLlmRef,
+    };
+}
+function hostFromEnv(env) {
+    const value = env.ONTO_HOST_RUNTIME?.trim().toLowerCase();
+    if (value === "codex" ||
+        value === "standalone" ||
+        value === "openai" ||
+        value === "anthropic" ||
+        value === "grok" ||
+        value === "lmstudio") {
+        return value;
+    }
+    return null;
+}
+function buildProfile(args) {
+    const execution = settingsExecution(args.settings);
+    const inherited = args.settings.llm;
+    const teamleadLlm = actorLlm(execution.teamlead.llm, inherited);
+    const lensLlm = actorLlm(execution.lens.llm, inherited);
+    const synthesizeLlm = actorLlm(execution.synthesize.llm, inherited);
+    const normalized = normalizeLlmModelSwitcher(inherited);
+    return {
+        mode: execution.mode,
+        teamlead: {
+            seat: execution.teamlead.seat,
+            llm: teamleadLlm,
+        },
+        lens: {
+            seat: execution.lens.seat,
+            llm: lensLlm,
+        },
+        synthesize: {
+            seat: execution.synthesize.seat,
+            llm: synthesizeLlm,
+        },
+        deliberation: execution.deliberation,
+        worker_executor: args.workerExecutor,
+        host: args.host,
+        ...(inherited?.provider ? { provider: inherited.provider } : {}),
+        ...(inherited?.auth ? { auth: inherited.auth } : {}),
+        ...(normalized?.model_id ? { model: normalized.model_id } : {}),
+        ...(normalized?.reasoning_effort ? { effort: normalized.reasoning_effort } : {}),
+        ...(normalized?.service_tier ? { service_tier: normalized.service_tier } : {}),
+        ...(normalized?.base_url ? { base_url: normalized.base_url } : {}),
+        trace: args.trace,
+    };
+}
+function noHost(trace, reason) {
+    return { type: "no_host", trace, reason };
+}
+export function resolveReviewExecutionProfile(args) {
+    const env = args.env ?? process.env;
+    const trace = [];
+    const log = (line) => {
+        trace.push(line);
+        process.stderr.write(`[profile] ${line}\n`);
+    };
+    if (env.ONTO_LLM_MOCK === "1") {
+        log("mock executor selected by ONTO_LLM_MOCK=1");
+        return {
+            type: "resolved",
+            profile: buildProfile({
+                settings: args.settings,
+                workerExecutor: "mock",
+                host: "standalone",
+                trace,
+            }),
+        };
+    }
+    const codexAvailable = args.codexAvailable ?? detectCodexBinaryAvailable();
+    const envHost = hostFromEnv(env);
+    const selection = normalizeLlmModelSwitcher(args.settings.llm);
+    if (env.ONTO_HOST_RUNTIME?.trim().toLowerCase() === "claude") {
+        return noHost(trace, "ONTO_HOST_RUNTIME=claude is not a wired onto-mcp runtime path. Use Codex OAuth, API-key direct-call, local direct-call, or mock.");
+    }
+    if (selection && selection.auth !== "oauth") {
+        log(`direct-call selected by llm.auth=${selection.auth} llm.provider=${selection.provider}`);
+        return {
+            type: "resolved",
+            profile: buildProfile({
+                settings: args.settings,
+                workerExecutor: "direct_call",
+                host: selection.provider,
+                trace,
+            }),
+        };
+    }
+    if (args.explicitCodex) {
+        if (!codexAvailable) {
+            return noHost(trace, "Codex worker was requested, but codex is not available.");
+        }
+        log("codex worker selected by --codex");
+        return {
+            type: "resolved",
+            profile: buildProfile({
+                settings: args.settings,
+                workerExecutor: "codex",
+                host: "codex",
+                trace,
+            }),
+        };
+    }
+    if (envHost && envHost !== "standalone") {
+        if (envHost === "codex") {
+            if (!codexAvailable) {
+                return noHost(trace, "ONTO_HOST_RUNTIME=codex requires an available codex worker.");
+            }
+            log("codex worker selected by ONTO_HOST_RUNTIME=codex");
+            return {
+                type: "resolved",
+                profile: buildProfile({
+                    settings: args.settings,
+                    workerExecutor: "codex",
+                    host: "codex",
+                    trace,
+                }),
+            };
+        }
+        log(`direct-call selected by ONTO_HOST_RUNTIME=${envHost}`);
+        return {
+            type: "resolved",
+            profile: buildProfile({
+                settings: args.settings,
+                workerExecutor: "direct_call",
+                host: envHost,
+                trace,
+            }),
+        };
+    }
+    if (selection?.auth === "oauth") {
+        if (selection.provider !== "codex") {
+            return noHost(trace, "OAuth settings must resolve to the current host worker provider.");
+        }
+        if (!codexAvailable) {
+            return noHost(trace, "llm.auth=oauth with llm.provider=openai requires an available Codex worker.");
+        }
+        log("codex worker selected by host-bound OpenAI OAuth settings");
+        return {
+            type: "resolved",
+            profile: buildProfile({
+                settings: args.settings,
+                workerExecutor: "codex",
+                host: "codex",
+                trace,
+            }),
+        };
+    }
+    if (codexAvailable) {
+        log("codex worker selected by local codex availability");
+        return {
+            type: "resolved",
+            profile: buildProfile({
+                settings: args.settings,
+                workerExecutor: "codex",
+                host: "codex",
+                trace,
+            }),
+        };
+    }
+    return noHost(trace, "No review worker path is available. Configure .onto/settings.json llm auth/provider/model or install/login Codex.");
+}

package/dist/core-runtime/review/review-execution-route.js

@@ -0,0 +1,52 @@
+function isDirectCallHost(host) {
+    return (host === "openai" ||
+        host === "anthropic" ||
+        host === "grok" ||
+        host === "lmstudio");
+}
+function directCallProviderForProfile(profile) {
+    if (isDirectCallHost(profile.host)) {
+        if (profile.provider && profile.provider !== profile.host) {
+            throw new Error(`Review direct-call route has conflicting provider authority: host=${profile.host}, provider=${profile.provider}.`);
+        }
+        if (profile.auth === "oauth") {
+            throw new Error(`Review direct-call route requires API-key/local auth; got auth=oauth for host=${profile.host}.`);
+        }
+        return profile.host;
+    }
+    if (profile.provider)
+        return profile.provider;
+    throw new Error(`Review direct-call route requires an API/local provider host; got host=${profile.host}.`);
+}
+export function buildReviewExecutionRoute(profile) {
+    if (profile.worker_executor === "mock") {
+        return {
+            host: "standalone",
+            executor: "mock",
+            resolved_provider: "mock",
+            auth_mode: null,
+            execution_realization: "direct-call",
+            artifact_host_runtime: "standalone",
+        };
+    }
+    if (profile.worker_executor === "codex") {
+        return {
+            host: "codex",
+            executor: "codex",
+            resolved_provider: "codex",
+            auth_mode: profile.auth ?? "oauth",
+            execution_realization: "worker",
+            artifact_host_runtime: "codex",
+        };
+    }
+    const resolvedProvider = directCallProviderForProfile(profile);
+    const artifactHostRuntime = isDirectCallHost(profile.host) ? profile.host : resolvedProvider;
+    return {
+        host: "standalone",
+        executor: "direct_call",
+        resolved_provider: resolvedProvider,
+        auth_mode: profile.auth ?? null,
+        execution_realization: "direct-call",
+        artifact_host_runtime: artifactHostRuntime,
+    };
+}

package/dist/core-runtime/review/review-progress-contract.js

@@ -0,0 +1,123 @@
+export const REVIEW_PROGRESS_STEPS = [
+    {
+        id: "manifest_validation",
+        step: 1,
+        label: "load execution plan",
+    },
+    {
+        id: "lens_dispatch",
+        step: 2,
+        label: "isolated lens execution",
+        halt_unit_kind: "lens",
+    },
+    {
+        id: "lens_completion_barrier",
+        step: 3,
+        label: "lens completion barrier",
+        halt_phase: "lens_completion_barrier",
+    },
+    {
+        id: "finding_ledger",
+        step: 4,
+        label: "finding ledger",
+        issue_artifact_id: "finding-ledger",
+        halt_phase: "issue_artifact",
+        halt_unit_kind: "issue_artifact",
+    },
+    {
+        id: "finding_relation_graph",
+        step: 5,
+        label: "finding relation graph",
+        issue_artifact_id: "finding-relation-graph",
+        halt_phase: "issue_artifact",
+        halt_unit_kind: "issue_artifact",
+    },
+    {
+        id: "issue_ledger",
+        step: 6,
+        label: "issue ledger",
+        issue_artifact_id: "issue-ledger",
+        halt_phase: "issue_artifact",
+        halt_unit_kind: "issue_artifact",
+    },
+    {
+        id: "issue_stance_matrix",
+        step: 7,
+        label: "issue stance matrix",
+        issue_artifact_id: "issue-stance-matrix",
+        halt_phase: "issue_artifact",
+        halt_unit_kind: "issue_artifact",
+    },
+    {
+        id: "deliberation_plan",
+        step: 8,
+        label: "deliberation plan",
+        issue_artifact_id: "deliberation-plan",
+        halt_phase: "issue_artifact",
+        halt_unit_kind: "issue_artifact",
+    },
+    {
+        id: "lens_deliberation_responses",
+        step: 9,
+        label: "lens deliberation responses",
+        halt_phase: "controlled_lens_deliberation",
+        halt_unit_kind: "deliberation",
+    },
+    {
+        id: "controlled_deliberation",
+        step: 10,
+        label: "teamlead controlled deliberation",
+        halt_phase: "controlled_lens_deliberation",
+        halt_unit_kind: "deliberation",
+    },
+    {
+        id: "problem_framing",
+        step: 11,
+        label: "problem framing",
+        issue_artifact_id: "problem-framing",
+        halt_phase: "issue_artifact",
+        halt_unit_kind: "issue_artifact",
+    },
+    {
+        id: "synthesize",
+        step: 12,
+        label: "synthesize and write execution result",
+        halt_phase: "synthesize",
+        halt_unit_kind: "synthesize",
+    },
+];
+export const REVIEW_PROGRESS_TOTAL_STEPS = REVIEW_PROGRESS_STEPS.length;
+export const REVIEW_EXECUTION_STEP_IDS = REVIEW_PROGRESS_STEPS.map((step) => step.id);
+export function reviewProgressStepById(stepId) {
+    const step = REVIEW_PROGRESS_STEPS.find((candidate) => candidate.id === stepId);
+    if (!step)
+        throw new Error(`Unknown review progress step id: ${stepId}`);
+    return step;
+}
+export function reviewProgressStepByIssueArtifact(artifactId) {
+    const step = REVIEW_PROGRESS_STEPS.find((candidate) => candidate.issue_artifact_id === artifactId);
+    if (!step) {
+        throw new Error(`No review progress step for issue artifact: ${artifactId}`);
+    }
+    return step;
+}
+export function reviewProgressStepIdFromHalt(args) {
+    if (args.haltPhase === "lens_completion_barrier") {
+        return "lens_completion_barrier";
+    }
+    if (args.haltPhase === "synthesize")
+        return "synthesize";
+    if (args.haltPhase === "controlled_lens_deliberation") {
+        return args.haltUnitId === "controlled-deliberation"
+            ? "controlled_deliberation"
+            : "lens_deliberation_responses";
+    }
+    if (args.haltPhase === "issue_artifact") {
+        const unitId = args.haltUnitId;
+        const step = REVIEW_PROGRESS_STEPS.find((candidate) => candidate.issue_artifact_id === unitId);
+        return step?.id ?? "finding_ledger";
+    }
+    if (args.haltUnitKind === "lens")
+        return "lens_dispatch";
+    return null;
+}