onto-mcp 0.3.0

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

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

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

@@ -0,0 +1,167 @@
+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();
+    });
+});