onto-mcp 0.3.0

package/dist/core-runtime/discovery/config-profile.js

@@ -0,0 +1,199 @@
+/**
+ * Atomic profile adoption for review config chain.
+ *
+ * # What this module is
+ *
+ * A policy module that enforces **atomic profile ownership** when merging
+ * project `.onto/config.yml` over global `~/.onto/config.yml`:
+ *
+ *   - Provider-coupled fields (`llm`, `main_llm`, `lens_agent_teams_mode`)
+ *     belong to ONE
+ *     source only. Either the project owns the whole profile, or the global
+ *     does — never a frankenstein merge.
+ *   - Orthogonal fields (output_language, domains, review_mode, etc.) remain
+ *     free to merge field-by-field because they carry no cross-provider
+ *     semantics.
+ *
+ * # How it relates
+ *
+ * `adoptProfile()` is called from `resolveConfigChain()`. It returns the
+ * adopted profile fields (one source, or empty when neither side declared
+ * any). `resolveConfigChain()` is the single integration seat for review
+ * callers.
+ *
+ * The atomic-ownership principle is preserved: `extractProfileFields`
+ * still transfers PROFILE_FIELDS as a group, so frankenstein merges
+ * remain impossible.
+ */
+// ---------------------------------------------------------------------------
+// Profile vs orthogonal field partitioning
+// ---------------------------------------------------------------------------
+/**
+ * Top-level OntoConfig keys whose semantics are coupled to the provider choice.
+ * A single source owns the entire set per adoption cycle.
+ */
+export const PROFILE_FIELDS = new Set([
+    "llm",
+    "main_llm",
+    "lens_agent_teams_mode",
+]);
+/**
+ * Orthogonal fields (output language, domain scope, listing limits, etc.)
+ * continue to merge last-wins across home → project. These do not encode
+ * provider-coupled semantics.
+ */
+function isOrthogonalField(key) {
+    return !PROFILE_FIELDS.has(key);
+}
+/**
+ * SSOT predicate for "does this config declare a non-empty `review:` axis
+ * block?". This is consumed only by `claimsProfileOwnership`
+ * below (the atomic-adoption ownership signal).
+ *
+ * A block counts as declared when it is a non-null object with at least
+ * one key. An empty `review: {}` does not count.
+ *
+ * Accepts either a typed `OntoConfig` or a raw `Record<string, unknown>`
+ * for compatibility with callers that read YAML before typing.
+ */
+export function hasReviewBlock(config) {
+    if (config === undefined || config === null)
+        return false;
+    const review = config.review;
+    if (typeof review !== "object" || review === null)
+        return false;
+    return Object.keys(review).length > 0;
+}
+// ---------------------------------------------------------------------------
+// Profile field presence
+// ---------------------------------------------------------------------------
+/**
+ * Does this config declare ANY PROFILE_FIELDS value? Used by `adoptProfile`
+ * to decide which side owns the profile slice. Returns true when at least
+ * one profile field is set to a non-empty value.
+ */
+export function hasAnyProfileField(config) {
+    for (const field of PROFILE_FIELDS) {
+        const value = config[field];
+        if (value === undefined || value === null)
+            continue;
+        if (typeof value === "object" && !Array.isArray(value)) {
+            if (Object.keys(value).length === 0)
+                continue;
+        }
+        return true;
+    }
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Profile extraction
+// ---------------------------------------------------------------------------
+/**
+ * Extract only profile-scoped fields from a config. Orthogonal fields are
+ * dropped — this is the "profile slice" that adoption transfers atomically.
+ */
+export function extractProfileFields(config) {
+    const out = {};
+    for (const field of PROFILE_FIELDS) {
+        const value = config[field];
+        if (value !== undefined && value !== null) {
+            out[field] = value;
+        }
+    }
+    return out;
+}
+/**
+ * Does this config claim profile ownership? A side claims ownership when it
+ * declares either any PROFILE_FIELDS value OR a non-empty `review:` axis
+ * block. The axis block is orthogonal-merged (not part of the profile slice
+ * itself), but its presence signals "I opted in to declaring this review
+ * setup" — which is strong enough to commit that side to owning whatever
+ * profile fields accompany it.
+ */
+function claimsProfileOwnership(config) {
+    return hasAnyProfileField(config) || hasReviewBlock(config);
+}
+/**
+ * Adopt exactly one profile atomically.
+ *
+ * # Decision table
+ *
+ *   sameRoot                              → home/project are the same file, treat as global
+ *   project claims ownership              → adopt project
+ *   project does not, home claims         → adopt home
+ *   neither claims                        → empty profile, source="none"
+ *
+ * # What "claims ownership" means
+ *
+ * Either a non-empty `review:` axis block OR any PROFILE_FIELDS value.
+ * See `claimsProfileOwnership` above.
+ *
+ * # Atomic ownership invariant
+ *
+ * When `source === "project"`, home's profile fields never appear in
+ * `profile`. When `source === "global"`, project's profile fields never
+ * appear. `extractProfileFields` is the enforcement point — it takes
+ * from one source only. Frankenstein merges remain impossible.
+ */
+export function adoptProfile(args) {
+    if (args.sameRoot) {
+        // Single-root case: home === project, so home's profile IS project's.
+        // Report as "global" for traceability (the home path is the canonical
+        // path for same-root runs).
+        if (claimsProfileOwnership(args.home)) {
+            return {
+                profile: extractProfileFields(args.home),
+                source: "global",
+                source_path: args.homePath,
+            };
+        }
+        return { profile: {}, source: "none", source_path: null };
+    }
+    if (claimsProfileOwnership(args.project)) {
+        return {
+            profile: extractProfileFields(args.project),
+            source: "project",
+            source_path: args.projectPath,
+        };
+    }
+    if (claimsProfileOwnership(args.home)) {
+        return {
+            profile: extractProfileFields(args.home),
+            source: "global",
+            source_path: args.homePath,
+        };
+    }
+    return { profile: {}, source: "none", source_path: null };
+}
+// ---------------------------------------------------------------------------
+// Orthogonal merge utility (used by resolveConfigChain)
+// ---------------------------------------------------------------------------
+/**
+ * Merge orthogonal (non-profile) fields from home and project with last-wins
+ * semantics. `excluded_names` uses union merge.
+ */
+export function mergeOrthogonalFields(home, project) {
+    const merged = {};
+    for (const [key, value] of Object.entries(home)) {
+        if (!isOrthogonalField(key) || value === undefined || value === null)
+            continue;
+        merged[key] = value;
+    }
+    for (const [key, value] of Object.entries(project)) {
+        if (!isOrthogonalField(key) || value === undefined || value === null)
+            continue;
+        if (key === "excluded_names") {
+            const homeNames = Array.isArray(home.excluded_names)
+                ? home.excluded_names
+                : [];
+            const projectNames = Array.isArray(value) ? value : [];
+            merged[key] = [
+                ...new Set([...homeNames, ...projectNames]),
+            ];
+        }
+        else {
+            merged[key] = value;
+        }
+    }
+    return merged;
+}

package/dist/core-runtime/discovery/config-profile.test.js

@@ -0,0 +1,233 @@
+import { describe, it, expect } from "vitest";
+import { adoptProfile, extractProfileFields, hasAnyProfileField, hasReviewBlock, mergeOrthogonalFields, } from "./config-profile.js";
+// ---------------------------------------------------------------------------
+// Atomic profile adoption invariants (post-P9.4, 2026-04-21).
+// ---------------------------------------------------------------------------
+//
+// These tests assert two invariants:
+//
+//   (1) Ownership is atomic — one source owns the full profile slice.
+//       No frankenstein merges where profile fields from different
+//       sources coexist in the adopted result.
+//
+//   (2) The adoption layer does NOT decide whether a profile is "runnable".
+//       Empty profiles and single-side-only profiles both return cleanly;
+//       the topology resolver's universal `main_native` degrade owns the
+//       "no viable host" fail-fast (P9.3).
+// ---------------------------------------------------------------------------
+// ─── hasAnyProfileField ───
+describe("hasAnyProfileField", () => {
+    it("empty config → false", () => {
+        expect(hasAnyProfileField({})).toBe(false);
+    });
+    it("only orthogonal fields → false", () => {
+        expect(hasAnyProfileField({
+            output_language: "ko",
+            review_mode: "full",
+            domains: ["se"],
+        })).toBe(false);
+    });
+    it("per-provider block set → true", () => {
+        expect(hasAnyProfileField({ codex: { model: "gpt-5.4" } })).toBe(true);
+    });
+    it("top-level model set → true", () => {
+        expect(hasAnyProfileField({ model: "gpt-5.4" })).toBe(true);
+    });
+    it("empty per-provider block (e.g. `codex: {}`) → false", () => {
+        // YAML authors who wrote `codex:` without a body should not flip
+        // profile ownership.
+        expect(hasAnyProfileField({ codex: {} })).toBe(false);
+    });
+});
+// ─── hasReviewBlock (surviving legacy-bypass SSOT) ───
+describe("hasReviewBlock", () => {
+    it("undefined / empty → false", () => {
+        expect(hasReviewBlock(undefined)).toBe(false);
+        expect(hasReviewBlock({})).toBe(false);
+    });
+    it("review block with one key → true", () => {
+        expect(hasReviewBlock({
+            review: { subagent: { provider: "main-native" } },
+        })).toBe(true);
+    });
+    it("empty `review: {}` → false (prevents accidental opt-in)", () => {
+        expect(hasReviewBlock({ review: {} })).toBe(false);
+    });
+});
+// ─── extractProfileFields ───
+describe("extractProfileFields", () => {
+    it("returns only profile fields, not orthogonal", () => {
+        const cfg = {
+            anthropic: { model: "claude-haiku-4-5" },
+            reasoning_effort: "high",
+            output_language: "ko", // orthogonal
+            domains: ["se"], // orthogonal
+            review_mode: "full", // orthogonal
+        };
+        const extracted = extractProfileFields(cfg);
+        expect(extracted.anthropic).toEqual({ model: "claude-haiku-4-5" });
+        expect(extracted.reasoning_effort).toBe("high");
+        expect(extracted.output_language).toBeUndefined();
+        expect(extracted.domains).toBeUndefined();
+        expect(extracted.review_mode).toBeUndefined();
+    });
+});
+// ─── adoptProfile — decision table (post-P9.4) ───
+const HOME_PATH = "/home/.onto/config.yml";
+const PROJECT_PATH = "/project/.onto/config.yml";
+function buildArgs(home, project) {
+    return { home, project, homePath: HOME_PATH, projectPath: PROJECT_PATH, sameRoot: false };
+}
+describe("adoptProfile — decision branches", () => {
+    it("project has profile → source=project", () => {
+        const adoption = adoptProfile(buildArgs({
+            review: { subagent: { provider: "codex", model_id: "gpt-5.4" } },
+            codex: { model: "gpt-5.4" },
+            reasoning_effort: "high",
+        }, {
+            review: { subagent: { provider: "main-native" } },
+            anthropic: { model: "claude-haiku-4-5" },
+        }));
+        expect(adoption.source).toBe("project");
+        expect(adoption.source_path).toBe(PROJECT_PATH);
+        expect(adoption.profile.anthropic).toEqual({ model: "claude-haiku-4-5" });
+        // Atomic ownership invariant: home's codex-flavored fields must NOT appear.
+        expect(adoption.profile.reasoning_effort).toBeUndefined();
+        expect(adoption.profile.codex).toBeUndefined();
+    });
+    it("project has ONLY review block (no profile fields) → source=project (ownership claimed)", () => {
+        // P9.4 invariant: a non-empty `review:` axis block alone signals
+        // profile ownership even without any PROFILE_FIELDS. This preserves
+        // B-5 class behaviour where a project declares `review:` + empty
+        // `codex: {}` and expects the codex namespace slot to survive
+        // adoption (belonging to the project, not inherited from home).
+        const adoption = adoptProfile(buildArgs({
+            review: { subagent: { provider: "main-native" } },
+            anthropic: { model: "claude-haiku-4-5" },
+        }, {
+            review: { subagent: { provider: "codex", model_id: "gpt-5.4" } },
+            codex: {}, // empty namespace — not counted by hasAnyProfileField,
+            // but the review block still claims ownership.
+        }));
+        expect(adoption.source).toBe("project");
+        // Home's anthropic namespace MUST NOT leak into the adopted profile.
+        expect(adoption.profile.anthropic).toBeUndefined();
+    });
+    it("project has profile without review block → still source=project", () => {
+        // P9.4 change: a project with only a `codex:` namespace (no `review:`
+        // axis block) now owns the profile. Previously this was treated as
+        // "touched-but-incomplete" and deferred to home.
+        const adoption = adoptProfile(buildArgs({
+            review: { subagent: { provider: "main-native" } },
+            anthropic: { model: "claude-haiku-4-5" },
+        }, { codex: { model: "gpt-5.4" } /* no review block */ }));
+        expect(adoption.source).toBe("project");
+        expect(adoption.profile.codex).toEqual({ model: "gpt-5.4" });
+        expect(adoption.profile.anthropic).toBeUndefined();
+    });
+    it("project has nothing, home has ONLY review block (no profile fields) → source=global", () => {
+        // Symmetric to the project-review-block-only case. `claimsProfileOwnership`
+        // must recognize a non-empty review block on the home side as an
+        // ownership claim, so home config authors can stage review settings
+        // without declaring a provider namespace.
+        const adoption = adoptProfile(buildArgs({
+            review: { subagent: { provider: "codex", model_id: "gpt-5.4" } },
+            // No PROFILE_FIELDS — only the review block.
+        }, {}));
+        expect(adoption.source).toBe("global");
+        expect(adoption.source_path).toBe(HOME_PATH);
+        // Adopted profile is empty (no PROFILE_FIELDS in home), but
+        // ownership was still claimed so we don't fall to source=none.
+        expect(adoption.profile).toEqual({});
+    });
+    it("project has no profile fields, home has → source=global", () => {
+        const adoption = adoptProfile(buildArgs({
+            review: { subagent: { provider: "codex", model_id: "gpt-5.4" } },
+            codex: { model: "gpt-5.4" },
+        }, {}));
+        expect(adoption.source).toBe("global");
+        expect(adoption.source_path).toBe(HOME_PATH);
+        expect(adoption.profile.codex).toEqual({ model: "gpt-5.4" });
+    });
+    it("project has no profile, home has only orthogonal fields → source=none", () => {
+        const adoption = adoptProfile(buildArgs({ output_language: "ko" /* orthogonal only */ }, {}));
+        expect(adoption.source).toBe("none");
+        expect(adoption.source_path).toBeNull();
+        expect(adoption.profile).toEqual({});
+    });
+    it("both absent → source=none (no throw — resolver handles it)", () => {
+        const adoption = adoptProfile(buildArgs({}, {}));
+        expect(adoption.source).toBe("none");
+        expect(adoption.profile).toEqual({});
+    });
+    it("sameRoot + home has profile → source=global", () => {
+        const adoption = adoptProfile({
+            home: {
+                review: { subagent: { provider: "codex", model_id: "gpt-5.4" } },
+                codex: { model: "gpt-5.4" },
+            },
+            // sameRoot: project is the same as home, so same object content.
+            project: {
+                review: { subagent: { provider: "codex", model_id: "gpt-5.4" } },
+                codex: { model: "gpt-5.4" },
+            },
+            homePath: HOME_PATH,
+            projectPath: PROJECT_PATH,
+            sameRoot: true,
+        });
+        expect(adoption.source).toBe("global");
+        expect(adoption.source_path).toBe(HOME_PATH);
+        expect(adoption.profile.codex).toEqual({ model: "gpt-5.4" });
+    });
+    it("sameRoot + no profile → source=none", () => {
+        const adoption = adoptProfile({
+            home: {},
+            project: {},
+            homePath: HOME_PATH,
+            projectPath: PROJECT_PATH,
+            sameRoot: true,
+        });
+        expect(adoption.source).toBe("none");
+        expect(adoption.profile).toEqual({});
+    });
+});
+// ─── mergeOrthogonalFields ───
+describe("mergeOrthogonalFields", () => {
+    it("last-wins for scalars (project over home)", () => {
+        const merged = mergeOrthogonalFields({ output_language: "en", review_mode: "core-axis" }, { output_language: "ko" });
+        expect(merged.output_language).toBe("ko");
+        expect(merged.review_mode).toBe("core-axis");
+    });
+    it("union-merges excluded_names", () => {
+        const merged = mergeOrthogonalFields({ excluded_names: ["node_modules", ".git"] }, { excluded_names: [".git", "dist"] });
+        expect(merged.excluded_names).toEqual(expect.arrayContaining(["node_modules", ".git", "dist"]));
+        expect(merged.excluded_names?.length).toBe(3);
+    });
+    it("drops profile fields entirely", () => {
+        const merged = mergeOrthogonalFields({ codex: { model: "gpt-5.4" }, output_language: "ko" }, { anthropic: { model: "claude-haiku-4-5" }, review_mode: "full" });
+        expect(merged.codex).toBeUndefined();
+        expect(merged.anthropic).toBeUndefined();
+        expect(merged.output_language).toBe("ko");
+        expect(merged.review_mode).toBe("full");
+    });
+    it("passes review block through as orthogonal", () => {
+        const merged = mergeOrthogonalFields({ review: { subagent: { provider: "codex", model_id: "gpt-5.4" } } }, { review: { subagent: { provider: "main-native" } } });
+        // Last-wins: project overrides home.
+        expect(merged.review).toEqual({ subagent: { provider: "main-native" } });
+    });
+});
+// ─── Regression: migrated Review UX Redesign config ───
+describe("regression — migrated Review UX Redesign config", () => {
+    it("project declares review block + codex block → project owns", () => {
+        const adoption = adoptProfile(buildArgs({}, // empty global
+        {
+            review: {
+                subagent: { provider: "codex", model_id: "gpt-5.4", effort: "medium" },
+            },
+            codex: { model: "gpt-5.4", effort: "medium" },
+            review_mode: "core-axis",
+        }));
+        expect(adoption.source).toBe("project");
+        expect(adoption.profile.codex).toEqual({ model: "gpt-5.4", effort: "medium" });
+    });
+});

package/dist/core-runtime/discovery/host-detection.js

@@ -0,0 +1,33 @@
+import fsSync from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const CODEX_ENV_SIGNALS = ["CODEX_THREAD_ID", "CODEX_CI"];
+/** True when the current process is running under a Codex-owned session. */
+export function detectCodexEnvSignal() {
+    for (const name of CODEX_ENV_SIGNALS) {
+        if (process.env[name])
+            return true;
+    }
+    return false;
+}
+/**
+ * True when the Codex worker path can be used from this process.
+ *
+ * Both the executable and an auth file are required. This keeps OAuth review
+ * execution fail-loud when the host-bound worker is unavailable.
+ */
+export function detectCodexBinaryAvailable() {
+    const pathEnv = process.env.PATH ?? "";
+    let codexOnPath = false;
+    for (const dir of pathEnv.split(path.delimiter)) {
+        if (!dir)
+            continue;
+        if (fsSync.existsSync(path.join(dir, "codex"))) {
+            codexOnPath = true;
+            break;
+        }
+    }
+    if (!codexOnPath)
+        return false;
+    return fsSync.existsSync(path.join(os.homedir(), ".codex", "auth.json"));
+}

package/dist/core-runtime/discovery/host-detection.test.js

@@ -0,0 +1,186 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { detectHostRuntime, detectHostRuntimeCategory, detectHostCapabilities, detectClaudeCodeEnvSignal, detectCodexEnvSignal, isClaudeCodeHost, isCodexHost, ENV_ONTO_HOST_RUNTIME, } from "./host-detection.js";
+const HOST_ENV_VARS = [
+    ENV_ONTO_HOST_RUNTIME,
+    "CLAUDECODE",
+    "CLAUDE_PROJECT_DIR",
+    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
+    "CODEX_THREAD_ID",
+    "CODEX_CI",
+    "ANTHROPIC_API_KEY",
+    "OPENAI_API_KEY",
+    "LITELLM_BASE_URL",
+];
+let savedEnv = {};
+function savePotentiallyConflictingEnv() {
+    savedEnv = {};
+    for (const key of HOST_ENV_VARS) {
+        savedEnv[key] = process.env[key];
+        delete process.env[key];
+    }
+    // Make PATH effectively empty so codex binary detection cannot
+    // accidentally trigger on the test runner's shell PATH.
+    savedEnv.PATH = process.env.PATH;
+    process.env.PATH = "";
+}
+function restoreEnv() {
+    for (const [key, value] of Object.entries(savedEnv)) {
+        if (value === undefined) {
+            delete process.env[key];
+        }
+        else {
+            process.env[key] = value;
+        }
+    }
+}
+beforeEach(() => {
+    savePotentiallyConflictingEnv();
+});
+afterEach(() => {
+    restoreEnv();
+});
+describe("detectHostRuntime — priority order", () => {
+    it("Priority 1: ONTO_HOST_RUNTIME env override wins over all signals", () => {
+        process.env[ENV_ONTO_HOST_RUNTIME] = "standalone";
+        process.env.CLAUDECODE = "1";
+        process.env.CODEX_THREAD_ID = "abc";
+        const result = detectHostRuntime({ host_runtime: "claude" });
+        expect(result.hostRuntime).toBe("standalone");
+        expect(result.detectionSource).toBe("env_override");
+    });
+    it("Priority 2: config.host_runtime wins over env signals (no env override)", () => {
+        process.env.CLAUDECODE = "1";
+        process.env.CODEX_THREAD_ID = "abc";
+        const result = detectHostRuntime({ host_runtime: "codex" });
+        expect(result.hostRuntime).toBe("codex");
+        expect(result.detectionSource).toBe("config_override");
+    });
+    it("Priority 3: Claude env signal → claude when no override", () => {
+        process.env.CLAUDECODE = "1";
+        const result = detectHostRuntime({});
+        expect(result.hostRuntime).toBe("claude");
+        expect(result.detectionSource).toBe("claude_env_signal");
+    });
+    it("Priority 4: Codex env signal → codex when no Claude signal", () => {
+        process.env.CODEX_THREAD_ID = "thread-123";
+        const result = detectHostRuntime({});
+        expect(result.hostRuntime).toBe("codex");
+        expect(result.detectionSource).toBe("codex_env_signal");
+    });
+    it("Priority 6: standalone default when no signals", () => {
+        const result = detectHostRuntime({});
+        expect(result.hostRuntime).toBe("standalone");
+        expect(result.detectionSource).toBe("standalone_default");
+    });
+    it("ONTO_HOST_RUNTIME accepts case-insensitive values", () => {
+        process.env[ENV_ONTO_HOST_RUNTIME] = "  CLAUDE  ";
+        const result = detectHostRuntime({});
+        expect(result.hostRuntime).toBe("claude");
+        expect(result.detectionSource).toBe("env_override");
+    });
+    it("ONTO_HOST_RUNTIME with invalid value is ignored, falls through to next priority", () => {
+        process.env[ENV_ONTO_HOST_RUNTIME] = "invalid_host";
+        process.env.CLAUDECODE = "1";
+        const result = detectHostRuntime({});
+        expect(result.hostRuntime).toBe("claude");
+        expect(result.detectionSource).toBe("claude_env_signal");
+    });
+});
+describe("detectHostRuntime — Claude env signal variants", () => {
+    it("CLAUDECODE alone triggers claude", () => {
+        process.env.CLAUDECODE = "1";
+        expect(detectHostRuntimeCategory({})).toBe("claude");
+    });
+    it("CLAUDE_PROJECT_DIR alone triggers claude", () => {
+        process.env.CLAUDE_PROJECT_DIR = "/some/project";
+        expect(detectHostRuntimeCategory({})).toBe("claude");
+    });
+    it("CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS alone triggers claude", () => {
+        process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS = "1";
+        expect(detectHostRuntimeCategory({})).toBe("claude");
+    });
+    it("Claude takes priority over codex when both env signals present", () => {
+        process.env.CLAUDECODE = "1";
+        process.env.CODEX_THREAD_ID = "thread-x";
+        expect(detectHostRuntimeCategory({})).toBe("claude");
+    });
+});
+describe("detectHostCapabilities — capability matrix", () => {
+    it("claude host: hasTeamCreate + hasAgentSpawn = true", () => {
+        const caps = detectHostCapabilities("claude");
+        expect(caps.hasTeamCreate).toBe(true);
+        expect(caps.hasAgentSpawn).toBe(true);
+    });
+    it("codex host: hasTeamCreate + hasAgentSpawn = false", () => {
+        const caps = detectHostCapabilities("codex");
+        expect(caps.hasTeamCreate).toBe(false);
+        expect(caps.hasAgentSpawn).toBe(false);
+    });
+    it("standalone host: hasTeamCreate + hasAgentSpawn = false", () => {
+        const caps = detectHostCapabilities("standalone");
+        expect(caps.hasTeamCreate).toBe(false);
+        expect(caps.hasAgentSpawn).toBe(false);
+    });
+    it("LLM provider capabilities are environmental, independent of host", () => {
+        process.env.ANTHROPIC_API_KEY = "sk-ant-test";
+        process.env.LITELLM_BASE_URL = "http://localhost:4000/v1";
+        const claudeCaps = detectHostCapabilities("claude");
+        const standaloneCaps = detectHostCapabilities("standalone");
+        expect(claudeCaps.hasAnthropicApiKey).toBe(true);
+        expect(claudeCaps.hasLiteLlmEndpoint).toBe(true);
+        expect(standaloneCaps.hasAnthropicApiKey).toBe(true);
+        expect(standaloneCaps.hasLiteLlmEndpoint).toBe(true);
+    });
+    it("Cross-host LLM combo: Claude main + LiteLLM subagent (capability indicates feasible)", () => {
+        process.env.CLAUDECODE = "1";
+        process.env.LITELLM_BASE_URL = "http://localhost:4000/v1";
+        const result = detectHostRuntime({});
+        expect(result.hostRuntime).toBe("claude");
+        expect(result.capabilities.hasTeamCreate).toBe(true); // main can orchestrate
+        expect(result.capabilities.hasLiteLlmEndpoint).toBe(true); // subagent can use LiteLLM
+    });
+});
+describe("Low-level signal detectors", () => {
+    it("detectClaudeCodeEnvSignal: returns false when no Claude env vars", () => {
+        expect(detectClaudeCodeEnvSignal()).toBe(false);
+    });
+    it("detectClaudeCodeEnvSignal: returns true on any of the 3 signals", () => {
+        process.env.CLAUDECODE = "1";
+        expect(detectClaudeCodeEnvSignal()).toBe(true);
+        delete process.env.CLAUDECODE;
+        process.env.CLAUDE_PROJECT_DIR = "/x";
+        expect(detectClaudeCodeEnvSignal()).toBe(true);
+    });
+    it("detectCodexEnvSignal: returns false when no codex env", () => {
+        expect(detectCodexEnvSignal()).toBe(false);
+    });
+    it("detectCodexEnvSignal: returns true on CODEX_THREAD_ID", () => {
+        process.env.CODEX_THREAD_ID = "x";
+        expect(detectCodexEnvSignal()).toBe(true);
+    });
+    it("detectCodexEnvSignal: returns true on CODEX_CI", () => {
+        process.env.CODEX_CI = "1";
+        expect(detectCodexEnvSignal()).toBe(true);
+    });
+});
+describe("Backward-compat shims", () => {
+    it("isClaudeCodeHost returns true when CLAUDECODE is set", () => {
+        process.env.CLAUDECODE = "1";
+        expect(isClaudeCodeHost({})).toBe(true);
+    });
+    it("isClaudeCodeHost returns false in standalone mode", () => {
+        expect(isClaudeCodeHost({})).toBe(false);
+    });
+    it("isCodexHost returns true when CODEX_THREAD_ID is set", () => {
+        process.env.CODEX_THREAD_ID = "x";
+        expect(isCodexHost({})).toBe(true);
+    });
+    it("isCodexHost returns false in standalone mode", () => {
+        expect(isCodexHost({})).toBe(false);
+    });
+    it("env override beats env signal in shim", () => {
+        process.env[ENV_ONTO_HOST_RUNTIME] = "standalone";
+        process.env.CLAUDECODE = "1";
+        expect(isClaudeCodeHost({})).toBe(false);
+    });
+});

package/dist/core-runtime/discovery/installation-paths.js

@@ -0,0 +1,21 @@
+import fs from "node:fs";
+import path from "node:path";
+const NEW_LAYOUT_ROOT = ".onto";
+const cache = new Map();
+export function resolveInstallationPath(kind, installRoot) {
+    const cacheKey = `${installRoot}::${kind}`;
+    const cached = cache.get(cacheKey);
+    if (cached !== undefined)
+        return cached;
+    const canonicalPath = path.join(installRoot, NEW_LAYOUT_ROOT, kind);
+    if (fs.existsSync(canonicalPath)) {
+        cache.set(cacheKey, canonicalPath);
+        return canonicalPath;
+    }
+    throw new Error(`[installation-paths] .onto/${kind}/ not found under ${installRoot}. ` +
+        `Installation resources must live under the .onto/ layout.`);
+}
+/** Test helper — clears the cache so tests can swap fixture installations. */
+export function __resetInstallationPathCacheForTesting() {
+    cache.clear();
+}