onto-mcp 0.3.2 → 0.4.1

package/dist/core-runtime/evolve/commands/e2e-evolve-full-cycle.test.js

@@ -1,208 +0,0 @@
-/**
- * Evolve full cycle E2E test (W-B-01).
- *
- * scope-runtime kernel 위에서 evolve 활동의 전체 lifecycle 을 검증한다:
- *   draft → grounded → align_proposed → align_locked → surface_iterating →
- *   surface_confirmed → constraints_resolved → target_locked → compiled →
- *   applied → validated → closed
- *
- * 초기 scope 생성(grounding)은 appendScopeEvent 로 직접 설정하고,
- * align 이후는 실제 command 함수(executeAlign/executeDraft/executeApply/executeClose)를 사용.
- */
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { createScope } from "../../scope-runtime/scope-manager.js";
-import { appendScopeEvent } from "../../scope-runtime/event-pipeline.js";
-import { readEvents } from "../../scope-runtime/event-store.js";
-import { reduce } from "../../scope-runtime/reducer.js";
-import { executeAlign } from "./align.js";
-import { executeDraft } from "./draft.js";
-import { executeApply } from "./apply.js";
-import { executeClose } from "./close.js";
-let tmpDir;
-beforeEach(() => { tmpDir = mkdtempSync(join(tmpdir(), "e2e-evolve-")); });
-afterEach(() => { rmSync(tmpDir, { recursive: true, force: true }); });
-describe("evolve full cycle E2E", () => {
-    it("draft → closed: 전체 lifecycle 을 command 함수로 통과한다", () => {
-        // ── Phase 0: Scope 생성 + Grounding ──
-        writeFileSync(join(tmpDir, ".sprint-kit.yaml"), "apply_enabled: true\ndefault_sources: []\n", "utf-8");
-        const paths = createScope(tmpDir, "E2E-FULL-001");
-        appendScopeEvent(paths, {
-            type: "scope.created",
-            actor: "user",
-            payload: { title: "E2E Full Cycle", description: "evolve full cycle test", entry_mode: "experience" },
-        });
-        appendScopeEvent(paths, {
-            type: "grounding.started",
-            actor: "system",
-            payload: { sources: [{ type: "add-dir", path_or_url: "/test-project" }] },
-        });
-        appendScopeEvent(paths, {
-            type: "grounding.completed",
-            actor: "system",
-            payload: { snapshot_revision: 1, source_hashes: { "add-dir:/test-project": "h1" }, perspective_summary: { experience: 1, code: 1, policy: 1 } },
-        });
-        appendScopeEvent(paths, {
-            type: "align.proposed",
-            actor: "system",
-            payload: { packet_path: "build/align-packet.md", packet_hash: "ap1", snapshot_revision: 1 },
-        });
-        let state = reduce(readEvents(paths.events));
-        expect(state.current_state).toBe("align_proposed");
-        // ── Phase 1: Align (executeAlign) ──
-        const alignResult = executeAlign({
-            paths,
-            verdict: {
-                type: "approve",
-                direction: "사용자 온보딩 흐름 개선",
-                scope_in: ["login", "signup"],
-                scope_out: ["admin"],
-            },
-        });
-        expect(alignResult.success).toBe(true);
-        if (!alignResult.success)
-            return;
-        expect(alignResult.nextState).toBe("align_locked");
-        state = reduce(readEvents(paths.events));
-        expect(state.current_state).toBe("align_locked");
-        // ── Phase 2: Draft — Surface 생성 (executeDraft) ──
-        const genResult = executeDraft({
-            paths,
-            action: { type: "generate_surface", surfacePath: "surface/preview/", surfaceHash: "sf1", snapshotRevision: 1 },
-        });
-        expect(genResult.success).toBe(true);
-        if (!genResult.success)
-            return;
-        expect(genResult.nextState).toBe("surface_iterating");
-        // ── Phase 2b: Surface 확인 ──
-        const confirmResult = executeDraft({
-            paths,
-            action: { type: "confirm_surface", surfacePath: "surface/preview/", surfaceHash: "sf1" },
-        });
-        expect(confirmResult.success).toBe(true);
-        if (!confirmResult.success)
-            return;
-        expect(confirmResult.nextState).toBe("surface_confirmed");
-        // ── Phase 2c: Constraint 발견 + 결정 ──
-        const constraintResult = executeDraft({
-            paths,
-            action: {
-                type: "record_constraint",
-                constraintPayload: {
-                    constraint_id: "CST-E2E-001",
-                    perspective: "code",
-                    summary: "기존 인증 모듈과 호환성 필요",
-                    severity: "required",
-                    discovery_stage: "draft_phase2",
-                    decision_owner: "product_owner",
-                    impact_if_ignored: "로그인 기능 장애",
-                    source_refs: [{ source: "auth.ts", detail: "OAuth 의존성" }],
-                },
-            },
-        });
-        expect(constraintResult.success).toBe(true);
-        const decisionResult = executeDraft({
-            paths,
-            action: {
-                type: "record_decision",
-                decisionPayload: {
-                    constraint_id: "CST-E2E-001",
-                    decision: "inject",
-                    selected_option: "호환 래퍼 추가",
-                    decision_owner: "product_owner",
-                    rationale: "기존 모듈 변경 최소화",
-                },
-            },
-        });
-        expect(decisionResult.success).toBe(true);
-        state = reduce(readEvents(paths.events));
-        expect(state.current_state).toBe("constraints_resolved");
-        // ── Phase 2d: Target 잠금 ──
-        const lockResult = executeDraft({
-            paths,
-            action: { type: "lock_target" },
-        });
-        expect(lockResult.success).toBe(true);
-        if (!lockResult.success)
-            return;
-        expect(lockResult.nextState).toBe("target_locked");
-        // ── Phase 2e: Compile ──
-        // compile 은 code-product adapter 를 호출하므로, compile.started/completed 를 직접 기록
-        appendScopeEvent(paths, {
-            type: "compile.started",
-            actor: "system",
-            payload: { snapshot_revision: 1, surface_hash: "sf1" },
-        });
-        appendScopeEvent(paths, {
-            type: "compile.completed",
-            actor: "system",
-            payload: {
-                build_spec_path: "build/build-spec.md", build_spec_hash: "bs1",
-                brownfield_detail_path: "build/brownfield-detail.md", brownfield_detail_hash: "bf1",
-                delta_set_path: "build/delta-set.json", delta_set_hash: "ds1",
-                validation_plan_path: "build/validation-plan.md", validation_plan_hash: "vp1",
-            },
-        });
-        state = reduce(readEvents(paths.events));
-        expect(state.current_state).toBe("compiled");
-        // ── Phase 3: Apply (executeApply) ──
-        // pre-apply + PRD review gate 통과
-        appendScopeEvent(paths, { type: "pre_apply.review_completed", actor: "agent", payload: { verdict: "pass", findings: [] } });
-        appendScopeEvent(paths, { type: "prd.review_completed", actor: "agent", payload: { verdict: "pass", perspectives: ["prd_logic"], findings: [] } });
-        const applyStartResult = executeApply(paths, { type: "start_apply", buildSpecHash: "bs1" }, { projectRoot: tmpDir });
-        expect(applyStartResult.success).toBe(true);
-        const applyCompleteResult = executeApply(paths, { type: "complete_apply", result: "success" });
-        expect(applyCompleteResult.success).toBe(true);
-        if (!applyCompleteResult.success)
-            return;
-        expect(applyCompleteResult.nextState).toBe("applied");
-        // ── Phase 4: Validation (executeApply) ──
-        const valStartResult = executeApply(paths, { type: "start_validation", validationPlanHash: "vp1" });
-        expect(valStartResult.success).toBe(true);
-        const valCompleteResult = executeApply(paths, {
-            type: "complete_validation",
-            plan: [{
-                    val_id: "VAL-001",
-                    related_cst: "CST-E2E-001",
-                    decision_type: "inject",
-                    target: "auth.ts",
-                    method: "수동 테스트",
-                    pass_criteria: "온보딩 흐름 정상 동작",
-                    fail_action: "호환 래퍼 재구현",
-                }],
-            results: [{ val_id: "VAL-001", related_cst: "CST-E2E-001", result: "pass", detail: "수동 테스트 통과" }],
-            actualPlanHash: "vp1",
-        });
-        expect(valCompleteResult.success).toBe(true);
-        if (!valCompleteResult.success)
-            return;
-        expect(valCompleteResult.nextState).toBe("validated");
-        state = reduce(readEvents(paths.events));
-        expect(state.current_state).toBe("validated");
-        // ── Phase 5: Close (executeClose) ──
-        const closeResult = executeClose(paths);
-        expect(closeResult.success).toBe(true);
-        if (!closeResult.success)
-            return;
-        expect(closeResult.nextState).toBe("closed");
-        // ── Final verification ──
-        state = reduce(readEvents(paths.events));
-        expect(state.current_state).toBe("closed");
-        const events = readEvents(paths.events);
-        expect(events.length).toBeGreaterThanOrEqual(18);
-        // 핵심 상태 전이가 모두 기록되었는지 확인
-        const eventTypes = events.map(e => e.type);
-        expect(eventTypes).toContain("scope.created");
-        expect(eventTypes).toContain("grounding.completed");
-        expect(eventTypes).toContain("align.locked");
-        expect(eventTypes).toContain("surface.confirmed");
-        expect(eventTypes).toContain("constraint.decision_recorded");
-        expect(eventTypes).toContain("target.locked");
-        expect(eventTypes).toContain("compile.completed");
-        expect(eventTypes).toContain("apply.completed");
-        expect(eventTypes).toContain("validation.completed");
-        expect(eventTypes).toContain("scope.closed");
-    });
-});

package/dist/core-runtime/evolve/commands/error-messages.js

@@ -1,125 +0,0 @@
-/**
- * Gate-guard error wrapping — Principal-facing Korean messages.
- *
- * W-B-08 (BL-044): 기존 문자열 매칭 switch 를 .onto/authority/diagnostic-codes.yaml
- * 기반 code registry 로 전환. 매칭 우선순위는 registry entry 순서를 따른다.
- *
- * Registry seat: .onto/authority/diagnostic-codes.yaml (authority-adjacent data seat).
- * Concept SSOT 아님 — citation check 대상 아님.
- *
- * 보증:
- * - Registry load 시 schema validation (code 유일성 + 최소 1 matcher + matcher 형식).
- *   violation 발견 시 load 실패 → fail-fast.
- * - lookupDiagnosticCode 미매칭 시 console.warn — silent fail 방지.
- *   (영문 reason 원문이 Principal 에 노출되는 UX 버그를 즉시 감지 가능.)
- */
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-import { parse as yamlParse } from "yaml";
-import { resolveInstallationPath } from "../../discovery/installation-paths.js";
-// ─── Registry load ───
-let cachedRegistry = null;
-function resolveRegistryPath() {
-    // dist / src 양쪽에서 작동:
-    //   src: src/core-runtime/evolve/commands/error-messages.ts
-    //   dist: dist/core-runtime/evolve/commands/error-messages.js
-    // 양쪽 모두 4 단계 위가 repo root. Authority dir 선택은 Phase 0
-    // 공유 resolver 에 위임 — canonical `.onto/authority/` 에서 resolve.
-    // Phase 7 (2026-04-21) 에서 legacy fallback 제거됨.
-    const here = dirname(fileURLToPath(import.meta.url));
-    const repoRoot = join(here, "..", "..", "..", "..");
-    const authorityDir = resolveInstallationPath("authority", repoRoot);
-    return join(authorityDir, "diagnostic-codes.yaml");
-}
-function loadRegistry() {
-    if (cachedRegistry !== null)
-        return cachedRegistry;
-    const raw = readFileSync(resolveRegistryPath(), "utf-8");
-    const parsed = yamlParse(raw);
-    if (!parsed || !Array.isArray(parsed.diagnostic_codes)) {
-        throw new Error("[diagnostic-codes] invalid registry — diagnostic_codes 배열 없음");
-    }
-    validateRegistry(parsed);
-    cachedRegistry = parsed;
-    return parsed;
-}
-/**
- * Registry schema 검증 — code 유일성 + matcher 형식.
- * loadRegistry 내부에서 호출되며, 테스트 용도로도 export.
- */
-export function validateRegistry(registry) {
-    const seenCodes = new Set();
-    for (const entry of registry.diagnostic_codes) {
-        if (seenCodes.has(entry.code)) {
-            throw new Error(`[diagnostic-codes] duplicate code "${entry.code}" — code는 registry 내에서 유일해야 합니다.`);
-        }
-        seenCodes.add(entry.code);
-        if (!Array.isArray(entry.matchers) || entry.matchers.length === 0) {
-            throw new Error(`[diagnostic-codes] entry "${entry.code}" has no matchers — 최소 1개 matcher가 필요합니다.`);
-        }
-        for (let i = 0; i < entry.matchers.length; i++) {
-            const m = entry.matchers[i];
-            const hasIncludes = typeof m.includes === "string" && m.includes.length > 0;
-            const hasIncludesAll = Array.isArray(m.includes_all) && m.includes_all.length > 0;
-            if (!hasIncludes && !hasIncludesAll) {
-                throw new Error(`[diagnostic-codes] entry "${entry.code}" matcher[${i}] — includes 또는 includes_all 중 하나를 비어있지 않은 값으로 지정해야 합니다.`);
-            }
-        }
-    }
-}
-/** 테스트용 registry 초기화 */
-export function __resetDiagnosticRegistryCache() {
-    cachedRegistry = null;
-}
-/** 테스트용 registry 주입 */
-export function __setDiagnosticRegistryForTesting(registry) {
-    cachedRegistry = registry;
-}
-// ─── Matching ───
-function matcherMatches(m, reason) {
-    if (m.includes !== undefined) {
-        return reason.includes(m.includes);
-    }
-    if (Array.isArray(m.includes_all) && m.includes_all.length > 0) {
-        return m.includes_all.every((s) => reason.includes(s));
-    }
-    return false;
-}
-function entryMatches(entry, reason) {
-    return entry.matchers.some((m) => matcherMatches(m, reason));
-}
-/**
- * reason 문자열에 매칭되는 diagnostic entry 를 반환한다.
- * 매칭 없으면 null.
- */
-export function lookupDiagnosticCode(reason) {
-    const registry = loadRegistry();
-    for (const entry of registry.diagnostic_codes) {
-        if (entryMatches(entry, reason)) {
-            const message = entry.passthrough ? reason : (entry.message_ko ?? reason);
-            return {
-                code: entry.code,
-                category: entry.category,
-                message,
-                passthrough: entry.passthrough === true,
-            };
-        }
-    }
-    // Silent failure 방지 — 매칭되지 않은 reason 은 영문 원문이 Principal 에 노출된다.
-    // 개발자용 경고를 남겨 registry entry 누락 또는 reason 문구 drift 를 즉시 감지 가능하게.
-    console.warn(`[diagnostic-codes] no matching entry for reason: "${reason}". Registry에 새 entry 추가 또는 기존 matcher 보강이 필요합니다.`);
-    return null;
-}
-/**
- * gate-guard English reason → Principal-facing 한국어 메시지 변환.
- * 매칭 없으면 reason 원문을 그대로 반환.
- */
-export function wrapGateError(reason) {
-    const hit = lookupDiagnosticCode(reason);
-    return hit ? hit.message : reason;
-}
-/** 등록된 모든 diagnostic code 의 snapshot (telemetry / 문서화용) */
-export function listDiagnosticCodes() {
-    return [...loadRegistry().diagnostic_codes];
-}

package/dist/core-runtime/evolve/commands/error-messages.test.js

@@ -1,167 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { wrapGateError, lookupDiagnosticCode, listDiagnosticCodes, validateRegistry, __resetDiagnosticRegistryCache, } from "./error-messages.js";
-beforeEach(() => {
-    __resetDiagnosticRegistryCache();
-});
-describe("wrapGateError — backward-compatible behavior (기존 7 tests)", () => {
-    it("wraps Transition denied → Korean message", () => {
-        const reason = 'Transition denied: "draft" does not allow "align.locked"';
-        expect(wrapGateError(reason)).toBe("현재 단계에서 이 작업을 수행할 수 없습니다.");
-    });
-    it("wraps Referential integrity → Korean message", () => {
-        const reason = 'Referential integrity: constraint_id "CST-999" not found in pool';
-        expect(wrapGateError(reason)).toBe("내부 참조 오류가 발생했습니다. 에이전트가 이벤트를 재확인해야 합니다.");
-    });
-    it("wraps Required constraint + rationale → Korean message", () => {
-        const reason = 'Required constraint "CST-001" with override decision requires non-empty rationale';
-        expect(wrapGateError(reason)).toBe("필수 제약 사항을 무시하려면 이유를 반드시 입력해야 합니다.");
-    });
-    it("wraps Convergence blocked → Korean message", () => {
-        const reason = 'Convergence blocked: cannot "align.revised" until convergence.action_taken is recorded';
-        expect(wrapGateError(reason)).toBe("수렴 차단 상태입니다. 방향 변경, scope 축소, 또는 보류 중 하나를 선택하세요.");
-    });
-    it("wraps Compile retry limit → Korean message", () => {
-        const reason = "Compile retry limit exceeded (3 gap_found cycles). Consider scope.deferred or redirect.to_align.";
-        expect(wrapGateError(reason)).toBe("compile 재시도 한도(3회)를 초과했습니다. scope를 보류하거나 방향을 재검토하세요.");
-    });
-    it("passes through Target lock messages (already Korean)", () => {
-        const reason = "Target lock 불가: 미결정 2건. 모든 constraint 결정이 완료되어야 합니다.";
-        expect(wrapGateError(reason)).toBe(reason);
-    });
-    it("passes through unknown error messages unchanged and warns developer", () => {
-        const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
-        const reason = "Some unknown error occurred";
-        expect(wrapGateError(reason)).toBe(reason);
-        expect(warnSpy).toHaveBeenCalledTimes(1);
-        expect(warnSpy.mock.calls[0]?.[0]).toContain("no matching entry");
-        expect(warnSpy.mock.calls[0]?.[0]).toContain(reason);
-        warnSpy.mockRestore();
-    });
-});
-describe("wrapGateError — 신규 coverage (기존 migrate 된 분기)", () => {
-    it("wraps cannot be invalidated → Korean message", () => {
-        const reason = "CST-007 is required and cannot be invalidated by system alone";
-        expect(wrapGateError(reason)).toBe("필수 제약 사항은 시스템이 단독으로 무효화할 수 없습니다. 주체자의 확인이 필요합니다.");
-    });
-    it("wraps Compile 실패: → Korean message (Korean pattern)", () => {
-        const reason = "Compile 실패: state mismatch at step 2";
-        expect(wrapGateError(reason)).toBe("구현 명세 생성에 실패했습니다. 에이전트가 구현 계획을 수정한 뒤 재시도합니다.");
-    });
-    it("wraps Compile Defense failed → Korean message (OR branch of same code)", () => {
-        const reason = "Compile Defense failed: shortcut not covered";
-        expect(wrapGateError(reason)).toBe("구현 명세 생성에 실패했습니다. 에이전트가 구현 계획을 수정한 뒤 재시도합니다.");
-    });
-    it("wraps 'must be X state' → Korean message (AND match via includes_all)", () => {
-        const reason = "scope must be in align_locked state before draft.surface.generated";
-        expect(wrapGateError(reason)).toBe("현재 단계에서 이 작업을 수행할 수 없습니다.");
-    });
-    it("wraps compile_ready is false → Korean message", () => {
-        const reason = "compile_ready is false: constraint decisions pending";
-        expect(wrapGateError(reason)).toBe("아직 구현 명세를 생성할 수 없습니다. 제약 사항 결정이 완료되지 않았거나 소스가 변경되었습니다.");
-    });
-    it("wraps validation_plan_hash mismatch → Korean message", () => {
-        const reason = "validation_plan_hash mismatch — recompute required";
-        expect(wrapGateError(reason)).toBe("검증 계획이 변경되었습니다. compile을 다시 실행해야 합니다.");
-    });
-    it("wraps no matching injectValidation → Korean message", () => {
-        const reason = "plan has no matching injectValidation for CST-003";
-        expect(wrapGateError(reason)).toBe("구현 계획에 누락된 검증 항목이 있습니다. 에이전트가 수정한 뒤 재시도합니다.");
-    });
-});
-describe("lookupDiagnosticCode — code 기반 routing", () => {
-    it("Transition denied → DIAG-STATE-TRANSITION-01 code + category", () => {
-        const hit = lookupDiagnosticCode('Transition denied: "draft" does not allow "x"');
-        expect(hit).not.toBeNull();
-        expect(hit.code).toBe("DIAG-STATE-TRANSITION-01");
-        expect(hit.category).toBe("state-transition");
-        expect(hit.passthrough).toBe(false);
-    });
-    it("Target lock → passthrough=true + 원문 message", () => {
-        const reason = "Target lock 불가: 예시";
-        const hit = lookupDiagnosticCode(reason);
-        expect(hit).not.toBeNull();
-        expect(hit.code).toBe("DIAG-TARGET-LOCK-01");
-        expect(hit.passthrough).toBe(true);
-        expect(hit.message).toBe(reason);
-    });
-    it("미매칭 reason → null (+ console.warn 발행)", () => {
-        const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
-        expect(lookupDiagnosticCode("totally unknown error")).toBeNull();
-        expect(warnSpy).toHaveBeenCalledTimes(1);
-        warnSpy.mockRestore();
-    });
-    it("우선순위: 가장 먼저 매칭되는 entry 가 이긴다 (registry 순서)", () => {
-        // "Transition denied" 가 먼저, "must be ... state" 가 나중이므로
-        // 둘 다 매칭될 수 있는 reason 에 대해 앞엣 것이 이겨야 한다.
-        const reason = 'Transition denied: scope must be in grounded state';
-        const hit = lookupDiagnosticCode(reason);
-        expect(hit.code).toBe("DIAG-STATE-TRANSITION-01");
-    });
-});
-describe("listDiagnosticCodes — registry 내용 노출", () => {
-    it("모든 등록된 code 를 반환", () => {
-        const codes = listDiagnosticCodes();
-        expect(codes.length).toBeGreaterThanOrEqual(12);
-        const codeIds = codes.map((c) => c.code);
-        expect(codeIds).toContain("DIAG-STATE-TRANSITION-01");
-        expect(codeIds).toContain("DIAG-TARGET-LOCK-01");
-        expect(codeIds).toContain("DIAG-VALIDATION-MISSING-01");
-    });
-    it("각 entry 는 code·matchers·category 필드를 가진다", () => {
-        const codes = listDiagnosticCodes();
-        for (const c of codes) {
-            expect(typeof c.code).toBe("string");
-            expect(Array.isArray(c.matchers)).toBe(true);
-            expect(c.matchers.length).toBeGreaterThan(0);
-            expect(typeof c.category).toBe("string");
-        }
-    });
-});
-describe("validateRegistry — schema check (fail-fast on malformed registry)", () => {
-    it("throws on duplicate code", () => {
-        expect(() => validateRegistry({
-            version: "test",
-            diagnostic_codes: [
-                { code: "DUP", matchers: [{ includes: "x" }], category: "test" },
-                { code: "DUP", matchers: [{ includes: "y" }], category: "test" },
-            ],
-        })).toThrow(/duplicate code.*DUP/);
-    });
-    it("throws when entry has no matchers", () => {
-        expect(() => validateRegistry({
-            version: "test",
-            diagnostic_codes: [
-                { code: "C1", matchers: [], category: "test" },
-            ],
-        })).toThrow(/no matchers/);
-    });
-    it("throws on matcher without includes / includes_all", () => {
-        expect(() => validateRegistry({
-            version: "test",
-            diagnostic_codes: [
-                { code: "C1", matchers: [{}], category: "test" },
-            ],
-        })).toThrow(/includes.*includes_all/);
-    });
-    it("throws on matcher with empty includes_all array", () => {
-        expect(() => validateRegistry({
-            version: "test",
-            diagnostic_codes: [
-                { code: "C1", matchers: [{ includes_all: [] }], category: "test" },
-            ],
-        })).toThrow(/includes.*includes_all/);
-    });
-    it("passes a well-formed registry without throwing", () => {
-        expect(() => validateRegistry({
-            version: "test",
-            diagnostic_codes: [
-                { code: "C1", matchers: [{ includes: "x" }], category: "test" },
-                { code: "C2", matchers: [{ includes_all: ["a", "b"] }], category: "test" },
-            ],
-        })).not.toThrow();
-    });
-    it("production registry (.onto/authority/diagnostic-codes.yaml) passes validation", () => {
-        // loadRegistry 내부에서 validateRegistry 호출 — listDiagnosticCodes 로 간접 트리거
-        expect(() => listDiagnosticCodes()).not.toThrow();
-    });
-});