onto-mcp 0.3.2 → 0.4.1

package/dist/core-runtime/readers/ontology-query.test.js

@@ -1,311 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { buildOntologyIndex } from "./ontology-index.js";
-import { queryOntology } from "./ontology-query.js";
-// ─── Fixtures ───
-const ONTOLOGY_YAML = `
-glossary:
-  - canonical: Lesson
-    meaning: "수업"
-    legacy_aliases: [Class, Lecture]
-    code_entity: Lecture
-    db_table: GT_CLASS
-    fk_variants: [classId, class_id, lectureId]
-  - canonical: Tutor
-    meaning: "튜터"
-    legacy_aliases: [Teacher]
-    code_entity: Tutor
-    db_table: GT_TUTOR
-    fk_variants: [tutorId, TUTOR_ID]
-  - canonical: Student
-    meaning: "학생"
-    legacy_aliases: [User]
-    code_entity: User
-    db_table: GT_USER
-    fk_variants: [studentId, userId]
-  - canonical: Ticket
-    meaning: "수강권"
-    legacy_aliases: [ClassTicket, 레슨권]
-    code_entity: Ticket
-    db_table: le_ticket
-    fk_variants: [classTicketId, ticketId]
-  - canonical: Subscribe
-    meaning: "구독"
-    legacy_aliases: [Subscription]
-    code_entity: Subscribe
-    db_table: le_subscribe
-    fk_variants: [subscribeId]
-`;
-const ACTIONS_YAML = `
-write_actions:
-  - id: AUTH-1
-    name: SocialLogin
-    display_name: "소셜 로그인"
-    domain: auth
-    actor: Student
-    target_entities: [Student, UserOauthMapping]
-    source_code: "AuthenticationGateway.oauthLogin()"
-  - id: LEC-1
-    name: CreateLecture
-    display_name: "수업 생성 (일반)"
-    domain: lecture
-    actor: Student
-    target_entities: [Lesson, LectureOnline]
-    source_code: "LectureCommandServiceImpl.createNewPodoLecture()"
-  - id: SCHEDULE-1
-    name: MatchTutor
-    display_name: "튜터 매칭"
-    domain: schedule
-    actor: Student
-    target_entities: [Lesson]
-    source_code: "PodoScheduleServiceImplV2.match()"
-  - id: TICKET-1
-    name: CreateTicket
-    display_name: "수강권 생성"
-    domain: ticket
-    actor: System
-    target_entities: [Ticket]
-    source_code: "TicketService.create()"
-read_actions:
-  - id: LEC-R1
-    name: GetLessonDetail
-    display_name: "수업 상세 조회"
-    domain: lecture
-    actor: Student
-    target_entities: [Lesson]
-    source_code: "LectureGateway.getLectureDetail()"
-`;
-const TRANSITIONS_YAML = `
-entities:
-  - name: Lesson
-    state_fields:
-      - field_name: invoice_status
-        transitions:
-          - id: L1
-            from: null
-            to: CREATED
-            trigger: "학생이 수업 생성"
-            source_code: "LectureCommandServiceImpl.createNewPodoLecture()"
-          - id: L2
-            from: CREATED
-            to: RESERVED
-            trigger: "학생이 시간 선택 + 튜터 매칭"
-            source_code: "PodoScheduleServiceImplV2.match()"
-          - id: L4
-            from: RESERVED
-            to: CANCEL
-            trigger: "학생이 수업 취소"
-            source_code: "PodoScheduleServiceImplV2.cancel()"
-  - name: Ticket
-    state_fields:
-      - field_name: status
-        transitions:
-          - id: T1
-            from: null
-            to: ACTIVE
-            trigger: "수강권 활성화"
-            source_code: "TicketService.activate()"
-          - id: T2
-            from: ACTIVE
-            to: EXPIRED
-            trigger: "수강권 만료"
-            source_code: "TicketBatchService.expire()"
-`;
-function buildFixtureIndex() {
-    return buildOntologyIndex(ONTOLOGY_YAML, ACTIONS_YAML, TRANSITIONS_YAML);
-}
-// ─── Tests ───
-describe("queryOntology", () => {
-    describe("키워드 매칭: 정확 매칭", () => {
-        it("canonical name으로 정확히 매칭한다", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["Lesson"]);
-            expect(result.matched_entities).toContain("Lesson");
-            expect(result.matched_entities).not.toContain("Tutor");
-        });
-        it("legacy alias로 매칭한다", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["Teacher"]);
-            expect(result.matched_entities).toContain("Tutor");
-        });
-    });
-    describe("키워드 매칭: 부분 매칭", () => {
-        it("canonical name의 부분 문자열로 매칭한다", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["less"]);
-            expect(result.matched_entities).toContain("Lesson");
-        });
-        it("legacy alias의 부분 문자열로 매칭한다", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["Teach"]);
-            expect(result.matched_entities).toContain("Tutor");
-        });
-        it("meaning 필드의 부분 문자열로 매칭한다", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["수업"]);
-            expect(result.matched_entities).toContain("Lesson");
-        });
-    });
-    describe("키워드 매칭: 대소문자 무시", () => {
-        it("소문자 키워드로 대문자 canonical name을 매칭한다", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["lesson"]);
-            expect(result.matched_entities).toContain("Lesson");
-        });
-        it("대문자 키워드로 소문자가 포함된 legacy alias를 매칭한다", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["TEACHER"]);
-            expect(result.matched_entities).toContain("Tutor");
-        });
-        it("혼합 대소문자 키워드로 매칭한다", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["lEsSON"]);
-            expect(result.matched_entities).toContain("Lesson");
-        });
-    });
-    describe("한국어 키워드 매칭 (meaning 필드)", () => {
-        it("한국어 meaning으로 매칭한다: 수업 → Lesson", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["수업"]);
-            expect(result.matched_entities).toContain("Lesson");
-            expect(result.db_tables).toContain("GT_CLASS");
-        });
-        it("한국어 meaning으로 매칭한다: 튜터 → Tutor", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["튜터"]);
-            expect(result.matched_entities).toContain("Tutor");
-            expect(result.db_tables).toContain("GT_TUTOR");
-        });
-        it("한국어 meaning으로 매칭한다: 수강권 → Ticket", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["수강권"]);
-            expect(result.matched_entities).toContain("Ticket");
-        });
-        it("한국어 meaning 부분 매칭: 수강 → Ticket (수강권)", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["수강"]);
-            expect(result.matched_entities).toContain("Ticket");
-        });
-        it("한국어 legacy alias로 매칭한다: 레슨권 → Ticket", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["레슨권"]);
-            expect(result.matched_entities).toContain("Ticket");
-        });
-    });
-    describe("관련 actions 수집", () => {
-        it("매칭된 entity를 target으로 가진 action을 수집한다", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["Lesson"]);
-            const actionIds = result.related_actions.map((a) => a.id);
-            expect(actionIds).toContain("LEC-1");
-            expect(actionIds).toContain("SCHEDULE-1");
-            expect(actionIds).toContain("LEC-R1");
-            // AUTH-1은 Student를 target으로 가지므로 포함되지 않아야 함
-            expect(actionIds).not.toContain("AUTH-1");
-        });
-        it("action summary에 display_name과 source_code가 포함된다", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["Lesson"]);
-            const lec1 = result.related_actions.find((a) => a.id === "LEC-1");
-            expect(lec1).toBeDefined();
-            expect(lec1.display_name).toBe("수업 생성 (일반)");
-            expect(lec1.source_code).toBe("LectureCommandServiceImpl.createNewPodoLecture()");
-        });
-    });
-    describe("관련 transitions 수집", () => {
-        it("매칭된 entity의 transition을 수집한다", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["Lesson"]);
-            expect(result.related_transitions.length).toBe(3);
-            const triggers = result.related_transitions.map((t) => t.trigger);
-            expect(triggers).toContain("학생이 수업 생성");
-            expect(triggers).toContain("학생이 시간 선택 + 튜터 매칭");
-            expect(triggers).toContain("학생이 수업 취소");
-        });
-        it("transition summary에 entity, from, to, trigger, source_code가 포함된다", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["Ticket"]);
-            expect(result.related_transitions.length).toBe(2);
-            const t1 = result.related_transitions[0];
-            expect(t1.entity).toBe("Ticket");
-            expect(t1.from).toBe("(none)");
-            expect(t1.to).toBe("ACTIVE");
-            expect(t1.source_code).toBe("TicketService.activate()");
-        });
-    });
-    describe("code_locations 수집", () => {
-        it("관련 action의 source_code에서 CodeLocation을 추출한다", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["Lesson"]);
-            expect(result.code_locations.length).toBeGreaterThan(0);
-            const refs = result.code_locations.map((cl) => cl.reference);
-            expect(refs).toContain("LectureCommandServiceImpl.createNewPodoLecture()");
-            expect(refs).toContain("PodoScheduleServiceImplV2.match()");
-        });
-        it("code_location의 context에 action id와 display_name이 포함된다", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["Lesson"]);
-            const lec1Location = result.code_locations.find((cl) => cl.reference === "LectureCommandServiceImpl.createNewPodoLecture()");
-            expect(lec1Location).toBeDefined();
-            expect(lec1Location.context).toBe("Action LEC-1: 수업 생성 (일반)");
-        });
-    });
-    describe("db_tables 수집", () => {
-        it("매칭된 entity의 db_table을 수집한다", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["Lesson"]);
-            expect(result.db_tables).toEqual(["GT_CLASS"]);
-        });
-        it("복수 entity 매칭 시 모든 db_table을 수집한다", () => {
-            const index = buildFixtureIndex();
-            // "수" 키워드는 "수업"(Lesson), "수강권"(Ticket) 모두 매칭
-            const result = queryOntology(index, ["Lesson", "Tutor"]);
-            expect(result.db_tables).toContain("GT_CLASS");
-            expect(result.db_tables).toContain("GT_TUTOR");
-        });
-    });
-    describe("복수 키워드", () => {
-        it("여러 키워드 중 하나라도 매칭되면 해당 entity를 포함한다", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["Lesson", "Tutor"]);
-            expect(result.matched_entities).toContain("Lesson");
-            expect(result.matched_entities).toContain("Tutor");
-        });
-        it("각 entity의 관련 action과 transition을 모두 수집한다", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["Lesson", "Ticket"]);
-            const actionIds = result.related_actions.map((a) => a.id);
-            expect(actionIds).toContain("LEC-1");
-            expect(actionIds).toContain("TICKET-1");
-            const entities = result.related_transitions.map((t) => t.entity);
-            expect(entities).toContain("Lesson");
-            expect(entities).toContain("Ticket");
-        });
-    });
-    describe("0건 매칭 → 빈 결과", () => {
-        it("매칭되는 entity가 없으면 모든 배열이 빈 상태이다", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, ["nonexistent"]);
-            expect(result.matched_entities).toEqual([]);
-            expect(result.code_locations).toEqual([]);
-            expect(result.db_tables).toEqual([]);
-            expect(result.related_actions).toEqual([]);
-            expect(result.related_transitions).toEqual([]);
-        });
-        it("빈 키워드 배열이면 빈 결과를 반환한다", () => {
-            const index = buildFixtureIndex();
-            const result = queryOntology(index, []);
-            expect(result.matched_entities).toEqual([]);
-            expect(result.code_locations).toEqual([]);
-            expect(result.db_tables).toEqual([]);
-            expect(result.related_actions).toEqual([]);
-            expect(result.related_transitions).toEqual([]);
-        });
-        it("빈 인덱스에 키워드를 전달하면 빈 결과를 반환한다", () => {
-            const index = buildOntologyIndex("", "", "");
-            const result = queryOntology(index, ["Lesson"]);
-            expect(result.matched_entities).toEqual([]);
-            expect(result.related_actions).toEqual([]);
-            expect(result.related_transitions).toEqual([]);
-        });
-    });
-});

package/dist/core-runtime/readers/ontology-resolve.js

@@ -1,48 +0,0 @@
-/**
- * source_code 문자열을 실제 파일 경로로 해석(resolve)한다.
- *
- * ActionEntry.source_code와 TransitionEntry.source_code는 자연어 문자열이다.
- * 예: "PodoScheduleServiceImplV2.match()"
- * 이 문자열에서 클래스명을 추출하고, ScanResult.files에서 해당 파일을 찾는다.
- */
-// ─── Resolve ───
-/**
- * CodeLocation 배열의 source_code 참조를 실제 파일 경로로 해석한다.
- *
- * 해석 방법:
- * 1. reference에서 클래스명 추출: "PodoScheduleServiceImplV2.match()" → "PodoScheduleServiceImplV2"
- * 2. files에서 해당 클래스명을 포함하는 파일 경로 검색
- * 3. 매칭 실패 시 resolution_method: "unresolved"
- */
-export function resolveCodeLocations(locations, files) {
-    return locations.map((loc) => {
-        const className = extractClassName(loc.reference);
-        if (!className) {
-            return { reference: loc.reference, resolved_files: [], resolution_method: "unresolved", entity: loc.entity || undefined };
-        }
-        const matched = files
-            .filter((f) => f.path.includes(className))
-            .map((f) => f.path);
-        return {
-            reference: loc.reference,
-            resolved_files: matched,
-            resolution_method: matched.length > 0 ? "filename" : "unresolved",
-            entity: loc.entity || undefined,
-        };
-    });
-}
-// ─── Helpers ───
-/**
- * source_code 문자열에서 클래스명을 추출한다.
- *
- * 예:
- * "PodoScheduleServiceImplV2.match()" → "PodoScheduleServiceImplV2"
- * "LectureCommandServiceImpl.createNewPodoLecture()" → "LectureCommandServiceImpl"
- * "AuthenticationGateway.oauthLogin(), OauthService.authenticate()" → "AuthenticationGateway"
- *   (첫 번째 클래스명만 추출 — 복수 참조는 호출자가 locations를 분리하여 전달)
- */
-function extractClassName(reference) {
-    // "ClassName.method()" 또는 "ClassName" 패턴
-    const match = reference.match(/^([A-Z][A-Za-z0-9]+)/);
-    return match ? match[1] : null;
-}

package/dist/core-runtime/readers/ontology-resolve.test.js

@@ -1,48 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { resolveCodeLocations } from "./ontology-resolve.js";
-const FILES = [
-    { path: "src/main/java/com/app/PodoScheduleServiceImplV2.java", category: "source", language: "java", size_bytes: 5000 },
-    { path: "src/main/java/com/app/LectureCommandServiceImpl.java", category: "source", language: "java", size_bytes: 3000 },
-    { path: "src/main/java/com/app/TrialLectureCommandServiceImpl.java", category: "source", language: "java", size_bytes: 2000 },
-    { path: "src/main/java/com/app/UserGateway.java", category: "source", language: "java", size_bytes: 4000 },
-    { path: "src/test/java/com/app/LectureCommandServiceTest.java", category: "test", language: "java", size_bytes: 1500 },
-];
-describe("resolveCodeLocations", () => {
-    it("클래스명이 파일 경로에 포함되면 매칭한다", () => {
-        const locations = [
-            { reference: "PodoScheduleServiceImplV2.match()", context: "Action", entity: "Lesson" },
-        ];
-        const result = resolveCodeLocations(locations, FILES);
-        expect(result).toHaveLength(1);
-        expect(result[0].resolved_files).toEqual(["src/main/java/com/app/PodoScheduleServiceImplV2.java"]);
-        expect(result[0].resolution_method).toBe("filename");
-    });
-    it("매칭 실패 시 unresolved를 반환한다", () => {
-        const locations = [
-            { reference: "NonExistentService.call()", context: "Action", entity: "Unknown" },
-        ];
-        const result = resolveCodeLocations(locations, FILES);
-        expect(result[0].resolved_files).toEqual([]);
-        expect(result[0].resolution_method).toBe("unresolved");
-    });
-    it("복수 파일이 매칭될 수 있다 (클래스명이 부분 매칭)", () => {
-        const locations = [
-            { reference: "LectureCommandServiceImpl.create()", context: "Action", entity: "Lesson" },
-        ];
-        const result = resolveCodeLocations(locations, FILES);
-        // LectureCommandServiceImpl과 TrialLectureCommandServiceImpl 모두 매칭
-        expect(result[0].resolved_files.length).toBeGreaterThanOrEqual(1);
-        expect(result[0].resolution_method).toBe("filename");
-    });
-    it("빈 locations 입력 시 빈 배열을 반환한다", () => {
-        const result = resolveCodeLocations([], FILES);
-        expect(result).toEqual([]);
-    });
-    it("reference에서 첫 번째 클래스명만 추출한다", () => {
-        const locations = [
-            { reference: "UserGateway.findUser(), OtherService.call()", context: "Action", entity: "User" },
-        ];
-        const result = resolveCodeLocations(locations, FILES);
-        expect(result[0].resolved_files).toContain("src/main/java/com/app/UserGateway.java");
-    });
-});

package/dist/core-runtime/readers/patterns/index.js

@@ -1,7 +0,0 @@
-/**
- * Stub: pattern detection is deferred (code parser infrastructure not yet absorbed).
- * Returns empty results for all categories.
- */
-export function detectPatterns(_content, _filePath) {
-    return { deps: [], apis: [], schemas: [], configs: [], docs: [] };
-}

package/dist/core-runtime/readers/review-log.js

@@ -1,213 +0,0 @@
-/**
- * review-log.ts — Review 실행 로그 수집 및 점진성(progressiveness) metric 산출
- *
- * W-A-71: DL-017 점진성 seat.
- * .onto/review/* 세션 디렉터리에서 execution-result.yaml + review-record.yaml 을 읽어
- * 세션별 타이밍 요약과 반복 review 간 비용·시간 변화를 계측한다.
- *
- * 소비자: W-A-75 (review-r+), W-A-76 (review-r−), onto:health (W-A-59)
- */
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { parse as yamlParse } from "yaml";
-import { getLogger } from "../logger.js";
-function normalizeRef(ref, projectRoot) {
-    if (ref.startsWith("/")) {
-        // 절대 경로 → 프로젝트 루트 기준 상대 경로로 변환
-        const rel = ref.replace(projectRoot + "/", "");
-        return rel.startsWith("/") ? ref : rel;
-    }
-    return ref;
-}
-function classifyProvenance(p) {
-    if (p === "runner_wallclock" ||
-        p === "coordinator_derived" ||
-        p === "batch_window") {
-        return p;
-    }
-    return "unknown";
-}
-function emptyProvenanceSummary() {
-    return { runner_wallclock: 0, coordinator_derived: 0, batch_window: 0, unknown: 0 };
-}
-function parseYamlFile(filePath) {
-    try {
-        const raw = readFileSync(filePath, "utf-8");
-        return yamlParse(raw);
-    }
-    catch {
-        getLogger().debug("review-log: failed to parse YAML", { path: filePath });
-        return null;
-    }
-}
-function isDirectory(path) {
-    try {
-        return statSync(path).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-// ─── Core API ───
-/**
- * .onto/review/ 이하 모든 세션의 실행 로그를 수집한다.
- *
- * @param reviewRoot - .onto/review 디렉터리 경로
- * @param projectRoot - 프로젝트 루트 (절대 경로 정규화용)
- * @returns ReviewLogSummary — 세션별 로그 + 점진성 metric
- */
-export function collectReviewLogs(reviewRoot, projectRoot) {
-    const absReviewRoot = resolve(reviewRoot);
-    const absProjectRoot = resolve(projectRoot);
-    let sessionDirs;
-    try {
-        sessionDirs = readdirSync(absReviewRoot).filter((name) => {
-            // session 디렉터리: YYYYMMDD-hexid 패턴
-            return /^\d{8}-[0-9a-f]+$/.test(name) && isDirectory(join(absReviewRoot, name));
-        });
-    }
-    catch {
-        getLogger().warn("review-log: review root not found", { path: absReviewRoot });
-        return {
-            collected_at: new Date().toISOString(),
-            review_root: absReviewRoot,
-            total_sessions: 0,
-            total_duration_ms: 0,
-            entries: [],
-            progressiveness: [],
-        };
-    }
-    const entries = [];
-    for (const dirName of sessionDirs) {
-        const sessionPath = join(absReviewRoot, dirName);
-        const entry = parseSession(sessionPath, absProjectRoot);
-        if (entry) {
-            entries.push(entry);
-        }
-    }
-    // 시간순 정렬 (오래된 것 먼저). undefined-safe comparator.
-    entries.sort((a, b) => (a.created_at ?? "").localeCompare(b.created_at ?? ""));
-    const totalDuration = entries.reduce((sum, e) => sum + e.total_duration_ms, 0);
-    const progressiveness = computeProgressiveness(entries);
-    return {
-        collected_at: new Date().toISOString(),
-        review_root: absReviewRoot,
-        total_sessions: entries.length,
-        total_duration_ms: totalDuration,
-        entries,
-        progressiveness,
-    };
-}
-/**
- * 단일 세션 디렉터리에서 ReviewLogEntry 를 추출한다.
- */
-function parseSession(sessionPath, projectRoot) {
-    const execResultPath = join(sessionPath, "execution-result.yaml");
-    const reviewRecordPath = join(sessionPath, "review-record.yaml");
-    const bindingPath = join(sessionPath, "binding.yaml");
-    const execResult = parseYamlFile(execResultPath);
-    if (!execResult) {
-        // execution-result.yaml 없으면 미완료 세션 — skip
-        return null;
-    }
-    const reviewRecord = parseYamlFile(reviewRecordPath);
-    const binding = parseYamlFile(bindingPath);
-    // target refs 수집: binding 우선, record는 보조 자료.
-    let targetRefs = [];
-    if (binding?.resolved_target_scope?.resolved_refs) {
-        targetRefs = binding.resolved_target_scope.resolved_refs.map((r) => normalizeRef(r, projectRoot));
-    }
-    // per-lens duration + provenance summary
-    const provSummary = emptyProvenanceSummary();
-    const perLensDuration = [];
-    for (const unit of execResult.lens_execution_results ?? []) {
-        const prov = classifyProvenance(unit.timestamp_provenance);
-        provSummary[prov]++;
-        perLensDuration.push({
-            lens_id: unit.unit_id,
-            duration_ms: unit.duration_ms,
-            provenance: prov,
-        });
-    }
-    // synthesis
-    let synthesisDuration = null;
-    if (execResult.synthesize_execution_result) {
-        synthesisDuration = execResult.synthesize_execution_result.duration_ms;
-        const synthProv = classifyProvenance(execResult.synthesize_execution_result.timestamp_provenance);
-        provSummary[synthProv]++;
-    }
-    return {
-        session_id: execResult.session_id,
-        created_at: reviewRecord?.created_at ?? execResult.execution_started_at,
-        review_target_refs: targetRefs,
-        request_text: reviewRecord?.request_text ?? "",
-        review_mode: requireReviewMode(execResult.review_mode),
-        execution_realization: execResult.execution_realization,
-        host_runtime: execResult.host_runtime,
-        execution_status: execResult.execution_status,
-        total_duration_ms: execResult.total_duration_ms,
-        lens_count: execResult.executed_lens_count,
-        participating_lens_ids: execResult.participating_lens_ids ?? [],
-        degraded_lens_ids: execResult.degraded_lens_ids ?? [],
-        per_lens_duration: perLensDuration,
-        synthesis_duration_ms: synthesisDuration,
-        provenance_summary: provSummary,
-    };
-}
-function requireReviewMode(value) {
-    if (value === "core-axis" || value === "full")
-        return value;
-    throw new Error(`review-log: unsupported review_mode in execution-result.yaml: ${value}`);
-}
-// ─── Progressiveness ───
-/**
- * 동일 대상을 반복 review 한 세션을 그룹화하고 점진성 metric 을 산출한다.
- *
- * 그룹화 기준: review_target_refs 를 정렬 후 join 한 문자열이 일치하면 동일 대상.
- * 세션이 2건 미만인 그룹은 점진성 측정 불가 → 제외.
- */
-export function computeProgressiveness(entries) {
-    const groups = new Map();
-    for (const entry of entries) {
-        if (entry.review_target_refs.length === 0)
-            continue;
-        const key = [...entry.review_target_refs].sort().join("\n");
-        const group = groups.get(key) ?? [];
-        group.push(entry);
-        groups.set(key, group);
-    }
-    const metrics = [];
-    for (const [key, group] of groups) {
-        if (group.length < 2)
-            continue;
-        // 시간순 정렬 (이미 정렬됐을 수 있으나 안전)
-        group.sort((a, b) => a.created_at.localeCompare(b.created_at));
-        const first = group[0];
-        const latest = group[group.length - 1];
-        const totalDuration = group.reduce((s, e) => s + e.total_duration_ms, 0);
-        const avgDuration = Math.round(totalDuration / group.length);
-        const deltaDuration = latest.total_duration_ms - first.total_duration_ms;
-        const deltaRatio = first.total_duration_ms > 0
-            ? deltaDuration / first.total_duration_ms
-            : 0;
-        metrics.push({
-            target_group_key: key,
-            target_refs: first.review_target_refs,
-            sessions: group.map((e) => ({
-                session_id: e.session_id,
-                created_at: e.created_at,
-                total_duration_ms: e.total_duration_ms,
-                execution_status: e.execution_status,
-            })),
-            session_count: group.length,
-            first_duration_ms: first.total_duration_ms,
-            latest_duration_ms: latest.total_duration_ms,
-            duration_delta_ms: deltaDuration,
-            duration_delta_ratio: Math.round(deltaRatio * 1000) / 1000,
-            avg_duration_ms: avgDuration,
-        });
-    }
-    // 세션 수 내림차순
-    metrics.sort((a, b) => b.session_count - a.session_count);
-    return metrics;
-}