onto-mcp 0.3.2 → 0.4.1

package/dist/core-runtime/evolve/adapters/methodology/perspectives/authority-consistency.js

@@ -1,298 +0,0 @@
-/**
- * Authority-Consistency Perspective.
- *
- * Checks whether a design document (or trajectory) maintains
- * consistency with the project's authority hierarchy.
- *
- * Failure modes this perspective detects:
- * 1. Self-contradiction: a section contradicts another section
- *    within the same document.
- * 2. Authority violation: a document overrides or conflicts with
- *    a higher-authority source without explicit justification.
- * 3. Ghost axis: a concept is declared removed/derived-only but
- *    operative prose still treats it as an independent field.
- */
-/**
- * Analyze a design document for authority consistency.
- *
- * Current implementation: structural analysis only.
- * LLM-assisted deep analysis is a future extension.
- */
-export function checkAuthorityConsistency(input) {
-    const violations = [];
-    // Phase 1: detect ghost axes —
-    // sections that declare a concept removed/derived but still reference it operatively
-    for (const section of input.sections) {
-        const declaredRemoved = extractRemovedDeclarations(section.content);
-        for (const other of input.sections) {
-            if (other.id === section.id)
-                continue;
-            for (const removed of declaredRemoved) {
-                if (hasOperativeUsage(other.content, removed.term)) {
-                    violations.push({
-                        id: `GHOST-${removed.term}-${other.id}`,
-                        type: "ghost-axis",
-                        severity: "high",
-                        source_section: section.id,
-                        conflicting_section: other.id,
-                        summary: `"${removed.term}" is declared ${removed.declaration} in ${section.id} but used operatively in ${other.id}`,
-                        recommendation: `Remove operative usage of "${removed.term}" from ${other.id}, or revoke the declaration in ${section.id}`,
-                    });
-                }
-            }
-        }
-    }
-    // Phase 2: detect authority violations —
-    // sections that contradict rules from higher-authority sources
-    for (const section of input.sections) {
-        const negations = extractNegations(section.content);
-        for (const ref of input.authority_refs) {
-            for (const rule of ref.relevant_rules) {
-                for (const neg of negations) {
-                    if (negationContradictsRule(neg, rule)) {
-                        const vid = `AUTH-${section.id}-${ref.source}`;
-                        // Avoid duplicate ids for same section+source pair
-                        const exists = violations.some((v) => v.id === vid);
-                        if (!exists) {
-                            violations.push({
-                                id: vid,
-                                type: "authority-violation",
-                                severity: "high",
-                                source_section: section.id,
-                                conflicting_section: ref.source,
-                                summary: `${section.id} declares "${neg.statement}" which contradicts authority rule "${rule}" from ${ref.source} (rank ${ref.rank})`,
-                                recommendation: `Align ${section.id} with ${ref.source} or provide explicit justification for the override`,
-                            });
-                        }
-                    }
-                }
-            }
-        }
-    }
-    // Phase 3: detect self-contradictions —
-    // pairs of sections where one negates what the other affirms about the same topic
-    for (const sA of input.sections) {
-        const negationsA = extractNegations(sA.content);
-        for (const sB of input.sections) {
-            if (sA.id === sB.id)
-                continue;
-            // Only process each unordered pair once: skip if sB.id < sA.id
-            if (sB.id <= sA.id)
-                continue;
-            for (const neg of negationsA) {
-                if (hasAffirmation(sB.content, neg)) {
-                    const vid = `SELF-${sA.id}-${sB.id}-${neg.topic}`;
-                    const exists = violations.some((v) => v.id === vid);
-                    if (!exists) {
-                        violations.push({
-                            id: vid,
-                            type: "self-contradiction",
-                            severity: "medium",
-                            source_section: sA.id,
-                            conflicting_section: sB.id,
-                            summary: `${sA.id} negates "${neg.topic}" ("${neg.statement}") but ${sB.id} affirms it`,
-                            recommendation: `Reconcile the conflicting statements about "${neg.topic}" between ${sA.id} and ${sB.id}`,
-                        });
-                    }
-                }
-            }
-        }
-    }
-    const high = violations.filter((v) => v.severity === "high").length;
-    const medium = violations.filter((v) => v.severity === "medium").length;
-    const low = violations.filter((v) => v.severity === "low").length;
-    return {
-        violations,
-        summary: { total: violations.length, high, medium, low },
-        passed: high === 0,
-    };
-}
-const REMOVAL_PATTERNS = [
-    /(?:제거|삭제|deprecated|removed)\s*[:：]?\s*[`"]?(\w[\w_-]*)[`"]?/gi,
-    /[`"]?(\w[\w_-]*)[`"]?\s*(?:를|을|은|는)\s*(?:제거|삭제)/gi,
-    /[`"]?(\w[\w_-]*)[`"]?\s*(?:is|are)\s+(?:removed|deprecated|derived.only)/gi,
-    // Korean pattern: "X는 derive-only 축" / "X를 ... 취급하지 않는다"
-    /[`"]?(\w[\w_-]*)[`"]?\s*(?:는|은)\s*derive[- ]only/gi,
-    /[`"]?(\w[\w_-]*)[`"]?\s*(?:를|을)\s*(?:.*?)취급하지\s*않/gi,
-];
-function extractRemovedDeclarations(content) {
-    const results = [];
-    for (const pattern of REMOVAL_PATTERNS) {
-        const regex = new RegExp(pattern.source, pattern.flags);
-        let match;
-        while ((match = regex.exec(content)) !== null) {
-            if (match[1]) {
-                results.push({ term: match[1], declaration: "removed" });
-            }
-        }
-    }
-    return results;
-}
-function hasOperativeUsage(content, term) {
-    // Simple heuristic: the term appears outside of declaration/removal context
-    const termRegex = new RegExp(`\\b${escapeRegex(term)}\\b`, "gi");
-    const matches = content.match(termRegex);
-    if (!matches || matches.length === 0)
-        return false;
-    // Check if any occurrence is NOT in a removal/declaration context
-    const lines = content.split("\n");
-    for (const line of lines) {
-        if (!termRegex.test(line))
-            continue;
-        // Reset lastIndex
-        termRegex.lastIndex = 0;
-        // Skip lines that are themselves declarations of removal
-        const isDeclaration = REMOVAL_PATTERNS.some((p) => {
-            const r = new RegExp(p.source, p.flags);
-            return r.test(line);
-        });
-        if (!isDeclaration)
-            return true;
-    }
-    return false;
-}
-function escapeRegex(s) {
-    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-// ─── Authority-violation & Self-contradiction Helpers ───
-/** Strip common Korean postpositions/particles from a word. */
-function stripKoreanParticles(word) {
-    // Order matters: longer suffixes first
-    return word.replace(/(?:에서|으로|이며|에게|부터|까지|처럼|만큼|이라|라고|이고|하고|과는|와는|은|는|이|가|을|를|의|에|도|로|와|과|고)$/, "");
-}
-/** Strip Korean verb/adjective endings to extract stem. */
-function stripKoreanVerbEndings(word) {
-    return word.replace(/(?:하지|하는|한다|하고|하며|해야|합니다|합니|했다|해서|하여|된다|되지|않는다|않다)$/, "");
-}
-/**
- * Korean negation patterns:
- *   "X는/은 Y하지 않는다", "X를/을 Y하지 않는다"
- *   "X를/을 차단", "X를/을 금지"
- *
- * English negation patterns:
- *   "does not X", "must not X", "cannot X", "X is blocked/prohibited"
- */
-const NEGATION_PATTERNS = [
-    // Korean: "A은/는 B하지 않는다" — topic = A, action keywords = B
-    {
-        pattern: /([가-힣\w_-]+)(?:은|는)\s+([가-힣\w_-]+(?:을|를)?)\s*(?:저장하지|하지|작성하지|기록하지)\s*않/g,
-        topicGroup: 1,
-        keywordGroups: [1, 2],
-    },
-    // Korean: "A를/을 차단/금지"
-    {
-        pattern: /([가-힣\w_-]+)(?:를|을)\s*(?:차단|금지|거부)/g,
-        topicGroup: 1,
-        keywordGroups: [1],
-    },
-    // English: "does not / must not / cannot X"
-    {
-        pattern: /(\w[\w_-]*)\s+(?:does not|must not|cannot|shall not)\s+(\w[\w_-]*)/gi,
-        topicGroup: 1,
-        keywordGroups: [1, 2],
-    },
-];
-function extractNegations(content) {
-    const results = [];
-    const sentences = content.split(/[.。!\n]+/).filter((s) => s.trim());
-    for (const sentence of sentences) {
-        for (const { pattern, topicGroup, keywordGroups } of NEGATION_PATTERNS) {
-            const regex = new RegExp(pattern.source, pattern.flags);
-            let match;
-            while ((match = regex.exec(sentence)) !== null) {
-                const topic = match[topicGroup]?.trim();
-                if (!topic)
-                    continue;
-                const keywords = [];
-                for (const g of keywordGroups) {
-                    if (match[g]) {
-                        const raw = match[g].trim();
-                        keywords.push(raw);
-                        keywords.push(stripKoreanParticles(raw));
-                    }
-                }
-                // Also extract keywords from surrounding context (with particles and verb endings stripped)
-                const surroundingWords = sentence
-                    .replace(/[^가-힣a-zA-Z0-9_-]/g, " ")
-                    .split(/\s+/)
-                    .filter((w) => w.length > 1)
-                    .flatMap((w) => {
-                    const stripped = stripKoreanParticles(w);
-                    const stemmed = stripKoreanVerbEndings(w);
-                    const stemmedStripped = stripKoreanVerbEndings(stripped);
-                    return [w, stripped, stemmed, stemmedStripped];
-                });
-                results.push({
-                    topic,
-                    statement: sentence.trim(),
-                    keywords: [...new Set([...keywords, ...surroundingWords].filter((k) => k.length > 0))],
-                });
-            }
-        }
-    }
-    return results;
-}
-/**
- * Check if a negation contradicts an authority rule.
- * A contradiction occurs when the negation's topic/keywords overlap
- * significantly with the rule's content, and the rule is affirmative
- * (grants permission or defines capability) while the section denies it.
- */
-function negationContradictsRule(neg, rule) {
-    // Extract rule words (both raw and particle-stripped)
-    const rawRuleWords = rule
-        .replace(/[^가-힣a-zA-Z0-9_-]/g, " ")
-        .split(/\s+/)
-        .filter((w) => w.length > 1);
-    const ruleWords = [...new Set(rawRuleWords.flatMap((w) => [w, stripKoreanParticles(w)]).filter((w) => w.length > 0))];
-    // The rule must contain affirmative action keywords
-    const affirmativePatterns = [
-        /write/i, /저장/i, /생성/i, /기록/i, /자동/i, /권한/i, /정의/i,
-    ];
-    const ruleIsAffirmative = affirmativePatterns.some((p) => p.test(rule));
-    if (!ruleIsAffirmative)
-        return false;
-    // Count keyword overlap between negation keywords and rule words
-    const negKeySet = new Set(neg.keywords.map((k) => k.toLowerCase()));
-    let overlap = 0;
-    for (const rw of ruleWords) {
-        if (negKeySet.has(rw.toLowerCase())) {
-            overlap++;
-        }
-    }
-    // Also check if the topic itself appears in the rule (partial match),
-    // or if negation keywords intersect with the rule's core concepts
-    const strippedTopic = stripKoreanParticles(neg.topic).toLowerCase();
-    const topicInRule = rule.toLowerCase().includes(strippedTopic) ||
-        (strippedTopic.includes("learn") && /learn/i.test(rule)) ||
-        (strippedTopic.includes("학습") && /학습|learn|저장/i.test(rule));
-    // Require either topic match or significant keyword overlap
-    return topicInRule || overlap >= 2;
-}
-/**
- * Check if content affirms what a negation denies.
- * Used for self-contradiction detection between section pairs.
- */
-function hasAffirmation(content, neg) {
-    const topicEscaped = escapeRegex(neg.topic);
-    const topicRegex = new RegExp(topicEscaped, "gi");
-    if (!topicRegex.test(content))
-        return false;
-    // The content should use the topic in an affirmative/operative way
-    // (not in another negation)
-    const lines = content.split("\n");
-    for (const line of lines) {
-        const lineTopicRegex = new RegExp(topicEscaped, "gi");
-        if (!lineTopicRegex.test(line))
-            continue;
-        // Check this line is NOT itself a negation
-        const isNeg = /하지\s*않|차단|금지|does not|must not|cannot|shall not/i.test(line);
-        if (isNeg)
-            continue;
-        // Affirmative usage patterns
-        const affirmativeUsage = /실재|직접|참여|사용|결정|생성|저장|기록|적용|소비|pipeline|consumer|write|read|create|apply/i.test(line);
-        if (affirmativeUsage)
-            return true;
-    }
-    return false;
-}

package/dist/core-runtime/evolve/adapters/methodology/perspectives/authority-consistency.test.js

@@ -1,70 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { checkAuthorityConsistency, } from "./authority-consistency.js";
-// ─── Load v9.3 trajectory fixture ───
-const fixturePath = join(import.meta.dirname, "../__fixtures__/v9.3-trajectory.json");
-const fixture = JSON.parse(readFileSync(fixturePath, "utf-8"));
-describe("authority-consistency perspective", () => {
-    it("detects ghost-axis violation in v9.3 trajectory", () => {
-        const input = {
-            sections: fixture.sections,
-            authority_refs: fixture.authority_refs,
-        };
-        const result = checkAuthorityConsistency(input);
-        // The v9.3 trajectory has C-3: consumer_assigned declared derive-only in §6.3
-        // but used operatively in §8.0 and §8.5
-        const ghostViolations = result.violations.filter((v) => v.type === "ghost-axis");
-        expect(ghostViolations.length).toBeGreaterThanOrEqual(1);
-        // At least one ghost-axis should mention consumer_assigned
-        const consumerAssigned = ghostViolations.find((v) => v.summary.includes("consumer_assigned"));
-        expect(consumerAssigned).toBeDefined();
-        expect(consumerAssigned.source_section).toBe("§6.3");
-    });
-    it("returns passed=false when high-severity violations exist", () => {
-        const input = {
-            sections: fixture.sections,
-            authority_refs: fixture.authority_refs,
-        };
-        const result = checkAuthorityConsistency(input);
-        expect(result.passed).toBe(false);
-        expect(result.summary.high).toBeGreaterThanOrEqual(1);
-    });
-    it("detects authority-violation when section contradicts authority refs", () => {
-        const input = {
-            sections: fixture.sections,
-            authority_refs: fixture.authority_refs,
-        };
-        const result = checkAuthorityConsistency(input);
-        // §6.3 says "design은 학습을 저장하지 않는다" which contradicts
-        // authority refs that define learn write permissions (build.md, review.md)
-        const authViolations = result.violations.filter((v) => v.type === "authority-violation");
-        expect(authViolations.length).toBeGreaterThanOrEqual(1);
-        // At least one violation should originate from §6.3
-        const fromSection63 = authViolations.find((v) => v.source_section === "§6.3");
-        expect(fromSection63).toBeDefined();
-    });
-    it("detects self-contradiction between sections", () => {
-        const input = {
-            sections: fixture.sections,
-            authority_refs: fixture.authority_refs,
-        };
-        const result = checkAuthorityConsistency(input);
-        // §6.3 negates learn participation ("학습을 저장하지 않는다")
-        // but §8.0 affirms learn as a real consumer with direct participation
-        const selfContradictions = result.violations.filter((v) => v.type === "self-contradiction");
-        expect(selfContradictions.length).toBeGreaterThanOrEqual(1);
-    });
-    it("returns passed=true for clean document", () => {
-        const input = {
-            sections: [
-                { id: "§1", title: "Introduction", content: "This document defines the process." },
-                { id: "§2", title: "Rules", content: "Rule A applies. Rule B applies." },
-            ],
-            authority_refs: [],
-        };
-        const result = checkAuthorityConsistency(input);
-        expect(result.passed).toBe(true);
-        expect(result.violations).toHaveLength(0);
-    });
-});

package/dist/core-runtime/evolve/adapters/methodology/scope-types/process.js

@@ -1,46 +0,0 @@
-/**
- * Process Scope Type.
- *
- * Defines the "process" scope type for designing methodologies,
- * processes, and governance structures.
- *
- * A process scope differs from a code-product scope in:
- * 1. Grounding sources are authority documents, not code files.
- * 2. Surface is a process document (Markdown), not a UI mockup or API spec.
- * 3. Constraints come from authority consistency, not code architecture.
- * 4. Validation checks document coherence, not test execution.
- *
- * Perspectives are derived from the methodology adapter (adapter.ts = SSOT).
- * This eliminates UF-CONCISENESS-METADATA-DUPLICATION.
- */
-import { methodologyAdapter } from "../adapter.js";
-export const processScopeDefaults = {
-    /** Derived from adapter.ts — single source of truth for methodology capabilities. */
-    perspectives: methodologyAdapter.perspectives,
-    entry_mode: "experience",
-    surface_type: "markdown",
-};
-/**
- * Validate that a process scope configuration is well-formed.
- */
-export function validateProcessScopeConfig(config) {
-    const errors = [];
-    if (config.authority_sources.length === 0) {
-        errors.push("At least one authority source is required for a process scope");
-    }
-    if (!config.target_document) {
-        errors.push("target_document must be specified");
-    }
-    if (config.perspectives.length === 0) {
-        errors.push("At least one perspective is required");
-    }
-    // Authority sources at the same rank are allowed (e.g., onto authority
-    // hierarchy has rank 2 for both OaC and LLM-Native guidelines).
-    // Only validate that ranks are positive integers.
-    for (const source of config.authority_sources) {
-        if (!Number.isInteger(source.rank) || source.rank < 1) {
-            errors.push(`Authority source rank must be a positive integer: ${source.path} has rank ${source.rank}`);
-        }
-    }
-    return { valid: errors.length === 0, errors };
-}

package/dist/core-runtime/evolve/adapters/methodology/scope-types/process.test.js

@@ -1,73 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { validateProcessScopeConfig, processScopeDefaults, } from "./process.js";
-describe("process scope type", () => {
-    it("has correct defaults", () => {
-        expect(processScopeDefaults.perspectives).toContain("authority-consistency");
-        expect(processScopeDefaults.entry_mode).toBe("experience");
-        expect(processScopeDefaults.surface_type).toBe("markdown");
-    });
-    it("validates a well-formed config", () => {
-        const config = {
-            authority_sources: [
-                { path: ".onto/authority/core-lexicon.yaml", rank: 1, description: "Core concepts" },
-                { path: ".onto/principles/ontology-as-code-guideline.md", rank: 2, description: "OaC principles" },
-            ],
-            target_document: ".onto/processes/evolve.md",
-            perspectives: ["authority-consistency"],
-        };
-        const result = validateProcessScopeConfig(config);
-        expect(result.valid).toBe(true);
-        expect(result.errors).toHaveLength(0);
-    });
-    it("rejects config with no authority sources", () => {
-        const config = {
-            authority_sources: [],
-            target_document: ".onto/processes/evolve.md",
-            perspectives: ["authority-consistency"],
-        };
-        const result = validateProcessScopeConfig(config);
-        expect(result.valid).toBe(false);
-        expect(result.errors).toContain("At least one authority source is required for a process scope");
-    });
-    it("allows duplicate authority ranks (onto hierarchy has shared ranks)", () => {
-        const config = {
-            authority_sources: [
-                { path: ".onto/principles/oac.md", rank: 2, description: "OaC" },
-                { path: ".onto/principles/llm-native.md", rank: 2, description: "LLM-Native" },
-            ],
-            target_document: ".onto/processes/evolve.md",
-            perspectives: ["authority-consistency"],
-        };
-        const result = validateProcessScopeConfig(config);
-        expect(result.valid).toBe(true);
-    });
-    it("rejects config with non-positive authority rank", () => {
-        const config = {
-            authority_sources: [
-                { path: "a.md", rank: 0, description: "A" },
-            ],
-            target_document: ".onto/processes/evolve.md",
-            perspectives: ["authority-consistency"],
-        };
-        const result = validateProcessScopeConfig(config);
-        expect(result.valid).toBe(false);
-    });
-    it("rejects config with empty target_document", () => {
-        const config = {
-            authority_sources: [{ path: "a.md", rank: 1, description: "A" }],
-            target_document: "",
-            perspectives: ["authority-consistency"],
-        };
-        const result = validateProcessScopeConfig(config);
-        expect(result.valid).toBe(false);
-    });
-    it("rejects config with no perspectives", () => {
-        const config = {
-            authority_sources: [{ path: "a.md", rank: 1, description: "A" }],
-            target_document: ".onto/processes/evolve.md",
-            perspectives: [],
-        };
-        const result = validateProcessScopeConfig(config);
-        expect(result.valid).toBe(false);
-    });
-});

package/dist/core-runtime/evolve/adapters/registry.js

@@ -1,47 +0,0 @@
-/**
- * Adapter Registry — single dispatch table for design adapters.
- *
- * Each adapter handles a specific family of scope types. The registry
- * enables runtime selection of the correct adapter based on scope_kind,
- * resolving C2 (methodology adapter has no runtime dispatch).
- *
- * Adapters registered:
- * - code-product: experience/interface scopes for building software
- * - methodology: process scopes for designing processes and governance
- */
-import { methodologyAdapter } from "./methodology/adapter.js";
-// ─── Registry Data ───
-const codeProductEntry = {
-    id: "code-product",
-    name: "Code-Product Adapter",
-    scope_kinds: ["experience", "interface"],
-    perspectives: ["experience", "policy", "code"],
-    surface_types: ["mockup", "api-contract"],
-};
-const methodologyEntry = {
-    id: methodologyAdapter.name,
-    name: "Methodology Adapter",
-    scope_kinds: methodologyAdapter.scope_types,
-    perspectives: methodologyAdapter.perspectives,
-    surface_types: ["markdown"],
-};
-const REGISTRY = [
-    codeProductEntry,
-    methodologyEntry,
-];
-// ─── Public API ───
-/**
- * Look up the adapter that handles a given scope kind.
- *
- * @param scopeKind - e.g. "experience", "interface", "process"
- * @returns The matching adapter entry, or undefined if none matches.
- */
-export function getAdapter(scopeKind) {
-    return REGISTRY.find((entry) => entry.scope_kinds.includes(scopeKind));
-}
-/**
- * List all registered adapters for discovery / introspection.
- */
-export function listAdapters() {
-    return REGISTRY;
-}

package/dist/core-runtime/evolve/adapters/registry.test.js

@@ -1,67 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { getAdapter, listAdapters } from "./registry.js";
-import { methodologyAdapter } from "./methodology/adapter.js";
-describe("adapter registry", () => {
-    // ─── getAdapter ───
-    it("returns code-product for 'experience' scope", () => {
-        const entry = getAdapter("experience");
-        expect(entry).toBeDefined();
-        expect(entry.id).toBe("code-product");
-        expect(entry.scope_kinds).toContain("experience");
-    });
-    it("returns code-product for 'interface' scope", () => {
-        const entry = getAdapter("interface");
-        expect(entry).toBeDefined();
-        expect(entry.id).toBe("code-product");
-        expect(entry.scope_kinds).toContain("interface");
-    });
-    it("returns methodology for 'process' scope", () => {
-        const entry = getAdapter("process");
-        expect(entry).toBeDefined();
-        expect(entry.id).toBe("methodology");
-        expect(entry.scope_kinds).toContain("process");
-    });
-    it("returns undefined for unknown scope kind", () => {
-        const entry = getAdapter("unknown-kind");
-        expect(entry).toBeUndefined();
-    });
-    // ─── methodology adapter metadata consistency ───
-    it("methodology entry perspectives match adapter.ts SSOT", () => {
-        const entry = getAdapter("process");
-        expect(entry.perspectives).toEqual(methodologyAdapter.perspectives);
-    });
-    it("methodology entry scope_kinds match adapter.ts scope_types", () => {
-        const entry = getAdapter("process");
-        expect(entry.scope_kinds).toEqual(methodologyAdapter.scope_types);
-    });
-    // ─── listAdapters ───
-    it("lists exactly 2 adapters", () => {
-        const all = listAdapters();
-        expect(all).toHaveLength(2);
-    });
-    it("returned list is readonly (immutable reference)", () => {
-        const a = listAdapters();
-        const b = listAdapters();
-        expect(a).toBe(b); // same reference
-    });
-    it("every entry has required fields", () => {
-        for (const entry of listAdapters()) {
-            expect(entry.id).toBeTruthy();
-            expect(entry.name).toBeTruthy();
-            expect(entry.scope_kinds.length).toBeGreaterThan(0);
-            expect(entry.perspectives.length).toBeGreaterThan(0);
-            expect(entry.surface_types.length).toBeGreaterThan(0);
-        }
-    });
-    // ─── No scope_kind collision ───
-    it("no scope_kind is claimed by two adapters", () => {
-        const all = listAdapters();
-        const seen = new Map();
-        for (const entry of all) {
-            for (const kind of entry.scope_kinds) {
-                expect(seen.has(kind)).toBe(false);
-                seen.set(kind, entry.id);
-            }
-        }
-    });
-});