onto-mcp 0.3.2 → 0.4.0

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

@@ -1,199 +0,0 @@
-/**
- * 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

@@ -1,233 +0,0 @@
-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.test.js

@@ -1,186 +0,0 @@
-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.test.js

@@ -1,65 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { __resetInstallationPathCacheForTesting, resolveInstallationPath, } from "./installation-paths.js";
-function makeTempInstallRoot() {
-    return fs.mkdtempSync(path.join(os.tmpdir(), "onto-install-paths-"));
-}
-describe("resolveInstallationPath — canonical-only resolver (Phase 7)", () => {
-    const tmpRoots = [];
-    beforeEach(() => {
-        __resetInstallationPathCacheForTesting();
-    });
-    afterEach(() => {
-        __resetInstallationPathCacheForTesting();
-        for (const root of tmpRoots) {
-            try {
-                fs.rmSync(root, { recursive: true, force: true });
-            }
-            catch {
-                // ignore
-            }
-        }
-        tmpRoots.length = 0;
-    });
-    it("returns .onto/{kind}/ when the canonical layout exists", () => {
-        const installRoot = makeTempInstallRoot();
-        tmpRoots.push(installRoot);
-        const canonical = path.join(installRoot, ".onto", "authority");
-        fs.mkdirSync(canonical, { recursive: true });
-        expect(resolveInstallationPath("authority", installRoot)).toBe(canonical);
-    });
-    it("throws when the canonical layout is missing", () => {
-        const installRoot = makeTempInstallRoot();
-        tmpRoots.push(installRoot);
-        expect(() => resolveInstallationPath("commands", installRoot)).toThrow(/\.onto\/commands\/ not found/);
-    });
-    it("ignores a bare top-level dir that matches the kind name (pre-Phase-6 legacy layout)", () => {
-        // A project still on the pre-migration layout (e.g., legacy `authority/`
-        // at repo root) must NOT be recognized by this resolver in Phase 7+.
-        // Error message should nudge the operator toward the migration script.
-        const installRoot = makeTempInstallRoot();
-        tmpRoots.push(installRoot);
-        fs.mkdirSync(path.join(installRoot, "authority"), { recursive: true });
-        expect(() => resolveInstallationPath("authority", installRoot)).toThrow(/\.onto\/authority\/ not found/);
-        expect(() => resolveInstallationPath("authority", installRoot)).toThrow(/repo-layout-migration-replace\.py/);
-    });
-    it("caches resolved paths (same kind / installRoot returns identical string)", () => {
-        const installRoot = makeTempInstallRoot();
-        tmpRoots.push(installRoot);
-        fs.mkdirSync(path.join(installRoot, ".onto", "domains"), { recursive: true });
-        const first = resolveInstallationPath("domains", installRoot);
-        const second = resolveInstallationPath("domains", installRoot);
-        expect(first).toBe(second);
-    });
-    it("cache reset helper allows swapping fixtures across tests", () => {
-        const installRoot = makeTempInstallRoot();
-        tmpRoots.push(installRoot);
-        fs.mkdirSync(path.join(installRoot, ".onto", "roles"), { recursive: true });
-        resolveInstallationPath("roles", installRoot);
-        __resetInstallationPathCacheForTesting();
-        // Second resolve must succeed after a cache flush.
-        expect(resolveInstallationPath("roles", installRoot)).toBe(path.join(installRoot, ".onto", "roles"));
-    });
-});