onto-mcp 0.3.2 → 0.4.0

package/dist/core-runtime/scope-runtime/domain-validation-log.js

@@ -1,135 +0,0 @@
-/**
- * domain-validation-log.ts — Domain knowledge 추정 적중률 계측 seat
- *
- * W-A-73: DL-017 기제 seat (reconstruct).
- * reconstruct(build) 활동에서 발생하는 domain assumption 의
- * validated/invalidated 비율을 기록·산출한다.
- *
- * 측정 대상 (§1.4 측면 3):
- *   - certainty 분류: observed / pending / rationale-absent / inferred / ambiguous / not-in-source
- *   - 적중률: inferred 분류 중 후속 검증에서 validated 된 비율
- *   - 가정 분포: Stage 1/Stage 2 분류 비율
- *
- * reconstruct 활동이 아직 완전 구현되지 않았으므로(W-A-74 pending),
- * 본 모듈은 데이터 모델과 수집·산출 함수의 **seat** 을 제공한다.
- * 실제 reconstruct 파이프라인 연동은 W-A-74 에서 수행.
- *
- * 소비자: W-A-74 (reconstruct-cli), onto:health (W-A-59), refresh protocol (§4)
- */
-// ─── Core API ───
-/**
- * DomainAssumptionRecord 목록에서 도메인별 적중률 metric 을 산출한다.
- */
-export function computeValidationMetrics(records) {
-    if (records.length === 0) {
-        return {
-            collected_at: new Date().toISOString(),
-            total_records: 0,
-            per_domain: [],
-            overall_accuracy_ratio: null,
-        };
-    }
-    // 도메인별 그룹화
-    const groups = new Map();
-    for (const r of records) {
-        const group = groups.get(r.domain) ?? [];
-        group.push(r);
-        groups.set(r.domain, group);
-    }
-    const perDomain = [];
-    let totalValidated = 0;
-    let totalInvalidated = 0;
-    let totalRevised = 0;
-    for (const [domain, group] of groups) {
-        const metric = computeDomainMetric(domain, group);
-        perDomain.push(metric);
-        totalValidated += metric.inferred_validated;
-        totalInvalidated += metric.inferred_invalidated;
-        totalRevised += metric.inferred_revised;
-    }
-    perDomain.sort((a, b) => a.domain.localeCompare(b.domain));
-    const resolved = totalValidated + totalInvalidated + totalRevised;
-    const overallAccuracy = resolved > 0
-        ? Math.round((totalValidated / resolved) * 1000) / 1000
-        : null;
-    return {
-        collected_at: new Date().toISOString(),
-        total_records: records.length,
-        per_domain: perDomain,
-        overall_accuracy_ratio: overallAccuracy,
-    };
-}
-function computeDomainMetric(domain, records) {
-    const stage1 = { observed: 0, pending: 0 };
-    const stage2 = { rationale_absent: 0, inferred: 0, ambiguous: 0, not_in_source: 0 };
-    let inferredValidated = 0;
-    let inferredInvalidated = 0;
-    let inferredRevised = 0;
-    let inferredPending = 0;
-    for (const r of records) {
-        // Stage 1
-        stage1[r.stage1_certainty]++;
-        // Stage 2
-        if (r.stage2_certainty) {
-            const key = r.stage2_certainty.replace("-", "_");
-            if (key in stage2)
-                stage2[key]++;
-        }
-        // inferred 검증 추적
-        if (r.stage2_certainty === "inferred") {
-            switch (r.validation_status) {
-                case "validated":
-                    inferredValidated++;
-                    break;
-                case "invalidated":
-                    inferredInvalidated++;
-                    break;
-                case "revised":
-                    inferredRevised++;
-                    break;
-                case "pending":
-                    inferredPending++;
-                    break;
-            }
-        }
-    }
-    const resolved = inferredValidated + inferredInvalidated + inferredRevised;
-    const accuracy = resolved > 0
-        ? Math.round((inferredValidated / resolved) * 1000) / 1000
-        : null;
-    return {
-        domain,
-        total_assumptions: records.length,
-        stage1_distribution: stage1,
-        stage2_distribution: stage2,
-        inferred_validated: inferredValidated,
-        inferred_invalidated: inferredInvalidated,
-        inferred_revised: inferredRevised,
-        inferred_pending: inferredPending,
-        accuracy_ratio: accuracy,
-    };
-}
-/**
- * DomainAssumptionRecord 를 생성하는 팩터리.
- * reconstruct 파이프라인(W-A-74)에서 가정 발견 시 호출.
- */
-export function createAssumptionRecord(params) {
-    return {
-        ...params,
-        validation_status: "pending",
-        validated_at: null,
-        validation_evidence: null,
-    };
-}
-/**
- * 기존 record 에 검증 결과를 기록한다.
- * Phase 3 (주체자 확인) 에서 호출.
- */
-export function markValidation(record, status, evidence) {
-    return {
-        ...record,
-        validation_status: status,
-        validated_at: new Date().toISOString(),
-        validation_evidence: evidence,
-    };
-}

package/dist/core-runtime/scope-runtime/domain-validation-log.test.js

@@ -1,156 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { computeValidationMetrics, createAssumptionRecord, markValidation, } from "./domain-validation-log.js";
-// ─── Test helpers ───
-function makeRecord(overrides = {}) {
-    return {
-        assumption_id: "a-001",
-        session_id: "20260414-test",
-        domain: "SE",
-        stage1_certainty: "pending",
-        stage2_certainty: "inferred",
-        description: "test assumption",
-        abduction_quality: { explanatory_power: "high", coherence: "consistent" },
-        validation_status: "pending",
-        validated_at: null,
-        validation_evidence: null,
-        ...overrides,
-    };
-}
-// ─── Tests ───
-describe("domain-validation-log", () => {
-    describe("computeValidationMetrics", () => {
-        it("빈 records 에서 null accuracy 를 반환한다", () => {
-            const result = computeValidationMetrics([]);
-            expect(result.total_records).toBe(0);
-            expect(result.per_domain).toHaveLength(0);
-            expect(result.overall_accuracy_ratio).toBeNull();
-        });
-        it("단일 도메인의 stage1/stage2 분포를 산출한다", () => {
-            const records = [
-                makeRecord({ assumption_id: "a-001", stage1_certainty: "observed", stage2_certainty: null }),
-                makeRecord({ assumption_id: "a-002", stage1_certainty: "pending", stage2_certainty: "inferred" }),
-                makeRecord({ assumption_id: "a-003", stage1_certainty: "pending", stage2_certainty: "rationale-absent" }),
-                makeRecord({ assumption_id: "a-004", stage1_certainty: "pending", stage2_certainty: "ambiguous" }),
-            ];
-            const result = computeValidationMetrics(records);
-            expect(result.per_domain).toHaveLength(1);
-            const se = result.per_domain[0];
-            expect(se.domain).toBe("SE");
-            expect(se.stage1_distribution.observed).toBe(1);
-            expect(se.stage1_distribution.pending).toBe(3);
-            expect(se.stage2_distribution.inferred).toBe(1);
-            expect(se.stage2_distribution.rationale_absent).toBe(1);
-            expect(se.stage2_distribution.ambiguous).toBe(1);
-        });
-        it("inferred 검증 결과 별 카운트를 정확히 산출한다", () => {
-            const records = [
-                makeRecord({ assumption_id: "a-001", validation_status: "validated" }),
-                makeRecord({ assumption_id: "a-002", validation_status: "validated" }),
-                makeRecord({ assumption_id: "a-003", validation_status: "invalidated" }),
-                makeRecord({ assumption_id: "a-004", validation_status: "pending" }),
-            ];
-            const result = computeValidationMetrics(records);
-            const se = result.per_domain[0];
-            expect(se.inferred_validated).toBe(2);
-            expect(se.inferred_invalidated).toBe(1);
-            expect(se.inferred_pending).toBe(1);
-        });
-        it("적중률을 정확히 계산한다 (validated / resolved)", () => {
-            const records = [
-                makeRecord({ assumption_id: "a-001", validation_status: "validated" }),
-                makeRecord({ assumption_id: "a-002", validation_status: "validated" }),
-                makeRecord({ assumption_id: "a-003", validation_status: "invalidated" }),
-                makeRecord({ assumption_id: "a-004", validation_status: "revised" }),
-            ];
-            const result = computeValidationMetrics(records);
-            // 2 validated / (2 + 1 + 1) = 0.5
-            expect(result.per_domain[0].accuracy_ratio).toBe(0.5);
-            expect(result.overall_accuracy_ratio).toBe(0.5);
-        });
-        it("검증 완료 건이 없으면 accuracy null 을 반환한다", () => {
-            const records = [
-                makeRecord({ assumption_id: "a-001", validation_status: "pending" }),
-                makeRecord({ assumption_id: "a-002", validation_status: "pending" }),
-            ];
-            const result = computeValidationMetrics(records);
-            expect(result.per_domain[0].accuracy_ratio).toBeNull();
-            expect(result.overall_accuracy_ratio).toBeNull();
-        });
-        it("여러 도메인을 별도 그룹으로 산출한다", () => {
-            const records = [
-                makeRecord({ assumption_id: "a-001", domain: "SE", validation_status: "validated" }),
-                makeRecord({ assumption_id: "a-002", domain: "SE", validation_status: "invalidated" }),
-                makeRecord({ assumption_id: "a-003", domain: "Business", validation_status: "validated" }),
-            ];
-            const result = computeValidationMetrics(records);
-            expect(result.per_domain).toHaveLength(2);
-            expect(result.total_records).toBe(3);
-            const business = result.per_domain.find((d) => d.domain === "Business");
-            expect(business.accuracy_ratio).toBe(1.0);
-            const se = result.per_domain.find((d) => d.domain === "SE");
-            expect(se.accuracy_ratio).toBe(0.5);
-        });
-        it("overall_accuracy_ratio 는 전체 도메인 합산 기준이다", () => {
-            const records = [
-                makeRecord({ assumption_id: "a-001", domain: "SE", validation_status: "validated" }),
-                makeRecord({ assumption_id: "a-002", domain: "SE", validation_status: "invalidated" }),
-                makeRecord({ assumption_id: "a-003", domain: "Business", validation_status: "validated" }),
-                makeRecord({ assumption_id: "a-004", domain: "Business", validation_status: "validated" }),
-            ];
-            const result = computeValidationMetrics(records);
-            // 3 validated / (3 + 1) = 0.75
-            expect(result.overall_accuracy_ratio).toBe(0.75);
-        });
-        it("non-inferred 항목은 적중률 계산에서 제외된다", () => {
-            const records = [
-                makeRecord({ assumption_id: "a-001", stage2_certainty: "inferred", validation_status: "validated" }),
-                makeRecord({ assumption_id: "a-002", stage2_certainty: "rationale-absent", validation_status: "validated" }),
-                makeRecord({ assumption_id: "a-003", stage2_certainty: "ambiguous", validation_status: "validated" }),
-            ];
-            const result = computeValidationMetrics(records);
-            const se = result.per_domain[0];
-            // inferred 1건만 validated → accuracy 1.0
-            expect(se.inferred_validated).toBe(1);
-            expect(se.accuracy_ratio).toBe(1.0);
-        });
-        it("도메인을 알파벳순 정렬한다", () => {
-            const records = [
-                makeRecord({ assumption_id: "a-001", domain: "Zebra" }),
-                makeRecord({ assumption_id: "a-002", domain: "Alpha" }),
-            ];
-            const result = computeValidationMetrics(records);
-            expect(result.per_domain[0].domain).toBe("Alpha");
-            expect(result.per_domain[1].domain).toBe("Zebra");
-        });
-    });
-    describe("createAssumptionRecord", () => {
-        it("validation_status=pending 으로 초기화한다", () => {
-            const record = createAssumptionRecord({
-                assumption_id: "a-new",
-                session_id: "20260414-new",
-                domain: "SE",
-                stage1_certainty: "pending",
-                stage2_certainty: "inferred",
-                description: "new assumption",
-                abduction_quality: { explanatory_power: "medium", coherence: "consistent" },
-            });
-            expect(record.validation_status).toBe("pending");
-            expect(record.validated_at).toBeNull();
-            expect(record.validation_evidence).toBeNull();
-        });
-    });
-    describe("markValidation", () => {
-        it("검증 결과를 기록한다", () => {
-            const record = makeRecord({ assumption_id: "a-001" });
-            const validated = markValidation(record, "validated", "confirmed by user");
-            expect(validated.validation_status).toBe("validated");
-            expect(validated.validated_at).toBeTruthy();
-            expect(validated.validation_evidence).toBe("confirmed by user");
-        });
-        it("원본을 변경하지 않는다 (immutable)", () => {
-            const record = makeRecord({ assumption_id: "a-001" });
-            markValidation(record, "invalidated", "wrong assumption");
-            expect(record.validation_status).toBe("pending");
-        });
-    });
-});

package/dist/core-runtime/scope-runtime/eval-persistence.js

@@ -1,65 +0,0 @@
-/**
- * eval-persistence — 산출물 재사용 횟수·비율 측정 (W-C-04, §1.4 측면 2 지속성).
- *
- * 지속성 = LLM 모델 교체 전후 eval 통과율 회귀 0.
- * 본 모듈은 산출물 (review record, learning, ontology) 이 **재사용** 되는 이벤트를 기록하고,
- * 재사용 횟수·비율을 산출하는 계측 seat.
- *
- * 저장: .onto/eval/persistence-log.ndjson (product-local, append-only event log)
- *
- * 이벤트 타입:
- *   - artifact_reuse: 기존 산출물이 새 session 에서 소비됨 (예: learning load, ontology reference)
- *
- * 소비자:
- *   - §1.4 지속성 metric dashboard (향후)
- *   - W-C-05 consumption feedback 와 보완 관계 (W-C-05 = learning 소비 baseline, W-C-04 = 산출물 전반 재사용)
- */
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-export function resolveEvalPath(projectRoot) {
-    return join(projectRoot, ".onto", "eval", "persistence-log.ndjson");
-}
-export function logArtifactReuse(projectRoot, event, now = new Date()) {
-    const logPath = resolveEvalPath(projectRoot);
-    const dir = dirname(logPath);
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    const full = {
-        type: "artifact_reuse",
-        ...event,
-        reused_at: now.toISOString(),
-    };
-    appendFileSync(logPath, JSON.stringify(full) + "\n", "utf-8");
-}
-export function readReuseEvents(projectRoot) {
-    const logPath = resolveEvalPath(projectRoot);
-    if (!existsSync(logPath))
-        return [];
-    const raw = readFileSync(logPath, "utf-8");
-    const events = [];
-    for (const line of raw.split("\n")) {
-        if (!line.trim())
-            continue;
-        try {
-            const parsed = JSON.parse(line);
-            if (parsed?.type === "artifact_reuse")
-                events.push(parsed);
-        }
-        catch { /* skip malformed */ }
-    }
-    return events;
-}
-export function computePersistenceMetrics(events) {
-    const byKind = {};
-    const uniqueRefs = new Set();
-    for (const ev of events) {
-        byKind[ev.artifact_kind] = (byKind[ev.artifact_kind] ?? 0) + 1;
-        uniqueRefs.add(`${ev.artifact_kind}:${ev.artifact_ref}`);
-    }
-    return {
-        total_reuse_events: events.length,
-        by_kind: byKind,
-        unique_artifacts: uniqueRefs.size,
-        reuse_ratio: uniqueRefs.size > 0 ? events.length / uniqueRefs.size : 0,
-    };
-}

package/dist/core-runtime/scope-runtime/eval-persistence.test.js

@@ -1,84 +0,0 @@
-/**
- * eval-persistence unit tests (W-C-04).
- */
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { computePersistenceMetrics, logArtifactReuse, readReuseEvents, resolveEvalPath, } from "./eval-persistence.js";
-describe("eval-persistence", () => {
-    let tmpRoot;
-    beforeEach(() => {
-        tmpRoot = mkdtempSync(join(tmpdir(), "onto-eval-persist-"));
-    });
-    afterEach(() => rmSync(tmpRoot, { recursive: true, force: true }));
-    it("logArtifactReuse appends ndjson event", () => {
-        logArtifactReuse(tmpRoot, {
-            artifact_kind: "learning",
-            artifact_ref: "~/.onto/learnings/logic.md:42",
-            consumer_session: "20260416-review-001",
-            consumer_activity: "review",
-        });
-        const raw = readFileSync(resolveEvalPath(tmpRoot), "utf-8");
-        const event = JSON.parse(raw.trim());
-        expect(event.type).toBe("artifact_reuse");
-        expect(event.artifact_kind).toBe("learning");
-        expect(event.artifact_ref).toBe("~/.onto/learnings/logic.md:42");
-        expect(event.consumer_activity).toBe("review");
-        expect(event.reused_at).toBeDefined();
-    });
-    it("multiple events appended as separate lines", () => {
-        logArtifactReuse(tmpRoot, {
-            artifact_kind: "learning",
-            artifact_ref: "logic.md:1",
-            consumer_session: "s1",
-            consumer_activity: "review",
-        });
-        logArtifactReuse(tmpRoot, {
-            artifact_kind: "ontology",
-            artifact_ref: "builds/001/output.yaml",
-            consumer_session: "s2",
-            consumer_activity: "evolve",
-        });
-        const events = readReuseEvents(tmpRoot);
-        expect(events.length).toBe(2);
-        expect(events[0].artifact_kind).toBe("learning");
-        expect(events[1].artifact_kind).toBe("ontology");
-    });
-    it("readReuseEvents returns empty for nonexistent file", () => {
-        expect(readReuseEvents(tmpRoot)).toEqual([]);
-    });
-    it("computePersistenceMetrics calculates correctly", () => {
-        logArtifactReuse(tmpRoot, {
-            artifact_kind: "learning",
-            artifact_ref: "logic.md:1",
-            consumer_session: "s1",
-            consumer_activity: "review",
-        });
-        logArtifactReuse(tmpRoot, {
-            artifact_kind: "learning",
-            artifact_ref: "logic.md:1",
-            consumer_session: "s2",
-            consumer_activity: "evolve",
-        });
-        logArtifactReuse(tmpRoot, {
-            artifact_kind: "review_record",
-            artifact_ref: "record-001.yaml",
-            consumer_session: "s3",
-            consumer_activity: "learn",
-        });
-        const events = readReuseEvents(tmpRoot);
-        const metrics = computePersistenceMetrics(events);
-        expect(metrics.total_reuse_events).toBe(3);
-        expect(metrics.by_kind.learning).toBe(2);
-        expect(metrics.by_kind.review_record).toBe(1);
-        expect(metrics.unique_artifacts).toBe(2);
-        expect(metrics.reuse_ratio).toBe(1.5);
-    });
-    it("computePersistenceMetrics handles empty events", () => {
-        const metrics = computePersistenceMetrics([]);
-        expect(metrics.total_reuse_events).toBe(0);
-        expect(metrics.unique_artifacts).toBe(0);
-        expect(metrics.reuse_ratio).toBe(0);
-    });
-});

package/dist/core-runtime/scope-runtime/event-pipeline.js

@@ -1,64 +0,0 @@
-import { writeFileSync } from "node:fs";
-import { readEvents, appendEvent } from "./event-store.js";
-import { reduce } from "./reducer.js";
-import { validateEvent } from "./gate-guard.js";
-import { makeId } from "./id.js";
-// ─── Main pipeline ───
-/**
- * Append an event to a scope through the full pipeline:
- * 1. Read current events → reduce to current state
- * 2. Validate the new event (gate-guard)
- * 3. Generate envelope (event_id, scope_id, ts, revision, state_before, state_after)
- * 4. Append to event store
- * 5. Re-reduce → write kernel materialized views (constraint-pool.json, verdict-log.json)
- *
- * Returns the updated ScopeState so the caller can render scope.md
- * or other view-layer outputs without kernel depending on renderers.
- *
- * This is the ONLY path for recording events. No other code should
- * call event-store.appendEvent directly.
- */
-export function appendScopeEvent(paths, input, gateOptions) {
-    // ── Step 1: Current state ──
-    const currentEvents = readEvents(paths.events);
-    const currentState = reduce(currentEvents);
-    // ── Step 2: Build temporary event for validation ──
-    const revision = currentEvents.length + 1;
-    const tempEvent = {
-        event_id: makeId("evt_", revision),
-        scope_id: paths.scopeId,
-        type: input.type,
-        ts: new Date().toISOString(),
-        revision,
-        actor: input.actor,
-        state_before: input.type === "scope.created" ? null : currentState.current_state,
-        state_after: "draft", // placeholder, gate-guard determines actual value
-        payload: input.payload,
-    };
-    // ── Step 3: Validate ──
-    const gate = validateEvent(currentState, tempEvent, gateOptions);
-    if (!gate.allowed) {
-        return {
-            success: false,
-            reason: gate.reason,
-            current_state: currentState.current_state,
-            rejected_type: input.type,
-        };
-    }
-    // ── Step 4: Set final state_after and append ──
-    const eventToAppend = {
-        ...tempEvent,
-        state_after: gate.next_state,
-    };
-    appendEvent(paths.events, eventToAppend);
-    // ── Step 5: Incremental reduce (reuse currentEvents instead of re-reading) ──
-    const updatedState = reduce([...currentEvents, eventToAppend]);
-    writeFileSync(paths.constraintPool, JSON.stringify(updatedState.constraint_pool, null, 2) + "\n", "utf-8");
-    writeFileSync(paths.verdictLog, JSON.stringify(updatedState.verdict_log, null, 2) + "\n", "utf-8");
-    return {
-        success: true,
-        event: eventToAppend,
-        next_state: gate.next_state,
-        state: updatedState,
-    };
-}